315 files changed, 10899 insertions, 2237 deletions

diff --git a/include/linux/acpi.h b/include/linux/acpi.h
index e54f40974eb0..de8d3d3fa651 100644
--- a/include/linux/acpi.h
+++ b/include/linux/acpi.h
@@ -1058,27 +1058,20 @@ static inline int acpi_dev_gpio_irq_get(struct acpi_device *adev, int index)
 
 /* Device properties */
 
-#define MAX_ACPI_REFERENCE_ARGS 8
-struct acpi_reference_args {
-        struct acpi_device *adev;
-        size_t nargs;
-        u64 args[MAX_ACPI_REFERENCE_ARGS];
-};
-
 #ifdef CONFIG_ACPI
 int acpi_dev_get_property(const struct acpi_device *adev, const char *name,
                           acpi_object_type type, const union acpi_object **obj);
 int __acpi_node_get_property_reference(const struct fwnode_handle *fwnode,
                                 const char *name, size_t index, size_t num_args,
-                                struct acpi_reference_args *args);
+                                struct fwnode_reference_args *args);
 
 static inline int acpi_node_get_property_reference(
                                 const struct fwnode_handle *fwnode,
                                 const char *name, size_t index,
-                                struct acpi_reference_args *args)
+                                struct fwnode_reference_args *args)
 {
         return __acpi_node_get_property_reference(fwnode, name, index,
-                MAX_ACPI_REFERENCE_ARGS, args);
+                NR_FWNODE_REFERENCE_ARGS, args);
 }
 
 int acpi_node_prop_get(const struct fwnode_handle *fwnode, const char *propname,
@@ -1096,14 +1089,6 @@ struct fwnode_handle *acpi_get_next_subnode(const struct fwnode_handle *fwnode,
                                             struct fwnode_handle *child);
 struct fwnode_handle *acpi_node_get_parent(const struct fwnode_handle *fwnode);
 
-struct fwnode_handle *
-acpi_graph_get_next_endpoint(const struct fwnode_handle *fwnode,
-                             struct fwnode_handle *prev);
-int acpi_graph_get_remote_endpoint(const struct fwnode_handle *fwnode,
-                                   struct fwnode_handle **remote,
-                                   struct fwnode_handle **port,
-                                   struct fwnode_handle **endpoint);
-
 struct acpi_probe_entry;
 typedef bool (*acpi_probe_entry_validate_subtbl)(struct acpi_subtable_header *,
                                                  struct acpi_probe_entry *);
@@ -1169,7 +1154,7 @@ static inline int acpi_dev_get_property(struct acpi_device *adev,
 static inline int
 __acpi_node_get_property_reference(const struct fwnode_handle *fwnode,
                                 const char *name, size_t index, size_t num_args,
-                                struct acpi_reference_args *args)
+                                struct fwnode_reference_args *args)
 {
         return -ENXIO;
 }
@@ -1177,7 +1162,7 @@ __acpi_node_get_property_reference(const struct fwnode_handle *fwnode,
 static inline int
 acpi_node_get_property_reference(const struct fwnode_handle *fwnode,
                                  const char *name, size_t index,
-                                 struct acpi_reference_args *args)
+                                 struct fwnode_reference_args *args)
 {
         return -ENXIO;
 }
diff --git a/include/linux/ahci_platform.h b/include/linux/ahci_platform.h
index 1b0a17b22cd3..eaedca5fe6fc 100644
--- a/include/linux/ahci_platform.h
+++ b/include/linux/ahci_platform.h
@@ -30,7 +30,7 @@ void ahci_platform_disable_regulators(struct ahci_host_priv *hpriv);
 int ahci_platform_enable_resources(struct ahci_host_priv *hpriv);
 void ahci_platform_disable_resources(struct ahci_host_priv *hpriv);
 struct ahci_host_priv *ahci_platform_get_resources(
-        struct platform_device *pdev);
+        struct platform_device *pdev, unsigned int flags);
 int ahci_platform_init_host(struct platform_device *pdev,
                             struct ahci_host_priv *hpriv,
                             const struct ata_port_info *pi_template,
@@ -43,4 +43,6 @@ int ahci_platform_resume_host(struct device *dev);
 int ahci_platform_suspend(struct device *dev);
 int ahci_platform_resume(struct device *dev);
 
+#define AHCI_PLATFORM_GET_RESETS        0x01
+
 #endif /* _AHCI_PLATFORM_H */
diff --git a/include/linux/arm-smccc.h b/include/linux/arm-smccc.h
index ca1d2cc2cdfa..18863d56273c 100644
--- a/include/linux/arm-smccc.h
+++ b/include/linux/arm-smccc.h
@@ -199,47 +199,57 @@ asmlinkage void __arm_smccc_hvc(unsigned long a0, unsigned long a1,
 
 #define __declare_arg_0(a0, res)                                        \
         struct arm_smccc_res   *___res = res;                           \
-        register u32           r0 asm("r0") = a0;                       \
+        register unsigned long r0 asm("r0") = (u32)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)                                    \
+        typeof(a1) __a1 = a1;                                           \
         struct arm_smccc_res   *___res = res;                           \
-        register u32           r0 asm("r0") = a0;                       \
-        register typeof(a1)    r1 asm("r1") = a1;                       \
+        register unsigned long r0 asm("r0") = (u32)a0;                  \
+        register unsigned long r1 asm("r1") = __a1;                     \
         register unsigned long r2 asm("r2");                            \
         register unsigned long r3 asm("r3")
 
 #define __declare_arg_2(a0, a1, a2, res)                                \
+        typeof(a1) __a1 = a1;                                           \
+        typeof(a2) __a2 = a2;                                           \
         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 r0 asm("r0") = (u32)a0;                  \
+        register unsigned long r1 asm("r1") = __a1;                     \
+        register unsigned long r2 asm("r2") = __a2;                     \
         register unsigned long r3 asm("r3")
 
 #define __declare_arg_3(a0, a1, a2, a3, res)                            \
+        typeof(a1) __a1 = a1;                                           \
+        typeof(a2) __a2 = a2;                                           \
+        typeof(a3) __a3 = a3;                                           \
         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
+        register unsigned long r0 asm("r0") = (u32)a0;                  \
+        register unsigned long r1 asm("r1") = __a1;                     \
+        register unsigned long r2 asm("r2") = __a2;                     \
+        register unsigned long r3 asm("r3") = __a3
 
 #define __declare_arg_4(a0, a1, a2, a3, a4, res)                        \
+        typeof(a4) __a4 = a4;                                           \
         __declare_arg_3(a0, a1, a2, a3, res);                           \
-        register typeof(a4) r4 asm("r4") = a4
+        register unsigned long r4 asm("r4") = __a4
 
 #define __declare_arg_5(a0, a1, a2, a3, a4, a5, res)                    \
+        typeof(a5) __a5 = a5;                                           \
         __declare_arg_4(a0, a1, a2, a3, a4, res);                       \
-        register typeof(a5) r5 asm("r5") = a5
+        register unsigned long r5 asm("r5") = __a5
 
 #define __declare_arg_6(a0, a1, a2, a3, a4, a5, a6, res)                \
+        typeof(a6) __a6 = a6;                                           \
         __declare_arg_5(a0, a1, a2, a3, a4, a5, res);                   \
-        register typeof(a6) r6 asm("r6") = a6
+        register unsigned long r6 asm("r6") = __a6
 
 #define __declare_arg_7(a0, a1, a2, a3, a4, a5, a6, a7, res)            \
+        typeof(a7) __a7 = a7;                                           \
         __declare_arg_6(a0, a1, a2, a3, a4, a5, a6, res);               \
-        register typeof(a7) r7 asm("r7") = a7
+        register unsigned long r7 asm("r7") = __a7
 
 #define ___declare_args(count, ...) __declare_arg_ ## count(__VA_ARGS__)
 #define __declare_args(count, ...)  ___declare_args(count, __VA_ARGS__)
diff --git a/include/linux/ascii85.h b/include/linux/ascii85.h
new file mode 100644
index 000000000000..4cc40201273e
--- /dev/null
+++ b/include/linux/ascii85.h
@@ -0,0 +1,38 @@
+/*
+ * SPDX-License-Identifier: GPL-2.0
+ *
+ * Copyright (c) 2008 Intel Corporation
+ * Copyright (c) 2018 The Linux Foundation. All rights reserved.
+ */
+
+#ifndef _ASCII85_H_
+#define _ASCII85_H_
+
+#include <linux/kernel.h>
+
+#define ASCII85_BUFSZ 6
+
+static inline long
+ascii85_encode_len(long len)
+{
+        return DIV_ROUND_UP(len, 4);
+}
+
+static inline const char *
+ascii85_encode(u32 in, char *out)
+{
+        int i;
+
+        if (in == 0)
+                return "z";
+
+        out[5] = '\0';
+        for (i = 5; i--; ) {
+                out[i] = '!' + in % 85;
+                in /= 85;
+        }
+
+        return out;
+}
+
+#endif
diff --git a/include/linux/audit.h b/include/linux/audit.h
index 69c78477590b..9334fbef7bae 100644
--- a/include/linux/audit.h
+++ b/include/linux/audit.h
@@ -117,6 +117,9 @@ struct filename;
 
 extern void audit_log_session_info(struct audit_buffer *ab);
 
+#define AUDIT_OFF       0
+#define AUDIT_ON        1
+#define AUDIT_LOCKED    2
 #ifdef CONFIG_AUDIT
 /* These are defined in audit.c */
                                 /* Public API */
@@ -202,7 +205,7 @@ static inline int audit_log_task_context(struct audit_buffer *ab)
 static inline void audit_log_task_info(struct audit_buffer *ab,
                                        struct task_struct *tsk)
 { }
-#define audit_enabled 0
+#define audit_enabled AUDIT_OFF
 #endif /* CONFIG_AUDIT */
 
 #ifdef CONFIG_AUDIT_COMPAT_GENERIC
diff --git a/include/linux/backing-dev-defs.h b/include/linux/backing-dev-defs.h
index 24251762c20c..9a6bc0951cfa 100644
--- a/include/linux/backing-dev-defs.h
+++ b/include/linux/backing-dev-defs.h
@@ -12,6 +12,7 @@
 #include <linux/timer.h>
 #include <linux/workqueue.h>
 #include <linux/kref.h>
+#include <linux/refcount.h>
 
 struct page;
 struct device;
@@ -75,7 +76,7 @@ enum wb_reason {
  */
 struct bdi_writeback_congested {
         unsigned long state;            /* WB_[a]sync_congested flags */
-        atomic_t refcnt;                /* nr of attached wb's and blkg */
+        refcount_t refcnt;              /* nr of attached wb's and blkg */
 
 #ifdef CONFIG_CGROUP_WRITEBACK
         struct backing_dev_info *__bdi; /* the associated bdi, set to NULL
diff --git a/include/linux/backing-dev.h b/include/linux/backing-dev.h
index 72ca0f3d39f3..c28a47cbe355 100644
--- a/include/linux/backing-dev.h
+++ b/include/linux/backing-dev.h
@@ -404,13 +404,13 @@ static inline bool inode_cgwb_enabled(struct inode *inode)
 static inline struct bdi_writeback_congested *
 wb_congested_get_create(struct backing_dev_info *bdi, int blkcg_id, gfp_t gfp)
 {
-        atomic_inc(&bdi->wb_congested->refcnt);
+        refcount_inc(&bdi->wb_congested->refcnt);
         return bdi->wb_congested;
 }
 
 static inline void wb_congested_put(struct bdi_writeback_congested *congested)
 {
-        if (atomic_dec_and_test(&congested->refcnt))
+        if (refcount_dec_and_test(&congested->refcnt))
                 kfree(congested);
 }
 
diff --git a/include/linux/backlight.h b/include/linux/backlight.h
index 7fbf0539e14a..0b5897446dca 100644
--- a/include/linux/backlight.h
+++ b/include/linux/backlight.h
@@ -79,7 +79,6 @@ struct backlight_properties {
         /* Backlight type */
         enum backlight_type type;
         /* Flags used to signal drivers of state changes */
-        /* Upper 4 bits are reserved for driver internal use */
         unsigned int state;
 
 #define BL_CORE_SUSPENDED       (1 << 0)        /* backlight is suspended */
diff --git a/include/linux/bio.h b/include/linux/bio.h
index f08f5fe7bd08..51371740d2a8 100644
--- a/include/linux/bio.h
+++ b/include/linux/bio.h
@@ -429,7 +429,6 @@ extern void bio_put(struct bio *);
 
 extern void __bio_clone_fast(struct bio *, struct bio *);
 extern struct bio *bio_clone_fast(struct bio *, gfp_t, struct bio_set *);
-extern struct bio *bio_clone_bioset(struct bio *, gfp_t, struct bio_set *bs);
 
 extern struct bio_set fs_bio_set;
 
@@ -443,12 +442,6 @@ static inline struct bio *bio_kmalloc(gfp_t gfp_mask, unsigned int nr_iovecs)
         return bio_alloc_bioset(gfp_mask, nr_iovecs, NULL);
 }
 
-static inline struct bio *bio_clone_kmalloc(struct bio *bio, gfp_t gfp_mask)
-{
-        return bio_clone_bioset(bio, gfp_mask, NULL);
-
-}
-
 extern blk_qc_t submit_bio(struct bio *);
 
 extern void bio_endio(struct bio *);
@@ -496,9 +489,9 @@ extern struct bio *bio_copy_kern(struct request_queue *, void *, unsigned int,
 extern void bio_set_pages_dirty(struct bio *bio);
 extern void bio_check_pages_dirty(struct bio *bio);
 
-void generic_start_io_acct(struct request_queue *q, int rw,
+void generic_start_io_acct(struct request_queue *q, int op,
                                 unsigned long sectors, struct hd_struct *part);
-void generic_end_io_acct(struct request_queue *q, int rw,
+void generic_end_io_acct(struct request_queue *q, int op,
                                 struct hd_struct *part,
                                 unsigned long start_time);
 
@@ -553,8 +546,16 @@ do {						\
 #define bio_dev(bio) \
         disk_devt((bio)->bi_disk)
 
+#if defined(CONFIG_MEMCG) && defined(CONFIG_BLK_CGROUP)
+int bio_associate_blkcg_from_page(struct bio *bio, struct page *page);
+#else
+static inline int bio_associate_blkcg_from_page(struct bio *bio,
+                                                struct page *page) {  return 0; }
+#endif
+
 #ifdef CONFIG_BLK_CGROUP
 int bio_associate_blkcg(struct bio *bio, struct cgroup_subsys_state *blkcg_css);
+int bio_associate_blkg(struct bio *bio, struct blkcg_gq *blkg);
 void bio_disassociate_task(struct bio *bio);
 void bio_clone_blkcg_association(struct bio *dst, struct bio *src);
 #else   /* CONFIG_BLK_CGROUP */
diff --git a/include/linux/bitfield.h b/include/linux/bitfield.h
index cf2588d81148..3f1ef4450a7c 100644
--- a/include/linux/bitfield.h
+++ b/include/linux/bitfield.h
@@ -53,7 +53,7 @@
         ({                                                              \
                 BUILD_BUG_ON_MSG(!__builtin_constant_p(_mask),          \
                                  _pfx "mask is not constant");          \
-                BUILD_BUG_ON_MSG(!(_mask), _pfx "mask is zero");        \
+                BUILD_BUG_ON_MSG((_mask) == 0, _pfx "mask is zero");    \
                 BUILD_BUG_ON_MSG(__builtin_constant_p(_val) ?           \
                                  ~((_mask) >> __bf_shf(_mask)) & (_val) : 0, \
                                  _pfx "value too large for the field"); \
@@ -104,7 +104,7 @@
                 (typeof(_mask))(((_reg) & (_mask)) >> __bf_shf(_mask)); \
         })
 
-extern void __compiletime_warning("value doesn't fit into mask")
+extern void __compiletime_error("value doesn't fit into mask")
 __field_overflow(void);
 extern void __compiletime_error("bad bitfield mask")
 __bad_mask(void);
@@ -121,8 +121,8 @@ static __always_inline u64 field_mask(u64 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();                         \
+        if (__builtin_constant_p(v) && (v & ~field_mask(field)))        \
+                __field_overflow();                                     \
         return to((v & field_mask(field)) * field_multiplier(field));   \
 }                                                                       \
 static __always_inline __##type type##_replace_bits(__##type old,       \
@@ -143,6 +143,7 @@ static __always_inline base type##_get_bits(__##type v, base field)	\
         ____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(u8,u8,,)
 __MAKE_OP(16)
 __MAKE_OP(32)
 __MAKE_OP(64)
diff --git a/include/linux/bitmap.h b/include/linux/bitmap.h
index 1ee46f492267..acf5e8df3504 100644
--- a/include/linux/bitmap.h
+++ b/include/linux/bitmap.h
@@ -105,6 +105,14 @@
  */
 
 /*
+ * Allocation and deallocation of bitmap.
+ * Provided in lib/bitmap.c to avoid circular dependency.
+ */
+extern unsigned long *bitmap_alloc(unsigned int nbits, gfp_t flags);
+extern unsigned long *bitmap_zalloc(unsigned int nbits, gfp_t flags);
+extern void bitmap_free(const unsigned long *bitmap);
+
+/*
  * lib/bitmap.c provides these functions:
  */
 
diff --git a/include/linux/bitops.h b/include/linux/bitops.h
index af419012d77d..7ddb1349394d 100644
--- a/include/linux/bitops.h
+++ b/include/linux/bitops.h
@@ -4,7 +4,8 @@
 #include <asm/types.h>
 #include <linux/bits.h>
 
-#define BITS_TO_LONGS(nr)       DIV_ROUND_UP(nr, BITS_PER_BYTE * sizeof(long))
+#define BITS_PER_TYPE(type) (sizeof(type) * BITS_PER_BYTE)
+#define BITS_TO_LONGS(nr)       DIV_ROUND_UP(nr, BITS_PER_TYPE(long))
 
 extern unsigned int __sw_hweight8(unsigned int w);
 extern unsigned int __sw_hweight16(unsigned int w);
diff --git a/include/linux/blk-cgroup.h b/include/linux/blk-cgroup.h
index 6c666fd7de3c..6d766a19f2bb 100644
--- a/include/linux/blk-cgroup.h
+++ b/include/linux/blk-cgroup.h
@@ -35,6 +35,7 @@ enum blkg_rwstat_type {
         BLKG_RWSTAT_WRITE,
         BLKG_RWSTAT_SYNC,
         BLKG_RWSTAT_ASYNC,
+        BLKG_RWSTAT_DISCARD,
 
         BLKG_RWSTAT_NR,
         BLKG_RWSTAT_TOTAL = BLKG_RWSTAT_NR,
@@ -55,6 +56,7 @@ struct blkcg {
         struct list_head                all_blkcgs_node;
 #ifdef CONFIG_CGROUP_WRITEBACK
         struct list_head                cgwb_list;
+        refcount_t                      cgwb_refcnt;
 #endif
 };
 
@@ -88,7 +90,6 @@ struct blkg_policy_data {
         /* the blkg and policy id this per-policy data belongs to */
         struct blkcg_gq                 *blkg;
         int                             plid;
-        bool                            offline;
 };
 
 /*
@@ -136,6 +137,12 @@ struct blkcg_gq {
         struct blkg_policy_data         *pd[BLKCG_MAX_POLS];
 
         struct rcu_head                 rcu_head;
+
+        atomic_t                        use_delay;
+        atomic64_t                      delay_nsec;
+        atomic64_t                      delay_start;
+        u64                             last_delay;
+        int                             last_use;
 };
 
 typedef struct blkcg_policy_data *(blkcg_pol_alloc_cpd_fn)(gfp_t gfp);
@@ -148,6 +155,8 @@ typedef void (blkcg_pol_online_pd_fn)(struct blkg_policy_data *pd);
 typedef void (blkcg_pol_offline_pd_fn)(struct blkg_policy_data *pd);
 typedef void (blkcg_pol_free_pd_fn)(struct blkg_policy_data *pd);
 typedef void (blkcg_pol_reset_pd_stats_fn)(struct blkg_policy_data *pd);
+typedef size_t (blkcg_pol_stat_pd_fn)(struct blkg_policy_data *pd, char *buf,
+                                      size_t size);
 
 struct blkcg_policy {
         int                             plid;
@@ -167,6 +176,7 @@ struct blkcg_policy {
         blkcg_pol_offline_pd_fn         *pd_offline_fn;
         blkcg_pol_free_pd_fn            *pd_free_fn;
         blkcg_pol_reset_pd_stats_fn     *pd_reset_stats_fn;
+        blkcg_pol_stat_pd_fn            *pd_stat_fn;
 };
 
 extern struct blkcg blkcg_root;
@@ -238,6 +248,42 @@ static inline struct blkcg *bio_blkcg(struct bio *bio)
         return css_to_blkcg(task_css(current, io_cgrp_id));
 }
 
+static inline bool blk_cgroup_congested(void)
+{
+        struct cgroup_subsys_state *css;
+        bool ret = false;
+
+        rcu_read_lock();
+        css = kthread_blkcg();
+        if (!css)
+                css = task_css(current, io_cgrp_id);
+        while (css) {
+                if (atomic_read(&css->cgroup->congestion_count)) {
+                        ret = true;
+                        break;
+                }
+                css = css->parent;
+        }
+        rcu_read_unlock();
+        return ret;
+}
+
+/**
+ * bio_issue_as_root_blkg - see if this bio needs to be issued as root blkg
+ * @return: true if this bio needs to be submitted with the root blkg context.
+ *
+ * In order to avoid priority inversions we sometimes need to issue a bio as if
+ * it were attached to the root blkg, and then backcharge to the actual owning
+ * blkg.  The idea is we do bio_blkcg() to look up the actual context for the
+ * bio and attach the appropriate blkg to the bio.  Then we call this helper and
+ * if it is true run with the root blkg for that queue and then do any
+ * backcharging to the originating cgroup once the io is complete.
+ */
+static inline bool bio_issue_as_root_blkg(struct bio *bio)
+{
+        return (bio->bi_opf & (REQ_META | REQ_SWAP)) != 0;
+}
+
 /**
  * blkcg_parent - get the parent of a blkcg
  * @blkcg: blkcg of interest
@@ -296,6 +342,17 @@ static inline struct blkcg_gq *blkg_lookup(struct blkcg *blkcg,
 }
 
 /**
+ * blk_queue_root_blkg - return blkg for the (blkcg_root, @q) pair
+ * @q: request_queue of interest
+ *
+ * Lookup blkg for @q at the root level. See also blkg_lookup().
+ */
+static inline struct blkcg_gq *blk_queue_root_blkg(struct request_queue *q)
+{
+        return q->root_blkg;
+}
+
+/**
  * blkg_to_pdata - get policy private data
  * @blkg: blkg of interest
  * @pol: policy of interest
@@ -330,6 +387,49 @@ static inline struct blkcg *cpd_to_blkcg(struct blkcg_policy_data *cpd)
         return cpd ? cpd->blkcg : NULL;
 }
 
+extern void blkcg_destroy_blkgs(struct blkcg *blkcg);
+
+#ifdef CONFIG_CGROUP_WRITEBACK
+
+/**
+ * blkcg_cgwb_get - get a reference for blkcg->cgwb_list
+ * @blkcg: blkcg of interest
+ *
+ * This is used to track the number of active wb's related to a blkcg.
+ */
+static inline void blkcg_cgwb_get(struct blkcg *blkcg)
+{
+        refcount_inc(&blkcg->cgwb_refcnt);
+}
+
+/**
+ * blkcg_cgwb_put - put a reference for @blkcg->cgwb_list
+ * @blkcg: blkcg of interest
+ *
+ * This is used to track the number of active wb's related to a blkcg.
+ * When this count goes to zero, all active wb has finished so the
+ * blkcg can continue destruction by calling blkcg_destroy_blkgs().
+ * This work may occur in cgwb_release_workfn() on the cgwb_release
+ * workqueue.
+ */
+static inline void blkcg_cgwb_put(struct blkcg *blkcg)
+{
+        if (refcount_dec_and_test(&blkcg->cgwb_refcnt))
+                blkcg_destroy_blkgs(blkcg);
+}
+
+#else
+
+static inline void blkcg_cgwb_get(struct blkcg *blkcg) { }
+
+static inline void blkcg_cgwb_put(struct blkcg *blkcg)
+{
+        /* wb isn't being accounted, so trigger destruction right away */
+        blkcg_destroy_blkgs(blkcg);
+}
+
+#endif
+
 /**
  * blkg_path - format cgroup path of blkg
  * @blkg: blkg of interest
@@ -355,6 +455,21 @@ static inline void blkg_get(struct blkcg_gq *blkg)
         atomic_inc(&blkg->refcnt);
 }
 
+/**
+ * blkg_try_get - try and get a blkg reference
+ * @blkg: blkg to get
+ *
+ * This is for use when doing an RCU lookup of the blkg.  We may be in the midst
+ * of freeing this blkg, so we can only use it if the refcnt is not zero.
+ */
+static inline struct blkcg_gq *blkg_try_get(struct blkcg_gq *blkg)
+{
+        if (atomic_inc_not_zero(&blkg->refcnt))
+                return blkg;
+        return NULL;
+}
+
+
 void __blkg_release_rcu(struct rcu_head *rcu);
 
 /**
@@ -589,7 +704,9 @@ static inline void blkg_rwstat_add(struct blkg_rwstat *rwstat,
 {
         struct percpu_counter *cnt;
 
-        if (op_is_write(op))
+        if (op_is_discard(op))
+                cnt = &rwstat->cpu_cnt[BLKG_RWSTAT_DISCARD];
+        else if (op_is_write(op))
                 cnt = &rwstat->cpu_cnt[BLKG_RWSTAT_WRITE];
         else
                 cnt = &rwstat->cpu_cnt[BLKG_RWSTAT_READ];
@@ -706,8 +823,14 @@ static inline bool blkcg_bio_issue_check(struct request_queue *q,
 
         if (!throtl) {
                 blkg = blkg ?: q->root_blkg;
-                blkg_rwstat_add(&blkg->stat_bytes, bio->bi_opf,
-                                bio->bi_iter.bi_size);
+                /*
+                 * If the bio is flagged with BIO_QUEUE_ENTERED it means this
+                 * is a split bio and we would have already accounted for the
+                 * size of the bio.
+                 */
+                if (!bio_flagged(bio, BIO_QUEUE_ENTERED))
+                        blkg_rwstat_add(&blkg->stat_bytes, bio->bi_opf,
+                                        bio->bi_iter.bi_size);
                 blkg_rwstat_add(&blkg->stat_ios, bio->bi_opf, 1);
         }
 
@@ -715,6 +838,59 @@ static inline bool blkcg_bio_issue_check(struct request_queue *q,
         return !throtl;
 }
 
+static inline void blkcg_use_delay(struct blkcg_gq *blkg)
+{
+        if (atomic_add_return(1, &blkg->use_delay) == 1)
+                atomic_inc(&blkg->blkcg->css.cgroup->congestion_count);
+}
+
+static inline int blkcg_unuse_delay(struct blkcg_gq *blkg)
+{
+        int old = atomic_read(&blkg->use_delay);
+
+        if (old == 0)
+                return 0;
+
+        /*
+         * We do this song and dance because we can race with somebody else
+         * adding or removing delay.  If we just did an atomic_dec we'd end up
+         * negative and we'd already be in trouble.  We need to subtract 1 and
+         * then check to see if we were the last delay so we can drop the
+         * congestion count on the cgroup.
+         */
+        while (old) {
+                int cur = atomic_cmpxchg(&blkg->use_delay, old, old - 1);
+                if (cur == old)
+                        break;
+                old = cur;
+        }
+
+        if (old == 0)
+                return 0;
+        if (old == 1)
+                atomic_dec(&blkg->blkcg->css.cgroup->congestion_count);
+        return 1;
+}
+
+static inline void blkcg_clear_delay(struct blkcg_gq *blkg)
+{
+        int old = atomic_read(&blkg->use_delay);
+        if (!old)
+                return;
+        /* We only want 1 person clearing the congestion count for this blkg. */
+        while (old) {
+                int cur = atomic_cmpxchg(&blkg->use_delay, old, 0);
+                if (cur == old) {
+                        atomic_dec(&blkg->blkcg->css.cgroup->congestion_count);
+                        break;
+                }
+                old = cur;
+        }
+}
+
+void blkcg_add_delay(struct blkcg_gq *blkg, u64 now, u64 delta);
+void blkcg_schedule_throttle(struct request_queue *q, bool use_memdelay);
+void blkcg_maybe_throttle_current(void);
 #else   /* CONFIG_BLK_CGROUP */
 
 struct blkcg {
@@ -734,9 +910,16 @@ struct blkcg_policy {
 
 #define blkcg_root_css  ((struct cgroup_subsys_state *)ERR_PTR(-EINVAL))
 
+static inline void blkcg_maybe_throttle_current(void) { }
+static inline bool blk_cgroup_congested(void) { return false; }
+
 #ifdef CONFIG_BLOCK
 
+static inline void blkcg_schedule_throttle(struct request_queue *q, bool use_memdelay) { }
+
 static inline struct blkcg_gq *blkg_lookup(struct blkcg *blkcg, void *key) { return NULL; }
+static inline struct blkcg_gq *blk_queue_root_blkg(struct request_queue *q)
+{ return NULL; }
 static inline int blkcg_init_queue(struct request_queue *q) { return 0; }
 static inline void blkcg_drain_queue(struct request_queue *q) { }
 static inline void blkcg_exit_queue(struct request_queue *q) { }
diff --git a/include/linux/blk-mq.h b/include/linux/blk-mq.h
index ca3f2c2edd85..1da59c16f637 100644
--- a/include/linux/blk-mq.h
+++ b/include/linux/blk-mq.h
@@ -35,10 +35,12 @@ struct blk_mq_hw_ctx {
         struct sbitmap          ctx_map;
 
         struct blk_mq_ctx       *dispatch_from;
+        unsigned int            dispatch_busy;
 
-        struct blk_mq_ctx       **ctxs;
         unsigned int            nr_ctx;
+        struct blk_mq_ctx       **ctxs;
 
+        spinlock_t              dispatch_wait_lock;
         wait_queue_entry_t      dispatch_wait;
         atomic_t                wait_index;
 
diff --git a/include/linux/blk_types.h b/include/linux/blk_types.h
index 3c4f390aea4b..f6dfb30737d8 100644
--- a/include/linux/blk_types.h
+++ b/include/linux/blk_types.h
@@ -179,11 +179,9 @@ struct bio {
          */
         struct io_context       *bi_ioc;
         struct cgroup_subsys_state *bi_css;
-#ifdef CONFIG_BLK_DEV_THROTTLING_LOW
-        void                    *bi_cg_private;
+        struct blkcg_gq         *bi_blkg;
         struct bio_issue        bi_issue;
 #endif
-#endif
         union {
 #if defined(CONFIG_BLK_DEV_INTEGRITY)
                 struct bio_integrity_payload *bi_integrity; /* data integrity */
@@ -329,7 +327,7 @@ enum req_flag_bits {
 
         /* for driver use */
         __REQ_DRV,
-
+        __REQ_SWAP,             /* swapping request. */
         __REQ_NR_BITS,          /* stops here */
 };
 
@@ -351,6 +349,7 @@ enum req_flag_bits {
 #define REQ_NOUNMAP             (1ULL << __REQ_NOUNMAP)
 
 #define REQ_DRV                 (1ULL << __REQ_DRV)
+#define REQ_SWAP                (1ULL << __REQ_SWAP)
 
 #define REQ_FAILFAST_MASK \
         (REQ_FAILFAST_DEV | REQ_FAILFAST_TRANSPORT | REQ_FAILFAST_DRIVER)
@@ -358,6 +357,14 @@ enum req_flag_bits {
 #define REQ_NOMERGE_FLAGS \
         (REQ_NOMERGE | REQ_PREFLUSH | REQ_FUA)
 
+enum stat_group {
+        STAT_READ,
+        STAT_WRITE,
+        STAT_DISCARD,
+
+        NR_STAT_GROUPS
+};
+
 #define bio_op(bio) \
         ((bio)->bi_opf & REQ_OP_MASK)
 #define req_op(req) \
@@ -395,6 +402,18 @@ static inline bool op_is_sync(unsigned int op)
                 (op & (REQ_SYNC | REQ_FUA | REQ_PREFLUSH));
 }
 
+static inline bool op_is_discard(unsigned int op)
+{
+        return (op & REQ_OP_MASK) == REQ_OP_DISCARD;
+}
+
+static inline int op_stat_group(unsigned int op)
+{
+        if (op_is_discard(op))
+                return STAT_DISCARD;
+        return op_is_write(op);
+}
+
 typedef unsigned int blk_qc_t;
 #define BLK_QC_T_NONE           -1U
 #define BLK_QC_T_SHIFT          16
diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index 79226ca8f80f..d6869e0e2b64 100644
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -27,8 +27,6 @@
 #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;
@@ -42,7 +40,7 @@ struct bsg_job;
 struct blkcg_gq;
 struct blk_flush_queue;
 struct pr_ops;
-struct rq_wb;
+struct rq_qos;
 struct blk_queue_stats;
 struct blk_stat_callback;
 
@@ -442,10 +440,8 @@ struct request_queue {
         int                     nr_rqs[2];      /* # allocated [a]sync rqs */
         int                     nr_rqs_elvpriv; /* # allocated rqs w/ elvpriv */
 
-        atomic_t                shared_hctx_restart;
-
         struct blk_queue_stats  *stats;
-        struct rq_wb            *rq_wb;
+        struct rq_qos           *rq_qos;
 
         /*
          * If blkcg is not used, @q->root_rl serves all requests.  If blkcg
@@ -592,6 +588,7 @@ struct request_queue {
 
         struct queue_limits     limits;
 
+#ifdef CONFIG_BLK_DEV_ZONED
         /*
          * Zoned block device information for request dispatch control.
          * nr_zones is the total number of zones of the device. This is always
@@ -612,6 +609,7 @@ struct request_queue {
         unsigned int            nr_zones;
         unsigned long           *seq_zones_bitmap;
         unsigned long           *seq_zones_wlock;
+#endif /* CONFIG_BLK_DEV_ZONED */
 
         /*
          * sg stuff
@@ -800,11 +798,7 @@ 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;
-}
-
+#ifdef CONFIG_BLK_DEV_ZONED
 static inline unsigned int blk_queue_zone_no(struct request_queue *q,
                                              sector_t sector)
 {
@@ -820,6 +814,7 @@ static inline bool blk_queue_zone_is_seq(struct request_queue *q,
                 return false;
         return test_bit(blk_queue_zone_no(q, sector), q->seq_zones_bitmap);
 }
+#endif /* CONFIG_BLK_DEV_ZONED */
 
 static inline bool rq_is_sync(struct request *rq)
 {
@@ -1070,6 +1065,7 @@ static inline unsigned int blk_rq_cur_sectors(const struct request *rq)
         return blk_rq_cur_bytes(rq) >> SECTOR_SHIFT;
 }
 
+#ifdef CONFIG_BLK_DEV_ZONED
 static inline unsigned int blk_rq_zone_no(struct request *rq)
 {
         return blk_queue_zone_no(rq->q, blk_rq_pos(rq));
@@ -1079,6 +1075,7 @@ static inline unsigned int blk_rq_zone_is_seq(struct request *rq)
 {
         return blk_queue_zone_is_seq(rq->q, blk_rq_pos(rq));
 }
+#endif /* CONFIG_BLK_DEV_ZONED */
 
 /*
  * Some commands like WRITE SAME have a payload or data transfer size which
@@ -1437,8 +1434,6 @@ enum blk_default_limits {
         BLK_SEG_BOUNDARY_MASK   = 0xFFFFFFFFUL,
 };
 
-#define blkdev_entry_to_request(entry) list_entry((entry), struct request, queuelist)
-
 static inline unsigned long queue_segment_boundary(struct request_queue *q)
 {
         return q->limits.seg_boundary_mask;
@@ -1639,15 +1634,6 @@ static inline unsigned int bdev_zone_sectors(struct block_device *bdev)
         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;
-}
-
 static inline int queue_dma_alignment(struct request_queue *q)
 {
         return q ? q->dma_alignment : 511;
@@ -1877,6 +1863,28 @@ static inline bool integrity_req_gap_front_merge(struct request *req,
                                 bip_next->bip_vec[0].bv_offset);
 }
 
+/**
+ * bio_integrity_intervals - Return number of integrity intervals for a bio
+ * @bi:         blk_integrity profile for device
+ * @sectors:    Size of the bio in 512-byte sectors
+ *
+ * Description: The block layer calculates everything in 512 byte
+ * sectors but integrity metadata is done in terms of the data integrity
+ * interval size of the storage device.  Convert the block layer sectors
+ * to the appropriate number of integrity intervals.
+ */
+static inline unsigned int bio_integrity_intervals(struct blk_integrity *bi,
+                                                   unsigned int sectors)
+{
+        return sectors >> (bi->interval_exp - 9);
+}
+
+static inline unsigned int bio_integrity_bytes(struct blk_integrity *bi,
+                                               unsigned int sectors)
+{
+        return bio_integrity_intervals(bi, sectors) * bi->tuple_size;
+}
+
 #else /* CONFIG_BLK_DEV_INTEGRITY */
 
 struct bio;
@@ -1950,12 +1958,24 @@ static inline bool integrity_req_gap_front_merge(struct request *req,
         return false;
 }
 
+static inline unsigned int bio_integrity_intervals(struct blk_integrity *bi,
+                                                   unsigned int sectors)
+{
+        return 0;
+}
+
+static inline unsigned int bio_integrity_bytes(struct blk_integrity *bi,
+                                               unsigned int sectors)
+{
+        return 0;
+}
+
 #endif /* CONFIG_BLK_DEV_INTEGRITY */
 
 struct block_device_operations {
         int (*open) (struct block_device *, fmode_t);
         void (*release) (struct gendisk *, fmode_t);
-        int (*rw_page)(struct block_device *, sector_t, struct page *, bool);
+        int (*rw_page)(struct block_device *, sector_t, struct page *, unsigned int);
         int (*ioctl) (struct block_device *, fmode_t, unsigned, unsigned long);
         int (*compat_ioctl) (struct block_device *, fmode_t, unsigned, unsigned long);
         unsigned int (*check_events) (struct gendisk *disk,
diff --git a/include/linux/bootmem.h b/include/linux/bootmem.h
index 7942a96b1a9d..42515195d7d8 100644
--- a/include/linux/bootmem.h
+++ b/include/linux/bootmem.h
@@ -27,9 +27,20 @@ extern unsigned long max_pfn;
 extern unsigned long long max_possible_pfn;
 
 #ifndef CONFIG_NO_BOOTMEM
-/*
- * node_bootmem_map is a map pointer - the bits represent all physical 
- * memory pages (including holes) on the node.
+/**
+ * struct bootmem_data - per-node information used by the bootmem allocator
+ * @node_min_pfn: the starting physical address of the node's memory
+ * @node_low_pfn: the end physical address of the directly addressable memory
+ * @node_bootmem_map: is a bitmap pointer - the bits represent all physical
+ *                    memory pages (including holes) on the node.
+ * @last_end_off: the offset within the page of the end of the last allocation;
+ *                if 0, the page used is full
+ * @hint_idx: the PFN of the page used with the last allocation;
+ *            together with using this with the @last_end_offset field,
+ *            a test can be made to see if allocations can be merged
+ *            with the page used for the last allocation rather than
+ *            using up a full new page.
+ * @list: list entry in the linked list ordered by the memory addresses
  */
 typedef struct bootmem_data {
         unsigned long node_min_pfn;
diff --git a/include/linux/bpf-cgroup.h b/include/linux/bpf-cgroup.h
index d50c2f0a655a..f91b0f8ff3a9 100644
--- a/include/linux/bpf-cgroup.h
+++ b/include/linux/bpf-cgroup.h
@@ -4,22 +4,46 @@
 
 #include <linux/errno.h>
 #include <linux/jump_label.h>
+#include <linux/percpu.h>
+#include <linux/rbtree.h>
 #include <uapi/linux/bpf.h>
 
 struct sock;
 struct sockaddr;
 struct cgroup;
 struct sk_buff;
+struct bpf_map;
+struct bpf_prog;
 struct bpf_sock_ops_kern;
+struct bpf_cgroup_storage;
 
 #ifdef CONFIG_CGROUP_BPF
 
 extern struct static_key_false cgroup_bpf_enabled_key;
 #define cgroup_bpf_enabled static_branch_unlikely(&cgroup_bpf_enabled_key)
 
+DECLARE_PER_CPU(void*, bpf_cgroup_storage);
+
+struct bpf_cgroup_storage_map;
+
+struct bpf_storage_buffer {
+        struct rcu_head rcu;
+        char data[0];
+};
+
+struct bpf_cgroup_storage {
+        struct bpf_storage_buffer *buf;
+        struct bpf_cgroup_storage_map *map;
+        struct bpf_cgroup_storage_key key;
+        struct list_head list;
+        struct rb_node node;
+        struct rcu_head rcu;
+};
+
 struct bpf_prog_list {
         struct list_head node;
         struct bpf_prog *prog;
+        struct bpf_cgroup_storage *storage;
 };
 
 struct bpf_prog_array;
@@ -77,6 +101,26 @@ int __cgroup_bpf_run_filter_sock_ops(struct sock *sk,
 int __cgroup_bpf_check_dev_permission(short dev_type, u32 major, u32 minor,
                                       short access, enum bpf_attach_type type);
 
+static inline void bpf_cgroup_storage_set(struct bpf_cgroup_storage *storage)
+{
+        struct bpf_storage_buffer *buf;
+
+        if (!storage)
+                return;
+
+        buf = READ_ONCE(storage->buf);
+        this_cpu_write(bpf_cgroup_storage, &buf->data[0]);
+}
+
+struct bpf_cgroup_storage *bpf_cgroup_storage_alloc(struct bpf_prog *prog);
+void bpf_cgroup_storage_free(struct bpf_cgroup_storage *storage);
+void bpf_cgroup_storage_link(struct bpf_cgroup_storage *storage,
+                             struct cgroup *cgroup,
+                             enum bpf_attach_type type);
+void bpf_cgroup_storage_unlink(struct bpf_cgroup_storage *storage);
+int bpf_cgroup_storage_assign(struct bpf_prog *prog, struct bpf_map *map);
+void bpf_cgroup_storage_release(struct bpf_prog *prog, struct bpf_map *map);
+
 /* Wrappers for __cgroup_bpf_run_filter_skb() guarded by cgroup_bpf_enabled. */
 #define BPF_CGROUP_RUN_PROG_INET_INGRESS(sk, skb)                             \
 ({                                                                            \
@@ -221,6 +265,16 @@ static inline int cgroup_bpf_prog_query(const union bpf_attr *attr,
         return -EINVAL;
 }
 
+static inline void bpf_cgroup_storage_set(struct bpf_cgroup_storage *storage) {}
+static inline int bpf_cgroup_storage_assign(struct bpf_prog *prog,
+                                            struct bpf_map *map) { return 0; }
+static inline void bpf_cgroup_storage_release(struct bpf_prog *prog,
+                                              struct bpf_map *map) {}
+static inline struct bpf_cgroup_storage *bpf_cgroup_storage_alloc(
+        struct bpf_prog *prog) { return 0; }
+static inline void bpf_cgroup_storage_free(
+        struct bpf_cgroup_storage *storage) {}
+
 #define cgroup_bpf_enabled (0)
 #define BPF_CGROUP_PRE_CONNECT_ENABLED(sk) (0)
 #define BPF_CGROUP_RUN_PROG_INET_INGRESS(sk,skb) ({ 0; })
diff --git a/include/linux/bpf.h b/include/linux/bpf.h
index 8827e797ff97..523481a3471b 100644
--- a/include/linux/bpf.h
+++ b/include/linux/bpf.h
@@ -23,7 +23,7 @@ struct bpf_prog;
 struct bpf_map;
 struct sock;
 struct seq_file;
-struct btf;
+struct btf_type;
 
 /* map is generic key/value storage optionally accesible by eBPF programs */
 struct bpf_map_ops {
@@ -48,8 +48,9 @@ struct bpf_map_ops {
         u32 (*map_fd_sys_lookup_elem)(void *ptr);
         void (*map_seq_show_elem)(struct bpf_map *map, void *key,
                                   struct seq_file *m);
-        int (*map_check_btf)(const struct bpf_map *map, const struct btf *btf,
-                             u32 key_type_id, u32 value_type_id);
+        int (*map_check_btf)(const struct bpf_map *map,
+                             const struct btf_type *key_type,
+                             const struct btf_type *value_type);
 };
 
 struct bpf_map {
@@ -85,6 +86,7 @@ struct bpf_map {
         char name[BPF_OBJ_NAME_LEN];
 };
 
+struct bpf_offload_dev;
 struct bpf_offloaded_map;
 
 struct bpf_map_dev_ops {
@@ -117,9 +119,13 @@ static inline bool bpf_map_offload_neutral(const struct bpf_map *map)
 
 static inline bool bpf_map_support_seq_show(const struct bpf_map *map)
 {
-        return map->ops->map_seq_show_elem && map->ops->map_check_btf;
+        return map->btf && map->ops->map_seq_show_elem;
 }
 
+int map_check_no_btf(const struct bpf_map *map,
+                     const struct btf_type *key_type,
+                     const struct btf_type *value_type);
+
 extern const struct bpf_map_ops bpf_map_offload_ops;
 
 /* function argument constraints */
@@ -154,6 +160,7 @@ enum bpf_arg_type {
 enum bpf_return_type {
         RET_INTEGER,                    /* function returns integer */
         RET_VOID,                       /* function doesn't return anything */
+        RET_PTR_TO_MAP_VALUE,           /* returns a pointer to map elem value */
         RET_PTR_TO_MAP_VALUE_OR_NULL,   /* returns a pointer to map elem value or NULL */
 };
 
@@ -281,6 +288,7 @@ struct bpf_prog_aux {
         struct bpf_prog *prog;
         struct user_struct *user;
         u64 load_time; /* ns since boottime */
+        struct bpf_map *cgroup_storage;
         char name[BPF_OBJ_NAME_LEN];
 #ifdef CONFIG_SECURITY
         void *security;
@@ -347,12 +355,17 @@ int bpf_prog_test_run_skb(struct bpf_prog *prog, const union bpf_attr *kattr,
  * The 'struct bpf_prog_array *' should only be replaced with xchg()
  * since other cpus are walking the array of pointers in parallel.
  */
+struct bpf_prog_array_item {
+        struct bpf_prog *prog;
+        struct bpf_cgroup_storage *cgroup_storage;
+};
+
 struct bpf_prog_array {
         struct rcu_head rcu;
-        struct bpf_prog *progs[0];
+        struct bpf_prog_array_item items[0];
 };
 
-struct bpf_prog_array __rcu *bpf_prog_array_alloc(u32 prog_cnt, gfp_t flags);
+struct bpf_prog_array *bpf_prog_array_alloc(u32 prog_cnt, gfp_t flags);
 void bpf_prog_array_free(struct bpf_prog_array __rcu *progs);
 int bpf_prog_array_length(struct bpf_prog_array __rcu *progs);
 int bpf_prog_array_copy_to_user(struct bpf_prog_array __rcu *progs,
@@ -370,7 +383,8 @@ int bpf_prog_array_copy(struct bpf_prog_array __rcu *old_array,
 
 #define __BPF_PROG_RUN_ARRAY(array, ctx, func, check_non_null)  \
         ({                                              \
-                struct bpf_prog **_prog, *__prog;       \
+                struct bpf_prog_array_item *_item;      \
+                struct bpf_prog *_prog;                 \
                 struct bpf_prog_array *_array;          \
                 u32 _ret = 1;                           \
                 preempt_disable();                      \
@@ -378,10 +392,11 @@ int bpf_prog_array_copy(struct bpf_prog_array __rcu *old_array,
                 _array = rcu_dereference(array);        \
                 if (unlikely(check_non_null && !_array))\
                         goto _out;                      \
-                _prog = _array->progs;                  \
-                while ((__prog = READ_ONCE(*_prog))) {  \
-                        _ret &= func(__prog, ctx);      \
-                        _prog++;                        \
+                _item = &_array->items[0];              \
+                while ((_prog = READ_ONCE(_item->prog))) {              \
+                        bpf_cgroup_storage_set(_item->cgroup_storage);  \
+                        _ret &= func(_prog, ctx);       \
+                        _item++;                        \
                 }                                       \
 _out:                                                   \
                 rcu_read_unlock();                      \
@@ -434,6 +449,8 @@ struct bpf_map * __must_check bpf_map_inc(struct bpf_map *map, bool uref);
 void bpf_map_put_with_uref(struct bpf_map *map);
 void bpf_map_put(struct bpf_map *map);
 int bpf_map_precharge_memlock(u32 pages);
+int bpf_map_charge_memlock(struct bpf_map *map, u32 pages);
+void bpf_map_uncharge_memlock(struct bpf_map *map, 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);
@@ -512,6 +529,7 @@ static inline int bpf_map_attr_numa_node(const union bpf_attr *attr)
 }
 
 struct bpf_prog *bpf_prog_get_type_path(const char *name, enum bpf_prog_type type);
+int array_map_alloc_check(union bpf_attr *attr);
 
 #else /* !CONFIG_BPF_SYSCALL */
 static inline struct bpf_prog *bpf_prog_get(u32 ufd)
@@ -648,7 +666,15 @@ 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);
+bool bpf_offload_prog_map_match(struct bpf_prog *prog, struct bpf_map *map);
+
+struct bpf_offload_dev *bpf_offload_dev_create(void);
+void bpf_offload_dev_destroy(struct bpf_offload_dev *offdev);
+int bpf_offload_dev_netdev_register(struct bpf_offload_dev *offdev,
+                                    struct net_device *netdev);
+void bpf_offload_dev_netdev_unregister(struct bpf_offload_dev *offdev,
+                                       struct net_device *netdev);
+bool bpf_offload_dev_match(struct bpf_prog *prog, struct net_device *netdev);
 
 #if defined(CONFIG_NET) && defined(CONFIG_BPF_SYSCALL)
 int bpf_prog_offload_init(struct bpf_prog *prog, union bpf_attr *attr);
@@ -749,6 +775,33 @@ static inline void __xsk_map_flush(struct bpf_map *map)
 }
 #endif
 
+#if defined(CONFIG_INET) && defined(CONFIG_BPF_SYSCALL)
+void bpf_sk_reuseport_detach(struct sock *sk);
+int bpf_fd_reuseport_array_lookup_elem(struct bpf_map *map, void *key,
+                                       void *value);
+int bpf_fd_reuseport_array_update_elem(struct bpf_map *map, void *key,
+                                       void *value, u64 map_flags);
+#else
+static inline void bpf_sk_reuseport_detach(struct sock *sk)
+{
+}
+
+#ifdef CONFIG_BPF_SYSCALL
+static inline int bpf_fd_reuseport_array_lookup_elem(struct bpf_map *map,
+                                                     void *key, void *value)
+{
+        return -EOPNOTSUPP;
+}
+
+static inline int bpf_fd_reuseport_array_update_elem(struct bpf_map *map,
+                                                     void *key, void *value,
+                                                     u64 map_flags)
+{
+        return -EOPNOTSUPP;
+}
+#endif /* CONFIG_BPF_SYSCALL */
+#endif /* defined(CONFIG_INET) && defined(CONFIG_BPF_SYSCALL) */
+
 /* verifier prototypes for helper functions called from eBPF programs */
 extern const struct bpf_func_proto bpf_map_lookup_elem_proto;
 extern const struct bpf_func_proto bpf_map_update_elem_proto;
@@ -768,6 +821,8 @@ extern const struct bpf_func_proto bpf_sock_map_update_proto;
 extern const struct bpf_func_proto bpf_sock_hash_update_proto;
 extern const struct bpf_func_proto bpf_get_current_cgroup_id_proto;
 
+extern const struct bpf_func_proto bpf_get_local_storage_proto;
+
 /* Shared helpers among cBPF and eBPF. */
 void bpf_user_rnd_init_once(void);
 u64 bpf_user_rnd_u32(u64 r1, u64 r2, u64 r3, u64 r4, u64 r5);
diff --git a/include/linux/bpf_types.h b/include/linux/bpf_types.h
index c5700c2d5549..cd26c090e7c0 100644
--- a/include/linux/bpf_types.h
+++ b/include/linux/bpf_types.h
@@ -29,6 +29,9 @@ BPF_PROG_TYPE(BPF_PROG_TYPE_CGROUP_DEVICE, cg_dev)
 #ifdef CONFIG_BPF_LIRC_MODE2
 BPF_PROG_TYPE(BPF_PROG_TYPE_LIRC_MODE2, lirc_mode2)
 #endif
+#ifdef CONFIG_INET
+BPF_PROG_TYPE(BPF_PROG_TYPE_SK_REUSEPORT, sk_reuseport)
+#endif
 
 BPF_MAP_TYPE(BPF_MAP_TYPE_ARRAY, array_map_ops)
 BPF_MAP_TYPE(BPF_MAP_TYPE_PERCPU_ARRAY, percpu_array_map_ops)
@@ -37,6 +40,9 @@ BPF_MAP_TYPE(BPF_MAP_TYPE_PERF_EVENT_ARRAY, perf_event_array_map_ops)
 #ifdef CONFIG_CGROUPS
 BPF_MAP_TYPE(BPF_MAP_TYPE_CGROUP_ARRAY, cgroup_array_map_ops)
 #endif
+#ifdef CONFIG_CGROUP_BPF
+BPF_MAP_TYPE(BPF_MAP_TYPE_CGROUP_STORAGE, cgroup_storage_map_ops)
+#endif
 BPF_MAP_TYPE(BPF_MAP_TYPE_HASH, htab_map_ops)
 BPF_MAP_TYPE(BPF_MAP_TYPE_PERCPU_HASH, htab_percpu_map_ops)
 BPF_MAP_TYPE(BPF_MAP_TYPE_LRU_HASH, htab_lru_map_ops)
@@ -57,4 +63,7 @@ BPF_MAP_TYPE(BPF_MAP_TYPE_CPUMAP, cpu_map_ops)
 #if defined(CONFIG_XDP_SOCKETS)
 BPF_MAP_TYPE(BPF_MAP_TYPE_XSKMAP, xsk_map_ops)
 #endif
+#ifdef CONFIG_INET
+BPF_MAP_TYPE(BPF_MAP_TYPE_REUSEPORT_SOCKARRAY, reuseport_array_ops)
+#endif
 #endif
diff --git a/include/linux/brcmphy.h b/include/linux/brcmphy.h
index daa9234a9baf..949e9af8d9d6 100644
--- a/include/linux/brcmphy.h
+++ b/include/linux/brcmphy.h
@@ -45,6 +45,7 @@
 #define PHY_ID_BCM7445                  0x600d8510
 
 #define PHY_ID_BCM_CYGNUS               0xae025200
+#define PHY_ID_BCM_OMEGA                0xae025100
 
 #define PHY_BCM_OUI_MASK                0xfffffc00
 #define PHY_BCM_OUI_1                   0x00206000
diff --git a/include/linux/build-salt.h b/include/linux/build-salt.h
new file mode 100644
index 000000000000..bb007bd05e7a
--- /dev/null
+++ b/include/linux/build-salt.h
@@ -0,0 +1,20 @@
+#ifndef __BUILD_SALT_H
+#define __BUILD_SALT_H
+
+#include <linux/elfnote.h>
+
+#define LINUX_ELFNOTE_BUILD_SALT       0x100
+
+#ifdef __ASSEMBLER__
+
+#define BUILD_SALT \
+       ELFNOTE(Linux, LINUX_ELFNOTE_BUILD_SALT, .asciz CONFIG_BUILD_SALT)
+
+#else
+
+#define BUILD_SALT \
+       ELFNOTE32("Linux", LINUX_ELFNOTE_BUILD_SALT, CONFIG_BUILD_SALT)
+
+#endif
+
+#endif /* __BUILD_SALT_H */
diff --git a/include/linux/can/dev.h b/include/linux/can/dev.h
index 055aaf5ed9af..a83e1f632eb7 100644
--- a/include/linux/can/dev.h
+++ b/include/linux/can/dev.h
@@ -143,7 +143,12 @@ u8 can_dlc2len(u8 can_dlc);
 /* map the sanitized data length to an appropriate data length code */
 u8 can_len2dlc(u8 len);
 
-struct net_device *alloc_candev(int sizeof_priv, unsigned int echo_skb_max);
+struct net_device *alloc_candev_mqs(int sizeof_priv, unsigned int echo_skb_max,
+                                    unsigned int txqs, unsigned int rxqs);
+#define alloc_candev(sizeof_priv, echo_skb_max) \
+        alloc_candev_mqs(sizeof_priv, echo_skb_max, 1, 1)
+#define alloc_candev_mq(sizeof_priv, echo_skb_max, count) \
+        alloc_candev_mqs(sizeof_priv, echo_skb_max, count, count)
 void free_candev(struct net_device *dev);
 
 /* a candev safe wrapper around netdev_priv */
diff --git a/include/linux/cdrom.h b/include/linux/cdrom.h
index e75dfd1f1dec..528271c60018 100644
--- a/include/linux/cdrom.h
+++ b/include/linux/cdrom.h
@@ -13,6 +13,7 @@
 
 #include <linux/fs.h>           /* not really needed, later.. */
 #include <linux/list.h>
+#include <scsi/scsi_common.h>
 #include <uapi/linux/cdrom.h>
 
 struct packet_command
@@ -21,7 +22,7 @@ struct packet_command
         unsigned char           *buffer;
         unsigned int            buflen;
         int                     stat;
-        struct request_sense    *sense;
+        struct scsi_sense_hdr   *sshdr;
         unsigned char           data_direction;
         int                     quiet;
         int                     timeout;
diff --git a/include/linux/ceph/auth.h b/include/linux/ceph/auth.h
index e931da8424a4..6728c2ee0205 100644
--- a/include/linux/ceph/auth.h
+++ b/include/linux/ceph/auth.h
@@ -64,6 +64,10 @@ struct ceph_auth_client_ops {
         /* ensure that an existing authorizer is up to date */
         int (*update_authorizer)(struct ceph_auth_client *ac, int peer_type,
                                  struct ceph_auth_handshake *auth);
+        int (*add_authorizer_challenge)(struct ceph_auth_client *ac,
+                                        struct ceph_authorizer *a,
+                                        void *challenge_buf,
+                                        int challenge_buf_len);
         int (*verify_authorizer_reply)(struct ceph_auth_client *ac,
                                        struct ceph_authorizer *a);
         void (*invalidate_authorizer)(struct ceph_auth_client *ac,
@@ -118,6 +122,10 @@ void ceph_auth_destroy_authorizer(struct ceph_authorizer *a);
 extern int ceph_auth_update_authorizer(struct ceph_auth_client *ac,
                                        int peer_type,
                                        struct ceph_auth_handshake *a);
+int ceph_auth_add_authorizer_challenge(struct ceph_auth_client *ac,
+                                       struct ceph_authorizer *a,
+                                       void *challenge_buf,
+                                       int challenge_buf_len);
 extern int ceph_auth_verify_authorizer_reply(struct ceph_auth_client *ac,
                                              struct ceph_authorizer *a);
 extern void ceph_auth_invalidate_authorizer(struct ceph_auth_client *ac,
diff --git a/include/linux/ceph/ceph_features.h b/include/linux/ceph/ceph_features.h
index 3901927cf6a0..6b92b3395fa9 100644
--- a/include/linux/ceph/ceph_features.h
+++ b/include/linux/ceph/ceph_features.h
@@ -165,9 +165,9 @@ DEFINE_CEPH_FEATURE(58, 1, FS_FILE_LAYOUT_V2) // overlap
 DEFINE_CEPH_FEATURE(59, 1, FS_BTIME)
 DEFINE_CEPH_FEATURE(59, 1, FS_CHANGE_ATTR) // overlap
 DEFINE_CEPH_FEATURE(59, 1, MSG_ADDR2) // overlap
-DEFINE_CEPH_FEATURE(60, 1, BLKIN_TRACING)  // *do not share this bit*
+DEFINE_CEPH_FEATURE(60, 1, OSD_RECOVERY_DELETES) // *do not share this bit*
+DEFINE_CEPH_FEATURE(61, 1, CEPHX_V2)             // *do not share this bit*
 
-DEFINE_CEPH_FEATURE(61, 1, RESERVED2)          // unused, but slow down!
 DEFINE_CEPH_FEATURE(62, 1, RESERVED)           // do not use; used as a sentinal
 DEFINE_CEPH_FEATURE_DEPRECATED(63, 1, RESERVED_BROKEN, LUMINOUS) // client-facing
 
@@ -210,7 +210,8 @@ DEFINE_CEPH_FEATURE_DEPRECATED(63, 1, RESERVED_BROKEN, LUMINOUS) // client-facin
          CEPH_FEATURE_SERVER_JEWEL |            \
          CEPH_FEATURE_MON_STATEFUL_SUB |        \
          CEPH_FEATURE_CRUSH_TUNABLES5 |         \
-         CEPH_FEATURE_NEW_OSDOPREPLY_ENCODING)
+         CEPH_FEATURE_NEW_OSDOPREPLY_ENCODING | \
+         CEPH_FEATURE_CEPHX_V2)
 
 #define CEPH_FEATURES_REQUIRED_DEFAULT   \
         (CEPH_FEATURE_NOSRCADDR |        \
diff --git a/include/linux/ceph/decode.h b/include/linux/ceph/decode.h
index d143ac8879c6..a6c2a48d42e0 100644
--- a/include/linux/ceph/decode.h
+++ b/include/linux/ceph/decode.h
@@ -194,16 +194,22 @@ ceph_decode_skip_n(p, end, sizeof(u8), bad)
         } while (0)
 
 /*
- * struct ceph_timespec <-> struct timespec
+ * struct ceph_timespec <-> struct timespec64
  */
-static inline void ceph_decode_timespec(struct timespec *ts,
-                                        const struct ceph_timespec *tv)
+static inline void ceph_decode_timespec64(struct timespec64 *ts,
+                                          const struct ceph_timespec *tv)
 {
-        ts->tv_sec = (__kernel_time_t)le32_to_cpu(tv->tv_sec);
+        /*
+         * This will still overflow in year 2106.  We could extend
+         * the protocol to steal two more bits from tv_nsec to
+         * add three more 136 year epochs after that the way ext4
+         * does if necessary.
+         */
+        ts->tv_sec = (time64_t)le32_to_cpu(tv->tv_sec);
         ts->tv_nsec = (long)le32_to_cpu(tv->tv_nsec);
 }
-static inline void ceph_encode_timespec(struct ceph_timespec *tv,
-                                        const struct timespec *ts)
+static inline void ceph_encode_timespec64(struct ceph_timespec *tv,
+                                          const struct timespec64 *ts)
 {
         tv->tv_sec = cpu_to_le32((u32)ts->tv_sec);
         tv->tv_nsec = cpu_to_le32((u32)ts->tv_nsec);
diff --git a/include/linux/ceph/messenger.h b/include/linux/ceph/messenger.h
index c7dfcb8a1fb2..fc2b4491ee0a 100644
--- a/include/linux/ceph/messenger.h
+++ b/include/linux/ceph/messenger.h
@@ -31,6 +31,9 @@ struct ceph_connection_operations {
         struct ceph_auth_handshake *(*get_authorizer) (
                                 struct ceph_connection *con,
                                int *proto, int force_new);
+        int (*add_authorizer_challenge)(struct ceph_connection *con,
+                                        void *challenge_buf,
+                                        int challenge_buf_len);
         int (*verify_authorizer_reply) (struct ceph_connection *con);
         int (*invalidate_authorizer)(struct ceph_connection *con);
 
@@ -286,9 +289,8 @@ struct ceph_connection {
                                  attempt for this connection, client */
         u32 peer_global_seq;  /* peer's global seq for this connection */
 
+        struct ceph_auth_handshake *auth;
         int auth_retry;       /* true if we need a newer authorizer */
-        void *auth_reply_buf;   /* where to put the authorizer reply */
-        int auth_reply_buf_len;
 
         struct mutex mutex;
 
@@ -330,7 +332,7 @@ struct ceph_connection {
         int in_base_pos;     /* bytes read */
         __le64 in_temp_ack;  /* for reading an ack */
 
-        struct timespec last_keepalive_ack; /* keepalive2 ack stamp */
+        struct timespec64 last_keepalive_ack; /* keepalive2 ack stamp */
 
         struct delayed_work work;           /* send|recv work */
         unsigned long       delay;          /* current delay interval */
diff --git a/include/linux/ceph/msgr.h b/include/linux/ceph/msgr.h
index 73ae2a926548..9e50aede46c8 100644
--- a/include/linux/ceph/msgr.h
+++ b/include/linux/ceph/msgr.h
@@ -91,7 +91,7 @@ struct ceph_entity_inst {
 #define CEPH_MSGR_TAG_SEQ           13 /* 64-bit int follows with seen seq number */
 #define CEPH_MSGR_TAG_KEEPALIVE2    14 /* keepalive2 byte + ceph_timespec */
 #define CEPH_MSGR_TAG_KEEPALIVE2_ACK 15 /* keepalive2 reply */
-
+#define CEPH_MSGR_TAG_CHALLENGE_AUTHORIZER 16  /* cephx v2 doing server challenge */
 
 /*
  * connection negotiation
diff --git a/include/linux/ceph/osd_client.h b/include/linux/ceph/osd_client.h
index 0d6ee04b4c41..02096da01845 100644
--- a/include/linux/ceph/osd_client.h
+++ b/include/linux/ceph/osd_client.h
@@ -199,7 +199,7 @@ struct ceph_osd_request {
         /* set by submitter */
         u64 r_snapid;                         /* for reads, CEPH_NOSNAP o/w */
         struct ceph_snap_context *r_snapc;    /* for writes */
-        struct timespec r_mtime;              /* ditto */
+        struct timespec64 r_mtime;            /* ditto */
         u64 r_data_offset;                    /* ditto */
         bool r_linger;                        /* don't resend on failure */
 
@@ -253,7 +253,7 @@ struct ceph_osd_linger_request {
         struct ceph_osd_request_target t;
         u32 map_dne_bound;
 
-        struct timespec mtime;
+        struct timespec64 mtime;
 
         struct kref kref;
         struct mutex lock;
@@ -508,7 +508,7 @@ extern int ceph_osdc_writepages(struct ceph_osd_client *osdc,
                                 struct ceph_snap_context *sc,
                                 u64 off, u64 len,
                                 u32 truncate_seq, u64 truncate_size,
-                                struct timespec *mtime,
+                                struct timespec64 *mtime,
                                 struct page **pages, int nr_pages);
 
 /* watch/notify */
@@ -528,12 +528,12 @@ int ceph_osdc_notify_ack(struct ceph_osd_client *osdc,
                          u64 notify_id,
                          u64 cookie,
                          void *payload,
-                         size_t payload_len);
+                         u32 payload_len);
 int ceph_osdc_notify(struct ceph_osd_client *osdc,
                      struct ceph_object_id *oid,
                      struct ceph_object_locator *oloc,
                      void *payload,
-                     size_t payload_len,
+                     u32 payload_len,
                      u32 timeout,
                      struct page ***preply_pages,
                      size_t *preply_len);
diff --git a/include/linux/ceph/pagelist.h b/include/linux/ceph/pagelist.h
index 7edcded07641..d0223364349f 100644
--- a/include/linux/ceph/pagelist.h
+++ b/include/linux/ceph/pagelist.h
@@ -68,7 +68,7 @@ static inline int ceph_pagelist_encode_8(struct ceph_pagelist *pl, u8 v)
         return ceph_pagelist_append(pl, &v, 1);
 }
 static inline int ceph_pagelist_encode_string(struct ceph_pagelist *pl,
-                                              char *s, size_t len)
+                                              char *s, u32 len)
 {
         int ret = ceph_pagelist_encode_32(pl, len);
         if (ret)
diff --git a/include/linux/cgroup-defs.h b/include/linux/cgroup-defs.h
index c0e68f903011..ff20b677fb9f 100644
--- a/include/linux/cgroup-defs.h
+++ b/include/linux/cgroup-defs.h
@@ -438,6 +438,9 @@ struct cgroup {
         /* used to store eBPF programs */
         struct cgroup_bpf bpf;
 
+        /* If there is block congestion on this cgroup. */
+        atomic_t congestion_count;
+
         /* ids of the ancestors at each level including self */
         int ancestor_ids[];
 };
diff --git a/include/linux/cgroup.h b/include/linux/cgroup.h
index c9fdf6f57913..32c553556bbd 100644
--- a/include/linux/cgroup.h
+++ b/include/linux/cgroup.h
@@ -554,6 +554,36 @@ static inline bool cgroup_is_descendant(struct cgroup *cgrp,
 }
 
 /**
+ * cgroup_ancestor - find ancestor of cgroup
+ * @cgrp: cgroup to find ancestor of
+ * @ancestor_level: level of ancestor to find starting from root
+ *
+ * Find ancestor of cgroup at specified level starting from root if it exists
+ * and return pointer to it. Return NULL if @cgrp doesn't have ancestor at
+ * @ancestor_level.
+ *
+ * This function is safe to call as long as @cgrp is accessible.
+ */
+static inline struct cgroup *cgroup_ancestor(struct cgroup *cgrp,
+                                             int ancestor_level)
+{
+        struct cgroup *ptr;
+
+        if (cgrp->level < ancestor_level)
+                return NULL;
+
+        for (ptr = cgrp;
+             ptr && ptr->level > ancestor_level;
+             ptr = cgroup_parent(ptr))
+                ;
+
+        if (ptr && ptr->level == ancestor_level)
+                return ptr;
+
+        return NULL;
+}
+
+/**
  * task_under_cgroup_hierarchy - test task's membership of cgroup ancestry
  * @task: the task to be tested
  * @ancestor: possible ancestor of @task's cgroup
diff --git a/include/linux/clk-provider.h b/include/linux/clk-provider.h
index b7cfa037e593..08b1aa70a38d 100644
--- a/include/linux/clk-provider.h
+++ b/include/linux/clk-provider.h
@@ -38,6 +38,8 @@
 #define CLK_IS_CRITICAL         BIT(11) /* do not gate, ever */
 /* parents need enable during gate/ungate, set rate and re-parent */
 #define CLK_OPS_PARENT_ENABLE   BIT(12)
+/* duty cycle call may be forwarded to the parent clock */
+#define CLK_DUTY_CYCLE_PARENT   BIT(13)
 
 struct clk;
 struct clk_hw;
@@ -67,6 +69,17 @@ struct clk_rate_request {
 };
 
 /**
+ * struct clk_duty - Struture encoding the duty cycle ratio of a clock
+ *
+ * @num:        Numerator of the duty cycle ratio
+ * @den:        Denominator of the duty cycle ratio
+ */
+struct clk_duty {
+        unsigned int num;
+        unsigned int den;
+};
+
+/**
  * struct clk_ops -  Callback operations for hardware clocks; these are to
  * be provided by the clock implementation, and will be called by drivers
  * through the clk_* api.
@@ -169,6 +182,15 @@ struct clk_rate_request {
  *              by the second argument. Valid values for degrees are
  *              0-359. Return 0 on success, otherwise -EERROR.
  *
+ * @get_duty_cycle: Queries the hardware to get the current duty cycle ratio
+ *              of a clock. Returned values denominator cannot be 0 and must be
+ *              superior or equal to the numerator.
+ *
+ * @set_duty_cycle: Apply the duty cycle ratio to this clock signal specified by
+ *              the numerator (2nd argurment) and denominator (3rd  argument).
+ *              Argument must be a valid ratio (denominator > 0
+ *              and >= numerator) Return 0 on success, otherwise -EERROR.
+ *
  * @init:       Perform platform-specific initialization magic.
  *              This is not not used by any of the basic clock types.
  *              Please consider other ways of solving initialization problems
@@ -218,6 +240,10 @@ struct clk_ops {
                                            unsigned long parent_accuracy);
         int             (*get_phase)(struct clk_hw *hw);
         int             (*set_phase)(struct clk_hw *hw, int degrees);
+        int             (*get_duty_cycle)(struct clk_hw *hw,
+                                          struct clk_duty *duty);
+        int             (*set_duty_cycle)(struct clk_hw *hw,
+                                          struct clk_duty *duty);
         void            (*init)(struct clk_hw *hw);
         void            (*debug_init)(struct clk_hw *hw, struct dentry *dentry);
 };
diff --git a/include/linux/clk.h b/include/linux/clk.h
index 0dbd0885b2c2..4f750c481b82 100644
--- a/include/linux/clk.h
+++ b/include/linux/clk.h
@@ -142,6 +142,27 @@ int clk_set_phase(struct clk *clk, int degrees);
 int clk_get_phase(struct clk *clk);
 
 /**
+ * clk_set_duty_cycle - adjust the duty cycle ratio of a clock signal
+ * @clk: clock signal source
+ * @num: numerator of the duty cycle ratio to be applied
+ * @den: denominator of the duty cycle ratio to be applied
+ *
+ * Adjust the duty cycle of a clock signal by the specified ratio. Returns 0 on
+ * success, -EERROR otherwise.
+ */
+int clk_set_duty_cycle(struct clk *clk, unsigned int num, unsigned int den);
+
+/**
+ * clk_get_duty_cycle - return the duty cycle ratio of a clock signal
+ * @clk: clock signal source
+ * @scale: scaling factor to be applied to represent the ratio as an integer
+ *
+ * Returns the duty cycle ratio multiplied by the scale provided, otherwise
+ * returns -EERROR.
+ */
+int clk_get_scaled_duty_cycle(struct clk *clk, unsigned int scale);
+
+/**
  * clk_is_match - check if two clk's point to the same hardware clock
  * @p: clk compared against q
  * @q: clk compared against p
@@ -183,6 +204,18 @@ static inline long clk_get_phase(struct clk *clk)
         return -ENOTSUPP;
 }
 
+static inline int clk_set_duty_cycle(struct clk *clk, unsigned int num,
+                                     unsigned int den)
+{
+        return -ENOTSUPP;
+}
+
+static inline unsigned int clk_get_scaled_duty_cycle(struct clk *clk,
+                                                     unsigned int scale)
+{
+        return 0;
+}
+
 static inline bool clk_is_match(const struct clk *p, const struct clk *q)
 {
         return p == q;
diff --git a/include/linux/clk/at91_pmc.h b/include/linux/clk/at91_pmc.h
index 6aca5ce8a99a..931ab05f771d 100644
--- a/include/linux/clk/at91_pmc.h
+++ b/include/linux/clk/at91_pmc.h
@@ -47,8 +47,10 @@
 #define AT91_CKGR_MOR           0x20                    /* Main Oscillator Register [not on SAM9RL] */
 #define         AT91_PMC_MOSCEN         (1    <<  0)            /* Main Oscillator Enable */
 #define         AT91_PMC_OSCBYPASS      (1    <<  1)            /* Oscillator Bypass */
+#define         AT91_PMC_WAITMODE       (1    <<  2)            /* Wait Mode Command */
 #define         AT91_PMC_MOSCRCEN       (1    <<  3)            /* Main On-Chip RC Oscillator Enable [some SAM9] */
 #define         AT91_PMC_OSCOUNT        (0xff <<  8)            /* Main Oscillator Start-up Time */
+#define         AT91_PMC_KEY_MASK       (0xff << 16)
 #define         AT91_PMC_KEY            (0x37 << 16)            /* MOR Writing Key */
 #define         AT91_PMC_MOSCSEL        (1    << 24)            /* Main Oscillator Selection [some SAM9] */
 #define         AT91_PMC_CFDEN          (1    << 25)            /* Clock Failure Detector Enable [some SAM9] */
@@ -155,6 +157,19 @@
 #define         AT91_PMC_GCKRDY         (1 << 24)               /* Generated Clocks */
 #define AT91_PMC_IMR            0x6c                    /* Interrupt Mask Register */
 
+#define AT91_PMC_FSMR           0x70            /* Fast Startup Mode Register */
+#define AT91_PMC_FSTT(n)        BIT(n)
+#define AT91_PMC_RTCAL          BIT(17)         /* RTC Alarm Enable */
+#define AT91_PMC_USBAL          BIT(18)         /* USB Resume Enable */
+#define AT91_PMC_SDMMC_CD       BIT(19)         /* SDMMC Card Detect Enable */
+#define AT91_PMC_LPM            BIT(20)         /* Low-power Mode */
+#define AT91_PMC_RXLP_MCE       BIT(24)         /* Backup UART Receive Enable */
+#define AT91_PMC_ACC_CE         BIT(25)         /* ACC Enable */
+
+#define AT91_PMC_FSPR           0x74            /* Fast Startup Polarity Reg */
+
+#define AT91_PMC_FS_INPUT_MASK  0x7ff
+
 #define AT91_PMC_PLLICPR        0x80                    /* PLL Charge Pump Current Register */
 
 #define AT91_PMC_PROT           0xe4                    /* Write Protect Mode Register [some SAM9] */
diff --git a/include/linux/cma.h b/include/linux/cma.h
index bf90f0bb42bd..190184b5ff32 100644
--- a/include/linux/cma.h
+++ b/include/linux/cma.h
@@ -33,7 +33,7 @@ extern int cma_init_reserved_mem(phys_addr_t base, phys_addr_t size,
                                         const char *name,
                                         struct cma **res_cma);
 extern struct page *cma_alloc(struct cma *cma, size_t count, unsigned int align,
-                              gfp_t gfp_mask);
+                              bool no_warn);
 extern bool cma_release(struct cma *cma, const struct page *pages, unsigned int count);
 
 extern int cma_for_each_area(int (*it)(struct cma *cma, void *data), void *data);
diff --git a/include/linux/compat.h b/include/linux/compat.h
index df45ee8413d6..1a3c4f37e908 100644
--- a/include/linux/compat.h
+++ b/include/linux/compat.h
@@ -1019,6 +1019,17 @@ static inline struct compat_timeval ns_to_compat_timeval(s64 nsec)
         return ctv;
 }
 
+/*
+ * Kernel code should not call compat syscalls (i.e., compat_sys_xyzyyz())
+ * directly.  Instead, use one of the functions which work equivalently, such
+ * as the kcompat_sys_xyzyyz() functions prototyped below.
+ */
+
+int kcompat_sys_statfs64(const char __user * pathname, compat_size_t sz,
+                     struct compat_statfs64 __user * buf);
+int kcompat_sys_fstatfs64(unsigned int fd, compat_size_t sz,
+                          struct compat_statfs64 __user * buf);
+
 #else /* !CONFIG_COMPAT */
 
 #define is_compat_task() (0)
diff --git a/include/linux/compiler-clang.h b/include/linux/compiler-clang.h
index 7087446c24c8..b1ce500fe8b3 100644
--- a/include/linux/compiler-clang.h
+++ b/include/linux/compiler-clang.h
@@ -6,11 +6,7 @@
 /* Some compiler specific definitions are overwritten here
  * for Clang compiler
  */
-
-#ifdef uninitialized_var
-#undef uninitialized_var
 #define uninitialized_var(x) x = *(&(x))
-#endif
 
 /* same as gcc, this was present in clang-2.6 so we can assume it works
  * with any version that can compile the kernel
@@ -25,14 +21,8 @@
 #define __SANITIZE_ADDRESS__
 #endif
 
-#undef __no_sanitize_address
 #define __no_sanitize_address __attribute__((no_sanitize("address")))
 
-/* Clang doesn't have a way to turn it off per-function, yet. */
-#ifdef __noretpoline
-#undef __noretpoline
-#endif
-
 /*
  * Not all versions of clang implement the the type-generic versions
  * of the builtin overflow checkers. Fortunately, clang implements
@@ -40,9 +30,17 @@
  * checks. Unfortunately, we don't know which version of gcc clang
  * pretends to be, so the macro may or may not be defined.
  */
-#undef COMPILER_HAS_GENERIC_BUILTIN_OVERFLOW
 #if __has_builtin(__builtin_mul_overflow) && \
     __has_builtin(__builtin_add_overflow) && \
     __has_builtin(__builtin_sub_overflow)
 #define COMPILER_HAS_GENERIC_BUILTIN_OVERFLOW 1
 #endif
+
+/* The following are for compatibility with GCC, from compiler-gcc.h,
+ * and may be redefined here because they should not be shared with other
+ * compilers, like ICC.
+ */
+#define barrier() __asm__ __volatile__("" : : : "memory")
+#define __must_be_array(a) BUILD_BUG_ON_ZERO(__same_type((a), &(a)[0]))
+#define __assume_aligned(a, ...)        \
+        __attribute__((__assume_aligned__(a, ## __VA_ARGS__)))
diff --git a/include/linux/compiler-gcc.h b/include/linux/compiler-gcc.h
index 573f5a7d42d4..763bbad1e258 100644
--- a/include/linux/compiler-gcc.h
+++ b/include/linux/compiler-gcc.h
@@ -10,6 +10,10 @@
                      + __GNUC_MINOR__ * 100     \
                      + __GNUC_PATCHLEVEL__)
 
+#if GCC_VERSION < 40600
+# error Sorry, your compiler is too old - please upgrade it.
+#endif
+
 /* Optimization barrier */
 
 /* The "volatile" is due to gcc bugs */
@@ -58,6 +62,12 @@
 #define OPTIMIZER_HIDE_VAR(var)                                         \
         __asm__ ("" : "=r" (var) : "0" (var))
 
+/*
+ * A trick to suppress uninitialized variable warning without generating any
+ * code
+ */
+#define uninitialized_var(x) x = x
+
 #ifdef __CHECKER__
 #define __must_be_array(a)      0
 #else
@@ -65,49 +75,6 @@
 #define __must_be_array(a)      BUILD_BUG_ON_ZERO(__same_type((a), &(a)[0]))
 #endif
 
-/*
- * Feature detection for gnu_inline (gnu89 extern inline semantics). Either
- * __GNUC_STDC_INLINE__ is defined (not using gnu89 extern inline semantics,
- * and we opt in to the gnu89 semantics), or __GNUC_STDC_INLINE__ is not
- * defined so the gnu89 semantics are the default.
- */
-#ifdef __GNUC_STDC_INLINE__
-# define __gnu_inline   __attribute__((gnu_inline))
-#else
-# define __gnu_inline
-#endif
-
-/*
- * Force always-inline if the user requests it so via the .config,
- * or if gcc is too old.
- * GCC does not warn about unused static inline functions for
- * -Wunused-function.  This turns out to avoid the need for complex #ifdef
- * directives.  Suppress the warning in clang as well by using "unused"
- * function attribute, which is redundant but not harmful for gcc.
- * Prefer gnu_inline, so that extern inline functions do not emit an
- * externally visible function. This makes extern inline behave as per gnu89
- * semantics rather than c99. This prevents multiple symbol definition errors
- * of extern inline functions at link time.
- * A lot of inline functions can cause havoc with function tracing.
- */
-#if !defined(CONFIG_ARCH_SUPPORTS_OPTIMIZED_INLINING) ||                \
-    !defined(CONFIG_OPTIMIZE_INLINING) || (__GNUC__ < 4)
-#define inline \
-        inline __attribute__((always_inline, unused)) notrace __gnu_inline
-#else
-#define inline inline           __attribute__((unused)) notrace __gnu_inline
-#endif
-
-#define __inline__ inline
-#define __inline inline
-#define __always_inline inline __attribute__((always_inline))
-#define  noinline       __attribute__((noinline))
-
-#define __deprecated    __attribute__((deprecated))
-#define __packed        __attribute__((packed))
-#define __weak          __attribute__((weak))
-#define __alias(symbol) __attribute__((alias(#symbol)))
-
 #ifdef RETPOLINE
 #define __noretpoline __attribute__((indirect_branch("keep")))
 #endif
@@ -126,105 +93,20 @@
  */
 #define __naked         __attribute__((naked)) noinline __noclone notrace
 
-#define __noreturn      __attribute__((noreturn))
-
-/*
- * From the GCC manual:
- *
- * Many functions have no effects except the return value and their
- * return value depends only on the parameters and/or global
- * variables.  Such a function can be subject to common subexpression
- * elimination and loop optimization just as an arithmetic operator
- * would be.
- * [...]
- */
-#define __pure                  __attribute__((pure))
-#define __aligned(x)            __attribute__((aligned(x)))
-#define __aligned_largest       __attribute__((aligned))
-#define __printf(a, b)          __attribute__((format(printf, a, b)))
-#define __scanf(a, b)           __attribute__((format(scanf, a, b)))
-#define __attribute_const__     __attribute__((__const__))
-#define __maybe_unused          __attribute__((unused))
-#define __always_unused         __attribute__((unused))
-#define __mode(x)               __attribute__((mode(x)))
-
-/* gcc version specific checks */
-
-#if GCC_VERSION < 30200
-# error Sorry, your compiler is too old - please upgrade it.
-#endif
-
-#if GCC_VERSION < 30300
-# define __used                 __attribute__((__unused__))
-#else
-# define __used                 __attribute__((__used__))
-#endif
-
-#ifdef CONFIG_GCOV_KERNEL
-# if GCC_VERSION < 30400
-#   error "GCOV profiling support for gcc versions below 3.4 not included"
-# endif /* __GNUC_MINOR__ */
-#endif /* CONFIG_GCOV_KERNEL */
-
-#if GCC_VERSION >= 30400
-#define __must_check            __attribute__((warn_unused_result))
-#define __malloc                __attribute__((__malloc__))
-#endif
-
-#if GCC_VERSION >= 40000
-
-/* GCC 4.1.[01] miscompiles __weak */
-#ifdef __KERNEL__
-# if GCC_VERSION >= 40100 &&  GCC_VERSION <= 40101
-#  error Your version of gcc miscompiles the __weak directive
-# endif
-#endif
-
-#define __used                  __attribute__((__used__))
-#define __compiler_offsetof(a, b)                                       \
-        __builtin_offsetof(a, b)
-
-#if GCC_VERSION >= 40100
-# define __compiletime_object_size(obj) __builtin_object_size(obj, 0)
-#endif
-
-#if GCC_VERSION >= 40300
-/* Mark functions as cold. gcc will assume any path leading to a call
- * to them will be unlikely.  This means a lot of manual unlikely()s
- * are unnecessary now for any paths leading to the usual suspects
- * like BUG(), printk(), panic() etc. [but let's keep them for now for
- * older compilers]
- *
- * Early snapshots of gcc 4.3 don't support this and we can't detect this
- * in the preprocessor, but we can live with this because they're unreleased.
- * Maketime probing would be overkill here.
- *
- * gcc also has a __attribute__((__hot__)) to move hot functions into
- * a special section, but I don't see any sense in this right now in
- * the kernel context
- */
-#define __cold                  __attribute__((__cold__))
-
 #define __UNIQUE_ID(prefix) __PASTE(__PASTE(__UNIQUE_ID_, prefix), __COUNTER__)
 
-#ifndef __CHECKER__
-# define __compiletime_warning(message) __attribute__((warning(message)))
-# define __compiletime_error(message) __attribute__((error(message)))
-#endif /* __CHECKER__ */
-#endif /* GCC_VERSION >= 40300 */
-
-#if GCC_VERSION >= 40400
 #define __optimize(level)       __attribute__((__optimize__(level)))
-#define __nostackprotector      __optimize("no-stack-protector")
-#endif /* GCC_VERSION >= 40400 */
 
-#if GCC_VERSION >= 40500
+#define __compiletime_object_size(obj) __builtin_object_size(obj, 0)
 
 #ifndef __CHECKER__
+#define __compiletime_warning(message) __attribute__((warning(message)))
+#define __compiletime_error(message) __attribute__((error(message)))
+
 #ifdef LATENT_ENTROPY_PLUGIN
 #define __latent_entropy __attribute__((latent_entropy))
 #endif
-#endif
+#endif /* __CHECKER__ */
 
 /*
  * calling noreturn functions, __builtin_unreachable() and __builtin_trap()
@@ -262,10 +144,6 @@
 #define randomized_struct_fields_end    } __randomize_layout;
 #endif
 
-#endif /* GCC_VERSION >= 40500 */
-
-#if GCC_VERSION >= 40600
-
 /*
  * When used with Link Time Optimization, gcc can optimize away C functions or
  * variables which are referenced only from assembly code.  __visible tells the
@@ -274,8 +152,7 @@
  */
 #define __visible       __attribute__((externally_visible))
 
-#endif /* GCC_VERSION >= 40600 */
-
+/* gcc version specific checks */
 
 #if GCC_VERSION >= 40900 && !defined(__CHECKER__)
 /*
@@ -309,10 +186,8 @@
  * folding in __builtin_bswap*() (yet), so don't set these for it.
  */
 #if defined(CONFIG_ARCH_USE_BUILTIN_BSWAP) && !defined(__CHECKER__)
-#if GCC_VERSION >= 40400
 #define __HAVE_BUILTIN_BSWAP32__
 #define __HAVE_BUILTIN_BSWAP64__
-#endif
 #if GCC_VERSION >= 40800
 #define __HAVE_BUILTIN_BSWAP16__
 #endif
@@ -341,10 +216,9 @@
  * https://gcc.gnu.org/onlinedocs/gcc/Designated-Inits.html
  */
 #define __designated_init __attribute__((designated_init))
+#define COMPILER_HAS_GENERIC_BUILTIN_OVERFLOW 1
 #endif
 
-#endif  /* gcc version >= 40000 specific checks */
-
 #if !defined(__noclone)
 #define __noclone       /* not needed */
 #endif
@@ -354,16 +228,6 @@
 #endif
 
 /*
- * A trick to suppress uninitialized variable warning without generating any
- * code
- */
-#define uninitialized_var(x) x = x
-
-#if GCC_VERSION >= 50100
-#define COMPILER_HAS_GENERIC_BUILTIN_OVERFLOW 1
-#endif
-
-/*
  * Turn individual warnings and errors on and off locally, depending
  * on version.
  */
@@ -375,12 +239,9 @@
 #define __diag_GCC_warn         warning
 #define __diag_GCC_error        error
 
-/* Compilers before gcc-4.6 do not understand "#pragma GCC diagnostic push" */
-#if GCC_VERSION >= 40600
 #define __diag_str1(s)          #s
 #define __diag_str(s)           __diag_str1(s)
 #define __diag(s)               _Pragma(__diag_str(GCC diagnostic s))
-#endif
 
 #if GCC_VERSION >= 80000
 #define __diag_GCC_8(s)         __diag(s)
diff --git a/include/linux/compiler-intel.h b/include/linux/compiler-intel.h
index 547cdc920a3c..4c7f9befa9f6 100644
--- a/include/linux/compiler-intel.h
+++ b/include/linux/compiler-intel.h
@@ -14,10 +14,6 @@
 /* Intel ECC compiler doesn't support gcc specific asm stmts.
  * It uses intrinsics to do the equivalent things.
  */
-#undef barrier
-#undef barrier_data
-#undef RELOC_HIDE
-#undef OPTIMIZER_HIDE_VAR
 
 #define barrier() __memory_barrier()
 #define barrier_data(ptr) barrier()
@@ -38,13 +34,12 @@
 
 #endif
 
-#ifndef __HAVE_BUILTIN_BSWAP16__
 /* icc has this, but it's called _bswap16 */
 #define __HAVE_BUILTIN_BSWAP16__
 #define __builtin_bswap16 _bswap16
-#endif
 
-/*
- * icc defines __GNUC__, but does not implement the builtin overflow checkers.
+/* The following are for compatibility with GCC, from compiler-gcc.h,
+ * and may be redefined here because they should not be shared with other
+ * compilers, like clang.
  */
-#undef COMPILER_HAS_GENERIC_BUILTIN_OVERFLOW
+#define __visible       __attribute__((externally_visible))
diff --git a/include/linux/compiler.h b/include/linux/compiler.h
index 42506e4d1f53..681d866efb1e 100644
--- a/include/linux/compiler.h
+++ b/include/linux/compiler.h
@@ -280,6 +280,25 @@ unsigned long read_word_at_a_time(const void *addr)
 
 #endif /* __KERNEL__ */
 
+/*
+ * Force the compiler to emit 'sym' as a symbol, so that we can reference
+ * it from inline assembler. Necessary in case 'sym' could be inlined
+ * otherwise, or eliminated entirely due to lack of references that are
+ * visible to the compiler.
+ */
+#define __ADDRESSABLE(sym) \
+        static void * __attribute__((section(".discard.addressable"), used)) \
+                __PASTE(__addressable_##sym, __LINE__) = (void *)&sym;
+
+/**
+ * offset_to_ptr - convert a relative memory offset to an absolute pointer
+ * @off:        the address of the 32-bit offset value
+ */
+static inline void *offset_to_ptr(const int *off)
+{
+        return (void *)((unsigned long)off + *off);
+}
+
 #endif /* __ASSEMBLY__ */
 
 #ifndef __optimize
@@ -313,7 +332,7 @@ unsigned long read_word_at_a_time(const void *addr)
 #ifdef __OPTIMIZE__
 # define __compiletime_assert(condition, msg, prefix, suffix)           \
         do {                                                            \
-                bool __cond = !(condition);                             \
+                int __cond = !(condition);                              \
                 extern void prefix ## suffix(void) __compiletime_error(msg); \
                 if (__cond)                                             \
                         prefix ## suffix();                             \
diff --git a/include/linux/compiler_types.h b/include/linux/compiler_types.h
index a8ba6b04152c..3525c179698c 100644
--- a/include/linux/compiler_types.h
+++ b/include/linux/compiler_types.h
@@ -54,32 +54,32 @@ extern void __chk_io_ptr(const volatile void __iomem *);
 
 #ifdef __KERNEL__
 
-#ifdef __GNUC__
+/* Compiler specific macros. */
+#ifdef __clang__
+#include <linux/compiler-clang.h>
+#elif defined(__INTEL_COMPILER)
+#include <linux/compiler-intel.h>
+#elif defined(__GNUC__)
+/* The above compilers also define __GNUC__, so order is important here. */
 #include <linux/compiler-gcc.h>
-#endif
-
-#if defined(CC_USING_HOTPATCH) && !defined(__CHECKER__)
-#define notrace __attribute__((hotpatch(0,0)))
 #else
-#define notrace __attribute__((no_instrument_function))
-#endif
-
-/* Intel compiler defines __GNUC__. So we will overwrite implementations
- * coming from above header files here
- */
-#ifdef __INTEL_COMPILER
-# include <linux/compiler-intel.h>
+#error "Unknown compiler"
 #endif
 
-/* Clang compiler defines __GNUC__. So we will overwrite implementations
- * coming from above header files here
+/*
+ * Some architectures need to provide custom definitions of macros provided
+ * by linux/compiler-*.h, and can do so using asm/compiler.h. We include that
+ * conditionally rather than using an asm-generic wrapper in order to avoid
+ * build failures if any C compilation, which will include this file via an
+ * -include argument in c_flags, occurs prior to the asm-generic wrappers being
+ * generated.
  */
-#ifdef __clang__
-#include <linux/compiler-clang.h>
+#ifdef CONFIG_HAVE_ARCH_COMPILER_H
+#include <asm/compiler.h>
 #endif
 
 /*
- * Generic compiler-dependent macros required for kernel
+ * Generic compiler-independent macros required for kernel
  * build go below this comment. Actual compiler/compiler version
  * specific implementations come from the above header files
  */
@@ -106,110 +106,19 @@ struct ftrace_likely_data {
         unsigned long                   constant;
 };
 
-#endif /* __KERNEL__ */
-
-#endif /* __ASSEMBLY__ */
-
-#ifdef __KERNEL__
-/*
- * Allow us to mark functions as 'deprecated' and have gcc emit a nice
- * warning for each use, in hopes of speeding the functions removal.
- * Usage is:
- *              int __deprecated foo(void)
- */
-#ifndef __deprecated
-# define __deprecated           /* unimplemented */
-#endif
-
-#ifdef MODULE
-#define __deprecated_for_modules __deprecated
-#else
-#define __deprecated_for_modules
-#endif
-
-#ifndef __must_check
-#define __must_check
-#endif
-
-#ifndef CONFIG_ENABLE_MUST_CHECK
-#undef __must_check
-#define __must_check
-#endif
-#ifndef CONFIG_ENABLE_WARN_DEPRECATED
-#undef __deprecated
-#undef __deprecated_for_modules
+/* Don't. Just don't. */
 #define __deprecated
 #define __deprecated_for_modules
-#endif
-
-#ifndef __malloc
-#define __malloc
-#endif
-
-/*
- * Allow us to avoid 'defined but not used' warnings on functions and data,
- * as well as force them to be emitted to the assembly file.
- *
- * As of gcc 3.4, static functions that are not marked with attribute((used))
- * may be elided from the assembly file.  As of gcc 3.4, static data not so
- * marked will not be elided, but this may change in a future gcc version.
- *
- * NOTE: Because distributions shipped with a backported unit-at-a-time
- * compiler in gcc 3.3, we must define __used to be __attribute__((used))
- * for gcc >=3.3 instead of 3.4.
- *
- * In prior versions of gcc, such functions and data would be emitted, but
- * would be warned about except with attribute((unused)).
- *
- * Mark functions that are referenced only in inline assembly as __used so
- * the code is emitted even though it appears to be unreferenced.
- */
-#ifndef __used
-# define __used                 /* unimplemented */
-#endif
-
-#ifndef __maybe_unused
-# define __maybe_unused         /* unimplemented */
-#endif
-
-#ifndef __always_unused
-# define __always_unused        /* unimplemented */
-#endif
-
-#ifndef noinline
-#define noinline
-#endif
-
-/*
- * Rather then using noinline to prevent stack consumption, use
- * noinline_for_stack instead.  For documentation reasons.
- */
-#define noinline_for_stack noinline
-
-#ifndef __always_inline
-#define __always_inline inline
-#endif
 
 #endif /* __KERNEL__ */
 
+#endif /* __ASSEMBLY__ */
+
 /*
- * From the GCC manual:
- *
- * Many functions do not examine any values except their arguments,
- * and have no effects except the return value.  Basically this is
- * just slightly more strict class than the `pure' attribute above,
- * since function is not allowed to read global memory.
- *
- * Note that a function that has pointer arguments and examines the
- * data pointed to must _not_ be declared `const'.  Likewise, a
- * function that calls a non-`const' function usually must not be
- * `const'.  It does not make sense for a `const' function to return
- * `void'.
+ * The below symbols may be defined for one or more, but not ALL, of the above
+ * compilers. We don't consider that to be an error, so set them to nothing.
+ * For example, some of them are for compiler specific plugins.
  */
-#ifndef __attribute_const__
-# define __attribute_const__    /* unimplemented */
-#endif
-
 #ifndef __designated_init
 # define __designated_init
 #endif
@@ -231,28 +140,10 @@ struct ftrace_likely_data {
 # define randomized_struct_fields_end
 #endif
 
-/*
- * Tell gcc if a function is cold. The compiler will assume any path
- * directly leading to the call is unlikely.
- */
-
-#ifndef __cold
-#define __cold
-#endif
-
-/* Simple shorthand for a section definition */
-#ifndef __section
-# define __section(S) __attribute__ ((__section__(#S)))
-#endif
-
 #ifndef __visible
 #define __visible
 #endif
 
-#ifndef __nostackprotector
-# define __nostackprotector
-#endif
-
 /*
  * Assume alignment of return value.
  */
@@ -260,17 +151,23 @@ struct ftrace_likely_data {
 #define __assume_aligned(a, ...)
 #endif
 
-
 /* Are two types/vars the same type (ignoring qualifiers)? */
-#ifndef __same_type
-# define __same_type(a, b) __builtin_types_compatible_p(typeof(a), typeof(b))
-#endif
+#define __same_type(a, b) __builtin_types_compatible_p(typeof(a), typeof(b))
 
 /* Is this type a native word size -- useful for atomic operations */
-#ifndef __native_word
-# define __native_word(t) (sizeof(t) == sizeof(char) || sizeof(t) == sizeof(short) || sizeof(t) == sizeof(int) || sizeof(t) == sizeof(long))
+#define __native_word(t) \
+        (sizeof(t) == sizeof(char) || sizeof(t) == sizeof(short) || \
+         sizeof(t) == sizeof(int) || sizeof(t) == sizeof(long))
+
+#ifndef __attribute_const__
+#define __attribute_const__     __attribute__((__const__))
+#endif
+
+#ifndef __noclone
+#define __noclone
 #endif
 
+/* Helpers for emitting diagnostics in pragmas. */
 #ifndef __diag
 #define __diag(string)
 #endif
@@ -289,4 +186,92 @@ struct ftrace_likely_data {
 #define __diag_error(compiler, version, option, comment) \
         __diag_ ## compiler(version, error, option)
 
+/*
+ * From the GCC manual:
+ *
+ * Many functions have no effects except the return value and their
+ * return value depends only on the parameters and/or global
+ * variables.  Such a function can be subject to common subexpression
+ * elimination and loop optimization just as an arithmetic operator
+ * would be.
+ * [...]
+ */
+#define __pure                  __attribute__((pure))
+#define __aligned(x)            __attribute__((aligned(x)))
+#define __aligned_largest       __attribute__((aligned))
+#define __printf(a, b)          __attribute__((format(printf, a, b)))
+#define __scanf(a, b)           __attribute__((format(scanf, a, b)))
+#define __maybe_unused          __attribute__((unused))
+#define __always_unused         __attribute__((unused))
+#define __mode(x)               __attribute__((mode(x)))
+#define __malloc                __attribute__((__malloc__))
+#define __used                  __attribute__((__used__))
+#define __noreturn              __attribute__((noreturn))
+#define __packed                __attribute__((packed))
+#define __weak                  __attribute__((weak))
+#define __alias(symbol)         __attribute__((alias(#symbol)))
+#define __cold                  __attribute__((cold))
+#define __section(S)            __attribute__((__section__(#S)))
+
+
+#ifdef CONFIG_ENABLE_MUST_CHECK
+#define __must_check            __attribute__((warn_unused_result))
+#else
+#define __must_check
+#endif
+
+#if defined(CC_USING_HOTPATCH) && !defined(__CHECKER__)
+#define notrace                 __attribute__((hotpatch(0, 0)))
+#else
+#define notrace                 __attribute__((no_instrument_function))
+#endif
+
+#define __compiler_offsetof(a, b)       __builtin_offsetof(a, b)
+
+/*
+ * Feature detection for gnu_inline (gnu89 extern inline semantics). Either
+ * __GNUC_STDC_INLINE__ is defined (not using gnu89 extern inline semantics,
+ * and we opt in to the gnu89 semantics), or __GNUC_STDC_INLINE__ is not
+ * defined so the gnu89 semantics are the default.
+ */
+#ifdef __GNUC_STDC_INLINE__
+# define __gnu_inline   __attribute__((gnu_inline))
+#else
+# define __gnu_inline
+#endif
+
+/*
+ * Force always-inline if the user requests it so via the .config.
+ * GCC does not warn about unused static inline functions for
+ * -Wunused-function.  This turns out to avoid the need for complex #ifdef
+ * directives.  Suppress the warning in clang as well by using "unused"
+ * function attribute, which is redundant but not harmful for gcc.
+ * Prefer gnu_inline, so that extern inline functions do not emit an
+ * externally visible function. This makes extern inline behave as per gnu89
+ * semantics rather than c99. This prevents multiple symbol definition errors
+ * of extern inline functions at link time.
+ * A lot of inline functions can cause havoc with function tracing.
+ */
+#if !defined(CONFIG_ARCH_SUPPORTS_OPTIMIZED_INLINING) || \
+        !defined(CONFIG_OPTIMIZE_INLINING)
+#define inline \
+        inline __attribute__((always_inline, unused)) notrace __gnu_inline
+#else
+#define inline inline   __attribute__((unused)) notrace __gnu_inline
+#endif
+
+#define __inline__ inline
+#define __inline inline
+#define noinline        __attribute__((noinline))
+
+#ifndef __always_inline
+#define __always_inline inline __attribute__((always_inline))
+#endif
+
+/*
+ * Rather then using noinline to prevent stack consumption, use
+ * noinline_for_stack instead.  For documentation reasons.
+ */
+#define noinline_for_stack noinline
+
 #endif /* __LINUX_COMPILER_TYPES_H */
diff --git a/include/linux/console.h b/include/linux/console.h
index dfd6b0e97855..ec9bdb3d7bab 100644
--- a/include/linux/console.h
+++ b/include/linux/console.h
@@ -14,6 +14,7 @@
 #ifndef _LINUX_CONSOLE_H_
 #define _LINUX_CONSOLE_H_ 1
 
+#include <linux/atomic.h>
 #include <linux/types.h>
 
 struct vc_data;
@@ -21,6 +22,7 @@ struct console_font_op;
 struct console_font;
 struct module;
 struct tty_struct;
+struct notifier_block;
 
 /*
  * this is what the terminal answers to a ESC-Z or csi0c query.
@@ -200,11 +202,14 @@ void vcs_make_sysfs(int index);
 void vcs_remove_sysfs(int index);
 
 /* Some debug stub to catch some of the obvious races in the VT code */
-#if 1
-#define WARN_CONSOLE_UNLOCKED() WARN_ON(!is_console_locked() && !oops_in_progress)
-#else
-#define WARN_CONSOLE_UNLOCKED()
-#endif
+#define WARN_CONSOLE_UNLOCKED()                                         \
+        WARN_ON(!atomic_read(&ignore_console_lock_warning) &&           \
+                !is_console_locked() && !oops_in_progress)
+/*
+ * Increment ignore_console_lock_warning if you need to quiet
+ * WARN_CONSOLE_UNLOCKED() for debugging purposes.
+ */
+extern atomic_t ignore_console_lock_warning;
 
 /* VESA Blanking Levels */
 #define VESA_NO_BLANKING        0
@@ -220,4 +225,8 @@ static inline bool vgacon_text_force(void) { return false; }
 
 extern void console_init(void);
 
+/* For deferred console takeover */
+void dummycon_register_output_notifier(struct notifier_block *nb);
+void dummycon_unregister_output_notifier(struct notifier_block *nb);
+
 #endif /* _LINUX_CONSOLE_H */
diff --git a/include/linux/console_struct.h b/include/linux/console_struct.h
index c0ec478ea5bf..fea64f2692a0 100644
--- a/include/linux/console_struct.h
+++ b/include/linux/console_struct.h
@@ -17,8 +17,8 @@
 #include <linux/vt.h>
 #include <linux/workqueue.h>
 
-struct vt_struct;
 struct uni_pagedir;
+struct uni_screen;
 
 #define NPAR 16
 
@@ -140,6 +140,7 @@ struct vc_data {
         struct vc_data **vc_display_fg;         /* [!] Ptr to var holding fg console for this display */
         struct uni_pagedir *vc_uni_pagedir;
         struct uni_pagedir **vc_uni_pagedir_loc; /* [!] Location of uni_pagedir variable for this console */
+        struct uni_screen *vc_uni_screen;       /* unicode screen content */
         bool vc_panic_force_write; /* when oops/panic this VC can accept forced output/blanking */
         /* additional information is in vt_kern.h */
 };
@@ -148,7 +149,7 @@ struct vc {
         struct vc_data *d;
         struct work_struct SAK_work;
 
-        /* might add  scrmem, vt_struct, kbd  at some time,
+        /* might add  scrmem, kbd  at some time,
            to have everything in one place - the disadvantage
            would be that vc_cons etc can no longer be static */
 };
diff --git a/include/linux/coresight.h b/include/linux/coresight.h
index c265e0468414..d828a6efe0b1 100644
--- a/include/linux/coresight.h
+++ b/include/linux/coresight.h
@@ -40,6 +40,7 @@ enum coresight_dev_type {
         CORESIGHT_DEV_TYPE_LINK,
         CORESIGHT_DEV_TYPE_LINKSINK,
         CORESIGHT_DEV_TYPE_SOURCE,
+        CORESIGHT_DEV_TYPE_HELPER,
 };
 
 enum coresight_dev_subtype_sink {
@@ -62,19 +63,30 @@ enum coresight_dev_subtype_source {
         CORESIGHT_DEV_SUBTYPE_SOURCE_SOFTWARE,
 };
 
+enum coresight_dev_subtype_helper {
+        CORESIGHT_DEV_SUBTYPE_HELPER_NONE,
+        CORESIGHT_DEV_SUBTYPE_HELPER_CATU,
+};
+
 /**
- * struct coresight_dev_subtype - further characterisation of a type
+ * union coresight_dev_subtype - further characterisation of a type
  * @sink_subtype:       type of sink this component is, as defined
-                        by @coresight_dev_subtype_sink.
+ *                      by @coresight_dev_subtype_sink.
  * @link_subtype:       type of link this component is, as defined
-                        by @coresight_dev_subtype_link.
+ *                      by @coresight_dev_subtype_link.
  * @source_subtype:     type of source this component is, as defined
-                        by @coresight_dev_subtype_source.
+ *                      by @coresight_dev_subtype_source.
+ * @helper_subtype:     type of helper this component is, as defined
+ *                      by @coresight_dev_subtype_helper.
  */
-struct coresight_dev_subtype {
-        enum coresight_dev_subtype_sink sink_subtype;
-        enum coresight_dev_subtype_link link_subtype;
+union coresight_dev_subtype {
+        /* We have some devices which acts as LINK and SINK */
+        struct {
+                enum coresight_dev_subtype_sink sink_subtype;
+                enum coresight_dev_subtype_link link_subtype;
+        };
         enum coresight_dev_subtype_source source_subtype;
+        enum coresight_dev_subtype_helper helper_subtype;
 };
 
 /**
@@ -87,7 +99,6 @@ struct coresight_dev_subtype {
  * @child_ports:child component port number the current component is
                 connected  to.
  * @nr_outport: number of output ports for this component.
- * @clk:        The clock this component is associated to.
  */
 struct coresight_platform_data {
         int cpu;
@@ -97,7 +108,6 @@ struct coresight_platform_data {
         const char **child_names;
         int *child_ports;
         int nr_outport;
-        struct clk *clk;
 };
 
 /**
@@ -113,7 +123,7 @@ struct coresight_platform_data {
  */
 struct coresight_desc {
         enum coresight_dev_type type;
-        struct coresight_dev_subtype subtype;
+        union coresight_dev_subtype subtype;
         const struct coresight_ops *ops;
         struct coresight_platform_data *pdata;
         struct device *dev;
@@ -157,7 +167,7 @@ struct coresight_device {
         int nr_inport;
         int nr_outport;
         enum coresight_dev_type type;
-        struct coresight_dev_subtype subtype;
+        union coresight_dev_subtype subtype;
         const struct coresight_ops *ops;
         struct device dev;
         atomic_t *refcnt;
@@ -171,6 +181,7 @@ struct coresight_device {
 #define source_ops(csdev)       csdev->ops->source_ops
 #define sink_ops(csdev)         csdev->ops->sink_ops
 #define link_ops(csdev)         csdev->ops->link_ops
+#define helper_ops(csdev)       csdev->ops->helper_ops
 
 /**
  * struct coresight_ops_sink - basic operations for a sink
@@ -230,10 +241,25 @@ struct coresight_ops_source {
                         struct perf_event *event);
 };
 
+/**
+ * struct coresight_ops_helper - Operations for a helper device.
+ *
+ * All operations could pass in a device specific data, which could
+ * help the helper device to determine what to do.
+ *
+ * @enable      : Enable the device
+ * @disable     : Disable the device
+ */
+struct coresight_ops_helper {
+        int (*enable)(struct coresight_device *csdev, void *data);
+        int (*disable)(struct coresight_device *csdev, void *data);
+};
+
 struct coresight_ops {
         const struct coresight_ops_sink *sink_ops;
         const struct coresight_ops_link *link_ops;
         const struct coresight_ops_source *source_ops;
+        const struct coresight_ops_helper *helper_ops;
 };
 
 #ifdef CONFIG_CORESIGHT
@@ -267,24 +293,4 @@ static inline struct coresight_platform_data *of_get_coresight_platform_data(
         struct device *dev, const struct device_node *node) { return NULL; }
 #endif
 
-#ifdef CONFIG_PID_NS
-static inline unsigned long
-coresight_vpid_to_pid(unsigned long vpid)
-{
-        struct task_struct *task = NULL;
-        unsigned long pid = 0;
-
-        rcu_read_lock();
-        task = find_task_by_vpid(vpid);
-        if (task)
-                pid = task_pid_nr(task);
-        rcu_read_unlock();
-
-        return pid;
-}
-#else
-static inline unsigned long
-coresight_vpid_to_pid(unsigned long vpid) { return vpid; }
-#endif
-
 #endif
diff --git a/include/linux/cpu.h b/include/linux/cpu.h
index 3233fbe23594..218df7f4d3e1 100644
--- a/include/linux/cpu.h
+++ b/include/linux/cpu.h
@@ -55,6 +55,8 @@ extern ssize_t cpu_show_spectre_v2(struct device *dev,
                                    struct device_attribute *attr, char *buf);
 extern ssize_t cpu_show_spec_store_bypass(struct device *dev,
                                           struct device_attribute *attr, char *buf);
+extern ssize_t cpu_show_l1tf(struct device *dev,
+                             struct device_attribute *attr, char *buf);
 
 extern __printf(4, 5)
 struct device *cpu_device_create(struct device *parent, void *drvdata,
@@ -103,6 +105,7 @@ extern void cpus_write_lock(void);
 extern void cpus_write_unlock(void);
 extern void cpus_read_lock(void);
 extern void cpus_read_unlock(void);
+extern int  cpus_read_trylock(void);
 extern void lockdep_assert_cpus_held(void);
 extern void cpu_hotplug_disable(void);
 extern void cpu_hotplug_enable(void);
@@ -115,6 +118,7 @@ static inline void cpus_write_lock(void) { }
 static inline void cpus_write_unlock(void) { }
 static inline void cpus_read_lock(void) { }
 static inline void cpus_read_unlock(void) { }
+static inline int  cpus_read_trylock(void) { return true; }
 static inline void lockdep_assert_cpus_held(void) { }
 static inline void cpu_hotplug_disable(void) { }
 static inline void cpu_hotplug_enable(void) { }
@@ -166,4 +170,23 @@ void cpuhp_report_idle_dead(void);
 static inline void cpuhp_report_idle_dead(void) { }
 #endif /* #ifdef CONFIG_HOTPLUG_CPU */
 
+enum cpuhp_smt_control {
+        CPU_SMT_ENABLED,
+        CPU_SMT_DISABLED,
+        CPU_SMT_FORCE_DISABLED,
+        CPU_SMT_NOT_SUPPORTED,
+};
+
+#if defined(CONFIG_SMP) && defined(CONFIG_HOTPLUG_SMT)
+extern enum cpuhp_smt_control cpu_smt_control;
+extern void cpu_smt_disable(bool force);
+extern void cpu_smt_check_topology_early(void);
+extern void cpu_smt_check_topology(void);
+#else
+# define cpu_smt_control                (CPU_SMT_ENABLED)
+static inline void cpu_smt_disable(bool force) { }
+static inline void cpu_smt_check_topology_early(void) { }
+static inline void cpu_smt_check_topology(void) { }
+#endif
+
 #endif /* _LINUX_CPU_H_ */
diff --git a/include/linux/cpuhotplug.h b/include/linux/cpuhotplug.h
index 4cf06a64bc02..caf40ad0bbc6 100644
--- a/include/linux/cpuhotplug.h
+++ b/include/linux/cpuhotplug.h
@@ -125,6 +125,7 @@ enum cpuhp_state {
         CPUHP_AP_MARCO_TIMER_STARTING,
         CPUHP_AP_MIPS_GIC_TIMER_STARTING,
         CPUHP_AP_ARC_TIMER_STARTING,
+        CPUHP_AP_RISCV_TIMER_STARTING,
         CPUHP_AP_KVM_STARTING,
         CPUHP_AP_KVM_ARM_VGIC_INIT_STARTING,
         CPUHP_AP_KVM_ARM_VGIC_STARTING,
@@ -143,6 +144,7 @@ enum cpuhp_state {
         CPUHP_AP_SMPBOOT_THREADS,
         CPUHP_AP_X86_VDSO_VMA_ONLINE,
         CPUHP_AP_IRQ_AFFINITY_ONLINE,
+        CPUHP_AP_ARM_MVEBU_SYNC_CLOCKS,
         CPUHP_AP_PERF_ONLINE,
         CPUHP_AP_PERF_X86_ONLINE,
         CPUHP_AP_PERF_X86_UNCORE_ONLINE,
diff --git a/include/linux/cpumask.h b/include/linux/cpumask.h
index bf53d893ad02..147bdec42215 100644
--- a/include/linux/cpumask.h
+++ b/include/linux/cpumask.h
@@ -115,12 +115,17 @@ extern struct cpumask __cpu_active_mask;
 #define cpu_active(cpu)         ((cpu) == 0)
 #endif
 
-/* verify cpu argument to cpumask_* operators */
-static inline unsigned int cpumask_check(unsigned int cpu)
+static inline void cpu_max_bits_warn(unsigned int cpu, unsigned int bits)
 {
 #ifdef CONFIG_DEBUG_PER_CPU_MAPS
-        WARN_ON_ONCE(cpu >= nr_cpumask_bits);
+        WARN_ON_ONCE(cpu >= bits);
 #endif /* CONFIG_DEBUG_PER_CPU_MAPS */
+}
+
+/* verify cpu argument to cpumask_* operators */
+static inline unsigned int cpumask_check(unsigned int cpu)
+{
+        cpu_max_bits_warn(cpu, nr_cpumask_bits);
         return cpu;
 }
 
@@ -154,6 +159,13 @@ static inline unsigned int cpumask_next_and(int n,
         return n+1;
 }
 
+static inline unsigned int cpumask_next_wrap(int n, const struct cpumask *mask,
+                                             int start, bool wrap)
+{
+        /* cpu0 unless stop condition, wrap and at cpu0, then nr_cpumask_bits */
+        return (wrap && n == 0);
+}
+
 /* cpu must be a valid cpu, ie 0, so there's no other choice. */
 static inline unsigned int cpumask_any_but(const struct cpumask *mask,
                                            unsigned int cpu)
diff --git a/include/linux/crash_core.h b/include/linux/crash_core.h
index b511f6d24b42..525510a9f965 100644
--- a/include/linux/crash_core.h
+++ b/include/linux/crash_core.h
@@ -60,6 +60,8 @@ phys_addr_t paddr_vmcoreinfo_note(void);
 #define VMCOREINFO_CONFIG(name) \
         vmcoreinfo_append_str("CONFIG_%s=y\n", #name)
 
+extern unsigned char *vmcoreinfo_data;
+extern size_t vmcoreinfo_size;
 extern u32 *vmcoreinfo_note;
 
 Elf_Word *append_elf_note(Elf_Word *buf, char *name, unsigned int type,
diff --git a/include/linux/crc32poly.h b/include/linux/crc32poly.h
new file mode 100644
index 000000000000..62c4b7790a28
--- /dev/null
+++ b/include/linux/crc32poly.h
@@ -0,0 +1,20 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+#ifndef _LINUX_CRC32_POLY_H
+#define _LINUX_CRC32_POLY_H
+
+/*
+ * There are multiple 16-bit CRC polynomials in common use, but this is
+ * *the* standard CRC-32 polynomial, first popularized by Ethernet.
+ * x^32+x^26+x^23+x^22+x^16+x^12+x^11+x^10+x^8+x^7+x^5+x^4+x^2+x^1+x^0
+ */
+#define CRC32_POLY_LE 0xedb88320
+#define CRC32_POLY_BE 0x04c11db7
+
+/*
+ * This is the CRC32c polynomial, as outlined by Castagnoli.
+ * x^32+x^28+x^27+x^26+x^25+x^23+x^22+x^20+x^19+x^18+x^14+x^13+x^11+x^10+x^9+
+ * x^8+x^6+x^0
+ */
+#define CRC32C_POLY_LE 0x82F63B78
+
+#endif /* _LINUX_CRC32_POLY_H */
diff --git a/include/linux/crc64.h b/include/linux/crc64.h
new file mode 100644
index 000000000000..c756e65a1b58
--- /dev/null
+++ b/include/linux/crc64.h
@@ -0,0 +1,11 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * See lib/crc64.c for the related specification and polynomial arithmetic.
+ */
+#ifndef _LINUX_CRC64_H
+#define _LINUX_CRC64_H
+
+#include <linux/types.h>
+
+u64 __pure crc64_be(u64 crc, const void *p, size_t len);
+#endif /* _LINUX_CRC64_H */
diff --git a/include/linux/cred.h b/include/linux/cred.h
index 631286535d0f..7eed6101c791 100644
--- a/include/linux/cred.h
+++ b/include/linux/cred.h
@@ -65,6 +65,12 @@ extern void groups_free(struct group_info *);
 
 extern int in_group_p(kgid_t);
 extern int in_egroup_p(kgid_t);
+extern int groups_search(const struct group_info *, kgid_t);
+
+extern int set_current_groups(struct group_info *);
+extern void set_groups(struct cred *, struct group_info *);
+extern bool may_setgroups(void);
+extern void groups_sort(struct group_info *);
 #else
 static inline void groups_free(struct group_info *group_info)
 {
@@ -78,12 +84,11 @@ static inline int in_egroup_p(kgid_t grp)
 {
         return 1;
 }
+static inline int groups_search(const struct group_info *group_info, kgid_t grp)
+{
+        return 1;
+}
 #endif
-extern int set_current_groups(struct group_info *);
-extern void set_groups(struct cred *, struct group_info *);
-extern int groups_search(const struct group_info *, kgid_t);
-extern bool may_setgroups(void);
-extern void groups_sort(struct group_info *);
 
 /*
  * The security context of a task
diff --git a/include/linux/crypto.h b/include/linux/crypto.h
index 6eb06101089f..e8839d3a7559 100644
--- a/include/linux/crypto.h
+++ b/include/linux/crypto.h
@@ -113,6 +113,11 @@
 #define CRYPTO_ALG_OPTIONAL_KEY         0x00004000
 
 /*
+ * Don't trigger module loading
+ */
+#define CRYPTO_NOLOAD                   0x00008000
+
+/*
  * Transform masks and values (for crt_flags).
  */
 #define CRYPTO_TFM_NEED_KEY             0x00000001
diff --git a/include/linux/dax.h b/include/linux/dax.h
index deb0f663252f..450b28db9533 100644
--- a/include/linux/dax.h
+++ b/include/linux/dax.h
@@ -88,6 +88,8 @@ int dax_writeback_mapping_range(struct address_space *mapping,
                 struct block_device *bdev, struct writeback_control *wbc);
 
 struct page *dax_layout_busy_page(struct address_space *mapping);
+bool dax_lock_mapping_entry(struct page *page);
+void dax_unlock_mapping_entry(struct page *page);
 #else
 static inline bool bdev_dax_supported(struct block_device *bdev,
                 int blocksize)
@@ -119,6 +121,17 @@ static inline int dax_writeback_mapping_range(struct address_space *mapping,
 {
         return -EOPNOTSUPP;
 }
+
+static inline bool dax_lock_mapping_entry(struct page *page)
+{
+        if (IS_DAX(page->mapping->host))
+                return true;
+        return false;
+}
+
+static inline void dax_unlock_mapping_entry(struct page *page)
+{
+}
 #endif
 
 int dax_read_lock(void);
diff --git a/include/linux/dcache.h b/include/linux/dcache.h
index 66c6e17e61e5..ef4b70f64f33 100644
--- a/include/linux/dcache.h
+++ b/include/linux/dcache.h
@@ -145,8 +145,7 @@ struct dentry_operations {
         char *(*d_dname)(struct dentry *, char *, int);
         struct vfsmount *(*d_automount)(struct path *);
         int (*d_manage)(const struct path *, bool);
-        struct dentry *(*d_real)(struct dentry *, const struct inode *,
-                                 unsigned int, unsigned int);
+        struct dentry *(*d_real)(struct dentry *, const struct inode *);
 } ____cacheline_aligned;
 
 /*
@@ -227,7 +226,6 @@ extern void d_instantiate(struct dentry *, struct inode *);
 extern void d_instantiate_new(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);
 extern void d_delete(struct dentry *);
@@ -271,8 +269,6 @@ extern void d_rehash(struct dentry *);
  
 extern void d_add(struct dentry *, struct inode *);
 
-extern void dentry_update_name_case(struct dentry *, const struct qstr *);
-
 /* used for rename() and baskets */
 extern void d_move(struct dentry *, struct dentry *);
 extern void d_exchange(struct dentry *, struct dentry *);
@@ -564,15 +560,10 @@ static inline struct dentry *d_backing_dentry(struct dentry *upper)
         return upper;
 }
 
-/* d_real() flags */
-#define D_REAL_UPPER    0x2     /* return upper dentry or NULL if non-upper */
-
 /**
  * d_real - Return the real dentry
  * @dentry: the dentry to query
  * @inode: inode to select the dentry from multiple layers (can be NULL)
- * @open_flags: open flags to control copy-up behavior
- * @flags: flags to control what is returned by this function
  *
  * If dentry is on a union/overlay, then return the underlying, real dentry.
  * Otherwise return the dentry itself.
@@ -580,11 +571,10 @@ static inline struct dentry *d_backing_dentry(struct dentry *upper)
  * See also: Documentation/filesystems/vfs.txt
  */
 static inline struct dentry *d_real(struct dentry *dentry,
-                                    const struct inode *inode,
-                                    unsigned int open_flags, unsigned int flags)
+                                    const struct inode *inode)
 {
         if (unlikely(dentry->d_flags & DCACHE_OP_REAL))
-                return dentry->d_op->d_real(dentry, inode, open_flags, flags);
+                return dentry->d_op->d_real(dentry, inode);
         else
                 return dentry;
 }
@@ -599,7 +589,7 @@ static inline struct dentry *d_real(struct dentry *dentry,
 static inline struct inode *d_real_inode(const struct dentry *dentry)
 {
         /* This usage of d_real() results in const dentry */
-        return d_backing_inode(d_real((struct dentry *) dentry, NULL, 0, 0));
+        return d_backing_inode(d_real((struct dentry *) dentry, NULL));
 }
 
 struct name_snapshot {
diff --git a/include/linux/device.h b/include/linux/device.h
index 055a69dbcd18..8f882549edee 100644
--- a/include/linux/device.h
+++ b/include/linux/device.h
@@ -90,7 +90,7 @@ extern void bus_remove_file(struct bus_type *, struct bus_attribute *);
  * @num_vf:     Called to find out how many virtual functions a device on this
  *              bus supports.
  * @dma_configure:      Called to setup DMA configuration on a device on
-                        this bus.
+ *                      this bus.
  * @pm:         Power management operations of this bus, callback the specific
  *              device driver's pm-ops.
  * @iommu_ops:  IOMMU specific operations for this bus, used to attach IOMMU
@@ -339,6 +339,8 @@ struct device *driver_find_device(struct device_driver *drv,
                                   struct device *start, void *data,
                                   int (*match)(struct device *dev, void *data));
 
+int driver_deferred_probe_check_state(struct device *dev);
+
 /**
  * struct subsys_interface - interfaces to device functions
  * @name:       name of the device function
@@ -384,6 +386,9 @@ int subsys_virtual_register(struct bus_type *subsys,
  * @shutdown_pre: Called at shut-down time before driver shutdown.
  * @ns_type:    Callbacks so sysfs can detemine namespaces.
  * @namespace:  Namespace of the device belongs to this class.
+ * @get_ownership: Allows class to specify uid/gid of the sysfs directories
+ *              for the devices belonging to the class. Usually tied to
+ *              device's namespace.
  * @pm:         The default device power management operations of this class.
  * @p:          The private data of the driver core, no one other than the
  *              driver core can touch this.
@@ -413,6 +418,8 @@ struct class {
         const struct kobj_ns_type_operations *ns_type;
         const void *(*namespace)(struct device *dev);
 
+        void (*get_ownership)(struct device *dev, kuid_t *uid, kgid_t *gid);
+
         const struct dev_pm_ops *pm;
 
         struct subsys_private *p;
@@ -696,6 +703,10 @@ extern void devm_free_pages(struct device *dev, unsigned long addr);
 
 void __iomem *devm_ioremap_resource(struct device *dev, struct resource *res);
 
+void __iomem *devm_of_iomap(struct device *dev,
+                            struct device_node *node, int index,
+                            resource_size_t *size);
+
 /* allows to add/remove a custom action to devres stack */
 int devm_add_action(struct device *dev, void (*action)(void *), void *data);
 void devm_remove_action(struct device *dev, void (*action)(void *), void *data);
@@ -784,14 +795,16 @@ enum device_link_state {
  * Device link flags.
  *
  * STATELESS: The core won't track the presence of supplier/consumer drivers.
- * AUTOREMOVE: Remove this link automatically on consumer driver unbind.
+ * AUTOREMOVE_CONSUMER: Remove the link automatically on consumer driver unbind.
  * PM_RUNTIME: If set, the runtime PM framework will use this link.
  * RPM_ACTIVE: Run pm_runtime_get_sync() on the supplier during link creation.
+ * AUTOREMOVE_SUPPLIER: Remove the link automatically on supplier driver unbind.
  */
-#define DL_FLAG_STATELESS       BIT(0)
-#define DL_FLAG_AUTOREMOVE      BIT(1)
-#define DL_FLAG_PM_RUNTIME      BIT(2)
-#define DL_FLAG_RPM_ACTIVE      BIT(3)
+#define DL_FLAG_STATELESS               BIT(0)
+#define DL_FLAG_AUTOREMOVE_CONSUMER     BIT(1)
+#define DL_FLAG_PM_RUNTIME              BIT(2)
+#define DL_FLAG_RPM_ACTIVE              BIT(3)
+#define DL_FLAG_AUTOREMOVE_SUPPLIER     BIT(4)
 
 /**
  * struct device_link - Device link representation.
@@ -886,6 +899,8 @@ struct dev_links_info {
  * @coherent_dma_mask: Like dma_mask, but for alloc_coherent mapping as not all
  *              hardware supports 64-bit addresses for consistent allocations
  *              such descriptors.
+ * @bus_dma_mask: Mask of an upstream bridge or bus which imposes a smaller DMA
+ *              limit than the device itself supports.
  * @dma_pfn_offset: offset of DMA memory range relatively of RAM
  * @dma_parms:  A low level driver may set these to teach IOMMU code about
  *              segment limitations.
@@ -912,8 +927,6 @@ struct dev_links_info {
  * @offline:    Set after successful invocation of bus type's .offline().
  * @of_node_reused: Set if the device-tree node is shared with an ancestor
  *              device.
- * @dma_32bit_limit: bridge limited to 32bit DMA even if the device itself
- *              indicates support for a higher limit in the dma_mask field.
  *
  * At the lowest level, every device in a Linux system is represented by an
  * instance of struct device. The device structure contains the information
@@ -967,6 +980,7 @@ struct device {
                                              not all hardware supports
                                              64 bit addresses for consistent
                                              allocations such descriptors. */
+        u64             bus_dma_mask;   /* upstream dma_mask constraint */
         unsigned long   dma_pfn_offset;
 
         struct device_dma_parameters *dma_parms;
@@ -1002,7 +1016,6 @@ struct device {
         bool                    offline_disabled:1;
         bool                    offline:1;
         bool                    of_node_reused:1;
-        bool                    dma_32bit_limit:1;
 };
 
 static inline struct device *kobj_to_dev(struct kobject *kobj)
@@ -1316,31 +1329,36 @@ extern const char *dev_driver_string(const struct device *dev);
 struct device_link *device_link_add(struct device *consumer,
                                     struct device *supplier, u32 flags);
 void device_link_del(struct device_link *link);
+void device_link_remove(void *consumer, struct device *supplier);
+
+#ifndef dev_fmt
+#define dev_fmt(fmt) fmt
+#endif
 
 #ifdef CONFIG_PRINTK
 
-extern __printf(3, 0)
+__printf(3, 0)
 int dev_vprintk_emit(int level, const struct device *dev,
                      const char *fmt, va_list args);
-extern __printf(3, 4)
+__printf(3, 4)
 int dev_printk_emit(int level, const struct device *dev, const char *fmt, ...);
 
-extern __printf(3, 4)
+__printf(3, 4)
 void dev_printk(const char *level, const struct device *dev,
                 const char *fmt, ...);
-extern __printf(2, 3)
-void dev_emerg(const struct device *dev, const char *fmt, ...);
-extern __printf(2, 3)
-void dev_alert(const struct device *dev, const char *fmt, ...);
-extern __printf(2, 3)
-void dev_crit(const struct device *dev, const char *fmt, ...);
-extern __printf(2, 3)
-void dev_err(const struct device *dev, const char *fmt, ...);
-extern __printf(2, 3)
-void dev_warn(const struct device *dev, const char *fmt, ...);
-extern __printf(2, 3)
-void dev_notice(const struct device *dev, const char *fmt, ...);
-extern __printf(2, 3)
+__printf(2, 3)
+void _dev_emerg(const struct device *dev, const char *fmt, ...);
+__printf(2, 3)
+void _dev_alert(const struct device *dev, const char *fmt, ...);
+__printf(2, 3)
+void _dev_crit(const struct device *dev, const char *fmt, ...);
+__printf(2, 3)
+void _dev_err(const struct device *dev, const char *fmt, ...);
+__printf(2, 3)
+void _dev_warn(const struct device *dev, const char *fmt, ...);
+__printf(2, 3)
+void _dev_notice(const struct device *dev, const char *fmt, ...);
+__printf(2, 3)
 void _dev_info(const struct device *dev, const char *fmt, ...);
 
 #else
@@ -1358,26 +1376,26 @@ static inline void __dev_printk(const char *level, const struct device *dev,
 {}
 static inline __printf(3, 4)
 void dev_printk(const char *level, const struct device *dev,
-                const char *fmt, ...)
+                 const char *fmt, ...)
 {}
 
 static inline __printf(2, 3)
-void dev_emerg(const struct device *dev, const char *fmt, ...)
+void _dev_emerg(const struct device *dev, const char *fmt, ...)
 {}
 static inline __printf(2, 3)
-void dev_crit(const struct device *dev, const char *fmt, ...)
+void _dev_crit(const struct device *dev, const char *fmt, ...)
 {}
 static inline __printf(2, 3)
-void dev_alert(const struct device *dev, const char *fmt, ...)
+void _dev_alert(const struct device *dev, const char *fmt, ...)
 {}
 static inline __printf(2, 3)
-void dev_err(const struct device *dev, const char *fmt, ...)
+void _dev_err(const struct device *dev, const char *fmt, ...)
 {}
 static inline __printf(2, 3)
-void dev_warn(const struct device *dev, const char *fmt, ...)
+void _dev_warn(const struct device *dev, const char *fmt, ...)
 {}
 static inline __printf(2, 3)
-void dev_notice(const struct device *dev, const char *fmt, ...)
+void _dev_notice(const struct device *dev, const char *fmt, ...)
 {}
 static inline __printf(2, 3)
 void _dev_info(const struct device *dev, const char *fmt, ...)
@@ -1386,27 +1404,36 @@ void _dev_info(const struct device *dev, const char *fmt, ...)
 #endif
 
 /*
- * Stupid hackaround for existing uses of non-printk uses dev_info
- *
- * Note that the definition of dev_info below is actually _dev_info
- * and a macro is used to avoid redefining dev_info
+ * #defines for all the dev_<level> macros to prefix with whatever
+ * possible use of #define dev_fmt(fmt) ...
  */
 
-#define dev_info(dev, fmt, arg...) _dev_info(dev, fmt, ##arg)
+#define dev_emerg(dev, fmt, ...)                                        \
+        _dev_emerg(dev, dev_fmt(fmt), ##__VA_ARGS__)
+#define dev_crit(dev, fmt, ...)                                         \
+        _dev_crit(dev, dev_fmt(fmt), ##__VA_ARGS__)
+#define dev_alert(dev, fmt, ...)                                        \
+        _dev_alert(dev, dev_fmt(fmt), ##__VA_ARGS__)
+#define dev_err(dev, fmt, ...)                                          \
+        _dev_err(dev, dev_fmt(fmt), ##__VA_ARGS__)
+#define dev_warn(dev, fmt, ...)                                         \
+        _dev_warn(dev, dev_fmt(fmt), ##__VA_ARGS__)
+#define dev_notice(dev, fmt, ...)                                       \
+        _dev_notice(dev, dev_fmt(fmt), ##__VA_ARGS__)
+#define dev_info(dev, fmt, ...)                                         \
+        _dev_info(dev, dev_fmt(fmt), ##__VA_ARGS__)
 
 #if defined(CONFIG_DYNAMIC_DEBUG)
-#define dev_dbg(dev, format, ...)                    \
-do {                                                 \
-        dynamic_dev_dbg(dev, format, ##__VA_ARGS__); \
-} while (0)
+#define dev_dbg(dev, fmt, ...)                                          \
+        dynamic_dev_dbg(dev, dev_fmt(fmt), ##__VA_ARGS__)
 #elif defined(DEBUG)
-#define dev_dbg(dev, format, arg...)            \
-        dev_printk(KERN_DEBUG, dev, format, ##arg)
+#define dev_dbg(dev, fmt, ...)                                          \
+        dev_printk(KERN_DEBUG, dev, dev_fmt(fmt), ##__VA_ARGS__)
 #else
-#define dev_dbg(dev, format, arg...)                            \
-({                                                              \
-        if (0)                                                  \
-                dev_printk(KERN_DEBUG, dev, format, ##arg);     \
+#define dev_dbg(dev, fmt, ...)                                          \
+({                                                                      \
+        if (0)                                                          \
+                dev_printk(KERN_DEBUG, dev, dev_fmt(fmt), ##__VA_ARGS__); \
 })
 #endif
 
@@ -1478,7 +1505,7 @@ do {									\
         DEFINE_DYNAMIC_DEBUG_METADATA(descriptor, fmt);                 \
         if (unlikely(descriptor.flags & _DPRINTK_FLAGS_PRINT) &&        \
             __ratelimit(&_rs))                                          \
-                __dynamic_dev_dbg(&descriptor, dev, fmt,                \
+                __dynamic_dev_dbg(&descriptor, dev, dev_fmt(fmt),       \
                                   ##__VA_ARGS__);                       \
 } while (0)
 #elif defined(DEBUG)
@@ -1488,23 +1515,23 @@ do {									\
                                       DEFAULT_RATELIMIT_INTERVAL,       \
                                       DEFAULT_RATELIMIT_BURST);         \
         if (__ratelimit(&_rs))                                          \
-                dev_printk(KERN_DEBUG, dev, fmt, ##__VA_ARGS__);        \
+                dev_printk(KERN_DEBUG, dev, dev_fmt(fmt), ##__VA_ARGS__); \
 } while (0)
 #else
 #define dev_dbg_ratelimited(dev, fmt, ...)                              \
 do {                                                                    \
         if (0)                                                          \
-                dev_printk(KERN_DEBUG, dev, fmt, ##__VA_ARGS__);        \
+                dev_printk(KERN_DEBUG, dev, dev_fmt(fmt), ##__VA_ARGS__); \
 } while (0)
 #endif
 
 #ifdef VERBOSE_DEBUG
 #define dev_vdbg        dev_dbg
 #else
-#define dev_vdbg(dev, format, arg...)                           \
-({                                                              \
-        if (0)                                                  \
-                dev_printk(KERN_DEBUG, dev, format, ##arg);     \
+#define dev_vdbg(dev, fmt, ...)                                         \
+({                                                                      \
+        if (0)                                                          \
+                dev_printk(KERN_DEBUG, dev, dev_fmt(fmt), ##__VA_ARGS__); \
 })
 #endif
 
diff --git a/include/linux/dm-kcopyd.h b/include/linux/dm-kcopyd.h
index cfac8588ed56..e42de7750c88 100644
--- a/include/linux/dm-kcopyd.h
+++ b/include/linux/dm-kcopyd.h
@@ -62,9 +62,9 @@ void dm_kcopyd_client_destroy(struct dm_kcopyd_client *kc);
 typedef void (*dm_kcopyd_notify_fn)(int read_err, unsigned long write_err,
                                     void *context);
 
-int dm_kcopyd_copy(struct dm_kcopyd_client *kc, struct dm_io_region *from,
-                   unsigned num_dests, struct dm_io_region *dests,
-                   unsigned flags, dm_kcopyd_notify_fn fn, void *context);
+void dm_kcopyd_copy(struct dm_kcopyd_client *kc, struct dm_io_region *from,
+                    unsigned num_dests, struct dm_io_region *dests,
+                    unsigned flags, dm_kcopyd_notify_fn fn, void *context);
 
 /*
  * Prepare a callback and submit it via the kcopyd thread.
@@ -81,9 +81,9 @@ void *dm_kcopyd_prepare_callback(struct dm_kcopyd_client *kc,
                                  dm_kcopyd_notify_fn fn, void *context);
 void dm_kcopyd_do_callback(void *job, int read_err, unsigned long write_err);
 
-int dm_kcopyd_zero(struct dm_kcopyd_client *kc,
-                   unsigned num_dests, struct dm_io_region *dests,
-                   unsigned flags, dm_kcopyd_notify_fn fn, void *context);
+void dm_kcopyd_zero(struct dm_kcopyd_client *kc,
+                    unsigned num_dests, struct dm_io_region *dests,
+                    unsigned flags, dm_kcopyd_notify_fn fn, void *context);
 
 #endif  /* __KERNEL__ */
 #endif  /* _LINUX_DM_KCOPYD_H */
diff --git a/include/linux/dma-buf.h b/include/linux/dma-buf.h
index 085db2fee2d7..58725f890b5b 100644
--- a/include/linux/dma-buf.h
+++ b/include/linux/dma-buf.h
@@ -39,12 +39,12 @@ struct dma_buf_attachment;
 
 /**
  * struct dma_buf_ops - operations possible on struct dma_buf
- * @map_atomic: maps a page from the buffer into kernel address
+ * @map_atomic: [optional] maps a page from the buffer into kernel address
  *              space, users may not block until the subsequent unmap call.
  *              This callback must not sleep.
  * @unmap_atomic: [optional] unmaps a atomically mapped page from the buffer.
  *                This Callback must not sleep.
- * @map: maps a page from the buffer into kernel address space.
+ * @map: [optional] maps a page from the buffer into kernel address space.
  * @unmap: [optional] unmaps a page from the buffer.
  * @vmap: [optional] creates a virtual mapping for the buffer into kernel
  *        address space. Same restrictions as for vmap and friends apply.
@@ -55,11 +55,11 @@ struct dma_buf_ops {
          * @attach:
          *
          * This is called from dma_buf_attach() to make sure that a given
-         * &device can access the provided &dma_buf. Exporters which support
-         * buffer objects in special locations like VRAM or device-specific
-         * carveout areas should check whether the buffer could be move to
-         * system memory (or directly accessed by the provided device), and
-         * otherwise need to fail the attach operation.
+         * &dma_buf_attachment.dev can access the provided &dma_buf. Exporters
+         * which support buffer objects in special locations like VRAM or
+         * device-specific carveout areas should check whether the buffer could
+         * be move to system memory (or directly accessed by the provided
+         * device), and otherwise need to fail the attach operation.
          *
          * The exporter should also in general check whether the current
          * allocation fullfills the DMA constraints of the new device. If this
@@ -77,8 +77,7 @@ struct dma_buf_ops {
          * to signal that backing storage is already allocated and incompatible
          * with the requirements of requesting device.
          */
-        int (*attach)(struct dma_buf *, struct device *,
-                      struct dma_buf_attachment *);
+        int (*attach)(struct dma_buf *, struct dma_buf_attachment *);
 
         /**
          * @detach:
@@ -206,8 +205,6 @@ struct dma_buf_ops {
          * to be restarted.
          */
         int (*end_cpu_access)(struct dma_buf *, enum dma_data_direction);
-        void *(*map_atomic)(struct dma_buf *, unsigned long);
-        void (*unmap_atomic)(struct dma_buf *, unsigned long, void *);
         void *(*map)(struct dma_buf *, unsigned long);
         void (*unmap)(struct dma_buf *, unsigned long, void *);
 
@@ -395,8 +392,6 @@ int dma_buf_begin_cpu_access(struct dma_buf *dma_buf,
                              enum dma_data_direction dir);
 int dma_buf_end_cpu_access(struct dma_buf *dma_buf,
                            enum dma_data_direction dir);
-void *dma_buf_kmap_atomic(struct dma_buf *, unsigned long);
-void dma_buf_kunmap_atomic(struct dma_buf *, unsigned long, void *);
 void *dma_buf_kmap(struct dma_buf *, unsigned long);
 void dma_buf_kunmap(struct dma_buf *, unsigned long, void *);
 
diff --git a/include/linux/dma-contiguous.h b/include/linux/dma-contiguous.h
index 3c5a4cb3eb95..f247e8aa5e3d 100644
--- a/include/linux/dma-contiguous.h
+++ b/include/linux/dma-contiguous.h
@@ -112,7 +112,7 @@ static inline int dma_declare_contiguous(struct device *dev, phys_addr_t size,
 }
 
 struct page *dma_alloc_from_contiguous(struct device *dev, size_t count,
-                                       unsigned int order, gfp_t gfp_mask);
+                                       unsigned int order, bool no_warn);
 bool dma_release_from_contiguous(struct device *dev, struct page *pages,
                                  int count);
 
@@ -145,7 +145,7 @@ int dma_declare_contiguous(struct device *dev, phys_addr_t size,
 
 static inline
 struct page *dma_alloc_from_contiguous(struct device *dev, size_t count,
-                                       unsigned int order, gfp_t gfp_mask)
+                                       unsigned int order, bool no_warn)
 {
         return NULL;
 }
diff --git a/include/linux/dma-direction.h b/include/linux/dma-direction.h
index 3649a031893a..9c96e30e6a0b 100644
--- a/include/linux/dma-direction.h
+++ b/include/linux/dma-direction.h
@@ -1,14 +1,12 @@
 /* SPDX-License-Identifier: GPL-2.0 */
 #ifndef _LINUX_DMA_DIRECTION_H
 #define _LINUX_DMA_DIRECTION_H
-/*
- * These definitions mirror those in pci.h, so they can be used
- * interchangeably with their PCI_ counterparts.
- */
+
 enum dma_data_direction {
         DMA_BIDIRECTIONAL = 0,
         DMA_TO_DEVICE = 1,
         DMA_FROM_DEVICE = 2,
         DMA_NONE = 3,
 };
+
 #endif
diff --git a/include/linux/dma-fence.h b/include/linux/dma-fence.h
index eb9b05aa5aea..02dba8cd033d 100644
--- a/include/linux/dma-fence.h
+++ b/include/linux/dma-fence.h
@@ -166,7 +166,8 @@ struct dma_fence_ops {
          * released when the fence is signalled (through e.g. the interrupt
          * handler).
          *
-         * This callback is mandatory.
+         * This callback is optional. If this callback is not present, then the
+         * driver must always have signaling enabled.
          */
         bool (*enable_signaling)(struct dma_fence *fence);
 
@@ -190,11 +191,14 @@ struct dma_fence_ops {
         /**
          * @wait:
          *
-         * Custom wait implementation, or dma_fence_default_wait.
+         * Custom wait implementation, defaults to dma_fence_default_wait() if
+         * not set.
          *
-         * Must not be NULL, set to dma_fence_default_wait for default implementation.
-         * the dma_fence_default_wait implementation should work for any fence, as long
-         * as enable_signaling works correctly.
+         * The dma_fence_default_wait implementation should work for any fence, as long
+         * as @enable_signaling works correctly. This hook allows drivers to
+         * have an optimized version for the case where a process context is
+         * already available, e.g. if @enable_signaling for the general case
+         * needs to set up a worker thread.
          *
          * Must return -ERESTARTSYS if the wait is intr = true and the wait was
          * interrupted, and remaining jiffies if fence has signaled, or 0 if wait
@@ -202,7 +206,7 @@ struct dma_fence_ops {
          * which should be treated as if the fence is signaled. For example a hardware
          * lockup could be reported like that.
          *
-         * This callback is mandatory.
+         * This callback is optional.
          */
         signed long (*wait)(struct dma_fence *fence,
                             bool intr, signed long timeout);
@@ -218,17 +222,6 @@ struct dma_fence_ops {
         void (*release)(struct dma_fence *fence);
 
         /**
-         * @fill_driver_data:
-         *
-         * Callback to fill in free-form debug info.
-         *
-         * Returns amount of bytes filled, or negative error on failure.
-         *
-         * This callback is optional.
-         */
-        int (*fill_driver_data)(struct dma_fence *fence, void *data, int size);
-
-        /**
          * @fence_value_str:
          *
          * Callback to fill in free-form debug info specific to this fence, like
@@ -242,8 +235,9 @@ struct dma_fence_ops {
          * @timeline_value_str:
          *
          * Fills in the current value of the timeline as a string, like the
-         * sequence number. This should match what @fill_driver_data prints for
-         * the most recently signalled fence (assuming no delayed signalling).
+         * sequence number. Note that the specific fence passed to this function
+         * should not matter, drivers should only use it to look up the
+         * corresponding timeline structures.
          */
         void (*timeline_value_str)(struct dma_fence *fence,
                                    char *str, int size);
diff --git a/include/linux/dma-mapping.h b/include/linux/dma-mapping.h
index f9cc309507d9..1db6a6b46d0d 100644
--- a/include/linux/dma-mapping.h
+++ b/include/linux/dma-mapping.h
@@ -538,10 +538,17 @@ static inline void dma_free_attrs(struct device *dev, size_t size,
         const struct dma_map_ops *ops = get_dma_ops(dev);
 
         BUG_ON(!ops);
-        WARN_ON(irqs_disabled());
 
         if (dma_release_from_dev_coherent(dev, get_order(size), cpu_addr))
                 return;
+        /*
+         * On non-coherent platforms which implement DMA-coherent buffers via
+         * non-cacheable remaps, ops->free() may call vunmap(). Thus getting
+         * this far in IRQ context is a) at risk of a BUG_ON() or trying to
+         * sleep on some machines, and b) an indication that the driver is
+         * probably misusing the coherent API anyway.
+         */
+        WARN_ON(irqs_disabled());
 
         if (!ops->free || !cpu_addr)
                 return;
diff --git a/include/linux/dma-noncoherent.h b/include/linux/dma-noncoherent.h
index 10b2654d549b..a0aa00cc909d 100644
--- a/include/linux/dma-noncoherent.h
+++ b/include/linux/dma-noncoherent.h
@@ -44,4 +44,12 @@ static inline void arch_sync_dma_for_cpu(struct device *dev,
 }
 #endif /* ARCH_HAS_SYNC_DMA_FOR_CPU */
 
+#ifdef CONFIG_ARCH_HAS_SYNC_DMA_FOR_CPU_ALL
+void arch_sync_dma_for_cpu_all(struct device *dev);
+#else
+static inline void arch_sync_dma_for_cpu_all(struct device *dev)
+{
+}
+#endif /* CONFIG_ARCH_HAS_SYNC_DMA_FOR_CPU_ALL */
+
 #endif /* _LINUX_DMA_NONCOHERENT_H */
diff --git a/include/linux/dma/pxa-dma.h b/include/linux/dma/pxa-dma.h
index e56ec7af4fd7..9fc594f69eff 100644
--- a/include/linux/dma/pxa-dma.h
+++ b/include/linux/dma/pxa-dma.h
@@ -9,6 +9,15 @@ enum pxad_chan_prio {
         PXAD_PRIO_LOWEST,
 };
 
+/**
+ * struct pxad_param - dma channel request parameters
+ * @drcmr: requestor line number
+ * @prio: minimal mandatory priority of the channel
+ *
+ * If a requested channel is granted, its priority will be at least @prio,
+ * ie. if PXAD_PRIO_LOW is required, the requested channel will be either
+ * PXAD_PRIO_LOW, PXAD_PRIO_NORMAL or PXAD_PRIO_HIGHEST.
+ */
 struct pxad_param {
         unsigned int drcmr;
         enum pxad_chan_prio prio;
diff --git a/include/linux/dma/xilinx_dma.h b/include/linux/dma/xilinx_dma.h
index 34b98f276ed0..5b6e61e4b3aa 100644
--- a/include/linux/dma/xilinx_dma.h
+++ b/include/linux/dma/xilinx_dma.h
@@ -27,6 +27,7 @@
  * @delay: Delay counter
  * @reset: Reset Channel
  * @ext_fsync: External Frame Sync source
+ * @vflip_en:  Vertical Flip enable
  */
 struct xilinx_vdma_config {
         int frm_dly;
@@ -39,6 +40,7 @@ struct xilinx_vdma_config {
         int delay;
         int reset;
         int ext_fsync;
+        bool vflip_en;
 };
 
 int xilinx_vdma_channel_set_config(struct dma_chan *dchan,
diff --git a/include/linux/dmaengine.h b/include/linux/dmaengine.h
index 861be5cab1df..d49ec5c31944 100644
--- a/include/linux/dmaengine.h
+++ b/include/linux/dmaengine.h
@@ -415,7 +415,9 @@ enum dma_residue_granularity {
  *      each type, the dma controller should set BIT(<TYPE>) and same
  *      should be checked by controller as well
  * @max_burst: max burst capability per-transfer
- * @cmd_pause: true, if pause and thereby resume is supported
+ * @cmd_pause: true, if pause is supported (i.e. for reading residue or
+ *             for resume later)
+ * @cmd_resume: true, if resume is supported
  * @cmd_terminate: true, if terminate cmd is supported
  * @residue_granularity: granularity of the reported transfer residue
  * @descriptor_reuse: if a descriptor can be reused by client and
@@ -427,6 +429,7 @@ struct dma_slave_caps {
         u32 directions;
         u32 max_burst;
         bool cmd_pause;
+        bool cmd_resume;
         bool cmd_terminate;
         enum dma_residue_granularity residue_granularity;
         bool descriptor_reuse;
@@ -1403,6 +1406,7 @@ static inline int dmaengine_desc_free(struct dma_async_tx_descriptor *desc)
 /* --- DMA device --- */
 
 int dma_async_device_register(struct dma_device *device);
+int dmaenginem_async_device_register(struct dma_device *device);
 void dma_async_device_unregister(struct dma_device *device);
 void dma_run_dependencies(struct dma_async_tx_descriptor *tx);
 struct dma_chan *dma_get_slave_channel(struct dma_chan *chan);
diff --git a/include/linux/dmar.h b/include/linux/dmar.h
index e2433bc50210..843a41ba7e28 100644
--- a/include/linux/dmar.h
+++ b/include/linux/dmar.h
@@ -265,11 +265,6 @@ static inline void dmar_copy_shared_irte(struct irte *dst, struct irte *src)
 #define PDA_LOW_BIT    26
 #define PDA_HIGH_BIT   32
 
-enum {
-        IRQ_REMAP_XAPIC_MODE,
-        IRQ_REMAP_X2APIC_MODE,
-};
-
 /* Can't use the common MSI interrupt functions
  * since DMAR is not a pci device
  */
diff --git a/include/linux/etherdevice.h b/include/linux/etherdevice.h
index 79563840c295..572e11bb8696 100644
--- a/include/linux/etherdevice.h
+++ b/include/linux/etherdevice.h
@@ -59,8 +59,7 @@ struct net_device *devm_alloc_etherdev_mqs(struct device *dev, int sizeof_priv,
                                            unsigned int rxqs);
 #define devm_alloc_etherdev(dev, sizeof_priv) devm_alloc_etherdev_mqs(dev, sizeof_priv, 1, 1)
 
-struct sk_buff **eth_gro_receive(struct sk_buff **head,
-                                 struct sk_buff *skb);
+struct sk_buff *eth_gro_receive(struct list_head *head, struct sk_buff *skb);
 int eth_gro_complete(struct sk_buff *skb, int nhoff);
 
 /* Reserved Ethernet Addresses per IEEE 802.1Q */
diff --git a/include/linux/export.h b/include/linux/export.h
index b768d6dd3c90..ce764a5d2ee4 100644
--- a/include/linux/export.h
+++ b/include/linux/export.h
@@ -10,20 +10,7 @@
  * hackers place grumpy comments in header files.
  */
 
-#define __VMLINUX_SYMBOL(x) x
-#define __VMLINUX_SYMBOL_STR(x) #x
-
-/* Indirect, so macros are expanded before pasting. */
-#define VMLINUX_SYMBOL(x) __VMLINUX_SYMBOL(x)
-#define VMLINUX_SYMBOL_STR(x) __VMLINUX_SYMBOL_STR(x)
-
 #ifndef __ASSEMBLY__
-struct kernel_symbol
-{
-        unsigned long value;
-        const char *name;
-};
-
 #ifdef MODULE
 extern struct module __this_module;
 #define THIS_MODULE (&__this_module)
@@ -54,19 +41,58 @@ extern struct module __this_module;
 #define __CRC_SYMBOL(sym, sec)
 #endif
 
+#ifdef CONFIG_HAVE_ARCH_PREL32_RELOCATIONS
+#include <linux/compiler.h>
+/*
+ * Emit the ksymtab entry as a pair of relative references: this reduces
+ * the size by half on 64-bit architectures, and eliminates the need for
+ * absolute relocations that require runtime processing on relocatable
+ * kernels.
+ */
+#define __KSYMTAB_ENTRY(sym, sec)                                       \
+        __ADDRESSABLE(sym)                                              \
+        asm("   .section \"___ksymtab" sec "+" #sym "\", \"a\"  \n"     \
+            "   .balign 8                                       \n"     \
+            "__ksymtab_" #sym ":                                \n"     \
+            "   .long   " #sym "- .                             \n"     \
+            "   .long   __kstrtab_" #sym "- .                   \n"     \
+            "   .previous                                       \n")
+
+struct kernel_symbol {
+        int value_offset;
+        int name_offset;
+};
+#else
+#define __KSYMTAB_ENTRY(sym, sec)                                       \
+        static const struct kernel_symbol __ksymtab_##sym               \
+        __attribute__((section("___ksymtab" sec "+" #sym), used))       \
+        = { (unsigned long)&sym, __kstrtab_##sym }
+
+struct kernel_symbol {
+        unsigned long value;
+        const char *name;
+};
+#endif
+
 /* For every exported symbol, place a struct in the __ksymtab section */
 #define ___EXPORT_SYMBOL(sym, sec)                                      \
         extern typeof(sym) sym;                                         \
         __CRC_SYMBOL(sym, sec)                                          \
         static const char __kstrtab_##sym[]                             \
-        __attribute__((section("__ksymtab_strings"), aligned(1)))       \
+        __attribute__((section("__ksymtab_strings"), used, aligned(1))) \
         = #sym;                                                         \
-        static const struct kernel_symbol __ksymtab_##sym               \
-        __used                                                          \
-        __attribute__((section("___ksymtab" sec "+" #sym), used))       \
-        = { (unsigned long)&sym, __kstrtab_##sym }
+        __KSYMTAB_ENTRY(sym, sec)
+
+#if defined(__DISABLE_EXPORTS)
+
+/*
+ * Allow symbol exports to be disabled completely so that C code may
+ * be reused in other execution contexts such as the UEFI stub or the
+ * decompressor.
+ */
+#define __EXPORT_SYMBOL(sym, sec)
 
-#if defined(__KSYM_DEPS__)
+#elif defined(__KSYM_DEPS__)
 
 /*
  * For fine grained build dependencies, we want to tell the build system
diff --git a/include/linux/f2fs_fs.h b/include/linux/f2fs_fs.h
index aa5db8b5521a..f70f8ac9c4f4 100644
--- a/include/linux/f2fs_fs.h
+++ b/include/linux/f2fs_fs.h
@@ -304,11 +304,6 @@ struct f2fs_node {
  * For NAT entries
  */
 #define NAT_ENTRY_PER_BLOCK (PAGE_SIZE / sizeof(struct f2fs_nat_entry))
-#define NAT_ENTRY_BITMAP_SIZE   ((NAT_ENTRY_PER_BLOCK + 7) / 8)
-#define NAT_ENTRY_BITMAP_SIZE_ALIGNED                           \
-        ((NAT_ENTRY_BITMAP_SIZE + BITS_PER_LONG - 1) /          \
-        BITS_PER_LONG * BITS_PER_LONG)
-
 
 struct f2fs_nat_entry {
         __u8 version;           /* latest version of cached nat entry */
diff --git a/include/linux/fb.h b/include/linux/fb.h
index aa74a228bb92..3e7e75383d32 100644
--- a/include/linux/fb.h
+++ b/include/linux/fb.h
@@ -126,7 +126,7 @@ struct fb_cursor_user {
 
 /*      The resolution of the passed in fb_info about to change */ 
 #define FB_EVENT_MODE_CHANGE            0x01
-/*      The display on this fb_info is beeing suspended, no access to the
+/*      The display on this fb_info is being suspended, no access to the
  *      framebuffer is allowed any more after that call returns
  */
 #define FB_EVENT_SUSPEND                0x02
@@ -159,9 +159,9 @@ struct fb_cursor_user {
 #define FB_EVENT_FB_UNBIND              0x0E
 /*      CONSOLE-SPECIFIC: remap all consoles to new fb - for vga_switcheroo */
 #define FB_EVENT_REMAP_ALL_CONSOLE      0x0F
-/*      A hardware display blank early change occured */
+/*      A hardware display blank early change occurred */
 #define FB_EARLY_EVENT_BLANK            0x10
-/*      A hardware display blank revert early change occured */
+/*      A hardware display blank revert early change occurred */
 #define FB_R_EARLY_EVENT_BLANK          0x11
 
 struct fb_event {
@@ -650,6 +650,10 @@ extern struct fb_info *registered_fb[FB_MAX];
 extern int num_registered_fb;
 extern struct class *fb_class;
 
+#define for_each_registered_fb(i)               \
+        for (i = 0; i < FB_MAX; i++)            \
+                if (!registered_fb[i]) {} else
+
 extern int lock_fb_info(struct fb_info *info);
 
 static inline void unlock_fb_info(struct fb_info *info)
diff --git a/include/linux/file.h b/include/linux/file.h
index 279720db984a..6b2fb032416c 100644
--- a/include/linux/file.h
+++ b/include/linux/file.h
@@ -17,9 +17,12 @@ extern void fput(struct file *);
 struct file_operations;
 struct vfsmount;
 struct dentry;
+struct inode;
 struct path;
-extern struct file *alloc_file(const struct path *, fmode_t mode,
-        const struct file_operations *fop);
+extern struct file *alloc_file_pseudo(struct inode *, struct vfsmount *,
+        const char *, int flags, const struct file_operations *);
+extern struct file *alloc_file_clone(struct file *, int flags,
+        const struct file_operations *);
 
 static inline void fput_light(struct file *file, int fput_needed)
 {
@@ -78,7 +81,6 @@ extern int f_dupfd(unsigned int from, struct file *file, unsigned flags);
 extern int replace_fd(unsigned fd, struct file *file, unsigned flags);
 extern void set_close_on_exec(unsigned int fd, int flag);
 extern bool get_close_on_exec(unsigned int fd);
-extern void put_filp(struct file *);
 extern int get_unused_fd_flags(unsigned flags);
 extern void put_unused_fd(unsigned int fd);
 
diff --git a/include/linux/filter.h b/include/linux/filter.h
index c73dd7396886..6791a0ac0139 100644
--- a/include/linux/filter.h
+++ b/include/linux/filter.h
@@ -32,6 +32,7 @@ struct seccomp_data;
 struct bpf_prog_aux;
 struct xdp_rxq_info;
 struct xdp_buff;
+struct sock_reuseport;
 
 /* ArgX, context and stack frame pointer register positions. Note,
  * Arg1, Arg2, Arg3, etc are used as argument mappings of function
@@ -537,6 +538,19 @@ struct sk_msg_buff {
         struct list_head list;
 };
 
+struct bpf_redirect_info {
+        u32 ifindex;
+        u32 flags;
+        struct bpf_map *map;
+        struct bpf_map *map_to_flush;
+        u32 kern_flags;
+};
+
+DECLARE_PER_CPU(struct bpf_redirect_info, bpf_redirect_info);
+
+/* flags for bpf_redirect_info kern_flags */
+#define BPF_RI_F_RF_NO_DIRECT   BIT(0)  /* no napi_direct on return_frame */
+
 /* Compute the linear packet data range [data, data_end) which
  * will be accessed by various program types (cls_bpf, act_bpf,
  * lwt, ...). Subsystems allowing direct data access must (!)
@@ -738,6 +752,7 @@ int sk_attach_filter(struct sock_fprog *fprog, struct sock *sk);
 int sk_attach_bpf(u32 ufd, struct sock *sk);
 int sk_reuseport_attach_filter(struct sock_fprog *fprog, struct sock *sk);
 int sk_reuseport_attach_bpf(u32 ufd, struct sock *sk);
+void sk_reuseport_prog_free(struct bpf_prog *prog);
 int sk_detach_filter(struct sock *sk);
 int sk_get_filter(struct sock *sk, struct sock_filter __user *filter,
                   unsigned int len);
@@ -765,6 +780,29 @@ static inline bool bpf_dump_raw_ok(void)
 struct bpf_prog *bpf_patch_insn_single(struct bpf_prog *prog, u32 off,
                                        const struct bpf_insn *patch, u32 len);
 
+void bpf_clear_redirect_map(struct bpf_map *map);
+
+static inline bool xdp_return_frame_no_direct(void)
+{
+        struct bpf_redirect_info *ri = this_cpu_ptr(&bpf_redirect_info);
+
+        return ri->kern_flags & BPF_RI_F_RF_NO_DIRECT;
+}
+
+static inline void xdp_set_return_frame_no_direct(void)
+{
+        struct bpf_redirect_info *ri = this_cpu_ptr(&bpf_redirect_info);
+
+        ri->kern_flags |= BPF_RI_F_RF_NO_DIRECT;
+}
+
+static inline void xdp_clear_return_frame_no_direct(void)
+{
+        struct bpf_redirect_info *ri = this_cpu_ptr(&bpf_redirect_info);
+
+        ri->kern_flags &= ~BPF_RI_F_RF_NO_DIRECT;
+}
+
 static inline int xdp_ok_fwd_dev(const struct net_device *fwd,
                                  unsigned int pktlen)
 {
@@ -798,6 +836,20 @@ void bpf_warn_invalid_xdp_action(u32 act);
 struct sock *do_sk_redirect_map(struct sk_buff *skb);
 struct sock *do_msg_redirect_map(struct sk_msg_buff *md);
 
+#ifdef CONFIG_INET
+struct sock *bpf_run_sk_reuseport(struct sock_reuseport *reuse, struct sock *sk,
+                                  struct bpf_prog *prog, struct sk_buff *skb,
+                                  u32 hash);
+#else
+static inline struct sock *
+bpf_run_sk_reuseport(struct sock_reuseport *reuse, struct sock *sk,
+                     struct bpf_prog *prog, struct sk_buff *skb,
+                     u32 hash)
+{
+        return NULL;
+}
+#endif
+
 #ifdef CONFIG_BPF_JIT
 extern int bpf_jit_enable;
 extern int bpf_jit_harden;
diff --git a/include/linux/fpga/fpga-mgr.h b/include/linux/fpga/fpga-mgr.h
index eec7c2478b0d..8942e61f0028 100644
--- a/include/linux/fpga/fpga-mgr.h
+++ b/include/linux/fpga/fpga-mgr.h
@@ -77,6 +77,7 @@ enum fpga_mgr_states {
  * @sgt: scatter/gather table containing FPGA image
  * @buf: contiguous buffer containing FPGA image
  * @count: size of buf
+ * @region_id: id of target region
  * @dev: device that owns this
  * @overlay: Device Tree overlay
  */
@@ -89,6 +90,7 @@ struct fpga_image_info {
         struct sg_table *sgt;
         const char *buf;
         size_t count;
+        int region_id;
         struct device *dev;
 #ifdef CONFIG_OF
         struct device_node *overlay;
@@ -99,6 +101,7 @@ struct fpga_image_info {
  * struct fpga_manager_ops - ops for low level fpga manager drivers
  * @initial_header_size: Maximum number of bytes that should be passed into write_init
  * @state: returns an enum value of the FPGA's state
+ * @status: returns status of the FPGA, including reconfiguration error code
  * @write_init: prepare the FPGA to receive confuration data
  * @write: write count bytes of configuration data to the FPGA
  * @write_sg: write the scatter list of configuration data to the FPGA
@@ -113,6 +116,7 @@ struct fpga_image_info {
 struct fpga_manager_ops {
         size_t initial_header_size;
         enum fpga_mgr_states (*state)(struct fpga_manager *mgr);
+        u64 (*status)(struct fpga_manager *mgr);
         int (*write_init)(struct fpga_manager *mgr,
                           struct fpga_image_info *info,
                           const char *buf, size_t count);
@@ -124,12 +128,31 @@ struct fpga_manager_ops {
         const struct attribute_group **groups;
 };
 
+/* FPGA manager status: Partial/Full Reconfiguration errors */
+#define FPGA_MGR_STATUS_OPERATION_ERR           BIT(0)
+#define FPGA_MGR_STATUS_CRC_ERR                 BIT(1)
+#define FPGA_MGR_STATUS_INCOMPATIBLE_IMAGE_ERR  BIT(2)
+#define FPGA_MGR_STATUS_IP_PROTOCOL_ERR         BIT(3)
+#define FPGA_MGR_STATUS_FIFO_OVERFLOW_ERR       BIT(4)
+
+/**
+ * struct fpga_compat_id - id for compatibility check
+ *
+ * @id_h: high 64bit of the compat_id
+ * @id_l: low 64bit of the compat_id
+ */
+struct fpga_compat_id {
+        u64 id_h;
+        u64 id_l;
+};
+
 /**
  * struct fpga_manager - fpga manager structure
  * @name: name of low level fpga manager
  * @dev: fpga manager device
  * @ref_mutex: only allows one reference to fpga manager
  * @state: state of fpga manager
+ * @compat_id: FPGA manager id for compatibility check.
  * @mops: pointer to struct of fpga manager ops
  * @priv: low level driver private date
  */
@@ -138,6 +161,7 @@ struct fpga_manager {
         struct device dev;
         struct mutex ref_mutex;
         enum fpga_mgr_states state;
+        struct fpga_compat_id *compat_id;
         const struct fpga_manager_ops *mops;
         void *priv;
 };
diff --git a/include/linux/fpga/fpga-region.h b/include/linux/fpga/fpga-region.h
index d7071cddd727..0521b7f577a4 100644
--- a/include/linux/fpga/fpga-region.h
+++ b/include/linux/fpga/fpga-region.h
@@ -14,6 +14,7 @@
  * @bridge_list: list of FPGA bridges specified in region
  * @mgr: FPGA manager
  * @info: FPGA image info
+ * @compat_id: FPGA region id for compatibility check.
  * @priv: private data
  * @get_bridges: optional function to get bridges to a list
  */
@@ -23,6 +24,7 @@ struct fpga_region {
         struct list_head bridge_list;
         struct fpga_manager *mgr;
         struct fpga_image_info *info;
+        struct fpga_compat_id *compat_id;
         void *priv;
         int (*get_bridges)(struct fpga_region *region);
 };
diff --git a/include/linux/fs.h b/include/linux/fs.h
index 805bf22898cf..33322702c910 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -74,6 +74,8 @@ extern struct inodes_stat_t inodes_stat;
 extern int leases_enable, lease_break_time;
 extern int sysctl_protected_symlinks;
 extern int sysctl_protected_hardlinks;
+extern int sysctl_protected_fifos;
+extern int sysctl_protected_regular;
 
 typedef __kernel_rwf_t rwf_t;
 
@@ -148,12 +150,18 @@ typedef int (dio_iodone_t)(struct kiocb *iocb, loff_t offset,
 /* Has write method(s) */
 #define FMODE_CAN_WRITE         ((__force fmode_t)0x40000)
 
+#define FMODE_OPENED            ((__force fmode_t)0x80000)
+#define FMODE_CREATED           ((__force fmode_t)0x100000)
+
 /* File was opened by fanotify and shouldn't generate fanotify events */
 #define FMODE_NONOTIFY          ((__force fmode_t)0x4000000)
 
 /* File is capable of returning -EAGAIN if I/O will block */
 #define FMODE_NOWAIT    ((__force fmode_t)0x8000000)
 
+/* File does not contribute to nr_files count */
+#define FMODE_NOACCOUNT ((__force fmode_t)0x20000000)
+
 /*
  * Flag for rw_copy_check_uvector and compat_rw_copy_check_uvector
  * that indicates that they should check the contents of the iovec are
@@ -176,7 +184,6 @@ typedef int (dio_iodone_t)(struct kiocb *iocb, loff_t offset,
 #define ATTR_ATIME_SET  (1 << 7)
 #define ATTR_MTIME_SET  (1 << 8)
 #define ATTR_FORCE      (1 << 9) /* Not a change, but a change it */
-#define ATTR_ATTR_FLAG  (1 << 10)
 #define ATTR_KILL_SUID  (1 << 11)
 #define ATTR_KILL_SGID  (1 << 12)
 #define ATTR_FILE       (1 << 13)
@@ -275,6 +282,7 @@ struct writeback_control;
 
 /*
  * Write life time hint values.
+ * Stored in struct inode as u8.
  */
 enum rw_hint {
         WRITE_LIFE_NOT_SET      = 0,
@@ -341,6 +349,10 @@ struct address_space_operations {
         /* Set a page dirty.  Return true if this dirtied it */
         int (*set_page_dirty)(struct page *page);
 
+        /*
+         * Reads in the requested pages. Unlike ->readpage(), this is
+         * PURELY used for read-ahead!.
+         */
         int (*readpages)(struct file *filp, struct address_space *mapping,
                         struct list_head *pages, unsigned nr_pages);
 
@@ -609,8 +621,8 @@ struct inode {
         struct timespec64       i_ctime;
         spinlock_t              i_lock; /* i_blocks, i_bytes, maybe i_size */
         unsigned short          i_bytes;
-        unsigned int            i_blkbits;
-        enum rw_hint            i_write_hint;
+        u8                      i_blkbits;
+        u8                      i_write_hint;
         blkcnt_t                i_blocks;
 
 #ifdef __NEED_I_SIZE_ORDERED
@@ -685,6 +697,17 @@ static inline int inode_unhashed(struct inode *inode)
 }
 
 /*
+ * __mark_inode_dirty expects inodes to be hashed.  Since we don't
+ * want special inodes in the fileset inode space, we make them
+ * appear hashed, but do not put on any lists.  hlist_del()
+ * will work fine and require no locking.
+ */
+static inline void inode_fake_hash(struct inode *inode)
+{
+        hlist_add_fake(&inode->i_hash);
+}
+
+/*
  * inode->i_mutex nesting subclasses for the lock validator:
  *
  * 0: the object of the current VFS operation
@@ -1049,17 +1072,7 @@ struct file_lock_context {
 
 extern void send_sigio(struct fown_struct *fown, int fd, int band);
 
-/*
- * Return the inode to use for locking
- *
- * For overlayfs this should be the overlay inode, not the real inode returned
- * by file_inode().  For any other fs file_inode(filp) and locks_inode(filp) are
- * equal.
- */
-static inline struct inode *locks_inode(const struct file *f)
-{
-        return f->f_path.dentry->d_inode;
-}
+#define locks_inode(f) file_inode(f)
 
 #ifdef CONFIG_FILE_LOCKING
 extern int fcntl_getlk(struct file *, unsigned int, struct flock *);
@@ -1244,7 +1257,7 @@ static inline struct inode *file_inode(const struct file *f)
 
 static inline struct dentry *file_dentry(const struct file *file)
 {
-        return d_real(file->f_path.dentry, file_inode(file), 0, 0);
+        return d_real(file->f_path.dentry, file_inode(file));
 }
 
 static inline int locks_lock_file_wait(struct file *filp, struct file_lock *fl)
@@ -1300,7 +1313,6 @@ extern int send_sigurg(struct fown_struct *fown);
 
 /* These sb flags are internal to the kernel */
 #define SB_SUBMOUNT     (1<<26)
-#define SB_NOREMOTELOCK (1<<27)
 #define SB_NOSEC        (1<<28)
 #define SB_BORN         (1<<29)
 #define SB_ACTIVE       (1<<30)
@@ -1629,6 +1641,8 @@ int vfs_mkobj(struct dentry *, umode_t,
                 int (*f)(struct dentry *, umode_t, void *),
                 void *);
 
+extern long vfs_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
+
 /*
  * VFS file helper functions.
  */
@@ -1747,7 +1761,7 @@ struct file_operations {
                         loff_t, size_t, unsigned int);
         int (*clone_file_range)(struct file *, loff_t, struct file *, loff_t,
                         u64);
-        ssize_t (*dedupe_file_range)(struct file *, u64, u64, struct file *,
+        int (*dedupe_file_range)(struct file *, loff_t, struct file *, loff_t,
                         u64);
 } __randomize_layout;
 
@@ -1776,7 +1790,7 @@ struct inode_operations {
         int (*update_time)(struct inode *, struct timespec64 *, int);
         int (*atomic_open)(struct inode *, struct dentry *,
                            struct file *, unsigned open_flag,
-                           umode_t create_mode, int *opened);
+                           umode_t create_mode);
         int (*tmpfile) (struct inode *, struct dentry *, umode_t);
         int (*set_acl)(struct inode *, struct posix_acl *, int);
 } ____cacheline_aligned;
@@ -1820,6 +1834,10 @@ extern int vfs_dedupe_file_range_compare(struct inode *src, loff_t srcoff,
                                          loff_t len, bool *is_same);
 extern int vfs_dedupe_file_range(struct file *file,
                                  struct file_dedupe_range *same);
+extern int vfs_dedupe_file_range_one(struct file *src_file, loff_t src_pos,
+                                     struct file *dst_file, loff_t dst_pos,
+                                     u64 len);
+
 
 struct super_operations {
         struct inode *(*alloc_inode)(struct super_block *sb);
@@ -2014,6 +2032,8 @@ static inline void init_sync_kiocb(struct kiocb *kiocb, struct file *filp)
  * I_OVL_INUSE          Used by overlayfs to get exclusive ownership on upper
  *                      and work dirs among overlayfs mounts.
  *
+ * I_CREATING           New object's inode in the middle of setting up.
+ *
  * Q: What is the difference between I_WILL_FREE and I_FREEING?
  */
 #define I_DIRTY_SYNC            (1 << 0)
@@ -2034,7 +2054,8 @@ static inline void init_sync_kiocb(struct kiocb *kiocb, struct file *filp)
 #define __I_DIRTY_TIME_EXPIRED  12
 #define I_DIRTY_TIME_EXPIRED    (1 << __I_DIRTY_TIME_EXPIRED)
 #define I_WB_SWITCH             (1 << 13)
-#define I_OVL_INUSE                     (1 << 14)
+#define I_OVL_INUSE             (1 << 14)
+#define I_CREATING              (1 << 15)
 
 #define I_DIRTY_INODE (I_DIRTY_SYNC | I_DIRTY_DATASYNC)
 #define I_DIRTY (I_DIRTY_INODE | I_DIRTY_PAGES)
@@ -2075,6 +2096,7 @@ enum file_time_flags {
         S_VERSION = 8,
 };
 
+extern bool atime_needs_update(const struct path *, struct inode *);
 extern void touch_atime(const struct path *);
 static inline void file_accessed(struct file *file)
 {
@@ -2420,7 +2442,12 @@ extern struct file *filp_open(const char *, int, umode_t);
 extern struct file *file_open_root(struct dentry *, struct vfsmount *,
                                    const char *, int, umode_t);
 extern struct file * dentry_open(const struct path *, int, const struct cred *);
-extern struct file *filp_clone_open(struct file *);
+extern struct file * open_with_fake_path(const struct path *, int,
+                                         struct inode*, const struct cred *);
+static inline struct file *file_clone_open(struct file *file)
+{
+        return dentry_open(&file->f_path, file->f_flags, file->f_cred);
+}
 extern int filp_close(struct file *, fl_owner_t id);
 
 extern struct filename *getname_flags(const char __user *, int, int *);
@@ -2428,13 +2455,8 @@ extern struct filename *getname(const char __user *);
 extern struct filename *getname_kernel(const char *);
 extern void putname(struct filename *name);
 
-enum {
-        FILE_CREATED = 1,
-        FILE_OPENED = 2
-};
 extern int finish_open(struct file *file, struct dentry *dentry,
-                        int (*open)(struct inode *, struct file *),
-                        int *opened);
+                        int (*open)(struct inode *, struct file *));
 extern int finish_no_open(struct file *file, struct dentry *dentry);
 
 /* fs/ioctl.c */
@@ -2622,8 +2644,6 @@ static inline int filemap_fdatawait(struct address_space *mapping)
 
 extern bool filemap_range_has_page(struct address_space *, loff_t lstart,
                                   loff_t lend);
-extern int __must_check file_fdatawait_range(struct file *file, loff_t lstart,
-                                                loff_t lend);
 extern int filemap_write_and_wait(struct address_space *mapping);
 extern int filemap_write_and_wait_range(struct address_space *mapping,
                                         loff_t lstart, loff_t lend);
@@ -2918,6 +2938,7 @@ extern void lockdep_annotate_inode_mutex_key(struct inode *inode);
 static inline void lockdep_annotate_inode_mutex_key(struct inode *inode) { };
 #endif
 extern void unlock_new_inode(struct inode *);
+extern void discard_new_inode(struct inode *);
 extern unsigned int get_next_ino(void);
 extern void evict_inodes(struct super_block *sb);
 
diff --git a/include/linux/fsi-sbefifo.h b/include/linux/fsi-sbefifo.h
new file mode 100644
index 000000000000..13f9ebeaa25e
--- /dev/null
+++ b/include/linux/fsi-sbefifo.h
@@ -0,0 +1,33 @@
+/*
+ * SBEFIFO FSI Client device driver
+ *
+ * Copyright (C) IBM Corporation 2017
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERGCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#ifndef LINUX_FSI_SBEFIFO_H
+#define LINUX_FSI_SBEFIFO_H
+
+#define SBEFIFO_CMD_PUT_OCC_SRAM        0xa404
+#define SBEFIFO_CMD_GET_OCC_SRAM        0xa403
+#define SBEFIFO_CMD_GET_SBE_FFDC        0xa801
+
+#define SBEFIFO_MAX_FFDC_SIZE           0x2000
+
+struct device;
+
+int sbefifo_submit(struct device *dev, const __be32 *command, size_t cmd_len,
+                   __be32 *response, size_t *resp_len);
+
+int sbefifo_parse_status(struct device *dev, u16 cmd, __be32 *response,
+                         size_t resp_len, size_t *data_len);
+
+#endif /* LINUX_FSI_SBEFIFO_H */
diff --git a/include/linux/fsi.h b/include/linux/fsi.h
index 141fd38d061f..ec3be0d5b786 100644
--- a/include/linux/fsi.h
+++ b/include/linux/fsi.h
@@ -76,8 +76,18 @@ extern int fsi_slave_read(struct fsi_slave *slave, uint32_t addr,
 extern int fsi_slave_write(struct fsi_slave *slave, uint32_t addr,
                 const void *val, size_t size);
 
+extern struct bus_type fsi_bus_type;
+extern const struct device_type fsi_cdev_type;
 
+enum fsi_dev_type {
+        fsi_dev_cfam,
+        fsi_dev_sbefifo,
+        fsi_dev_scom,
+        fsi_dev_occ
+};
 
-extern struct bus_type fsi_bus_type;
+extern int fsi_get_new_minor(struct fsi_device *fdev, enum fsi_dev_type type,
+                             dev_t *out_dev, int *out_index);
+extern void fsi_free_minor(dev_t dev);
 
 #endif /* LINUX_FSI_H */
diff --git a/include/linux/fsl/ptp_qoriq.h b/include/linux/fsl/ptp_qoriq.h
index b462d9ea8007..c1f003aadcce 100644
--- a/include/linux/fsl/ptp_qoriq.h
+++ b/include/linux/fsl/ptp_qoriq.h
@@ -11,9 +11,8 @@
 
 /*
  * qoriq ptp registers
- * Generated by regen.tcl on Thu May 13 01:38:57 PM CEST 2010
  */
-struct qoriq_ptp_registers {
+struct ctrl_regs {
         u32 tmr_ctrl;     /* Timer control register */
         u32 tmr_tevent;   /* Timestamp event register */
         u32 tmr_temask;   /* Timer event mask register */
@@ -28,22 +27,47 @@ struct qoriq_ptp_registers {
         u8  res1[4];
         u32 tmroff_h;     /* Timer offset high */
         u32 tmroff_l;     /* Timer offset low */
-        u8  res2[8];
+};
+
+struct alarm_regs {
         u32 tmr_alarm1_h; /* Timer alarm 1 high register */
         u32 tmr_alarm1_l; /* Timer alarm 1 high register */
         u32 tmr_alarm2_h; /* Timer alarm 2 high register */
         u32 tmr_alarm2_l; /* Timer alarm 2 high register */
-        u8  res3[48];
+};
+
+struct fiper_regs {
         u32 tmr_fiper1;   /* Timer fixed period interval */
         u32 tmr_fiper2;   /* Timer fixed period interval */
         u32 tmr_fiper3;   /* Timer fixed period interval */
-        u8  res4[20];
+};
+
+struct etts_regs {
         u32 tmr_etts1_h;  /* Timestamp of general purpose external trigger */
         u32 tmr_etts1_l;  /* Timestamp of general purpose external trigger */
         u32 tmr_etts2_h;  /* Timestamp of general purpose external trigger */
         u32 tmr_etts2_l;  /* Timestamp of general purpose external trigger */
 };
 
+struct qoriq_ptp_registers {
+        struct ctrl_regs __iomem *ctrl_regs;
+        struct alarm_regs __iomem *alarm_regs;
+        struct fiper_regs __iomem *fiper_regs;
+        struct etts_regs __iomem *etts_regs;
+};
+
+/* Offset definitions for the four register groups */
+#define CTRL_REGS_OFFSET        0x0
+#define ALARM_REGS_OFFSET       0x40
+#define FIPER_REGS_OFFSET       0x80
+#define ETTS_REGS_OFFSET        0xa0
+
+#define FMAN_CTRL_REGS_OFFSET   0x80
+#define FMAN_ALARM_REGS_OFFSET  0xb8
+#define FMAN_FIPER_REGS_OFFSET  0xd0
+#define FMAN_ETTS_REGS_OFFSET   0xe0
+
+
 /* Bit definitions for the TMR_CTRL register */
 #define ALM1P                 (1<<31) /* Alarm1 output polarity */
 #define ALM2P                 (1<<30) /* Alarm2 output polarity */
@@ -103,12 +127,16 @@ struct qoriq_ptp_registers {
 
 
 #define DRIVER          "ptp_qoriq"
-#define DEFAULT_CKSEL   1
 #define N_EXT_TS        2
-#define REG_SIZE        sizeof(struct qoriq_ptp_registers)
+
+#define DEFAULT_CKSEL           1
+#define DEFAULT_TMR_PRSC        2
+#define DEFAULT_FIPER1_PERIOD   1000000000
+#define DEFAULT_FIPER2_PERIOD   100000
 
 struct qoriq_ptp {
-        struct qoriq_ptp_registers __iomem *regs;
+        void __iomem *base;
+        struct qoriq_ptp_registers regs;
         spinlock_t lock; /* protects regs */
         struct ptp_clock *clock;
         struct ptp_clock_info caps;
diff --git a/include/linux/fsnotify.h b/include/linux/fsnotify.h
index bdaf22582f6e..fd1ce10553bf 100644
--- a/include/linux/fsnotify.h
+++ b/include/linux/fsnotify.h
@@ -30,11 +30,7 @@ static inline int fsnotify_parent(const struct path *path, struct dentry *dentry
 static inline int fsnotify_perm(struct file *file, int mask)
 {
         const struct path *path = &file->f_path;
-        /*
-         * Do not use file_inode() here or anywhere in this file to get the
-         * inode.  That would break *notity on overlayfs.
-         */
-        struct inode *inode = path->dentry->d_inode;
+        struct inode *inode = file_inode(file);
         __u32 fsnotify_mask = 0;
         int ret;
 
@@ -178,7 +174,7 @@ static inline void fsnotify_mkdir(struct inode *inode, struct dentry *dentry)
 static inline void fsnotify_access(struct file *file)
 {
         const struct path *path = &file->f_path;
-        struct inode *inode = path->dentry->d_inode;
+        struct inode *inode = file_inode(file);
         __u32 mask = FS_ACCESS;
 
         if (S_ISDIR(inode->i_mode))
@@ -196,7 +192,7 @@ static inline void fsnotify_access(struct file *file)
 static inline void fsnotify_modify(struct file *file)
 {
         const struct path *path = &file->f_path;
-        struct inode *inode = path->dentry->d_inode;
+        struct inode *inode = file_inode(file);
         __u32 mask = FS_MODIFY;
 
         if (S_ISDIR(inode->i_mode))
@@ -214,7 +210,7 @@ static inline void fsnotify_modify(struct file *file)
 static inline void fsnotify_open(struct file *file)
 {
         const struct path *path = &file->f_path;
-        struct inode *inode = path->dentry->d_inode;
+        struct inode *inode = file_inode(file);
         __u32 mask = FS_OPEN;
 
         if (S_ISDIR(inode->i_mode))
@@ -230,7 +226,7 @@ static inline void fsnotify_open(struct file *file)
 static inline void fsnotify_close(struct file *file)
 {
         const struct path *path = &file->f_path;
-        struct inode *inode = path->dentry->d_inode;
+        struct inode *inode = file_inode(file);
         fmode_t mode = file->f_mode;
         __u32 mask = (mode & FMODE_WRITE) ? FS_CLOSE_WRITE : FS_CLOSE_NOWRITE;
 
diff --git a/include/linux/fsnotify_backend.h b/include/linux/fsnotify_backend.h
index b38964a7a521..b8f4182f42f1 100644
--- a/include/linux/fsnotify_backend.h
+++ b/include/linux/fsnotify_backend.h
@@ -84,6 +84,8 @@ struct fsnotify_event_private_data;
 struct fsnotify_fname;
 struct fsnotify_iter_info;
 
+struct mem_cgroup;
+
 /*
  * Each group much define these ops.  The fsnotify infrastructure will call
  * these operations for each relevant group.
@@ -127,6 +129,8 @@ struct fsnotify_event {
  * everything will be cleaned up.
  */
 struct fsnotify_group {
+        const struct fsnotify_ops *ops; /* how this group handles things */
+
         /*
          * How the refcnt is used is up to each group.  When the refcnt hits 0
          * fsnotify will clean up all of the resources associated with this group.
@@ -137,8 +141,6 @@ struct fsnotify_group {
          */
         refcount_t refcnt;              /* things with interest in this group */
 
-        const struct fsnotify_ops *ops; /* how this group handles things */
-
         /* needed to send notification to userspace */
         spinlock_t notification_lock;           /* protect the notification_list */
         struct list_head notification_list;     /* list of event_holder this group needs to send to userspace */
@@ -160,6 +162,8 @@ struct fsnotify_group {
         atomic_t num_marks;             /* 1 for each mark and 1 for not being
                                          * past the point of no return when freeing
                                          * a group */
+        atomic_t user_waits;            /* Number of tasks waiting for user
+                                         * response */
         struct list_head marks_list;    /* all inode marks for this group */
 
         struct fasync_struct *fsn_fa;    /* async notification */
@@ -167,8 +171,8 @@ struct fsnotify_group {
         struct fsnotify_event *overflow_event;  /* Event we queue when the
                                                  * notification list is too
                                                  * full */
-        atomic_t user_waits;            /* Number of tasks waiting for user
-                                         * response */
+
+        struct mem_cgroup *memcg;       /* memcg to charge allocations */
 
         /* groups can define private fields here or use the void *private */
         union {
@@ -210,6 +214,11 @@ enum fsnotify_obj_type {
 #define FSNOTIFY_OBJ_TYPE_VFSMOUNT_FL   (1U << FSNOTIFY_OBJ_TYPE_VFSMOUNT)
 #define FSNOTIFY_OBJ_ALL_TYPES_MASK     ((1U << FSNOTIFY_OBJ_TYPE_COUNT) - 1)
 
+static inline bool fsnotify_valid_obj_type(unsigned int type)
+{
+        return (type < FSNOTIFY_OBJ_TYPE_COUNT);
+}
+
 struct fsnotify_iter_info {
         struct fsnotify_mark *marks[FSNOTIFY_OBJ_TYPE_COUNT];
         unsigned int report_mask;
@@ -251,6 +260,13 @@ FSNOTIFY_ITER_FUNCS(vfsmount, VFSMOUNT)
         for (type = 0; type < FSNOTIFY_OBJ_TYPE_COUNT; type++)
 
 /*
+ * fsnotify_connp_t is what we embed in objects which connector can be attached
+ * to. fsnotify_connp_t * is how we refer from connector back to object.
+ */
+struct fsnotify_mark_connector;
+typedef struct fsnotify_mark_connector __rcu *fsnotify_connp_t;
+
+/*
  * Inode / vfsmount point to this structure which tracks all marks attached to
  * the inode / vfsmount. The reference to inode / vfsmount is held by this
  * structure. We destroy this structure when there are no more marks attached
@@ -259,9 +275,9 @@ FSNOTIFY_ITER_FUNCS(vfsmount, VFSMOUNT)
 struct fsnotify_mark_connector {
         spinlock_t lock;
         unsigned int type;      /* Type of object [lock] */
-        union { /* Object pointer [lock] */
-                struct inode *inode;
-                struct vfsmount *mnt;
+        union {
+                /* Object pointer [lock] */
+                fsnotify_connp_t *obj;
                 /* Used listing heads to free after srcu period expires */
                 struct fsnotify_mark_connector *destroy_next;
         };
@@ -389,32 +405,36 @@ extern struct fsnotify_event *fsnotify_remove_first_event(struct fsnotify_group
 
 /* functions used to manipulate the marks attached to inodes */
 
+/* Get mask of events for a list of marks */
+extern __u32 fsnotify_conn_mask(struct fsnotify_mark_connector *conn);
 /* Calculate mask of events for a list of marks */
 extern void fsnotify_recalc_mask(struct fsnotify_mark_connector *conn);
 extern void fsnotify_init_mark(struct fsnotify_mark *mark,
                                struct fsnotify_group *group);
 /* Find mark belonging to given group in the list of marks */
-extern struct fsnotify_mark *fsnotify_find_mark(
-                                struct fsnotify_mark_connector __rcu **connp,
-                                struct fsnotify_group *group);
-/* attach the mark to the inode or vfsmount */
-extern int fsnotify_add_mark(struct fsnotify_mark *mark, struct inode *inode,
-                             struct vfsmount *mnt, int allow_dups);
+extern struct fsnotify_mark *fsnotify_find_mark(fsnotify_connp_t *connp,
+                                                struct fsnotify_group *group);
+/* attach the mark to the object */
+extern int fsnotify_add_mark(struct fsnotify_mark *mark,
+                             fsnotify_connp_t *connp, unsigned int type,
+                             int allow_dups);
 extern int fsnotify_add_mark_locked(struct fsnotify_mark *mark,
-                                    struct inode *inode, struct vfsmount *mnt,
+                                    fsnotify_connp_t *connp, unsigned int type,
                                     int allow_dups);
 /* attach the mark to the inode */
 static inline int fsnotify_add_inode_mark(struct fsnotify_mark *mark,
                                           struct inode *inode,
                                           int allow_dups)
 {
-        return fsnotify_add_mark(mark, inode, NULL, allow_dups);
+        return fsnotify_add_mark(mark, &inode->i_fsnotify_marks,
+                                 FSNOTIFY_OBJ_TYPE_INODE, allow_dups);
 }
 static inline int fsnotify_add_inode_mark_locked(struct fsnotify_mark *mark,
                                                  struct inode *inode,
                                                  int allow_dups)
 {
-        return fsnotify_add_mark_locked(mark, inode, NULL, allow_dups);
+        return fsnotify_add_mark_locked(mark, &inode->i_fsnotify_marks,
+                                        FSNOTIFY_OBJ_TYPE_INODE, allow_dups);
 }
 /* given a group and a mark, flag mark to be freed when all references are dropped */
 extern void fsnotify_destroy_mark(struct fsnotify_mark *mark,
diff --git a/include/linux/ftrace.h b/include/linux/ftrace.h
index ebb77674be90..a397907e8d72 100644
--- a/include/linux/ftrace.h
+++ b/include/linux/ftrace.h
@@ -234,10 +234,6 @@ extern void ftrace_stub(unsigned long a0, unsigned long a1,
  */
 #define register_ftrace_function(ops) ({ 0; })
 #define unregister_ftrace_function(ops) ({ 0; })
-static inline int ftrace_nr_registered_ops(void)
-{
-        return 0;
-}
 static inline void ftrace_kill(void) { }
 static inline void ftrace_free_init_mem(void) { }
 static inline void ftrace_free_mem(struct module *mod, void *start, void *end) { }
@@ -328,8 +324,6 @@ struct seq_file;
 
 extern int ftrace_text_reserved(const void *start, const void *end);
 
-extern int ftrace_nr_registered_ops(void);
-
 struct ftrace_ops *ftrace_ops_trampoline(unsigned long addr);
 
 bool is_ftrace_trampoline(unsigned long addr);
@@ -707,16 +701,7 @@ static inline unsigned long get_lock_parent_ip(void)
         return CALLER_ADDR2;
 }
 
-#ifdef CONFIG_IRQSOFF_TRACER
-  extern void time_hardirqs_on(unsigned long a0, unsigned long a1);
-  extern void time_hardirqs_off(unsigned long a0, unsigned long a1);
-#else
-  static inline void time_hardirqs_on(unsigned long a0, unsigned long a1) { }
-  static inline void time_hardirqs_off(unsigned long a0, unsigned long a1) { }
-#endif
-
-#if defined(CONFIG_PREEMPT_TRACER) || \
-        (defined(CONFIG_DEBUG_PREEMPT) && defined(CONFIG_PREEMPTIRQ_EVENTS))
+#ifdef CONFIG_TRACE_PREEMPT_TOGGLE
   extern void trace_preempt_on(unsigned long a0, unsigned long a1);
   extern void trace_preempt_off(unsigned long a0, unsigned long a1);
 #else
diff --git a/include/linux/fwnode.h b/include/linux/fwnode.h
index 4fe8f289b3f6..faebf0ca0686 100644
--- a/include/linux/fwnode.h
+++ b/include/linux/fwnode.h
@@ -45,7 +45,7 @@ struct fwnode_endpoint {
 struct fwnode_reference_args {
         struct fwnode_handle *fwnode;
         unsigned int nargs;
-        unsigned int args[NR_FWNODE_REFERENCE_ARGS];
+        u64 args[NR_FWNODE_REFERENCE_ARGS];
 };
 
 /**
diff --git a/include/linux/genhd.h b/include/linux/genhd.h
index 6cb8a5789668..57864422a2c8 100644
--- a/include/linux/genhd.h
+++ b/include/linux/genhd.h
@@ -16,6 +16,7 @@
 #include <linux/slab.h>
 #include <linux/percpu-refcount.h>
 #include <linux/uuid.h>
+#include <linux/blk_types.h>
 
 #ifdef CONFIG_BLOCK
 
@@ -82,10 +83,10 @@ struct partition {
 } __attribute__((packed));
 
 struct disk_stats {
-        unsigned long sectors[2];       /* READs and WRITEs */
-        unsigned long ios[2];
-        unsigned long merges[2];
-        unsigned long ticks[2];
+        unsigned long sectors[NR_STAT_GROUPS];
+        unsigned long ios[NR_STAT_GROUPS];
+        unsigned long merges[NR_STAT_GROUPS];
+        unsigned long ticks[NR_STAT_GROUPS];
         unsigned long io_ticks;
         unsigned long time_in_queue;
 };
@@ -353,6 +354,11 @@ static inline void free_part_stats(struct hd_struct *part)
 
 #endif /* CONFIG_SMP */
 
+#define part_stat_read_accum(part, field)                               \
+        (part_stat_read(part, field[STAT_READ]) +                       \
+         part_stat_read(part, field[STAT_WRITE]) +                      \
+         part_stat_read(part, field[STAT_DISCARD]))
+
 #define part_stat_add(cpu, part, field, addnd)  do {                    \
         __part_stat_add((cpu), (part), field, addnd);                   \
         if ((part)->partno)                                             \
diff --git a/include/linux/gfp.h b/include/linux/gfp.h
index a6afcec53795..24bcc5eec6b4 100644
--- a/include/linux/gfp.h
+++ b/include/linux/gfp.h
@@ -59,29 +59,32 @@ struct vm_area_struct;
 #define __GFP_MOVABLE   ((__force gfp_t)___GFP_MOVABLE)  /* ZONE_MOVABLE allowed */
 #define GFP_ZONEMASK    (__GFP_DMA|__GFP_HIGHMEM|__GFP_DMA32|__GFP_MOVABLE)
 
-/*
+/**
+ * DOC: Page mobility and placement hints
+ *
  * Page mobility and placement hints
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  *
  * These flags provide hints about how mobile the page is. Pages with similar
  * mobility are placed within the same pageblocks to minimise problems due
  * to external fragmentation.
  *
- * __GFP_MOVABLE (also a zone modifier) indicates that the page can be
- *   moved by page migration during memory compaction or can be reclaimed.
+ * %__GFP_MOVABLE (also a zone modifier) indicates that the page can be
+ * moved by page migration during memory compaction or can be reclaimed.
  *
- * __GFP_RECLAIMABLE is used for slab allocations that specify
- *   SLAB_RECLAIM_ACCOUNT and whose pages can be freed via shrinkers.
+ * %__GFP_RECLAIMABLE is used for slab allocations that specify
+ * SLAB_RECLAIM_ACCOUNT and whose pages can be freed via shrinkers.
  *
- * __GFP_WRITE indicates the caller intends to dirty the page. Where possible,
- *   these pages will be spread between local zones to avoid all the dirty
- *   pages being in one zone (fair zone allocation policy).
+ * %__GFP_WRITE indicates the caller intends to dirty the page. Where possible,
+ * these pages will be spread between local zones to avoid all the dirty
+ * pages being in one zone (fair zone allocation policy).
  *
- * __GFP_HARDWALL enforces the cpuset memory allocation policy.
+ * %__GFP_HARDWALL enforces the cpuset memory allocation policy.
  *
- * __GFP_THISNODE forces the allocation to be satisified from the requested
- *   node with no fallbacks or placement policy enforcements.
+ * %__GFP_THISNODE forces the allocation to be satisified from the requested
+ * node with no fallbacks or placement policy enforcements.
  *
- * __GFP_ACCOUNT causes the allocation to be accounted to kmemcg.
+ * %__GFP_ACCOUNT causes the allocation to be accounted to kmemcg.
  */
 #define __GFP_RECLAIMABLE ((__force gfp_t)___GFP_RECLAIMABLE)
 #define __GFP_WRITE     ((__force gfp_t)___GFP_WRITE)
@@ -89,54 +92,60 @@ struct vm_area_struct;
 #define __GFP_THISNODE  ((__force gfp_t)___GFP_THISNODE)
 #define __GFP_ACCOUNT   ((__force gfp_t)___GFP_ACCOUNT)
 
-/*
+/**
+ * DOC: Watermark modifiers
+ *
  * Watermark modifiers -- controls access to emergency reserves
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  *
- * __GFP_HIGH indicates that the caller is high-priority and that granting
- *   the request is necessary before the system can make forward progress.
- *   For example, creating an IO context to clean pages.
+ * %__GFP_HIGH indicates that the caller is high-priority and that granting
+ * the request is necessary before the system can make forward progress.
+ * For example, creating an IO context to clean pages.
  *
- * __GFP_ATOMIC indicates that the caller cannot reclaim or sleep and is
- *   high priority. Users are typically interrupt handlers. This may be
- *   used in conjunction with __GFP_HIGH
+ * %__GFP_ATOMIC indicates that the caller cannot reclaim or sleep and is
+ * high priority. Users are typically interrupt handlers. This may be
+ * used in conjunction with %__GFP_HIGH
  *
- * __GFP_MEMALLOC allows access to all memory. This should only be used when
- *   the caller guarantees the allocation will allow more memory to be freed
- *   very shortly e.g. process exiting or swapping. Users either should
- *   be the MM or co-ordinating closely with the VM (e.g. swap over NFS).
+ * %__GFP_MEMALLOC allows access to all memory. This should only be used when
+ * the caller guarantees the allocation will allow more memory to be freed
+ * very shortly e.g. process exiting or swapping. Users either should
+ * be the MM or co-ordinating closely with the VM (e.g. swap over NFS).
  *
- * __GFP_NOMEMALLOC is used to explicitly forbid access to emergency reserves.
- *   This takes precedence over the __GFP_MEMALLOC flag if both are set.
+ * %__GFP_NOMEMALLOC is used to explicitly forbid access to emergency reserves.
+ * This takes precedence over the %__GFP_MEMALLOC flag if both are set.
  */
 #define __GFP_ATOMIC    ((__force gfp_t)___GFP_ATOMIC)
 #define __GFP_HIGH      ((__force gfp_t)___GFP_HIGH)
 #define __GFP_MEMALLOC  ((__force gfp_t)___GFP_MEMALLOC)
 #define __GFP_NOMEMALLOC ((__force gfp_t)___GFP_NOMEMALLOC)
 
-/*
+/**
+ * DOC: Reclaim modifiers
+ *
  * Reclaim modifiers
+ * ~~~~~~~~~~~~~~~~~
  *
- * __GFP_IO can start physical IO.
+ * %__GFP_IO can start physical IO.
  *
- * __GFP_FS can call down to the low-level FS. Clearing the flag avoids the
- *   allocator recursing into the filesystem which might already be holding
- *   locks.
+ * %__GFP_FS can call down to the low-level FS. Clearing the flag avoids the
+ * allocator recursing into the filesystem which might already be holding
+ * locks.
  *
- * __GFP_DIRECT_RECLAIM indicates that the caller may enter direct reclaim.
- *   This flag can be cleared to avoid unnecessary delays when a fallback
- *   option is available.
+ * %__GFP_DIRECT_RECLAIM indicates that the caller may enter direct reclaim.
+ * This flag can be cleared to avoid unnecessary delays when a fallback
+ * option is available.
  *
- * __GFP_KSWAPD_RECLAIM indicates that the caller wants to wake kswapd when
- *   the low watermark is reached and have it reclaim pages until the high
- *   watermark is reached. A caller may wish to clear this flag when fallback
- *   options are available and the reclaim is likely to disrupt the system. The
- *   canonical example is THP allocation where a fallback is cheap but
- *   reclaim/compaction may cause indirect stalls.
+ * %__GFP_KSWAPD_RECLAIM indicates that the caller wants to wake kswapd when
+ * the low watermark is reached and have it reclaim pages until the high
+ * watermark is reached. A caller may wish to clear this flag when fallback
+ * options are available and the reclaim is likely to disrupt the system. The
+ * canonical example is THP allocation where a fallback is cheap but
+ * reclaim/compaction may cause indirect stalls.
  *
- * __GFP_RECLAIM is shorthand to allow/forbid both direct and kswapd reclaim.
+ * %__GFP_RECLAIM is shorthand to allow/forbid both direct and kswapd reclaim.
  *
  * The default allocator behavior depends on the request size. We have a concept
- * of so called costly allocations (with order > PAGE_ALLOC_COSTLY_ORDER).
+ * of so called costly allocations (with order > %PAGE_ALLOC_COSTLY_ORDER).
  * !costly allocations are too essential to fail so they are implicitly
  * non-failing by default (with some exceptions like OOM victims might fail so
  * the caller still has to check for failures) while costly requests try to be
@@ -144,40 +153,40 @@ struct vm_area_struct;
  * The following three modifiers might be used to override some of these
  * implicit rules
  *
- * __GFP_NORETRY: The VM implementation will try only very lightweight
- *   memory direct reclaim to get some memory under memory pressure (thus
- *   it can sleep). It will avoid disruptive actions like OOM killer. The
- *   caller must handle the failure which is quite likely to happen under
- *   heavy memory pressure. The flag is suitable when failure can easily be
- *   handled at small cost, such as reduced throughput
- *
- * __GFP_RETRY_MAYFAIL: The VM implementation will retry memory reclaim
- *   procedures that have previously failed if there is some indication
- *   that progress has been made else where.  It can wait for other
- *   tasks to attempt high level approaches to freeing memory such as
- *   compaction (which removes fragmentation) and page-out.
- *   There is still a definite limit to the number of retries, but it is
- *   a larger limit than with __GFP_NORETRY.
- *   Allocations with this flag may fail, but only when there is
- *   genuinely little unused memory. While these allocations do not
- *   directly trigger the OOM killer, their failure indicates that
- *   the system is likely to need to use the OOM killer soon.  The
- *   caller must handle failure, but can reasonably do so by failing
- *   a higher-level request, or completing it only in a much less
- *   efficient manner.
- *   If the allocation does fail, and the caller is in a position to
- *   free some non-essential memory, doing so could benefit the system
- *   as a whole.
- *
- * __GFP_NOFAIL: The VM implementation _must_ retry infinitely: the caller
- *   cannot handle allocation failures. The allocation could block
- *   indefinitely but will never return with failure. Testing for
- *   failure is pointless.
- *   New users should be evaluated carefully (and the flag should be
- *   used only when there is no reasonable failure policy) but it is
- *   definitely preferable to use the flag rather than opencode endless
- *   loop around allocator.
- *   Using this flag for costly allocations is _highly_ discouraged.
+ * %__GFP_NORETRY: The VM implementation will try only very lightweight
+ * memory direct reclaim to get some memory under memory pressure (thus
+ * it can sleep). It will avoid disruptive actions like OOM killer. The
+ * caller must handle the failure which is quite likely to happen under
+ * heavy memory pressure. The flag is suitable when failure can easily be
+ * handled at small cost, such as reduced throughput
+ *
+ * %__GFP_RETRY_MAYFAIL: The VM implementation will retry memory reclaim
+ * procedures that have previously failed if there is some indication
+ * that progress has been made else where.  It can wait for other
+ * tasks to attempt high level approaches to freeing memory such as
+ * compaction (which removes fragmentation) and page-out.
+ * There is still a definite limit to the number of retries, but it is
+ * a larger limit than with %__GFP_NORETRY.
+ * Allocations with this flag may fail, but only when there is
+ * genuinely little unused memory. While these allocations do not
+ * directly trigger the OOM killer, their failure indicates that
+ * the system is likely to need to use the OOM killer soon.  The
+ * caller must handle failure, but can reasonably do so by failing
+ * a higher-level request, or completing it only in a much less
+ * efficient manner.
+ * If the allocation does fail, and the caller is in a position to
+ * free some non-essential memory, doing so could benefit the system
+ * as a whole.
+ *
+ * %__GFP_NOFAIL: The VM implementation _must_ retry infinitely: the caller
+ * cannot handle allocation failures. The allocation could block
+ * indefinitely but will never return with failure. Testing for
+ * failure is pointless.
+ * New users should be evaluated carefully (and the flag should be
+ * used only when there is no reasonable failure policy) but it is
+ * definitely preferable to use the flag rather than opencode endless
+ * loop around allocator.
+ * Using this flag for costly allocations is _highly_ discouraged.
  */
 #define __GFP_IO        ((__force gfp_t)___GFP_IO)
 #define __GFP_FS        ((__force gfp_t)___GFP_FS)
@@ -188,14 +197,17 @@ struct vm_area_struct;
 #define __GFP_NOFAIL    ((__force gfp_t)___GFP_NOFAIL)
 #define __GFP_NORETRY   ((__force gfp_t)___GFP_NORETRY)
 
-/*
+/**
+ * DOC: Action modifiers
+ *
  * Action modifiers
+ * ~~~~~~~~~~~~~~~~
  *
- * __GFP_NOWARN suppresses allocation failure reports.
+ * %__GFP_NOWARN suppresses allocation failure reports.
  *
- * __GFP_COMP address compound page metadata.
+ * %__GFP_COMP address compound page metadata.
  *
- * __GFP_ZERO returns a zeroed page on success.
+ * %__GFP_ZERO returns a zeroed page on success.
  */
 #define __GFP_NOWARN    ((__force gfp_t)___GFP_NOWARN)
 #define __GFP_COMP      ((__force gfp_t)___GFP_COMP)
@@ -208,66 +220,71 @@ struct vm_area_struct;
 #define __GFP_BITS_SHIFT (23 + IS_ENABLED(CONFIG_LOCKDEP))
 #define __GFP_BITS_MASK ((__force gfp_t)((1 << __GFP_BITS_SHIFT) - 1))
 
-/*
+/**
+ * DOC: Useful GFP flag combinations
+ *
+ * Useful GFP flag combinations
+ * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ *
  * Useful GFP flag combinations that are commonly used. It is recommended
  * that subsystems start with one of these combinations and then set/clear
- * __GFP_FOO flags as necessary.
- *
- * GFP_ATOMIC users can not sleep and need the allocation to succeed. A lower
- *   watermark is applied to allow access to "atomic reserves"
- *
- * GFP_KERNEL is typical for kernel-internal allocations. The caller requires
- *   ZONE_NORMAL or a lower zone for direct access but can direct reclaim.
- *
- * GFP_KERNEL_ACCOUNT is the same as GFP_KERNEL, except the allocation is
- *   accounted to kmemcg.
- *
- * GFP_NOWAIT is for kernel allocations that should not stall for direct
- *   reclaim, start physical IO or use any filesystem callback.
- *
- * GFP_NOIO will use direct reclaim to discard clean pages or slab pages
- *   that do not require the starting of any physical IO.
- *   Please try to avoid using this flag directly and instead use
- *   memalloc_noio_{save,restore} to mark the whole scope which cannot
- *   perform any IO with a short explanation why. All allocation requests
- *   will inherit GFP_NOIO implicitly.
- *
- * GFP_NOFS will use direct reclaim but will not use any filesystem interfaces.
- *   Please try to avoid using this flag directly and instead use
- *   memalloc_nofs_{save,restore} to mark the whole scope which cannot/shouldn't
- *   recurse into the FS layer with a short explanation why. All allocation
- *   requests will inherit GFP_NOFS implicitly.
- *
- * GFP_USER is for userspace allocations that also need to be directly
- *   accessibly by the kernel or hardware. It is typically used by hardware
- *   for buffers that are mapped to userspace (e.g. graphics) that hardware
- *   still must DMA to. cpuset limits are enforced for these allocations.
- *
- * GFP_DMA exists for historical reasons and should be avoided where possible.
- *   The flags indicates that the caller requires that the lowest zone be
- *   used (ZONE_DMA or 16M on x86-64). Ideally, this would be removed but
- *   it would require careful auditing as some users really require it and
- *   others use the flag to avoid lowmem reserves in ZONE_DMA and treat the
- *   lowest zone as a type of emergency reserve.
- *
- * GFP_DMA32 is similar to GFP_DMA except that the caller requires a 32-bit
- *   address.
- *
- * GFP_HIGHUSER is for userspace allocations that may be mapped to userspace,
- *   do not need to be directly accessible by the kernel but that cannot
- *   move once in use. An example may be a hardware allocation that maps
- *   data directly into userspace but has no addressing limitations.
- *
- * GFP_HIGHUSER_MOVABLE is for userspace allocations that the kernel does not
- *   need direct access to but can use kmap() when access is required. They
- *   are expected to be movable via page reclaim or page migration. Typically,
- *   pages on the LRU would also be allocated with GFP_HIGHUSER_MOVABLE.
- *
- * GFP_TRANSHUGE and GFP_TRANSHUGE_LIGHT are used for THP allocations. They are
- *   compound allocations that will generally fail quickly if memory is not
- *   available and will not wake kswapd/kcompactd on failure. The _LIGHT
- *   version does not attempt reclaim/compaction at all and is by default used
- *   in page fault path, while the non-light is used by khugepaged.
+ * %__GFP_FOO flags as necessary.
+ *
+ * %GFP_ATOMIC users can not sleep and need the allocation to succeed. A lower
+ * watermark is applied to allow access to "atomic reserves"
+ *
+ * %GFP_KERNEL is typical for kernel-internal allocations. The caller requires
+ * %ZONE_NORMAL or a lower zone for direct access but can direct reclaim.
+ *
+ * %GFP_KERNEL_ACCOUNT is the same as GFP_KERNEL, except the allocation is
+ * accounted to kmemcg.
+ *
+ * %GFP_NOWAIT is for kernel allocations that should not stall for direct
+ * reclaim, start physical IO or use any filesystem callback.
+ *
+ * %GFP_NOIO will use direct reclaim to discard clean pages or slab pages
+ * that do not require the starting of any physical IO.
+ * Please try to avoid using this flag directly and instead use
+ * memalloc_noio_{save,restore} to mark the whole scope which cannot
+ * perform any IO with a short explanation why. All allocation requests
+ * will inherit GFP_NOIO implicitly.
+ *
+ * %GFP_NOFS will use direct reclaim but will not use any filesystem interfaces.
+ * Please try to avoid using this flag directly and instead use
+ * memalloc_nofs_{save,restore} to mark the whole scope which cannot/shouldn't
+ * recurse into the FS layer with a short explanation why. All allocation
+ * requests will inherit GFP_NOFS implicitly.
+ *
+ * %GFP_USER is for userspace allocations that also need to be directly
+ * accessibly by the kernel or hardware. It is typically used by hardware
+ * for buffers that are mapped to userspace (e.g. graphics) that hardware
+ * still must DMA to. cpuset limits are enforced for these allocations.
+ *
+ * %GFP_DMA exists for historical reasons and should be avoided where possible.
+ * The flags indicates that the caller requires that the lowest zone be
+ * used (%ZONE_DMA or 16M on x86-64). Ideally, this would be removed but
+ * it would require careful auditing as some users really require it and
+ * others use the flag to avoid lowmem reserves in %ZONE_DMA and treat the
+ * lowest zone as a type of emergency reserve.
+ *
+ * %GFP_DMA32 is similar to %GFP_DMA except that the caller requires a 32-bit
+ * address.
+ *
+ * %GFP_HIGHUSER is for userspace allocations that may be mapped to userspace,
+ * do not need to be directly accessible by the kernel but that cannot
+ * move once in use. An example may be a hardware allocation that maps
+ * data directly into userspace but has no addressing limitations.
+ *
+ * %GFP_HIGHUSER_MOVABLE is for userspace allocations that the kernel does not
+ * need direct access to but can use kmap() when access is required. They
+ * are expected to be movable via page reclaim or page migration. Typically,
+ * pages on the LRU would also be allocated with %GFP_HIGHUSER_MOVABLE.
+ *
+ * %GFP_TRANSHUGE and %GFP_TRANSHUGE_LIGHT are used for THP allocations. They
+ * are compound allocations that will generally fail quickly if memory is not
+ * available and will not wake kswapd/kcompactd on failure. The _LIGHT
+ * version does not attempt reclaim/compaction at all and is by default used
+ * in page fault path, while the non-light is used by khugepaged.
  */
 #define GFP_ATOMIC      (__GFP_HIGH|__GFP_ATOMIC|__GFP_KSWAPD_RECLAIM)
 #define GFP_KERNEL      (__GFP_RECLAIM | __GFP_IO | __GFP_FS)
diff --git a/include/linux/gnss.h b/include/linux/gnss.h
new file mode 100644
index 000000000000..43546977098c
--- /dev/null
+++ b/include/linux/gnss.h
@@ -0,0 +1,75 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * GNSS receiver support
+ *
+ * Copyright (C) 2018 Johan Hovold <johan@kernel.org>
+ */
+
+#ifndef _LINUX_GNSS_H
+#define _LINUX_GNSS_H
+
+#include <linux/cdev.h>
+#include <linux/device.h>
+#include <linux/kfifo.h>
+#include <linux/mutex.h>
+#include <linux/rwsem.h>
+#include <linux/types.h>
+#include <linux/wait.h>
+
+struct gnss_device;
+
+enum gnss_type {
+        GNSS_TYPE_NMEA = 0,
+        GNSS_TYPE_SIRF,
+        GNSS_TYPE_UBX,
+
+        GNSS_TYPE_COUNT
+};
+
+struct gnss_operations {
+        int (*open)(struct gnss_device *gdev);
+        void (*close)(struct gnss_device *gdev);
+        int (*write_raw)(struct gnss_device *gdev, const unsigned char *buf,
+                                size_t count);
+};
+
+struct gnss_device {
+        struct device dev;
+        struct cdev cdev;
+        int id;
+
+        enum gnss_type type;
+        unsigned long flags;
+
+        struct rw_semaphore rwsem;
+        const struct gnss_operations *ops;
+        unsigned int count;
+        unsigned int disconnected:1;
+
+        struct mutex read_mutex;
+        struct kfifo read_fifo;
+        wait_queue_head_t read_queue;
+
+        struct mutex write_mutex;
+        char *write_buf;
+};
+
+struct gnss_device *gnss_allocate_device(struct device *parent);
+void gnss_put_device(struct gnss_device *gdev);
+int gnss_register_device(struct gnss_device *gdev);
+void gnss_deregister_device(struct gnss_device *gdev);
+
+int gnss_insert_raw(struct gnss_device *gdev, const unsigned char *buf,
+                        size_t count);
+
+static inline void gnss_set_drvdata(struct gnss_device *gdev, void *data)
+{
+        dev_set_drvdata(&gdev->dev, data);
+}
+
+static inline void *gnss_get_drvdata(struct gnss_device *gdev)
+{
+        return dev_get_drvdata(&gdev->dev);
+}
+
+#endif /* _LINUX_GNSS_H */
diff --git a/include/linux/goldfish.h b/include/linux/goldfish.h
index 2835c150c3ff..265a099cd3b8 100644
--- a/include/linux/goldfish.h
+++ b/include/linux/goldfish.h
@@ -2,14 +2,20 @@
 #ifndef __LINUX_GOLDFISH_H
 #define __LINUX_GOLDFISH_H
 
+#include <linux/kernel.h>
+#include <linux/types.h>
+#include <linux/io.h>
+
 /* Helpers for Goldfish virtual platform */
 
 static inline void gf_write_ptr(const void *ptr, void __iomem *portl,
                                 void __iomem *porth)
 {
-        writel((u32)(unsigned long)ptr, portl);
+        const unsigned long addr = (unsigned long)ptr;
+
+        writel(lower_32_bits(addr), portl);
 #ifdef CONFIG_64BIT
-        writel((unsigned long)ptr >> 32, porth);
+        writel(upper_32_bits(addr), porth);
 #endif
 }
 
@@ -17,9 +23,9 @@ static inline void gf_write_dma_addr(const dma_addr_t addr,
                                      void __iomem *portl,
                                      void __iomem *porth)
 {
-        writel((u32)addr, portl);
+        writel(lower_32_bits(addr), portl);
 #ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT
-        writel(addr >> 32, porth);
+        writel(upper_32_bits(addr), porth);
 #endif
 }
 
diff --git a/include/linux/gpio.h b/include/linux/gpio.h
index 91ed23468530..39745b8bdd65 100644
--- a/include/linux/gpio.h
+++ b/include/linux/gpio.h
@@ -14,7 +14,7 @@
 
 #include <linux/errno.h>
 
-/* see Documentation/gpio/gpio-legacy.txt */
+/* see Documentation/driver-api/gpio/legacy.rst */
 
 /* make these flag values available regardless of GPIO kconfig options */
 #define GPIOF_DIR_OUT   (0 << 0)
diff --git a/include/linux/gpio/aspeed.h b/include/linux/gpio/aspeed.h
new file mode 100644
index 000000000000..1bfb3cdc86d0
--- /dev/null
+++ b/include/linux/gpio/aspeed.h
@@ -0,0 +1,15 @@
+#ifndef __GPIO_ASPEED_H
+#define __GPIO_ASPEED_H
+
+struct aspeed_gpio_copro_ops {
+        int (*request_access)(void *data);
+        int (*release_access)(void *data);
+};
+
+int aspeed_gpio_copro_grab_gpio(struct gpio_desc *desc,
+                                u16 *vreg_offset, u16 *dreg_offset, u8 *bit);
+int aspeed_gpio_copro_release_gpio(struct gpio_desc *desc);
+int aspeed_gpio_copro_set_ops(const struct aspeed_gpio_copro_ops *ops, void *data);
+
+
+#endif /* __GPIO_ASPEED_H */
diff --git a/include/linux/gpio/consumer.h b/include/linux/gpio/consumer.h
index 243112c7fa7d..21ddbe440030 100644
--- a/include/linux/gpio/consumer.h
+++ b/include/linux/gpio/consumer.h
@@ -41,11 +41,8 @@ enum gpiod_flags {
         GPIOD_OUT_LOW   = GPIOD_FLAGS_BIT_DIR_SET | GPIOD_FLAGS_BIT_DIR_OUT,
         GPIOD_OUT_HIGH  = GPIOD_FLAGS_BIT_DIR_SET | GPIOD_FLAGS_BIT_DIR_OUT |
                           GPIOD_FLAGS_BIT_DIR_VAL,
-        GPIOD_OUT_LOW_OPEN_DRAIN = GPIOD_FLAGS_BIT_DIR_SET |
-                          GPIOD_FLAGS_BIT_DIR_OUT | GPIOD_FLAGS_BIT_OPEN_DRAIN,
-        GPIOD_OUT_HIGH_OPEN_DRAIN = GPIOD_FLAGS_BIT_DIR_SET |
-                          GPIOD_FLAGS_BIT_DIR_OUT | GPIOD_FLAGS_BIT_DIR_VAL |
-                          GPIOD_FLAGS_BIT_OPEN_DRAIN,
+        GPIOD_OUT_LOW_OPEN_DRAIN = GPIOD_OUT_LOW | GPIOD_FLAGS_BIT_OPEN_DRAIN,
+        GPIOD_OUT_HIGH_OPEN_DRAIN = GPIOD_OUT_HIGH | GPIOD_FLAGS_BIT_OPEN_DRAIN,
 };
 
 #ifdef CONFIG_GPIOLIB
@@ -145,6 +142,7 @@ int gpiod_is_active_low(const struct gpio_desc *desc);
 int gpiod_cansleep(const struct gpio_desc *desc);
 
 int gpiod_to_irq(const struct gpio_desc *desc);
+void gpiod_set_consumer_name(struct gpio_desc *desc, const char *name);
 
 /* Convert between the old gpio_ and new gpiod_ interfaces */
 struct gpio_desc *gpio_to_desc(unsigned gpio);
@@ -467,6 +465,12 @@ static inline int gpiod_to_irq(const struct gpio_desc *desc)
         return -EINVAL;
 }
 
+static inline void gpiod_set_consumer_name(struct gpio_desc *desc, const char *name)
+{
+        /* GPIO can never have been requested */
+        WARN_ON(1);
+}
+
 static inline struct gpio_desc *gpio_to_desc(unsigned gpio)
 {
         return ERR_PTR(-EINVAL);
diff --git a/include/linux/gpio/driver.h b/include/linux/gpio/driver.h
index 5382b5183b7e..0ea328e71ec9 100644
--- a/include/linux/gpio/driver.h
+++ b/include/linux/gpio/driver.h
@@ -201,6 +201,8 @@ static inline struct gpio_irq_chip *to_gpio_irq_chip(struct irq_chip *chip)
  * @reg_set: output set register (out=high) for generic GPIO
  * @reg_clr: output clear register (out=low) for generic GPIO
  * @reg_dir: direction setting register for generic GPIO
+ * @bgpio_dir_inverted: indicates that the direction register is inverted
+ *      (gpiolib private state variable)
  * @bgpio_bits: number of register bits used for a generic GPIO i.e.
  *      <register width> * 8
  * @bgpio_lock: used to lock chip->bgpio_data. Also, this is needed to keep
@@ -267,6 +269,7 @@ struct gpio_chip {
         void __iomem *reg_set;
         void __iomem *reg_clr;
         void __iomem *reg_dir;
+        bool bgpio_dir_inverted;
         int bgpio_bits;
         spinlock_t bgpio_lock;
         unsigned long bgpio_data;
diff --git a/include/linux/gpio_keys.h b/include/linux/gpio_keys.h
index 7160df54a6fe..3f84aeb81e48 100644
--- a/include/linux/gpio_keys.h
+++ b/include/linux/gpio_keys.h
@@ -2,6 +2,8 @@
 #ifndef _GPIO_KEYS_H
 #define _GPIO_KEYS_H
 
+#include <linux/types.h>
+
 struct device;
 
 /**
diff --git a/include/linux/hid.h b/include/linux/hid.h
index 773bcb1d4044..834e6461a690 100644
--- a/include/linux/hid.h
+++ b/include/linux/hid.h
@@ -190,6 +190,12 @@ struct hid_item {
  * http://www.usb.org/developers/hidpage/HUTRR40RadioHIDUsagesFinal.pdf
  */
 #define HID_GD_WIRELESS_RADIO_CTLS      0x0001000c
+/*
+ * System Multi-Axis, see:
+ * http://www.usb.org/developers/hidpage/HUTRR62_-_Generic_Desktop_CA_for_System_Multi-Axis_Controllers.txt
+ */
+#define HID_GD_SYSTEM_MULTIAXIS 0x0001000e
+
 #define HID_GD_X                0x00010030
 #define HID_GD_Y                0x00010031
 #define HID_GD_Z                0x00010032
@@ -638,12 +644,13 @@ static inline void hid_set_drvdata(struct hid_device *hdev, void *data)
 struct hid_parser {
         struct hid_global     global;
         struct hid_global     global_stack[HID_GLOBAL_STACK_SIZE];
-        unsigned              global_stack_ptr;
+        unsigned int          global_stack_ptr;
         struct hid_local      local;
-        unsigned              collection_stack[HID_COLLECTION_STACK_SIZE];
-        unsigned              collection_stack_ptr;
+        unsigned int         *collection_stack;
+        unsigned int          collection_stack_ptr;
+        unsigned int          collection_stack_size;
         struct hid_device    *device;
-        unsigned              scan_flags;
+        unsigned int          scan_flags;
 };
 
 struct hid_class_descriptor {
@@ -894,6 +901,8 @@ 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);
+bool hid_compare_device_paths(struct hid_device *hdev_a,
+                              struct hid_device *hdev_b, char separator);
 s32 hid_snto32(__u32 value, unsigned n);
 __u32 hid_field_extract(const struct hid_device *hid, __u8 *report,
                      unsigned offset, unsigned n);
diff --git a/include/linux/huge_mm.h b/include/linux/huge_mm.h
index a8a126259bc4..99c19b06d9a4 100644
--- a/include/linux/huge_mm.h
+++ b/include/linux/huge_mm.h
@@ -3,10 +3,11 @@
 #define _LINUX_HUGE_MM_H
 
 #include <linux/sched/coredump.h>
+#include <linux/mm_types.h>
 
 #include <linux/fs.h> /* only for vma_is_dax() */
 
-extern int do_huge_pmd_anonymous_page(struct vm_fault *vmf);
+extern vm_fault_t do_huge_pmd_anonymous_page(struct vm_fault *vmf);
 extern int copy_huge_pmd(struct mm_struct *dst_mm, struct mm_struct *src_mm,
                          pmd_t *dst_pmd, pmd_t *src_pmd, unsigned long addr,
                          struct vm_area_struct *vma);
@@ -23,7 +24,7 @@ static inline void huge_pud_set_accessed(struct vm_fault *vmf, pud_t orig_pud)
 }
 #endif
 
-extern int do_huge_pmd_wp_page(struct vm_fault *vmf, pmd_t orig_pmd);
+extern vm_fault_t do_huge_pmd_wp_page(struct vm_fault *vmf, pmd_t orig_pmd);
 extern struct page *follow_trans_huge_pmd(struct vm_area_struct *vma,
                                           unsigned long addr,
                                           pmd_t *pmd,
@@ -46,9 +47,9 @@ extern bool move_huge_pmd(struct vm_area_struct *vma, unsigned long old_addr,
 extern int change_huge_pmd(struct vm_area_struct *vma, pmd_t *pmd,
                         unsigned long addr, pgprot_t newprot,
                         int prot_numa);
-int vmf_insert_pfn_pmd(struct vm_area_struct *vma, unsigned long addr,
+vm_fault_t vmf_insert_pfn_pmd(struct vm_area_struct *vma, unsigned long addr,
                         pmd_t *pmd, pfn_t pfn, bool write);
-int vmf_insert_pfn_pud(struct vm_area_struct *vma, unsigned long addr,
+vm_fault_t vmf_insert_pfn_pud(struct vm_area_struct *vma, unsigned long addr,
                         pud_t *pud, pfn_t pfn, bool write);
 enum transparent_hugepage_flag {
         TRANSPARENT_HUGEPAGE_FLAG,
@@ -216,7 +217,7 @@ struct page *follow_devmap_pmd(struct vm_area_struct *vma, unsigned long addr,
 struct page *follow_devmap_pud(struct vm_area_struct *vma, unsigned long addr,
                 pud_t *pud, int flags);
 
-extern int do_huge_pmd_numa_page(struct vm_fault *vmf, pmd_t orig_pmd);
+extern vm_fault_t do_huge_pmd_numa_page(struct vm_fault *vmf, pmd_t orig_pmd);
 
 extern struct page *huge_zero_page;
 
@@ -321,7 +322,8 @@ static inline spinlock_t *pud_trans_huge_lock(pud_t *pud,
         return NULL;
 }
 
-static inline int do_huge_pmd_numa_page(struct vm_fault *vmf, pmd_t orig_pmd)
+static inline vm_fault_t do_huge_pmd_numa_page(struct vm_fault *vmf,
+                pmd_t orig_pmd)
 {
         return 0;
 }
diff --git a/include/linux/hugetlb.h b/include/linux/hugetlb.h
index 36fa6a2a82e3..6b68e345f0ca 100644
--- a/include/linux/hugetlb.h
+++ b/include/linux/hugetlb.h
@@ -105,7 +105,7 @@ void hugetlb_report_meminfo(struct seq_file *);
 int hugetlb_report_node_meminfo(int, char *);
 void hugetlb_show_meminfo(void);
 unsigned long hugetlb_total_pages(void);
-int hugetlb_fault(struct mm_struct *mm, struct vm_area_struct *vma,
+vm_fault_t hugetlb_fault(struct mm_struct *mm, struct vm_area_struct *vma,
                         unsigned long address, unsigned int flags);
 int hugetlb_mcopy_atomic_pte(struct mm_struct *dst_mm, pte_t *dst_pte,
                                 struct vm_area_struct *dst_vma,
@@ -348,9 +348,6 @@ struct hstate {
 struct huge_bootmem_page {
         struct list_head list;
         struct hstate *hstate;
-#ifdef CONFIG_HIGHMEM
-        phys_addr_t phys;
-#endif
 };
 
 struct page *alloc_huge_page(struct vm_area_struct *vma,
diff --git a/include/linux/hwmon.h b/include/linux/hwmon.h
index e5fd2707b6df..9493d4a388db 100644
--- a/include/linux/hwmon.h
+++ b/include/linux/hwmon.h
@@ -93,6 +93,7 @@ enum hwmon_temp_attributes {
 #define HWMON_T_MIN_ALARM       BIT(hwmon_temp_min_alarm)
 #define HWMON_T_MAX_ALARM       BIT(hwmon_temp_max_alarm)
 #define HWMON_T_CRIT_ALARM      BIT(hwmon_temp_crit_alarm)
+#define HWMON_T_LCRIT_ALARM     BIT(hwmon_temp_lcrit_alarm)
 #define HWMON_T_EMERGENCY_ALARM BIT(hwmon_temp_emergency_alarm)
 #define HWMON_T_FAULT           BIT(hwmon_temp_fault)
 #define HWMON_T_OFFSET          BIT(hwmon_temp_offset)
@@ -187,12 +188,16 @@ enum hwmon_power_attributes {
         hwmon_power_cap_hyst,
         hwmon_power_cap_max,
         hwmon_power_cap_min,
+        hwmon_power_min,
         hwmon_power_max,
         hwmon_power_crit,
+        hwmon_power_lcrit,
         hwmon_power_label,
         hwmon_power_alarm,
         hwmon_power_cap_alarm,
+        hwmon_power_min_alarm,
         hwmon_power_max_alarm,
+        hwmon_power_lcrit_alarm,
         hwmon_power_crit_alarm,
 };
 
@@ -213,12 +218,16 @@ enum hwmon_power_attributes {
 #define HWMON_P_CAP_HYST                BIT(hwmon_power_cap_hyst)
 #define HWMON_P_CAP_MAX                 BIT(hwmon_power_cap_max)
 #define HWMON_P_CAP_MIN                 BIT(hwmon_power_cap_min)
+#define HWMON_P_MIN                     BIT(hwmon_power_min)
 #define HWMON_P_MAX                     BIT(hwmon_power_max)
+#define HWMON_P_LCRIT                   BIT(hwmon_power_lcrit)
 #define HWMON_P_CRIT                    BIT(hwmon_power_crit)
 #define HWMON_P_LABEL                   BIT(hwmon_power_label)
 #define HWMON_P_ALARM                   BIT(hwmon_power_alarm)
 #define HWMON_P_CAP_ALARM               BIT(hwmon_power_cap_alarm)
+#define HWMON_P_MIN_ALARM               BIT(hwmon_power_max_alarm)
 #define HWMON_P_MAX_ALARM               BIT(hwmon_power_max_alarm)
+#define HWMON_P_LCRIT_ALARM             BIT(hwmon_power_lcrit_alarm)
 #define HWMON_P_CRIT_ALARM              BIT(hwmon_power_crit_alarm)
 
 enum hwmon_energy_attributes {
@@ -389,4 +398,27 @@ devm_hwmon_device_register_with_info(struct device *dev,
 void hwmon_device_unregister(struct device *dev);
 void devm_hwmon_device_unregister(struct device *dev);
 
+/**
+ * hwmon_is_bad_char - Is the char invalid in a hwmon name
+ * @ch: the char to be considered
+ *
+ * hwmon_is_bad_char() can be used to determine if the given character
+ * may not be used in a hwmon name.
+ *
+ * Returns true if the char is invalid, false otherwise.
+ */
+static inline bool hwmon_is_bad_char(const char ch)
+{
+        switch (ch) {
+        case '-':
+        case '*':
+        case ' ':
+        case '\t':
+        case '\n':
+                return true;
+        default:
+                return false;
+        }
+}
+
 #endif
diff --git a/include/linux/hwspinlock.h b/include/linux/hwspinlock.h
index 57537e67b468..0afe693be5f4 100644
--- a/include/linux/hwspinlock.h
+++ b/include/linux/hwspinlock.h
@@ -52,7 +52,7 @@ struct hwspinlock_pdata {
         int base_id;
 };
 
-#if defined(CONFIG_HWSPINLOCK) || defined(CONFIG_HWSPINLOCK_MODULE)
+#ifdef CONFIG_HWSPINLOCK
 
 int hwspin_lock_register(struct hwspinlock_device *bank, struct device *dev,
                 const struct hwspinlock_ops *ops, int base_id, int num_locks);
@@ -66,6 +66,17 @@ int __hwspin_lock_timeout(struct hwspinlock *, unsigned int, int,
                                                         unsigned long *);
 int __hwspin_trylock(struct hwspinlock *, int, unsigned long *);
 void __hwspin_unlock(struct hwspinlock *, int, unsigned long *);
+int of_hwspin_lock_get_id_byname(struct device_node *np, const char *name);
+int devm_hwspin_lock_free(struct device *dev, struct hwspinlock *hwlock);
+struct hwspinlock *devm_hwspin_lock_request(struct device *dev);
+struct hwspinlock *devm_hwspin_lock_request_specific(struct device *dev,
+                                                     unsigned int id);
+int devm_hwspin_lock_unregister(struct device *dev,
+                                struct hwspinlock_device *bank);
+int devm_hwspin_lock_register(struct device *dev,
+                              struct hwspinlock_device *bank,
+                              const struct hwspinlock_ops *ops,
+                              int base_id, int num_locks);
 
 #else /* !CONFIG_HWSPINLOCK */
 
@@ -125,6 +136,30 @@ static inline int hwspin_lock_get_id(struct hwspinlock *hwlock)
         return 0;
 }
 
+static inline
+int of_hwspin_lock_get_id_byname(struct device_node *np, const char *name)
+{
+        return 0;
+}
+
+static inline
+int devm_hwspin_lock_free(struct device *dev, struct hwspinlock *hwlock)
+{
+        return 0;
+}
+
+static inline struct hwspinlock *devm_hwspin_lock_request(struct device *dev)
+{
+        return ERR_PTR(-ENODEV);
+}
+
+static inline
+struct hwspinlock *devm_hwspin_lock_request_specific(struct device *dev,
+                                                     unsigned int id)
+{
+        return ERR_PTR(-ENODEV);
+}
+
 #endif /* !CONFIG_HWSPINLOCK */
 
 /**
diff --git a/include/linux/hyperv.h b/include/linux/hyperv.h
index 3a3012f57be4..efda23cf32c7 100644
--- a/include/linux/hyperv.h
+++ b/include/linux/hyperv.h
@@ -89,18 +89,33 @@ struct hv_ring_buffer {
         u32 interrupt_mask;
 
         /*
-         * Win8 uses some of the reserved bits to implement
-         * interrupt driven flow management. On the send side
-         * we can request that the receiver interrupt the sender
-         * when the ring transitions from being full to being able
-         * to handle a message of size "pending_send_sz".
+         * WS2012/Win8 and later versions of Hyper-V implement interrupt
+         * driven flow management. The feature bit feat_pending_send_sz
+         * is set by the host on the host->guest ring buffer, and by the
+         * guest on the guest->host ring buffer.
          *
-         * Add necessary state for this enhancement.
+         * The meaning of the feature bit is a bit complex in that it has
+         * semantics that apply to both ring buffers.  If the guest sets
+         * the feature bit in the guest->host ring buffer, the guest is
+         * telling the host that:
+         * 1) It will set the pending_send_sz field in the guest->host ring
+         *    buffer when it is waiting for space to become available, and
+         * 2) It will read the pending_send_sz field in the host->guest
+         *    ring buffer and interrupt the host when it frees enough space
+         *
+         * Similarly, if the host sets the feature bit in the host->guest
+         * ring buffer, the host is telling the guest that:
+         * 1) It will set the pending_send_sz field in the host->guest ring
+         *    buffer when it is waiting for space to become available, and
+         * 2) It will read the pending_send_sz field in the guest->host
+         *    ring buffer and interrupt the guest when it frees enough space
+         *
+         * If either the guest or host does not set the feature bit that it
+         * owns, that guest or host must do polling if it encounters a full
+         * ring buffer, and not signal the other end with an interrupt.
          */
         u32 pending_send_sz;
-
         u32 reserved1[12];
-
         union {
                 struct {
                         u32 feat_pending_send_sz:1;
@@ -1046,6 +1061,8 @@ extern int vmbus_establish_gpadl(struct vmbus_channel *channel,
 extern int vmbus_teardown_gpadl(struct vmbus_channel *channel,
                                      u32 gpadl_handle);
 
+void vmbus_reset_channel_cb(struct vmbus_channel *channel);
+
 extern int vmbus_recvpacket(struct vmbus_channel *channel,
                                   void *buffer,
                                   u32 bufferlen,
diff --git a/include/linux/i2c.h b/include/linux/i2c.h
index 254cd34eeae2..65b4eaed1d96 100644
--- a/include/linux/i2c.h
+++ b/include/linux/i2c.h
@@ -140,9 +140,14 @@ extern int __i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs,
    and probably just as fast.
    Note that we use i2c_adapter here, because you do not need a specific
    smbus adapter to call this function. */
-extern s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr,
-                          unsigned short flags, char read_write, u8 command,
-                          int size, union i2c_smbus_data *data);
+s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr,
+                   unsigned short flags, char read_write, u8 command,
+                   int protocol, union i2c_smbus_data *data);
+
+/* Unlocked flavor */
+s32 __i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr,
+                     unsigned short flags, char read_write, u8 command,
+                     int protocol, union i2c_smbus_data *data);
 
 /* Now follow the 'nice' access routines. These also document the calling
    conventions of i2c_smbus_xfer. */
@@ -226,7 +231,6 @@ enum i2c_alert_protocol {
 /**
  * struct i2c_driver - represent an I2C device driver
  * @class: What kind of i2c device we instantiate (for detect)
- * @attach_adapter: Callback for bus addition (deprecated)
  * @probe: Callback for device binding - soon to be deprecated
  * @probe_new: New callback for device binding
  * @remove: Callback for device unbinding
@@ -263,11 +267,6 @@ enum i2c_alert_protocol {
 struct i2c_driver {
         unsigned int class;
 
-        /* Notifies the driver that a new bus has appeared. You should avoid
-         * using this, it will be removed in a near future.
-         */
-        int (*attach_adapter)(struct i2c_adapter *) __deprecated;
-
         /* Standard driver model interfaces */
         int (*probe)(struct i2c_client *, const struct i2c_device_id *);
         int (*remove)(struct i2c_client *);
@@ -559,6 +558,7 @@ struct i2c_lock_operations {
  * @scl_fall_ns: time SCL signal takes to fall in ns; t(f) in the I2C specification
  * @scl_int_delay_ns: time IP core additionally needs to setup SCL in ns
  * @sda_fall_ns: time SDA signal takes to fall in ns; t(f) in the I2C specification
+ * @sda_hold_ns: time IP core additionally needs to hold SDA in ns
  */
 struct i2c_timings {
         u32 bus_freq_hz;
@@ -566,6 +566,7 @@ struct i2c_timings {
         u32 scl_fall_ns;
         u32 scl_int_delay_ns;
         u32 sda_fall_ns;
+        u32 sda_hold_ns;
 };
 
 /**
@@ -576,12 +577,14 @@ struct i2c_timings {
  *      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. 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.
+ * @get_sda: This gets current value of SDA line. This or set_sda() is mandatory
+ *      for generic SCL recovery. Populated internally, if sda_gpio is a valid
+ *      GPIO, for generic GPIO recovery.
+ * @set_sda: This sets/clears the SDA line. This or get_sda() is mandatory for
+ *      generic SCL recovery. Populated internally, if sda_gpio is a valid GPIO,
+ *      for generic GPIO recovery.
+ * @get_bus_free: Returns the bus free state as seen from the IP core in case it
+ *      has a more complex internal logic than just reading SDA. Optional.
  * @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
@@ -596,6 +599,7 @@ struct i2c_bus_recovery_info {
         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);
+        int (*get_bus_free)(struct i2c_adapter *adap);
 
         void (*prepare_recovery)(struct i2c_adapter *adap);
         void (*unprepare_recovery)(struct i2c_adapter *adap);
@@ -653,6 +657,10 @@ struct i2c_adapter_quirks {
                                          I2C_AQ_COMB_READ_SECOND | I2C_AQ_COMB_SAME_ADDR)
 /* clock stretching is not supported */
 #define I2C_AQ_NO_CLK_STRETCH           BIT(4)
+/* message cannot have length of 0 */
+#define I2C_AQ_NO_ZERO_LEN_READ         BIT(5)
+#define I2C_AQ_NO_ZERO_LEN_WRITE        BIT(6)
+#define I2C_AQ_NO_ZERO_LEN              (I2C_AQ_NO_ZERO_LEN_READ | I2C_AQ_NO_ZERO_LEN_WRITE)
 
 /*
  * i2c_adapter is the structure used to identify a physical i2c bus along
@@ -754,18 +762,6 @@ i2c_unlock_bus(struct i2c_adapter *adapter, unsigned int flags)
         adapter->lock_ops->unlock_bus(adapter, flags);
 }
 
-static inline void
-i2c_lock_adapter(struct i2c_adapter *adapter)
-{
-        i2c_lock_bus(adapter, I2C_LOCK_ROOT_ADAPTER);
-}
-
-static inline void
-i2c_unlock_adapter(struct i2c_adapter *adapter)
-{
-        i2c_unlock_bus(adapter, I2C_LOCK_ROOT_ADAPTER);
-}
-
 /*flags for the client struct: */
 #define I2C_CLIENT_PEC          0x04    /* Use Packet Error Checking */
 #define I2C_CLIENT_TEN          0x10    /* we have a ten bit chip address */
@@ -859,7 +855,7 @@ static inline u8 i2c_8bit_addr_from_msg(const struct i2c_msg *msg)
 }
 
 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);
+void i2c_put_dma_safe_msg_buf(u8 *buf, struct i2c_msg *msg, bool xferred);
 
 int i2c_handle_smbus_host_notify(struct i2c_adapter *adap, unsigned short addr);
 /**
diff --git a/include/linux/idle_inject.h b/include/linux/idle_inject.h
new file mode 100644
index 000000000000..bdc0293fb6cb
--- /dev/null
+++ b/include/linux/idle_inject.h
@@ -0,0 +1,29 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Copyright (C) 2018 Linaro Ltd
+ *
+ * Author: Daniel Lezcano <daniel.lezcano@linaro.org>
+ *
+ */
+#ifndef __IDLE_INJECT_H__
+#define __IDLE_INJECT_H__
+
+/* private idle injection device structure */
+struct idle_inject_device;
+
+struct idle_inject_device *idle_inject_register(struct cpumask *cpumask);
+
+void idle_inject_unregister(struct idle_inject_device *ii_dev);
+
+int idle_inject_start(struct idle_inject_device *ii_dev);
+
+void idle_inject_stop(struct idle_inject_device *ii_dev);
+
+void idle_inject_set_duration(struct idle_inject_device *ii_dev,
+                                 unsigned int run_duration_ms,
+                                 unsigned int idle_duration_ms);
+
+void idle_inject_get_duration(struct idle_inject_device *ii_dev,
+                                 unsigned int *run_duration_ms,
+                                 unsigned int *idle_duration_ms);
+#endif /* __IDLE_INJECT_H__ */
diff --git a/include/linux/idr.h b/include/linux/idr.h
index e856f4e0ab35..3ec8628ce17f 100644
--- a/include/linux/idr.h
+++ b/include/linux/idr.h
@@ -98,6 +98,17 @@ static inline void idr_set_cursor(struct idr *idr, unsigned int val)
  * period).
  */
 
+#define idr_lock(idr)           xa_lock(&(idr)->idr_rt)
+#define idr_unlock(idr)         xa_unlock(&(idr)->idr_rt)
+#define idr_lock_bh(idr)        xa_lock_bh(&(idr)->idr_rt)
+#define idr_unlock_bh(idr)      xa_unlock_bh(&(idr)->idr_rt)
+#define idr_lock_irq(idr)       xa_lock_irq(&(idr)->idr_rt)
+#define idr_unlock_irq(idr)     xa_unlock_irq(&(idr)->idr_rt)
+#define idr_lock_irqsave(idr, flags) \
+                                xa_lock_irqsave(&(idr)->idr_rt, flags)
+#define idr_unlock_irqrestore(idr, flags) \
+                                xa_unlock_irqrestore(&(idr)->idr_rt, flags)
+
 void idr_preload(gfp_t gfp_mask);
 
 int idr_alloc(struct idr *, void *ptr, int start, int end, gfp_t);
@@ -225,34 +236,74 @@ struct ida {
 }
 #define DEFINE_IDA(name)        struct ida name = IDA_INIT(name)
 
-int ida_pre_get(struct ida *ida, gfp_t gfp_mask);
-int ida_get_new_above(struct ida *ida, int starting_id, int *p_id);
-void ida_remove(struct ida *ida, int id);
+int ida_alloc_range(struct ida *, unsigned int min, unsigned int max, gfp_t);
+void ida_free(struct ida *, unsigned int id);
 void ida_destroy(struct ida *ida);
 
-int ida_simple_get(struct ida *ida, unsigned int start, unsigned int end,
-                   gfp_t gfp_mask);
-void ida_simple_remove(struct ida *ida, unsigned int id);
+/**
+ * ida_alloc() - Allocate an unused ID.
+ * @ida: IDA handle.
+ * @gfp: Memory allocation flags.
+ *
+ * Allocate an ID between 0 and %INT_MAX, inclusive.
+ *
+ * Context: Any context.
+ * Return: The allocated ID, or %-ENOMEM if memory could not be allocated,
+ * or %-ENOSPC if there are no free IDs.
+ */
+static inline int ida_alloc(struct ida *ida, gfp_t gfp)
+{
+        return ida_alloc_range(ida, 0, ~0, gfp);
+}
 
-static inline void ida_init(struct ida *ida)
+/**
+ * ida_alloc_min() - Allocate an unused ID.
+ * @ida: IDA handle.
+ * @min: Lowest ID to allocate.
+ * @gfp: Memory allocation flags.
+ *
+ * Allocate an ID between @min and %INT_MAX, inclusive.
+ *
+ * Context: Any context.
+ * Return: The allocated ID, or %-ENOMEM if memory could not be allocated,
+ * or %-ENOSPC if there are no free IDs.
+ */
+static inline int ida_alloc_min(struct ida *ida, unsigned int min, gfp_t gfp)
 {
-        INIT_RADIX_TREE(&ida->ida_rt, IDR_RT_MARKER | GFP_NOWAIT);
+        return ida_alloc_range(ida, min, ~0, gfp);
 }
 
 /**
- * ida_get_new - allocate new ID
- * @ida:        idr handle
- * @p_id:       pointer to the allocated handle
+ * ida_alloc_max() - Allocate an unused ID.
+ * @ida: IDA handle.
+ * @max: Highest ID to allocate.
+ * @gfp: Memory allocation flags.
+ *
+ * Allocate an ID between 0 and @max, inclusive.
  *
- * Simple wrapper around ida_get_new_above() w/ @starting_id of zero.
+ * Context: Any context.
+ * Return: The allocated ID, or %-ENOMEM if memory could not be allocated,
+ * or %-ENOSPC if there are no free IDs.
  */
-static inline int ida_get_new(struct ida *ida, int *p_id)
+static inline int ida_alloc_max(struct ida *ida, unsigned int max, gfp_t gfp)
 {
-        return ida_get_new_above(ida, 0, p_id);
+        return ida_alloc_range(ida, 0, max, gfp);
 }
 
+static inline void ida_init(struct ida *ida)
+{
+        INIT_RADIX_TREE(&ida->ida_rt, IDR_RT_MARKER | GFP_NOWAIT);
+}
+
+#define ida_simple_get(ida, start, end, gfp)    \
+                        ida_alloc_range(ida, start, (end) - 1, gfp)
+#define ida_simple_remove(ida, id)      ida_free(ida, id)
+
 static inline bool ida_is_empty(const struct ida *ida)
 {
         return radix_tree_empty(&ida->ida_rt);
 }
+
+/* in lib/radix-tree.c */
+int ida_pre_get(struct ida *ida, gfp_t gfp_mask);
 #endif /* __IDR_H__ */
diff --git a/include/linux/ieee80211.h b/include/linux/ieee80211.h
index 8fe7e4306816..9c03a7d5e400 100644
--- a/include/linux/ieee80211.h
+++ b/include/linux/ieee80211.h
@@ -1433,11 +1433,13 @@ struct ieee80211_ht_operation {
 #define IEEE80211_DELBA_PARAM_INITIATOR_MASK 0x0800
 
 /*
- * A-PMDU buffer sizes
- * According to IEEE802.11n spec size varies from 8K to 64K (in powers of 2)
+ * A-MPDU buffer sizes
+ * According to HT size varies from 8 to 64 frames
+ * HE adds the ability to have up to 256 frames.
  */
-#define IEEE80211_MIN_AMPDU_BUF 0x8
-#define IEEE80211_MAX_AMPDU_BUF 0x40
+#define IEEE80211_MIN_AMPDU_BUF         0x8
+#define IEEE80211_MAX_AMPDU_BUF_HT      0x40
+#define IEEE80211_MAX_AMPDU_BUF         0x100
 
 
 /* Spatial Multiplexing Power Save Modes (for capability) */
@@ -1539,6 +1541,106 @@ struct ieee80211_vht_operation {
         __le16 basic_mcs_set;
 } __packed;
 
+/**
+ * struct ieee80211_he_cap_elem - HE capabilities element
+ *
+ * This structure is the "HE capabilities element" fixed fields as
+ * described in P802.11ax_D2.0 section 9.4.2.237.2 and 9.4.2.237.3
+ */
+struct ieee80211_he_cap_elem {
+        u8 mac_cap_info[5];
+        u8 phy_cap_info[9];
+} __packed;
+
+#define IEEE80211_TX_RX_MCS_NSS_DESC_MAX_LEN    5
+
+/**
+ * enum ieee80211_he_mcs_support - HE MCS support definitions
+ * @IEEE80211_HE_MCS_SUPPORT_0_7: MCSes 0-7 are supported for the
+ *      number of streams
+ * @IEEE80211_HE_MCS_SUPPORT_0_9: MCSes 0-9 are supported
+ * @IEEE80211_HE_MCS_SUPPORT_0_11: MCSes 0-11 are supported
+ * @IEEE80211_HE_MCS_NOT_SUPPORTED: This number of streams isn't supported
+ *
+ * These definitions are used in each 2-bit subfield of the rx_mcs_*
+ * and tx_mcs_* fields of &struct ieee80211_he_mcs_nss_supp, which are
+ * both split into 8 subfields by number of streams. These values indicate
+ * which MCSes are supported for the number of streams the value appears
+ * for.
+ */
+enum ieee80211_he_mcs_support {
+        IEEE80211_HE_MCS_SUPPORT_0_7    = 0,
+        IEEE80211_HE_MCS_SUPPORT_0_9    = 1,
+        IEEE80211_HE_MCS_SUPPORT_0_11   = 2,
+        IEEE80211_HE_MCS_NOT_SUPPORTED  = 3,
+};
+
+/**
+ * struct ieee80211_he_mcs_nss_supp - HE Tx/Rx HE MCS NSS Support Field
+ *
+ * This structure holds the data required for the Tx/Rx HE MCS NSS Support Field
+ * described in P802.11ax_D2.0 section 9.4.2.237.4
+ *
+ * @rx_mcs_80: Rx MCS map 2 bits for each stream, total 8 streams, for channel
+ *     widths less than 80MHz.
+ * @tx_mcs_80: Tx MCS map 2 bits for each stream, total 8 streams, for channel
+ *     widths less than 80MHz.
+ * @rx_mcs_160: Rx MCS map 2 bits for each stream, total 8 streams, for channel
+ *     width 160MHz.
+ * @tx_mcs_160: Tx MCS map 2 bits for each stream, total 8 streams, for channel
+ *     width 160MHz.
+ * @rx_mcs_80p80: Rx MCS map 2 bits for each stream, total 8 streams, for
+ *     channel width 80p80MHz.
+ * @tx_mcs_80p80: Tx MCS map 2 bits for each stream, total 8 streams, for
+ *     channel width 80p80MHz.
+ */
+struct ieee80211_he_mcs_nss_supp {
+        __le16 rx_mcs_80;
+        __le16 tx_mcs_80;
+        __le16 rx_mcs_160;
+        __le16 tx_mcs_160;
+        __le16 rx_mcs_80p80;
+        __le16 tx_mcs_80p80;
+} __packed;
+
+/**
+ * struct ieee80211_he_operation - HE capabilities element
+ *
+ * This structure is the "HE operation element" fields as
+ * described in P802.11ax_D2.0 section 9.4.2.238
+ */
+struct ieee80211_he_operation {
+        __le32 he_oper_params;
+        __le16 he_mcs_nss_set;
+        /* Optional 0,1,3 or 4 bytes: depends on @he_oper_params */
+        u8 optional[0];
+} __packed;
+
+/**
+ * struct ieee80211_he_mu_edca_param_ac_rec - MU AC Parameter Record field
+ *
+ * This structure is the "MU AC Parameter Record" fields as
+ * described in P802.11ax_D2.0 section 9.4.2.240
+ */
+struct ieee80211_he_mu_edca_param_ac_rec {
+        u8 aifsn;
+        u8 ecw_min_max;
+        u8 mu_edca_timer;
+} __packed;
+
+/**
+ * struct ieee80211_mu_edca_param_set - MU EDCA Parameter Set element
+ *
+ * This structure is the "MU EDCA Parameter Set element" fields as
+ * described in P802.11ax_D2.0 section 9.4.2.240
+ */
+struct ieee80211_mu_edca_param_set {
+        u8 mu_qos_info;
+        struct ieee80211_he_mu_edca_param_ac_rec ac_be;
+        struct ieee80211_he_mu_edca_param_ac_rec ac_bk;
+        struct ieee80211_he_mu_edca_param_ac_rec ac_vi;
+        struct ieee80211_he_mu_edca_param_ac_rec ac_vo;
+} __packed;
 
 /* 802.11ac VHT Capabilities */
 #define IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_3895                  0x00000000
@@ -1577,6 +1679,328 @@ struct ieee80211_vht_operation {
 #define IEEE80211_VHT_CAP_RX_ANTENNA_PATTERN                    0x10000000
 #define IEEE80211_VHT_CAP_TX_ANTENNA_PATTERN                    0x20000000
 
+/* 802.11ax HE MAC capabilities */
+#define IEEE80211_HE_MAC_CAP0_HTC_HE                            0x01
+#define IEEE80211_HE_MAC_CAP0_TWT_REQ                           0x02
+#define IEEE80211_HE_MAC_CAP0_TWT_RES                           0x04
+#define IEEE80211_HE_MAC_CAP0_DYNAMIC_FRAG_NOT_SUPP             0x00
+#define IEEE80211_HE_MAC_CAP0_DYNAMIC_FRAG_LEVEL_1              0x08
+#define IEEE80211_HE_MAC_CAP0_DYNAMIC_FRAG_LEVEL_2              0x10
+#define IEEE80211_HE_MAC_CAP0_DYNAMIC_FRAG_LEVEL_3              0x18
+#define IEEE80211_HE_MAC_CAP0_DYNAMIC_FRAG_MASK                 0x18
+#define IEEE80211_HE_MAC_CAP0_MAX_NUM_FRAG_MSDU_1               0x00
+#define IEEE80211_HE_MAC_CAP0_MAX_NUM_FRAG_MSDU_2               0x20
+#define IEEE80211_HE_MAC_CAP0_MAX_NUM_FRAG_MSDU_4               0x40
+#define IEEE80211_HE_MAC_CAP0_MAX_NUM_FRAG_MSDU_8               0x60
+#define IEEE80211_HE_MAC_CAP0_MAX_NUM_FRAG_MSDU_16              0x80
+#define IEEE80211_HE_MAC_CAP0_MAX_NUM_FRAG_MSDU_32              0xa0
+#define IEEE80211_HE_MAC_CAP0_MAX_NUM_FRAG_MSDU_64              0xc0
+#define IEEE80211_HE_MAC_CAP0_MAX_NUM_FRAG_MSDU_UNLIMITED       0xe0
+#define IEEE80211_HE_MAC_CAP0_MAX_NUM_FRAG_MSDU_MASK            0xe0
+
+#define IEEE80211_HE_MAC_CAP1_MIN_FRAG_SIZE_UNLIMITED           0x00
+#define IEEE80211_HE_MAC_CAP1_MIN_FRAG_SIZE_128                 0x01
+#define IEEE80211_HE_MAC_CAP1_MIN_FRAG_SIZE_256                 0x02
+#define IEEE80211_HE_MAC_CAP1_MIN_FRAG_SIZE_512                 0x03
+#define IEEE80211_HE_MAC_CAP1_MIN_FRAG_SIZE_MASK                0x03
+#define IEEE80211_HE_MAC_CAP1_TF_MAC_PAD_DUR_0US                0x00
+#define IEEE80211_HE_MAC_CAP1_TF_MAC_PAD_DUR_8US                0x04
+#define IEEE80211_HE_MAC_CAP1_TF_MAC_PAD_DUR_16US               0x08
+#define IEEE80211_HE_MAC_CAP1_TF_MAC_PAD_DUR_MASK               0x0c
+#define IEEE80211_HE_MAC_CAP1_MULTI_TID_AGG_QOS_1               0x00
+#define IEEE80211_HE_MAC_CAP1_MULTI_TID_AGG_QOS_2               0x10
+#define IEEE80211_HE_MAC_CAP1_MULTI_TID_AGG_QOS_3               0x20
+#define IEEE80211_HE_MAC_CAP1_MULTI_TID_AGG_QOS_4               0x30
+#define IEEE80211_HE_MAC_CAP1_MULTI_TID_AGG_QOS_5               0x40
+#define IEEE80211_HE_MAC_CAP1_MULTI_TID_AGG_QOS_6               0x50
+#define IEEE80211_HE_MAC_CAP1_MULTI_TID_AGG_QOS_7               0x60
+#define IEEE80211_HE_MAC_CAP1_MULTI_TID_AGG_QOS_8               0x70
+#define IEEE80211_HE_MAC_CAP1_MULTI_TID_AGG_QOS_MASK            0x70
+
+/* Link adaptation is split between byte HE_MAC_CAP1 and
+ * HE_MAC_CAP2. It should be set only if IEEE80211_HE_MAC_CAP0_HTC_HE
+ * in which case the following values apply:
+ * 0 = No feedback.
+ * 1 = reserved.
+ * 2 = Unsolicited feedback.
+ * 3 = both
+ */
+#define IEEE80211_HE_MAC_CAP1_LINK_ADAPTATION                   0x80
+
+#define IEEE80211_HE_MAC_CAP2_LINK_ADAPTATION                   0x01
+#define IEEE80211_HE_MAC_CAP2_ALL_ACK                           0x02
+#define IEEE80211_HE_MAC_CAP2_UL_MU_RESP_SCHED                  0x04
+#define IEEE80211_HE_MAC_CAP2_BSR                               0x08
+#define IEEE80211_HE_MAC_CAP2_BCAST_TWT                         0x10
+#define IEEE80211_HE_MAC_CAP2_32BIT_BA_BITMAP                   0x20
+#define IEEE80211_HE_MAC_CAP2_MU_CASCADING                      0x40
+#define IEEE80211_HE_MAC_CAP2_ACK_EN                            0x80
+
+#define IEEE80211_HE_MAC_CAP3_GRP_ADDR_MULTI_STA_BA_DL_MU       0x01
+#define IEEE80211_HE_MAC_CAP3_OMI_CONTROL                       0x02
+#define IEEE80211_HE_MAC_CAP3_OFDMA_RA                          0x04
+
+/* The maximum length of an A-MDPU is defined by the combination of the Maximum
+ * A-MDPU Length Exponent field in the HT capabilities, VHT capabilities and the
+ * same field in the HE capabilities.
+ */
+#define IEEE80211_HE_MAC_CAP3_MAX_A_AMPDU_LEN_EXP_USE_VHT       0x00
+#define IEEE80211_HE_MAC_CAP3_MAX_A_AMPDU_LEN_EXP_VHT_1         0x08
+#define IEEE80211_HE_MAC_CAP3_MAX_A_AMPDU_LEN_EXP_VHT_2         0x10
+#define IEEE80211_HE_MAC_CAP3_MAX_A_AMPDU_LEN_EXP_RESERVED      0x18
+#define IEEE80211_HE_MAC_CAP3_MAX_A_AMPDU_LEN_EXP_MASK          0x18
+#define IEEE80211_HE_MAC_CAP3_A_AMSDU_FRAG                      0x20
+#define IEEE80211_HE_MAC_CAP3_FLEX_TWT_SCHED                    0x40
+#define IEEE80211_HE_MAC_CAP3_RX_CTRL_FRAME_TO_MULTIBSS         0x80
+
+#define IEEE80211_HE_MAC_CAP4_BSRP_BQRP_A_MPDU_AGG              0x01
+#define IEEE80211_HE_MAC_CAP4_QTP                               0x02
+#define IEEE80211_HE_MAC_CAP4_BQR                               0x04
+#define IEEE80211_HE_MAC_CAP4_SR_RESP                           0x08
+#define IEEE80211_HE_MAC_CAP4_NDP_FB_REP                        0x10
+#define IEEE80211_HE_MAC_CAP4_OPS                               0x20
+#define IEEE80211_HE_MAC_CAP4_AMDSU_IN_AMPDU                    0x40
+
+/* 802.11ax HE PHY capabilities */
+#define IEEE80211_HE_PHY_CAP0_DUAL_BAND                                 0x01
+#define IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_40MHZ_IN_2G             0x02
+#define IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_40MHZ_80MHZ_IN_5G       0x04
+#define IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_160MHZ_IN_5G            0x08
+#define IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_80PLUS80_MHZ_IN_5G      0x10
+#define IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_RU_MAPPING_IN_2G        0x20
+#define IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_RU_MAPPING_IN_5G        0x40
+#define IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_MASK                    0xfe
+
+#define IEEE80211_HE_PHY_CAP1_PREAMBLE_PUNC_RX_80MHZ_ONLY_SECOND_20MHZ  0x01
+#define IEEE80211_HE_PHY_CAP1_PREAMBLE_PUNC_RX_80MHZ_ONLY_SECOND_40MHZ  0x02
+#define IEEE80211_HE_PHY_CAP1_PREAMBLE_PUNC_RX_160MHZ_ONLY_SECOND_20MHZ 0x04
+#define IEEE80211_HE_PHY_CAP1_PREAMBLE_PUNC_RX_160MHZ_ONLY_SECOND_40MHZ 0x08
+#define IEEE80211_HE_PHY_CAP1_PREAMBLE_PUNC_RX_MASK                     0x0f
+#define IEEE80211_HE_PHY_CAP1_DEVICE_CLASS_A                            0x10
+#define IEEE80211_HE_PHY_CAP1_LDPC_CODING_IN_PAYLOAD                    0x20
+#define IEEE80211_HE_PHY_CAP1_HE_LTF_AND_GI_FOR_HE_PPDUS_0_8US          0x40
+/* Midamble RX Max NSTS is split between byte #2 and byte #3 */
+#define IEEE80211_HE_PHY_CAP1_MIDAMBLE_RX_MAX_NSTS                      0x80
+
+#define IEEE80211_HE_PHY_CAP2_MIDAMBLE_RX_MAX_NSTS                      0x01
+#define IEEE80211_HE_PHY_CAP2_NDP_4x_LTF_AND_3_2US                      0x02
+#define IEEE80211_HE_PHY_CAP2_STBC_TX_UNDER_80MHZ                       0x04
+#define IEEE80211_HE_PHY_CAP2_STBC_RX_UNDER_80MHZ                       0x08
+#define IEEE80211_HE_PHY_CAP2_DOPPLER_TX                                0x10
+#define IEEE80211_HE_PHY_CAP2_DOPPLER_RX                                0x20
+
+/* Note that the meaning of UL MU below is different between an AP and a non-AP
+ * sta, where in the AP case it indicates support for Rx and in the non-AP sta
+ * case it indicates support for Tx.
+ */
+#define IEEE80211_HE_PHY_CAP2_UL_MU_FULL_MU_MIMO                        0x40
+#define IEEE80211_HE_PHY_CAP2_UL_MU_PARTIAL_MU_MIMO                     0x80
+
+#define IEEE80211_HE_PHY_CAP3_DCM_MAX_CONST_TX_NO_DCM                   0x00
+#define IEEE80211_HE_PHY_CAP3_DCM_MAX_CONST_TX_BPSK                     0x01
+#define IEEE80211_HE_PHY_CAP3_DCM_MAX_CONST_TX_QPSK                     0x02
+#define IEEE80211_HE_PHY_CAP3_DCM_MAX_CONST_TX_16_QAM                   0x03
+#define IEEE80211_HE_PHY_CAP3_DCM_MAX_CONST_TX_MASK                     0x03
+#define IEEE80211_HE_PHY_CAP3_DCM_MAX_TX_NSS_1                          0x00
+#define IEEE80211_HE_PHY_CAP3_DCM_MAX_TX_NSS_2                          0x04
+#define IEEE80211_HE_PHY_CAP3_DCM_MAX_CONST_RX_NO_DCM                   0x00
+#define IEEE80211_HE_PHY_CAP3_DCM_MAX_CONST_RX_BPSK                     0x08
+#define IEEE80211_HE_PHY_CAP3_DCM_MAX_CONST_RX_QPSK                     0x10
+#define IEEE80211_HE_PHY_CAP3_DCM_MAX_CONST_RX_16_QAM                   0x18
+#define IEEE80211_HE_PHY_CAP3_DCM_MAX_CONST_RX_MASK                     0x18
+#define IEEE80211_HE_PHY_CAP3_DCM_MAX_RX_NSS_1                          0x00
+#define IEEE80211_HE_PHY_CAP3_DCM_MAX_RX_NSS_2                          0x20
+#define IEEE80211_HE_PHY_CAP3_RX_HE_MU_PPDU_FROM_NON_AP_STA             0x40
+#define IEEE80211_HE_PHY_CAP3_SU_BEAMFORMER                             0x80
+
+#define IEEE80211_HE_PHY_CAP4_SU_BEAMFORMEE                             0x01
+#define IEEE80211_HE_PHY_CAP4_MU_BEAMFORMER                             0x02
+
+/* Minimal allowed value of Max STS under 80MHz is 3 */
+#define IEEE80211_HE_PHY_CAP4_BEAMFORMEE_MAX_STS_UNDER_80MHZ_4          0x0c
+#define IEEE80211_HE_PHY_CAP4_BEAMFORMEE_MAX_STS_UNDER_80MHZ_5          0x10
+#define IEEE80211_HE_PHY_CAP4_BEAMFORMEE_MAX_STS_UNDER_80MHZ_6          0x14
+#define IEEE80211_HE_PHY_CAP4_BEAMFORMEE_MAX_STS_UNDER_80MHZ_7          0x18
+#define IEEE80211_HE_PHY_CAP4_BEAMFORMEE_MAX_STS_UNDER_80MHZ_8          0x1c
+#define IEEE80211_HE_PHY_CAP4_BEAMFORMEE_MAX_STS_UNDER_80MHZ_MASK       0x1c
+
+/* Minimal allowed value of Max STS above 80MHz is 3 */
+#define IEEE80211_HE_PHY_CAP4_BEAMFORMEE_MAX_STS_ABOVE_80MHZ_4          0x60
+#define IEEE80211_HE_PHY_CAP4_BEAMFORMEE_MAX_STS_ABOVE_80MHZ_5          0x80
+#define IEEE80211_HE_PHY_CAP4_BEAMFORMEE_MAX_STS_ABOVE_80MHZ_6          0xa0
+#define IEEE80211_HE_PHY_CAP4_BEAMFORMEE_MAX_STS_ABOVE_80MHZ_7          0xc0
+#define IEEE80211_HE_PHY_CAP4_BEAMFORMEE_MAX_STS_ABOVE_80MHZ_8          0xe0
+#define IEEE80211_HE_PHY_CAP4_BEAMFORMEE_MAX_STS_ABOVE_80MHZ_MASK       0xe0
+
+#define IEEE80211_HE_PHY_CAP5_BEAMFORMEE_NUM_SND_DIM_UNDER_80MHZ_1      0x00
+#define IEEE80211_HE_PHY_CAP5_BEAMFORMEE_NUM_SND_DIM_UNDER_80MHZ_2      0x01
+#define IEEE80211_HE_PHY_CAP5_BEAMFORMEE_NUM_SND_DIM_UNDER_80MHZ_3      0x02
+#define IEEE80211_HE_PHY_CAP5_BEAMFORMEE_NUM_SND_DIM_UNDER_80MHZ_4      0x03
+#define IEEE80211_HE_PHY_CAP5_BEAMFORMEE_NUM_SND_DIM_UNDER_80MHZ_5      0x04
+#define IEEE80211_HE_PHY_CAP5_BEAMFORMEE_NUM_SND_DIM_UNDER_80MHZ_6      0x05
+#define IEEE80211_HE_PHY_CAP5_BEAMFORMEE_NUM_SND_DIM_UNDER_80MHZ_7      0x06
+#define IEEE80211_HE_PHY_CAP5_BEAMFORMEE_NUM_SND_DIM_UNDER_80MHZ_8      0x07
+#define IEEE80211_HE_PHY_CAP5_BEAMFORMEE_NUM_SND_DIM_UNDER_80MHZ_MASK   0x07
+
+#define IEEE80211_HE_PHY_CAP5_BEAMFORMEE_NUM_SND_DIM_ABOVE_80MHZ_1      0x00
+#define IEEE80211_HE_PHY_CAP5_BEAMFORMEE_NUM_SND_DIM_ABOVE_80MHZ_2      0x08
+#define IEEE80211_HE_PHY_CAP5_BEAMFORMEE_NUM_SND_DIM_ABOVE_80MHZ_3      0x10
+#define IEEE80211_HE_PHY_CAP5_BEAMFORMEE_NUM_SND_DIM_ABOVE_80MHZ_4      0x18
+#define IEEE80211_HE_PHY_CAP5_BEAMFORMEE_NUM_SND_DIM_ABOVE_80MHZ_5      0x20
+#define IEEE80211_HE_PHY_CAP5_BEAMFORMEE_NUM_SND_DIM_ABOVE_80MHZ_6      0x28
+#define IEEE80211_HE_PHY_CAP5_BEAMFORMEE_NUM_SND_DIM_ABOVE_80MHZ_7      0x30
+#define IEEE80211_HE_PHY_CAP5_BEAMFORMEE_NUM_SND_DIM_ABOVE_80MHZ_8      0x38
+#define IEEE80211_HE_PHY_CAP5_BEAMFORMEE_NUM_SND_DIM_ABOVE_80MHZ_MASK   0x38
+
+#define IEEE80211_HE_PHY_CAP5_NG16_SU_FEEDBACK                          0x40
+#define IEEE80211_HE_PHY_CAP5_NG16_MU_FEEDBACK                          0x80
+
+#define IEEE80211_HE_PHY_CAP6_CODEBOOK_SIZE_42_SU                       0x01
+#define IEEE80211_HE_PHY_CAP6_CODEBOOK_SIZE_75_MU                       0x02
+#define IEEE80211_HE_PHY_CAP6_TRIG_SU_BEAMFORMER_FB                     0x04
+#define IEEE80211_HE_PHY_CAP6_TRIG_MU_BEAMFORMER_FB                     0x08
+#define IEEE80211_HE_PHY_CAP6_TRIG_CQI_FB                               0x10
+#define IEEE80211_HE_PHY_CAP6_PARTIAL_BW_EXT_RANGE                      0x20
+#define IEEE80211_HE_PHY_CAP6_PARTIAL_BANDWIDTH_DL_MUMIMO               0x40
+#define IEEE80211_HE_PHY_CAP6_PPE_THRESHOLD_PRESENT                     0x80
+
+#define IEEE80211_HE_PHY_CAP7_SRP_BASED_SR                              0x01
+#define IEEE80211_HE_PHY_CAP7_POWER_BOOST_FACTOR_AR                     0x02
+#define IEEE80211_HE_PHY_CAP7_HE_SU_MU_PPDU_4XLTF_AND_08_US_GI          0x04
+#define IEEE80211_HE_PHY_CAP7_MAX_NC_1                                  0x08
+#define IEEE80211_HE_PHY_CAP7_MAX_NC_2                                  0x10
+#define IEEE80211_HE_PHY_CAP7_MAX_NC_3                                  0x18
+#define IEEE80211_HE_PHY_CAP7_MAX_NC_4                                  0x20
+#define IEEE80211_HE_PHY_CAP7_MAX_NC_5                                  0x28
+#define IEEE80211_HE_PHY_CAP7_MAX_NC_6                                  0x30
+#define IEEE80211_HE_PHY_CAP7_MAX_NC_7                                  0x38
+#define IEEE80211_HE_PHY_CAP7_MAX_NC_MASK                               0x38
+#define IEEE80211_HE_PHY_CAP7_STBC_TX_ABOVE_80MHZ                       0x40
+#define IEEE80211_HE_PHY_CAP7_STBC_RX_ABOVE_80MHZ                       0x80
+
+#define IEEE80211_HE_PHY_CAP8_HE_ER_SU_PPDU_4XLTF_AND_08_US_GI          0x01
+#define IEEE80211_HE_PHY_CAP8_20MHZ_IN_40MHZ_HE_PPDU_IN_2G              0x02
+#define IEEE80211_HE_PHY_CAP8_20MHZ_IN_160MHZ_HE_PPDU                   0x04
+#define IEEE80211_HE_PHY_CAP8_80MHZ_IN_160MHZ_HE_PPDU                   0x08
+#define IEEE80211_HE_PHY_CAP8_HE_ER_SU_1XLTF_AND_08_US_GI               0x10
+#define IEEE80211_HE_PHY_CAP8_MIDAMBLE_RX_2X_AND_1XLTF                  0x20
+
+/* 802.11ax HE TX/RX MCS NSS Support  */
+#define IEEE80211_TX_RX_MCS_NSS_SUPP_HIGHEST_MCS_POS                    (3)
+#define IEEE80211_TX_RX_MCS_NSS_SUPP_TX_BITMAP_POS                      (6)
+#define IEEE80211_TX_RX_MCS_NSS_SUPP_RX_BITMAP_POS                      (11)
+#define IEEE80211_TX_RX_MCS_NSS_SUPP_TX_BITMAP_MASK                     0x07c0
+#define IEEE80211_TX_RX_MCS_NSS_SUPP_RX_BITMAP_MASK                     0xf800
+
+/* TX/RX HE MCS Support field Highest MCS subfield encoding */
+enum ieee80211_he_highest_mcs_supported_subfield_enc {
+        HIGHEST_MCS_SUPPORTED_MCS7 = 0,
+        HIGHEST_MCS_SUPPORTED_MCS8,
+        HIGHEST_MCS_SUPPORTED_MCS9,
+        HIGHEST_MCS_SUPPORTED_MCS10,
+        HIGHEST_MCS_SUPPORTED_MCS11,
+};
+
+/* Calculate 802.11ax HE capabilities IE Tx/Rx HE MCS NSS Support Field size */
+static inline u8
+ieee80211_he_mcs_nss_size(const struct ieee80211_he_cap_elem *he_cap)
+{
+        u8 count = 4;
+
+        if (he_cap->phy_cap_info[0] &
+            IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_160MHZ_IN_5G)
+                count += 4;
+
+        if (he_cap->phy_cap_info[0] &
+            IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_80PLUS80_MHZ_IN_5G)
+                count += 4;
+
+        return count;
+}
+
+/* 802.11ax HE PPE Thresholds */
+#define IEEE80211_PPE_THRES_NSS_SUPPORT_2NSS                    (1)
+#define IEEE80211_PPE_THRES_NSS_POS                             (0)
+#define IEEE80211_PPE_THRES_NSS_MASK                            (7)
+#define IEEE80211_PPE_THRES_RU_INDEX_BITMASK_2x966_AND_966_RU   \
+        (BIT(5) | BIT(6))
+#define IEEE80211_PPE_THRES_RU_INDEX_BITMASK_MASK               0x78
+#define IEEE80211_PPE_THRES_RU_INDEX_BITMASK_POS                (3)
+#define IEEE80211_PPE_THRES_INFO_PPET_SIZE                      (3)
+
+/*
+ * Calculate 802.11ax HE capabilities IE PPE field size
+ * Input: Header byte of ppe_thres (first byte), and HE capa IE's PHY cap u8*
+ */
+static inline u8
+ieee80211_he_ppe_size(u8 ppe_thres_hdr, const u8 *phy_cap_info)
+{
+        u8 n;
+
+        if ((phy_cap_info[6] &
+             IEEE80211_HE_PHY_CAP6_PPE_THRESHOLD_PRESENT) == 0)
+                return 0;
+
+        n = hweight8(ppe_thres_hdr &
+                     IEEE80211_PPE_THRES_RU_INDEX_BITMASK_MASK);
+        n *= (1 + ((ppe_thres_hdr & IEEE80211_PPE_THRES_NSS_MASK) >>
+                   IEEE80211_PPE_THRES_NSS_POS));
+
+        /*
+         * Each pair is 6 bits, and we need to add the 7 "header" bits to the
+         * total size.
+         */
+        n = (n * IEEE80211_PPE_THRES_INFO_PPET_SIZE * 2) + 7;
+        n = DIV_ROUND_UP(n, 8);
+
+        return n;
+}
+
+/* HE Operation defines */
+#define IEEE80211_HE_OPERATION_BSS_COLOR_MASK                   0x0000003f
+#define IEEE80211_HE_OPERATION_DFLT_PE_DURATION_MASK            0x000001c0
+#define IEEE80211_HE_OPERATION_DFLT_PE_DURATION_OFFSET          6
+#define IEEE80211_HE_OPERATION_TWT_REQUIRED                     0x00000200
+#define IEEE80211_HE_OPERATION_RTS_THRESHOLD_MASK               0x000ffc00
+#define IEEE80211_HE_OPERATION_RTS_THRESHOLD_OFFSET             10
+#define IEEE80211_HE_OPERATION_PARTIAL_BSS_COLOR                0x000100000
+#define IEEE80211_HE_OPERATION_VHT_OPER_INFO                    0x000200000
+#define IEEE80211_HE_OPERATION_MULTI_BSSID_AP                   0x10000000
+#define IEEE80211_HE_OPERATION_TX_BSSID_INDICATOR               0x20000000
+#define IEEE80211_HE_OPERATION_BSS_COLOR_DISABLED               0x40000000
+
+/*
+ * ieee80211_he_oper_size - calculate 802.11ax HE Operations IE size
+ * @he_oper_ie: byte data of the He Operations IE, stating from the the byte
+ *      after the ext ID byte. It is assumed that he_oper_ie has at least
+ *      sizeof(struct ieee80211_he_operation) bytes, checked already in
+ *      ieee802_11_parse_elems_crc()
+ * @return the actual size of the IE data (not including header), or 0 on error
+ */
+static inline u8
+ieee80211_he_oper_size(const u8 *he_oper_ie)
+{
+        struct ieee80211_he_operation *he_oper = (void *)he_oper_ie;
+        u8 oper_len = sizeof(struct ieee80211_he_operation);
+        u32 he_oper_params;
+
+        /* Make sure the input is not NULL */
+        if (!he_oper_ie)
+                return 0;
+
+        /* Calc required length */
+        he_oper_params = le32_to_cpu(he_oper->he_oper_params);
+        if (he_oper_params & IEEE80211_HE_OPERATION_VHT_OPER_INFO)
+                oper_len += 3;
+        if (he_oper_params & IEEE80211_HE_OPERATION_MULTI_BSSID_AP)
+                oper_len++;
+
+        /* Add the first byte (extension ID) to the total length */
+        oper_len++;
+
+        return oper_len;
+}
+
 /* Authentication algorithms */
 #define WLAN_AUTH_OPEN 0
 #define WLAN_AUTH_SHARED_KEY 1
@@ -1992,6 +2416,11 @@ enum ieee80211_eid_ext {
         WLAN_EID_EXT_FILS_WRAPPED_DATA = 8,
         WLAN_EID_EXT_FILS_PUBLIC_KEY = 12,
         WLAN_EID_EXT_FILS_NONCE = 13,
+        WLAN_EID_EXT_FUTURE_CHAN_GUIDANCE = 14,
+        WLAN_EID_EXT_HE_CAPABILITY = 35,
+        WLAN_EID_EXT_HE_OPERATION = 36,
+        WLAN_EID_EXT_UORA = 37,
+        WLAN_EID_EXT_HE_MU_EDCA = 38,
 };
 
 /* Action category code */
diff --git a/include/linux/if_team.h b/include/linux/if_team.h
index d95cae09dea0..ac42da56f7a2 100644
--- a/include/linux/if_team.h
+++ b/include/linux/if_team.h
@@ -74,6 +74,11 @@ struct team_port {
         long mode_priv[0];
 };
 
+static inline struct team_port *team_port_get_rcu(const struct net_device *dev)
+{
+        return rcu_dereference(dev->rx_handler_data);
+}
+
 static inline bool team_port_enabled(struct team_port *port)
 {
         return port->index != -1;
@@ -84,6 +89,19 @@ static inline bool team_port_txable(struct team_port *port)
         return port->linkup && team_port_enabled(port);
 }
 
+static inline bool team_port_dev_txable(const struct net_device *port_dev)
+{
+        struct team_port *port;
+        bool txable;
+
+        rcu_read_lock();
+        port = team_port_get_rcu(port_dev);
+        txable = port ? team_port_txable(port) : false;
+        rcu_read_unlock();
+
+        return txable;
+}
+
 #ifdef CONFIG_NET_POLL_CONTROLLER
 static inline void team_netpoll_send_skb(struct team_port *port,
                                          struct sk_buff *skb)
diff --git a/include/linux/ima.h b/include/linux/ima.h
index 0e4647e0eb60..97914a2833d1 100644
--- a/include/linux/ima.h
+++ b/include/linux/ima.h
@@ -11,14 +11,16 @@
 #define _LINUX_IMA_H
 
 #include <linux/fs.h>
+#include <linux/security.h>
 #include <linux/kexec.h>
 struct linux_binprm;
 
 #ifdef CONFIG_IMA
 extern int ima_bprm_check(struct linux_binprm *bprm);
-extern int ima_file_check(struct file *file, int mask, int opened);
+extern int ima_file_check(struct file *file, int mask);
 extern void ima_file_free(struct file *file);
 extern int ima_file_mmap(struct file *file, unsigned long prot);
+extern int ima_load_data(enum kernel_load_data_id id);
 extern int ima_read_file(struct file *file, enum kernel_read_file_id id);
 extern int ima_post_read_file(struct file *file, void *buf, loff_t size,
                               enum kernel_read_file_id id);
@@ -34,7 +36,7 @@ static inline int ima_bprm_check(struct linux_binprm *bprm)
         return 0;
 }
 
-static inline int ima_file_check(struct file *file, int mask, int opened)
+static inline int ima_file_check(struct file *file, int mask)
 {
         return 0;
 }
@@ -49,6 +51,11 @@ static inline int ima_file_mmap(struct file *file, unsigned long prot)
         return 0;
 }
 
+static inline int ima_load_data(enum kernel_load_data_id id)
+{
+        return 0;
+}
+
 static inline int ima_read_file(struct file *file, enum kernel_read_file_id id)
 {
         return 0;
diff --git a/include/linux/inetdevice.h b/include/linux/inetdevice.h
index 27650f1bff3d..c759d1cbcedd 100644
--- a/include/linux/inetdevice.h
+++ b/include/linux/inetdevice.h
@@ -93,6 +93,7 @@ static inline void ipv4_devconf_setall(struct in_device *in_dev)
 
 #define IN_DEV_FORWARD(in_dev)          IN_DEV_CONF_GET((in_dev), FORWARDING)
 #define IN_DEV_MFORWARD(in_dev)         IN_DEV_ANDCONF((in_dev), MC_FORWARDING)
+#define IN_DEV_BFORWARD(in_dev)         IN_DEV_ANDCONF((in_dev), BC_FORWARDING)
 #define IN_DEV_RPFILTER(in_dev)         IN_DEV_MAXCONF((in_dev), RP_FILTER)
 #define IN_DEV_SRC_VMARK(in_dev)        IN_DEV_ORCONF((in_dev), SRC_VMARK)
 #define IN_DEV_SOURCE_ROUTE(in_dev)     IN_DEV_ANDCONF((in_dev), \
diff --git a/include/linux/init.h b/include/linux/init.h
index bc27cf03c41e..2538d176dd1f 100644
--- a/include/linux/init.h
+++ b/include/linux/init.h
@@ -116,8 +116,24 @@
 typedef int (*initcall_t)(void);
 typedef void (*exitcall_t)(void);
 
-extern initcall_t __con_initcall_start[], __con_initcall_end[];
-extern initcall_t __security_initcall_start[], __security_initcall_end[];
+#ifdef CONFIG_HAVE_ARCH_PREL32_RELOCATIONS
+typedef int initcall_entry_t;
+
+static inline initcall_t initcall_from_entry(initcall_entry_t *entry)
+{
+        return offset_to_ptr(entry);
+}
+#else
+typedef initcall_t initcall_entry_t;
+
+static inline initcall_t initcall_from_entry(initcall_entry_t *entry)
+{
+        return *entry;
+}
+#endif
+
+extern initcall_entry_t __con_initcall_start[], __con_initcall_end[];
+extern initcall_entry_t __security_initcall_start[], __security_initcall_end[];
 
 /* Used for contructor calls. */
 typedef void (*ctor_fn_t)(void);
@@ -167,9 +183,20 @@ extern bool initcall_debug;
  * as KEEP() in the linker script.
  */
 
-#define __define_initcall(fn, id) \
+#ifdef CONFIG_HAVE_ARCH_PREL32_RELOCATIONS
+#define ___define_initcall(fn, id, __sec)                       \
+        __ADDRESSABLE(fn)                                       \
+        asm(".section   \"" #__sec ".init\", \"a\"      \n"     \
+        "__initcall_" #fn #id ":                        \n"     \
+            ".long      " #fn " - .                     \n"     \
+            ".previous                                  \n");
+#else
+#define ___define_initcall(fn, id, __sec) \
         static initcall_t __initcall_##fn##id __used \
-        __attribute__((__section__(".initcall" #id ".init"))) = fn;
+                __attribute__((__section__(#__sec ".init"))) = fn;
+#endif
+
+#define __define_initcall(fn, id) ___define_initcall(fn, id, .initcall##id)
 
 /*
  * Early initcalls run before initializing SMP.
@@ -208,13 +235,8 @@ extern bool initcall_debug;
 #define __exitcall(fn)                                          \
         static exitcall_t __exitcall_##fn __exit_call = fn
 
-#define console_initcall(fn)                                    \
-        static initcall_t __initcall_##fn                       \
-        __used __section(.con_initcall.init) = fn
-
-#define security_initcall(fn)                                   \
-        static initcall_t __initcall_##fn                       \
-        __used __section(.security_initcall.init) = fn
+#define console_initcall(fn)    ___define_initcall(fn,, .con_initcall)
+#define security_initcall(fn)   ___define_initcall(fn,, .security_initcall)
 
 struct obs_kernel_param {
         const char *str;
diff --git a/include/linux/init_task.h b/include/linux/init_task.h
index a454b8aeb938..a7083a45a26c 100644
--- a/include/linux/init_task.h
+++ b/include/linux/init_task.h
@@ -46,15 +46,6 @@ extern struct cred init_cred;
 #define INIT_CPU_TIMERS(s)
 #endif
 
-#define INIT_PID_LINK(type)                                     \
-{                                                               \
-        .node = {                                               \
-                .next = NULL,                                   \
-                .pprev = NULL,                                  \
-        },                                                      \
-        .pid = &init_struct_pid,                                \
-}
-
 #define INIT_TASK_COMM "swapper"
 
 /* Attach to the init_task data structure for proper alignment */
diff --git a/include/linux/inotify.h b/include/linux/inotify.h
index 44f9ffe72c87..6a24905f6e1e 100644
--- a/include/linux/inotify.h
+++ b/include/linux/inotify.h
@@ -18,6 +18,6 @@ extern struct ctl_table inotify_table[]; /* for sysctl */
                           IN_DELETE_SELF | IN_MOVE_SELF | IN_UNMOUNT | \
                           IN_Q_OVERFLOW | IN_IGNORED | IN_ONLYDIR | \
                           IN_DONT_FOLLOW | IN_EXCL_UNLINK | IN_MASK_ADD | \
-                          IN_ISDIR | IN_ONESHOT)
+                          IN_MASK_CREATE | IN_ISDIR | IN_ONESHOT)
 
 #endif  /* _LINUX_INOTIFY_H */
diff --git a/include/linux/integrity.h b/include/linux/integrity.h
index 858d3f4a2241..54c853ec2fd1 100644
--- a/include/linux/integrity.h
+++ b/include/linux/integrity.h
@@ -44,4 +44,17 @@ static inline void integrity_load_keys(void)
 }
 #endif /* CONFIG_INTEGRITY */
 
+#ifdef CONFIG_INTEGRITY_ASYMMETRIC_KEYS
+
+extern int integrity_kernel_module_request(char *kmod_name);
+
+#else
+
+static inline int integrity_kernel_module_request(char *kmod_name)
+{
+        return 0;
+}
+
+#endif /* CONFIG_INTEGRITY_ASYMMETRIC_KEYS */
+
 #endif /* _LINUX_INTEGRITY_H */
diff --git a/include/linux/intel-iommu.h b/include/linux/intel-iommu.h
index ef169d67df92..28004d74ae04 100644
--- a/include/linux/intel-iommu.h
+++ b/include/linux/intel-iommu.h
@@ -31,6 +31,7 @@
 #include <linux/list.h>
 #include <linux/iommu.h>
 #include <linux/io-64-nonatomic-lo-hi.h>
+#include <linux/dmar.h>
 
 #include <asm/cacheflush.h>
 #include <asm/iommu.h>
@@ -114,6 +115,7 @@
  * Extended Capability Register
  */
 
+#define ecap_dit(e)             ((e >> 41) & 0x1)
 #define ecap_pasid(e)           ((e >> 40) & 0x1)
 #define ecap_pss(e)             ((e >> 35) & 0x1f)
 #define ecap_eafs(e)            ((e >> 34) & 0x1)
@@ -284,6 +286,7 @@ enum {
 #define QI_DEV_IOTLB_SID(sid)   ((u64)((sid) & 0xffff) << 32)
 #define QI_DEV_IOTLB_QDEP(qdep) (((qdep) & 0x1f) << 16)
 #define QI_DEV_IOTLB_ADDR(addr) ((u64)(addr) & VTD_PAGE_MASK)
+#define QI_DEV_IOTLB_PFSID(pfsid) (((u64)(pfsid & 0xf) << 12) | ((u64)(pfsid & 0xfff) << 52))
 #define QI_DEV_IOTLB_SIZE       1
 #define QI_DEV_IOTLB_MAX_INVS   32
 
@@ -308,6 +311,7 @@ enum {
 #define QI_DEV_EIOTLB_PASID(p)  (((u64)p) << 32)
 #define QI_DEV_EIOTLB_SID(sid)  ((u64)((sid) & 0xffff) << 16)
 #define QI_DEV_EIOTLB_QDEP(qd)  ((u64)((qd) & 0x1f) << 4)
+#define QI_DEV_EIOTLB_PFSID(pfsid) (((u64)(pfsid & 0xf) << 12) | ((u64)(pfsid & 0xfff) << 52))
 #define QI_DEV_EIOTLB_MAX_INVS  32
 
 #define QI_PGRP_IDX(idx)        (((u64)(idx)) << 55)
@@ -385,6 +389,42 @@ struct pasid_entry;
 struct pasid_state_entry;
 struct page_req_dsc;
 
+struct dmar_domain {
+        int     nid;                    /* node id */
+
+        unsigned        iommu_refcnt[DMAR_UNITS_SUPPORTED];
+                                        /* Refcount of devices per iommu */
+
+
+        u16             iommu_did[DMAR_UNITS_SUPPORTED];
+                                        /* Domain ids per IOMMU. Use u16 since
+                                         * domain ids are 16 bit wide according
+                                         * to VT-d spec, section 9.3 */
+
+        bool has_iotlb_device;
+        struct list_head devices;       /* all devices' list */
+        struct iova_domain iovad;       /* iova's that belong to this domain */
+
+        struct dma_pte  *pgd;           /* virtual address */
+        int             gaw;            /* max guest address width */
+
+        /* adjusted guest address width, 0 is level 2 30-bit */
+        int             agaw;
+
+        int             flags;          /* flags to find out type of domain */
+
+        int             iommu_coherency;/* indicate coherency of iommu access */
+        int             iommu_snooping; /* indicate snooping control feature*/
+        int             iommu_count;    /* reference count of iommu */
+        int             iommu_superpage;/* Level of superpages supported:
+                                           0 == 4KiB (no superpages), 1 == 2MiB,
+                                           2 == 1GiB, 3 == 512GiB, 4 == 1TiB */
+        u64             max_addr;       /* maximum mapped address */
+
+        struct iommu_domain domain;     /* generic domain data structure for
+                                           iommu core */
+};
+
 struct intel_iommu {
         void __iomem    *reg; /* Pointer to hardware regs, virtual addr */
         u64             reg_phys; /* physical address of hw register set */
@@ -414,11 +454,9 @@ struct intel_iommu {
          * devices away to userspace processes (e.g. for DPDK) and don't
          * want to trust that userspace will use *only* the PASID it was
          * told to. But while it's all driver-arbitrated, we're fine. */
-        struct pasid_entry *pasid_table;
         struct pasid_state_entry *pasid_state_table;
         struct page_req_dsc *prq;
         unsigned char prq_name[16];    /* Name for PRQ interrupt */
-        struct idr pasid_idr;
         u32 pasid_max;
 #endif
         struct q_inval  *qi;            /* Queued invalidation info */
@@ -434,6 +472,27 @@ struct intel_iommu {
         u32             flags;      /* Software defined flags */
 };
 
+/* PCI domain-device relationship */
+struct device_domain_info {
+        struct list_head link;  /* link to domain siblings */
+        struct list_head global; /* link to global list */
+        struct list_head table; /* link to pasid table */
+        u8 bus;                 /* PCI bus number */
+        u8 devfn;               /* PCI devfn number */
+        u16 pfsid;              /* SRIOV physical function source ID */
+        u8 pasid_supported:3;
+        u8 pasid_enabled:1;
+        u8 pri_supported:1;
+        u8 pri_enabled:1;
+        u8 ats_supported:1;
+        u8 ats_enabled:1;
+        u8 ats_qdep;
+        struct device *dev; /* it's NULL for PCIe-to-PCI bridge */
+        struct intel_iommu *iommu; /* IOMMU used by this device */
+        struct dmar_domain *domain; /* pointer to domain */
+        struct pasid_table *pasid_table; /* pasid table */
+};
+
 static inline void __iommu_flush_cache(
         struct intel_iommu *iommu, void *addr, int size)
 {
@@ -453,16 +512,22 @@ extern void qi_flush_context(struct intel_iommu *iommu, u16 did, u16 sid,
                              u8 fm, u64 type);
 extern void qi_flush_iotlb(struct intel_iommu *iommu, u16 did, u64 addr,
                           unsigned int size_order, u64 type);
-extern void qi_flush_dev_iotlb(struct intel_iommu *iommu, u16 sid, u16 qdep,
-                               u64 addr, unsigned mask);
-
+extern void qi_flush_dev_iotlb(struct intel_iommu *iommu, u16 sid, u16 pfsid,
+                        u16 qdep, u64 addr, unsigned mask);
 extern int qi_submit_sync(struct qi_desc *desc, struct intel_iommu *iommu);
 
 extern int dmar_ir_support(void);
 
+struct dmar_domain *get_valid_domain_for_dev(struct device *dev);
+void *alloc_pgtable_page(int node);
+void free_pgtable_page(void *vaddr);
+struct intel_iommu *domain_get_iommu(struct dmar_domain *domain);
+int for_each_device_domain(int (*fn)(struct device_domain_info *info,
+                                     void *data), void *data);
+
 #ifdef CONFIG_INTEL_IOMMU_SVM
-extern int intel_svm_alloc_pasid_tables(struct intel_iommu *iommu);
-extern int intel_svm_free_pasid_tables(struct intel_iommu *iommu);
+int intel_svm_init(struct intel_iommu *iommu);
+int intel_svm_exit(struct intel_iommu *iommu);
 extern int intel_svm_enable_prq(struct intel_iommu *iommu);
 extern int intel_svm_finish_prq(struct intel_iommu *iommu);
 
@@ -486,6 +551,7 @@ struct intel_svm {
         int flags;
         int pasid;
         struct list_head devs;
+        struct list_head list;
 };
 
 extern int intel_iommu_enable_pasid(struct intel_iommu *iommu, struct intel_svm_dev *sdev);
diff --git a/include/linux/iomap.h b/include/linux/iomap.h
index a044a824da85..3555d54bf79a 100644
--- a/include/linux/iomap.h
+++ b/include/linux/iomap.h
@@ -2,6 +2,9 @@
 #ifndef LINUX_IOMAP_H
 #define LINUX_IOMAP_H 1
 
+#include <linux/atomic.h>
+#include <linux/bitmap.h>
+#include <linux/mm.h>
 #include <linux/types.h>
 
 struct address_space;
@@ -9,6 +12,7 @@ struct fiemap_extent_info;
 struct inode;
 struct iov_iter;
 struct kiocb;
+struct page;
 struct vm_area_struct;
 struct vm_fault;
 
@@ -29,6 +33,7 @@ struct vm_fault;
  */
 #define IOMAP_F_NEW             0x01    /* blocks have been newly allocated */
 #define IOMAP_F_DIRTY           0x02    /* uncommitted metadata */
+#define IOMAP_F_BUFFER_HEAD     0x04    /* file system requires buffer heads */
 
 /*
  * Flags that only need to be reported for IOMAP_REPORT requests:
@@ -55,6 +60,16 @@ struct iomap {
         u16                     flags;  /* flags for mapping */
         struct block_device     *bdev;  /* block device for I/O */
         struct dax_device       *dax_dev; /* dax_dev for dax operations */
+        void                    *inline_data;
+        void                    *private; /* filesystem private */
+
+        /*
+         * Called when finished processing a page in the mapping returned in
+         * this iomap.  At least for now this is only supported in the buffered
+         * write path.
+         */
+        void (*page_done)(struct inode *inode, loff_t pos, unsigned copied,
+                        struct page *page, struct iomap *iomap);
 };
 
 /*
@@ -86,8 +101,40 @@ struct iomap_ops {
                         ssize_t written, unsigned flags, struct iomap *iomap);
 };
 
+/*
+ * Structure allocate for each page when block size < PAGE_SIZE to track
+ * sub-page uptodate status and I/O completions.
+ */
+struct iomap_page {
+        atomic_t                read_count;
+        atomic_t                write_count;
+        DECLARE_BITMAP(uptodate, PAGE_SIZE / 512);
+};
+
+static inline struct iomap_page *to_iomap_page(struct page *page)
+{
+        if (page_has_private(page))
+                return (struct iomap_page *)page_private(page);
+        return NULL;
+}
+
 ssize_t iomap_file_buffered_write(struct kiocb *iocb, struct iov_iter *from,
                 const struct iomap_ops *ops);
+int iomap_readpage(struct page *page, const struct iomap_ops *ops);
+int iomap_readpages(struct address_space *mapping, struct list_head *pages,
+                unsigned nr_pages, const struct iomap_ops *ops);
+int iomap_set_page_dirty(struct page *page);
+int iomap_is_partially_uptodate(struct page *page, unsigned long from,
+                unsigned long count);
+int iomap_releasepage(struct page *page, gfp_t gfp_mask);
+void iomap_invalidatepage(struct page *page, unsigned int offset,
+                unsigned int len);
+#ifdef CONFIG_MIGRATION
+int iomap_migrate_page(struct address_space *mapping, struct page *newpage,
+                struct page *page, enum migrate_mode mode);
+#else
+#define iomap_migrate_page NULL
+#endif
 int iomap_file_dirty(struct inode *inode, loff_t pos, loff_t len,
                 const struct iomap_ops *ops);
 int iomap_zero_range(struct inode *inode, loff_t pos, loff_t len,
diff --git a/include/linux/iommu.h b/include/linux/iommu.h
index 19938ee6eb31..87994c265bf5 100644
--- a/include/linux/iommu.h
+++ b/include/linux/iommu.h
@@ -166,8 +166,6 @@ struct iommu_resv_region {
  * @detach_dev: detach device from an iommu domain
  * @map: map a physically contiguous memory region to an iommu domain
  * @unmap: unmap a physically contiguous memory region from an iommu domain
- * @map_sg: map a scatter-gather list of physically contiguous memory chunks
- *          to an iommu domain
  * @flush_tlb_all: Synchronously flush all hardware TLBs for this domain
  * @tlb_range_add: Add a given iova range to the flush queue for this domain
  * @tlb_sync: Flush all queued ranges from the hardware TLBs and empty flush
@@ -201,8 +199,6 @@ struct iommu_ops {
                    phys_addr_t paddr, size_t size, int prot);
         size_t (*unmap)(struct iommu_domain *domain, unsigned long iova,
                      size_t size);
-        size_t (*map_sg)(struct iommu_domain *domain, unsigned long iova,
-                         struct scatterlist *sg, unsigned int nents, int prot);
         void (*flush_iotlb_all)(struct iommu_domain *domain);
         void (*iotlb_range_add)(struct iommu_domain *domain,
                                 unsigned long iova, size_t size);
@@ -303,9 +299,8 @@ extern size_t iommu_unmap(struct iommu_domain *domain, unsigned long iova,
                           size_t size);
 extern size_t iommu_unmap_fast(struct iommu_domain *domain,
                                unsigned long iova, size_t size);
-extern size_t default_iommu_map_sg(struct iommu_domain *domain, unsigned long iova,
-                                struct scatterlist *sg,unsigned int nents,
-                                int prot);
+extern size_t iommu_map_sg(struct iommu_domain *domain, unsigned long iova,
+                           struct scatterlist *sg,unsigned int nents, int prot);
 extern phys_addr_t iommu_iova_to_phys(struct iommu_domain *domain, dma_addr_t iova);
 extern void iommu_set_fault_handler(struct iommu_domain *domain,
                         iommu_fault_handler_t handler, void *token);
@@ -378,13 +373,6 @@ static inline void iommu_tlb_sync(struct iommu_domain *domain)
                 domain->ops->iotlb_sync(domain);
 }
 
-static inline size_t iommu_map_sg(struct iommu_domain *domain,
-                                  unsigned long iova, struct scatterlist *sg,
-                                  unsigned int nents, int prot)
-{
-        return domain->ops->map_sg(domain, iova, sg, nents, prot);
-}
-
 /* PCI device grouping function */
 extern struct iommu_group *pci_device_group(struct device *dev);
 /* Generic device grouping function */
@@ -698,4 +686,11 @@ const struct iommu_ops *iommu_ops_from_fwnode(struct fwnode_handle *fwnode)
 
 #endif /* CONFIG_IOMMU_API */
 
+#ifdef CONFIG_IOMMU_DEBUGFS
+extern  struct dentry *iommu_debugfs_dir;
+void iommu_debugfs_setup(void);
+#else
+static inline void iommu_debugfs_setup(void) {}
+#endif
+
 #endif /* __LINUX_IOMMU_H */
diff --git a/include/linux/ipc.h b/include/linux/ipc.h
index 6cc2df7f7ac9..e1c9eea6015b 100644
--- a/include/linux/ipc.h
+++ b/include/linux/ipc.h
@@ -4,7 +4,7 @@
 
 #include <linux/spinlock.h>
 #include <linux/uidgid.h>
-#include <linux/rhashtable.h>
+#include <linux/rhashtable-types.h>
 #include <uapi/linux/ipc.h>
 #include <linux/refcount.h>
 
diff --git a/include/linux/ipc_namespace.h b/include/linux/ipc_namespace.h
index b5630c8eb2f3..6ab8c1bada3f 100644
--- a/include/linux/ipc_namespace.h
+++ b/include/linux/ipc_namespace.h
@@ -9,17 +9,16 @@
 #include <linux/nsproxy.h>
 #include <linux/ns_common.h>
 #include <linux/refcount.h>
-#include <linux/rhashtable.h>
+#include <linux/rhashtable-types.h>
 
 struct user_namespace;
 
 struct ipc_ids {
         int in_use;
         unsigned short seq;
-        bool tables_initialized;
         struct rw_semaphore rwsem;
         struct idr ipcs_idr;
-        int max_id;
+        int max_idx;
 #ifdef CONFIG_CHECKPOINT_RESTORE
         int next_id;
 #endif
diff --git a/include/linux/irqchip/arm-gic-v3.h b/include/linux/irqchip/arm-gic-v3.h
index 9d2ea3e907d0..8bdbb5f29494 100644
--- a/include/linux/irqchip/arm-gic-v3.h
+++ b/include/linux/irqchip/arm-gic-v3.h
@@ -61,6 +61,16 @@
 #define GICD_CTLR_ENABLE_G1A            (1U << 1)
 #define GICD_CTLR_ENABLE_G1             (1U << 0)
 
+#define GICD_IIDR_IMPLEMENTER_SHIFT     0
+#define GICD_IIDR_IMPLEMENTER_MASK      (0xfff << GICD_IIDR_IMPLEMENTER_SHIFT)
+#define GICD_IIDR_REVISION_SHIFT        12
+#define GICD_IIDR_REVISION_MASK         (0xf << GICD_IIDR_REVISION_SHIFT)
+#define GICD_IIDR_VARIANT_SHIFT         16
+#define GICD_IIDR_VARIANT_MASK          (0xf << GICD_IIDR_VARIANT_SHIFT)
+#define GICD_IIDR_PRODUCT_ID_SHIFT      24
+#define GICD_IIDR_PRODUCT_ID_MASK       (0xff << GICD_IIDR_PRODUCT_ID_SHIFT)
+
+
 /*
  * In systems with a single security state (what we emulate in KVM)
  * the meaning of the interrupt group enable bits is slightly different
diff --git a/include/linux/irqchip/arm-gic.h b/include/linux/irqchip/arm-gic.h
index 68d8b1f73682..6c4aaf04046c 100644
--- a/include/linux/irqchip/arm-gic.h
+++ b/include/linux/irqchip/arm-gic.h
@@ -71,6 +71,16 @@
                                         (GICD_INT_DEF_PRI << 8) |\
                                         GICD_INT_DEF_PRI)
 
+#define GICD_IIDR_IMPLEMENTER_SHIFT     0
+#define GICD_IIDR_IMPLEMENTER_MASK      (0xfff << GICD_IIDR_IMPLEMENTER_SHIFT)
+#define GICD_IIDR_REVISION_SHIFT        12
+#define GICD_IIDR_REVISION_MASK         (0xf << GICD_IIDR_REVISION_SHIFT)
+#define GICD_IIDR_VARIANT_SHIFT         16
+#define GICD_IIDR_VARIANT_MASK          (0xf << GICD_IIDR_VARIANT_SHIFT)
+#define GICD_IIDR_PRODUCT_ID_SHIFT      24
+#define GICD_IIDR_PRODUCT_ID_MASK       (0xff << GICD_IIDR_PRODUCT_ID_SHIFT)
+
+
 #define GICH_HCR                        0x0
 #define GICH_VTR                        0x4
 #define GICH_VMCR                       0x8
@@ -94,6 +104,7 @@
 #define GICH_LR_PENDING_BIT             (1 << 28)
 #define GICH_LR_ACTIVE_BIT              (1 << 29)
 #define GICH_LR_EOI                     (1 << 19)
+#define GICH_LR_GROUP1                  (1 << 30)
 #define GICH_LR_HW                      (1 << 31)
 
 #define GICH_VMCR_ENABLE_GRP0_SHIFT     0
diff --git a/include/linux/irqflags.h b/include/linux/irqflags.h
index 9700f00bbc04..21619c92c377 100644
--- a/include/linux/irqflags.h
+++ b/include/linux/irqflags.h
@@ -15,9 +15,20 @@
 #include <linux/typecheck.h>
 #include <asm/irqflags.h>
 
-#ifdef CONFIG_TRACE_IRQFLAGS
+/* Currently trace_softirqs_on/off is used only by lockdep */
+#ifdef CONFIG_PROVE_LOCKING
   extern void trace_softirqs_on(unsigned long ip);
   extern void trace_softirqs_off(unsigned long ip);
+  extern void lockdep_hardirqs_on(unsigned long ip);
+  extern void lockdep_hardirqs_off(unsigned long ip);
+#else
+  static inline void trace_softirqs_on(unsigned long ip) { }
+  static inline void trace_softirqs_off(unsigned long ip) { }
+  static inline void lockdep_hardirqs_on(unsigned long ip) { }
+  static inline void lockdep_hardirqs_off(unsigned long ip) { }
+#endif
+
+#ifdef CONFIG_TRACE_IRQFLAGS
   extern void trace_hardirqs_on(void);
   extern void trace_hardirqs_off(void);
 # define trace_hardirq_context(p)       ((p)->hardirq_context)
@@ -43,8 +54,6 @@ do {						\
 #else
 # define trace_hardirqs_on()            do { } while (0)
 # define trace_hardirqs_off()           do { } while (0)
-# define trace_softirqs_on(ip)          do { } while (0)
-# define trace_softirqs_off(ip)         do { } while (0)
 # define trace_hardirq_context(p)       0
 # define trace_softirq_context(p)       0
 # define trace_hardirqs_enabled(p)      0
diff --git a/include/linux/jiffies.h b/include/linux/jiffies.h
index a27cf6652327..fa928242567d 100644
--- a/include/linux/jiffies.h
+++ b/include/linux/jiffies.h
@@ -447,6 +447,11 @@ static inline clock_t jiffies_delta_to_clock_t(long delta)
         return jiffies_to_clock_t(max(0L, delta));
 }
 
+static inline unsigned int jiffies_delta_to_msecs(long delta)
+{
+        return jiffies_to_msecs(max(0L, delta));
+}
+
 extern unsigned long clock_t_to_jiffies(unsigned long x);
 extern u64 jiffies_64_to_clock_t(u64 x);
 extern u64 nsec_to_clock_t(u64 x);
diff --git a/include/linux/joystick.h b/include/linux/joystick.h
index cbf2aa9e93b9..5153f5b9294c 100644
--- a/include/linux/joystick.h
+++ b/include/linux/joystick.h
@@ -17,10 +17,6 @@
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
- * 
- * Should you need to contact me, the author, you can do so either by
- * e-mail - mail your message to <vojtech@suse.cz>, or by paper mail:
- * Vojtech Pavlik, Ucitelska 1576, Prague 8, 182 00 Czech Republic
  */
 #ifndef _LINUX_JOYSTICK_H
 #define _LINUX_JOYSTICK_H
diff --git a/include/linux/jump_label.h b/include/linux/jump_label.h
index b46b541c67c4..1a0b6f17a5d6 100644
--- a/include/linux/jump_label.h
+++ b/include/linux/jump_label.h
@@ -299,12 +299,18 @@ struct static_key_false {
 #define DEFINE_STATIC_KEY_TRUE(name)    \
         struct static_key_true name = STATIC_KEY_TRUE_INIT
 
+#define DEFINE_STATIC_KEY_TRUE_RO(name) \
+        struct static_key_true name __ro_after_init = STATIC_KEY_TRUE_INIT
+
 #define DECLARE_STATIC_KEY_TRUE(name)   \
         extern struct static_key_true name
 
 #define DEFINE_STATIC_KEY_FALSE(name)   \
         struct static_key_false name = STATIC_KEY_FALSE_INIT
 
+#define DEFINE_STATIC_KEY_FALSE_RO(name)        \
+        struct static_key_false name __ro_after_init = STATIC_KEY_FALSE_INIT
+
 #define DECLARE_STATIC_KEY_FALSE(name)  \
         extern struct static_key_false name
 
diff --git a/include/linux/kasan.h b/include/linux/kasan.h
index de784fd11d12..46aae129917c 100644
--- a/include/linux/kasan.h
+++ b/include/linux/kasan.h
@@ -20,7 +20,7 @@ extern pmd_t kasan_zero_pmd[PTRS_PER_PMD];
 extern pud_t kasan_zero_pud[PTRS_PER_PUD];
 extern p4d_t kasan_zero_p4d[MAX_PTRS_PER_P4D];
 
-void kasan_populate_zero_shadow(const void *shadow_start,
+int kasan_populate_zero_shadow(const void *shadow_start,
                                 const void *shadow_end);
 
 static inline void *kasan_mem_to_shadow(const void *addr)
@@ -71,6 +71,9 @@ struct kasan_cache {
 int kasan_module_alloc(void *addr, size_t size);
 void kasan_free_shadow(const struct vm_struct *vm);
 
+int kasan_add_zero_shadow(void *start, unsigned long size);
+void kasan_remove_zero_shadow(void *start, unsigned long size);
+
 size_t ksize(const void *);
 static inline void kasan_unpoison_slab(const void *ptr) { ksize(ptr); }
 size_t kasan_metadata_size(struct kmem_cache *cache);
@@ -124,6 +127,14 @@ static inline bool kasan_slab_free(struct kmem_cache *s, void *object,
 static inline int kasan_module_alloc(void *addr, size_t size) { return 0; }
 static inline void kasan_free_shadow(const struct vm_struct *vm) {}
 
+static inline int kasan_add_zero_shadow(void *start, unsigned long size)
+{
+        return 0;
+}
+static inline void kasan_remove_zero_shadow(void *start,
+                                        unsigned long size)
+{}
+
 static inline void kasan_unpoison_slab(const void *ptr) { }
 static inline size_t kasan_metadata_size(struct kmem_cache *cache) { return 0; }
 
diff --git a/include/linux/kcore.h b/include/linux/kcore.h
index bc088ef96358..8c3f8c14eeaa 100644
--- a/include/linux/kcore.h
+++ b/include/linux/kcore.h
@@ -37,7 +37,7 @@ struct vmcoredd_node {
 };
 
 #ifdef CONFIG_PROC_KCORE
-extern void kclist_add(struct kcore_list *, void *, size_t, int type);
+void __init kclist_add(struct kcore_list *, void *, size_t, int type);
 static inline
 void kclist_add_remap(struct kcore_list *m, void *addr, void *vaddr, size_t sz)
 {
diff --git a/include/linux/kernel.h b/include/linux/kernel.h
index 941dc0a5a877..d6aac75b51ba 100644
--- a/include/linux/kernel.h
+++ b/include/linux/kernel.h
@@ -85,7 +85,23 @@
  * arguments just once each.
  */
 #define __round_mask(x, y) ((__typeof__(x))((y)-1))
+/**
+ * round_up - round up to next specified power of 2
+ * @x: the value to round
+ * @y: multiple to round up to (must be a power of 2)
+ *
+ * Rounds @x up to next multiple of @y (which must be a power of 2).
+ * To perform arbitrary rounding up, use roundup() below.
+ */
 #define round_up(x, y) ((((x)-1) | __round_mask(x, y))+1)
+/**
+ * round_down - round down to next specified power of 2
+ * @x: the value to round
+ * @y: multiple to round down to (must be a power of 2)
+ *
+ * Rounds @x down to next multiple of @y (which must be a power of 2).
+ * To perform arbitrary rounding down, use rounddown() below.
+ */
 #define round_down(x, y) ((x) & ~__round_mask(x, y))
 
 /**
@@ -110,13 +126,30 @@
 # define DIV_ROUND_UP_SECTOR_T(ll,d) DIV_ROUND_UP(ll,d)
 #endif
 
-/* The `const' in roundup() prevents gcc-3.3 from calling __divdi3 */
+/**
+ * roundup - round up to the next specified multiple
+ * @x: the value to up
+ * @y: multiple to round up to
+ *
+ * Rounds @x up to next multiple of @y. If @y will always be a power
+ * of 2, consider using the faster round_up().
+ *
+ * The `const' here prevents gcc-3.3 from calling __divdi3
+ */
 #define roundup(x, y) (                                 \
 {                                                       \
         const typeof(y) __y = y;                        \
         (((x) + (__y - 1)) / __y) * __y;                \
 }                                                       \
 )
+/**
+ * rounddown - round down to next specified multiple
+ * @x: the value to round
+ * @y: multiple to round down to
+ *
+ * Rounds @x down to next multiple of @y. If @y will always be a power
+ * of 2, consider using the faster round_down().
+ */
 #define rounddown(x, y) (                               \
 {                                                       \
         typeof(x) __x = (x);                            \
diff --git a/include/linux/kernfs.h b/include/linux/kernfs.h
index ab25c8b6d9e3..814643f7ee52 100644
--- a/include/linux/kernfs.h
+++ b/include/linux/kernfs.h
@@ -15,6 +15,7 @@
 #include <linux/lockdep.h>
 #include <linux/rbtree.h>
 #include <linux/atomic.h>
+#include <linux/uidgid.h>
 #include <linux/wait.h>
 
 struct file;
@@ -325,12 +326,14 @@ void kernfs_destroy_root(struct kernfs_root *root);
 
 struct kernfs_node *kernfs_create_dir_ns(struct kernfs_node *parent,
                                          const char *name, umode_t mode,
+                                         kuid_t uid, kgid_t gid,
                                          void *priv, const void *ns);
 struct kernfs_node *kernfs_create_empty_dir(struct kernfs_node *parent,
                                             const char *name);
 struct kernfs_node *__kernfs_create_file(struct kernfs_node *parent,
-                                         const char *name,
-                                         umode_t mode, loff_t size,
+                                         const char *name, umode_t mode,
+                                         kuid_t uid, kgid_t gid,
+                                         loff_t size,
                                          const struct kernfs_ops *ops,
                                          void *priv, const void *ns,
                                          struct lock_class_key *key);
@@ -415,12 +418,14 @@ static inline void kernfs_destroy_root(struct kernfs_root *root) { }
 
 static inline struct kernfs_node *
 kernfs_create_dir_ns(struct kernfs_node *parent, const char *name,
-                     umode_t mode, void *priv, const void *ns)
+                     umode_t mode, kuid_t uid, kgid_t gid,
+                     void *priv, const void *ns)
 { return ERR_PTR(-ENOSYS); }
 
 static inline struct kernfs_node *
 __kernfs_create_file(struct kernfs_node *parent, const char *name,
-                     umode_t mode, loff_t size, const struct kernfs_ops *ops,
+                     umode_t mode, kuid_t uid, kgid_t gid,
+                     loff_t size, const struct kernfs_ops *ops,
                      void *priv, const void *ns, struct lock_class_key *key)
 { return ERR_PTR(-ENOSYS); }
 
@@ -498,12 +503,15 @@ static inline struct kernfs_node *
 kernfs_create_dir(struct kernfs_node *parent, const char *name, umode_t mode,
                   void *priv)
 {
-        return kernfs_create_dir_ns(parent, name, mode, priv, NULL);
+        return kernfs_create_dir_ns(parent, name, mode,
+                                    GLOBAL_ROOT_UID, GLOBAL_ROOT_GID,
+                                    priv, NULL);
 }
 
 static inline struct kernfs_node *
 kernfs_create_file_ns(struct kernfs_node *parent, const char *name,
-                      umode_t mode, loff_t size, const struct kernfs_ops *ops,
+                      umode_t mode, kuid_t uid, kgid_t gid,
+                      loff_t size, const struct kernfs_ops *ops,
                       void *priv, const void *ns)
 {
         struct lock_class_key *key = NULL;
@@ -511,15 +519,17 @@ kernfs_create_file_ns(struct kernfs_node *parent, const char *name,
 #ifdef CONFIG_DEBUG_LOCK_ALLOC
         key = (struct lock_class_key *)&ops->lockdep_key;
 #endif
-        return __kernfs_create_file(parent, name, mode, size, ops, priv, ns,
-                                    key);
+        return __kernfs_create_file(parent, name, mode, uid, gid,
+                                    size, ops, priv, ns, key);
 }
 
 static inline struct kernfs_node *
 kernfs_create_file(struct kernfs_node *parent, const char *name, umode_t mode,
                    loff_t size, const struct kernfs_ops *ops, void *priv)
 {
-        return kernfs_create_file_ns(parent, name, mode, size, ops, priv, NULL);
+        return kernfs_create_file_ns(parent, name, mode,
+                                     GLOBAL_ROOT_UID, GLOBAL_ROOT_GID,
+                                     size, ops, priv, NULL);
 }
 
 static inline int kernfs_remove_by_name(struct kernfs_node *parent,
diff --git a/include/linux/kobject.h b/include/linux/kobject.h
index 7f6f93c3df9c..1ab0d624fb36 100644
--- a/include/linux/kobject.h
+++ b/include/linux/kobject.h
@@ -26,6 +26,7 @@
 #include <linux/wait.h>
 #include <linux/atomic.h>
 #include <linux/workqueue.h>
+#include <linux/uidgid.h>
 
 #define UEVENT_HELPER_PATH_LEN          256
 #define UEVENT_NUM_ENVP                 32      /* number of env pointers */
@@ -114,14 +115,34 @@ extern struct kobject * __must_check kobject_get_unless_zero(
 extern void kobject_put(struct kobject *kobj);
 
 extern const void *kobject_namespace(struct kobject *kobj);
+extern void kobject_get_ownership(struct kobject *kobj,
+                                  kuid_t *uid, kgid_t *gid);
 extern char *kobject_get_path(struct kobject *kobj, gfp_t flag);
 
+/**
+ * kobject_has_children - Returns whether a kobject has children.
+ * @kobj: the object to test
+ *
+ * This will return whether a kobject has other kobjects as children.
+ *
+ * It does NOT account for the presence of attribute files, only sub
+ * directories. It also assumes there is no concurrent addition or
+ * removal of such children, and thus relies on external locking.
+ */
+static inline bool kobject_has_children(struct kobject *kobj)
+{
+        WARN_ON_ONCE(kref_read(&kobj->kref) == 0);
+
+        return kobj->sd && kobj->sd->dir.subdirs;
+}
+
 struct kobj_type {
         void (*release)(struct kobject *kobj);
         const struct sysfs_ops *sysfs_ops;
         struct attribute **default_attrs;
         const struct kobj_ns_type_operations *(*child_ns_type)(struct kobject *kobj);
         const void *(*namespace)(struct kobject *kobj);
+        void (*get_ownership)(struct kobject *kobj, kuid_t *uid, kgid_t *gid);
 };
 
 struct kobj_uevent_env {
diff --git a/include/linux/kvm_host.h b/include/linux/kvm_host.h
index 4ee7bc548a83..0205aee44ded 100644
--- a/include/linux/kvm_host.h
+++ b/include/linux/kvm_host.h
@@ -130,7 +130,7 @@ static inline bool is_error_page(struct page *page)
 #define KVM_REQUEST_ARCH_BASE     8
 
 #define KVM_ARCH_REQ_FLAGS(nr, flags) ({ \
-        BUILD_BUG_ON((unsigned)(nr) >= 32 - KVM_REQUEST_ARCH_BASE); \
+        BUILD_BUG_ON((unsigned)(nr) >= (FIELD_SIZEOF(struct kvm_vcpu, requests) * 8) - KVM_REQUEST_ARCH_BASE); \
         (unsigned)(((nr) + KVM_REQUEST_ARCH_BASE) | (flags)); \
 })
 #define KVM_ARCH_REQ(nr)           KVM_ARCH_REQ_FLAGS(nr, 0)
@@ -224,7 +224,7 @@ struct kvm_vcpu {
         int vcpu_id;
         int srcu_idx;
         int mode;
-        unsigned long requests;
+        u64 requests;
         unsigned long guest_debug;
 
         int pre_pcpu;
@@ -309,6 +309,13 @@ static inline unsigned long kvm_dirty_bitmap_bytes(struct kvm_memory_slot *memsl
         return ALIGN(memslot->npages, BITS_PER_LONG) / 8;
 }
 
+static inline unsigned long *kvm_second_dirty_bitmap(struct kvm_memory_slot *memslot)
+{
+        unsigned long len = kvm_dirty_bitmap_bytes(memslot);
+
+        return memslot->dirty_bitmap + len / sizeof(*memslot->dirty_bitmap);
+}
+
 struct kvm_s390_adapter_int {
         u64 ind_addr;
         u64 summary_addr;
@@ -827,6 +834,13 @@ static inline void kvm_arch_free_vm(struct kvm *kvm)
 }
 #endif
 
+#ifndef __KVM_HAVE_ARCH_FLUSH_REMOTE_TLB
+static inline int kvm_arch_flush_remote_tlb(struct kvm *kvm)
+{
+        return -ENOTSUPP;
+}
+#endif
+
 #ifdef __KVM_HAVE_ARCH_NONCOHERENT_DMA
 void kvm_arch_register_noncoherent_dma(struct kvm *kvm);
 void kvm_arch_unregister_noncoherent_dma(struct kvm *kvm);
@@ -1124,7 +1138,7 @@ static inline void kvm_make_request(int req, struct kvm_vcpu *vcpu)
          * caller.  Paired with the smp_mb__after_atomic in kvm_check_request.
          */
         smp_wmb();
-        set_bit(req & KVM_REQUEST_MASK, &vcpu->requests);
+        set_bit(req & KVM_REQUEST_MASK, (void *)&vcpu->requests);
 }
 
 static inline bool kvm_request_pending(struct kvm_vcpu *vcpu)
@@ -1134,12 +1148,12 @@ static inline bool kvm_request_pending(struct kvm_vcpu *vcpu)
 
 static inline bool kvm_test_request(int req, struct kvm_vcpu *vcpu)
 {
-        return test_bit(req & KVM_REQUEST_MASK, &vcpu->requests);
+        return test_bit(req & KVM_REQUEST_MASK, (void *)&vcpu->requests);
 }
 
 static inline void kvm_clear_request(int req, struct kvm_vcpu *vcpu)
 {
-        clear_bit(req & KVM_REQUEST_MASK, &vcpu->requests);
+        clear_bit(req & KVM_REQUEST_MASK, (void *)&vcpu->requests);
 }
 
 static inline bool kvm_check_request(int req, struct kvm_vcpu *vcpu)
@@ -1275,8 +1289,8 @@ static inline long kvm_arch_vcpu_async_ioctl(struct file *filp,
 }
 #endif /* CONFIG_HAVE_KVM_VCPU_ASYNC_IOCTL */
 
-void kvm_arch_mmu_notifier_invalidate_range(struct kvm *kvm,
-                unsigned long start, unsigned long end);
+int kvm_arch_mmu_notifier_invalidate_range(struct kvm *kvm,
+                unsigned long start, unsigned long end, bool blockable);
 
 #ifdef CONFIG_HAVE_KVM_VCPU_RUN_PID_CHANGE
 int kvm_arch_vcpu_run_pid_change(struct kvm_vcpu *vcpu);
diff --git a/include/linux/leds.h b/include/linux/leds.h
index b7e82550e655..834683d603f9 100644
--- a/include/linux/leds.h
+++ b/include/linux/leds.h
@@ -253,7 +253,7 @@ static inline bool led_sysfs_is_disabled(struct led_classdev *led_cdev)
 struct led_trigger {
         /* Trigger Properties */
         const char       *name;
-        void            (*activate)(struct led_classdev *led_cdev);
+        int             (*activate)(struct led_classdev *led_cdev);
         void            (*deactivate)(struct led_classdev *led_cdev);
 
         /* LEDs under control by this trigger (for simple triggers) */
@@ -262,8 +262,19 @@ struct led_trigger {
 
         /* Link to next registered trigger */
         struct list_head  next_trig;
+
+        const struct attribute_group **groups;
 };
 
+/*
+ * Currently the attributes in struct led_trigger::groups are added directly to
+ * the LED device. As this might change in the future, the following
+ * macros abstract getting the LED device and its trigger_data from the dev
+ * parameter passed to the attribute accessor functions.
+ */
+#define led_trigger_get_led(dev)        ((struct led_classdev *)dev_get_drvdata((dev)))
+#define led_trigger_get_drvdata(dev)    (led_get_trigger_data(led_trigger_get_led(dev)))
+
 ssize_t led_trigger_store(struct device *dev, struct device_attribute *attr,
                         const char *buf, size_t count);
 ssize_t led_trigger_show(struct device *dev, struct device_attribute *attr,
@@ -288,10 +299,16 @@ extern void led_trigger_blink_oneshot(struct led_trigger *trigger,
                                       unsigned long *delay_off,
                                       int invert);
 extern void led_trigger_set_default(struct led_classdev *led_cdev);
-extern void led_trigger_set(struct led_classdev *led_cdev,
-                        struct led_trigger *trigger);
+extern int led_trigger_set(struct led_classdev *led_cdev,
+                           struct led_trigger *trigger);
 extern void led_trigger_remove(struct led_classdev *led_cdev);
 
+static inline void led_set_trigger_data(struct led_classdev *led_cdev,
+                                        void *trigger_data)
+{
+        led_cdev->trigger_data = trigger_data;
+}
+
 static inline void *led_get_trigger_data(struct led_classdev *led_cdev)
 {
         return led_cdev->trigger_data;
@@ -315,6 +332,10 @@ static inline void *led_get_trigger_data(struct led_classdev *led_cdev)
 extern void led_trigger_rename_static(const char *name,
                                       struct led_trigger *trig);
 
+#define module_led_trigger(__led_trigger) \
+        module_driver(__led_trigger, led_trigger_register, \
+                      led_trigger_unregister)
+
 #else
 
 /* Trigger has no members */
@@ -334,9 +355,14 @@ static inline void led_trigger_blink_oneshot(struct led_trigger *trigger,
                                       unsigned long *delay_off,
                                       int invert) {}
 static inline void led_trigger_set_default(struct led_classdev *led_cdev) {}
-static inline void led_trigger_set(struct led_classdev *led_cdev,
-                                struct led_trigger *trigger) {}
+static inline int led_trigger_set(struct led_classdev *led_cdev,
+                                  struct led_trigger *trigger)
+{
+        return 0;
+}
+
 static inline void led_trigger_remove(struct led_classdev *led_cdev) {}
+static inline void led_set_trigger_data(struct led_classdev *led_cdev) {}
 static inline void *led_get_trigger_data(struct led_classdev *led_cdev)
 {
         return NULL;
diff --git a/include/linux/libata.h b/include/linux/libata.h
index 32f247cb5e9e..38c95d66ab12 100644
--- a/include/linux/libata.h
+++ b/include/linux/libata.h
@@ -523,7 +523,8 @@ enum ata_lpm_policy {
         ATA_LPM_MAX_POWER,
         ATA_LPM_MED_POWER,
         ATA_LPM_MED_POWER_WITH_DIPM, /* Med power + DIPM as win IRST does */
-        ATA_LPM_MIN_POWER,
+        ATA_LPM_MIN_POWER_WITH_PARTIAL, /* Min Power + partial and slumber */
+        ATA_LPM_MIN_POWER, /* Min power + no partial (slumber only) */
 };
 
 enum ata_lpm_hints {
@@ -1111,6 +1112,8 @@ extern struct ata_host *ata_host_alloc(struct device *dev, int max_ports);
 extern struct ata_host *ata_host_alloc_pinfo(struct device *dev,
                         const struct ata_port_info * const * ppi, int n_ports);
 extern int ata_slave_link_init(struct ata_port *ap);
+extern void ata_host_get(struct ata_host *host);
+extern void ata_host_put(struct ata_host *host);
 extern int ata_host_start(struct ata_host *host);
 extern int ata_host_register(struct ata_host *host,
                              struct scsi_host_template *sht);
@@ -1856,8 +1859,6 @@ extern unsigned int ata_sff_data_xfer(struct ata_queued_cmd *qc,
                         unsigned char *buf, unsigned int buflen, int rw);
 extern unsigned int ata_sff_data_xfer32(struct ata_queued_cmd *qc,
                         unsigned char *buf, unsigned int buflen, int rw);
-extern unsigned int ata_sff_data_xfer_noirq(struct ata_queued_cmd *qc,
-                        unsigned char *buf, unsigned int buflen, int rw);
 extern void ata_sff_irq_on(struct ata_port *ap);
 extern void ata_sff_irq_clear(struct ata_port *ap);
 extern int ata_sff_hsm_move(struct ata_port *ap, struct ata_queued_cmd *qc,
diff --git a/include/linux/list.h b/include/linux/list.h
index 4b129df4d46b..de04cc5ed536 100644
--- a/include/linux/list.h
+++ b/include/linux/list.h
@@ -285,6 +285,36 @@ static inline void list_cut_position(struct list_head *list,
                 __list_cut_position(list, head, entry);
 }
 
+/**
+ * list_cut_before - cut a list into two, before given entry
+ * @list: a new list to add all removed entries
+ * @head: a list with entries
+ * @entry: an entry within head, could be the head itself
+ *
+ * This helper moves the initial part of @head, up to but
+ * excluding @entry, from @head to @list.  You should pass
+ * in @entry an element you know is on @head.  @list should
+ * be an empty list or a list you do not care about losing
+ * its data.
+ * If @entry == @head, all entries on @head are moved to
+ * @list.
+ */
+static inline void list_cut_before(struct list_head *list,
+                                   struct list_head *head,
+                                   struct list_head *entry)
+{
+        if (head->next == entry) {
+                INIT_LIST_HEAD(list);
+                return;
+        }
+        list->next = head->next;
+        list->next->prev = list;
+        list->prev = entry->prev;
+        list->prev->next = list;
+        head->next = entry;
+        entry->prev = head;
+}
+
 static inline void __list_splice(const struct list_head *list,
                                  struct list_head *prev,
                                  struct list_head *next)
diff --git a/include/linux/list_lru.h b/include/linux/list_lru.h
index 96def9d15b1b..aa5efd9351eb 100644
--- a/include/linux/list_lru.h
+++ b/include/linux/list_lru.h
@@ -42,7 +42,7 @@ struct list_lru_node {
         spinlock_t              lock;
         /* global list, used for the root cgroup in cgroup aware lrus */
         struct list_lru_one     lru;
-#if defined(CONFIG_MEMCG) && !defined(CONFIG_SLOB)
+#ifdef CONFIG_MEMCG_KMEM
         /* for cgroup aware lrus points to per cgroup lists, otherwise NULL */
         struct list_lru_memcg   __rcu *memcg_lrus;
 #endif
@@ -51,21 +51,25 @@ struct list_lru_node {
 
 struct list_lru {
         struct list_lru_node    *node;
-#if defined(CONFIG_MEMCG) && !defined(CONFIG_SLOB)
+#ifdef CONFIG_MEMCG_KMEM
         struct list_head        list;
+        int                     shrinker_id;
 #endif
 };
 
 void list_lru_destroy(struct list_lru *lru);
 int __list_lru_init(struct list_lru *lru, bool memcg_aware,
-                    struct lock_class_key *key);
+                    struct lock_class_key *key, struct shrinker *shrinker);
 
-#define list_lru_init(lru)              __list_lru_init((lru), false, NULL)
-#define list_lru_init_key(lru, key)     __list_lru_init((lru), false, (key))
-#define list_lru_init_memcg(lru)        __list_lru_init((lru), true, NULL)
+#define list_lru_init(lru)                              \
+        __list_lru_init((lru), false, NULL, NULL)
+#define list_lru_init_key(lru, key)                     \
+        __list_lru_init((lru), false, (key), NULL)
+#define list_lru_init_memcg(lru, shrinker)              \
+        __list_lru_init((lru), true, NULL, shrinker)
 
 int memcg_update_all_list_lrus(int num_memcgs);
-void memcg_drain_all_list_lrus(int src_idx, int dst_idx);
+void memcg_drain_all_list_lrus(int src_idx, struct mem_cgroup *dst_memcg);
 
 /**
  * list_lru_add: add an element to the lru list's tail
@@ -162,6 +166,23 @@ unsigned long list_lru_walk_one(struct list_lru *lru,
                                 int nid, struct mem_cgroup *memcg,
                                 list_lru_walk_cb isolate, void *cb_arg,
                                 unsigned long *nr_to_walk);
+/**
+ * list_lru_walk_one_irq: walk a list_lru, isolating and disposing freeable items.
+ * @lru: the lru pointer.
+ * @nid: the node id to scan from.
+ * @memcg: the cgroup to scan from.
+ * @isolate: callback function that is resposible for deciding what to do with
+ *  the item currently being scanned
+ * @cb_arg: opaque type that will be passed to @isolate
+ * @nr_to_walk: how many items to scan.
+ *
+ * Same as @list_lru_walk_one except that the spinlock is acquired with
+ * spin_lock_irq().
+ */
+unsigned long list_lru_walk_one_irq(struct list_lru *lru,
+                                    int nid, struct mem_cgroup *memcg,
+                                    list_lru_walk_cb isolate, void *cb_arg,
+                                    unsigned long *nr_to_walk);
 unsigned long list_lru_walk_node(struct list_lru *lru, int nid,
                                  list_lru_walk_cb isolate, void *cb_arg,
                                  unsigned long *nr_to_walk);
@@ -175,6 +196,14 @@ list_lru_shrink_walk(struct list_lru *lru, struct shrink_control *sc,
 }
 
 static inline unsigned long
+list_lru_shrink_walk_irq(struct list_lru *lru, struct shrink_control *sc,
+                         list_lru_walk_cb isolate, void *cb_arg)
+{
+        return list_lru_walk_one_irq(lru, sc->nid, sc->memcg, isolate, cb_arg,
+                                     &sc->nr_to_scan);
+}
+
+static inline unsigned long
 list_lru_walk(struct list_lru *lru, list_lru_walk_cb isolate,
               void *cb_arg, unsigned long nr_to_walk)
 {
diff --git a/include/linux/lockd/lockd.h b/include/linux/lockd/lockd.h
index 4fd95dbeb52f..b065ef406770 100644
--- a/include/linux/lockd/lockd.h
+++ b/include/linux/lockd/lockd.h
@@ -299,7 +299,7 @@ int           nlmsvc_unlock_all_by_ip(struct sockaddr *server_addr);
 
 static inline struct inode *nlmsvc_file_inode(struct nlm_file *file)
 {
-        return file_inode(file->f_file);
+        return locks_inode(file->f_file);
 }
 
 static inline int __nlm_privileged_request4(const struct sockaddr *sap)
@@ -359,7 +359,7 @@ static inline int nlm_privileged_requester(const struct svc_rqst *rqstp)
 static inline int nlm_compare_locks(const struct file_lock *fl1,
                                     const struct file_lock *fl2)
 {
-        return file_inode(fl1->fl_file) == file_inode(fl2->fl_file)
+        return locks_inode(fl1->fl_file) == locks_inode(fl2->fl_file)
              && fl1->fl_pid   == fl2->fl_pid
              && fl1->fl_owner == fl2->fl_owner
              && fl1->fl_start == fl2->fl_start
diff --git a/include/linux/lockdep.h b/include/linux/lockdep.h
index 6fc77d4dbdcd..b0d0b51c4d85 100644
--- a/include/linux/lockdep.h
+++ b/include/linux/lockdep.h
@@ -266,7 +266,7 @@ struct held_lock {
 /*
  * Initialization, self-test and debugging-output methods:
  */
-extern void lockdep_info(void);
+extern void lockdep_init(void);
 extern void lockdep_reset(void);
 extern void lockdep_reset_lock(struct lockdep_map *lock);
 extern void lockdep_free_key_range(void *start, unsigned long size);
@@ -406,7 +406,7 @@ static inline void lockdep_on(void)
 # define lock_downgrade(l, i)                   do { } while (0)
 # define lock_set_class(l, n, k, s, i)          do { } while (0)
 # define lock_set_subclass(l, s, i)             do { } while (0)
-# define lockdep_info()                         do { } while (0)
+# define lockdep_init()                         do { } while (0)
 # define lockdep_init_map(lock, name, key, sub) \
                 do { (void)(name); (void)(key); } while (0)
 # define lockdep_set_class(lock, key)           do { (void)(key); } while (0)
@@ -532,7 +532,7 @@ do {								\
 
 #endif /* CONFIG_LOCKDEP */
 
-#ifdef CONFIG_TRACE_IRQFLAGS
+#ifdef CONFIG_PROVE_LOCKING
 extern void print_irqtrace_events(struct task_struct *curr);
 #else
 static inline void print_irqtrace_events(struct task_struct *curr)
diff --git a/include/linux/lsm_hooks.h b/include/linux/lsm_hooks.h
index 8f1131c8dd54..97a020c616ad 100644
--- a/include/linux/lsm_hooks.h
+++ b/include/linux/lsm_hooks.h
@@ -576,6 +576,10 @@
  *      userspace to load a kernel module with the given name.
  *      @kmod_name name of the module requested by the kernel
  *      Return 0 if successful.
+ * @kernel_load_data:
+ *      Load data provided by userspace.
+ *      @id kernel load data identifier
+ *      Return 0 if permission is granted.
  * @kernel_read_file:
  *      Read a file specified by userspace.
  *      @file contains the file structure pointing to the file being read
@@ -1569,7 +1573,7 @@ union security_list_options {
         int (*file_send_sigiotask)(struct task_struct *tsk,
                                         struct fown_struct *fown, int sig);
         int (*file_receive)(struct file *file);
-        int (*file_open)(struct file *file, const struct cred *cred);
+        int (*file_open)(struct file *file);
 
         int (*task_alloc)(struct task_struct *task, unsigned long clone_flags);
         void (*task_free)(struct task_struct *task);
@@ -1582,6 +1586,7 @@ union security_list_options {
         int (*kernel_act_as)(struct cred *new, u32 secid);
         int (*kernel_create_files_as)(struct cred *new, struct inode *inode);
         int (*kernel_module_request)(char *kmod_name);
+        int (*kernel_load_data)(enum kernel_load_data_id id);
         int (*kernel_read_file)(struct file *file, enum kernel_read_file_id id);
         int (*kernel_post_read_file)(struct file *file, char *buf, loff_t size,
                                      enum kernel_read_file_id id);
@@ -1872,6 +1877,7 @@ struct security_hook_heads {
         struct hlist_head cred_getsecid;
         struct hlist_head kernel_act_as;
         struct hlist_head kernel_create_files_as;
+        struct hlist_head kernel_load_data;
         struct hlist_head kernel_read_file;
         struct hlist_head kernel_post_read_file;
         struct hlist_head kernel_module_request;
diff --git a/include/linux/mailbox/mtk-cmdq-mailbox.h b/include/linux/mailbox/mtk-cmdq-mailbox.h
new file mode 100644
index 000000000000..ccb73422c2fa
--- /dev/null
+++ b/include/linux/mailbox/mtk-cmdq-mailbox.h
@@ -0,0 +1,77 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Copyright (c) 2018 MediaTek Inc.
+ *
+ */
+
+#ifndef __MTK_CMDQ_MAILBOX_H__
+#define __MTK_CMDQ_MAILBOX_H__
+
+#include <linux/platform_device.h>
+#include <linux/slab.h>
+#include <linux/types.h>
+
+#define CMDQ_INST_SIZE                  8 /* instruction is 64-bit */
+#define CMDQ_SUBSYS_SHIFT               16
+#define CMDQ_OP_CODE_SHIFT              24
+#define CMDQ_JUMP_PASS                  CMDQ_INST_SIZE
+
+#define CMDQ_WFE_UPDATE                 BIT(31)
+#define CMDQ_WFE_WAIT                   BIT(15)
+#define CMDQ_WFE_WAIT_VALUE             0x1
+
+/*
+ * CMDQ_CODE_MASK:
+ *   set write mask
+ *   format: op mask
+ * CMDQ_CODE_WRITE:
+ *   write value into target register
+ *   format: op subsys address value
+ * CMDQ_CODE_JUMP:
+ *   jump by offset
+ *   format: op offset
+ * CMDQ_CODE_WFE:
+ *   wait for event and clear
+ *   it is just clear if no wait
+ *   format: [wait]  op event update:1 to_wait:1 wait:1
+ *           [clear] op event update:1 to_wait:0 wait:0
+ * CMDQ_CODE_EOC:
+ *   end of command
+ *   format: op irq_flag
+ */
+enum cmdq_code {
+        CMDQ_CODE_MASK = 0x02,
+        CMDQ_CODE_WRITE = 0x04,
+        CMDQ_CODE_JUMP = 0x10,
+        CMDQ_CODE_WFE = 0x20,
+        CMDQ_CODE_EOC = 0x40,
+};
+
+enum cmdq_cb_status {
+        CMDQ_CB_NORMAL = 0,
+        CMDQ_CB_ERROR
+};
+
+struct cmdq_cb_data {
+        enum cmdq_cb_status     sta;
+        void                    *data;
+};
+
+typedef void (*cmdq_async_flush_cb)(struct cmdq_cb_data data);
+
+struct cmdq_task_cb {
+        cmdq_async_flush_cb     cb;
+        void                    *data;
+};
+
+struct cmdq_pkt {
+        void                    *va_base;
+        dma_addr_t              pa_base;
+        size_t                  cmd_buf_size; /* command occupied size */
+        size_t                  buf_size; /* real buffer size */
+        struct cmdq_task_cb     cb;
+        struct cmdq_task_cb     async_cb;
+        void                    *cl;
+};
+
+#endif /* __MTK_CMDQ_MAILBOX_H__ */
diff --git a/include/linux/memblock.h b/include/linux/memblock.h
index ca59883c8364..516920549378 100644
--- a/include/linux/memblock.h
+++ b/include/linux/memblock.h
@@ -20,31 +20,60 @@
 #define INIT_MEMBLOCK_REGIONS   128
 #define INIT_PHYSMEM_REGIONS    4
 
-/* Definition of memblock flags. */
-enum {
+/**
+ * enum memblock_flags - definition of memory region attributes
+ * @MEMBLOCK_NONE: no special request
+ * @MEMBLOCK_HOTPLUG: hotpluggable region
+ * @MEMBLOCK_MIRROR: mirrored region
+ * @MEMBLOCK_NOMAP: don't add to kernel direct mapping
+ */
+enum memblock_flags {
         MEMBLOCK_NONE           = 0x0,  /* No special request */
         MEMBLOCK_HOTPLUG        = 0x1,  /* hotpluggable region */
         MEMBLOCK_MIRROR         = 0x2,  /* mirrored region */
         MEMBLOCK_NOMAP          = 0x4,  /* don't add to kernel direct mapping */
 };
 
+/**
+ * struct memblock_region - represents a memory region
+ * @base: physical address of the region
+ * @size: size of the region
+ * @flags: memory region attributes
+ * @nid: NUMA node id
+ */
 struct memblock_region {
         phys_addr_t base;
         phys_addr_t size;
-        unsigned long flags;
+        enum memblock_flags flags;
 #ifdef CONFIG_HAVE_MEMBLOCK_NODE_MAP
         int nid;
 #endif
 };
 
+/**
+ * struct memblock_type - collection of memory regions of certain type
+ * @cnt: number of regions
+ * @max: size of the allocated array
+ * @total_size: size of all regions
+ * @regions: array of regions
+ * @name: the memory type symbolic name
+ */
 struct memblock_type {
-        unsigned long cnt;      /* number of regions */
-        unsigned long max;      /* size of the allocated array */
-        phys_addr_t total_size; /* size of all regions */
+        unsigned long cnt;
+        unsigned long max;
+        phys_addr_t total_size;
         struct memblock_region *regions;
         char *name;
 };
 
+/**
+ * struct memblock - memblock allocator metadata
+ * @bottom_up: is bottom up direction?
+ * @current_limit: physical address of the current allocation limit
+ * @memory: usabe memory regions
+ * @reserved: reserved memory regions
+ * @physmem: all physical memory
+ */
 struct memblock {
         bool bottom_up;  /* is bottom up direction? */
         phys_addr_t current_limit;
@@ -72,7 +101,7 @@ void memblock_discard(void);
 
 phys_addr_t memblock_find_in_range_node(phys_addr_t size, phys_addr_t align,
                                         phys_addr_t start, phys_addr_t end,
-                                        int nid, ulong flags);
+                                        int nid, enum memblock_flags flags);
 phys_addr_t memblock_find_in_range(phys_addr_t start, phys_addr_t end,
                                    phys_addr_t size, phys_addr_t align);
 void memblock_allow_resize(void);
@@ -89,19 +118,19 @@ int memblock_clear_hotplug(phys_addr_t base, phys_addr_t size);
 int memblock_mark_mirror(phys_addr_t base, phys_addr_t size);
 int memblock_mark_nomap(phys_addr_t base, phys_addr_t size);
 int memblock_clear_nomap(phys_addr_t base, phys_addr_t size);
-ulong choose_memblock_flags(void);
+enum memblock_flags choose_memblock_flags(void);
 
 /* Low level functions */
 int memblock_add_range(struct memblock_type *type,
                        phys_addr_t base, phys_addr_t size,
-                       int nid, unsigned long flags);
+                       int nid, enum memblock_flags flags);
 
-void __next_mem_range(u64 *idx, int nid, ulong flags,
+void __next_mem_range(u64 *idx, int nid, enum memblock_flags flags,
                       struct memblock_type *type_a,
                       struct memblock_type *type_b, phys_addr_t *out_start,
                       phys_addr_t *out_end, int *out_nid);
 
-void __next_mem_range_rev(u64 *idx, int nid, ulong flags,
+void __next_mem_range_rev(u64 *idx, int nid, enum memblock_flags flags,
                           struct memblock_type *type_a,
                           struct memblock_type *type_b, phys_addr_t *out_start,
                           phys_addr_t *out_end, int *out_nid);
@@ -239,7 +268,6 @@ void __next_mem_pfn_range(int *idx, int nid, unsigned long *out_start_pfn,
 /**
  * for_each_resv_unavail_range - iterate through reserved and unavailable memory
  * @i: u64 used as loop variable
- * @flags: pick from blocks based on memory attributes
  * @p_start: ptr to phys_addr_t for start address of the range, can be %NULL
  * @p_end: ptr to phys_addr_t for end address of the range, can be %NULL
  *
@@ -253,13 +281,13 @@ void __next_mem_pfn_range(int *idx, int nid, unsigned long *out_start_pfn,
                            NUMA_NO_NODE, MEMBLOCK_NONE, p_start, p_end, NULL)
 
 static inline void memblock_set_region_flags(struct memblock_region *r,
-                                             unsigned long flags)
+                                             enum memblock_flags flags)
 {
         r->flags |= flags;
 }
 
 static inline void memblock_clear_region_flags(struct memblock_region *r,
-                                               unsigned long flags)
+                                               enum memblock_flags flags)
 {
         r->flags &= ~flags;
 }
@@ -317,10 +345,10 @@ static inline bool memblock_bottom_up(void)
 
 phys_addr_t __init memblock_alloc_range(phys_addr_t size, phys_addr_t align,
                                         phys_addr_t start, phys_addr_t end,
-                                        ulong flags);
+                                        enum memblock_flags flags);
 phys_addr_t memblock_alloc_base_nid(phys_addr_t size,
                                         phys_addr_t align, phys_addr_t max_addr,
-                                        int nid, ulong flags);
+                                        int nid, enum memblock_flags flags);
 phys_addr_t memblock_alloc_base(phys_addr_t size, phys_addr_t align,
                                 phys_addr_t max_addr);
 phys_addr_t __memblock_alloc_base(phys_addr_t size, phys_addr_t align,
@@ -367,8 +395,10 @@ phys_addr_t memblock_get_current_limit(void);
  */
 
 /**
- * memblock_region_memory_base_pfn - Return the lowest pfn intersecting with the memory region
+ * memblock_region_memory_base_pfn - get the lowest pfn of the memory region
  * @reg: memblock_region structure
+ *
+ * Return: the lowest pfn intersecting with the memory region
  */
 static inline unsigned long memblock_region_memory_base_pfn(const struct memblock_region *reg)
 {
@@ -376,8 +406,10 @@ static inline unsigned long memblock_region_memory_base_pfn(const struct membloc
 }
 
 /**
- * memblock_region_memory_end_pfn - Return the end_pfn this region
+ * memblock_region_memory_end_pfn - get the end pfn of the memory region
  * @reg: memblock_region structure
+ *
+ * Return: the end_pfn of the reserved region
  */
 static inline unsigned long memblock_region_memory_end_pfn(const struct memblock_region *reg)
 {
@@ -385,8 +417,10 @@ static inline unsigned long memblock_region_memory_end_pfn(const struct memblock
 }
 
 /**
- * memblock_region_reserved_base_pfn - Return the lowest pfn intersecting with the reserved region
+ * memblock_region_reserved_base_pfn - get the lowest pfn of the reserved region
  * @reg: memblock_region structure
+ *
+ * Return: the lowest pfn intersecting with the reserved region
  */
 static inline unsigned long memblock_region_reserved_base_pfn(const struct memblock_region *reg)
 {
@@ -394,8 +428,10 @@ static inline unsigned long memblock_region_reserved_base_pfn(const struct membl
 }
 
 /**
- * memblock_region_reserved_end_pfn - Return the end_pfn this region
+ * memblock_region_reserved_end_pfn - get the end pfn of the reserved region
  * @reg: memblock_region structure
+ *
+ * Return: the end_pfn of the reserved region
  */
 static inline unsigned long memblock_region_reserved_end_pfn(const struct memblock_region *reg)
 {
diff --git a/include/linux/memcontrol.h b/include/linux/memcontrol.h
index 6c6fb116e925..652f602167df 100644
--- a/include/linux/memcontrol.h
+++ b/include/linux/memcontrol.h
@@ -112,6 +112,15 @@ struct lruvec_stat {
 };
 
 /*
+ * Bitmap of shrinker::id corresponding to memcg-aware shrinkers,
+ * which have elements charged to this memcg.
+ */
+struct memcg_shrinker_map {
+        struct rcu_head rcu;
+        unsigned long map[0];
+};
+
+/*
  * per-zone information in memory controller.
  */
 struct mem_cgroup_per_node {
@@ -124,6 +133,9 @@ struct mem_cgroup_per_node {
 
         struct mem_cgroup_reclaim_iter  iter[DEF_PRIORITY + 1];
 
+#ifdef CONFIG_MEMCG_KMEM
+        struct memcg_shrinker_map __rcu *shrinker_map;
+#endif
         struct rb_node          tree_node;      /* RB tree node */
         unsigned long           usage_in_excess;/* Set to the value by which */
                                                 /* the soft limit is exceeded*/
@@ -213,6 +225,11 @@ struct mem_cgroup {
          */
         bool use_hierarchy;
 
+        /*
+         * Should the OOM killer kill all belonging tasks, had it kill one?
+         */
+        bool oom_group;
+
         /* protected by memcg_oom_lock */
         bool            oom_lock;
         int             under_oom;
@@ -271,7 +288,7 @@ struct mem_cgroup {
         bool                    tcpmem_active;
         int                     tcpmem_pressure;
 
-#ifndef CONFIG_SLOB
+#ifdef CONFIG_MEMCG_KMEM
         /* Index in the kmem_cache->memcg_params.memcg_caches array */
         int kmemcg_id;
         enum memcg_kmem_state kmem_state;
@@ -306,6 +323,11 @@ struct mem_cgroup {
 
 extern struct mem_cgroup *root_mem_cgroup;
 
+static inline bool mem_cgroup_is_root(struct mem_cgroup *memcg)
+{
+        return (memcg == root_mem_cgroup);
+}
+
 static inline bool mem_cgroup_disabled(void)
 {
         return !cgroup_subsys_enabled(memory_cgrp_subsys);
@@ -317,6 +339,9 @@ enum mem_cgroup_protection mem_cgroup_protected(struct mem_cgroup *root,
 int mem_cgroup_try_charge(struct page *page, struct mm_struct *mm,
                           gfp_t gfp_mask, struct mem_cgroup **memcgp,
                           bool compound);
+int mem_cgroup_try_charge_delay(struct page *page, struct mm_struct *mm,
+                          gfp_t gfp_mask, struct mem_cgroup **memcgp,
+                          bool compound);
 void mem_cgroup_commit_charge(struct page *page, struct mem_cgroup *memcg,
                               bool lrucare, bool compound);
 void mem_cgroup_cancel_charge(struct page *page, struct mem_cgroup *memcg,
@@ -370,11 +395,21 @@ struct lruvec *mem_cgroup_page_lruvec(struct page *, struct pglist_data *);
 bool task_in_mem_cgroup(struct task_struct *task, struct mem_cgroup *memcg);
 struct mem_cgroup *mem_cgroup_from_task(struct task_struct *p);
 
+struct mem_cgroup *get_mem_cgroup_from_mm(struct mm_struct *mm);
+
+struct mem_cgroup *get_mem_cgroup_from_page(struct page *page);
+
 static inline
 struct mem_cgroup *mem_cgroup_from_css(struct cgroup_subsys_state *css){
         return css ? container_of(css, struct mem_cgroup, css) : NULL;
 }
 
+static inline void mem_cgroup_put(struct mem_cgroup *memcg)
+{
+        if (memcg)
+                css_put(&memcg->css);
+}
+
 #define mem_cgroup_from_counter(counter, member)        \
         container_of(counter, struct mem_cgroup, member)
 
@@ -494,16 +529,16 @@ unsigned long mem_cgroup_get_max(struct mem_cgroup *memcg);
 void mem_cgroup_print_oom_info(struct mem_cgroup *memcg,
                                 struct task_struct *p);
 
-static inline void mem_cgroup_oom_enable(void)
+static inline void mem_cgroup_enter_user_fault(void)
 {
-        WARN_ON(current->memcg_may_oom);
-        current->memcg_may_oom = 1;
+        WARN_ON(current->in_user_fault);
+        current->in_user_fault = 1;
 }
 
-static inline void mem_cgroup_oom_disable(void)
+static inline void mem_cgroup_exit_user_fault(void)
 {
-        WARN_ON(!current->memcg_may_oom);
-        current->memcg_may_oom = 0;
+        WARN_ON(!current->in_user_fault);
+        current->in_user_fault = 0;
 }
 
 static inline bool task_in_memcg_oom(struct task_struct *p)
@@ -512,6 +547,9 @@ static inline bool task_in_memcg_oom(struct task_struct *p)
 }
 
 bool mem_cgroup_oom_synchronize(bool wait);
+struct mem_cgroup *mem_cgroup_get_oom_group(struct task_struct *victim,
+                                            struct mem_cgroup *oom_domain);
+void mem_cgroup_print_oom_group(struct mem_cgroup *memcg);
 
 #ifdef CONFIG_MEMCG_SWAP
 extern int do_swap_account;
@@ -759,6 +797,11 @@ void mem_cgroup_split_huge_fixup(struct page *head);
 
 struct mem_cgroup;
 
+static inline bool mem_cgroup_is_root(struct mem_cgroup *memcg)
+{
+        return true;
+}
+
 static inline bool mem_cgroup_disabled(void)
 {
         return true;
@@ -789,6 +832,16 @@ static inline int mem_cgroup_try_charge(struct page *page, struct mm_struct *mm,
         return 0;
 }
 
+static inline int mem_cgroup_try_charge_delay(struct page *page,
+                                              struct mm_struct *mm,
+                                              gfp_t gfp_mask,
+                                              struct mem_cgroup **memcgp,
+                                              bool compound)
+{
+        *memcgp = NULL;
+        return 0;
+}
+
 static inline void mem_cgroup_commit_charge(struct page *page,
                                             struct mem_cgroup *memcg,
                                             bool lrucare, bool compound)
@@ -837,6 +890,20 @@ static inline bool task_in_mem_cgroup(struct task_struct *task,
         return true;
 }
 
+static inline struct mem_cgroup *get_mem_cgroup_from_mm(struct mm_struct *mm)
+{
+        return NULL;
+}
+
+static inline struct mem_cgroup *get_mem_cgroup_from_page(struct page *page)
+{
+        return NULL;
+}
+
+static inline void mem_cgroup_put(struct mem_cgroup *memcg)
+{
+}
+
 static inline struct mem_cgroup *
 mem_cgroup_iter(struct mem_cgroup *root,
                 struct mem_cgroup *prev,
@@ -924,11 +991,11 @@ static inline void mem_cgroup_handle_over_high(void)
 {
 }
 
-static inline void mem_cgroup_oom_enable(void)
+static inline void mem_cgroup_enter_user_fault(void)
 {
 }
 
-static inline void mem_cgroup_oom_disable(void)
+static inline void mem_cgroup_exit_user_fault(void)
 {
 }
 
@@ -942,6 +1009,16 @@ static inline bool mem_cgroup_oom_synchronize(bool wait)
         return false;
 }
 
+static inline struct mem_cgroup *mem_cgroup_get_oom_group(
+        struct task_struct *victim, struct mem_cgroup *oom_domain)
+{
+        return NULL;
+}
+
+static inline void mem_cgroup_print_oom_group(struct mem_cgroup *memcg)
+{
+}
+
 static inline unsigned long memcg_page_state(struct mem_cgroup *memcg,
                                              int idx)
 {
@@ -1194,7 +1271,7 @@ int memcg_kmem_charge_memcg(struct page *page, gfp_t gfp, int order,
 int memcg_kmem_charge(struct page *page, gfp_t gfp, int order);
 void memcg_kmem_uncharge(struct page *page, int order);
 
-#if defined(CONFIG_MEMCG) && !defined(CONFIG_SLOB)
+#ifdef CONFIG_MEMCG_KMEM
 extern struct static_key_false memcg_kmem_enabled_key;
 extern struct workqueue_struct *memcg_kmem_cache_wq;
 
@@ -1225,6 +1302,10 @@ static inline int memcg_cache_id(struct mem_cgroup *memcg)
         return memcg ? memcg->kmemcg_id : -1;
 }
 
+extern int memcg_expand_shrinker_maps(int new_id);
+
+extern void memcg_set_shrinker_bit(struct mem_cgroup *memcg,
+                                   int nid, int shrinker_id);
 #else
 #define for_each_memcg_cache_index(_idx)        \
         for (; NULL; )
@@ -1247,6 +1328,8 @@ static inline void memcg_put_cache_ids(void)
 {
 }
 
-#endif /* CONFIG_MEMCG && !CONFIG_SLOB */
+static inline void memcg_set_shrinker_bit(struct mem_cgroup *memcg,
+                                          int nid, int shrinker_id) { }
+#endif /* CONFIG_MEMCG_KMEM */
 
 #endif /* _LINUX_MEMCONTROL_H */
diff --git a/include/linux/memory_hotplug.h b/include/linux/memory_hotplug.h
index 4e9828cda7a2..34a28227068d 100644
--- a/include/linux/memory_hotplug.h
+++ b/include/linux/memory_hotplug.h
@@ -319,6 +319,7 @@ static inline int offline_pages(unsigned long start_pfn, unsigned long nr_pages)
 static inline void remove_memory(int nid, u64 start, u64 size) {}
 #endif /* CONFIG_MEMORY_HOTREMOVE */
 
+extern void __ref free_area_init_core_hotplug(int nid);
 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);
diff --git a/include/linux/mfd/as3722.h b/include/linux/mfd/as3722.h
index 51e6f9414575..b404a5af9bba 100644
--- a/include/linux/mfd/as3722.h
+++ b/include/linux/mfd/as3722.h
@@ -296,6 +296,8 @@
 #define AS3722_ADC1_CONV_NOTREADY                       BIT(7)
 #define AS3722_ADC1_SOURCE_SELECT_MASK                  0x1F
 
+#define AS3722_CTRL_SEQU1_AC_OK_PWR_ON                  BIT(0)
+
 /* GPIO modes */
 #define AS3722_GPIO_MODE_MASK                           0x07
 #define AS3722_GPIO_MODE_INPUT                          0x00
@@ -391,6 +393,7 @@ struct as3722 {
         unsigned long irq_flags;
         bool en_intern_int_pullup;
         bool en_intern_i2c_pullup;
+        bool en_ac_ok_pwr_on;
         struct regmap_irq_chip_data *irq_data;
 };
 
diff --git a/include/linux/mfd/cros_ec.h b/include/linux/mfd/cros_ec.h
index 32421dfeb996..20949dde35cd 100644
--- a/include/linux/mfd/cros_ec.h
+++ b/include/linux/mfd/cros_ec.h
@@ -147,7 +147,7 @@ struct cros_ec_device {
         bool mkbp_event_supported;
         struct blocking_notifier_head event_notifier;
 
-        struct ec_response_get_next_event event_data;
+        struct ec_response_get_next_event_v1 event_data;
         int event_size;
         u32 host_event_wake_mask;
 };
diff --git a/include/linux/mfd/cros_ec_commands.h b/include/linux/mfd/cros_ec_commands.h
index f2edd9969b40..6e1ab9bead28 100644
--- a/include/linux/mfd/cros_ec_commands.h
+++ b/include/linux/mfd/cros_ec_commands.h
@@ -804,6 +804,8 @@ enum ec_feature_code {
         EC_FEATURE_MOTION_SENSE_FIFO = 24,
         /* EC has RTC feature that can be controlled by host commands */
         EC_FEATURE_RTC = 27,
+        /* EC supports CEC commands */
+        EC_FEATURE_CEC = 35,
 };
 
 #define EC_FEATURE_MASK_0(event_code) (1UL << (event_code % 32))
@@ -2078,6 +2080,12 @@ enum ec_mkbp_event {
         /* EC sent a sysrq command */
         EC_MKBP_EVENT_SYSRQ = 6,
 
+        /* Notify the AP that something happened on CEC */
+        EC_MKBP_EVENT_CEC_EVENT = 8,
+
+        /* Send an incoming CEC message to the AP */
+        EC_MKBP_EVENT_CEC_MESSAGE = 9,
+
         /* Number of MKBP events */
         EC_MKBP_EVENT_COUNT,
 };
@@ -2093,12 +2101,28 @@ union ec_response_get_next_data {
         uint32_t   sysrq;
 } __packed;
 
+union ec_response_get_next_data_v1 {
+        uint8_t key_matrix[16];
+        uint32_t host_event;
+        uint32_t buttons;
+        uint32_t switches;
+        uint32_t sysrq;
+        uint32_t cec_events;
+        uint8_t cec_message[16];
+} __packed;
+
 struct ec_response_get_next_event {
         uint8_t event_type;
         /* Followed by event data if any */
         union ec_response_get_next_data data;
 } __packed;
 
+struct ec_response_get_next_event_v1 {
+        uint8_t event_type;
+        /* Followed by event data if any */
+        union ec_response_get_next_data_v1 data;
+} __packed;
+
 /* Bit indices for buttons and switches.*/
 /* Buttons */
 #define EC_MKBP_POWER_BUTTON    0
@@ -2593,14 +2617,18 @@ struct ec_params_current_limit {
 } __packed;
 
 /*
- * Set maximum external power current.
+ * Set maximum external voltage / current.
  */
-#define EC_CMD_EXT_POWER_CURRENT_LIMIT 0xa2
+#define EC_CMD_EXTERNAL_POWER_LIMIT 0x00A2
 
-struct ec_params_ext_power_current_limit {
-        uint32_t limit; /* in mA */
+/* Command v0 is used only on Spring and is obsolete + unsupported */
+struct ec_params_external_power_limit_v1 {
+        uint16_t current_lim; /* in mA, or EC_POWER_LIMIT_NONE to clear limit */
+        uint16_t voltage_lim; /* in mV, or EC_POWER_LIMIT_NONE to clear limit */
 } __packed;
 
+#define EC_POWER_LIMIT_NONE 0xffff
+
 /* Inform the EC when entering a sleep state */
 #define EC_CMD_HOST_SLEEP_EVENT 0xa9
 
@@ -2831,6 +2859,79 @@ struct ec_params_reboot_ec {
 
 /*****************************************************************************/
 /*
+ * HDMI CEC commands
+ *
+ * These commands are for sending and receiving message via HDMI CEC
+ */
+#define EC_MAX_CEC_MSG_LEN 16
+
+/* CEC message from the AP to be written on the CEC bus */
+#define EC_CMD_CEC_WRITE_MSG 0x00B8
+
+/**
+ * struct ec_params_cec_write - Message to write to the CEC bus
+ * @msg: message content to write to the CEC bus
+ */
+struct ec_params_cec_write {
+        uint8_t msg[EC_MAX_CEC_MSG_LEN];
+} __packed;
+
+/* Set various CEC parameters */
+#define EC_CMD_CEC_SET 0x00BA
+
+/**
+ * struct ec_params_cec_set - CEC parameters set
+ * @cmd: parameter type, can be CEC_CMD_ENABLE or CEC_CMD_LOGICAL_ADDRESS
+ * @val: in case cmd is CEC_CMD_ENABLE, this field can be 0 to disable CEC
+ *      or 1 to enable CEC functionality, in case cmd is CEC_CMD_LOGICAL_ADDRESS,
+ *      this field encodes the requested logical address between 0 and 15
+ *      or 0xff to unregister
+ */
+struct ec_params_cec_set {
+        uint8_t cmd; /* enum cec_command */
+        uint8_t val;
+} __packed;
+
+/* Read various CEC parameters */
+#define EC_CMD_CEC_GET 0x00BB
+
+/**
+ * struct ec_params_cec_get - CEC parameters get
+ * @cmd: parameter type, can be CEC_CMD_ENABLE or CEC_CMD_LOGICAL_ADDRESS
+ */
+struct ec_params_cec_get {
+        uint8_t cmd; /* enum cec_command */
+} __packed;
+
+/**
+ * struct ec_response_cec_get - CEC parameters get response
+ * @val: in case cmd was CEC_CMD_ENABLE, this field will 0 if CEC is
+ *      disabled or 1 if CEC functionality is enabled,
+ *      in case cmd was CEC_CMD_LOGICAL_ADDRESS, this will encode the
+ *      configured logical address between 0 and 15 or 0xff if unregistered
+ */
+struct ec_response_cec_get {
+        uint8_t val;
+} __packed;
+
+/* CEC parameters command */
+enum ec_cec_command {
+        /* CEC reading, writing and events enable */
+        CEC_CMD_ENABLE,
+        /* CEC logical address  */
+        CEC_CMD_LOGICAL_ADDRESS,
+};
+
+/* Events from CEC to AP */
+enum mkbp_cec_event {
+        /* Outgoing message was acknowledged by a follower */
+        EC_MKBP_CEC_SEND_OK                     = BIT(0),
+        /* Outgoing message was not acknowledged */
+        EC_MKBP_CEC_SEND_FAILED                 = BIT(1),
+};
+
+/*****************************************************************************/
+/*
  * Special commands
  *
  * These do not follow the normal rules for commands.  See each command for
@@ -2974,6 +3075,12 @@ enum usb_chg_type {
         USB_CHG_TYPE_VBUS,
         USB_CHG_TYPE_UNKNOWN,
 };
+enum usb_power_roles {
+        USB_PD_PORT_POWER_DISCONNECTED,
+        USB_PD_PORT_POWER_SOURCE,
+        USB_PD_PORT_POWER_SINK,
+        USB_PD_PORT_POWER_SINK_NOT_CHARGING,
+};
 
 struct usb_chg_measures {
         uint16_t voltage_max;
@@ -2991,6 +3098,120 @@ struct ec_response_usb_pd_power_info {
         uint32_t max_power;
 } __packed;
 
+struct ec_params_usb_pd_info_request {
+        uint8_t port;
+} __packed;
+
+/* Read USB-PD Device discovery info */
+#define EC_CMD_USB_PD_DISCOVERY 0x0113
+struct ec_params_usb_pd_discovery_entry {
+        uint16_t vid;  /* USB-IF VID */
+        uint16_t pid;  /* USB-IF PID */
+        uint8_t ptype; /* product type (hub,periph,cable,ama) */
+} __packed;
+
+/* Override default charge behavior */
+#define EC_CMD_PD_CHARGE_PORT_OVERRIDE 0x0114
+
+/* Negative port parameters have special meaning */
+enum usb_pd_override_ports {
+        OVERRIDE_DONT_CHARGE = -2,
+        OVERRIDE_OFF = -1,
+        /* [0, CONFIG_USB_PD_PORT_COUNT): Port# */
+};
+
+struct ec_params_charge_port_override {
+        int16_t override_port; /* Override port# */
+} __packed;
+
+/* Read (and delete) one entry of PD event log */
+#define EC_CMD_PD_GET_LOG_ENTRY 0x0115
+
+struct ec_response_pd_log {
+        uint32_t timestamp; /* relative timestamp in milliseconds */
+        uint8_t type;       /* event type : see PD_EVENT_xx below */
+        uint8_t size_port;  /* [7:5] port number [4:0] payload size in bytes */
+        uint16_t data;      /* type-defined data payload */
+        uint8_t payload[0]; /* optional additional data payload: 0..16 bytes */
+} __packed;
+
+/* The timestamp is the microsecond counter shifted to get about a ms. */
+#define PD_LOG_TIMESTAMP_SHIFT 10 /* 1 LSB = 1024us */
+
+#define PD_LOG_SIZE_MASK  0x1f
+#define PD_LOG_PORT_MASK  0xe0
+#define PD_LOG_PORT_SHIFT    5
+#define PD_LOG_PORT_SIZE(port, size) (((port) << PD_LOG_PORT_SHIFT) | \
+                                      ((size) & PD_LOG_SIZE_MASK))
+#define PD_LOG_PORT(size_port) ((size_port) >> PD_LOG_PORT_SHIFT)
+#define PD_LOG_SIZE(size_port) ((size_port) & PD_LOG_SIZE_MASK)
+
+/* PD event log : entry types */
+/* PD MCU events */
+#define PD_EVENT_MCU_BASE       0x00
+#define PD_EVENT_MCU_CHARGE             (PD_EVENT_MCU_BASE+0)
+#define PD_EVENT_MCU_CONNECT            (PD_EVENT_MCU_BASE+1)
+/* Reserved for custom board event */
+#define PD_EVENT_MCU_BOARD_CUSTOM       (PD_EVENT_MCU_BASE+2)
+/* PD generic accessory events */
+#define PD_EVENT_ACC_BASE       0x20
+#define PD_EVENT_ACC_RW_FAIL   (PD_EVENT_ACC_BASE+0)
+#define PD_EVENT_ACC_RW_ERASE  (PD_EVENT_ACC_BASE+1)
+/* PD power supply events */
+#define PD_EVENT_PS_BASE        0x40
+#define PD_EVENT_PS_FAULT      (PD_EVENT_PS_BASE+0)
+/* PD video dongles events */
+#define PD_EVENT_VIDEO_BASE     0x60
+#define PD_EVENT_VIDEO_DP_MODE (PD_EVENT_VIDEO_BASE+0)
+#define PD_EVENT_VIDEO_CODEC   (PD_EVENT_VIDEO_BASE+1)
+/* Returned in the "type" field, when there is no entry available */
+#define PD_EVENT_NO_ENTRY       0xff
+
+/*
+ * PD_EVENT_MCU_CHARGE event definition :
+ * the payload is "struct usb_chg_measures"
+ * the data field contains the port state flags as defined below :
+ */
+/* Port partner is a dual role device */
+#define CHARGE_FLAGS_DUAL_ROLE         BIT(15)
+/* Port is the pending override port */
+#define CHARGE_FLAGS_DELAYED_OVERRIDE  BIT(14)
+/* Port is the override port */
+#define CHARGE_FLAGS_OVERRIDE          BIT(13)
+/* Charger type */
+#define CHARGE_FLAGS_TYPE_SHIFT               3
+#define CHARGE_FLAGS_TYPE_MASK       (0xf << CHARGE_FLAGS_TYPE_SHIFT)
+/* Power delivery role */
+#define CHARGE_FLAGS_ROLE_MASK         (7 <<  0)
+
+/*
+ * PD_EVENT_PS_FAULT data field flags definition :
+ */
+#define PS_FAULT_OCP                          1
+#define PS_FAULT_FAST_OCP                     2
+#define PS_FAULT_OVP                          3
+#define PS_FAULT_DISCH                        4
+
+/*
+ * PD_EVENT_VIDEO_CODEC payload is "struct mcdp_info".
+ */
+struct mcdp_version {
+        uint8_t major;
+        uint8_t minor;
+        uint16_t build;
+} __packed;
+
+struct mcdp_info {
+        uint8_t family[2];
+        uint8_t chipid[2];
+        struct mcdp_version irom;
+        struct mcdp_version fw;
+} __packed;
+
+/* struct mcdp_info field decoding */
+#define MCDP_CHIPID(chipid) ((chipid[0] << 8) | chipid[1])
+#define MCDP_FAMILY(family) ((family[0] << 8) | family[1])
+
 /* Get info about USB-C SS muxes */
 #define EC_CMD_USB_PD_MUX_INFO 0x11a
 
diff --git a/include/linux/mfd/da9063/core.h b/include/linux/mfd/da9063/core.h
index f3ae65db4c86..71b09154e2db 100644
--- a/include/linux/mfd/da9063/core.h
+++ b/include/linux/mfd/da9063/core.h
@@ -29,8 +29,11 @@
 #define DA9063_DRVNAME_RTC              "da9063-rtc"
 #define DA9063_DRVNAME_VIBRATION        "da9063-vibration"
 
-enum da9063_models {
-        PMIC_DA9063 = 0x61,
+#define PMIC_CHIP_ID_DA9063             0x61
+
+enum da9063_type {
+        PMIC_TYPE_DA9063 = 0,
+        PMIC_TYPE_DA9063L,
 };
 
 enum da9063_variant_codes {
@@ -72,13 +75,10 @@ enum da9063_irqs {
         DA9063_IRQ_GPI15,
 };
 
-#define DA9063_IRQ_BASE_OFFSET  0
-#define DA9063_NUM_IRQ          (DA9063_IRQ_GPI15 + 1 - DA9063_IRQ_BASE_OFFSET)
-
 struct da9063 {
         /* Device */
         struct device   *dev;
-        unsigned short  model;
+        enum da9063_type type;
         unsigned char   variant_code;
         unsigned int    flags;
 
@@ -94,7 +94,4 @@ struct da9063 {
 int da9063_device_init(struct da9063 *da9063, unsigned int irq);
 int da9063_irq_init(struct da9063 *da9063);
 
-void da9063_device_exit(struct da9063 *da9063);
-void da9063_irq_exit(struct da9063 *da9063);
-
 #endif /* __MFD_DA9063_CORE_H__ */
diff --git a/include/linux/mfd/madera/core.h b/include/linux/mfd/madera/core.h
new file mode 100644
index 000000000000..c332681848ef
--- /dev/null
+++ b/include/linux/mfd/madera/core.h
@@ -0,0 +1,187 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * MFD internals for Cirrus Logic Madera codecs
+ *
+ * Copyright (C) 2015-2018 Cirrus Logic
+ *
+ * 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.
+ */
+
+#ifndef MADERA_CORE_H
+#define MADERA_CORE_H
+
+#include <linux/gpio/consumer.h>
+#include <linux/interrupt.h>
+#include <linux/mfd/madera/pdata.h>
+#include <linux/notifier.h>
+#include <linux/regmap.h>
+#include <linux/regulator/consumer.h>
+
+enum madera_type {
+        /* 0 is reserved for indicating failure to identify */
+        CS47L35 = 1,
+        CS47L85 = 2,
+        CS47L90 = 3,
+        CS47L91 = 4,
+        WM1840 = 7,
+};
+
+#define MADERA_MAX_CORE_SUPPLIES        2
+#define MADERA_MAX_GPIOS                40
+
+#define CS47L35_NUM_GPIOS               16
+#define CS47L85_NUM_GPIOS               40
+#define CS47L90_NUM_GPIOS               38
+
+#define MADERA_MAX_MICBIAS              4
+
+/* Notifier events */
+#define MADERA_NOTIFY_VOICE_TRIGGER     0x1
+#define MADERA_NOTIFY_HPDET             0x2
+#define MADERA_NOTIFY_MICDET            0x4
+
+/* GPIO Function Definitions */
+#define MADERA_GP_FN_ALTERNATE          0x00
+#define MADERA_GP_FN_GPIO               0x01
+#define MADERA_GP_FN_DSP_GPIO           0x02
+#define MADERA_GP_FN_IRQ1               0x03
+#define MADERA_GP_FN_IRQ2               0x04
+#define MADERA_GP_FN_FLL1_CLOCK         0x10
+#define MADERA_GP_FN_FLL2_CLOCK         0x11
+#define MADERA_GP_FN_FLL3_CLOCK         0x12
+#define MADERA_GP_FN_FLLAO_CLOCK        0x13
+#define MADERA_GP_FN_FLL1_LOCK          0x18
+#define MADERA_GP_FN_FLL2_LOCK          0x19
+#define MADERA_GP_FN_FLL3_LOCK          0x1A
+#define MADERA_GP_FN_FLLAO_LOCK         0x1B
+#define MADERA_GP_FN_OPCLK_OUT          0x40
+#define MADERA_GP_FN_OPCLK_ASYNC_OUT    0x41
+#define MADERA_GP_FN_PWM1               0x48
+#define MADERA_GP_FN_PWM2               0x49
+#define MADERA_GP_FN_SPDIF_OUT          0x4C
+#define MADERA_GP_FN_HEADPHONE_DET      0x50
+#define MADERA_GP_FN_MIC_DET            0x58
+#define MADERA_GP_FN_DRC1_SIGNAL_DETECT 0x80
+#define MADERA_GP_FN_DRC2_SIGNAL_DETECT 0x81
+#define MADERA_GP_FN_ASRC1_IN1_LOCK     0x88
+#define MADERA_GP_FN_ASRC1_IN2_LOCK     0x89
+#define MADERA_GP_FN_ASRC2_IN1_LOCK     0x8A
+#define MADERA_GP_FN_ASRC2_IN2_LOCK     0x8B
+#define MADERA_GP_FN_DSP_IRQ1           0xA0
+#define MADERA_GP_FN_DSP_IRQ2           0xA1
+#define MADERA_GP_FN_DSP_IRQ3           0xA2
+#define MADERA_GP_FN_DSP_IRQ4           0xA3
+#define MADERA_GP_FN_DSP_IRQ5           0xA4
+#define MADERA_GP_FN_DSP_IRQ6           0xA5
+#define MADERA_GP_FN_DSP_IRQ7           0xA6
+#define MADERA_GP_FN_DSP_IRQ8           0xA7
+#define MADERA_GP_FN_DSP_IRQ9           0xA8
+#define MADERA_GP_FN_DSP_IRQ10          0xA9
+#define MADERA_GP_FN_DSP_IRQ11          0xAA
+#define MADERA_GP_FN_DSP_IRQ12          0xAB
+#define MADERA_GP_FN_DSP_IRQ13          0xAC
+#define MADERA_GP_FN_DSP_IRQ14          0xAD
+#define MADERA_GP_FN_DSP_IRQ15          0xAE
+#define MADERA_GP_FN_DSP_IRQ16          0xAF
+#define MADERA_GP_FN_HPOUT1L_SC         0xB0
+#define MADERA_GP_FN_HPOUT1R_SC         0xB1
+#define MADERA_GP_FN_HPOUT2L_SC         0xB2
+#define MADERA_GP_FN_HPOUT2R_SC         0xB3
+#define MADERA_GP_FN_HPOUT3L_SC         0xB4
+#define MADERA_GP_FN_HPOUT4R_SC         0xB5
+#define MADERA_GP_FN_SPKOUTL_SC         0xB6
+#define MADERA_GP_FN_SPKOUTR_SC         0xB7
+#define MADERA_GP_FN_HPOUT1L_ENA        0xC0
+#define MADERA_GP_FN_HPOUT1R_ENA        0xC1
+#define MADERA_GP_FN_HPOUT2L_ENA        0xC2
+#define MADERA_GP_FN_HPOUT2R_ENA        0xC3
+#define MADERA_GP_FN_HPOUT3L_ENA        0xC4
+#define MADERA_GP_FN_HPOUT4R_ENA        0xC5
+#define MADERA_GP_FN_SPKOUTL_ENA        0xC6
+#define MADERA_GP_FN_SPKOUTR_ENA        0xC7
+#define MADERA_GP_FN_HPOUT1L_DIS        0xD0
+#define MADERA_GP_FN_HPOUT1R_DIS        0xD1
+#define MADERA_GP_FN_HPOUT2L_DIS        0xD2
+#define MADERA_GP_FN_HPOUT2R_DIS        0xD3
+#define MADERA_GP_FN_HPOUT3L_DIS        0xD4
+#define MADERA_GP_FN_HPOUT4R_DIS        0xD5
+#define MADERA_GP_FN_SPKOUTL_DIS        0xD6
+#define MADERA_GP_FN_SPKOUTR_DIS        0xD7
+#define MADERA_GP_FN_SPK_SHUTDOWN       0xE0
+#define MADERA_GP_FN_SPK_OVH_SHUTDOWN   0xE1
+#define MADERA_GP_FN_SPK_OVH_WARN       0xE2
+#define MADERA_GP_FN_TIMER1_STATUS      0x140
+#define MADERA_GP_FN_TIMER2_STATUS      0x141
+#define MADERA_GP_FN_TIMER3_STATUS      0x142
+#define MADERA_GP_FN_TIMER4_STATUS      0x143
+#define MADERA_GP_FN_TIMER5_STATUS      0x144
+#define MADERA_GP_FN_TIMER6_STATUS      0x145
+#define MADERA_GP_FN_TIMER7_STATUS      0x146
+#define MADERA_GP_FN_TIMER8_STATUS      0x147
+#define MADERA_GP_FN_EVENTLOG1_FIFO_STS 0x150
+#define MADERA_GP_FN_EVENTLOG2_FIFO_STS 0x151
+#define MADERA_GP_FN_EVENTLOG3_FIFO_STS 0x152
+#define MADERA_GP_FN_EVENTLOG4_FIFO_STS 0x153
+#define MADERA_GP_FN_EVENTLOG5_FIFO_STS 0x154
+#define MADERA_GP_FN_EVENTLOG6_FIFO_STS 0x155
+#define MADERA_GP_FN_EVENTLOG7_FIFO_STS 0x156
+#define MADERA_GP_FN_EVENTLOG8_FIFO_STS 0x157
+
+struct snd_soc_dapm_context;
+
+/*
+ * struct madera - internal data shared by the set of Madera drivers
+ *
+ * This should not be used by anything except child drivers of the Madera MFD
+ *
+ * @regmap:             pointer to the regmap instance for 16-bit registers
+ * @regmap_32bit:       pointer to the regmap instance for 32-bit registers
+ * @dev:                pointer to the MFD device
+ * @type:               type of codec
+ * @rev:                silicon revision
+ * @type_name:          display name of this codec
+ * @num_core_supplies:  number of core supply regulators
+ * @core_supplies:      list of core supplies that are always required
+ * @dcvdd:              pointer to DCVDD regulator
+ * @internal_dcvdd:     true if DCVDD is supplied from the internal LDO1
+ * @pdata:              our pdata
+ * @irq_dev:            the irqchip child driver device
+ * @irq:                host irq number from SPI or I2C configuration
+ * @out_clamp:          indicates output clamp state for each analogue output
+ * @out_shorted:        indicates short circuit state for each analogue output
+ * @hp_ena:             bitflags of enable state for the headphone outputs
+ * @num_micbias:        number of MICBIAS outputs
+ * @num_childbias:      number of child biases for each MICBIAS
+ * @dapm:               pointer to codec driver DAPM context
+ * @notifier:           notifier for signalling events to ASoC machine driver
+ */
+struct madera {
+        struct regmap *regmap;
+        struct regmap *regmap_32bit;
+
+        struct device *dev;
+
+        enum madera_type type;
+        unsigned int rev;
+        const char *type_name;
+
+        int num_core_supplies;
+        struct regulator_bulk_data core_supplies[MADERA_MAX_CORE_SUPPLIES];
+        struct regulator *dcvdd;
+        bool internal_dcvdd;
+
+        struct madera_pdata pdata;
+
+        struct device *irq_dev;
+        int irq;
+
+        unsigned int num_micbias;
+        unsigned int num_childbias[MADERA_MAX_MICBIAS];
+
+        struct snd_soc_dapm_context *dapm;
+
+        struct blocking_notifier_head notifier;
+};
+#endif
diff --git a/include/linux/mfd/madera/pdata.h b/include/linux/mfd/madera/pdata.h
new file mode 100644
index 000000000000..0b311f39c8f4
--- /dev/null
+++ b/include/linux/mfd/madera/pdata.h
@@ -0,0 +1,59 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Platform data for Cirrus Logic Madera codecs
+ *
+ * Copyright (C) 2015-2018 Cirrus Logic
+ *
+ * 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.
+ */
+
+#ifndef MADERA_PDATA_H
+#define MADERA_PDATA_H
+
+#include <linux/kernel.h>
+#include <linux/regulator/arizona-ldo1.h>
+#include <linux/regulator/arizona-micsupp.h>
+#include <linux/regulator/machine.h>
+
+#define MADERA_MAX_MICBIAS              4
+#define MADERA_MAX_CHILD_MICBIAS        4
+
+#define MADERA_MAX_GPSW                 2
+
+struct gpio_desc;
+struct pinctrl_map;
+struct madera_irqchip_pdata;
+struct madera_codec_pdata;
+
+/**
+ * struct madera_pdata - Configuration data for Madera devices
+ *
+ * @reset:          GPIO controlling /RESET (NULL = none)
+ * @ldo1:           Substruct of pdata for the LDO1 regulator
+ * @micvdd:         Substruct of pdata for the MICVDD regulator
+ * @irq_flags:      Mode for primary IRQ (defaults to active low)
+ * @gpio_base:      Base GPIO number
+ * @gpio_configs:   Array of GPIO configurations (See Documentation/pinctrl.txt)
+ * @n_gpio_configs: Number of entries in gpio_configs
+ * @gpsw:           General purpose switch mode setting. Depends on the external
+ *                  hardware connected to the switch. (See the SW1_MODE field
+ *                  in the datasheet for the available values for your codec)
+ */
+struct madera_pdata {
+        struct gpio_desc *reset;
+
+        struct arizona_ldo1_pdata ldo1;
+        struct arizona_micsupp_pdata micvdd;
+
+        unsigned int irq_flags;
+        int gpio_base;
+
+        const struct pinctrl_map *gpio_configs;
+        int n_gpio_configs;
+
+        u32 gpsw[MADERA_MAX_GPSW];
+};
+
+#endif
diff --git a/include/linux/mfd/madera/registers.h b/include/linux/mfd/madera/registers.h
new file mode 100644
index 000000000000..977e06101711
--- /dev/null
+++ b/include/linux/mfd/madera/registers.h
@@ -0,0 +1,3968 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Madera register definitions
+ *
+ * Copyright (C) 2015-2018 Cirrus Logic
+ *
+ * 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.
+ */
+
+#ifndef MADERA_REGISTERS_H
+#define MADERA_REGISTERS_H
+
+/*
+ * Register Addresses.
+ */
+#define MADERA_SOFTWARE_RESET                           0x00
+#define MADERA_HARDWARE_REVISION                        0x01
+#define MADERA_CTRL_IF_CFG_1                            0x08
+#define MADERA_CTRL_IF_CFG_2                            0x09
+#define MADERA_CTRL_IF_CFG_3                            0x0A
+#define MADERA_WRITE_SEQUENCER_CTRL_0                   0x16
+#define MADERA_WRITE_SEQUENCER_CTRL_1                   0x17
+#define MADERA_WRITE_SEQUENCER_CTRL_2                   0x18
+#define MADERA_TONE_GENERATOR_1                         0x20
+#define MADERA_TONE_GENERATOR_2                         0x21
+#define MADERA_TONE_GENERATOR_3                         0x22
+#define MADERA_TONE_GENERATOR_4                         0x23
+#define MADERA_TONE_GENERATOR_5                         0x24
+#define MADERA_PWM_DRIVE_1                              0x30
+#define MADERA_PWM_DRIVE_2                              0x31
+#define MADERA_PWM_DRIVE_3                              0x32
+#define MADERA_SEQUENCE_CONTROL                         0x41
+#define MADERA_SAMPLE_RATE_SEQUENCE_SELECT_1            0x61
+#define MADERA_SAMPLE_RATE_SEQUENCE_SELECT_2            0x62
+#define MADERA_SAMPLE_RATE_SEQUENCE_SELECT_3            0x63
+#define MADERA_SAMPLE_RATE_SEQUENCE_SELECT_4            0x64
+#define MADERA_ALWAYS_ON_TRIGGERS_SEQUENCE_SELECT_1     0x66
+#define MADERA_ALWAYS_ON_TRIGGERS_SEQUENCE_SELECT_2     0x67
+#define MADERA_HAPTICS_CONTROL_1                        0x90
+#define MADERA_HAPTICS_CONTROL_2                        0x91
+#define MADERA_HAPTICS_PHASE_1_INTENSITY                0x92
+#define MADERA_HAPTICS_PHASE_1_DURATION                 0x93
+#define MADERA_HAPTICS_PHASE_2_INTENSITY                0x94
+#define MADERA_HAPTICS_PHASE_2_DURATION                 0x95
+#define MADERA_HAPTICS_PHASE_3_INTENSITY                0x96
+#define MADERA_HAPTICS_PHASE_3_DURATION                 0x97
+#define MADERA_HAPTICS_STATUS                           0x98
+#define MADERA_COMFORT_NOISE_GENERATOR                  0xA0
+#define MADERA_CLOCK_32K_1                              0x100
+#define MADERA_SYSTEM_CLOCK_1                           0x101
+#define MADERA_SAMPLE_RATE_1                            0x102
+#define MADERA_SAMPLE_RATE_2                            0x103
+#define MADERA_SAMPLE_RATE_3                            0x104
+#define MADERA_SAMPLE_RATE_1_STATUS                     0x10A
+#define MADERA_SAMPLE_RATE_2_STATUS                     0x10B
+#define MADERA_SAMPLE_RATE_3_STATUS                     0x10C
+#define MADERA_ASYNC_CLOCK_1                            0x112
+#define MADERA_ASYNC_SAMPLE_RATE_1                      0x113
+#define MADERA_ASYNC_SAMPLE_RATE_2                      0x114
+#define MADERA_ASYNC_SAMPLE_RATE_1_STATUS               0x11B
+#define MADERA_ASYNC_SAMPLE_RATE_2_STATUS               0x11C
+#define MADERA_DSP_CLOCK_1                              0x120
+#define MADERA_DSP_CLOCK_2                              0x122
+#define MADERA_OUTPUT_SYSTEM_CLOCK                      0x149
+#define MADERA_OUTPUT_ASYNC_CLOCK                       0x14A
+#define MADERA_RATE_ESTIMATOR_1                         0x152
+#define MADERA_RATE_ESTIMATOR_2                         0x153
+#define MADERA_RATE_ESTIMATOR_3                         0x154
+#define MADERA_RATE_ESTIMATOR_4                         0x155
+#define MADERA_RATE_ESTIMATOR_5                         0x156
+#define MADERA_FLL1_CONTROL_1                           0x171
+#define MADERA_FLL1_CONTROL_2                           0x172
+#define MADERA_FLL1_CONTROL_3                           0x173
+#define MADERA_FLL1_CONTROL_4                           0x174
+#define MADERA_FLL1_CONTROL_5                           0x175
+#define MADERA_FLL1_CONTROL_6                           0x176
+#define MADERA_FLL1_LOOP_FILTER_TEST_1                  0x177
+#define MADERA_FLL1_NCO_TEST_0                          0x178
+#define MADERA_FLL1_CONTROL_7                           0x179
+#define MADERA_FLL1_EFS_2                               0x17A
+#define CS47L35_FLL1_SYNCHRONISER_1                     0x17F
+#define CS47L35_FLL1_SYNCHRONISER_2                     0x180
+#define CS47L35_FLL1_SYNCHRONISER_3                     0x181
+#define CS47L35_FLL1_SYNCHRONISER_4                     0x182
+#define CS47L35_FLL1_SYNCHRONISER_5                     0x183
+#define CS47L35_FLL1_SYNCHRONISER_6                     0x184
+#define CS47L35_FLL1_SYNCHRONISER_7                     0x185
+#define CS47L35_FLL1_SPREAD_SPECTRUM                    0x187
+#define CS47L35_FLL1_GPIO_CLOCK                         0x188
+#define MADERA_FLL1_SYNCHRONISER_1                      0x181
+#define MADERA_FLL1_SYNCHRONISER_2                      0x182
+#define MADERA_FLL1_SYNCHRONISER_3                      0x183
+#define MADERA_FLL1_SYNCHRONISER_4                      0x184
+#define MADERA_FLL1_SYNCHRONISER_5                      0x185
+#define MADERA_FLL1_SYNCHRONISER_6                      0x186
+#define MADERA_FLL1_SYNCHRONISER_7                      0x187
+#define MADERA_FLL1_SPREAD_SPECTRUM                     0x189
+#define MADERA_FLL1_GPIO_CLOCK                          0x18A
+#define MADERA_FLL2_CONTROL_1                           0x191
+#define MADERA_FLL2_CONTROL_2                           0x192
+#define MADERA_FLL2_CONTROL_3                           0x193
+#define MADERA_FLL2_CONTROL_4                           0x194
+#define MADERA_FLL2_CONTROL_5                           0x195
+#define MADERA_FLL2_CONTROL_6                           0x196
+#define MADERA_FLL2_LOOP_FILTER_TEST_1                  0x197
+#define MADERA_FLL2_NCO_TEST_0                          0x198
+#define MADERA_FLL2_CONTROL_7                           0x199
+#define MADERA_FLL2_EFS_2                               0x19A
+#define MADERA_FLL2_SYNCHRONISER_1                      0x1A1
+#define MADERA_FLL2_SYNCHRONISER_2                      0x1A2
+#define MADERA_FLL2_SYNCHRONISER_3                      0x1A3
+#define MADERA_FLL2_SYNCHRONISER_4                      0x1A4
+#define MADERA_FLL2_SYNCHRONISER_5                      0x1A5
+#define MADERA_FLL2_SYNCHRONISER_6                      0x1A6
+#define MADERA_FLL2_SYNCHRONISER_7                      0x1A7
+#define MADERA_FLL2_SPREAD_SPECTRUM                     0x1A9
+#define MADERA_FLL2_GPIO_CLOCK                          0x1AA
+#define MADERA_FLL3_CONTROL_1                           0x1B1
+#define MADERA_FLL3_CONTROL_2                           0x1B2
+#define MADERA_FLL3_CONTROL_3                           0x1B3
+#define MADERA_FLL3_CONTROL_4                           0x1B4
+#define MADERA_FLL3_CONTROL_5                           0x1B5
+#define MADERA_FLL3_CONTROL_6                           0x1B6
+#define MADERA_FLL3_LOOP_FILTER_TEST_1                  0x1B7
+#define MADERA_FLL3_NCO_TEST_0                          0x1B8
+#define MADERA_FLL3_CONTROL_7                           0x1B9
+#define MADERA_FLL3_SYNCHRONISER_1                      0x1C1
+#define MADERA_FLL3_SYNCHRONISER_2                      0x1C2
+#define MADERA_FLL3_SYNCHRONISER_3                      0x1C3
+#define MADERA_FLL3_SYNCHRONISER_4                      0x1C4
+#define MADERA_FLL3_SYNCHRONISER_5                      0x1C5
+#define MADERA_FLL3_SYNCHRONISER_6                      0x1C6
+#define MADERA_FLL3_SYNCHRONISER_7                      0x1C7
+#define MADERA_FLL3_SPREAD_SPECTRUM                     0x1C9
+#define MADERA_FLL3_GPIO_CLOCK                          0x1CA
+#define MADERA_FLLAO_CONTROL_1                          0x1D1
+#define MADERA_FLLAO_CONTROL_2                          0x1D2
+#define MADERA_FLLAO_CONTROL_3                          0x1D3
+#define MADERA_FLLAO_CONTROL_4                          0x1D4
+#define MADERA_FLLAO_CONTROL_5                          0x1D5
+#define MADERA_FLLAO_CONTROL_6                          0x1D6
+#define MADERA_FLLAO_CONTROL_7                          0x1D8
+#define MADERA_FLLAO_CONTROL_8                          0x1DA
+#define MADERA_FLLAO_CONTROL_9                          0x1DB
+#define MADERA_FLLAO_CONTROL_10                         0x1DC
+#define MADERA_FLLAO_CONTROL_11                         0x1DD
+#define MADERA_MIC_CHARGE_PUMP_1                        0x200
+#define MADERA_HP_CHARGE_PUMP_8                         0x20B
+#define MADERA_LDO1_CONTROL_1                           0x210
+#define MADERA_LDO2_CONTROL_1                           0x213
+#define MADERA_MIC_BIAS_CTRL_1                          0x218
+#define MADERA_MIC_BIAS_CTRL_2                          0x219
+#define MADERA_MIC_BIAS_CTRL_3                          0x21A
+#define MADERA_MIC_BIAS_CTRL_4                          0x21B
+#define MADERA_MIC_BIAS_CTRL_5                          0x21C
+#define MADERA_MIC_BIAS_CTRL_6                          0x21E
+#define MADERA_HP_CTRL_1L                               0x225
+#define MADERA_HP_CTRL_1R                               0x226
+#define MADERA_HP_CTRL_2L                               0x227
+#define MADERA_HP_CTRL_2R                               0x228
+#define MADERA_HP_CTRL_3L                               0x229
+#define MADERA_HP_CTRL_3R                               0x22A
+#define MADERA_DCS_HP1L_CONTROL                         0x232
+#define MADERA_DCS_HP1R_CONTROL                         0x238
+#define MADERA_EDRE_HP_STEREO_CONTROL                   0x27E
+#define MADERA_ACCESSORY_DETECT_MODE_1                  0x293
+#define MADERA_HEADPHONE_DETECT_0                       0x299
+#define MADERA_HEADPHONE_DETECT_1                       0x29B
+#define MADERA_HEADPHONE_DETECT_2                       0x29C
+#define MADERA_HEADPHONE_DETECT_3                       0x29D
+#define MADERA_HEADPHONE_DETECT_4                       0x29E
+#define MADERA_HEADPHONE_DETECT_5                       0x29F
+#define MADERA_MIC_DETECT_1_CONTROL_0                   0x2A2
+#define MADERA_MIC_DETECT_1_CONTROL_1                   0x2A3
+#define MADERA_MIC_DETECT_1_CONTROL_2                   0x2A4
+#define MADERA_MIC_DETECT_1_CONTROL_3                   0x2A5
+#define MADERA_MIC_DETECT_1_LEVEL_1                     0x2A6
+#define MADERA_MIC_DETECT_1_LEVEL_2                     0x2A7
+#define MADERA_MIC_DETECT_1_LEVEL_3                     0x2A8
+#define MADERA_MIC_DETECT_1_LEVEL_4                     0x2A9
+#define MADERA_MIC_DETECT_1_CONTROL_4                   0x2AB
+#define MADERA_MIC_DETECT_2_CONTROL_0                   0x2B2
+#define MADERA_MIC_DETECT_2_CONTROL_1                   0x2B3
+#define MADERA_MIC_DETECT_2_CONTROL_2                   0x2B4
+#define MADERA_MIC_DETECT_2_CONTROL_3                   0x2B5
+#define MADERA_MIC_DETECT_2_LEVEL_1                     0x2B6
+#define MADERA_MIC_DETECT_2_LEVEL_2                     0x2B7
+#define MADERA_MIC_DETECT_2_LEVEL_3                     0x2B8
+#define MADERA_MIC_DETECT_2_LEVEL_4                     0x2B9
+#define MADERA_MIC_DETECT_2_CONTROL_4                   0x2BB
+#define MADERA_MICD_CLAMP_CONTROL                       0x2C6
+#define MADERA_GP_SWITCH_1                              0x2C8
+#define MADERA_JACK_DETECT_ANALOGUE                     0x2D3
+#define MADERA_INPUT_ENABLES                            0x300
+#define MADERA_INPUT_ENABLES_STATUS                     0x301
+#define MADERA_INPUT_RATE                               0x308
+#define MADERA_INPUT_VOLUME_RAMP                        0x309
+#define MADERA_HPF_CONTROL                              0x30C
+#define MADERA_IN1L_CONTROL                             0x310
+#define MADERA_ADC_DIGITAL_VOLUME_1L                    0x311
+#define MADERA_DMIC1L_CONTROL                           0x312
+#define MADERA_IN1L_RATE_CONTROL                        0x313
+#define MADERA_IN1R_CONTROL                             0x314
+#define MADERA_ADC_DIGITAL_VOLUME_1R                    0x315
+#define MADERA_DMIC1R_CONTROL                           0x316
+#define MADERA_IN1R_RATE_CONTROL                        0x317
+#define MADERA_IN2L_CONTROL                             0x318
+#define MADERA_ADC_DIGITAL_VOLUME_2L                    0x319
+#define MADERA_DMIC2L_CONTROL                           0x31A
+#define MADERA_IN2L_RATE_CONTROL                        0x31B
+#define MADERA_IN2R_CONTROL                             0x31C
+#define MADERA_ADC_DIGITAL_VOLUME_2R                    0x31D
+#define MADERA_DMIC2R_CONTROL                           0x31E
+#define MADERA_IN2R_RATE_CONTROL                        0x31F
+#define MADERA_IN3L_CONTROL                             0x320
+#define MADERA_ADC_DIGITAL_VOLUME_3L                    0x321
+#define MADERA_DMIC3L_CONTROL                           0x322
+#define MADERA_IN3L_RATE_CONTROL                        0x323
+#define MADERA_IN3R_CONTROL                             0x324
+#define MADERA_ADC_DIGITAL_VOLUME_3R                    0x325
+#define MADERA_DMIC3R_CONTROL                           0x326
+#define MADERA_IN3R_RATE_CONTROL                        0x327
+#define MADERA_IN4L_CONTROL                             0x328
+#define MADERA_ADC_DIGITAL_VOLUME_4L                    0x329
+#define MADERA_DMIC4L_CONTROL                           0x32A
+#define MADERA_IN4L_RATE_CONTROL                        0x32B
+#define MADERA_IN4R_CONTROL                             0x32C
+#define MADERA_ADC_DIGITAL_VOLUME_4R                    0x32D
+#define MADERA_DMIC4R_CONTROL                           0x32E
+#define MADERA_IN4R_RATE_CONTROL                        0x32F
+#define MADERA_IN5L_CONTROL                             0x330
+#define MADERA_ADC_DIGITAL_VOLUME_5L                    0x331
+#define MADERA_DMIC5L_CONTROL                           0x332
+#define MADERA_IN5L_RATE_CONTROL                        0x333
+#define MADERA_IN5R_CONTROL                             0x334
+#define MADERA_ADC_DIGITAL_VOLUME_5R                    0x335
+#define MADERA_DMIC5R_CONTROL                           0x336
+#define MADERA_IN5R_RATE_CONTROL                        0x337
+#define MADERA_IN6L_CONTROL                             0x338
+#define MADERA_ADC_DIGITAL_VOLUME_6L                    0x339
+#define MADERA_DMIC6L_CONTROL                           0x33A
+#define MADERA_IN6R_CONTROL                             0x33C
+#define MADERA_ADC_DIGITAL_VOLUME_6R                    0x33D
+#define MADERA_DMIC6R_CONTROL                           0x33E
+#define MADERA_OUTPUT_ENABLES_1                         0x400
+#define MADERA_OUTPUT_STATUS_1                          0x401
+#define MADERA_RAW_OUTPUT_STATUS_1                      0x406
+#define MADERA_OUTPUT_RATE_1                            0x408
+#define MADERA_OUTPUT_VOLUME_RAMP                       0x409
+#define MADERA_OUTPUT_PATH_CONFIG_1L                    0x410
+#define MADERA_DAC_DIGITAL_VOLUME_1L                    0x411
+#define MADERA_OUTPUT_PATH_CONFIG_1                     0x412
+#define MADERA_NOISE_GATE_SELECT_1L                     0x413
+#define MADERA_OUTPUT_PATH_CONFIG_1R                    0x414
+#define MADERA_DAC_DIGITAL_VOLUME_1R                    0x415
+#define MADERA_NOISE_GATE_SELECT_1R                     0x417
+#define MADERA_OUTPUT_PATH_CONFIG_2L                    0x418
+#define MADERA_DAC_DIGITAL_VOLUME_2L                    0x419
+#define MADERA_OUTPUT_PATH_CONFIG_2                     0x41A
+#define MADERA_NOISE_GATE_SELECT_2L                     0x41B
+#define MADERA_OUTPUT_PATH_CONFIG_2R                    0x41C
+#define MADERA_DAC_DIGITAL_VOLUME_2R                    0x41D
+#define MADERA_NOISE_GATE_SELECT_2R                     0x41F
+#define MADERA_OUTPUT_PATH_CONFIG_3L                    0x420
+#define MADERA_DAC_DIGITAL_VOLUME_3L                    0x421
+#define MADERA_NOISE_GATE_SELECT_3L                     0x423
+#define MADERA_OUTPUT_PATH_CONFIG_3R                    0x424
+#define MADERA_DAC_DIGITAL_VOLUME_3R                    0x425
+#define MADERA_NOISE_GATE_SELECT_3R                     0x427
+#define MADERA_OUTPUT_PATH_CONFIG_4L                    0x428
+#define MADERA_DAC_DIGITAL_VOLUME_4L                    0x429
+#define MADERA_NOISE_GATE_SELECT_4L                     0x42B
+#define MADERA_OUTPUT_PATH_CONFIG_4R                    0x42C
+#define MADERA_DAC_DIGITAL_VOLUME_4R                    0x42D
+#define MADERA_NOISE_GATE_SELECT_4R                     0x42F
+#define MADERA_OUTPUT_PATH_CONFIG_5L                    0x430
+#define MADERA_DAC_DIGITAL_VOLUME_5L                    0x431
+#define MADERA_NOISE_GATE_SELECT_5L                     0x433
+#define MADERA_OUTPUT_PATH_CONFIG_5R                    0x434
+#define MADERA_DAC_DIGITAL_VOLUME_5R                    0x435
+#define MADERA_NOISE_GATE_SELECT_5R                     0x437
+#define MADERA_OUTPUT_PATH_CONFIG_6L                    0x438
+#define MADERA_DAC_DIGITAL_VOLUME_6L                    0x439
+#define MADERA_NOISE_GATE_SELECT_6L                     0x43B
+#define MADERA_OUTPUT_PATH_CONFIG_6R                    0x43C
+#define MADERA_DAC_DIGITAL_VOLUME_6R                    0x43D
+#define MADERA_NOISE_GATE_SELECT_6R                     0x43F
+#define MADERA_DRE_ENABLE                               0x440
+#define MADERA_EDRE_ENABLE                              0x448
+#define MADERA_EDRE_MANUAL                              0x44A
+#define MADERA_DAC_AEC_CONTROL_1                        0x450
+#define MADERA_DAC_AEC_CONTROL_2                        0x451
+#define MADERA_NOISE_GATE_CONTROL                       0x458
+#define MADERA_PDM_SPK1_CTRL_1                          0x490
+#define MADERA_PDM_SPK1_CTRL_2                          0x491
+#define MADERA_PDM_SPK2_CTRL_1                          0x492
+#define MADERA_PDM_SPK2_CTRL_2                          0x493
+#define MADERA_HP1_SHORT_CIRCUIT_CTRL                   0x4A0
+#define MADERA_HP2_SHORT_CIRCUIT_CTRL                   0x4A1
+#define MADERA_HP3_SHORT_CIRCUIT_CTRL                   0x4A2
+#define MADERA_HP_TEST_CTRL_1                           0x4A4
+#define MADERA_HP_TEST_CTRL_5                           0x4A8
+#define MADERA_HP_TEST_CTRL_6                           0x4A9
+#define MADERA_AIF1_BCLK_CTRL                           0x500
+#define MADERA_AIF1_TX_PIN_CTRL                         0x501
+#define MADERA_AIF1_RX_PIN_CTRL                         0x502
+#define MADERA_AIF1_RATE_CTRL                           0x503
+#define MADERA_AIF1_FORMAT                              0x504
+#define MADERA_AIF1_RX_BCLK_RATE                        0x506
+#define MADERA_AIF1_FRAME_CTRL_1                        0x507
+#define MADERA_AIF1_FRAME_CTRL_2                        0x508
+#define MADERA_AIF1_FRAME_CTRL_3                        0x509
+#define MADERA_AIF1_FRAME_CTRL_4                        0x50A
+#define MADERA_AIF1_FRAME_CTRL_5                        0x50B
+#define MADERA_AIF1_FRAME_CTRL_6                        0x50C
+#define MADERA_AIF1_FRAME_CTRL_7                        0x50D
+#define MADERA_AIF1_FRAME_CTRL_8                        0x50E
+#define MADERA_AIF1_FRAME_CTRL_9                        0x50F
+#define MADERA_AIF1_FRAME_CTRL_10                       0x510
+#define MADERA_AIF1_FRAME_CTRL_11                       0x511
+#define MADERA_AIF1_FRAME_CTRL_12                       0x512
+#define MADERA_AIF1_FRAME_CTRL_13                       0x513
+#define MADERA_AIF1_FRAME_CTRL_14                       0x514
+#define MADERA_AIF1_FRAME_CTRL_15                       0x515
+#define MADERA_AIF1_FRAME_CTRL_16                       0x516
+#define MADERA_AIF1_FRAME_CTRL_17                       0x517
+#define MADERA_AIF1_FRAME_CTRL_18                       0x518
+#define MADERA_AIF1_TX_ENABLES                          0x519
+#define MADERA_AIF1_RX_ENABLES                          0x51A
+#define MADERA_AIF1_FORCE_WRITE                         0x51B
+#define MADERA_AIF2_BCLK_CTRL                           0x540
+#define MADERA_AIF2_TX_PIN_CTRL                         0x541
+#define MADERA_AIF2_RX_PIN_CTRL                         0x542
+#define MADERA_AIF2_RATE_CTRL                           0x543
+#define MADERA_AIF2_FORMAT                              0x544
+#define MADERA_AIF2_RX_BCLK_RATE                        0x546
+#define MADERA_AIF2_FRAME_CTRL_1                        0x547
+#define MADERA_AIF2_FRAME_CTRL_2                        0x548
+#define MADERA_AIF2_FRAME_CTRL_3                        0x549
+#define MADERA_AIF2_FRAME_CTRL_4                        0x54A
+#define MADERA_AIF2_FRAME_CTRL_5                        0x54B
+#define MADERA_AIF2_FRAME_CTRL_6                        0x54C
+#define MADERA_AIF2_FRAME_CTRL_7                        0x54D
+#define MADERA_AIF2_FRAME_CTRL_8                        0x54E
+#define MADERA_AIF2_FRAME_CTRL_9                        0x54F
+#define MADERA_AIF2_FRAME_CTRL_10                       0x550
+#define MADERA_AIF2_FRAME_CTRL_11                       0x551
+#define MADERA_AIF2_FRAME_CTRL_12                       0x552
+#define MADERA_AIF2_FRAME_CTRL_13                       0x553
+#define MADERA_AIF2_FRAME_CTRL_14                       0x554
+#define MADERA_AIF2_FRAME_CTRL_15                       0x555
+#define MADERA_AIF2_FRAME_CTRL_16                       0x556
+#define MADERA_AIF2_FRAME_CTRL_17                       0x557
+#define MADERA_AIF2_FRAME_CTRL_18                       0x558
+#define MADERA_AIF2_TX_ENABLES                          0x559
+#define MADERA_AIF2_RX_ENABLES                          0x55A
+#define MADERA_AIF2_FORCE_WRITE                         0x55B
+#define MADERA_AIF3_BCLK_CTRL                           0x580
+#define MADERA_AIF3_TX_PIN_CTRL                         0x581
+#define MADERA_AIF3_RX_PIN_CTRL                         0x582
+#define MADERA_AIF3_RATE_CTRL                           0x583
+#define MADERA_AIF3_FORMAT                              0x584
+#define MADERA_AIF3_RX_BCLK_RATE                        0x586
+#define MADERA_AIF3_FRAME_CTRL_1                        0x587
+#define MADERA_AIF3_FRAME_CTRL_2                        0x588
+#define MADERA_AIF3_FRAME_CTRL_3                        0x589
+#define MADERA_AIF3_FRAME_CTRL_4                        0x58A
+#define MADERA_AIF3_FRAME_CTRL_11                       0x591
+#define MADERA_AIF3_FRAME_CTRL_12                       0x592
+#define MADERA_AIF3_TX_ENABLES                          0x599
+#define MADERA_AIF3_RX_ENABLES                          0x59A
+#define MADERA_AIF3_FORCE_WRITE                         0x59B
+#define MADERA_AIF4_BCLK_CTRL                           0x5A0
+#define MADERA_AIF4_TX_PIN_CTRL                         0x5A1
+#define MADERA_AIF4_RX_PIN_CTRL                         0x5A2
+#define MADERA_AIF4_RATE_CTRL                           0x5A3
+#define MADERA_AIF4_FORMAT                              0x5A4
+#define MADERA_AIF4_RX_BCLK_RATE                        0x5A6
+#define MADERA_AIF4_FRAME_CTRL_1                        0x5A7
+#define MADERA_AIF4_FRAME_CTRL_2                        0x5A8
+#define MADERA_AIF4_FRAME_CTRL_3                        0x5A9
+#define MADERA_AIF4_FRAME_CTRL_4                        0x5AA
+#define MADERA_AIF4_FRAME_CTRL_11                       0x5B1
+#define MADERA_AIF4_FRAME_CTRL_12                       0x5B2
+#define MADERA_AIF4_TX_ENABLES                          0x5B9
+#define MADERA_AIF4_RX_ENABLES                          0x5BA
+#define MADERA_AIF4_FORCE_WRITE                         0x5BB
+#define MADERA_SPD1_TX_CONTROL                          0x5C2
+#define MADERA_SPD1_TX_CHANNEL_STATUS_1                 0x5C3
+#define MADERA_SPD1_TX_CHANNEL_STATUS_2                 0x5C4
+#define MADERA_SPD1_TX_CHANNEL_STATUS_3                 0x5C5
+#define MADERA_SLIMBUS_FRAMER_REF_GEAR                  0x5E3
+#define MADERA_SLIMBUS_RATES_1                          0x5E5
+#define MADERA_SLIMBUS_RATES_2                          0x5E6
+#define MADERA_SLIMBUS_RATES_3                          0x5E7
+#define MADERA_SLIMBUS_RATES_4                          0x5E8
+#define MADERA_SLIMBUS_RATES_5                          0x5E9
+#define MADERA_SLIMBUS_RATES_6                          0x5EA
+#define MADERA_SLIMBUS_RATES_7                          0x5EB
+#define MADERA_SLIMBUS_RATES_8                          0x5EC
+#define MADERA_SLIMBUS_RX_CHANNEL_ENABLE                0x5F5
+#define MADERA_SLIMBUS_TX_CHANNEL_ENABLE                0x5F6
+#define MADERA_SLIMBUS_RX_PORT_STATUS                   0x5F7
+#define MADERA_SLIMBUS_TX_PORT_STATUS                   0x5F8
+#define MADERA_PWM1MIX_INPUT_1_SOURCE                   0x640
+#define MADERA_PWM1MIX_INPUT_1_VOLUME                   0x641
+#define MADERA_PWM1MIX_INPUT_2_SOURCE                   0x642
+#define MADERA_PWM1MIX_INPUT_2_VOLUME                   0x643
+#define MADERA_PWM1MIX_INPUT_3_SOURCE                   0x644
+#define MADERA_PWM1MIX_INPUT_3_VOLUME                   0x645
+#define MADERA_PWM1MIX_INPUT_4_SOURCE                   0x646
+#define MADERA_PWM1MIX_INPUT_4_VOLUME                   0x647
+#define MADERA_PWM2MIX_INPUT_1_SOURCE                   0x648
+#define MADERA_PWM2MIX_INPUT_1_VOLUME                   0x649
+#define MADERA_PWM2MIX_INPUT_2_SOURCE                   0x64A
+#define MADERA_PWM2MIX_INPUT_2_VOLUME                   0x64B
+#define MADERA_PWM2MIX_INPUT_3_SOURCE                   0x64C
+#define MADERA_PWM2MIX_INPUT_3_VOLUME                   0x64D
+#define MADERA_PWM2MIX_INPUT_4_SOURCE                   0x64E
+#define MADERA_PWM2MIX_INPUT_4_VOLUME                   0x64F
+#define MADERA_OUT1LMIX_INPUT_1_SOURCE                  0x680
+#define MADERA_OUT1LMIX_INPUT_1_VOLUME                  0x681
+#define MADERA_OUT1LMIX_INPUT_2_SOURCE                  0x682
+#define MADERA_OUT1LMIX_INPUT_2_VOLUME                  0x683
+#define MADERA_OUT1LMIX_INPUT_3_SOURCE                  0x684
+#define MADERA_OUT1LMIX_INPUT_3_VOLUME                  0x685
+#define MADERA_OUT1LMIX_INPUT_4_SOURCE                  0x686
+#define MADERA_OUT1LMIX_INPUT_4_VOLUME                  0x687
+#define MADERA_OUT1RMIX_INPUT_1_SOURCE                  0x688
+#define MADERA_OUT1RMIX_INPUT_1_VOLUME                  0x689
+#define MADERA_OUT1RMIX_INPUT_2_SOURCE                  0x68A
+#define MADERA_OUT1RMIX_INPUT_2_VOLUME                  0x68B
+#define MADERA_OUT1RMIX_INPUT_3_SOURCE                  0x68C
+#define MADERA_OUT1RMIX_INPUT_3_VOLUME                  0x68D
+#define MADERA_OUT1RMIX_INPUT_4_SOURCE                  0x68E
+#define MADERA_OUT1RMIX_INPUT_4_VOLUME                  0x68F
+#define MADERA_OUT2LMIX_INPUT_1_SOURCE                  0x690
+#define MADERA_OUT2LMIX_INPUT_1_VOLUME                  0x691
+#define MADERA_OUT2LMIX_INPUT_2_SOURCE                  0x692
+#define MADERA_OUT2LMIX_INPUT_2_VOLUME                  0x693
+#define MADERA_OUT2LMIX_INPUT_3_SOURCE                  0x694
+#define MADERA_OUT2LMIX_INPUT_3_VOLUME                  0x695
+#define MADERA_OUT2LMIX_INPUT_4_SOURCE                  0x696
+#define MADERA_OUT2LMIX_INPUT_4_VOLUME                  0x697
+#define MADERA_OUT2RMIX_INPUT_1_SOURCE                  0x698
+#define MADERA_OUT2RMIX_INPUT_1_VOLUME                  0x699
+#define MADERA_OUT2RMIX_INPUT_2_SOURCE                  0x69A
+#define MADERA_OUT2RMIX_INPUT_2_VOLUME                  0x69B
+#define MADERA_OUT2RMIX_INPUT_3_SOURCE                  0x69C
+#define MADERA_OUT2RMIX_INPUT_3_VOLUME                  0x69D
+#define MADERA_OUT2RMIX_INPUT_4_SOURCE                  0x69E
+#define MADERA_OUT2RMIX_INPUT_4_VOLUME                  0x69F
+#define MADERA_OUT3LMIX_INPUT_1_SOURCE                  0x6A0
+#define MADERA_OUT3LMIX_INPUT_1_VOLUME                  0x6A1
+#define MADERA_OUT3LMIX_INPUT_2_SOURCE                  0x6A2
+#define MADERA_OUT3LMIX_INPUT_2_VOLUME                  0x6A3
+#define MADERA_OUT3LMIX_INPUT_3_SOURCE                  0x6A4
+#define MADERA_OUT3LMIX_INPUT_3_VOLUME                  0x6A5
+#define MADERA_OUT3LMIX_INPUT_4_SOURCE                  0x6A6
+#define MADERA_OUT3LMIX_INPUT_4_VOLUME                  0x6A7
+#define MADERA_OUT3RMIX_INPUT_1_SOURCE                  0x6A8
+#define MADERA_OUT3RMIX_INPUT_1_VOLUME                  0x6A9
+#define MADERA_OUT3RMIX_INPUT_2_SOURCE                  0x6AA
+#define MADERA_OUT3RMIX_INPUT_2_VOLUME                  0x6AB
+#define MADERA_OUT3RMIX_INPUT_3_SOURCE                  0x6AC
+#define MADERA_OUT3RMIX_INPUT_3_VOLUME                  0x6AD
+#define MADERA_OUT3RMIX_INPUT_4_SOURCE                  0x6AE
+#define MADERA_OUT3RMIX_INPUT_4_VOLUME                  0x6AF
+#define MADERA_OUT4LMIX_INPUT_1_SOURCE                  0x6B0
+#define MADERA_OUT4LMIX_INPUT_1_VOLUME                  0x6B1
+#define MADERA_OUT4LMIX_INPUT_2_SOURCE                  0x6B2
+#define MADERA_OUT4LMIX_INPUT_2_VOLUME                  0x6B3
+#define MADERA_OUT4LMIX_INPUT_3_SOURCE                  0x6B4
+#define MADERA_OUT4LMIX_INPUT_3_VOLUME                  0x6B5
+#define MADERA_OUT4LMIX_INPUT_4_SOURCE                  0x6B6
+#define MADERA_OUT4LMIX_INPUT_4_VOLUME                  0x6B7
+#define MADERA_OUT4RMIX_INPUT_1_SOURCE                  0x6B8
+#define MADERA_OUT4RMIX_INPUT_1_VOLUME                  0x6B9
+#define MADERA_OUT4RMIX_INPUT_2_SOURCE                  0x6BA
+#define MADERA_OUT4RMIX_INPUT_2_VOLUME                  0x6BB
+#define MADERA_OUT4RMIX_INPUT_3_SOURCE                  0x6BC
+#define MADERA_OUT4RMIX_INPUT_3_VOLUME                  0x6BD
+#define MADERA_OUT4RMIX_INPUT_4_SOURCE                  0x6BE
+#define MADERA_OUT4RMIX_INPUT_4_VOLUME                  0x6BF
+#define MADERA_OUT5LMIX_INPUT_1_SOURCE                  0x6C0
+#define MADERA_OUT5LMIX_INPUT_1_VOLUME                  0x6C1
+#define MADERA_OUT5LMIX_INPUT_2_SOURCE                  0x6C2
+#define MADERA_OUT5LMIX_INPUT_2_VOLUME                  0x6C3
+#define MADERA_OUT5LMIX_INPUT_3_SOURCE                  0x6C4
+#define MADERA_OUT5LMIX_INPUT_3_VOLUME                  0x6C5
+#define MADERA_OUT5LMIX_INPUT_4_SOURCE                  0x6C6
+#define MADERA_OUT5LMIX_INPUT_4_VOLUME                  0x6C7
+#define MADERA_OUT5RMIX_INPUT_1_SOURCE                  0x6C8
+#define MADERA_OUT5RMIX_INPUT_1_VOLUME                  0x6C9
+#define MADERA_OUT5RMIX_INPUT_2_SOURCE                  0x6CA
+#define MADERA_OUT5RMIX_INPUT_2_VOLUME                  0x6CB
+#define MADERA_OUT5RMIX_INPUT_3_SOURCE                  0x6CC
+#define MADERA_OUT5RMIX_INPUT_3_VOLUME                  0x6CD
+#define MADERA_OUT5RMIX_INPUT_4_SOURCE                  0x6CE
+#define MADERA_OUT5RMIX_INPUT_4_VOLUME                  0x6CF
+#define MADERA_OUT6LMIX_INPUT_1_SOURCE                  0x6D0
+#define MADERA_OUT6LMIX_INPUT_1_VOLUME                  0x6D1
+#define MADERA_OUT6LMIX_INPUT_2_SOURCE                  0x6D2
+#define MADERA_OUT6LMIX_INPUT_2_VOLUME                  0x6D3
+#define MADERA_OUT6LMIX_INPUT_3_SOURCE                  0x6D4
+#define MADERA_OUT6LMIX_INPUT_3_VOLUME                  0x6D5
+#define MADERA_OUT6LMIX_INPUT_4_SOURCE                  0x6D6
+#define MADERA_OUT6LMIX_INPUT_4_VOLUME                  0x6D7
+#define MADERA_OUT6RMIX_INPUT_1_SOURCE                  0x6D8
+#define MADERA_OUT6RMIX_INPUT_1_VOLUME                  0x6D9
+#define MADERA_OUT6RMIX_INPUT_2_SOURCE                  0x6DA
+#define MADERA_OUT6RMIX_INPUT_2_VOLUME                  0x6DB
+#define MADERA_OUT6RMIX_INPUT_3_SOURCE                  0x6DC
+#define MADERA_OUT6RMIX_INPUT_3_VOLUME                  0x6DD
+#define MADERA_OUT6RMIX_INPUT_4_SOURCE                  0x6DE
+#define MADERA_OUT6RMIX_INPUT_4_VOLUME                  0x6DF
+#define MADERA_AIF1TX1MIX_INPUT_1_SOURCE                0x700
+#define MADERA_AIF1TX1MIX_INPUT_1_VOLUME                0x701
+#define MADERA_AIF1TX1MIX_INPUT_2_SOURCE                0x702
+#define MADERA_AIF1TX1MIX_INPUT_2_VOLUME                0x703
+#define MADERA_AIF1TX1MIX_INPUT_3_SOURCE                0x704
+#define MADERA_AIF1TX1MIX_INPUT_3_VOLUME                0x705
+#define MADERA_AIF1TX1MIX_INPUT_4_SOURCE                0x706
+#define MADERA_AIF1TX1MIX_INPUT_4_VOLUME                0x707
+#define MADERA_AIF1TX2MIX_INPUT_1_SOURCE                0x708
+#define MADERA_AIF1TX2MIX_INPUT_1_VOLUME                0x709
+#define MADERA_AIF1TX2MIX_INPUT_2_SOURCE                0x70A
+#define MADERA_AIF1TX2MIX_INPUT_2_VOLUME                0x70B
+#define MADERA_AIF1TX2MIX_INPUT_3_SOURCE                0x70C
+#define MADERA_AIF1TX2MIX_INPUT_3_VOLUME                0x70D
+#define MADERA_AIF1TX2MIX_INPUT_4_SOURCE                0x70E
+#define MADERA_AIF1TX2MIX_INPUT_4_VOLUME                0x70F
+#define MADERA_AIF1TX3MIX_INPUT_1_SOURCE                0x710
+#define MADERA_AIF1TX3MIX_INPUT_1_VOLUME                0x711
+#define MADERA_AIF1TX3MIX_INPUT_2_SOURCE                0x712
+#define MADERA_AIF1TX3MIX_INPUT_2_VOLUME                0x713
+#define MADERA_AIF1TX3MIX_INPUT_3_SOURCE                0x714
+#define MADERA_AIF1TX3MIX_INPUT_3_VOLUME                0x715
+#define MADERA_AIF1TX3MIX_INPUT_4_SOURCE                0x716
+#define MADERA_AIF1TX3MIX_INPUT_4_VOLUME                0x717
+#define MADERA_AIF1TX4MIX_INPUT_1_SOURCE                0x718
+#define MADERA_AIF1TX4MIX_INPUT_1_VOLUME                0x719
+#define MADERA_AIF1TX4MIX_INPUT_2_SOURCE                0x71A
+#define MADERA_AIF1TX4MIX_INPUT_2_VOLUME                0x71B
+#define MADERA_AIF1TX4MIX_INPUT_3_SOURCE                0x71C
+#define MADERA_AIF1TX4MIX_INPUT_3_VOLUME                0x71D
+#define MADERA_AIF1TX4MIX_INPUT_4_SOURCE                0x71E
+#define MADERA_AIF1TX4MIX_INPUT_4_VOLUME                0x71F
+#define MADERA_AIF1TX5MIX_INPUT_1_SOURCE                0x720
+#define MADERA_AIF1TX5MIX_INPUT_1_VOLUME                0x721
+#define MADERA_AIF1TX5MIX_INPUT_2_SOURCE                0x722
+#define MADERA_AIF1TX5MIX_INPUT_2_VOLUME                0x723
+#define MADERA_AIF1TX5MIX_INPUT_3_SOURCE                0x724
+#define MADERA_AIF1TX5MIX_INPUT_3_VOLUME                0x725
+#define MADERA_AIF1TX5MIX_INPUT_4_SOURCE                0x726
+#define MADERA_AIF1TX5MIX_INPUT_4_VOLUME                0x727
+#define MADERA_AIF1TX6MIX_INPUT_1_SOURCE                0x728
+#define MADERA_AIF1TX6MIX_INPUT_1_VOLUME                0x729
+#define MADERA_AIF1TX6MIX_INPUT_2_SOURCE                0x72A
+#define MADERA_AIF1TX6MIX_INPUT_2_VOLUME                0x72B
+#define MADERA_AIF1TX6MIX_INPUT_3_SOURCE                0x72C
+#define MADERA_AIF1TX6MIX_INPUT_3_VOLUME                0x72D
+#define MADERA_AIF1TX6MIX_INPUT_4_SOURCE                0x72E
+#define MADERA_AIF1TX6MIX_INPUT_4_VOLUME                0x72F
+#define MADERA_AIF1TX7MIX_INPUT_1_SOURCE                0x730
+#define MADERA_AIF1TX7MIX_INPUT_1_VOLUME                0x731
+#define MADERA_AIF1TX7MIX_INPUT_2_SOURCE                0x732
+#define MADERA_AIF1TX7MIX_INPUT_2_VOLUME                0x733
+#define MADERA_AIF1TX7MIX_INPUT_3_SOURCE                0x734
+#define MADERA_AIF1TX7MIX_INPUT_3_VOLUME                0x735
+#define MADERA_AIF1TX7MIX_INPUT_4_SOURCE                0x736
+#define MADERA_AIF1TX7MIX_INPUT_4_VOLUME                0x737
+#define MADERA_AIF1TX8MIX_INPUT_1_SOURCE                0x738
+#define MADERA_AIF1TX8MIX_INPUT_1_VOLUME                0x739
+#define MADERA_AIF1TX8MIX_INPUT_2_SOURCE                0x73A
+#define MADERA_AIF1TX8MIX_INPUT_2_VOLUME                0x73B
+#define MADERA_AIF1TX8MIX_INPUT_3_SOURCE                0x73C
+#define MADERA_AIF1TX8MIX_INPUT_3_VOLUME                0x73D
+#define MADERA_AIF1TX8MIX_INPUT_4_SOURCE                0x73E
+#define MADERA_AIF1TX8MIX_INPUT_4_VOLUME                0x73F
+#define MADERA_AIF2TX1MIX_INPUT_1_SOURCE                0x740
+#define MADERA_AIF2TX1MIX_INPUT_1_VOLUME                0x741
+#define MADERA_AIF2TX1MIX_INPUT_2_SOURCE                0x742
+#define MADERA_AIF2TX1MIX_INPUT_2_VOLUME                0x743
+#define MADERA_AIF2TX1MIX_INPUT_3_SOURCE                0x744
+#define MADERA_AIF2TX1MIX_INPUT_3_VOLUME                0x745
+#define MADERA_AIF2TX1MIX_INPUT_4_SOURCE                0x746
+#define MADERA_AIF2TX1MIX_INPUT_4_VOLUME                0x747
+#define MADERA_AIF2TX2MIX_INPUT_1_SOURCE                0x748
+#define MADERA_AIF2TX2MIX_INPUT_1_VOLUME                0x749
+#define MADERA_AIF2TX2MIX_INPUT_2_SOURCE                0x74A
+#define MADERA_AIF2TX2MIX_INPUT_2_VOLUME                0x74B
+#define MADERA_AIF2TX2MIX_INPUT_3_SOURCE                0x74C
+#define MADERA_AIF2TX2MIX_INPUT_3_VOLUME                0x74D
+#define MADERA_AIF2TX2MIX_INPUT_4_SOURCE                0x74E
+#define MADERA_AIF2TX2MIX_INPUT_4_VOLUME                0x74F
+#define MADERA_AIF2TX3MIX_INPUT_1_SOURCE                0x750
+#define MADERA_AIF2TX3MIX_INPUT_1_VOLUME                0x751
+#define MADERA_AIF2TX3MIX_INPUT_2_SOURCE                0x752
+#define MADERA_AIF2TX3MIX_INPUT_2_VOLUME                0x753
+#define MADERA_AIF2TX3MIX_INPUT_3_SOURCE                0x754
+#define MADERA_AIF2TX3MIX_INPUT_3_VOLUME                0x755
+#define MADERA_AIF2TX3MIX_INPUT_4_SOURCE                0x756
+#define MADERA_AIF2TX3MIX_INPUT_4_VOLUME                0x757
+#define MADERA_AIF2TX4MIX_INPUT_1_SOURCE                0x758
+#define MADERA_AIF2TX4MIX_INPUT_1_VOLUME                0x759
+#define MADERA_AIF2TX4MIX_INPUT_2_SOURCE                0x75A
+#define MADERA_AIF2TX4MIX_INPUT_2_VOLUME                0x75B
+#define MADERA_AIF2TX4MIX_INPUT_3_SOURCE                0x75C
+#define MADERA_AIF2TX4MIX_INPUT_3_VOLUME                0x75D
+#define MADERA_AIF2TX4MIX_INPUT_4_SOURCE                0x75E
+#define MADERA_AIF2TX4MIX_INPUT_4_VOLUME                0x75F
+#define MADERA_AIF2TX5MIX_INPUT_1_SOURCE                0x760
+#define MADERA_AIF2TX5MIX_INPUT_1_VOLUME                0x761
+#define MADERA_AIF2TX5MIX_INPUT_2_SOURCE                0x762
+#define MADERA_AIF2TX5MIX_INPUT_2_VOLUME                0x763
+#define MADERA_AIF2TX5MIX_INPUT_3_SOURCE                0x764
+#define MADERA_AIF2TX5MIX_INPUT_3_VOLUME                0x765
+#define MADERA_AIF2TX5MIX_INPUT_4_SOURCE                0x766
+#define MADERA_AIF2TX5MIX_INPUT_4_VOLUME                0x767
+#define MADERA_AIF2TX6MIX_INPUT_1_SOURCE                0x768
+#define MADERA_AIF2TX6MIX_INPUT_1_VOLUME                0x769
+#define MADERA_AIF2TX6MIX_INPUT_2_SOURCE                0x76A
+#define MADERA_AIF2TX6MIX_INPUT_2_VOLUME                0x76B
+#define MADERA_AIF2TX6MIX_INPUT_3_SOURCE                0x76C
+#define MADERA_AIF2TX6MIX_INPUT_3_VOLUME                0x76D
+#define MADERA_AIF2TX6MIX_INPUT_4_SOURCE                0x76E
+#define MADERA_AIF2TX6MIX_INPUT_4_VOLUME                0x76F
+#define MADERA_AIF2TX7MIX_INPUT_1_SOURCE                0x770
+#define MADERA_AIF2TX7MIX_INPUT_1_VOLUME                0x771
+#define MADERA_AIF2TX7MIX_INPUT_2_SOURCE                0x772
+#define MADERA_AIF2TX7MIX_INPUT_2_VOLUME                0x773
+#define MADERA_AIF2TX7MIX_INPUT_3_SOURCE                0x774
+#define MADERA_AIF2TX7MIX_INPUT_3_VOLUME                0x775
+#define MADERA_AIF2TX7MIX_INPUT_4_SOURCE                0x776
+#define MADERA_AIF2TX7MIX_INPUT_4_VOLUME                0x777
+#define MADERA_AIF2TX8MIX_INPUT_1_SOURCE                0x778
+#define MADERA_AIF2TX8MIX_INPUT_1_VOLUME                0x779
+#define MADERA_AIF2TX8MIX_INPUT_2_SOURCE                0x77A
+#define MADERA_AIF2TX8MIX_INPUT_2_VOLUME                0x77B
+#define MADERA_AIF2TX8MIX_INPUT_3_SOURCE                0x77C
+#define MADERA_AIF2TX8MIX_INPUT_3_VOLUME                0x77D
+#define MADERA_AIF2TX8MIX_INPUT_4_SOURCE                0x77E
+#define MADERA_AIF2TX8MIX_INPUT_4_VOLUME                0x77F
+#define MADERA_AIF3TX1MIX_INPUT_1_SOURCE                0x780
+#define MADERA_AIF3TX1MIX_INPUT_1_VOLUME                0x781
+#define MADERA_AIF3TX1MIX_INPUT_2_SOURCE                0x782
+#define MADERA_AIF3TX1MIX_INPUT_2_VOLUME                0x783
+#define MADERA_AIF3TX1MIX_INPUT_3_SOURCE                0x784
+#define MADERA_AIF3TX1MIX_INPUT_3_VOLUME                0x785
+#define MADERA_AIF3TX1MIX_INPUT_4_SOURCE                0x786
+#define MADERA_AIF3TX1MIX_INPUT_4_VOLUME                0x787
+#define MADERA_AIF3TX2MIX_INPUT_1_SOURCE                0x788
+#define MADERA_AIF3TX2MIX_INPUT_1_VOLUME                0x789
+#define MADERA_AIF3TX2MIX_INPUT_2_SOURCE                0x78A
+#define MADERA_AIF3TX2MIX_INPUT_2_VOLUME                0x78B
+#define MADERA_AIF3TX2MIX_INPUT_3_SOURCE                0x78C
+#define MADERA_AIF3TX2MIX_INPUT_3_VOLUME                0x78D
+#define MADERA_AIF3TX2MIX_INPUT_4_SOURCE                0x78E
+#define MADERA_AIF3TX2MIX_INPUT_4_VOLUME                0x78F
+#define MADERA_AIF4TX1MIX_INPUT_1_SOURCE                0x7A0
+#define MADERA_AIF4TX1MIX_INPUT_1_VOLUME                0x7A1
+#define MADERA_AIF4TX1MIX_INPUT_2_SOURCE                0x7A2
+#define MADERA_AIF4TX1MIX_INPUT_2_VOLUME                0x7A3
+#define MADERA_AIF4TX1MIX_INPUT_3_SOURCE                0x7A4
+#define MADERA_AIF4TX1MIX_INPUT_3_VOLUME                0x7A5
+#define MADERA_AIF4TX1MIX_INPUT_4_SOURCE                0x7A6
+#define MADERA_AIF4TX1MIX_INPUT_4_VOLUME                0x7A7
+#define MADERA_AIF4TX2MIX_INPUT_1_SOURCE                0x7A8
+#define MADERA_AIF4TX2MIX_INPUT_1_VOLUME                0x7A9
+#define MADERA_AIF4TX2MIX_INPUT_2_SOURCE                0x7AA
+#define MADERA_AIF4TX2MIX_INPUT_2_VOLUME                0x7AB
+#define MADERA_AIF4TX2MIX_INPUT_3_SOURCE                0x7AC
+#define MADERA_AIF4TX2MIX_INPUT_3_VOLUME                0x7AD
+#define MADERA_AIF4TX2MIX_INPUT_4_SOURCE                0x7AE
+#define MADERA_AIF4TX2MIX_INPUT_4_VOLUME                0x7AF
+#define MADERA_SLIMTX1MIX_INPUT_1_SOURCE                0x7C0
+#define MADERA_SLIMTX1MIX_INPUT_1_VOLUME                0x7C1
+#define MADERA_SLIMTX1MIX_INPUT_2_SOURCE                0x7C2
+#define MADERA_SLIMTX1MIX_INPUT_2_VOLUME                0x7C3
+#define MADERA_SLIMTX1MIX_INPUT_3_SOURCE                0x7C4
+#define MADERA_SLIMTX1MIX_INPUT_3_VOLUME                0x7C5
+#define MADERA_SLIMTX1MIX_INPUT_4_SOURCE                0x7C6
+#define MADERA_SLIMTX1MIX_INPUT_4_VOLUME                0x7C7
+#define MADERA_SLIMTX2MIX_INPUT_1_SOURCE                0x7C8
+#define MADERA_SLIMTX2MIX_INPUT_1_VOLUME                0x7C9
+#define MADERA_SLIMTX2MIX_INPUT_2_SOURCE                0x7CA
+#define MADERA_SLIMTX2MIX_INPUT_2_VOLUME                0x7CB
+#define MADERA_SLIMTX2MIX_INPUT_3_SOURCE                0x7CC
+#define MADERA_SLIMTX2MIX_INPUT_3_VOLUME                0x7CD
+#define MADERA_SLIMTX2MIX_INPUT_4_SOURCE                0x7CE
+#define MADERA_SLIMTX2MIX_INPUT_4_VOLUME                0x7CF
+#define MADERA_SLIMTX3MIX_INPUT_1_SOURCE                0x7D0
+#define MADERA_SLIMTX3MIX_INPUT_1_VOLUME                0x7D1
+#define MADERA_SLIMTX3MIX_INPUT_2_SOURCE                0x7D2
+#define MADERA_SLIMTX3MIX_INPUT_2_VOLUME                0x7D3
+#define MADERA_SLIMTX3MIX_INPUT_3_SOURCE                0x7D4
+#define MADERA_SLIMTX3MIX_INPUT_3_VOLUME                0x7D5
+#define MADERA_SLIMTX3MIX_INPUT_4_SOURCE                0x7D6
+#define MADERA_SLIMTX3MIX_INPUT_4_VOLUME                0x7D7
+#define MADERA_SLIMTX4MIX_INPUT_1_SOURCE                0x7D8
+#define MADERA_SLIMTX4MIX_INPUT_1_VOLUME                0x7D9
+#define MADERA_SLIMTX4MIX_INPUT_2_SOURCE                0x7DA
+#define MADERA_SLIMTX4MIX_INPUT_2_VOLUME                0x7DB
+#define MADERA_SLIMTX4MIX_INPUT_3_SOURCE                0x7DC
+#define MADERA_SLIMTX4MIX_INPUT_3_VOLUME                0x7DD
+#define MADERA_SLIMTX4MIX_INPUT_4_SOURCE                0x7DE
+#define MADERA_SLIMTX4MIX_INPUT_4_VOLUME                0x7DF
+#define MADERA_SLIMTX5MIX_INPUT_1_SOURCE                0x7E0
+#define MADERA_SLIMTX5MIX_INPUT_1_VOLUME                0x7E1
+#define MADERA_SLIMTX5MIX_INPUT_2_SOURCE                0x7E2
+#define MADERA_SLIMTX5MIX_INPUT_2_VOLUME                0x7E3
+#define MADERA_SLIMTX5MIX_INPUT_3_SOURCE                0x7E4
+#define MADERA_SLIMTX5MIX_INPUT_3_VOLUME                0x7E5
+#define MADERA_SLIMTX5MIX_INPUT_4_SOURCE                0x7E6
+#define MADERA_SLIMTX5MIX_INPUT_4_VOLUME                0x7E7
+#define MADERA_SLIMTX6MIX_INPUT_1_SOURCE                0x7E8
+#define MADERA_SLIMTX6MIX_INPUT_1_VOLUME                0x7E9
+#define MADERA_SLIMTX6MIX_INPUT_2_SOURCE                0x7EA
+#define MADERA_SLIMTX6MIX_INPUT_2_VOLUME                0x7EB
+#define MADERA_SLIMTX6MIX_INPUT_3_SOURCE                0x7EC
+#define MADERA_SLIMTX6MIX_INPUT_3_VOLUME                0x7ED
+#define MADERA_SLIMTX6MIX_INPUT_4_SOURCE                0x7EE
+#define MADERA_SLIMTX6MIX_INPUT_4_VOLUME                0x7EF
+#define MADERA_SLIMTX7MIX_INPUT_1_SOURCE                0x7F0
+#define MADERA_SLIMTX7MIX_INPUT_1_VOLUME                0x7F1
+#define MADERA_SLIMTX7MIX_INPUT_2_SOURCE                0x7F2
+#define MADERA_SLIMTX7MIX_INPUT_2_VOLUME                0x7F3
+#define MADERA_SLIMTX7MIX_INPUT_3_SOURCE                0x7F4
+#define MADERA_SLIMTX7MIX_INPUT_3_VOLUME                0x7F5
+#define MADERA_SLIMTX7MIX_INPUT_4_SOURCE                0x7F6
+#define MADERA_SLIMTX7MIX_INPUT_4_VOLUME                0x7F7
+#define MADERA_SLIMTX8MIX_INPUT_1_SOURCE                0x7F8
+#define MADERA_SLIMTX8MIX_INPUT_1_VOLUME                0x7F9
+#define MADERA_SLIMTX8MIX_INPUT_2_SOURCE                0x7FA
+#define MADERA_SLIMTX8MIX_INPUT_2_VOLUME                0x7FB
+#define MADERA_SLIMTX8MIX_INPUT_3_SOURCE                0x7FC
+#define MADERA_SLIMTX8MIX_INPUT_3_VOLUME                0x7FD
+#define MADERA_SLIMTX8MIX_INPUT_4_SOURCE                0x7FE
+#define MADERA_SLIMTX8MIX_INPUT_4_VOLUME                0x7FF
+#define MADERA_SPDIF1TX1MIX_INPUT_1_SOURCE              0x800
+#define MADERA_SPDIF1TX1MIX_INPUT_1_VOLUME              0x801
+#define MADERA_SPDIF1TX2MIX_INPUT_1_SOURCE              0x808
+#define MADERA_SPDIF1TX2MIX_INPUT_1_VOLUME              0x809
+#define MADERA_EQ1MIX_INPUT_1_SOURCE                    0x880
+#define MADERA_EQ1MIX_INPUT_1_VOLUME                    0x881
+#define MADERA_EQ1MIX_INPUT_2_SOURCE                    0x882
+#define MADERA_EQ1MIX_INPUT_2_VOLUME                    0x883
+#define MADERA_EQ1MIX_INPUT_3_SOURCE                    0x884
+#define MADERA_EQ1MIX_INPUT_3_VOLUME                    0x885
+#define MADERA_EQ1MIX_INPUT_4_SOURCE                    0x886
+#define MADERA_EQ1MIX_INPUT_4_VOLUME                    0x887
+#define MADERA_EQ2MIX_INPUT_1_SOURCE                    0x888
+#define MADERA_EQ2MIX_INPUT_1_VOLUME                    0x889
+#define MADERA_EQ2MIX_INPUT_2_SOURCE                    0x88A
+#define MADERA_EQ2MIX_INPUT_2_VOLUME                    0x88B
+#define MADERA_EQ2MIX_INPUT_3_SOURCE                    0x88C
+#define MADERA_EQ2MIX_INPUT_3_VOLUME                    0x88D
+#define MADERA_EQ2MIX_INPUT_4_SOURCE                    0x88E
+#define MADERA_EQ2MIX_INPUT_4_VOLUME                    0x88F
+#define MADERA_EQ3MIX_INPUT_1_SOURCE                    0x890
+#define MADERA_EQ3MIX_INPUT_1_VOLUME                    0x891
+#define MADERA_EQ3MIX_INPUT_2_SOURCE                    0x892
+#define MADERA_EQ3MIX_INPUT_2_VOLUME                    0x893
+#define MADERA_EQ3MIX_INPUT_3_SOURCE                    0x894
+#define MADERA_EQ3MIX_INPUT_3_VOLUME                    0x895
+#define MADERA_EQ3MIX_INPUT_4_SOURCE                    0x896
+#define MADERA_EQ3MIX_INPUT_4_VOLUME                    0x897
+#define MADERA_EQ4MIX_INPUT_1_SOURCE                    0x898
+#define MADERA_EQ4MIX_INPUT_1_VOLUME                    0x899
+#define MADERA_EQ4MIX_INPUT_2_SOURCE                    0x89A
+#define MADERA_EQ4MIX_INPUT_2_VOLUME                    0x89B
+#define MADERA_EQ4MIX_INPUT_3_SOURCE                    0x89C
+#define MADERA_EQ4MIX_INPUT_3_VOLUME                    0x89D
+#define MADERA_EQ4MIX_INPUT_4_SOURCE                    0x89E
+#define MADERA_EQ4MIX_INPUT_4_VOLUME                    0x89F
+#define MADERA_DRC1LMIX_INPUT_1_SOURCE                  0x8C0
+#define MADERA_DRC1LMIX_INPUT_1_VOLUME                  0x8C1
+#define MADERA_DRC1LMIX_INPUT_2_SOURCE                  0x8C2
+#define MADERA_DRC1LMIX_INPUT_2_VOLUME                  0x8C3
+#define MADERA_DRC1LMIX_INPUT_3_SOURCE                  0x8C4
+#define MADERA_DRC1LMIX_INPUT_3_VOLUME                  0x8C5
+#define MADERA_DRC1LMIX_INPUT_4_SOURCE                  0x8C6
+#define MADERA_DRC1LMIX_INPUT_4_VOLUME                  0x8C7
+#define MADERA_DRC1RMIX_INPUT_1_SOURCE                  0x8C8
+#define MADERA_DRC1RMIX_INPUT_1_VOLUME                  0x8C9
+#define MADERA_DRC1RMIX_INPUT_2_SOURCE                  0x8CA
+#define MADERA_DRC1RMIX_INPUT_2_VOLUME                  0x8CB
+#define MADERA_DRC1RMIX_INPUT_3_SOURCE                  0x8CC
+#define MADERA_DRC1RMIX_INPUT_3_VOLUME                  0x8CD
+#define MADERA_DRC1RMIX_INPUT_4_SOURCE                  0x8CE
+#define MADERA_DRC1RMIX_INPUT_4_VOLUME                  0x8CF
+#define MADERA_DRC2LMIX_INPUT_1_SOURCE                  0x8D0
+#define MADERA_DRC2LMIX_INPUT_1_VOLUME                  0x8D1
+#define MADERA_DRC2LMIX_INPUT_2_SOURCE                  0x8D2
+#define MADERA_DRC2LMIX_INPUT_2_VOLUME                  0x8D3
+#define MADERA_DRC2LMIX_INPUT_3_SOURCE                  0x8D4
+#define MADERA_DRC2LMIX_INPUT_3_VOLUME                  0x8D5
+#define MADERA_DRC2LMIX_INPUT_4_SOURCE                  0x8D6
+#define MADERA_DRC2LMIX_INPUT_4_VOLUME                  0x8D7
+#define MADERA_DRC2RMIX_INPUT_1_SOURCE                  0x8D8
+#define MADERA_DRC2RMIX_INPUT_1_VOLUME                  0x8D9
+#define MADERA_DRC2RMIX_INPUT_2_SOURCE                  0x8DA
+#define MADERA_DRC2RMIX_INPUT_2_VOLUME                  0x8DB
+#define MADERA_DRC2RMIX_INPUT_3_SOURCE                  0x8DC
+#define MADERA_DRC2RMIX_INPUT_3_VOLUME                  0x8DD
+#define MADERA_DRC2RMIX_INPUT_4_SOURCE                  0x8DE
+#define MADERA_DRC2RMIX_INPUT_4_VOLUME                  0x8DF
+#define MADERA_HPLP1MIX_INPUT_1_SOURCE                  0x900
+#define MADERA_HPLP1MIX_INPUT_1_VOLUME                  0x901
+#define MADERA_HPLP1MIX_INPUT_2_SOURCE                  0x902
+#define MADERA_HPLP1MIX_INPUT_2_VOLUME                  0x903
+#define MADERA_HPLP1MIX_INPUT_3_SOURCE                  0x904
+#define MADERA_HPLP1MIX_INPUT_3_VOLUME                  0x905
+#define MADERA_HPLP1MIX_INPUT_4_SOURCE                  0x906
+#define MADERA_HPLP1MIX_INPUT_4_VOLUME                  0x907
+#define MADERA_HPLP2MIX_INPUT_1_SOURCE                  0x908
+#define MADERA_HPLP2MIX_INPUT_1_VOLUME                  0x909
+#define MADERA_HPLP2MIX_INPUT_2_SOURCE                  0x90A
+#define MADERA_HPLP2MIX_INPUT_2_VOLUME                  0x90B
+#define MADERA_HPLP2MIX_INPUT_3_SOURCE                  0x90C
+#define MADERA_HPLP2MIX_INPUT_3_VOLUME                  0x90D
+#define MADERA_HPLP2MIX_INPUT_4_SOURCE                  0x90E
+#define MADERA_HPLP2MIX_INPUT_4_VOLUME                  0x90F
+#define MADERA_HPLP3MIX_INPUT_1_SOURCE                  0x910
+#define MADERA_HPLP3MIX_INPUT_1_VOLUME                  0x911
+#define MADERA_HPLP3MIX_INPUT_2_SOURCE                  0x912
+#define MADERA_HPLP3MIX_INPUT_2_VOLUME                  0x913
+#define MADERA_HPLP3MIX_INPUT_3_SOURCE                  0x914
+#define MADERA_HPLP3MIX_INPUT_3_VOLUME                  0x915
+#define MADERA_HPLP3MIX_INPUT_4_SOURCE                  0x916
+#define MADERA_HPLP3MIX_INPUT_4_VOLUME                  0x917
+#define MADERA_HPLP4MIX_INPUT_1_SOURCE                  0x918
+#define MADERA_HPLP4MIX_INPUT_1_VOLUME                  0x919
+#define MADERA_HPLP4MIX_INPUT_2_SOURCE                  0x91A
+#define MADERA_HPLP4MIX_INPUT_2_VOLUME                  0x91B
+#define MADERA_HPLP4MIX_INPUT_3_SOURCE                  0x91C
+#define MADERA_HPLP4MIX_INPUT_3_VOLUME                  0x91D
+#define MADERA_HPLP4MIX_INPUT_4_SOURCE                  0x91E
+#define MADERA_HPLP4MIX_INPUT_4_VOLUME                  0x91F
+#define MADERA_DSP1LMIX_INPUT_1_SOURCE                  0x940
+#define MADERA_DSP1LMIX_INPUT_1_VOLUME                  0x941
+#define MADERA_DSP1LMIX_INPUT_2_SOURCE                  0x942
+#define MADERA_DSP1LMIX_INPUT_2_VOLUME                  0x943
+#define MADERA_DSP1LMIX_INPUT_3_SOURCE                  0x944
+#define MADERA_DSP1LMIX_INPUT_3_VOLUME                  0x945
+#define MADERA_DSP1LMIX_INPUT_4_SOURCE                  0x946
+#define MADERA_DSP1LMIX_INPUT_4_VOLUME                  0x947
+#define MADERA_DSP1RMIX_INPUT_1_SOURCE                  0x948
+#define MADERA_DSP1RMIX_INPUT_1_VOLUME                  0x949
+#define MADERA_DSP1RMIX_INPUT_2_SOURCE                  0x94A
+#define MADERA_DSP1RMIX_INPUT_2_VOLUME                  0x94B
+#define MADERA_DSP1RMIX_INPUT_3_SOURCE                  0x94C
+#define MADERA_DSP1RMIX_INPUT_3_VOLUME                  0x94D
+#define MADERA_DSP1RMIX_INPUT_4_SOURCE                  0x94E
+#define MADERA_DSP1RMIX_INPUT_4_VOLUME                  0x94F
+#define MADERA_DSP1AUX1MIX_INPUT_1_SOURCE               0x950
+#define MADERA_DSP1AUX2MIX_INPUT_1_SOURCE               0x958
+#define MADERA_DSP1AUX3MIX_INPUT_1_SOURCE               0x960
+#define MADERA_DSP1AUX4MIX_INPUT_1_SOURCE               0x968
+#define MADERA_DSP1AUX5MIX_INPUT_1_SOURCE               0x970
+#define MADERA_DSP1AUX6MIX_INPUT_1_SOURCE               0x978
+#define MADERA_DSP2LMIX_INPUT_1_SOURCE                  0x980
+#define MADERA_DSP2LMIX_INPUT_1_VOLUME                  0x981
+#define MADERA_DSP2LMIX_INPUT_2_SOURCE                  0x982
+#define MADERA_DSP2LMIX_INPUT_2_VOLUME                  0x983
+#define MADERA_DSP2LMIX_INPUT_3_SOURCE                  0x984
+#define MADERA_DSP2LMIX_INPUT_3_VOLUME                  0x985
+#define MADERA_DSP2LMIX_INPUT_4_SOURCE                  0x986
+#define MADERA_DSP2LMIX_INPUT_4_VOLUME                  0x987
+#define MADERA_DSP2RMIX_INPUT_1_SOURCE                  0x988
+#define MADERA_DSP2RMIX_INPUT_1_VOLUME                  0x989
+#define MADERA_DSP2RMIX_INPUT_2_SOURCE                  0x98A
+#define MADERA_DSP2RMIX_INPUT_2_VOLUME                  0x98B
+#define MADERA_DSP2RMIX_INPUT_3_SOURCE                  0x98C
+#define MADERA_DSP2RMIX_INPUT_3_VOLUME                  0x98D
+#define MADERA_DSP2RMIX_INPUT_4_SOURCE                  0x98E
+#define MADERA_DSP2RMIX_INPUT_4_VOLUME                  0x98F
+#define MADERA_DSP2AUX1MIX_INPUT_1_SOURCE               0x990
+#define MADERA_DSP2AUX2MIX_INPUT_1_SOURCE               0x998
+#define MADERA_DSP2AUX3MIX_INPUT_1_SOURCE               0x9A0
+#define MADERA_DSP2AUX4MIX_INPUT_1_SOURCE               0x9A8
+#define MADERA_DSP2AUX5MIX_INPUT_1_SOURCE               0x9B0
+#define MADERA_DSP2AUX6MIX_INPUT_1_SOURCE               0x9B8
+#define MADERA_DSP3LMIX_INPUT_1_SOURCE                  0x9C0
+#define MADERA_DSP3LMIX_INPUT_1_VOLUME                  0x9C1
+#define MADERA_DSP3LMIX_INPUT_2_SOURCE                  0x9C2
+#define MADERA_DSP3LMIX_INPUT_2_VOLUME                  0x9C3
+#define MADERA_DSP3LMIX_INPUT_3_SOURCE                  0x9C4
+#define MADERA_DSP3LMIX_INPUT_3_VOLUME                  0x9C5
+#define MADERA_DSP3LMIX_INPUT_4_SOURCE                  0x9C6
+#define MADERA_DSP3LMIX_INPUT_4_VOLUME                  0x9C7
+#define MADERA_DSP3RMIX_INPUT_1_SOURCE                  0x9C8
+#define MADERA_DSP3RMIX_INPUT_1_VOLUME                  0x9C9
+#define MADERA_DSP3RMIX_INPUT_2_SOURCE                  0x9CA
+#define MADERA_DSP3RMIX_INPUT_2_VOLUME                  0x9CB
+#define MADERA_DSP3RMIX_INPUT_3_SOURCE                  0x9CC
+#define MADERA_DSP3RMIX_INPUT_3_VOLUME                  0x9CD
+#define MADERA_DSP3RMIX_INPUT_4_SOURCE                  0x9CE
+#define MADERA_DSP3RMIX_INPUT_4_VOLUME                  0x9CF
+#define MADERA_DSP3AUX1MIX_INPUT_1_SOURCE               0x9D0
+#define MADERA_DSP3AUX2MIX_INPUT_1_SOURCE               0x9D8
+#define MADERA_DSP3AUX3MIX_INPUT_1_SOURCE               0x9E0
+#define MADERA_DSP3AUX4MIX_INPUT_1_SOURCE               0x9E8
+#define MADERA_DSP3AUX5MIX_INPUT_1_SOURCE               0x9F0
+#define MADERA_DSP3AUX6MIX_INPUT_1_SOURCE               0x9F8
+#define MADERA_DSP4LMIX_INPUT_1_SOURCE                  0xA00
+#define MADERA_DSP4LMIX_INPUT_1_VOLUME                  0xA01
+#define MADERA_DSP4LMIX_INPUT_2_SOURCE                  0xA02
+#define MADERA_DSP4LMIX_INPUT_2_VOLUME                  0xA03
+#define MADERA_DSP4LMIX_INPUT_3_SOURCE                  0xA04
+#define MADERA_DSP4LMIX_INPUT_3_VOLUME                  0xA05
+#define MADERA_DSP4LMIX_INPUT_4_SOURCE                  0xA06
+#define MADERA_DSP4LMIX_INPUT_4_VOLUME                  0xA07
+#define MADERA_DSP4RMIX_INPUT_1_SOURCE                  0xA08
+#define MADERA_DSP4RMIX_INPUT_1_VOLUME                  0xA09
+#define MADERA_DSP4RMIX_INPUT_2_SOURCE                  0xA0A
+#define MADERA_DSP4RMIX_INPUT_2_VOLUME                  0xA0B
+#define MADERA_DSP4RMIX_INPUT_3_SOURCE                  0xA0C
+#define MADERA_DSP4RMIX_INPUT_3_VOLUME                  0xA0D
+#define MADERA_DSP4RMIX_INPUT_4_SOURCE                  0xA0E
+#define MADERA_DSP4RMIX_INPUT_4_VOLUME                  0xA0F
+#define MADERA_DSP4AUX1MIX_INPUT_1_SOURCE               0xA10
+#define MADERA_DSP4AUX2MIX_INPUT_1_SOURCE               0xA18
+#define MADERA_DSP4AUX3MIX_INPUT_1_SOURCE               0xA20
+#define MADERA_DSP4AUX4MIX_INPUT_1_SOURCE               0xA28
+#define MADERA_DSP4AUX5MIX_INPUT_1_SOURCE               0xA30
+#define MADERA_DSP4AUX6MIX_INPUT_1_SOURCE               0xA38
+#define MADERA_DSP5LMIX_INPUT_1_SOURCE                  0xA40
+#define MADERA_DSP5LMIX_INPUT_1_VOLUME                  0xA41
+#define MADERA_DSP5LMIX_INPUT_2_SOURCE                  0xA42
+#define MADERA_DSP5LMIX_INPUT_2_VOLUME                  0xA43
+#define MADERA_DSP5LMIX_INPUT_3_SOURCE                  0xA44
+#define MADERA_DSP5LMIX_INPUT_3_VOLUME                  0xA45
+#define MADERA_DSP5LMIX_INPUT_4_SOURCE                  0xA46
+#define MADERA_DSP5LMIX_INPUT_4_VOLUME                  0xA47
+#define MADERA_DSP5RMIX_INPUT_1_SOURCE                  0xA48
+#define MADERA_DSP5RMIX_INPUT_1_VOLUME                  0xA49
+#define MADERA_DSP5RMIX_INPUT_2_SOURCE                  0xA4A
+#define MADERA_DSP5RMIX_INPUT_2_VOLUME                  0xA4B
+#define MADERA_DSP5RMIX_INPUT_3_SOURCE                  0xA4C
+#define MADERA_DSP5RMIX_INPUT_3_VOLUME                  0xA4D
+#define MADERA_DSP5RMIX_INPUT_4_SOURCE                  0xA4E
+#define MADERA_DSP5RMIX_INPUT_4_VOLUME                  0xA4F
+#define MADERA_DSP5AUX1MIX_INPUT_1_SOURCE               0xA50
+#define MADERA_DSP5AUX2MIX_INPUT_1_SOURCE               0xA58
+#define MADERA_DSP5AUX3MIX_INPUT_1_SOURCE               0xA60
+#define MADERA_DSP5AUX4MIX_INPUT_1_SOURCE               0xA68
+#define MADERA_DSP5AUX5MIX_INPUT_1_SOURCE               0xA70
+#define MADERA_DSP5AUX6MIX_INPUT_1_SOURCE               0xA78
+#define MADERA_ASRC1_1LMIX_INPUT_1_SOURCE               0xA80
+#define MADERA_ASRC1_1RMIX_INPUT_1_SOURCE               0xA88
+#define MADERA_ASRC1_2LMIX_INPUT_1_SOURCE               0xA90
+#define MADERA_ASRC1_2RMIX_INPUT_1_SOURCE               0xA98
+#define MADERA_ASRC2_1LMIX_INPUT_1_SOURCE               0xAA0
+#define MADERA_ASRC2_1RMIX_INPUT_1_SOURCE               0xAA8
+#define MADERA_ASRC2_2LMIX_INPUT_1_SOURCE               0xAB0
+#define MADERA_ASRC2_2RMIX_INPUT_1_SOURCE               0xAB8
+#define MADERA_ISRC1DEC1MIX_INPUT_1_SOURCE              0xB00
+#define MADERA_ISRC1DEC2MIX_INPUT_1_SOURCE              0xB08
+#define MADERA_ISRC1DEC3MIX_INPUT_1_SOURCE              0xB10
+#define MADERA_ISRC1DEC4MIX_INPUT_1_SOURCE              0xB18
+#define MADERA_ISRC1INT1MIX_INPUT_1_SOURCE              0xB20
+#define MADERA_ISRC1INT2MIX_INPUT_1_SOURCE              0xB28
+#define MADERA_ISRC1INT3MIX_INPUT_1_SOURCE              0xB30
+#define MADERA_ISRC1INT4MIX_INPUT_1_SOURCE              0xB38
+#define MADERA_ISRC2DEC1MIX_INPUT_1_SOURCE              0xB40
+#define MADERA_ISRC2DEC2MIX_INPUT_1_SOURCE              0xB48
+#define MADERA_ISRC2DEC3MIX_INPUT_1_SOURCE              0xB50
+#define MADERA_ISRC2DEC4MIX_INPUT_1_SOURCE              0xB58
+#define MADERA_ISRC2INT1MIX_INPUT_1_SOURCE              0xB60
+#define MADERA_ISRC2INT2MIX_INPUT_1_SOURCE              0xB68
+#define MADERA_ISRC2INT3MIX_INPUT_1_SOURCE              0xB70
+#define MADERA_ISRC2INT4MIX_INPUT_1_SOURCE              0xB78
+#define MADERA_ISRC3DEC1MIX_INPUT_1_SOURCE              0xB80
+#define MADERA_ISRC3DEC2MIX_INPUT_1_SOURCE              0xB88
+#define MADERA_ISRC3DEC3MIX_INPUT_1_SOURCE              0xB90
+#define MADERA_ISRC3DEC4MIX_INPUT_1_SOURCE              0xB98
+#define MADERA_ISRC3INT1MIX_INPUT_1_SOURCE              0xBA0
+#define MADERA_ISRC3INT2MIX_INPUT_1_SOURCE              0xBA8
+#define MADERA_ISRC3INT3MIX_INPUT_1_SOURCE              0xBB0
+#define MADERA_ISRC3INT4MIX_INPUT_1_SOURCE              0xBB8
+#define MADERA_ISRC4DEC1MIX_INPUT_1_SOURCE              0xBC0
+#define MADERA_ISRC4DEC2MIX_INPUT_1_SOURCE              0xBC8
+#define MADERA_ISRC4INT1MIX_INPUT_1_SOURCE              0xBE0
+#define MADERA_ISRC4INT2MIX_INPUT_1_SOURCE              0xBE8
+#define MADERA_DSP6LMIX_INPUT_1_SOURCE                  0xC00
+#define MADERA_DSP6LMIX_INPUT_1_VOLUME                  0xC01
+#define MADERA_DSP6LMIX_INPUT_2_SOURCE                  0xC02
+#define MADERA_DSP6LMIX_INPUT_2_VOLUME                  0xC03
+#define MADERA_DSP6LMIX_INPUT_3_SOURCE                  0xC04
+#define MADERA_DSP6LMIX_INPUT_3_VOLUME                  0xC05
+#define MADERA_DSP6LMIX_INPUT_4_SOURCE                  0xC06
+#define MADERA_DSP6LMIX_INPUT_4_VOLUME                  0xC07
+#define MADERA_DSP6RMIX_INPUT_1_SOURCE                  0xC08
+#define MADERA_DSP6RMIX_INPUT_1_VOLUME                  0xC09
+#define MADERA_DSP6RMIX_INPUT_2_SOURCE                  0xC0A
+#define MADERA_DSP6RMIX_INPUT_2_VOLUME                  0xC0B
+#define MADERA_DSP6RMIX_INPUT_3_SOURCE                  0xC0C
+#define MADERA_DSP6RMIX_INPUT_3_VOLUME                  0xC0D
+#define MADERA_DSP6RMIX_INPUT_4_SOURCE                  0xC0E
+#define MADERA_DSP6RMIX_INPUT_4_VOLUME                  0xC0F
+#define MADERA_DSP6AUX1MIX_INPUT_1_SOURCE               0xC10
+#define MADERA_DSP6AUX2MIX_INPUT_1_SOURCE               0xC18
+#define MADERA_DSP6AUX3MIX_INPUT_1_SOURCE               0xC20
+#define MADERA_DSP6AUX4MIX_INPUT_1_SOURCE               0xC28
+#define MADERA_DSP6AUX5MIX_INPUT_1_SOURCE               0xC30
+#define MADERA_DSP6AUX6MIX_INPUT_1_SOURCE               0xC38
+#define MADERA_DSP7LMIX_INPUT_1_SOURCE                  0xC40
+#define MADERA_DSP7LMIX_INPUT_1_VOLUME                  0xC41
+#define MADERA_DSP7LMIX_INPUT_2_SOURCE                  0xC42
+#define MADERA_DSP7LMIX_INPUT_2_VOLUME                  0xC43
+#define MADERA_DSP7LMIX_INPUT_3_SOURCE                  0xC44
+#define MADERA_DSP7LMIX_INPUT_3_VOLUME                  0xC45
+#define MADERA_DSP7LMIX_INPUT_4_SOURCE                  0xC46
+#define MADERA_DSP7LMIX_INPUT_4_VOLUME                  0xC47
+#define MADERA_DSP7RMIX_INPUT_1_SOURCE                  0xC48
+#define MADERA_DSP7RMIX_INPUT_1_VOLUME                  0xC49
+#define MADERA_DSP7RMIX_INPUT_2_SOURCE                  0xC4A
+#define MADERA_DSP7RMIX_INPUT_2_VOLUME                  0xC4B
+#define MADERA_DSP7RMIX_INPUT_3_SOURCE                  0xC4C
+#define MADERA_DSP7RMIX_INPUT_3_VOLUME                  0xC4D
+#define MADERA_DSP7RMIX_INPUT_4_SOURCE                  0xC4E
+#define MADERA_DSP7RMIX_INPUT_4_VOLUME                  0xC4F
+#define MADERA_DSP7AUX1MIX_INPUT_1_SOURCE               0xC50
+#define MADERA_DSP7AUX2MIX_INPUT_1_SOURCE               0xC58
+#define MADERA_DSP7AUX3MIX_INPUT_1_SOURCE               0xC60
+#define MADERA_DSP7AUX4MIX_INPUT_1_SOURCE               0xC68
+#define MADERA_DSP7AUX5MIX_INPUT_1_SOURCE               0xC70
+#define MADERA_DSP7AUX6MIX_INPUT_1_SOURCE               0xC78
+#define MADERA_DFC1MIX_INPUT_1_SOURCE                   0xDC0
+#define MADERA_DFC2MIX_INPUT_1_SOURCE                   0xDC8
+#define MADERA_DFC3MIX_INPUT_1_SOURCE                   0xDD0
+#define MADERA_DFC4MIX_INPUT_1_SOURCE                   0xDD8
+#define MADERA_DFC5MIX_INPUT_1_SOURCE                   0xDE0
+#define MADERA_DFC6MIX_INPUT_1_SOURCE                   0xDE8
+#define MADERA_DFC7MIX_INPUT_1_SOURCE                   0xDF0
+#define MADERA_DFC8MIX_INPUT_1_SOURCE                   0xDF8
+#define MADERA_FX_CTRL1                                 0xE00
+#define MADERA_FX_CTRL2                                 0xE01
+#define MADERA_EQ1_1                                    0xE10
+#define MADERA_EQ1_2                                    0xE11
+#define MADERA_EQ1_21                                   0xE24
+#define MADERA_EQ2_1                                    0xE26
+#define MADERA_EQ2_2                                    0xE27
+#define MADERA_EQ2_21                                   0xE3A
+#define MADERA_EQ3_1                                    0xE3C
+#define MADERA_EQ3_2                                    0xE3D
+#define MADERA_EQ3_21                                   0xE50
+#define MADERA_EQ4_1                                    0xE52
+#define MADERA_EQ4_2                                    0xE53
+#define MADERA_EQ4_21                                   0xE66
+#define MADERA_DRC1_CTRL1                               0xE80
+#define MADERA_DRC1_CTRL2                               0xE81
+#define MADERA_DRC1_CTRL3                               0xE82
+#define MADERA_DRC1_CTRL4                               0xE83
+#define MADERA_DRC1_CTRL5                               0xE84
+#define MADERA_DRC2_CTRL1                               0xE88
+#define MADERA_DRC2_CTRL2                               0xE89
+#define MADERA_DRC2_CTRL3                               0xE8A
+#define MADERA_DRC2_CTRL4                               0xE8B
+#define MADERA_DRC2_CTRL5                               0xE8C
+#define MADERA_HPLPF1_1                                 0xEC0
+#define MADERA_HPLPF1_2                                 0xEC1
+#define MADERA_HPLPF2_1                                 0xEC4
+#define MADERA_HPLPF2_2                                 0xEC5
+#define MADERA_HPLPF3_1                                 0xEC8
+#define MADERA_HPLPF3_2                                 0xEC9
+#define MADERA_HPLPF4_1                                 0xECC
+#define MADERA_HPLPF4_2                                 0xECD
+#define MADERA_ASRC2_ENABLE                             0xED0
+#define MADERA_ASRC2_STATUS                             0xED1
+#define MADERA_ASRC2_RATE1                              0xED2
+#define MADERA_ASRC2_RATE2                              0xED3
+#define MADERA_ASRC1_ENABLE                             0xEE0
+#define MADERA_ASRC1_STATUS                             0xEE1
+#define MADERA_ASRC1_RATE1                              0xEE2
+#define MADERA_ASRC1_RATE2                              0xEE3
+#define MADERA_ISRC_1_CTRL_1                            0xEF0
+#define MADERA_ISRC_1_CTRL_2                            0xEF1
+#define MADERA_ISRC_1_CTRL_3                            0xEF2
+#define MADERA_ISRC_2_CTRL_1                            0xEF3
+#define MADERA_ISRC_2_CTRL_2                            0xEF4
+#define MADERA_ISRC_2_CTRL_3                            0xEF5
+#define MADERA_ISRC_3_CTRL_1                            0xEF6
+#define MADERA_ISRC_3_CTRL_2                            0xEF7
+#define MADERA_ISRC_3_CTRL_3                            0xEF8
+#define MADERA_ISRC_4_CTRL_1                            0xEF9
+#define MADERA_ISRC_4_CTRL_2                            0xEFA
+#define MADERA_ISRC_4_CTRL_3                            0xEFB
+#define MADERA_CLOCK_CONTROL                            0xF00
+#define MADERA_ANC_SRC                                  0xF01
+#define MADERA_DSP_STATUS                               0xF02
+#define MADERA_ANC_COEFF_START                          0xF08
+#define MADERA_ANC_COEFF_END                            0xF12
+#define MADERA_FCL_FILTER_CONTROL                       0xF15
+#define MADERA_FCL_ADC_REFORMATTER_CONTROL              0xF17
+#define MADERA_FCL_COEFF_START                          0xF18
+#define MADERA_FCL_COEFF_END                            0xF69
+#define MADERA_FCR_FILTER_CONTROL                       0xF71
+#define MADERA_FCR_ADC_REFORMATTER_CONTROL              0xF73
+#define MADERA_FCR_COEFF_START                          0xF74
+#define MADERA_FCR_COEFF_END                            0xFC5
+#define MADERA_DAC_COMP_1                               0x1300
+#define MADERA_DAC_COMP_2                               0x1302
+#define MADERA_FRF_COEFFICIENT_1L_1                     0x1380
+#define MADERA_FRF_COEFFICIENT_1L_2                     0x1381
+#define MADERA_FRF_COEFFICIENT_1L_3                     0x1382
+#define MADERA_FRF_COEFFICIENT_1L_4                     0x1383
+#define MADERA_FRF_COEFFICIENT_1R_1                     0x1390
+#define MADERA_FRF_COEFFICIENT_1R_2                     0x1391
+#define MADERA_FRF_COEFFICIENT_1R_3                     0x1392
+#define MADERA_FRF_COEFFICIENT_1R_4                     0x1393
+#define MADERA_FRF_COEFFICIENT_2L_1                     0x13A0
+#define MADERA_FRF_COEFFICIENT_2L_2                     0x13A1
+#define MADERA_FRF_COEFFICIENT_2L_3                     0x13A2
+#define MADERA_FRF_COEFFICIENT_2L_4                     0x13A3
+#define MADERA_FRF_COEFFICIENT_2R_1                     0x13B0
+#define MADERA_FRF_COEFFICIENT_2R_2                     0x13B1
+#define MADERA_FRF_COEFFICIENT_2R_3                     0x13B2
+#define MADERA_FRF_COEFFICIENT_2R_4                     0x13B3
+#define MADERA_FRF_COEFFICIENT_3L_1                     0x13C0
+#define MADERA_FRF_COEFFICIENT_3L_2                     0x13C1
+#define MADERA_FRF_COEFFICIENT_3L_3                     0x13C2
+#define MADERA_FRF_COEFFICIENT_3L_4                     0x13C3
+#define MADERA_FRF_COEFFICIENT_3R_1                     0x13D0
+#define MADERA_FRF_COEFFICIENT_3R_2                     0x13D1
+#define MADERA_FRF_COEFFICIENT_3R_3                     0x13D2
+#define MADERA_FRF_COEFFICIENT_3R_4                     0x13D3
+#define MADERA_FRF_COEFFICIENT_4L_1                     0x13E0
+#define MADERA_FRF_COEFFICIENT_4L_2                     0x13E1
+#define MADERA_FRF_COEFFICIENT_4L_3                     0x13E2
+#define MADERA_FRF_COEFFICIENT_4L_4                     0x13E3
+#define MADERA_FRF_COEFFICIENT_4R_1                     0x13F0
+#define MADERA_FRF_COEFFICIENT_4R_2                     0x13F1
+#define MADERA_FRF_COEFFICIENT_4R_3                     0x13F2
+#define MADERA_FRF_COEFFICIENT_4R_4                     0x13F3
+#define CS47L35_FRF_COEFFICIENT_4L_1                    0x13A0
+#define CS47L35_FRF_COEFFICIENT_4L_2                    0x13A1
+#define CS47L35_FRF_COEFFICIENT_4L_3                    0x13A2
+#define CS47L35_FRF_COEFFICIENT_4L_4                    0x13A3
+#define CS47L35_FRF_COEFFICIENT_5L_1                    0x13B0
+#define CS47L35_FRF_COEFFICIENT_5L_2                    0x13B1
+#define CS47L35_FRF_COEFFICIENT_5L_3                    0x13B2
+#define CS47L35_FRF_COEFFICIENT_5L_4                    0x13B3
+#define CS47L35_FRF_COEFFICIENT_5R_1                    0x13C0
+#define CS47L35_FRF_COEFFICIENT_5R_2                    0x13C1
+#define CS47L35_FRF_COEFFICIENT_5R_3                    0x13C2
+#define CS47L35_FRF_COEFFICIENT_5R_4                    0x13C3
+#define MADERA_FRF_COEFFICIENT_5L_1                     0x1400
+#define MADERA_FRF_COEFFICIENT_5L_2                     0x1401
+#define MADERA_FRF_COEFFICIENT_5L_3                     0x1402
+#define MADERA_FRF_COEFFICIENT_5L_4                     0x1403
+#define MADERA_FRF_COEFFICIENT_5R_1                     0x1410
+#define MADERA_FRF_COEFFICIENT_5R_2                     0x1411
+#define MADERA_FRF_COEFFICIENT_5R_3                     0x1412
+#define MADERA_FRF_COEFFICIENT_5R_4                     0x1413
+#define MADERA_FRF_COEFFICIENT_6L_1                     0x1420
+#define MADERA_FRF_COEFFICIENT_6L_2                     0x1421
+#define MADERA_FRF_COEFFICIENT_6L_3                     0x1422
+#define MADERA_FRF_COEFFICIENT_6L_4                     0x1423
+#define MADERA_FRF_COEFFICIENT_6R_1                     0x1430
+#define MADERA_FRF_COEFFICIENT_6R_2                     0x1431
+#define MADERA_FRF_COEFFICIENT_6R_3                     0x1432
+#define MADERA_FRF_COEFFICIENT_6R_4                     0x1433
+#define MADERA_DFC1_CTRL                                0x1480
+#define MADERA_DFC1_RX                                  0x1482
+#define MADERA_DFC1_TX                                  0x1484
+#define MADERA_DFC2_CTRL                                0x1486
+#define MADERA_DFC2_RX                                  0x1488
+#define MADERA_DFC2_TX                                  0x148A
+#define MADERA_DFC3_CTRL                                0x148C
+#define MADERA_DFC3_RX                                  0x148E
+#define MADERA_DFC3_TX                                  0x1490
+#define MADERA_DFC4_CTRL                                0x1492
+#define MADERA_DFC4_RX                                  0x1494
+#define MADERA_DFC4_TX                                  0x1496
+#define MADERA_DFC5_CTRL                                0x1498
+#define MADERA_DFC5_RX                                  0x149A
+#define MADERA_DFC5_TX                                  0x149C
+#define MADERA_DFC6_CTRL                                0x149E
+#define MADERA_DFC6_RX                                  0x14A0
+#define MADERA_DFC6_TX                                  0x14A2
+#define MADERA_DFC7_CTRL                                0x14A4
+#define MADERA_DFC7_RX                                  0x14A6
+#define MADERA_DFC7_TX                                  0x14A8
+#define MADERA_DFC8_CTRL                                0x14AA
+#define MADERA_DFC8_RX                                  0x14AC
+#define MADERA_DFC8_TX                                  0x14AE
+#define MADERA_DFC_STATUS                               0x14B6
+#define MADERA_ADSP2_IRQ0                               0x1600
+#define MADERA_ADSP2_IRQ1                               0x1601
+#define MADERA_ADSP2_IRQ2                               0x1602
+#define MADERA_ADSP2_IRQ3                               0x1603
+#define MADERA_ADSP2_IRQ4                               0x1604
+#define MADERA_ADSP2_IRQ5                               0x1605
+#define MADERA_ADSP2_IRQ6                               0x1606
+#define MADERA_ADSP2_IRQ7                               0x1607
+#define MADERA_GPIO1_CTRL_1                             0x1700
+#define MADERA_GPIO1_CTRL_2                             0x1701
+#define MADERA_GPIO2_CTRL_1                             0x1702
+#define MADERA_GPIO2_CTRL_2                             0x1703
+#define MADERA_GPIO16_CTRL_1                            0x171E
+#define MADERA_GPIO16_CTRL_2                            0x171F
+#define MADERA_GPIO38_CTRL_1                            0x174A
+#define MADERA_GPIO38_CTRL_2                            0x174B
+#define MADERA_GPIO40_CTRL_1                            0x174E
+#define MADERA_GPIO40_CTRL_2                            0x174F
+#define MADERA_IRQ1_STATUS_1                            0x1800
+#define MADERA_IRQ1_STATUS_2                            0x1801
+#define MADERA_IRQ1_STATUS_6                            0x1805
+#define MADERA_IRQ1_STATUS_7                            0x1806
+#define MADERA_IRQ1_STATUS_9                            0x1808
+#define MADERA_IRQ1_STATUS_11                           0x180A
+#define MADERA_IRQ1_STATUS_12                           0x180B
+#define MADERA_IRQ1_STATUS_15                           0x180E
+#define MADERA_IRQ1_STATUS_33                           0x1820
+#define MADERA_IRQ1_MASK_1                              0x1840
+#define MADERA_IRQ1_MASK_2                              0x1841
+#define MADERA_IRQ1_MASK_6                              0x1845
+#define MADERA_IRQ1_MASK_33                             0x1860
+#define MADERA_IRQ1_RAW_STATUS_1                        0x1880
+#define MADERA_IRQ1_RAW_STATUS_2                        0x1881
+#define MADERA_IRQ1_RAW_STATUS_7                        0x1886
+#define MADERA_IRQ1_RAW_STATUS_15                       0x188E
+#define MADERA_IRQ1_RAW_STATUS_33                       0x18A0
+#define MADERA_INTERRUPT_DEBOUNCE_7                     0x1A06
+#define MADERA_INTERRUPT_DEBOUNCE_15                    0x1A0E
+#define MADERA_IRQ1_CTRL                                0x1A80
+#define MADERA_IRQ2_CTRL                                0x1A82
+#define MADERA_INTERRUPT_RAW_STATUS_1                   0x1AA0
+#define MADERA_WSEQ_SEQUENCE_1                          0x3000
+#define MADERA_WSEQ_SEQUENCE_252                        0x31F6
+#define CS47L35_OTP_HPDET_CAL_1                         0x31F8
+#define CS47L35_OTP_HPDET_CAL_2                         0x31FA
+#define MADERA_WSEQ_SEQUENCE_508                        0x33F6
+#define CS47L85_OTP_HPDET_CAL_1                         0x33F8
+#define CS47L85_OTP_HPDET_CAL_2                         0x33FA
+#define MADERA_OTP_HPDET_CAL_1                          0x20004
+#define MADERA_OTP_HPDET_CAL_2                          0x20006
+#define MADERA_DSP1_CONFIG_1                            0x0FFE00
+#define MADERA_DSP1_CONFIG_2                            0x0FFE02
+#define MADERA_DSP1_SCRATCH_1                           0x0FFE40
+#define MADERA_DSP1_SCRATCH_2                           0x0FFE42
+#define MADERA_DSP1_PMEM_ERR_ADDR___XMEM_ERR_ADDR       0xFFE7C
+#define MADERA_DSP2_CONFIG_1                            0x17FE00
+#define MADERA_DSP2_CONFIG_2                            0x17FE02
+#define MADERA_DSP2_SCRATCH_1                           0x17FE40
+#define MADERA_DSP2_SCRATCH_2                           0x17FE42
+#define MADERA_DSP2_PMEM_ERR_ADDR___XMEM_ERR_ADDR       0x17FE7C
+#define MADERA_DSP3_CONFIG_1                            0x1FFE00
+#define MADERA_DSP3_CONFIG_2                            0x1FFE02
+#define MADERA_DSP3_SCRATCH_1                           0x1FFE40
+#define MADERA_DSP3_SCRATCH_2                           0x1FFE42
+#define MADERA_DSP3_PMEM_ERR_ADDR___XMEM_ERR_ADDR       0x1FFE7C
+#define MADERA_DSP4_CONFIG_1                            0x27FE00
+#define MADERA_DSP4_CONFIG_2                            0x27FE02
+#define MADERA_DSP4_SCRATCH_1                           0x27FE40
+#define MADERA_DSP4_SCRATCH_2                           0x27FE42
+#define MADERA_DSP4_PMEM_ERR_ADDR___XMEM_ERR_ADDR       0x27FE7C
+#define MADERA_DSP5_CONFIG_1                            0x2FFE00
+#define MADERA_DSP5_CONFIG_2                            0x2FFE02
+#define MADERA_DSP5_SCRATCH_1                           0x2FFE40
+#define MADERA_DSP5_SCRATCH_2                           0x2FFE42
+#define MADERA_DSP5_PMEM_ERR_ADDR___XMEM_ERR_ADDR       0x2FFE7C
+#define MADERA_DSP6_CONFIG_1                            0x37FE00
+#define MADERA_DSP6_CONFIG_2                            0x37FE02
+#define MADERA_DSP6_SCRATCH_1                           0x37FE40
+#define MADERA_DSP6_SCRATCH_2                           0x37FE42
+#define MADERA_DSP6_PMEM_ERR_ADDR___XMEM_ERR_ADDR       0x37FE7C
+#define MADERA_DSP7_CONFIG_1                            0x3FFE00
+#define MADERA_DSP7_CONFIG_2                            0x3FFE02
+#define MADERA_DSP7_SCRATCH_1                           0x3FFE40
+#define MADERA_DSP7_SCRATCH_2                           0x3FFE42
+#define MADERA_DSP7_PMEM_ERR_ADDR___XMEM_ERR_ADDR       0x3FFE7C
+
+/* (0x0000)  Software_Reset */
+#define MADERA_SW_RST_DEV_ID1_MASK                      0xFFFF
+#define MADERA_SW_RST_DEV_ID1_SHIFT                          0
+#define MADERA_SW_RST_DEV_ID1_WIDTH                         16
+
+/* (0x0001)  Hardware_Revision */
+#define MADERA_HW_REVISION_MASK                         0x00FF
+#define MADERA_HW_REVISION_SHIFT                             0
+#define MADERA_HW_REVISION_WIDTH                             8
+
+/* (0x0020)  Tone_Generator_1 */
+#define MADERA_TONE2_ENA                                0x0002
+#define MADERA_TONE2_ENA_MASK                           0x0002
+#define MADERA_TONE2_ENA_SHIFT                               1
+#define MADERA_TONE2_ENA_WIDTH                               1
+#define MADERA_TONE1_ENA                                0x0001
+#define MADERA_TONE1_ENA_MASK                           0x0001
+#define MADERA_TONE1_ENA_SHIFT                               0
+#define MADERA_TONE1_ENA_WIDTH                               1
+
+/* (0x0021)  Tone_Generator_2 */
+#define MADERA_TONE1_LVL_0_MASK                         0xFFFF
+#define MADERA_TONE1_LVL_0_SHIFT                             0
+#define MADERA_TONE1_LVL_0_WIDTH                            16
+
+/* (0x0022)  Tone_Generator_3 */
+#define MADERA_TONE1_LVL_MASK                           0x00FF
+#define MADERA_TONE1_LVL_SHIFT                               0
+#define MADERA_TONE1_LVL_WIDTH                               8
+
+/* (0x0023)  Tone_Generator_4 */
+#define MADERA_TONE2_LVL_0_MASK                         0xFFFF
+#define MADERA_TONE2_LVL_0_SHIFT                             0
+#define MADERA_TONE2_LVL_0_WIDTH                            16
+
+/* (0x0024)  Tone_Generator_5 */
+#define MADERA_TONE2_LVL_MASK                           0x00FF
+#define MADERA_TONE2_LVL_SHIFT                               0
+#define MADERA_TONE2_LVL_WIDTH                               8
+
+/* (0x0030)  PWM_Drive_1 */
+#define MADERA_PWM2_ENA                                 0x0002
+#define MADERA_PWM2_ENA_MASK                            0x0002
+#define MADERA_PWM2_ENA_SHIFT                                1
+#define MADERA_PWM2_ENA_WIDTH                                1
+#define MADERA_PWM1_ENA                                 0x0001
+#define MADERA_PWM1_ENA_MASK                            0x0001
+#define MADERA_PWM1_ENA_SHIFT                                0
+#define MADERA_PWM1_ENA_WIDTH                                1
+
+/* (0x00A0)  Comfort_Noise_Generator */
+#define MADERA_NOISE_GEN_ENA                            0x0020
+#define MADERA_NOISE_GEN_ENA_MASK                       0x0020
+#define MADERA_NOISE_GEN_ENA_SHIFT                           5
+#define MADERA_NOISE_GEN_ENA_WIDTH                           1
+#define MADERA_NOISE_GEN_GAIN_MASK                      0x001F
+#define MADERA_NOISE_GEN_GAIN_SHIFT                          0
+#define MADERA_NOISE_GEN_GAIN_WIDTH                          5
+
+/* (0x0100)  Clock_32k_1 */
+#define MADERA_CLK_32K_ENA                              0x0040
+#define MADERA_CLK_32K_ENA_MASK                         0x0040
+#define MADERA_CLK_32K_ENA_SHIFT                             6
+#define MADERA_CLK_32K_ENA_WIDTH                             1
+#define MADERA_CLK_32K_SRC_MASK                         0x0003
+#define MADERA_CLK_32K_SRC_SHIFT                             0
+#define MADERA_CLK_32K_SRC_WIDTH                             2
+
+/* (0x0101)  System_Clock_1 */
+#define MADERA_SYSCLK_FRAC                              0x8000
+#define MADERA_SYSCLK_FRAC_MASK                         0x8000
+#define MADERA_SYSCLK_FRAC_SHIFT                            15
+#define MADERA_SYSCLK_FRAC_WIDTH                             1
+#define MADERA_SYSCLK_FREQ_MASK                         0x0700
+#define MADERA_SYSCLK_FREQ_SHIFT                             8
+#define MADERA_SYSCLK_FREQ_WIDTH                             3
+#define MADERA_SYSCLK_ENA                               0x0040
+#define MADERA_SYSCLK_ENA_MASK                          0x0040
+#define MADERA_SYSCLK_ENA_SHIFT                              6
+#define MADERA_SYSCLK_ENA_WIDTH                              1
+#define MADERA_SYSCLK_SRC_MASK                          0x000F
+#define MADERA_SYSCLK_SRC_SHIFT                              0
+#define MADERA_SYSCLK_SRC_WIDTH                              4
+
+/* (0x0102)  Sample_rate_1 */
+#define MADERA_SAMPLE_RATE_1_MASK                       0x001F
+#define MADERA_SAMPLE_RATE_1_SHIFT                           0
+#define MADERA_SAMPLE_RATE_1_WIDTH                           5
+
+/* (0x0103)  Sample_rate_2 */
+#define MADERA_SAMPLE_RATE_2_MASK                       0x001F
+#define MADERA_SAMPLE_RATE_2_SHIFT                           0
+#define MADERA_SAMPLE_RATE_2_WIDTH                           5
+
+/* (0x0104)  Sample_rate_3 */
+#define MADERA_SAMPLE_RATE_3_MASK                       0x001F
+#define MADERA_SAMPLE_RATE_3_SHIFT                           0
+#define MADERA_SAMPLE_RATE_3_WIDTH                           5
+
+/* (0x0112)  Async_clock_1 */
+#define MADERA_ASYNC_CLK_FREQ_MASK                      0x0700
+#define MADERA_ASYNC_CLK_FREQ_SHIFT                          8
+#define MADERA_ASYNC_CLK_FREQ_WIDTH                          3
+#define MADERA_ASYNC_CLK_ENA                            0x0040
+#define MADERA_ASYNC_CLK_ENA_MASK                       0x0040
+#define MADERA_ASYNC_CLK_ENA_SHIFT                           6
+#define MADERA_ASYNC_CLK_ENA_WIDTH                           1
+#define MADERA_ASYNC_CLK_SRC_MASK                       0x000F
+#define MADERA_ASYNC_CLK_SRC_SHIFT                           0
+#define MADERA_ASYNC_CLK_SRC_WIDTH                           4
+
+/* (0x0113)  Async_sample_rate_1 */
+#define MADERA_ASYNC_SAMPLE_RATE_1_MASK                 0x001F
+#define MADERA_ASYNC_SAMPLE_RATE_1_SHIFT                     0
+#define MADERA_ASYNC_SAMPLE_RATE_1_WIDTH                     5
+
+/* (0x0114)  Async_sample_rate_2 */
+#define MADERA_ASYNC_SAMPLE_RATE_2_MASK                 0x001F
+#define MADERA_ASYNC_SAMPLE_RATE_2_SHIFT                     0
+#define MADERA_ASYNC_SAMPLE_RATE_2_WIDTH                     5
+
+/* (0x0120)  DSP_Clock_1 */
+#define MADERA_DSP_CLK_FREQ_LEGACY                      0x0700
+#define MADERA_DSP_CLK_FREQ_LEGACY_MASK                 0x0700
+#define MADERA_DSP_CLK_FREQ_LEGACY_SHIFT                     8
+#define MADERA_DSP_CLK_FREQ_LEGACY_WIDTH                     3
+#define MADERA_DSP_CLK_ENA                              0x0040
+#define MADERA_DSP_CLK_ENA_MASK                         0x0040
+#define MADERA_DSP_CLK_ENA_SHIFT                             6
+#define MADERA_DSP_CLK_ENA_WIDTH                             1
+#define MADERA_DSP_CLK_SRC                              0x000F
+#define MADERA_DSP_CLK_SRC_MASK                         0x000F
+#define MADERA_DSP_CLK_SRC_SHIFT                             0
+#define MADERA_DSP_CLK_SRC_WIDTH                             4
+
+/* (0x0122)  DSP_Clock_2 */
+#define MADERA_DSP_CLK_FREQ_MASK                        0x03FF
+#define MADERA_DSP_CLK_FREQ_SHIFT                            0
+#define MADERA_DSP_CLK_FREQ_WIDTH                           10
+
+/* (0x0149)  Output_system_clock */
+#define MADERA_OPCLK_ENA                                0x8000
+#define MADERA_OPCLK_ENA_MASK                           0x8000
+#define MADERA_OPCLK_ENA_SHIFT                              15
+#define MADERA_OPCLK_ENA_WIDTH                               1
+#define MADERA_OPCLK_DIV_MASK                           0x00F8
+#define MADERA_OPCLK_DIV_SHIFT                               3
+#define MADERA_OPCLK_DIV_WIDTH                               5
+#define MADERA_OPCLK_SEL_MASK                           0x0007
+#define MADERA_OPCLK_SEL_SHIFT                               0
+#define MADERA_OPCLK_SEL_WIDTH                               3
+
+/* (0x014A)  Output_async_clock */
+#define MADERA_OPCLK_ASYNC_ENA                          0x8000
+#define MADERA_OPCLK_ASYNC_ENA_MASK                     0x8000
+#define MADERA_OPCLK_ASYNC_ENA_SHIFT                        15
+#define MADERA_OPCLK_ASYNC_ENA_WIDTH                         1
+#define MADERA_OPCLK_ASYNC_DIV_MASK                     0x00F8
+#define MADERA_OPCLK_ASYNC_DIV_SHIFT                         3
+#define MADERA_OPCLK_ASYNC_DIV_WIDTH                         5
+#define MADERA_OPCLK_ASYNC_SEL_MASK                     0x0007
+#define MADERA_OPCLK_ASYNC_SEL_SHIFT                         0
+#define MADERA_OPCLK_ASYNC_SEL_WIDTH                         3
+
+/* (0x0171)  FLL1_Control_1 */
+#define MADERA_FLL1_FREERUN                             0x0002
+#define MADERA_FLL1_FREERUN_MASK                        0x0002
+#define MADERA_FLL1_FREERUN_SHIFT                            1
+#define MADERA_FLL1_FREERUN_WIDTH                            1
+#define MADERA_FLL1_ENA                                 0x0001
+#define MADERA_FLL1_ENA_MASK                            0x0001
+#define MADERA_FLL1_ENA_SHIFT                                0
+#define MADERA_FLL1_ENA_WIDTH                                1
+
+/* (0x0172)  FLL1_Control_2 */
+#define MADERA_FLL1_CTRL_UPD                            0x8000
+#define MADERA_FLL1_CTRL_UPD_MASK                       0x8000
+#define MADERA_FLL1_CTRL_UPD_SHIFT                          15
+#define MADERA_FLL1_CTRL_UPD_WIDTH                           1
+#define MADERA_FLL1_N_MASK                              0x03FF
+#define MADERA_FLL1_N_SHIFT                                  0
+#define MADERA_FLL1_N_WIDTH                                 10
+
+/* (0x0173)  FLL1_Control_3 */
+#define MADERA_FLL1_THETA_MASK                          0xFFFF
+#define MADERA_FLL1_THETA_SHIFT                              0
+#define MADERA_FLL1_THETA_WIDTH                             16
+
+/* (0x0174)  FLL1_Control_4 */
+#define MADERA_FLL1_LAMBDA_MASK                         0xFFFF
+#define MADERA_FLL1_LAMBDA_SHIFT                             0
+#define MADERA_FLL1_LAMBDA_WIDTH                            16
+
+/* (0x0175)  FLL1_Control_5 */
+#define MADERA_FLL1_FRATIO_MASK                         0x0F00
+#define MADERA_FLL1_FRATIO_SHIFT                             8
+#define MADERA_FLL1_FRATIO_WIDTH                             4
+
+/* (0x0176)  FLL1_Control_6 */
+#define MADERA_FLL1_REFCLK_DIV_MASK                     0x00C0
+#define MADERA_FLL1_REFCLK_DIV_SHIFT                         6
+#define MADERA_FLL1_REFCLK_DIV_WIDTH                         2
+#define MADERA_FLL1_REFCLK_SRC_MASK                     0x000F
+#define MADERA_FLL1_REFCLK_SRC_SHIFT                         0
+#define MADERA_FLL1_REFCLK_SRC_WIDTH                         4
+
+/* (0x0177)  FLL1_Loop_Filter_Test_1 */
+#define MADERA_FLL1_FRC_INTEG_UPD                       0x8000
+#define MADERA_FLL1_FRC_INTEG_UPD_MASK                  0x8000
+#define MADERA_FLL1_FRC_INTEG_UPD_SHIFT                     15
+#define MADERA_FLL1_FRC_INTEG_UPD_WIDTH                      1
+#define MADERA_FLL1_FRC_INTEG_VAL_MASK                  0x0FFF
+#define MADERA_FLL1_FRC_INTEG_VAL_SHIFT                      0
+#define MADERA_FLL1_FRC_INTEG_VAL_WIDTH                     12
+
+/* (0x0179)  FLL1_Control_7 */
+#define MADERA_FLL1_GAIN_MASK                           0x003c
+#define MADERA_FLL1_GAIN_SHIFT                               2
+#define MADERA_FLL1_GAIN_WIDTH                               4
+
+/* (0x017A)  FLL1_EFS_2 */
+#define MADERA_FLL1_PHASE_GAIN_MASK                     0xF000
+#define MADERA_FLL1_PHASE_GAIN_SHIFT                        12
+#define MADERA_FLL1_PHASE_GAIN_WIDTH                         4
+#define MADERA_FLL1_PHASE_ENA_MASK                      0x0800
+#define MADERA_FLL1_PHASE_ENA_SHIFT                         11
+#define MADERA_FLL1_PHASE_ENA_WIDTH                          1
+
+/* (0x0181)  FLL1_Synchroniser_1 */
+#define MADERA_FLL1_SYNC_ENA                            0x0001
+#define MADERA_FLL1_SYNC_ENA_MASK                       0x0001
+#define MADERA_FLL1_SYNC_ENA_SHIFT                           0
+#define MADERA_FLL1_SYNC_ENA_WIDTH                           1
+
+/* (0x0182)  FLL1_Synchroniser_2 */
+#define MADERA_FLL1_SYNC_N_MASK                         0x03FF
+#define MADERA_FLL1_SYNC_N_SHIFT                             0
+#define MADERA_FLL1_SYNC_N_WIDTH                            10
+
+/* (0x0183)  FLL1_Synchroniser_3 */
+#define MADERA_FLL1_SYNC_THETA_MASK                     0xFFFF
+#define MADERA_FLL1_SYNC_THETA_SHIFT                         0
+#define MADERA_FLL1_SYNC_THETA_WIDTH                        16
+
+/* (0x0184)  FLL1_Synchroniser_4 */
+#define MADERA_FLL1_SYNC_LAMBDA_MASK                    0xFFFF
+#define MADERA_FLL1_SYNC_LAMBDA_SHIFT                        0
+#define MADERA_FLL1_SYNC_LAMBDA_WIDTH                       16
+
+/* (0x0185)  FLL1_Synchroniser_5 */
+#define MADERA_FLL1_SYNC_FRATIO_MASK                    0x0700
+#define MADERA_FLL1_SYNC_FRATIO_SHIFT                        8
+#define MADERA_FLL1_SYNC_FRATIO_WIDTH                        3
+
+/* (0x0186)  FLL1_Synchroniser_6 */
+#define MADERA_FLL1_SYNCCLK_DIV_MASK                    0x00C0
+#define MADERA_FLL1_SYNCCLK_DIV_SHIFT                        6
+#define MADERA_FLL1_SYNCCLK_DIV_WIDTH                        2
+#define MADERA_FLL1_SYNCCLK_SRC_MASK                    0x000F
+#define MADERA_FLL1_SYNCCLK_SRC_SHIFT                        0
+#define MADERA_FLL1_SYNCCLK_SRC_WIDTH                        4
+
+/* (0x0187)  FLL1_Synchroniser_7 */
+#define MADERA_FLL1_SYNC_GAIN_MASK                      0x003c
+#define MADERA_FLL1_SYNC_GAIN_SHIFT                          2
+#define MADERA_FLL1_SYNC_GAIN_WIDTH                          4
+#define MADERA_FLL1_SYNC_DFSAT                          0x0001
+#define MADERA_FLL1_SYNC_DFSAT_MASK                     0x0001
+#define MADERA_FLL1_SYNC_DFSAT_SHIFT                         0
+#define MADERA_FLL1_SYNC_DFSAT_WIDTH                         1
+
+/* (0x01D1)  FLL_AO_Control_1 */
+#define MADERA_FLL_AO_HOLD                              0x0004
+#define MADERA_FLL_AO_HOLD_MASK                         0x0004
+#define MADERA_FLL_AO_HOLD_SHIFT                             2
+#define MADERA_FLL_AO_HOLD_WIDTH                             1
+#define MADERA_FLL_AO_FREERUN                           0x0002
+#define MADERA_FLL_AO_FREERUN_MASK                      0x0002
+#define MADERA_FLL_AO_FREERUN_SHIFT                          1
+#define MADERA_FLL_AO_FREERUN_WIDTH                          1
+#define MADERA_FLL_AO_ENA                               0x0001
+#define MADERA_FLL_AO_ENA_MASK                          0x0001
+#define MADERA_FLL_AO_ENA_SHIFT                              0
+#define MADERA_FLL_AO_ENA_WIDTH                              1
+
+/* (0x01D2)  FLL_AO_Control_2 */
+#define MADERA_FLL_AO_CTRL_UPD                          0x8000
+#define MADERA_FLL_AO_CTRL_UPD_MASK                     0x8000
+#define MADERA_FLL_AO_CTRL_UPD_SHIFT                        15
+#define MADERA_FLL_AO_CTRL_UPD_WIDTH                         1
+
+/* (0x01D6)  FLL_AO_Control_6 */
+#define MADERA_FLL_AO_REFCLK_SRC_MASK                   0x000F
+#define MADERA_FLL_AO_REFCLK_SRC_SHIFT                       0
+#define MADERA_FLL_AO_REFCLK_SRC_WIDTH                       4
+
+/* (0x0200)  Mic_Charge_Pump_1 */
+#define MADERA_CPMIC_BYPASS                             0x0002
+#define MADERA_CPMIC_BYPASS_MASK                        0x0002
+#define MADERA_CPMIC_BYPASS_SHIFT                            1
+#define MADERA_CPMIC_BYPASS_WIDTH                            1
+#define MADERA_CPMIC_ENA                                0x0001
+#define MADERA_CPMIC_ENA_MASK                           0x0001
+#define MADERA_CPMIC_ENA_SHIFT                               0
+#define MADERA_CPMIC_ENA_WIDTH                               1
+
+/* (0x0210)  LDO1_Control_1 */
+#define MADERA_LDO1_VSEL_MASK                           0x07E0
+#define MADERA_LDO1_VSEL_SHIFT                               5
+#define MADERA_LDO1_VSEL_WIDTH                               6
+#define MADERA_LDO1_FAST                                0x0010
+#define MADERA_LDO1_FAST_MASK                           0x0010
+#define MADERA_LDO1_FAST_SHIFT                               4
+#define MADERA_LDO1_FAST_WIDTH                               1
+#define MADERA_LDO1_DISCH                               0x0004
+#define MADERA_LDO1_DISCH_MASK                          0x0004
+#define MADERA_LDO1_DISCH_SHIFT                              2
+#define MADERA_LDO1_DISCH_WIDTH                              1
+#define MADERA_LDO1_BYPASS                              0x0002
+#define MADERA_LDO1_BYPASS_MASK                         0x0002
+#define MADERA_LDO1_BYPASS_SHIFT                             1
+#define MADERA_LDO1_BYPASS_WIDTH                             1
+#define MADERA_LDO1_ENA                                 0x0001
+#define MADERA_LDO1_ENA_MASK                            0x0001
+#define MADERA_LDO1_ENA_SHIFT                                0
+#define MADERA_LDO1_ENA_WIDTH                                1
+
+/* (0x0213)  LDO2_Control_1 */
+#define MADERA_LDO2_VSEL_MASK                           0x07E0
+#define MADERA_LDO2_VSEL_SHIFT                               5
+#define MADERA_LDO2_VSEL_WIDTH                               6
+#define MADERA_LDO2_FAST                                0x0010
+#define MADERA_LDO2_FAST_MASK                           0x0010
+#define MADERA_LDO2_FAST_SHIFT                               4
+#define MADERA_LDO2_FAST_WIDTH                               1
+#define MADERA_LDO2_DISCH                               0x0004
+#define MADERA_LDO2_DISCH_MASK                          0x0004
+#define MADERA_LDO2_DISCH_SHIFT                              2
+#define MADERA_LDO2_DISCH_WIDTH                              1
+#define MADERA_LDO2_BYPASS                              0x0002
+#define MADERA_LDO2_BYPASS_MASK                         0x0002
+#define MADERA_LDO2_BYPASS_SHIFT                             1
+#define MADERA_LDO2_BYPASS_WIDTH                             1
+#define MADERA_LDO2_ENA                                 0x0001
+#define MADERA_LDO2_ENA_MASK                            0x0001
+#define MADERA_LDO2_ENA_SHIFT                                0
+#define MADERA_LDO2_ENA_WIDTH                                1
+
+/* (0x0218)  Mic_Bias_Ctrl_1 */
+#define MADERA_MICB1_ENA                                0x0001
+#define MADERA_MICB1_ENA_MASK                           0x0001
+#define MADERA_MICB1_ENA_SHIFT                               0
+#define MADERA_MICB1_ENA_WIDTH                               1
+
+/* (0x021C)  Mic_Bias_Ctrl_5 */
+#define MADERA_MICB1D_ENA                               0x1000
+#define MADERA_MICB1D_ENA_MASK                          0x1000
+#define MADERA_MICB1D_ENA_SHIFT                             12
+#define MADERA_MICB1D_ENA_WIDTH                              1
+#define MADERA_MICB1C_ENA                               0x0100
+#define MADERA_MICB1C_ENA_MASK                          0x0100
+#define MADERA_MICB1C_ENA_SHIFT                              8
+#define MADERA_MICB1C_ENA_WIDTH                              1
+#define MADERA_MICB1B_ENA                               0x0010
+#define MADERA_MICB1B_ENA_MASK                          0x0010
+#define MADERA_MICB1B_ENA_SHIFT                              4
+#define MADERA_MICB1B_ENA_WIDTH                              1
+#define MADERA_MICB1A_ENA                               0x0001
+#define MADERA_MICB1A_ENA_MASK                          0x0001
+#define MADERA_MICB1A_ENA_SHIFT                              0
+#define MADERA_MICB1A_ENA_WIDTH                              1
+
+/* (0x021E)  Mic_Bias_Ctrl_6 */
+#define MADERA_MICB2D_ENA                               0x1000
+#define MADERA_MICB2D_ENA_MASK                          0x1000
+#define MADERA_MICB2D_ENA_SHIFT                             12
+#define MADERA_MICB2D_ENA_WIDTH                              1
+#define MADERA_MICB2C_ENA                               0x0100
+#define MADERA_MICB2C_ENA_MASK                          0x0100
+#define MADERA_MICB2C_ENA_SHIFT                              8
+#define MADERA_MICB2C_ENA_WIDTH                              1
+#define MADERA_MICB2B_ENA                               0x0010
+#define MADERA_MICB2B_ENA_MASK                          0x0010
+#define MADERA_MICB2B_ENA_SHIFT                              4
+#define MADERA_MICB2B_ENA_WIDTH                              1
+#define MADERA_MICB2A_ENA                               0x0001
+#define MADERA_MICB2A_ENA_MASK                          0x0001
+#define MADERA_MICB2A_ENA_SHIFT                              0
+#define MADERA_MICB2A_ENA_WIDTH                              1
+
+/* (0x0225) - HP Ctrl 1L */
+#define MADERA_RMV_SHRT_HP1L                            0x4000
+#define MADERA_RMV_SHRT_HP1L_MASK                       0x4000
+#define MADERA_RMV_SHRT_HP1L_SHIFT                          14
+#define MADERA_RMV_SHRT_HP1L_WIDTH                           1
+#define MADERA_HP1L_FLWR                                0x0004
+#define MADERA_HP1L_FLWR_MASK                           0x0004
+#define MADERA_HP1L_FLWR_SHIFT                               2
+#define MADERA_HP1L_FLWR_WIDTH                               1
+#define MADERA_HP1L_SHRTI                               0x0002
+#define MADERA_HP1L_SHRTI_MASK                          0x0002
+#define MADERA_HP1L_SHRTI_SHIFT                              1
+#define MADERA_HP1L_SHRTI_WIDTH                              1
+#define MADERA_HP1L_SHRTO                               0x0001
+#define MADERA_HP1L_SHRTO_MASK                          0x0001
+#define MADERA_HP1L_SHRTO_SHIFT                              0
+#define MADERA_HP1L_SHRTO_WIDTH                              1
+
+/* (0x0226) - HP Ctrl 1R */
+#define MADERA_RMV_SHRT_HP1R                            0x4000
+#define MADERA_RMV_SHRT_HP1R_MASK                       0x4000
+#define MADERA_RMV_SHRT_HP1R_SHIFT                          14
+#define MADERA_RMV_SHRT_HP1R_WIDTH                           1
+#define MADERA_HP1R_FLWR                                0x0004
+#define MADERA_HP1R_FLWR_MASK                           0x0004
+#define MADERA_HP1R_FLWR_SHIFT                               2
+#define MADERA_HP1R_FLWR_WIDTH                               1
+#define MADERA_HP1R_SHRTI                               0x0002
+#define MADERA_HP1R_SHRTI_MASK                          0x0002
+#define MADERA_HP1R_SHRTI_SHIFT                              1
+#define MADERA_HP1R_SHRTI_WIDTH                              1
+#define MADERA_HP1R_SHRTO                               0x0001
+#define MADERA_HP1R_SHRTO_MASK                          0x0001
+#define MADERA_HP1R_SHRTO_SHIFT                              0
+#define MADERA_HP1R_SHRTO_WIDTH                              1
+
+/* (0x0293)  Accessory_Detect_Mode_1 */
+#define MADERA_ACCDET_SRC                               0x2000
+#define MADERA_ACCDET_SRC_MASK                          0x2000
+#define MADERA_ACCDET_SRC_SHIFT                             13
+#define MADERA_ACCDET_SRC_WIDTH                              1
+#define MADERA_ACCDET_POLARITY_INV_ENA                  0x0080
+#define MADERA_ACCDET_POLARITY_INV_ENA_MASK             0x0080
+#define MADERA_ACCDET_POLARITY_INV_ENA_SHIFT                 7
+#define MADERA_ACCDET_POLARITY_INV_ENA_WIDTH                 1
+#define MADERA_ACCDET_MODE_MASK                         0x0007
+#define MADERA_ACCDET_MODE_SHIFT                             0
+#define MADERA_ACCDET_MODE_WIDTH                             3
+
+/* (0x0299)  Headphone_Detect_0 */
+#define MADERA_HPD_GND_SEL                              0x0007
+#define MADERA_HPD_GND_SEL_MASK                         0x0007
+#define MADERA_HPD_GND_SEL_SHIFT                             0
+#define MADERA_HPD_GND_SEL_WIDTH                             3
+#define MADERA_HPD_SENSE_SEL                            0x00F0
+#define MADERA_HPD_SENSE_SEL_MASK                       0x00F0
+#define MADERA_HPD_SENSE_SEL_SHIFT                           4
+#define MADERA_HPD_SENSE_SEL_WIDTH                           4
+#define MADERA_HPD_FRC_SEL                              0x0F00
+#define MADERA_HPD_FRC_SEL_MASK                         0x0F00
+#define MADERA_HPD_FRC_SEL_SHIFT                             8
+#define MADERA_HPD_FRC_SEL_WIDTH                             4
+#define MADERA_HPD_OUT_SEL                              0x7000
+#define MADERA_HPD_OUT_SEL_MASK                         0x7000
+#define MADERA_HPD_OUT_SEL_SHIFT                            12
+#define MADERA_HPD_OUT_SEL_WIDTH                             3
+#define MADERA_HPD_OVD_ENA_SEL                          0x8000
+#define MADERA_HPD_OVD_ENA_SEL_MASK                     0x8000
+#define MADERA_HPD_OVD_ENA_SEL_SHIFT                        15
+#define MADERA_HPD_OVD_ENA_SEL_WIDTH                         1
+
+/* (0x029B)  Headphone_Detect_1 */
+#define MADERA_HP_IMPEDANCE_RANGE_MASK                  0x0600
+#define MADERA_HP_IMPEDANCE_RANGE_SHIFT                      9
+#define MADERA_HP_IMPEDANCE_RANGE_WIDTH                      2
+#define MADERA_HP_STEP_SIZE                             0x0100
+#define MADERA_HP_STEP_SIZE_MASK                        0x0100
+#define MADERA_HP_STEP_SIZE_SHIFT                            8
+#define MADERA_HP_STEP_SIZE_WIDTH                            1
+#define MADERA_HP_CLK_DIV_MASK                          0x0018
+#define MADERA_HP_CLK_DIV_SHIFT                              3
+#define MADERA_HP_CLK_DIV_WIDTH                              2
+#define MADERA_HP_RATE_MASK                             0x0006
+#define MADERA_HP_RATE_SHIFT                                 1
+#define MADERA_HP_RATE_WIDTH                                 2
+#define MADERA_HP_POLL                                  0x0001
+#define MADERA_HP_POLL_MASK                             0x0001
+#define MADERA_HP_POLL_SHIFT                                 0
+#define MADERA_HP_POLL_WIDTH                                 1
+
+/* (0x029C)  Headphone_Detect_2 */
+#define MADERA_HP_DONE_MASK                             0x8000
+#define MADERA_HP_DONE_SHIFT                                15
+#define MADERA_HP_DONE_WIDTH                                 1
+#define MADERA_HP_LVL_MASK                              0x7FFF
+#define MADERA_HP_LVL_SHIFT                                  0
+#define MADERA_HP_LVL_WIDTH                                 15
+
+/* (0x029D)  Headphone_Detect_3 */
+#define MADERA_HP_DACVAL_MASK                           0x03FF
+#define MADERA_HP_DACVAL_SHIFT                               0
+#define MADERA_HP_DACVAL_WIDTH                              10
+
+/* (0x029F) - Headphone Detect 5 */
+#define MADERA_HP_DACVAL_DOWN_MASK                      0x03FF
+#define MADERA_HP_DACVAL_DOWN_SHIFT                          0
+#define MADERA_HP_DACVAL_DOWN_WIDTH                         10
+
+/* (0x02A2)  Mic_Detect_1_Control_0 */
+#define MADERA_MICD1_GND_MASK                           0x0007
+#define MADERA_MICD1_GND_SHIFT                               0
+#define MADERA_MICD1_GND_WIDTH                               3
+#define MADERA_MICD1_SENSE_MASK                         0x00F0
+#define MADERA_MICD1_SENSE_SHIFT                             4
+#define MADERA_MICD1_SENSE_WIDTH                             4
+#define MADERA_MICD1_ADC_MODE_MASK                      0x8000
+#define MADERA_MICD1_ADC_MODE_SHIFT                         15
+#define MADERA_MICD1_ADC_MODE_WIDTH                          1
+
+/* (0x02A3)  Mic_Detect_1_Control_1 */
+#define MADERA_MICD_BIAS_STARTTIME_MASK                 0xF000
+#define MADERA_MICD_BIAS_STARTTIME_SHIFT                    12
+#define MADERA_MICD_BIAS_STARTTIME_WIDTH                     4
+#define MADERA_MICD_RATE_MASK                           0x0F00
+#define MADERA_MICD_RATE_SHIFT                               8
+#define MADERA_MICD_RATE_WIDTH                               4
+#define MADERA_MICD_BIAS_SRC_MASK                       0x00F0
+#define MADERA_MICD_BIAS_SRC_SHIFT                           4
+#define MADERA_MICD_BIAS_SRC_WIDTH                           4
+#define MADERA_MICD_DBTIME                              0x0002
+#define MADERA_MICD_DBTIME_MASK                         0x0002
+#define MADERA_MICD_DBTIME_SHIFT                             1
+#define MADERA_MICD_DBTIME_WIDTH                             1
+#define MADERA_MICD_ENA                                 0x0001
+#define MADERA_MICD_ENA_MASK                            0x0001
+#define MADERA_MICD_ENA_SHIFT                                0
+#define MADERA_MICD_ENA_WIDTH                                1
+
+/* (0x02A4)  Mic_Detect_1_Control_2 */
+#define MADERA_MICD_LVL_SEL_MASK                        0x00FF
+#define MADERA_MICD_LVL_SEL_SHIFT                            0
+#define MADERA_MICD_LVL_SEL_WIDTH                            8
+
+/* (0x02A5)  Mic_Detect_1_Control_3 */
+#define MADERA_MICD_LVL_0                               0x0004
+#define MADERA_MICD_LVL_1                               0x0008
+#define MADERA_MICD_LVL_2                               0x0010
+#define MADERA_MICD_LVL_3                               0x0020
+#define MADERA_MICD_LVL_4                               0x0040
+#define MADERA_MICD_LVL_5                               0x0080
+#define MADERA_MICD_LVL_6                               0x0100
+#define MADERA_MICD_LVL_7                               0x0200
+#define MADERA_MICD_LVL_8                               0x0400
+#define MADERA_MICD_LVL_MASK                            0x07FC
+#define MADERA_MICD_LVL_SHIFT                                2
+#define MADERA_MICD_LVL_WIDTH                                9
+#define MADERA_MICD_VALID                               0x0002
+#define MADERA_MICD_VALID_MASK                          0x0002
+#define MADERA_MICD_VALID_SHIFT                              1
+#define MADERA_MICD_VALID_WIDTH                              1
+#define MADERA_MICD_STS                                 0x0001
+#define MADERA_MICD_STS_MASK                            0x0001
+#define MADERA_MICD_STS_SHIFT                                0
+#define MADERA_MICD_STS_WIDTH                                1
+
+/* (0x02AB)  Mic_Detect_1_Control_4 */
+#define MADERA_MICDET_ADCVAL_DIFF_MASK                  0xFF00
+#define MADERA_MICDET_ADCVAL_DIFF_SHIFT                      8
+#define MADERA_MICDET_ADCVAL_DIFF_WIDTH                      8
+#define MADERA_MICDET_ADCVAL_MASK                       0x007F
+#define MADERA_MICDET_ADCVAL_SHIFT                           0
+#define MADERA_MICDET_ADCVAL_WIDTH                           7
+
+/* (0x02C6)  Micd_Clamp_control */
+#define MADERA_MICD_CLAMP_OVD                           0x0010
+#define MADERA_MICD_CLAMP_OVD_MASK                      0x0010
+#define MADERA_MICD_CLAMP_OVD_SHIFT                          4
+#define MADERA_MICD_CLAMP_OVD_WIDTH                          1
+#define MADERA_MICD_CLAMP_MODE_MASK                     0x000F
+#define MADERA_MICD_CLAMP_MODE_SHIFT                         0
+#define MADERA_MICD_CLAMP_MODE_WIDTH                         4
+
+/* (0x02C8)  GP_Switch_1 */
+#define MADERA_SW2_MODE_MASK                            0x000C
+#define MADERA_SW2_MODE_SHIFT                                2
+#define MADERA_SW2_MODE_WIDTH                                2
+#define MADERA_SW1_MODE_MASK                            0x0003
+#define MADERA_SW1_MODE_SHIFT                                0
+#define MADERA_SW1_MODE_WIDTH                                2
+
+/* (0x02D3)  Jack_detect_analogue */
+#define MADERA_JD2_ENA                                  0x0002
+#define MADERA_JD2_ENA_MASK                             0x0002
+#define MADERA_JD2_ENA_SHIFT                                 1
+#define MADERA_JD2_ENA_WIDTH                                 1
+#define MADERA_JD1_ENA                                  0x0001
+#define MADERA_JD1_ENA_MASK                             0x0001
+#define MADERA_JD1_ENA_SHIFT                                 0
+#define MADERA_JD1_ENA_WIDTH                                 1
+
+/* (0x0300)  Input_Enables */
+#define MADERA_IN6L_ENA                                 0x0800
+#define MADERA_IN6L_ENA_MASK                            0x0800
+#define MADERA_IN6L_ENA_SHIFT                               11
+#define MADERA_IN6L_ENA_WIDTH                                1
+#define MADERA_IN6R_ENA                                 0x0400
+#define MADERA_IN6R_ENA_MASK                            0x0400
+#define MADERA_IN6R_ENA_SHIFT                               10
+#define MADERA_IN6R_ENA_WIDTH                                1
+#define MADERA_IN5L_ENA                                 0x0200
+#define MADERA_IN5L_ENA_MASK                            0x0200
+#define MADERA_IN5L_ENA_SHIFT                                9
+#define MADERA_IN5L_ENA_WIDTH                                1
+#define MADERA_IN5R_ENA                                 0x0100
+#define MADERA_IN5R_ENA_MASK                            0x0100
+#define MADERA_IN5R_ENA_SHIFT                                8
+#define MADERA_IN5R_ENA_WIDTH                                1
+#define MADERA_IN4L_ENA                                 0x0080
+#define MADERA_IN4L_ENA_MASK                            0x0080
+#define MADERA_IN4L_ENA_SHIFT                                7
+#define MADERA_IN4L_ENA_WIDTH                                1
+#define MADERA_IN4R_ENA                                 0x0040
+#define MADERA_IN4R_ENA_MASK                            0x0040
+#define MADERA_IN4R_ENA_SHIFT                                6
+#define MADERA_IN4R_ENA_WIDTH                                1
+#define MADERA_IN3L_ENA                                 0x0020
+#define MADERA_IN3L_ENA_MASK                            0x0020
+#define MADERA_IN3L_ENA_SHIFT                                5
+#define MADERA_IN3L_ENA_WIDTH                                1
+#define MADERA_IN3R_ENA                                 0x0010
+#define MADERA_IN3R_ENA_MASK                            0x0010
+#define MADERA_IN3R_ENA_SHIFT                                4
+#define MADERA_IN3R_ENA_WIDTH                                1
+#define MADERA_IN2L_ENA                                 0x0008
+#define MADERA_IN2L_ENA_MASK                            0x0008
+#define MADERA_IN2L_ENA_SHIFT                                3
+#define MADERA_IN2L_ENA_WIDTH                                1
+#define MADERA_IN2R_ENA                                 0x0004
+#define MADERA_IN2R_ENA_MASK                            0x0004
+#define MADERA_IN2R_ENA_SHIFT                                2
+#define MADERA_IN2R_ENA_WIDTH                                1
+#define MADERA_IN1L_ENA                                 0x0002
+#define MADERA_IN1L_ENA_MASK                            0x0002
+#define MADERA_IN1L_ENA_SHIFT                                1
+#define MADERA_IN1L_ENA_WIDTH                                1
+#define MADERA_IN1R_ENA                                 0x0001
+#define MADERA_IN1R_ENA_MASK                            0x0001
+#define MADERA_IN1R_ENA_SHIFT                                0
+#define MADERA_IN1R_ENA_WIDTH                                1
+
+/* (0x0308)  Input_Rate */
+#define MADERA_IN_RATE_MASK                             0xF800
+#define MADERA_IN_RATE_SHIFT                                11
+#define MADERA_IN_RATE_WIDTH                                 5
+#define MADERA_IN_MODE_MASK                             0x0400
+#define MADERA_IN_MODE_SHIFT                                10
+#define MADERA_IN_MODE_WIDTH                                 1
+
+/* (0x0309)  Input_Volume_Ramp */
+#define MADERA_IN_VD_RAMP_MASK                          0x0070
+#define MADERA_IN_VD_RAMP_SHIFT                              4
+#define MADERA_IN_VD_RAMP_WIDTH                              3
+#define MADERA_IN_VI_RAMP_MASK                          0x0007
+#define MADERA_IN_VI_RAMP_SHIFT                              0
+#define MADERA_IN_VI_RAMP_WIDTH                              3
+
+/* (0x030C)  HPF_Control */
+#define MADERA_IN_HPF_CUT_MASK                          0x0007
+#define MADERA_IN_HPF_CUT_SHIFT                              0
+#define MADERA_IN_HPF_CUT_WIDTH                              3
+
+/* (0x0310)  IN1L_Control */
+#define MADERA_IN1L_HPF_MASK                            0x8000
+#define MADERA_IN1L_HPF_SHIFT                               15
+#define MADERA_IN1L_HPF_WIDTH                                1
+#define MADERA_IN1_DMIC_SUP_MASK                        0x1800
+#define MADERA_IN1_DMIC_SUP_SHIFT                           11
+#define MADERA_IN1_DMIC_SUP_WIDTH                            2
+#define MADERA_IN1_MODE_MASK                            0x0400
+#define MADERA_IN1_MODE_SHIFT                               10
+#define MADERA_IN1_MODE_WIDTH                                1
+#define MADERA_IN1L_PGA_VOL_MASK                        0x00FE
+#define MADERA_IN1L_PGA_VOL_SHIFT                            1
+#define MADERA_IN1L_PGA_VOL_WIDTH                            7
+
+/* (0x0311)  ADC_Digital_Volume_1L */
+#define MADERA_IN1L_SRC_MASK                            0x4000
+#define MADERA_IN1L_SRC_SHIFT                               14
+#define MADERA_IN1L_SRC_WIDTH                                1
+#define MADERA_IN1L_SRC_SE_MASK                         0x2000
+#define MADERA_IN1L_SRC_SE_SHIFT                            13
+#define MADERA_IN1L_SRC_SE_WIDTH                             1
+#define MADERA_IN1L_LP_MODE                             0x0800
+#define MADERA_IN1L_LP_MODE_MASK                        0x0800
+#define MADERA_IN1L_LP_MODE_SHIFT                           11
+#define MADERA_IN1L_LP_MODE_WIDTH                            1
+#define MADERA_IN_VU                                    0x0200
+#define MADERA_IN_VU_MASK                               0x0200
+#define MADERA_IN_VU_SHIFT                                   9
+#define MADERA_IN_VU_WIDTH                                   1
+#define MADERA_IN1L_MUTE                                0x0100
+#define MADERA_IN1L_MUTE_MASK                           0x0100
+#define MADERA_IN1L_MUTE_SHIFT                               8
+#define MADERA_IN1L_MUTE_WIDTH                               1
+#define MADERA_IN1L_DIG_VOL_MASK                        0x00FF
+#define MADERA_IN1L_DIG_VOL_SHIFT                            0
+#define MADERA_IN1L_DIG_VOL_WIDTH                            8
+
+/* (0x0312)  DMIC1L_Control */
+#define MADERA_IN1_OSR_MASK                             0x0700
+#define MADERA_IN1_OSR_SHIFT                                 8
+#define MADERA_IN1_OSR_WIDTH                                 3
+
+/* (0x0313)  IN1L_Rate_Control */
+#define MADERA_IN1L_RATE_MASK                           0xF800
+#define MADERA_IN1L_RATE_SHIFT                              11
+#define MADERA_IN1L_RATE_WIDTH                               5
+
+/* (0x0314)  IN1R_Control */
+#define MADERA_IN1R_HPF_MASK                            0x8000
+#define MADERA_IN1R_HPF_SHIFT                               15
+#define MADERA_IN1R_HPF_WIDTH                                1
+#define MADERA_IN1R_PGA_VOL_MASK                        0x00FE
+#define MADERA_IN1R_PGA_VOL_SHIFT                            1
+#define MADERA_IN1R_PGA_VOL_WIDTH                            7
+#define MADERA_IN1_DMICCLK_SRC_MASK                     0x1800
+#define MADERA_IN1_DMICCLK_SRC_SHIFT                        11
+#define MADERA_IN1_DMICCLK_SRC_WIDTH                         2
+
+/* (0x0315)  ADC_Digital_Volume_1R */
+#define MADERA_IN1R_SRC_MASK                            0x4000
+#define MADERA_IN1R_SRC_SHIFT                               14
+#define MADERA_IN1R_SRC_WIDTH                                1
+#define MADERA_IN1R_SRC_SE_MASK                         0x2000
+#define MADERA_IN1R_SRC_SE_SHIFT                            13
+#define MADERA_IN1R_SRC_SE_WIDTH                             1
+#define MADERA_IN1R_LP_MODE                             0x0800
+#define MADERA_IN1R_LP_MODE_MASK                        0x0800
+#define MADERA_IN1R_LP_MODE_SHIFT                           11
+#define MADERA_IN1R_LP_MODE_WIDTH                            1
+#define MADERA_IN1R_MUTE                                0x0100
+#define MADERA_IN1R_MUTE_MASK                           0x0100
+#define MADERA_IN1R_MUTE_SHIFT                               8
+#define MADERA_IN1R_MUTE_WIDTH                               1
+#define MADERA_IN1R_DIG_VOL_MASK                        0x00FF
+#define MADERA_IN1R_DIG_VOL_SHIFT                            0
+#define MADERA_IN1R_DIG_VOL_WIDTH                            8
+
+/* (0x0317)  IN1R_Rate_Control */
+#define MADERA_IN1R_RATE_MASK                           0xF800
+#define MADERA_IN1R_RATE_SHIFT                              11
+#define MADERA_IN1R_RATE_WIDTH                               5
+
+/* (0x0318)  IN2L_Control */
+#define MADERA_IN2L_HPF_MASK                            0x8000
+#define MADERA_IN2L_HPF_SHIFT                               15
+#define MADERA_IN2L_HPF_WIDTH                                1
+#define MADERA_IN2_DMIC_SUP_MASK                        0x1800
+#define MADERA_IN2_DMIC_SUP_SHIFT                           11
+#define MADERA_IN2_DMIC_SUP_WIDTH                            2
+#define MADERA_IN2_MODE_MASK                            0x0400
+#define MADERA_IN2_MODE_SHIFT                               10
+#define MADERA_IN2_MODE_WIDTH                                1
+#define MADERA_IN2L_PGA_VOL_MASK                        0x00FE
+#define MADERA_IN2L_PGA_VOL_SHIFT                            1
+#define MADERA_IN2L_PGA_VOL_WIDTH                            7
+
+/* (0x0319)  ADC_Digital_Volume_2L */
+#define MADERA_IN2L_SRC_MASK                            0x4000
+#define MADERA_IN2L_SRC_SHIFT                               14
+#define MADERA_IN2L_SRC_WIDTH                                1
+#define MADERA_IN2L_SRC_SE_MASK                         0x2000
+#define MADERA_IN2L_SRC_SE_SHIFT                            13
+#define MADERA_IN2L_SRC_SE_WIDTH                             1
+#define MADERA_IN2L_LP_MODE                             0x0800
+#define MADERA_IN2L_LP_MODE_MASK                        0x0800
+#define MADERA_IN2L_LP_MODE_SHIFT                           11
+#define MADERA_IN2L_LP_MODE_WIDTH                            1
+#define MADERA_IN2L_MUTE                                0x0100
+#define MADERA_IN2L_MUTE_MASK                           0x0100
+#define MADERA_IN2L_MUTE_SHIFT                               8
+#define MADERA_IN2L_MUTE_WIDTH                               1
+#define MADERA_IN2L_DIG_VOL_MASK                        0x00FF
+#define MADERA_IN2L_DIG_VOL_SHIFT                            0
+#define MADERA_IN2L_DIG_VOL_WIDTH                            8
+
+/* (0x031A)  DMIC2L_Control */
+#define MADERA_IN2_OSR_MASK                             0x0700
+#define MADERA_IN2_OSR_SHIFT                                 8
+#define MADERA_IN2_OSR_WIDTH                                 3
+
+/* (0x031C)  IN2R_Control */
+#define MADERA_IN2R_HPF_MASK                            0x8000
+#define MADERA_IN2R_HPF_SHIFT                               15
+#define MADERA_IN2R_HPF_WIDTH                                1
+#define MADERA_IN2R_PGA_VOL_MASK                        0x00FE
+#define MADERA_IN2R_PGA_VOL_SHIFT                            1
+#define MADERA_IN2R_PGA_VOL_WIDTH                            7
+#define MADERA_IN2_DMICCLK_SRC_MASK                     0x1800
+#define MADERA_IN2_DMICCLK_SRC_SHIFT                        11
+#define MADERA_IN2_DMICCLK_SRC_WIDTH                         2
+
+/* (0x031D)  ADC_Digital_Volume_2R */
+#define MADERA_IN2R_SRC_MASK                            0x4000
+#define MADERA_IN2R_SRC_SHIFT                               14
+#define MADERA_IN2R_SRC_WIDTH                                1
+#define MADERA_IN2R_SRC_SE_MASK                         0x2000
+#define MADERA_IN2R_SRC_SE_SHIFT                            13
+#define MADERA_IN2R_SRC_SE_WIDTH                             1
+#define MADERA_IN2R_LP_MODE                             0x0800
+#define MADERA_IN2R_LP_MODE_MASK                        0x0800
+#define MADERA_IN2R_LP_MODE_SHIFT                           11
+#define MADERA_IN2R_LP_MODE_WIDTH                            1
+#define MADERA_IN2R_MUTE                                0x0100
+#define MADERA_IN2R_MUTE_MASK                           0x0100
+#define MADERA_IN2R_MUTE_SHIFT                               8
+#define MADERA_IN2R_MUTE_WIDTH                               1
+#define MADERA_IN2R_DIG_VOL_MASK                        0x00FF
+#define MADERA_IN2R_DIG_VOL_SHIFT                            0
+#define MADERA_IN2R_DIG_VOL_WIDTH                            8
+
+/* (0x0320)  IN3L_Control */
+#define MADERA_IN3L_HPF_MASK                            0x8000
+#define MADERA_IN3L_HPF_SHIFT                               15
+#define MADERA_IN3L_HPF_WIDTH                                1
+#define MADERA_IN3_DMIC_SUP_MASK                        0x1800
+#define MADERA_IN3_DMIC_SUP_SHIFT                           11
+#define MADERA_IN3_DMIC_SUP_WIDTH                            2
+#define MADERA_IN3_MODE_MASK                            0x0400
+#define MADERA_IN3_MODE_SHIFT                               10
+#define MADERA_IN3_MODE_WIDTH                                1
+#define MADERA_IN3L_PGA_VOL_MASK                        0x00FE
+#define MADERA_IN3L_PGA_VOL_SHIFT                            1
+#define MADERA_IN3L_PGA_VOL_WIDTH                            7
+
+/* (0x0321)  ADC_Digital_Volume_3L */
+#define MADERA_IN3L_MUTE                                0x0100
+#define MADERA_IN3L_MUTE_MASK                           0x0100
+#define MADERA_IN3L_MUTE_SHIFT                               8
+#define MADERA_IN3L_MUTE_WIDTH                               1
+#define MADERA_IN3L_DIG_VOL_MASK                        0x00FF
+#define MADERA_IN3L_DIG_VOL_SHIFT                            0
+#define MADERA_IN3L_DIG_VOL_WIDTH                            8
+
+/* (0x0322)  DMIC3L_Control */
+#define MADERA_IN3_OSR_MASK                             0x0700
+#define MADERA_IN3_OSR_SHIFT                                 8
+#define MADERA_IN3_OSR_WIDTH                                 3
+
+/* (0x0324)  IN3R_Control */
+#define MADERA_IN3R_HPF_MASK                            0x8000
+#define MADERA_IN3R_HPF_SHIFT                               15
+#define MADERA_IN3R_HPF_WIDTH                                1
+#define MADERA_IN3R_PGA_VOL_MASK                        0x00FE
+#define MADERA_IN3R_PGA_VOL_SHIFT                            1
+#define MADERA_IN3R_PGA_VOL_WIDTH                            7
+#define MADERA_IN3_DMICCLK_SRC_MASK                     0x1800
+#define MADERA_IN3_DMICCLK_SRC_SHIFT                        11
+#define MADERA_IN3_DMICCLK_SRC_WIDTH                         2
+
+/* (0x0325)  ADC_Digital_Volume_3R */
+#define MADERA_IN3R_MUTE                                0x0100
+#define MADERA_IN3R_MUTE_MASK                           0x0100
+#define MADERA_IN3R_MUTE_SHIFT                               8
+#define MADERA_IN3R_MUTE_WIDTH                               1
+#define MADERA_IN3R_DIG_VOL_MASK                        0x00FF
+#define MADERA_IN3R_DIG_VOL_SHIFT                            0
+#define MADERA_IN3R_DIG_VOL_WIDTH                            8
+
+/* (0x0328)  IN4L_Control */
+#define MADERA_IN4L_HPF_MASK                            0x8000
+#define MADERA_IN4L_HPF_SHIFT                               15
+#define MADERA_IN4L_HPF_WIDTH                                1
+#define MADERA_IN4_DMIC_SUP_MASK                        0x1800
+#define MADERA_IN4_DMIC_SUP_SHIFT                           11
+#define MADERA_IN4_DMIC_SUP_WIDTH                            2
+
+/* (0x0329)  ADC_Digital_Volume_4L */
+#define MADERA_IN4L_MUTE                                0x0100
+#define MADERA_IN4L_MUTE_MASK                           0x0100
+#define MADERA_IN4L_MUTE_SHIFT                               8
+#define MADERA_IN4L_MUTE_WIDTH                               1
+#define MADERA_IN4L_DIG_VOL_MASK                        0x00FF
+#define MADERA_IN4L_DIG_VOL_SHIFT                            0
+#define MADERA_IN4L_DIG_VOL_WIDTH                            8
+
+/* (0x032A)  DMIC4L_Control */
+#define MADERA_IN4_OSR_MASK                             0x0700
+#define MADERA_IN4_OSR_SHIFT                                 8
+#define MADERA_IN4_OSR_WIDTH                                 3
+
+/* (0x032C)  IN4R_Control */
+#define MADERA_IN4R_HPF_MASK                            0x8000
+#define MADERA_IN4R_HPF_SHIFT                               15
+#define MADERA_IN4R_HPF_WIDTH                                1
+#define MADERA_IN4_DMICCLK_SRC_MASK                     0x1800
+#define MADERA_IN4_DMICCLK_SRC_SHIFT                        11
+#define MADERA_IN4_DMICCLK_SRC_WIDTH                         2
+
+/* (0x032D)  ADC_Digital_Volume_4R */
+#define MADERA_IN4R_MUTE                                0x0100
+#define MADERA_IN4R_MUTE_MASK                           0x0100
+#define MADERA_IN4R_MUTE_SHIFT                               8
+#define MADERA_IN4R_MUTE_WIDTH                               1
+#define MADERA_IN4R_DIG_VOL_MASK                        0x00FF
+#define MADERA_IN4R_DIG_VOL_SHIFT                            0
+#define MADERA_IN4R_DIG_VOL_WIDTH                            8
+
+/* (0x0330)  IN5L_Control */
+#define MADERA_IN5L_HPF_MASK                            0x8000
+#define MADERA_IN5L_HPF_SHIFT                               15
+#define MADERA_IN5L_HPF_WIDTH                                1
+#define MADERA_IN5_DMIC_SUP_MASK                        0x1800
+#define MADERA_IN5_DMIC_SUP_SHIFT                           11
+#define MADERA_IN5_DMIC_SUP_WIDTH                            2
+
+/* (0x0331)  ADC_Digital_Volume_5L */
+#define MADERA_IN5L_MUTE                                0x0100
+#define MADERA_IN5L_MUTE_MASK                           0x0100
+#define MADERA_IN5L_MUTE_SHIFT                               8
+#define MADERA_IN5L_MUTE_WIDTH                               1
+#define MADERA_IN5L_DIG_VOL_MASK                        0x00FF
+#define MADERA_IN5L_DIG_VOL_SHIFT                            0
+#define MADERA_IN5L_DIG_VOL_WIDTH                            8
+
+/* (0x0332)  DMIC5L_Control */
+#define MADERA_IN5_OSR_MASK                             0x0700
+#define MADERA_IN5_OSR_SHIFT                                 8
+#define MADERA_IN5_OSR_WIDTH                                 3
+
+/* (0x0334)  IN5R_Control */
+#define MADERA_IN5R_HPF_MASK                            0x8000
+#define MADERA_IN5R_HPF_SHIFT                               15
+#define MADERA_IN5R_HPF_WIDTH                                1
+#define MADERA_IN5_DMICCLK_SRC_MASK                     0x1800
+#define MADERA_IN5_DMICCLK_SRC_SHIFT                        11
+#define MADERA_IN5_DMICCLK_SRC_WIDTH                         2
+
+/* (0x0335)  ADC_Digital_Volume_5R */
+#define MADERA_IN5R_MUTE                                0x0100
+#define MADERA_IN5R_MUTE_MASK                           0x0100
+#define MADERA_IN5R_MUTE_SHIFT                               8
+#define MADERA_IN5R_MUTE_WIDTH                               1
+#define MADERA_IN5R_DIG_VOL_MASK                        0x00FF
+#define MADERA_IN5R_DIG_VOL_SHIFT                            0
+#define MADERA_IN5R_DIG_VOL_WIDTH                            8
+
+/* (0x0338)  IN6L_Control */
+#define MADERA_IN6L_HPF_MASK                            0x8000
+#define MADERA_IN6L_HPF_SHIFT                               15
+#define MADERA_IN6L_HPF_WIDTH                                1
+#define MADERA_IN6_DMIC_SUP_MASK                        0x1800
+#define MADERA_IN6_DMIC_SUP_SHIFT                           11
+#define MADERA_IN6_DMIC_SUP_WIDTH                            2
+
+/* (0x0339)  ADC_Digital_Volume_6L */
+#define MADERA_IN6L_MUTE                                0x0100
+#define MADERA_IN6L_MUTE_MASK                           0x0100
+#define MADERA_IN6L_MUTE_SHIFT                               8
+#define MADERA_IN6L_MUTE_WIDTH                               1
+#define MADERA_IN6L_DIG_VOL_MASK                        0x00FF
+#define MADERA_IN6L_DIG_VOL_SHIFT                            0
+#define MADERA_IN6L_DIG_VOL_WIDTH                            8
+
+/* (0x033A)  DMIC6L_Control */
+#define MADERA_IN6_OSR_MASK                             0x0700
+#define MADERA_IN6_OSR_SHIFT                                 8
+#define MADERA_IN6_OSR_WIDTH                                 3
+
+/* (0x033C)  IN6R_Control */
+#define MADERA_IN6R_HPF_MASK                            0x8000
+#define MADERA_IN6R_HPF_SHIFT                               15
+#define MADERA_IN6R_HPF_WIDTH                                1
+
+/* (0x033D)  ADC_Digital_Volume_6R */
+#define MADERA_IN6R_MUTE                                0x0100
+#define MADERA_IN6R_MUTE_MASK                           0x0100
+#define MADERA_IN6R_MUTE_SHIFT                               8
+#define MADERA_IN6R_MUTE_WIDTH                               1
+#define MADERA_IN6R_DIG_VOL_MASK                        0x00FF
+#define MADERA_IN6R_DIG_VOL_SHIFT                            0
+#define MADERA_IN6R_DIG_VOL_WIDTH                            8
+
+/* (0x033E)  DMIC6R_Control */
+#define MADERA_IN6_DMICCLK_SRC_MASK                     0x1800
+#define MADERA_IN6_DMICCLK_SRC_SHIFT                        11
+#define MADERA_IN6_DMICCLK_SRC_WIDTH                         2
+
+/* (0x0400)  Output_Enables_1 */
+#define MADERA_EP_SEL                                   0x8000
+#define MADERA_EP_SEL_MASK                              0x8000
+#define MADERA_EP_SEL_SHIFT                                 15
+#define MADERA_EP_SEL_WIDTH                                  1
+#define MADERA_OUT6L_ENA                                0x0800
+#define MADERA_OUT6L_ENA_MASK                           0x0800
+#define MADERA_OUT6L_ENA_SHIFT                              11
+#define MADERA_OUT6L_ENA_WIDTH                               1
+#define MADERA_OUT6R_ENA                                0x0400
+#define MADERA_OUT6R_ENA_MASK                           0x0400
+#define MADERA_OUT6R_ENA_SHIFT                              10
+#define MADERA_OUT6R_ENA_WIDTH                               1
+#define MADERA_OUT5L_ENA                                0x0200
+#define MADERA_OUT5L_ENA_MASK                           0x0200
+#define MADERA_OUT5L_ENA_SHIFT                               9
+#define MADERA_OUT5L_ENA_WIDTH                               1
+#define MADERA_OUT5R_ENA                                0x0100
+#define MADERA_OUT5R_ENA_MASK                           0x0100
+#define MADERA_OUT5R_ENA_SHIFT                               8
+#define MADERA_OUT5R_ENA_WIDTH                               1
+#define MADERA_OUT4L_ENA                                0x0080
+#define MADERA_OUT4L_ENA_MASK                           0x0080
+#define MADERA_OUT4L_ENA_SHIFT                               7
+#define MADERA_OUT4L_ENA_WIDTH                               1
+#define MADERA_OUT4R_ENA                                0x0040
+#define MADERA_OUT4R_ENA_MASK                           0x0040
+#define MADERA_OUT4R_ENA_SHIFT                               6
+#define MADERA_OUT4R_ENA_WIDTH                               1
+#define MADERA_OUT3L_ENA                                0x0020
+#define MADERA_OUT3L_ENA_MASK                           0x0020
+#define MADERA_OUT3L_ENA_SHIFT                               5
+#define MADERA_OUT3L_ENA_WIDTH                               1
+#define MADERA_OUT3R_ENA                                0x0010
+#define MADERA_OUT3R_ENA_MASK                           0x0010
+#define MADERA_OUT3R_ENA_SHIFT                               4
+#define MADERA_OUT3R_ENA_WIDTH                               1
+#define MADERA_OUT2L_ENA                                0x0008
+#define MADERA_OUT2L_ENA_MASK                           0x0008
+#define MADERA_OUT2L_ENA_SHIFT                               3
+#define MADERA_OUT2L_ENA_WIDTH                               1
+#define MADERA_OUT2R_ENA                                0x0004
+#define MADERA_OUT2R_ENA_MASK                           0x0004
+#define MADERA_OUT2R_ENA_SHIFT                               2
+#define MADERA_OUT2R_ENA_WIDTH                               1
+#define MADERA_OUT1L_ENA                                0x0002
+#define MADERA_OUT1L_ENA_MASK                           0x0002
+#define MADERA_OUT1L_ENA_SHIFT                               1
+#define MADERA_OUT1L_ENA_WIDTH                               1
+#define MADERA_OUT1R_ENA                                0x0001
+#define MADERA_OUT1R_ENA_MASK                           0x0001
+#define MADERA_OUT1R_ENA_SHIFT                               0
+#define MADERA_OUT1R_ENA_WIDTH                               1
+
+/* (0x0409)  Output_Volume_Ramp */
+#define MADERA_OUT_VD_RAMP_MASK                         0x0070
+#define MADERA_OUT_VD_RAMP_SHIFT                             4
+#define MADERA_OUT_VD_RAMP_WIDTH                             3
+#define MADERA_OUT_VI_RAMP_MASK                         0x0007
+#define MADERA_OUT_VI_RAMP_SHIFT                             0
+#define MADERA_OUT_VI_RAMP_WIDTH                             3
+
+/* (0x0410)  Output_Path_Config_1L */
+#define MADERA_OUT1_MONO                                0x1000
+#define MADERA_OUT1_MONO_MASK                           0x1000
+#define MADERA_OUT1_MONO_SHIFT                              12
+#define MADERA_OUT1_MONO_WIDTH                               1
+#define MADERA_OUT1L_ANC_SRC_MASK                       0x0C00
+#define MADERA_OUT1L_ANC_SRC_SHIFT                          10
+#define MADERA_OUT1L_ANC_SRC_WIDTH                           2
+
+/* (0x0411)  DAC_Digital_Volume_1L */
+#define MADERA_OUT1L_VU                                 0x0200
+#define MADERA_OUT1L_VU_MASK                            0x0200
+#define MADERA_OUT1L_VU_SHIFT                                9
+#define MADERA_OUT1L_VU_WIDTH                                1
+#define MADERA_OUT1L_MUTE                               0x0100
+#define MADERA_OUT1L_MUTE_MASK                          0x0100
+#define MADERA_OUT1L_MUTE_SHIFT                              8
+#define MADERA_OUT1L_MUTE_WIDTH                              1
+#define MADERA_OUT1L_VOL_MASK                           0x00FF
+#define MADERA_OUT1L_VOL_SHIFT                               0
+#define MADERA_OUT1L_VOL_WIDTH                               8
+
+/* (0x0412)  Output_Path_Config_1 */
+#define MADERA_HP1_GND_SEL_MASK                         0x0007
+#define MADERA_HP1_GND_SEL_SHIFT                             0
+#define MADERA_HP1_GND_SEL_WIDTH                             3
+
+/* (0x0414)  Output_Path_Config_1R */
+#define MADERA_OUT1R_ANC_SRC_MASK                       0x0C00
+#define MADERA_OUT1R_ANC_SRC_SHIFT                          10
+#define MADERA_OUT1R_ANC_SRC_WIDTH                           2
+
+/* (0x0415)  DAC_Digital_Volume_1R */
+#define MADERA_OUT1R_MUTE                               0x0100
+#define MADERA_OUT1R_MUTE_MASK                          0x0100
+#define MADERA_OUT1R_MUTE_SHIFT                              8
+#define MADERA_OUT1R_MUTE_WIDTH                              1
+#define MADERA_OUT1R_VOL_MASK                           0x00FF
+#define MADERA_OUT1R_VOL_SHIFT                               0
+#define MADERA_OUT1R_VOL_WIDTH                               8
+
+/* (0x0418)  Output_Path_Config_2L */
+#define MADERA_OUT2L_ANC_SRC_MASK                       0x0C00
+#define MADERA_OUT2L_ANC_SRC_SHIFT                          10
+#define MADERA_OUT2L_ANC_SRC_WIDTH                           2
+
+/* (0x0419)  DAC_Digital_Volume_2L */
+#define MADERA_OUT2L_MUTE                               0x0100
+#define MADERA_OUT2L_MUTE_MASK                          0x0100
+#define MADERA_OUT2L_MUTE_SHIFT                              8
+#define MADERA_OUT2L_MUTE_WIDTH                              1
+#define MADERA_OUT2L_VOL_MASK                           0x00FF
+#define MADERA_OUT2L_VOL_SHIFT                               0
+#define MADERA_OUT2L_VOL_WIDTH                               8
+
+/* (0x041A)  Output_Path_Config_2 */
+#define MADERA_HP2_GND_SEL_MASK                         0x0007
+#define MADERA_HP2_GND_SEL_SHIFT                             0
+#define MADERA_HP2_GND_SEL_WIDTH                             3
+
+/* (0x041C)  Output_Path_Config_2R */
+#define MADERA_OUT2R_ANC_SRC_MASK                       0x0C00
+#define MADERA_OUT2R_ANC_SRC_SHIFT                          10
+#define MADERA_OUT2R_ANC_SRC_WIDTH                           2
+
+/* (0x041D)  DAC_Digital_Volume_2R */
+#define MADERA_OUT2R_MUTE                               0x0100
+#define MADERA_OUT2R_MUTE_MASK                          0x0100
+#define MADERA_OUT2R_MUTE_SHIFT                              8
+#define MADERA_OUT2R_MUTE_WIDTH                              1
+#define MADERA_OUT2R_VOL_MASK                           0x00FF
+#define MADERA_OUT2R_VOL_SHIFT                               0
+#define MADERA_OUT2R_VOL_WIDTH                               8
+
+/* (0x0420)  Output_Path_Config_3L */
+#define MADERA_OUT3L_ANC_SRC_MASK                       0x0C00
+#define MADERA_OUT3L_ANC_SRC_SHIFT                          10
+#define MADERA_OUT3L_ANC_SRC_WIDTH                           2
+
+/* (0x0421)  DAC_Digital_Volume_3L */
+#define MADERA_OUT3L_MUTE                               0x0100
+#define MADERA_OUT3L_MUTE_MASK                          0x0100
+#define MADERA_OUT3L_MUTE_SHIFT                              8
+#define MADERA_OUT3L_MUTE_WIDTH                              1
+#define MADERA_OUT3L_VOL_MASK                           0x00FF
+#define MADERA_OUT3L_VOL_SHIFT                               0
+#define MADERA_OUT3L_VOL_WIDTH                               8
+
+/* (0x0424)  Output_Path_Config_3R */
+#define MADERA_OUT3R_ANC_SRC_MASK                       0x0C00
+#define MADERA_OUT3R_ANC_SRC_SHIFT                          10
+#define MADERA_OUT3R_ANC_SRC_WIDTH                           2
+
+/* (0x0425)  DAC_Digital_Volume_3R */
+#define MADERA_OUT3R_MUTE                               0x0100
+#define MADERA_OUT3R_MUTE_MASK                          0x0100
+#define MADERA_OUT3R_MUTE_SHIFT                              8
+#define MADERA_OUT3R_MUTE_WIDTH                              1
+#define MADERA_OUT3R_VOL_MASK                           0x00FF
+#define MADERA_OUT3R_VOL_SHIFT                               0
+#define MADERA_OUT3R_VOL_WIDTH                               8
+
+/* (0x0428)  Output_Path_Config_4L */
+#define MADERA_OUT4L_ANC_SRC_MASK                       0x0C00
+#define MADERA_OUT4L_ANC_SRC_SHIFT                          10
+#define MADERA_OUT4L_ANC_SRC_WIDTH                           2
+
+/* (0x0429)  DAC_Digital_Volume_4L */
+#define MADERA_OUT4L_MUTE                               0x0100
+#define MADERA_OUT4L_MUTE_MASK                          0x0100
+#define MADERA_OUT4L_MUTE_SHIFT                              8
+#define MADERA_OUT4L_MUTE_WIDTH                              1
+#define MADERA_OUT4L_VOL_MASK                           0x00FF
+#define MADERA_OUT4L_VOL_SHIFT                               0
+#define MADERA_OUT4L_VOL_WIDTH                               8
+
+/* (0x042C)  Output_Path_Config_4R */
+#define MADERA_OUT4R_ANC_SRC_MASK                       0x0C00
+#define MADERA_OUT4R_ANC_SRC_SHIFT                          10
+#define MADERA_OUT4R_ANC_SRC_WIDTH                           2
+
+/* (0x042D)  DAC_Digital_Volume_4R */
+#define MADERA_OUT4R_MUTE                               0x0100
+#define MADERA_OUT4R_MUTE_MASK                          0x0100
+#define MADERA_OUT4R_MUTE_SHIFT                              8
+#define MADERA_OUT4R_MUTE_WIDTH                              1
+#define MADERA_OUT4R_VOL_MASK                           0x00FF
+#define MADERA_OUT4R_VOL_SHIFT                               0
+#define MADERA_OUT4R_VOL_WIDTH                               8
+
+/* (0x0430)  Output_Path_Config_5L */
+#define MADERA_OUT5_OSR                                 0x2000
+#define MADERA_OUT5_OSR_MASK                            0x2000
+#define MADERA_OUT5_OSR_SHIFT                               13
+#define MADERA_OUT5_OSR_WIDTH                                1
+#define MADERA_OUT5L_ANC_SRC_MASK                       0x0C00
+#define MADERA_OUT5L_ANC_SRC_SHIFT                          10
+#define MADERA_OUT5L_ANC_SRC_WIDTH                           2
+
+/* (0x0431)  DAC_Digital_Volume_5L */
+#define MADERA_OUT5L_MUTE                               0x0100
+#define MADERA_OUT5L_MUTE_MASK                          0x0100
+#define MADERA_OUT5L_MUTE_SHIFT                              8
+#define MADERA_OUT5L_MUTE_WIDTH                              1
+#define MADERA_OUT5L_VOL_MASK                           0x00FF
+#define MADERA_OUT5L_VOL_SHIFT                               0
+#define MADERA_OUT5L_VOL_WIDTH                               8
+
+/* (0x0434)  Output_Path_Config_5R */
+#define MADERA_OUT5R_ANC_SRC_MASK                       0x0C00
+#define MADERA_OUT5R_ANC_SRC_SHIFT                          10
+#define MADERA_OUT5R_ANC_SRC_WIDTH                           2
+
+/* (0x0435)  DAC_Digital_Volume_5R */
+#define MADERA_OUT5R_MUTE                               0x0100
+#define MADERA_OUT5R_MUTE_MASK                          0x0100
+#define MADERA_OUT5R_MUTE_SHIFT                              8
+#define MADERA_OUT5R_MUTE_WIDTH                              1
+#define MADERA_OUT5R_VOL_MASK                           0x00FF
+#define MADERA_OUT5R_VOL_SHIFT                               0
+#define MADERA_OUT5R_VOL_WIDTH                               8
+
+/* (0x0438)  Output_Path_Config_6L */
+#define MADERA_OUT6_OSR                                 0x2000
+#define MADERA_OUT6_OSR_MASK                            0x2000
+#define MADERA_OUT6_OSR_SHIFT                               13
+#define MADERA_OUT6_OSR_WIDTH                                1
+#define MADERA_OUT6L_ANC_SRC_MASK                       0x0C00
+#define MADERA_OUT6L_ANC_SRC_SHIFT                          10
+#define MADERA_OUT6L_ANC_SRC_WIDTH                           2
+
+/* (0x0439)  DAC_Digital_Volume_6L */
+#define MADERA_OUT6L_MUTE                               0x0100
+#define MADERA_OUT6L_MUTE_MASK                          0x0100
+#define MADERA_OUT6L_MUTE_SHIFT                              8
+#define MADERA_OUT6L_MUTE_WIDTH                              1
+#define MADERA_OUT6L_VOL_MASK                           0x00FF
+#define MADERA_OUT6L_VOL_SHIFT                               0
+#define MADERA_OUT6L_VOL_WIDTH                               8
+
+/* (0x043C)  Output_Path_Config_6R */
+#define MADERA_OUT6R_ANC_SRC_MASK                       0x0C00
+#define MADERA_OUT6R_ANC_SRC_SHIFT                          10
+#define MADERA_OUT6R_ANC_SRC_WIDTH                           2
+
+/* (0x043D)  DAC_Digital_Volume_6R */
+#define MADERA_OUT6R_MUTE                               0x0100
+#define MADERA_OUT6R_MUTE_MASK                          0x0100
+#define MADERA_OUT6R_MUTE_SHIFT                              8
+#define MADERA_OUT6R_MUTE_WIDTH                              1
+#define MADERA_OUT6R_VOL_MASK                           0x00FF
+#define MADERA_OUT6R_VOL_SHIFT                               0
+#define MADERA_OUT6R_VOL_WIDTH                               8
+
+/* (0x0450) - DAC AEC Control 1 */
+#define MADERA_AEC1_LOOPBACK_SRC_MASK                   0x003C
+#define MADERA_AEC1_LOOPBACK_SRC_SHIFT                       2
+#define MADERA_AEC1_LOOPBACK_SRC_WIDTH                       4
+#define MADERA_AEC1_ENA_STS                             0x0002
+#define MADERA_AEC1_ENA_STS_MASK                        0x0002
+#define MADERA_AEC1_ENA_STS_SHIFT                            1
+#define MADERA_AEC1_ENA_STS_WIDTH                            1
+#define MADERA_AEC1_LOOPBACK_ENA                        0x0001
+#define MADERA_AEC1_LOOPBACK_ENA_MASK                   0x0001
+#define MADERA_AEC1_LOOPBACK_ENA_SHIFT                       0
+#define MADERA_AEC1_LOOPBACK_ENA_WIDTH                       1
+
+/* (0x0451)  DAC_AEC_Control_2 */
+#define MADERA_AEC2_LOOPBACK_SRC_MASK                   0x003C
+#define MADERA_AEC2_LOOPBACK_SRC_SHIFT                       2
+#define MADERA_AEC2_LOOPBACK_SRC_WIDTH                       4
+#define MADERA_AEC2_ENA_STS                             0x0002
+#define MADERA_AEC2_ENA_STS_MASK                        0x0002
+#define MADERA_AEC2_ENA_STS_SHIFT                            1
+#define MADERA_AEC2_ENA_STS_WIDTH                            1
+#define MADERA_AEC2_LOOPBACK_ENA                        0x0001
+#define MADERA_AEC2_LOOPBACK_ENA_MASK                   0x0001
+#define MADERA_AEC2_LOOPBACK_ENA_SHIFT                       0
+#define MADERA_AEC2_LOOPBACK_ENA_WIDTH                       1
+
+/* (0x0458)  Noise_Gate_Control */
+#define MADERA_NGATE_HOLD_MASK                          0x0030
+#define MADERA_NGATE_HOLD_SHIFT                              4
+#define MADERA_NGATE_HOLD_WIDTH                              2
+#define MADERA_NGATE_THR_MASK                           0x000E
+#define MADERA_NGATE_THR_SHIFT                               1
+#define MADERA_NGATE_THR_WIDTH                               3
+#define MADERA_NGATE_ENA                                0x0001
+#define MADERA_NGATE_ENA_MASK                           0x0001
+#define MADERA_NGATE_ENA_SHIFT                               0
+#define MADERA_NGATE_ENA_WIDTH                               1
+
+/* (0x0490)  PDM_SPK1_CTRL_1 */
+#define MADERA_SPK1R_MUTE                               0x2000
+#define MADERA_SPK1R_MUTE_MASK                          0x2000
+#define MADERA_SPK1R_MUTE_SHIFT                             13
+#define MADERA_SPK1R_MUTE_WIDTH                              1
+#define MADERA_SPK1L_MUTE                               0x1000
+#define MADERA_SPK1L_MUTE_MASK                          0x1000
+#define MADERA_SPK1L_MUTE_SHIFT                             12
+#define MADERA_SPK1L_MUTE_WIDTH                              1
+#define MADERA_SPK1_MUTE_ENDIAN                         0x0100
+#define MADERA_SPK1_MUTE_ENDIAN_MASK                    0x0100
+#define MADERA_SPK1_MUTE_ENDIAN_SHIFT                        8
+#define MADERA_SPK1_MUTE_ENDIAN_WIDTH                        1
+#define MADERA_SPK1_MUTE_SEQ1_MASK                      0x00FF
+#define MADERA_SPK1_MUTE_SEQ1_SHIFT                          0
+#define MADERA_SPK1_MUTE_SEQ1_WIDTH                          8
+
+/* (0x0491)  PDM_SPK1_CTRL_2 */
+#define MADERA_SPK1_FMT                                 0x0001
+#define MADERA_SPK1_FMT_MASK                            0x0001
+#define MADERA_SPK1_FMT_SHIFT                                0
+#define MADERA_SPK1_FMT_WIDTH                                1
+
+/* (0x0492)  PDM_SPK2_CTRL_1 */
+#define MADERA_SPK2R_MUTE                               0x2000
+#define MADERA_SPK2R_MUTE_MASK                          0x2000
+#define MADERA_SPK2R_MUTE_SHIFT                             13
+#define MADERA_SPK2R_MUTE_WIDTH                              1
+#define MADERA_SPK2L_MUTE                               0x1000
+#define MADERA_SPK2L_MUTE_MASK                          0x1000
+#define MADERA_SPK2L_MUTE_SHIFT                             12
+#define MADERA_SPK2L_MUTE_WIDTH                              1
+
+/* (0x04A0) - HP1 Short Circuit Ctrl */
+#define MADERA_HP1_SC_ENA                               0x1000
+#define MADERA_HP1_SC_ENA_MASK                          0x1000
+#define MADERA_HP1_SC_ENA_SHIFT                             12
+#define MADERA_HP1_SC_ENA_WIDTH                              1
+
+/* (0x04A1) - HP2 Short Circuit Ctrl */
+#define MADERA_HP2_SC_ENA                               0x1000
+#define MADERA_HP2_SC_ENA_MASK                          0x1000
+#define MADERA_HP2_SC_ENA_SHIFT                             12
+#define MADERA_HP2_SC_ENA_WIDTH                              1
+
+/* (0x04A2) - HP3 Short Circuit Ctrl */
+#define MADERA_HP3_SC_ENA                               0x1000
+#define MADERA_HP3_SC_ENA_MASK                          0x1000
+#define MADERA_HP3_SC_ENA_SHIFT                             12
+#define MADERA_HP3_SC_ENA_WIDTH                              1
+
+/* (0x04A8) - HP_Test_Ctrl_5 */
+#define MADERA_HP1L_ONEFLT                              0x0100
+#define MADERA_HP1L_ONEFLT_MASK                         0x0100
+#define MADERA_HP1L_ONEFLT_SHIFT                             8
+#define MADERA_HP1L_ONEFLT_WIDTH                             1
+
+/* (0x04A9) - HP_Test_Ctrl_6 */
+#define MADERA_HP1R_ONEFLT                              0x0100
+#define MADERA_HP1R_ONEFLT_MASK                         0x0100
+#define MADERA_HP1R_ONEFLT_SHIFT                             8
+#define MADERA_HP1R_ONEFLT_WIDTH                             1
+
+/* (0x0500)  AIF1_BCLK_Ctrl */
+#define MADERA_AIF1_BCLK_INV                            0x0080
+#define MADERA_AIF1_BCLK_INV_MASK                       0x0080
+#define MADERA_AIF1_BCLK_INV_SHIFT                           7
+#define MADERA_AIF1_BCLK_INV_WIDTH                           1
+#define MADERA_AIF1_BCLK_MSTR                           0x0020
+#define MADERA_AIF1_BCLK_MSTR_MASK                      0x0020
+#define MADERA_AIF1_BCLK_MSTR_SHIFT                          5
+#define MADERA_AIF1_BCLK_MSTR_WIDTH                          1
+#define MADERA_AIF1_BCLK_FREQ_MASK                      0x001F
+#define MADERA_AIF1_BCLK_FREQ_SHIFT                          0
+#define MADERA_AIF1_BCLK_FREQ_WIDTH                          5
+
+/* (0x0501)  AIF1_Tx_Pin_Ctrl */
+#define MADERA_AIF1TX_LRCLK_SRC                         0x0008
+#define MADERA_AIF1TX_LRCLK_SRC_MASK                    0x0008
+#define MADERA_AIF1TX_LRCLK_SRC_SHIFT                        3
+#define MADERA_AIF1TX_LRCLK_SRC_WIDTH                        1
+#define MADERA_AIF1TX_LRCLK_INV                         0x0004
+#define MADERA_AIF1TX_LRCLK_INV_MASK                    0x0004
+#define MADERA_AIF1TX_LRCLK_INV_SHIFT                        2
+#define MADERA_AIF1TX_LRCLK_INV_WIDTH                        1
+#define MADERA_AIF1TX_LRCLK_MSTR                        0x0001
+#define MADERA_AIF1TX_LRCLK_MSTR_MASK                   0x0001
+#define MADERA_AIF1TX_LRCLK_MSTR_SHIFT                       0
+#define MADERA_AIF1TX_LRCLK_MSTR_WIDTH                       1
+
+/* (0x0502)  AIF1_Rx_Pin_Ctrl */
+#define MADERA_AIF1RX_LRCLK_INV                         0x0004
+#define MADERA_AIF1RX_LRCLK_INV_MASK                    0x0004
+#define MADERA_AIF1RX_LRCLK_INV_SHIFT                        2
+#define MADERA_AIF1RX_LRCLK_INV_WIDTH                        1
+#define MADERA_AIF1RX_LRCLK_FRC                         0x0002
+#define MADERA_AIF1RX_LRCLK_FRC_MASK                    0x0002
+#define MADERA_AIF1RX_LRCLK_FRC_SHIFT                        1
+#define MADERA_AIF1RX_LRCLK_FRC_WIDTH                        1
+#define MADERA_AIF1RX_LRCLK_MSTR                        0x0001
+#define MADERA_AIF1RX_LRCLK_MSTR_MASK                   0x0001
+#define MADERA_AIF1RX_LRCLK_MSTR_SHIFT                       0
+#define MADERA_AIF1RX_LRCLK_MSTR_WIDTH                       1
+
+/* (0x0503)  AIF1_Rate_Ctrl */
+#define MADERA_AIF1_RATE_MASK                           0xF800
+#define MADERA_AIF1_RATE_SHIFT                              11
+#define MADERA_AIF1_RATE_WIDTH                               5
+#define MADERA_AIF1_TRI                                 0x0040
+#define MADERA_AIF1_TRI_MASK                            0x0040
+#define MADERA_AIF1_TRI_SHIFT                                6
+#define MADERA_AIF1_TRI_WIDTH                                1
+
+/* (0x0504)  AIF1_Format */
+#define MADERA_AIF1_FMT_MASK                            0x0007
+#define MADERA_AIF1_FMT_SHIFT                                0
+#define MADERA_AIF1_FMT_WIDTH                                3
+
+/* (0x0506)  AIF1_Rx_BCLK_Rate */
+#define MADERA_AIF1RX_BCPF_MASK                         0x1FFF
+#define MADERA_AIF1RX_BCPF_SHIFT                             0
+#define MADERA_AIF1RX_BCPF_WIDTH                            13
+
+/* (0x0507)  AIF1_Frame_Ctrl_1 */
+#define MADERA_AIF1TX_WL_MASK                           0x3F00
+#define MADERA_AIF1TX_WL_SHIFT                               8
+#define MADERA_AIF1TX_WL_WIDTH                               6
+#define MADERA_AIF1TX_SLOT_LEN_MASK                     0x00FF
+#define MADERA_AIF1TX_SLOT_LEN_SHIFT                         0
+#define MADERA_AIF1TX_SLOT_LEN_WIDTH                         8
+
+/* (0x0508)  AIF1_Frame_Ctrl_2 */
+#define MADERA_AIF1RX_WL_MASK                           0x3F00
+#define MADERA_AIF1RX_WL_SHIFT                               8
+#define MADERA_AIF1RX_WL_WIDTH                               6
+#define MADERA_AIF1RX_SLOT_LEN_MASK                     0x00FF
+#define MADERA_AIF1RX_SLOT_LEN_SHIFT                         0
+#define MADERA_AIF1RX_SLOT_LEN_WIDTH                         8
+
+/* (0x0509)  AIF1_Frame_Ctrl_3 */
+#define MADERA_AIF1TX1_SLOT_MASK                        0x003F
+#define MADERA_AIF1TX1_SLOT_SHIFT                            0
+#define MADERA_AIF1TX1_SLOT_WIDTH                            6
+
+/* (0x0519)  AIF1_Tx_Enables */
+#define MADERA_AIF1TX8_ENA                              0x0080
+#define MADERA_AIF1TX8_ENA_MASK                         0x0080
+#define MADERA_AIF1TX8_ENA_SHIFT                             7
+#define MADERA_AIF1TX8_ENA_WIDTH                             1
+#define MADERA_AIF1TX7_ENA                              0x0040
+#define MADERA_AIF1TX7_ENA_MASK                         0x0040
+#define MADERA_AIF1TX7_ENA_SHIFT                             6
+#define MADERA_AIF1TX7_ENA_WIDTH                             1
+#define MADERA_AIF1TX6_ENA                              0x0020
+#define MADERA_AIF1TX6_ENA_MASK                         0x0020
+#define MADERA_AIF1TX6_ENA_SHIFT                             5
+#define MADERA_AIF1TX6_ENA_WIDTH                             1
+#define MADERA_AIF1TX5_ENA                              0x0010
+#define MADERA_AIF1TX5_ENA_MASK                         0x0010
+#define MADERA_AIF1TX5_ENA_SHIFT                             4
+#define MADERA_AIF1TX5_ENA_WIDTH                             1
+#define MADERA_AIF1TX4_ENA                              0x0008
+#define MADERA_AIF1TX4_ENA_MASK                         0x0008
+#define MADERA_AIF1TX4_ENA_SHIFT                             3
+#define MADERA_AIF1TX4_ENA_WIDTH                             1
+#define MADERA_AIF1TX3_ENA                              0x0004
+#define MADERA_AIF1TX3_ENA_MASK                         0x0004
+#define MADERA_AIF1TX3_ENA_SHIFT                             2
+#define MADERA_AIF1TX3_ENA_WIDTH                             1
+#define MADERA_AIF1TX2_ENA                              0x0002
+#define MADERA_AIF1TX2_ENA_MASK                         0x0002
+#define MADERA_AIF1TX2_ENA_SHIFT                             1
+#define MADERA_AIF1TX2_ENA_WIDTH                             1
+#define MADERA_AIF1TX1_ENA                              0x0001
+#define MADERA_AIF1TX1_ENA_MASK                         0x0001
+#define MADERA_AIF1TX1_ENA_SHIFT                             0
+#define MADERA_AIF1TX1_ENA_WIDTH                             1
+
+/* (0x051A)  AIF1_Rx_Enables */
+#define MADERA_AIF1RX8_ENA                              0x0080
+#define MADERA_AIF1RX8_ENA_MASK                         0x0080
+#define MADERA_AIF1RX8_ENA_SHIFT                             7
+#define MADERA_AIF1RX8_ENA_WIDTH                             1
+#define MADERA_AIF1RX7_ENA                              0x0040
+#define MADERA_AIF1RX7_ENA_MASK                         0x0040
+#define MADERA_AIF1RX7_ENA_SHIFT                             6
+#define MADERA_AIF1RX7_ENA_WIDTH                             1
+#define MADERA_AIF1RX6_ENA                              0x0020
+#define MADERA_AIF1RX6_ENA_MASK                         0x0020
+#define MADERA_AIF1RX6_ENA_SHIFT                             5
+#define MADERA_AIF1RX6_ENA_WIDTH                             1
+#define MADERA_AIF1RX5_ENA                              0x0010
+#define MADERA_AIF1RX5_ENA_MASK                         0x0010
+#define MADERA_AIF1RX5_ENA_SHIFT                             4
+#define MADERA_AIF1RX5_ENA_WIDTH                             1
+#define MADERA_AIF1RX4_ENA                              0x0008
+#define MADERA_AIF1RX4_ENA_MASK                         0x0008
+#define MADERA_AIF1RX4_ENA_SHIFT                             3
+#define MADERA_AIF1RX4_ENA_WIDTH                             1
+#define MADERA_AIF1RX3_ENA                              0x0004
+#define MADERA_AIF1RX3_ENA_MASK                         0x0004
+#define MADERA_AIF1RX3_ENA_SHIFT                             2
+#define MADERA_AIF1RX3_ENA_WIDTH                             1
+#define MADERA_AIF1RX2_ENA                              0x0002
+#define MADERA_AIF1RX2_ENA_MASK                         0x0002
+#define MADERA_AIF1RX2_ENA_SHIFT                             1
+#define MADERA_AIF1RX2_ENA_WIDTH                             1
+#define MADERA_AIF1RX1_ENA                              0x0001
+#define MADERA_AIF1RX1_ENA_MASK                         0x0001
+#define MADERA_AIF1RX1_ENA_SHIFT                             0
+#define MADERA_AIF1RX1_ENA_WIDTH                             1
+
+/* (0x0559)  AIF2_Tx_Enables */
+#define MADERA_AIF2TX8_ENA                              0x0080
+#define MADERA_AIF2TX8_ENA_MASK                         0x0080
+#define MADERA_AIF2TX8_ENA_SHIFT                             7
+#define MADERA_AIF2TX8_ENA_WIDTH                             1
+#define MADERA_AIF2TX7_ENA                              0x0040
+#define MADERA_AIF2TX7_ENA_MASK                         0x0040
+#define MADERA_AIF2TX7_ENA_SHIFT                             6
+#define MADERA_AIF2TX7_ENA_WIDTH                             1
+#define MADERA_AIF2TX6_ENA                              0x0020
+#define MADERA_AIF2TX6_ENA_MASK                         0x0020
+#define MADERA_AIF2TX6_ENA_SHIFT                             5
+#define MADERA_AIF2TX6_ENA_WIDTH                             1
+#define MADERA_AIF2TX5_ENA                              0x0010
+#define MADERA_AIF2TX5_ENA_MASK                         0x0010
+#define MADERA_AIF2TX5_ENA_SHIFT                             4
+#define MADERA_AIF2TX5_ENA_WIDTH                             1
+#define MADERA_AIF2TX4_ENA                              0x0008
+#define MADERA_AIF2TX4_ENA_MASK                         0x0008
+#define MADERA_AIF2TX4_ENA_SHIFT                             3
+#define MADERA_AIF2TX4_ENA_WIDTH                             1
+#define MADERA_AIF2TX3_ENA                              0x0004
+#define MADERA_AIF2TX3_ENA_MASK                         0x0004
+#define MADERA_AIF2TX3_ENA_SHIFT                             2
+#define MADERA_AIF2TX3_ENA_WIDTH                             1
+#define MADERA_AIF2TX2_ENA                              0x0002
+#define MADERA_AIF2TX2_ENA_MASK                         0x0002
+#define MADERA_AIF2TX2_ENA_SHIFT                             1
+#define MADERA_AIF2TX2_ENA_WIDTH                             1
+#define MADERA_AIF2TX1_ENA                              0x0001
+#define MADERA_AIF2TX1_ENA_MASK                         0x0001
+#define MADERA_AIF2TX1_ENA_SHIFT                             0
+#define MADERA_AIF2TX1_ENA_WIDTH                             1
+
+/* (0x055A)  AIF2_Rx_Enables */
+#define MADERA_AIF2RX8_ENA                              0x0080
+#define MADERA_AIF2RX8_ENA_MASK                         0x0080
+#define MADERA_AIF2RX8_ENA_SHIFT                             7
+#define MADERA_AIF2RX8_ENA_WIDTH                             1
+#define MADERA_AIF2RX7_ENA                              0x0040
+#define MADERA_AIF2RX7_ENA_MASK                         0x0040
+#define MADERA_AIF2RX7_ENA_SHIFT                             6
+#define MADERA_AIF2RX7_ENA_WIDTH                             1
+#define MADERA_AIF2RX6_ENA                              0x0020
+#define MADERA_AIF2RX6_ENA_MASK                         0x0020
+#define MADERA_AIF2RX6_ENA_SHIFT                             5
+#define MADERA_AIF2RX6_ENA_WIDTH                             1
+#define MADERA_AIF2RX5_ENA                              0x0010
+#define MADERA_AIF2RX5_ENA_MASK                         0x0010
+#define MADERA_AIF2RX5_ENA_SHIFT                             4
+#define MADERA_AIF2RX5_ENA_WIDTH                             1
+#define MADERA_AIF2RX4_ENA                              0x0008
+#define MADERA_AIF2RX4_ENA_MASK                         0x0008
+#define MADERA_AIF2RX4_ENA_SHIFT                             3
+#define MADERA_AIF2RX4_ENA_WIDTH                             1
+#define MADERA_AIF2RX3_ENA                              0x0004
+#define MADERA_AIF2RX3_ENA_MASK                         0x0004
+#define MADERA_AIF2RX3_ENA_SHIFT                             2
+#define MADERA_AIF2RX3_ENA_WIDTH                             1
+#define MADERA_AIF2RX2_ENA                              0x0002
+#define MADERA_AIF2RX2_ENA_MASK                         0x0002
+#define MADERA_AIF2RX2_ENA_SHIFT                             1
+#define MADERA_AIF2RX2_ENA_WIDTH                             1
+#define MADERA_AIF2RX1_ENA                              0x0001
+#define MADERA_AIF2RX1_ENA_MASK                         0x0001
+#define MADERA_AIF2RX1_ENA_SHIFT                             0
+#define MADERA_AIF2RX1_ENA_WIDTH                             1
+
+/* (0x0599)  AIF3_Tx_Enables */
+#define MADERA_AIF3TX2_ENA                              0x0002
+#define MADERA_AIF3TX2_ENA_MASK                         0x0002
+#define MADERA_AIF3TX2_ENA_SHIFT                             1
+#define MADERA_AIF3TX2_ENA_WIDTH                             1
+#define MADERA_AIF3TX1_ENA                              0x0001
+#define MADERA_AIF3TX1_ENA_MASK                         0x0001
+#define MADERA_AIF3TX1_ENA_SHIFT                             0
+#define MADERA_AIF3TX1_ENA_WIDTH                             1
+
+/* (0x059A)  AIF3_Rx_Enables */
+#define MADERA_AIF3RX2_ENA                              0x0002
+#define MADERA_AIF3RX2_ENA_MASK                         0x0002
+#define MADERA_AIF3RX2_ENA_SHIFT                             1
+#define MADERA_AIF3RX2_ENA_WIDTH                             1
+#define MADERA_AIF3RX1_ENA                              0x0001
+#define MADERA_AIF3RX1_ENA_MASK                         0x0001
+#define MADERA_AIF3RX1_ENA_SHIFT                             0
+#define MADERA_AIF3RX1_ENA_WIDTH                             1
+
+/* (0x05B9)  AIF4_Tx_Enables */
+#define MADERA_AIF4TX2_ENA                              0x0002
+#define MADERA_AIF4TX2_ENA_MASK                         0x0002
+#define MADERA_AIF4TX2_ENA_SHIFT                             1
+#define MADERA_AIF4TX2_ENA_WIDTH                             1
+#define MADERA_AIF4TX1_ENA                              0x0001
+#define MADERA_AIF4TX1_ENA_MASK                         0x0001
+#define MADERA_AIF4TX1_ENA_SHIFT                             0
+#define MADERA_AIF4TX1_ENA_WIDTH                             1
+
+/* (0x05BA)  AIF4_Rx_Enables */
+#define MADERA_AIF4RX2_ENA                              0x0002
+#define MADERA_AIF4RX2_ENA_MASK                         0x0002
+#define MADERA_AIF4RX2_ENA_SHIFT                             1
+#define MADERA_AIF4RX2_ENA_WIDTH                             1
+#define MADERA_AIF4RX1_ENA                              0x0001
+#define MADERA_AIF4RX1_ENA_MASK                         0x0001
+#define MADERA_AIF4RX1_ENA_SHIFT                             0
+#define MADERA_AIF4RX1_ENA_WIDTH                             1
+
+/* (0x05C2)  SPD1_TX_Control */
+#define MADERA_SPD1_VAL2                                0x2000
+#define MADERA_SPD1_VAL2_MASK                           0x2000
+#define MADERA_SPD1_VAL2_SHIFT                              13
+#define MADERA_SPD1_VAL2_WIDTH                               1
+#define MADERA_SPD1_VAL1                                0x1000
+#define MADERA_SPD1_VAL1_MASK                           0x1000
+#define MADERA_SPD1_VAL1_SHIFT                              12
+#define MADERA_SPD1_VAL1_WIDTH                               1
+#define MADERA_SPD1_RATE_MASK                           0x00F0
+#define MADERA_SPD1_RATE_SHIFT                               4
+#define MADERA_SPD1_RATE_WIDTH                               4
+#define MADERA_SPD1_ENA                                 0x0001
+#define MADERA_SPD1_ENA_MASK                            0x0001
+#define MADERA_SPD1_ENA_SHIFT                                0
+#define MADERA_SPD1_ENA_WIDTH                                1
+
+/* (0x05F5)  SLIMbus_RX_Channel_Enable */
+#define MADERA_SLIMRX8_ENA                              0x0080
+#define MADERA_SLIMRX8_ENA_MASK                         0x0080
+#define MADERA_SLIMRX8_ENA_SHIFT                             7
+#define MADERA_SLIMRX8_ENA_WIDTH                             1
+#define MADERA_SLIMRX7_ENA                              0x0040
+#define MADERA_SLIMRX7_ENA_MASK                         0x0040
+#define MADERA_SLIMRX7_ENA_SHIFT                             6
+#define MADERA_SLIMRX7_ENA_WIDTH                             1
+#define MADERA_SLIMRX6_ENA                              0x0020
+#define MADERA_SLIMRX6_ENA_MASK                         0x0020
+#define MADERA_SLIMRX6_ENA_SHIFT                             5
+#define MADERA_SLIMRX6_ENA_WIDTH                             1
+#define MADERA_SLIMRX5_ENA                              0x0010
+#define MADERA_SLIMRX5_ENA_MASK                         0x0010
+#define MADERA_SLIMRX5_ENA_SHIFT                             4
+#define MADERA_SLIMRX5_ENA_WIDTH                             1
+#define MADERA_SLIMRX4_ENA                              0x0008
+#define MADERA_SLIMRX4_ENA_MASK                         0x0008
+#define MADERA_SLIMRX4_ENA_SHIFT                             3
+#define MADERA_SLIMRX4_ENA_WIDTH                             1
+#define MADERA_SLIMRX3_ENA                              0x0004
+#define MADERA_SLIMRX3_ENA_MASK                         0x0004
+#define MADERA_SLIMRX3_ENA_SHIFT                             2
+#define MADERA_SLIMRX3_ENA_WIDTH                             1
+#define MADERA_SLIMRX2_ENA                              0x0002
+#define MADERA_SLIMRX2_ENA_MASK                         0x0002
+#define MADERA_SLIMRX2_ENA_SHIFT                             1
+#define MADERA_SLIMRX2_ENA_WIDTH                             1
+#define MADERA_SLIMRX1_ENA                              0x0001
+#define MADERA_SLIMRX1_ENA_MASK                         0x0001
+#define MADERA_SLIMRX1_ENA_SHIFT                             0
+#define MADERA_SLIMRX1_ENA_WIDTH                             1
+
+/* (0x05F6)  SLIMbus_TX_Channel_Enable */
+#define MADERA_SLIMTX8_ENA                              0x0080
+#define MADERA_SLIMTX8_ENA_MASK                         0x0080
+#define MADERA_SLIMTX8_ENA_SHIFT                             7
+#define MADERA_SLIMTX8_ENA_WIDTH                             1
+#define MADERA_SLIMTX7_ENA                              0x0040
+#define MADERA_SLIMTX7_ENA_MASK                         0x0040
+#define MADERA_SLIMTX7_ENA_SHIFT                             6
+#define MADERA_SLIMTX7_ENA_WIDTH                             1
+#define MADERA_SLIMTX6_ENA                              0x0020
+#define MADERA_SLIMTX6_ENA_MASK                         0x0020
+#define MADERA_SLIMTX6_ENA_SHIFT                             5
+#define MADERA_SLIMTX6_ENA_WIDTH                             1
+#define MADERA_SLIMTX5_ENA                              0x0010
+#define MADERA_SLIMTX5_ENA_MASK                         0x0010
+#define MADERA_SLIMTX5_ENA_SHIFT                             4
+#define MADERA_SLIMTX5_ENA_WIDTH                             1
+#define MADERA_SLIMTX4_ENA                              0x0008
+#define MADERA_SLIMTX4_ENA_MASK                         0x0008
+#define MADERA_SLIMTX4_ENA_SHIFT                             3
+#define MADERA_SLIMTX4_ENA_WIDTH                             1
+#define MADERA_SLIMTX3_ENA                              0x0004
+#define MADERA_SLIMTX3_ENA_MASK                         0x0004
+#define MADERA_SLIMTX3_ENA_SHIFT                             2
+#define MADERA_SLIMTX3_ENA_WIDTH                             1
+#define MADERA_SLIMTX2_ENA                              0x0002
+#define MADERA_SLIMTX2_ENA_MASK                         0x0002
+#define MADERA_SLIMTX2_ENA_SHIFT                             1
+#define MADERA_SLIMTX2_ENA_WIDTH                             1
+#define MADERA_SLIMTX1_ENA                              0x0001
+#define MADERA_SLIMTX1_ENA_MASK                         0x0001
+#define MADERA_SLIMTX1_ENA_SHIFT                             0
+#define MADERA_SLIMTX1_ENA_WIDTH                             1
+
+/* (0x0E10)  EQ1_1 */
+#define MADERA_EQ1_B1_GAIN_MASK                         0xF800
+#define MADERA_EQ1_B1_GAIN_SHIFT                            11
+#define MADERA_EQ1_B1_GAIN_WIDTH                             5
+#define MADERA_EQ1_B2_GAIN_MASK                         0x07C0
+#define MADERA_EQ1_B2_GAIN_SHIFT                             6
+#define MADERA_EQ1_B2_GAIN_WIDTH                             5
+#define MADERA_EQ1_B3_GAIN_MASK                         0x003E
+#define MADERA_EQ1_B3_GAIN_SHIFT                             1
+#define MADERA_EQ1_B3_GAIN_WIDTH                             5
+#define MADERA_EQ1_ENA                                  0x0001
+#define MADERA_EQ1_ENA_MASK                             0x0001
+#define MADERA_EQ1_ENA_SHIFT                                 0
+#define MADERA_EQ1_ENA_WIDTH                                 1
+
+/* (0x0E11)  EQ1_2 */
+#define MADERA_EQ1_B4_GAIN_MASK                         0xF800
+#define MADERA_EQ1_B4_GAIN_SHIFT                            11
+#define MADERA_EQ1_B4_GAIN_WIDTH                             5
+#define MADERA_EQ1_B5_GAIN_MASK                         0x07C0
+#define MADERA_EQ1_B5_GAIN_SHIFT                             6
+#define MADERA_EQ1_B5_GAIN_WIDTH                             5
+#define MADERA_EQ1_B1_MODE                              0x0001
+#define MADERA_EQ1_B1_MODE_MASK                         0x0001
+#define MADERA_EQ1_B1_MODE_SHIFT                             0
+#define MADERA_EQ1_B1_MODE_WIDTH                             1
+
+/* (0x0E26)  EQ2_1 */
+#define MADERA_EQ2_B1_GAIN_MASK                         0xF800
+#define MADERA_EQ2_B1_GAIN_SHIFT                            11
+#define MADERA_EQ2_B1_GAIN_WIDTH                             5
+#define MADERA_EQ2_B2_GAIN_MASK                         0x07C0
+#define MADERA_EQ2_B2_GAIN_SHIFT                             6
+#define MADERA_EQ2_B2_GAIN_WIDTH                             5
+#define MADERA_EQ2_B3_GAIN_MASK                         0x003E
+#define MADERA_EQ2_B3_GAIN_SHIFT                             1
+#define MADERA_EQ2_B3_GAIN_WIDTH                             5
+#define MADERA_EQ2_ENA                                  0x0001
+#define MADERA_EQ2_ENA_MASK                             0x0001
+#define MADERA_EQ2_ENA_SHIFT                                 0
+#define MADERA_EQ2_ENA_WIDTH                                 1
+
+/* (0x0E27)  EQ2_2 */
+#define MADERA_EQ2_B4_GAIN_MASK                         0xF800
+#define MADERA_EQ2_B4_GAIN_SHIFT                            11
+#define MADERA_EQ2_B4_GAIN_WIDTH                             5
+#define MADERA_EQ2_B5_GAIN_MASK                         0x07C0
+#define MADERA_EQ2_B5_GAIN_SHIFT                             6
+#define MADERA_EQ2_B5_GAIN_WIDTH                             5
+#define MADERA_EQ2_B1_MODE                              0x0001
+#define MADERA_EQ2_B1_MODE_MASK                         0x0001
+#define MADERA_EQ2_B1_MODE_SHIFT                             0
+#define MADERA_EQ2_B1_MODE_WIDTH                             1
+
+/* (0x0E3C)  EQ3_1 */
+#define MADERA_EQ3_B1_GAIN_MASK                         0xF800
+#define MADERA_EQ3_B1_GAIN_SHIFT                            11
+#define MADERA_EQ3_B1_GAIN_WIDTH                             5
+#define MADERA_EQ3_B2_GAIN_MASK                         0x07C0
+#define MADERA_EQ3_B2_GAIN_SHIFT                             6
+#define MADERA_EQ3_B2_GAIN_WIDTH                             5
+#define MADERA_EQ3_B3_GAIN_MASK                         0x003E
+#define MADERA_EQ3_B3_GAIN_SHIFT                             1
+#define MADERA_EQ3_B3_GAIN_WIDTH                             5
+#define MADERA_EQ3_ENA                                  0x0001
+#define MADERA_EQ3_ENA_MASK                             0x0001
+#define MADERA_EQ3_ENA_SHIFT                                 0
+#define MADERA_EQ3_ENA_WIDTH                                 1
+
+/* (0x0E3D)  EQ3_2 */
+#define MADERA_EQ3_B4_GAIN_MASK                         0xF800
+#define MADERA_EQ3_B4_GAIN_SHIFT                            11
+#define MADERA_EQ3_B4_GAIN_WIDTH                             5
+#define MADERA_EQ3_B5_GAIN_MASK                         0x07C0
+#define MADERA_EQ3_B5_GAIN_SHIFT                             6
+#define MADERA_EQ3_B5_GAIN_WIDTH                             5
+#define MADERA_EQ3_B1_MODE                              0x0001
+#define MADERA_EQ3_B1_MODE_MASK                         0x0001
+#define MADERA_EQ3_B1_MODE_SHIFT                             0
+#define MADERA_EQ3_B1_MODE_WIDTH                             1
+
+/* (0x0E52)  EQ4_1 */
+#define MADERA_EQ4_B1_GAIN_MASK                         0xF800
+#define MADERA_EQ4_B1_GAIN_SHIFT                            11
+#define MADERA_EQ4_B1_GAIN_WIDTH                             5
+#define MADERA_EQ4_B2_GAIN_MASK                         0x07C0
+#define MADERA_EQ4_B2_GAIN_SHIFT                             6
+#define MADERA_EQ4_B2_GAIN_WIDTH                             5
+#define MADERA_EQ4_B3_GAIN_MASK                         0x003E
+#define MADERA_EQ4_B3_GAIN_SHIFT                             1
+#define MADERA_EQ4_B3_GAIN_WIDTH                             5
+#define MADERA_EQ4_ENA                                  0x0001
+#define MADERA_EQ4_ENA_MASK                             0x0001
+#define MADERA_EQ4_ENA_SHIFT                                 0
+#define MADERA_EQ4_ENA_WIDTH                                 1
+
+/* (0x0E53)  EQ4_2 */
+#define MADERA_EQ4_B4_GAIN_MASK                         0xF800
+#define MADERA_EQ4_B4_GAIN_SHIFT                            11
+#define MADERA_EQ4_B4_GAIN_WIDTH                             5
+#define MADERA_EQ4_B5_GAIN_MASK                         0x07C0
+#define MADERA_EQ4_B5_GAIN_SHIFT                             6
+#define MADERA_EQ4_B5_GAIN_WIDTH                             5
+#define MADERA_EQ4_B1_MODE                              0x0001
+#define MADERA_EQ4_B1_MODE_MASK                         0x0001
+#define MADERA_EQ4_B1_MODE_SHIFT                             0
+#define MADERA_EQ4_B1_MODE_WIDTH                             1
+
+/* (0x0E80)  DRC1_ctrl1 */
+#define MADERA_DRC1L_ENA                                0x0002
+#define MADERA_DRC1L_ENA_MASK                           0x0002
+#define MADERA_DRC1L_ENA_SHIFT                               1
+#define MADERA_DRC1L_ENA_WIDTH                               1
+#define MADERA_DRC1R_ENA                                0x0001
+#define MADERA_DRC1R_ENA_MASK                           0x0001
+#define MADERA_DRC1R_ENA_SHIFT                               0
+#define MADERA_DRC1R_ENA_WIDTH                               1
+
+/* (0x0E88)  DRC2_ctrl1 */
+#define MADERA_DRC2L_ENA                                0x0002
+#define MADERA_DRC2L_ENA_MASK                           0x0002
+#define MADERA_DRC2L_ENA_SHIFT                               1
+#define MADERA_DRC2L_ENA_WIDTH                               1
+#define MADERA_DRC2R_ENA                                0x0001
+#define MADERA_DRC2R_ENA_MASK                           0x0001
+#define MADERA_DRC2R_ENA_SHIFT                               0
+#define MADERA_DRC2R_ENA_WIDTH                               1
+
+/* (0x0EC0)  HPLPF1_1 */
+#define MADERA_LHPF1_MODE                               0x0002
+#define MADERA_LHPF1_MODE_MASK                          0x0002
+#define MADERA_LHPF1_MODE_SHIFT                              1
+#define MADERA_LHPF1_MODE_WIDTH                              1
+#define MADERA_LHPF1_ENA                                0x0001
+#define MADERA_LHPF1_ENA_MASK                           0x0001
+#define MADERA_LHPF1_ENA_SHIFT                               0
+#define MADERA_LHPF1_ENA_WIDTH                               1
+
+/* (0x0EC1)  HPLPF1_2 */
+#define MADERA_LHPF1_COEFF_MASK                         0xFFFF
+#define MADERA_LHPF1_COEFF_SHIFT                             0
+#define MADERA_LHPF1_COEFF_WIDTH                            16
+
+/* (0x0EC4)  HPLPF2_1 */
+#define MADERA_LHPF2_MODE                               0x0002
+#define MADERA_LHPF2_MODE_MASK                          0x0002
+#define MADERA_LHPF2_MODE_SHIFT                              1
+#define MADERA_LHPF2_MODE_WIDTH                              1
+#define MADERA_LHPF2_ENA                                0x0001
+#define MADERA_LHPF2_ENA_MASK                           0x0001
+#define MADERA_LHPF2_ENA_SHIFT                               0
+#define MADERA_LHPF2_ENA_WIDTH                               1
+
+/* (0x0EC5)  HPLPF2_2 */
+#define MADERA_LHPF2_COEFF_MASK                         0xFFFF
+#define MADERA_LHPF2_COEFF_SHIFT                             0
+#define MADERA_LHPF2_COEFF_WIDTH                            16
+
+/* (0x0EC8)  HPLPF3_1 */
+#define MADERA_LHPF3_MODE                               0x0002
+#define MADERA_LHPF3_MODE_MASK                          0x0002
+#define MADERA_LHPF3_MODE_SHIFT                              1
+#define MADERA_LHPF3_MODE_WIDTH                              1
+#define MADERA_LHPF3_ENA                                0x0001
+#define MADERA_LHPF3_ENA_MASK                           0x0001
+#define MADERA_LHPF3_ENA_SHIFT                               0
+#define MADERA_LHPF3_ENA_WIDTH                               1
+
+/* (0x0EC9)  HPLPF3_2 */
+#define MADERA_LHPF3_COEFF_MASK                         0xFFFF
+#define MADERA_LHPF3_COEFF_SHIFT                             0
+#define MADERA_LHPF3_COEFF_WIDTH                            16
+
+/* (0x0ECC)  HPLPF4_1 */
+#define MADERA_LHPF4_MODE                               0x0002
+#define MADERA_LHPF4_MODE_MASK                          0x0002
+#define MADERA_LHPF4_MODE_SHIFT                              1
+#define MADERA_LHPF4_MODE_WIDTH                              1
+#define MADERA_LHPF4_ENA                                0x0001
+#define MADERA_LHPF4_ENA_MASK                           0x0001
+#define MADERA_LHPF4_ENA_SHIFT                               0
+#define MADERA_LHPF4_ENA_WIDTH                               1
+
+/* (0x0ECD)  HPLPF4_2 */
+#define MADERA_LHPF4_COEFF_MASK                         0xFFFF
+#define MADERA_LHPF4_COEFF_SHIFT                             0
+#define MADERA_LHPF4_COEFF_WIDTH                            16
+
+/* (0x0ED0)  ASRC2_ENABLE */
+#define MADERA_ASRC2_IN2L_ENA                           0x0008
+#define MADERA_ASRC2_IN2L_ENA_MASK                      0x0008
+#define MADERA_ASRC2_IN2L_ENA_SHIFT                          3
+#define MADERA_ASRC2_IN2L_ENA_WIDTH                          1
+#define MADERA_ASRC2_IN2R_ENA                           0x0004
+#define MADERA_ASRC2_IN2R_ENA_MASK                      0x0004
+#define MADERA_ASRC2_IN2R_ENA_SHIFT                          2
+#define MADERA_ASRC2_IN2R_ENA_WIDTH                          1
+#define MADERA_ASRC2_IN1L_ENA                           0x0002
+#define MADERA_ASRC2_IN1L_ENA_MASK                      0x0002
+#define MADERA_ASRC2_IN1L_ENA_SHIFT                          1
+#define MADERA_ASRC2_IN1L_ENA_WIDTH                          1
+#define MADERA_ASRC2_IN1R_ENA                           0x0001
+#define MADERA_ASRC2_IN1R_ENA_MASK                      0x0001
+#define MADERA_ASRC2_IN1R_ENA_SHIFT                          0
+#define MADERA_ASRC2_IN1R_ENA_WIDTH                          1
+
+/* (0x0ED2)  ASRC2_RATE1 */
+#define MADERA_ASRC2_RATE1_MASK                         0xF800
+#define MADERA_ASRC2_RATE1_SHIFT                            11
+#define MADERA_ASRC2_RATE1_WIDTH                             5
+
+/* (0x0ED3)  ASRC2_RATE2 */
+#define MADERA_ASRC2_RATE2_MASK                         0xF800
+#define MADERA_ASRC2_RATE2_SHIFT                            11
+#define MADERA_ASRC2_RATE2_WIDTH                             5
+
+/* (0x0EE0)  ASRC1_ENABLE */
+#define MADERA_ASRC1_IN2L_ENA                           0x0008
+#define MADERA_ASRC1_IN2L_ENA_MASK                      0x0008
+#define MADERA_ASRC1_IN2L_ENA_SHIFT                          3
+#define MADERA_ASRC1_IN2L_ENA_WIDTH                          1
+#define MADERA_ASRC1_IN2R_ENA                           0x0004
+#define MADERA_ASRC1_IN2R_ENA_MASK                      0x0004
+#define MADERA_ASRC1_IN2R_ENA_SHIFT                          2
+#define MADERA_ASRC1_IN2R_ENA_WIDTH                          1
+#define MADERA_ASRC1_IN1L_ENA                           0x0002
+#define MADERA_ASRC1_IN1L_ENA_MASK                      0x0002
+#define MADERA_ASRC1_IN1L_ENA_SHIFT                          1
+#define MADERA_ASRC1_IN1L_ENA_WIDTH                          1
+#define MADERA_ASRC1_IN1R_ENA                           0x0001
+#define MADERA_ASRC1_IN1R_ENA_MASK                      0x0001
+#define MADERA_ASRC1_IN1R_ENA_SHIFT                          0
+#define MADERA_ASRC1_IN1R_ENA_WIDTH                          1
+
+/* (0x0EE2)  ASRC1_RATE1 */
+#define MADERA_ASRC1_RATE1_MASK                         0xF800
+#define MADERA_ASRC1_RATE1_SHIFT                            11
+#define MADERA_ASRC1_RATE1_WIDTH                             5
+
+/* (0x0EE3)  ASRC1_RATE2 */
+#define MADERA_ASRC1_RATE2_MASK                         0xF800
+#define MADERA_ASRC1_RATE2_SHIFT                            11
+#define MADERA_ASRC1_RATE2_WIDTH                             5
+
+/* (0x0EF0) - ISRC1 CTRL 1 */
+#define MADERA_ISRC1_FSH_MASK                           0xF800
+#define MADERA_ISRC1_FSH_SHIFT                              11
+#define MADERA_ISRC1_FSH_WIDTH                               5
+#define MADERA_ISRC1_CLK_SEL_MASK                       0x0700
+#define MADERA_ISRC1_CLK_SEL_SHIFT                           8
+#define MADERA_ISRC1_CLK_SEL_WIDTH                           3
+
+/* (0x0EF1)  ISRC1_CTRL_2 */
+#define MADERA_ISRC1_FSL_MASK                           0xF800
+#define MADERA_ISRC1_FSL_SHIFT                              11
+#define MADERA_ISRC1_FSL_WIDTH                               5
+
+/* (0x0EF2)  ISRC1_CTRL_3 */
+#define MADERA_ISRC1_INT1_ENA                           0x8000
+#define MADERA_ISRC1_INT1_ENA_MASK                      0x8000
+#define MADERA_ISRC1_INT1_ENA_SHIFT                         15
+#define MADERA_ISRC1_INT1_ENA_WIDTH                          1
+#define MADERA_ISRC1_INT2_ENA                           0x4000
+#define MADERA_ISRC1_INT2_ENA_MASK                      0x4000
+#define MADERA_ISRC1_INT2_ENA_SHIFT                         14
+#define MADERA_ISRC1_INT2_ENA_WIDTH                          1
+#define MADERA_ISRC1_INT3_ENA                           0x2000
+#define MADERA_ISRC1_INT3_ENA_MASK                      0x2000
+#define MADERA_ISRC1_INT3_ENA_SHIFT                         13
+#define MADERA_ISRC1_INT3_ENA_WIDTH                          1
+#define MADERA_ISRC1_INT4_ENA                           0x1000
+#define MADERA_ISRC1_INT4_ENA_MASK                      0x1000
+#define MADERA_ISRC1_INT4_ENA_SHIFT                         12
+#define MADERA_ISRC1_INT4_ENA_WIDTH                          1
+#define MADERA_ISRC1_DEC1_ENA                           0x0200
+#define MADERA_ISRC1_DEC1_ENA_MASK                      0x0200
+#define MADERA_ISRC1_DEC1_ENA_SHIFT                          9
+#define MADERA_ISRC1_DEC1_ENA_WIDTH                          1
+#define MADERA_ISRC1_DEC2_ENA                           0x0100
+#define MADERA_ISRC1_DEC2_ENA_MASK                      0x0100
+#define MADERA_ISRC1_DEC2_ENA_SHIFT                          8
+#define MADERA_ISRC1_DEC2_ENA_WIDTH                          1
+#define MADERA_ISRC1_DEC3_ENA                           0x0080
+#define MADERA_ISRC1_DEC3_ENA_MASK                      0x0080
+#define MADERA_ISRC1_DEC3_ENA_SHIFT                          7
+#define MADERA_ISRC1_DEC3_ENA_WIDTH                          1
+#define MADERA_ISRC1_DEC4_ENA                           0x0040
+#define MADERA_ISRC1_DEC4_ENA_MASK                      0x0040
+#define MADERA_ISRC1_DEC4_ENA_SHIFT                          6
+#define MADERA_ISRC1_DEC4_ENA_WIDTH                          1
+#define MADERA_ISRC1_NOTCH_ENA                          0x0001
+#define MADERA_ISRC1_NOTCH_ENA_MASK                     0x0001
+#define MADERA_ISRC1_NOTCH_ENA_SHIFT                         0
+#define MADERA_ISRC1_NOTCH_ENA_WIDTH                         1
+
+/* (0x0EF3)  ISRC2_CTRL_1 */
+#define MADERA_ISRC2_FSH_MASK                           0xF800
+#define MADERA_ISRC2_FSH_SHIFT                              11
+#define MADERA_ISRC2_FSH_WIDTH                               5
+#define MADERA_ISRC2_CLK_SEL_MASK                       0x0700
+#define MADERA_ISRC2_CLK_SEL_SHIFT                           8
+#define MADERA_ISRC2_CLK_SEL_WIDTH                           3
+
+/* (0x0EF4)  ISRC2_CTRL_2 */
+#define MADERA_ISRC2_FSL_MASK                           0xF800
+#define MADERA_ISRC2_FSL_SHIFT                              11
+#define MADERA_ISRC2_FSL_WIDTH                               5
+
+/* (0x0EF5)  ISRC2_CTRL_3 */
+#define MADERA_ISRC2_INT1_ENA                           0x8000
+#define MADERA_ISRC2_INT1_ENA_MASK                      0x8000
+#define MADERA_ISRC2_INT1_ENA_SHIFT                         15
+#define MADERA_ISRC2_INT1_ENA_WIDTH                          1
+#define MADERA_ISRC2_INT2_ENA                           0x4000
+#define MADERA_ISRC2_INT2_ENA_MASK                      0x4000
+#define MADERA_ISRC2_INT2_ENA_SHIFT                         14
+#define MADERA_ISRC2_INT2_ENA_WIDTH                          1
+#define MADERA_ISRC2_INT3_ENA                           0x2000
+#define MADERA_ISRC2_INT3_ENA_MASK                      0x2000
+#define MADERA_ISRC2_INT3_ENA_SHIFT                         13
+#define MADERA_ISRC2_INT3_ENA_WIDTH                          1
+#define MADERA_ISRC2_INT4_ENA                           0x1000
+#define MADERA_ISRC2_INT4_ENA_MASK                      0x1000
+#define MADERA_ISRC2_INT4_ENA_SHIFT                         12
+#define MADERA_ISRC2_INT4_ENA_WIDTH                          1
+#define MADERA_ISRC2_DEC1_ENA                           0x0200
+#define MADERA_ISRC2_DEC1_ENA_MASK                      0x0200
+#define MADERA_ISRC2_DEC1_ENA_SHIFT                          9
+#define MADERA_ISRC2_DEC1_ENA_WIDTH                          1
+#define MADERA_ISRC2_DEC2_ENA                           0x0100
+#define MADERA_ISRC2_DEC2_ENA_MASK                      0x0100
+#define MADERA_ISRC2_DEC2_ENA_SHIFT                          8
+#define MADERA_ISRC2_DEC2_ENA_WIDTH                          1
+#define MADERA_ISRC2_DEC3_ENA                           0x0080
+#define MADERA_ISRC2_DEC3_ENA_MASK                      0x0080
+#define MADERA_ISRC2_DEC3_ENA_SHIFT                          7
+#define MADERA_ISRC2_DEC3_ENA_WIDTH                          1
+#define MADERA_ISRC2_DEC4_ENA                           0x0040
+#define MADERA_ISRC2_DEC4_ENA_MASK                      0x0040
+#define MADERA_ISRC2_DEC4_ENA_SHIFT                          6
+#define MADERA_ISRC2_DEC4_ENA_WIDTH                          1
+#define MADERA_ISRC2_NOTCH_ENA                          0x0001
+#define MADERA_ISRC2_NOTCH_ENA_MASK                     0x0001
+#define MADERA_ISRC2_NOTCH_ENA_SHIFT                         0
+#define MADERA_ISRC2_NOTCH_ENA_WIDTH                         1
+
+/* (0x0EF6)  ISRC3_CTRL_1 */
+#define MADERA_ISRC3_FSH_MASK                           0xF800
+#define MADERA_ISRC3_FSH_SHIFT                              11
+#define MADERA_ISRC3_FSH_WIDTH                               5
+#define MADERA_ISRC3_CLK_SEL_MASK                       0x0700
+#define MADERA_ISRC3_CLK_SEL_SHIFT                           8
+#define MADERA_ISRC3_CLK_SEL_WIDTH                           3
+
+/* (0x0EF7)  ISRC3_CTRL_2 */
+#define MADERA_ISRC3_FSL_MASK                           0xF800
+#define MADERA_ISRC3_FSL_SHIFT                              11
+#define MADERA_ISRC3_FSL_WIDTH                               5
+
+/* (0x0EF8)  ISRC3_CTRL_3 */
+#define MADERA_ISRC3_INT1_ENA                           0x8000
+#define MADERA_ISRC3_INT1_ENA_MASK                      0x8000
+#define MADERA_ISRC3_INT1_ENA_SHIFT                         15
+#define MADERA_ISRC3_INT1_ENA_WIDTH                          1
+#define MADERA_ISRC3_INT2_ENA                           0x4000
+#define MADERA_ISRC3_INT2_ENA_MASK                      0x4000
+#define MADERA_ISRC3_INT2_ENA_SHIFT                         14
+#define MADERA_ISRC3_INT2_ENA_WIDTH                          1
+#define MADERA_ISRC3_INT3_ENA                           0x2000
+#define MADERA_ISRC3_INT3_ENA_MASK                      0x2000
+#define MADERA_ISRC3_INT3_ENA_SHIFT                         13
+#define MADERA_ISRC3_INT3_ENA_WIDTH                          1
+#define MADERA_ISRC3_INT4_ENA                           0x1000
+#define MADERA_ISRC3_INT4_ENA_MASK                      0x1000
+#define MADERA_ISRC3_INT4_ENA_SHIFT                         12
+#define MADERA_ISRC3_INT4_ENA_WIDTH                          1
+#define MADERA_ISRC3_DEC1_ENA                           0x0200
+#define MADERA_ISRC3_DEC1_ENA_MASK                      0x0200
+#define MADERA_ISRC3_DEC1_ENA_SHIFT                          9
+#define MADERA_ISRC3_DEC1_ENA_WIDTH                          1
+#define MADERA_ISRC3_DEC2_ENA                           0x0100
+#define MADERA_ISRC3_DEC2_ENA_MASK                      0x0100
+#define MADERA_ISRC3_DEC2_ENA_SHIFT                          8
+#define MADERA_ISRC3_DEC2_ENA_WIDTH                          1
+#define MADERA_ISRC3_DEC3_ENA                           0x0080
+#define MADERA_ISRC3_DEC3_ENA_MASK                      0x0080
+#define MADERA_ISRC3_DEC3_ENA_SHIFT                          7
+#define MADERA_ISRC3_DEC3_ENA_WIDTH                          1
+#define MADERA_ISRC3_DEC4_ENA                           0x0040
+#define MADERA_ISRC3_DEC4_ENA_MASK                      0x0040
+#define MADERA_ISRC3_DEC4_ENA_SHIFT                          6
+#define MADERA_ISRC3_DEC4_ENA_WIDTH                          1
+#define MADERA_ISRC3_NOTCH_ENA                          0x0001
+#define MADERA_ISRC3_NOTCH_ENA_MASK                     0x0001
+#define MADERA_ISRC3_NOTCH_ENA_SHIFT                         0
+#define MADERA_ISRC3_NOTCH_ENA_WIDTH                         1
+
+/* (0x0EF9)  ISRC4_CTRL_1 */
+#define MADERA_ISRC4_FSH_MASK                           0xF800
+#define MADERA_ISRC4_FSH_SHIFT                              11
+#define MADERA_ISRC4_FSH_WIDTH                               5
+#define MADERA_ISRC4_CLK_SEL_MASK                       0x0700
+#define MADERA_ISRC4_CLK_SEL_SHIFT                           8
+#define MADERA_ISRC4_CLK_SEL_WIDTH                           3
+
+/* (0x0EFA)  ISRC4_CTRL_2 */
+#define MADERA_ISRC4_FSL_MASK                           0xF800
+#define MADERA_ISRC4_FSL_SHIFT                              11
+#define MADERA_ISRC4_FSL_WIDTH                               5
+
+/* (0x0EFB)  ISRC4_CTRL_3 */
+#define MADERA_ISRC4_INT1_ENA                           0x8000
+#define MADERA_ISRC4_INT1_ENA_MASK                      0x8000
+#define MADERA_ISRC4_INT1_ENA_SHIFT                         15
+#define MADERA_ISRC4_INT1_ENA_WIDTH                          1
+#define MADERA_ISRC4_INT2_ENA                           0x4000
+#define MADERA_ISRC4_INT2_ENA_MASK                      0x4000
+#define MADERA_ISRC4_INT2_ENA_SHIFT                         14
+#define MADERA_ISRC4_INT2_ENA_WIDTH                          1
+#define MADERA_ISRC4_INT3_ENA                           0x2000
+#define MADERA_ISRC4_INT3_ENA_MASK                      0x2000
+#define MADERA_ISRC4_INT3_ENA_SHIFT                         13
+#define MADERA_ISRC4_INT3_ENA_WIDTH                          1
+#define MADERA_ISRC4_INT4_ENA                           0x1000
+#define MADERA_ISRC4_INT4_ENA_MASK                      0x1000
+#define MADERA_ISRC4_INT4_ENA_SHIFT                         12
+#define MADERA_ISRC4_INT4_ENA_WIDTH                          1
+#define MADERA_ISRC4_DEC1_ENA                           0x0200
+#define MADERA_ISRC4_DEC1_ENA_MASK                      0x0200
+#define MADERA_ISRC4_DEC1_ENA_SHIFT                          9
+#define MADERA_ISRC4_DEC1_ENA_WIDTH                          1
+#define MADERA_ISRC4_DEC2_ENA                           0x0100
+#define MADERA_ISRC4_DEC2_ENA_MASK                      0x0100
+#define MADERA_ISRC4_DEC2_ENA_SHIFT                          8
+#define MADERA_ISRC4_DEC2_ENA_WIDTH                          1
+#define MADERA_ISRC4_DEC3_ENA                           0x0080
+#define MADERA_ISRC4_DEC3_ENA_MASK                      0x0080
+#define MADERA_ISRC4_DEC3_ENA_SHIFT                          7
+#define MADERA_ISRC4_DEC3_ENA_WIDTH                          1
+#define MADERA_ISRC4_DEC4_ENA                           0x0040
+#define MADERA_ISRC4_DEC4_ENA_MASK                      0x0040
+#define MADERA_ISRC4_DEC4_ENA_SHIFT                          6
+#define MADERA_ISRC4_DEC4_ENA_WIDTH                          1
+#define MADERA_ISRC4_NOTCH_ENA                          0x0001
+#define MADERA_ISRC4_NOTCH_ENA_MASK                     0x0001
+#define MADERA_ISRC4_NOTCH_ENA_SHIFT                         0
+#define MADERA_ISRC4_NOTCH_ENA_WIDTH                         1
+
+/* (0x0F00)  Clock_Control */
+#define MADERA_EXT_NG_SEL_CLR                           0x0080
+#define MADERA_EXT_NG_SEL_CLR_MASK                      0x0080
+#define MADERA_EXT_NG_SEL_CLR_SHIFT                          7
+#define MADERA_EXT_NG_SEL_CLR_WIDTH                          1
+#define MADERA_EXT_NG_SEL_SET                           0x0040
+#define MADERA_EXT_NG_SEL_SET_MASK                      0x0040
+#define MADERA_EXT_NG_SEL_SET_SHIFT                          6
+#define MADERA_EXT_NG_SEL_SET_WIDTH                          1
+#define MADERA_CLK_R_ENA_CLR                            0x0020
+#define MADERA_CLK_R_ENA_CLR_MASK                       0x0020
+#define MADERA_CLK_R_ENA_CLR_SHIFT                           5
+#define MADERA_CLK_R_ENA_CLR_WIDTH                           1
+#define MADERA_CLK_R_ENA_SET                            0x0010
+#define MADERA_CLK_R_ENA_SET_MASK                       0x0010
+#define MADERA_CLK_R_ENA_SET_SHIFT                           4
+#define MADERA_CLK_R_ENA_SET_WIDTH                           1
+#define MADERA_CLK_NG_ENA_CLR                           0x0008
+#define MADERA_CLK_NG_ENA_CLR_MASK                      0x0008
+#define MADERA_CLK_NG_ENA_CLR_SHIFT                          3
+#define MADERA_CLK_NG_ENA_CLR_WIDTH                          1
+#define MADERA_CLK_NG_ENA_SET                           0x0004
+#define MADERA_CLK_NG_ENA_SET_MASK                      0x0004
+#define MADERA_CLK_NG_ENA_SET_SHIFT                          2
+#define MADERA_CLK_NG_ENA_SET_WIDTH                          1
+#define MADERA_CLK_L_ENA_CLR                            0x0002
+#define MADERA_CLK_L_ENA_CLR_MASK                       0x0002
+#define MADERA_CLK_L_ENA_CLR_SHIFT                           1
+#define MADERA_CLK_L_ENA_CLR_WIDTH                           1
+#define MADERA_CLK_L_ENA_SET                            0x0001
+#define MADERA_CLK_L_ENA_SET_MASK                       0x0001
+#define MADERA_CLK_L_ENA_SET_SHIFT                           0
+#define MADERA_CLK_L_ENA_SET_WIDTH                           1
+
+/* (0x0F01)  ANC_SRC */
+#define MADERA_IN_RXANCR_SEL_MASK                       0x0070
+#define MADERA_IN_RXANCR_SEL_SHIFT                           4
+#define MADERA_IN_RXANCR_SEL_WIDTH                           3
+#define MADERA_IN_RXANCL_SEL_MASK                       0x0007
+#define MADERA_IN_RXANCL_SEL_SHIFT                           0
+#define MADERA_IN_RXANCL_SEL_WIDTH                           3
+
+/* (0x0F17)  FCL_ADC_reformatter_control */
+#define MADERA_FCL_MIC_MODE_SEL                         0x000C
+#define MADERA_FCL_MIC_MODE_SEL_SHIFT                        2
+#define MADERA_FCL_MIC_MODE_SEL_WIDTH                        2
+
+/* (0x0F73)  FCR_ADC_reformatter_control */
+#define MADERA_FCR_MIC_MODE_SEL                         0x000C
+#define MADERA_FCR_MIC_MODE_SEL_SHIFT                        2
+#define MADERA_FCR_MIC_MODE_SEL_WIDTH                        2
+
+/* (0x1480)  DFC1_CTRL_W0 */
+#define MADERA_DFC1_RATE_MASK                           0x007C
+#define MADERA_DFC1_RATE_SHIFT                               2
+#define MADERA_DFC1_RATE_WIDTH                               5
+#define MADERA_DFC1_DITH_ENA                            0x0002
+#define MADERA_DFC1_DITH_ENA_MASK                       0x0002
+#define MADERA_DFC1_DITH_ENA_SHIFT                           1
+#define MADERA_DFC1_DITH_ENA_WIDTH                           1
+#define MADERA_DFC1_ENA                                 0x0001
+#define MADERA_DFC1_ENA_MASK                            0x0001
+#define MADERA_DFC1_ENA_SHIFT                                0
+#define MADERA_DFC1_ENA_WIDTH                                1
+
+/* (0x1482)  DFC1_RX_W0 */
+#define MADERA_DFC1_RX_DATA_WIDTH_MASK                  0x1F00
+#define MADERA_DFC1_RX_DATA_WIDTH_SHIFT                      8
+#define MADERA_DFC1_RX_DATA_WIDTH_WIDTH                      5
+
+#define MADERA_DFC1_RX_DATA_TYPE_MASK                   0x0007
+#define MADERA_DFC1_RX_DATA_TYPE_SHIFT                       0
+#define MADERA_DFC1_RX_DATA_TYPE_WIDTH                       3
+
+/* (0x1484)  DFC1_TX_W0 */
+#define MADERA_DFC1_TX_DATA_WIDTH_MASK                  0x1F00
+#define MADERA_DFC1_TX_DATA_WIDTH_SHIFT                      8
+#define MADERA_DFC1_TX_DATA_WIDTH_WIDTH                      5
+
+#define MADERA_DFC1_TX_DATA_TYPE_MASK                   0x0007
+#define MADERA_DFC1_TX_DATA_TYPE_SHIFT                       0
+#define MADERA_DFC1_TX_DATA_TYPE_WIDTH                       3
+
+/* (0x1600)  ADSP2_IRQ0 */
+#define MADERA_DSP_IRQ2                                 0x0002
+#define MADERA_DSP_IRQ1                                 0x0001
+
+/* (0x1601)  ADSP2_IRQ1 */
+#define MADERA_DSP_IRQ4                                 0x0002
+#define MADERA_DSP_IRQ3                                 0x0001
+
+/* (0x1602)  ADSP2_IRQ2 */
+#define MADERA_DSP_IRQ6                                 0x0002
+#define MADERA_DSP_IRQ5                                 0x0001
+
+/* (0x1603)  ADSP2_IRQ3 */
+#define MADERA_DSP_IRQ8                                 0x0002
+#define MADERA_DSP_IRQ7                                 0x0001
+
+/* (0x1604)  ADSP2_IRQ4 */
+#define MADERA_DSP_IRQ10                                0x0002
+#define MADERA_DSP_IRQ9                                 0x0001
+
+/* (0x1605)  ADSP2_IRQ5 */
+#define MADERA_DSP_IRQ12                                0x0002
+#define MADERA_DSP_IRQ11                                0x0001
+
+/* (0x1606)  ADSP2_IRQ6 */
+#define MADERA_DSP_IRQ14                                0x0002
+#define MADERA_DSP_IRQ13                                0x0001
+
+/* (0x1607)  ADSP2_IRQ7 */
+#define MADERA_DSP_IRQ16                                0x0002
+#define MADERA_DSP_IRQ15                                0x0001
+
+/* (0x1700)  GPIO1_CTRL_1 */
+#define MADERA_GP1_LVL                                  0x8000
+#define MADERA_GP1_LVL_MASK                             0x8000
+#define MADERA_GP1_LVL_SHIFT                                15
+#define MADERA_GP1_LVL_WIDTH                                 1
+#define MADERA_GP1_OP_CFG                               0x4000
+#define MADERA_GP1_OP_CFG_MASK                          0x4000
+#define MADERA_GP1_OP_CFG_SHIFT                             14
+#define MADERA_GP1_OP_CFG_WIDTH                              1
+#define MADERA_GP1_DB                                   0x2000
+#define MADERA_GP1_DB_MASK                              0x2000
+#define MADERA_GP1_DB_SHIFT                                 13
+#define MADERA_GP1_DB_WIDTH                                  1
+#define MADERA_GP1_POL                                  0x1000
+#define MADERA_GP1_POL_MASK                             0x1000
+#define MADERA_GP1_POL_SHIFT                                12
+#define MADERA_GP1_POL_WIDTH                                 1
+#define MADERA_GP1_IP_CFG                               0x0800
+#define MADERA_GP1_IP_CFG_MASK                          0x0800
+#define MADERA_GP1_IP_CFG_SHIFT                             11
+#define MADERA_GP1_IP_CFG_WIDTH                              1
+#define MADERA_GP1_FN_MASK                              0x03FF
+#define MADERA_GP1_FN_SHIFT                                  0
+#define MADERA_GP1_FN_WIDTH                                 10
+
+/* (0x1701)  GPIO1_CTRL_2 */
+#define MADERA_GP1_DIR                                  0x8000
+#define MADERA_GP1_DIR_MASK                             0x8000
+#define MADERA_GP1_DIR_SHIFT                                15
+#define MADERA_GP1_DIR_WIDTH                                 1
+#define MADERA_GP1_PU                                   0x4000
+#define MADERA_GP1_PU_MASK                              0x4000
+#define MADERA_GP1_PU_SHIFT                                 14
+#define MADERA_GP1_PU_WIDTH                                  1
+#define MADERA_GP1_PD                                   0x2000
+#define MADERA_GP1_PD_MASK                              0x2000
+#define MADERA_GP1_PD_SHIFT                                 13
+#define MADERA_GP1_PD_WIDTH                                  1
+#define MADERA_GP1_DRV_STR_MASK                         0x1800
+#define MADERA_GP1_DRV_STR_SHIFT                            11
+#define MADERA_GP1_DRV_STR_WIDTH                             2
+
+/* (0x1800)  IRQ1_Status_1 */
+#define MADERA_CTRLIF_ERR_EINT1                         0x1000
+#define MADERA_CTRLIF_ERR_EINT1_MASK                    0x1000
+#define MADERA_CTRLIF_ERR_EINT1_SHIFT                       12
+#define MADERA_CTRLIF_ERR_EINT1_WIDTH                        1
+#define MADERA_SYSCLK_FAIL_EINT1                        0x0200
+#define MADERA_SYSCLK_FAIL_EINT1_MASK                   0x0200
+#define MADERA_SYSCLK_FAIL_EINT1_SHIFT                       9
+#define MADERA_SYSCLK_FAIL_EINT1_WIDTH                       1
+#define MADERA_CLOCK_DETECT_EINT1                       0x0100
+#define MADERA_CLOCK_DETECT_EINT1_MASK                  0x0100
+#define MADERA_CLOCK_DETECT_EINT1_SHIFT                      8
+#define MADERA_CLOCK_DETECT_EINT1_WIDTH                      1
+#define MADERA_BOOT_DONE_EINT1                          0x0080
+#define MADERA_BOOT_DONE_EINT1_MASK                     0x0080
+#define MADERA_BOOT_DONE_EINT1_SHIFT                         7
+#define MADERA_BOOT_DONE_EINT1_WIDTH                         1
+
+/* (0x1801)  IRQ1_Status_2 */
+#define MADERA_FLLAO_LOCK_EINT1                         0x0800
+#define MADERA_FLLAO_LOCK_EINT1_MASK                    0x0800
+#define MADERA_FLLAO_LOCK_EINT1_SHIFT                       11
+#define MADERA_FLLAO_LOCK_EINT1_WIDTH                        1
+#define MADERA_FLL3_LOCK_EINT1                          0x0400
+#define MADERA_FLL3_LOCK_EINT1_MASK                     0x0400
+#define MADERA_FLL3_LOCK_EINT1_SHIFT                        10
+#define MADERA_FLL3_LOCK_EINT1_WIDTH                         1
+#define MADERA_FLL2_LOCK_EINT1                          0x0200
+#define MADERA_FLL2_LOCK_EINT1_MASK                     0x0200
+#define MADERA_FLL2_LOCK_EINT1_SHIFT                         9
+#define MADERA_FLL2_LOCK_EINT1_WIDTH                         1
+#define MADERA_FLL1_LOCK_EINT1                          0x0100
+#define MADERA_FLL1_LOCK_EINT1_MASK                     0x0100
+#define MADERA_FLL1_LOCK_EINT1_SHIFT                         8
+#define MADERA_FLL1_LOCK_EINT1_WIDTH                         1
+
+/* (0x1805)  IRQ1_Status_6 */
+#define MADERA_MICDET2_EINT1                            0x0200
+#define MADERA_MICDET2_EINT1_MASK                       0x0200
+#define MADERA_MICDET2_EINT1_SHIFT                           9
+#define MADERA_MICDET2_EINT1_WIDTH                           1
+#define MADERA_MICDET1_EINT1                            0x0100
+#define MADERA_MICDET1_EINT1_MASK                       0x0100
+#define MADERA_MICDET1_EINT1_SHIFT                           8
+#define MADERA_MICDET1_EINT1_WIDTH                           1
+#define MADERA_HPDET_EINT1                              0x0001
+#define MADERA_HPDET_EINT1_MASK                         0x0001
+#define MADERA_HPDET_EINT1_SHIFT                             0
+#define MADERA_HPDET_EINT1_WIDTH                             1
+
+/* (0x1806)  IRQ1_Status_7 */
+#define MADERA_MICD_CLAMP_FALL_EINT1                    0x0020
+#define MADERA_MICD_CLAMP_FALL_EINT1_MASK               0x0020
+#define MADERA_MICD_CLAMP_FALL_EINT1_SHIFT                   5
+#define MADERA_MICD_CLAMP_FALL_EINT1_WIDTH                   1
+#define MADERA_MICD_CLAMP_RISE_EINT1                    0x0010
+#define MADERA_MICD_CLAMP_RISE_EINT1_MASK               0x0010
+#define MADERA_MICD_CLAMP_RISE_EINT1_SHIFT                   4
+#define MADERA_MICD_CLAMP_RISE_EINT1_WIDTH                   1
+#define MADERA_JD2_FALL_EINT1                           0x0008
+#define MADERA_JD2_FALL_EINT1_MASK                      0x0008
+#define MADERA_JD2_FALL_EINT1_SHIFT                          3
+#define MADERA_JD2_FALL_EINT1_WIDTH                          1
+#define MADERA_JD2_RISE_EINT1                           0x0004
+#define MADERA_JD2_RISE_EINT1_MASK                      0x0004
+#define MADERA_JD2_RISE_EINT1_SHIFT                          2
+#define MADERA_JD2_RISE_EINT1_WIDTH                          1
+#define MADERA_JD1_FALL_EINT1                           0x0002
+#define MADERA_JD1_FALL_EINT1_MASK                      0x0002
+#define MADERA_JD1_FALL_EINT1_SHIFT                          1
+#define MADERA_JD1_FALL_EINT1_WIDTH                          1
+#define MADERA_JD1_RISE_EINT1                           0x0001
+#define MADERA_JD1_RISE_EINT1_MASK                      0x0001
+#define MADERA_JD1_RISE_EINT1_SHIFT                          0
+#define MADERA_JD1_RISE_EINT1_WIDTH                          1
+
+/* (0x1808)  IRQ1_Status_9 */
+#define MADERA_ASRC2_IN2_LOCK_EINT1                     0x0800
+#define MADERA_ASRC2_IN2_LOCK_EINT1_MASK                0x0800
+#define MADERA_ASRC2_IN2_LOCK_EINT1_SHIFT                   11
+#define MADERA_ASRC2_IN2_LOCK_EINT1_WIDTH                    1
+#define MADERA_ASRC2_IN1_LOCK_EINT1                     0x0400
+#define MADERA_ASRC2_IN1_LOCK_EINT1_MASK                0x0400
+#define MADERA_ASRC2_IN1_LOCK_EINT1_SHIFT                   10
+#define MADERA_ASRC2_IN1_LOCK_EINT1_WIDTH                    1
+#define MADERA_ASRC1_IN2_LOCK_EINT1                     0x0200
+#define MADERA_ASRC1_IN2_LOCK_EINT1_MASK                0x0200
+#define MADERA_ASRC1_IN2_LOCK_EINT1_SHIFT                    9
+#define MADERA_ASRC1_IN2_LOCK_EINT1_WIDTH                    1
+#define MADERA_ASRC1_IN1_LOCK_EINT1                     0x0100
+#define MADERA_ASRC1_IN1_LOCK_EINT1_MASK                0x0100
+#define MADERA_ASRC1_IN1_LOCK_EINT1_SHIFT                    8
+#define MADERA_ASRC1_IN1_LOCK_EINT1_WIDTH                    1
+#define MADERA_DRC2_SIG_DET_EINT1                       0x0002
+#define MADERA_DRC2_SIG_DET_EINT1_MASK                  0x0002
+#define MADERA_DRC2_SIG_DET_EINT1_SHIFT                      1
+#define MADERA_DRC2_SIG_DET_EINT1_WIDTH                      1
+#define MADERA_DRC1_SIG_DET_EINT1                       0x0001
+#define MADERA_DRC1_SIG_DET_EINT1_MASK                  0x0001
+#define MADERA_DRC1_SIG_DET_EINT1_SHIFT                      0
+#define MADERA_DRC1_SIG_DET_EINT1_WIDTH                      1
+
+/* (0x180A)  IRQ1_Status_11 */
+#define MADERA_DSP_IRQ16_EINT1                          0x8000
+#define MADERA_DSP_IRQ16_EINT1_MASK                     0x8000
+#define MADERA_DSP_IRQ16_EINT1_SHIFT                        15
+#define MADERA_DSP_IRQ16_EINT1_WIDTH                         1
+#define MADERA_DSP_IRQ15_EINT1                          0x4000
+#define MADERA_DSP_IRQ15_EINT1_MASK                     0x4000
+#define MADERA_DSP_IRQ15_EINT1_SHIFT                        14
+#define MADERA_DSP_IRQ15_EINT1_WIDTH                         1
+#define MADERA_DSP_IRQ14_EINT1                          0x2000
+#define MADERA_DSP_IRQ14_EINT1_MASK                     0x2000
+#define MADERA_DSP_IRQ14_EINT1_SHIFT                        13
+#define MADERA_DSP_IRQ14_EINT1_WIDTH                         1
+#define MADERA_DSP_IRQ13_EINT1                          0x1000
+#define MADERA_DSP_IRQ13_EINT1_MASK                     0x1000
+#define MADERA_DSP_IRQ13_EINT1_SHIFT                        12
+#define MADERA_DSP_IRQ13_EINT1_WIDTH                         1
+#define MADERA_DSP_IRQ12_EINT1                          0x0800
+#define MADERA_DSP_IRQ12_EINT1_MASK                     0x0800
+#define MADERA_DSP_IRQ12_EINT1_SHIFT                        11
+#define MADERA_DSP_IRQ12_EINT1_WIDTH                         1
+#define MADERA_DSP_IRQ11_EINT1                          0x0400
+#define MADERA_DSP_IRQ11_EINT1_MASK                     0x0400
+#define MADERA_DSP_IRQ11_EINT1_SHIFT                        10
+#define MADERA_DSP_IRQ11_EINT1_WIDTH                         1
+#define MADERA_DSP_IRQ10_EINT1                          0x0200
+#define MADERA_DSP_IRQ10_EINT1_MASK                     0x0200
+#define MADERA_DSP_IRQ10_EINT1_SHIFT                         9
+#define MADERA_DSP_IRQ10_EINT1_WIDTH                         1
+#define MADERA_DSP_IRQ9_EINT1                           0x0100
+#define MADERA_DSP_IRQ9_EINT1_MASK                      0x0100
+#define MADERA_DSP_IRQ9_EINT1_SHIFT                          8
+#define MADERA_DSP_IRQ9_EINT1_WIDTH                          1
+#define MADERA_DSP_IRQ8_EINT1                           0x0080
+#define MADERA_DSP_IRQ8_EINT1_MASK                      0x0080
+#define MADERA_DSP_IRQ8_EINT1_SHIFT                          7
+#define MADERA_DSP_IRQ8_EINT1_WIDTH                          1
+#define MADERA_DSP_IRQ7_EINT1                           0x0040
+#define MADERA_DSP_IRQ7_EINT1_MASK                      0x0040
+#define MADERA_DSP_IRQ7_EINT1_SHIFT                          6
+#define MADERA_DSP_IRQ7_EINT1_WIDTH                          1
+#define MADERA_DSP_IRQ6_EINT1                           0x0020
+#define MADERA_DSP_IRQ6_EINT1_MASK                      0x0020
+#define MADERA_DSP_IRQ6_EINT1_SHIFT                          5
+#define MADERA_DSP_IRQ6_EINT1_WIDTH                          1
+#define MADERA_DSP_IRQ5_EINT1                           0x0010
+#define MADERA_DSP_IRQ5_EINT1_MASK                      0x0010
+#define MADERA_DSP_IRQ5_EINT1_SHIFT                          4
+#define MADERA_DSP_IRQ5_EINT1_WIDTH                          1
+#define MADERA_DSP_IRQ4_EINT1                           0x0008
+#define MADERA_DSP_IRQ4_EINT1_MASK                      0x0008
+#define MADERA_DSP_IRQ4_EINT1_SHIFT                          3
+#define MADERA_DSP_IRQ4_EINT1_WIDTH                          1
+#define MADERA_DSP_IRQ3_EINT1                           0x0004
+#define MADERA_DSP_IRQ3_EINT1_MASK                      0x0004
+#define MADERA_DSP_IRQ3_EINT1_SHIFT                          2
+#define MADERA_DSP_IRQ3_EINT1_WIDTH                          1
+#define MADERA_DSP_IRQ2_EINT1                           0x0002
+#define MADERA_DSP_IRQ2_EINT1_MASK                      0x0002
+#define MADERA_DSP_IRQ2_EINT1_SHIFT                          1
+#define MADERA_DSP_IRQ2_EINT1_WIDTH                          1
+#define MADERA_DSP_IRQ1_EINT1                           0x0001
+#define MADERA_DSP_IRQ1_EINT1_MASK                      0x0001
+#define MADERA_DSP_IRQ1_EINT1_SHIFT                          0
+#define MADERA_DSP_IRQ1_EINT1_WIDTH                          1
+
+/* (0x180B)  IRQ1_Status_12 */
+#define MADERA_SPKOUTR_SC_EINT1                         0x0080
+#define MADERA_SPKOUTR_SC_EINT1_MASK                    0x0080
+#define MADERA_SPKOUTR_SC_EINT1_SHIFT                        7
+#define MADERA_SPKOUTR_SC_EINT1_WIDTH                        1
+#define MADERA_SPKOUTL_SC_EINT1                         0x0040
+#define MADERA_SPKOUTL_SC_EINT1_MASK                    0x0040
+#define MADERA_SPKOUTL_SC_EINT1_SHIFT                        6
+#define MADERA_SPKOUTL_SC_EINT1_WIDTH                        1
+#define MADERA_HP3R_SC_EINT1                            0x0020
+#define MADERA_HP3R_SC_EINT1_MASK                       0x0020
+#define MADERA_HP3R_SC_EINT1_SHIFT                           5
+#define MADERA_HP3R_SC_EINT1_WIDTH                           1
+#define MADERA_HP3L_SC_EINT1                            0x0010
+#define MADERA_HP3L_SC_EINT1_MASK                       0x0010
+#define MADERA_HP3L_SC_EINT1_SHIFT                           4
+#define MADERA_HP3L_SC_EINT1_WIDTH                           1
+#define MADERA_HP2R_SC_EINT1                            0x0008
+#define MADERA_HP2R_SC_EINT1_MASK                       0x0008
+#define MADERA_HP2R_SC_EINT1_SHIFT                           3
+#define MADERA_HP2R_SC_EINT1_WIDTH                           1
+#define MADERA_HP2L_SC_EINT1                            0x0004
+#define MADERA_HP2L_SC_EINT1_MASK                       0x0004
+#define MADERA_HP2L_SC_EINT1_SHIFT                           2
+#define MADERA_HP2L_SC_EINT1_WIDTH                           1
+#define MADERA_HP1R_SC_EINT1                            0x0002
+#define MADERA_HP1R_SC_EINT1_MASK                       0x0002
+#define MADERA_HP1R_SC_EINT1_SHIFT                           1
+#define MADERA_HP1R_SC_EINT1_WIDTH                           1
+#define MADERA_HP1L_SC_EINT1                            0x0001
+#define MADERA_HP1L_SC_EINT1_MASK                       0x0001
+#define MADERA_HP1L_SC_EINT1_SHIFT                           0
+#define MADERA_HP1L_SC_EINT1_WIDTH                           1
+
+/* (0x180E)  IRQ1_Status_15 */
+#define MADERA_SPK_OVERHEAT_WARN_EINT1                  0x0004
+#define MADERA_SPK_OVERHEAT_WARN_EINT1_MASK             0x0004
+#define MADERA_SPK_OVERHEAT_WARN_EINT1_SHIFT                 2
+#define MADERA_SPK_OVERHEAT_WARN_EINT1_WIDTH                 1
+#define MADERA_SPK_OVERHEAT_EINT1                       0x0002
+#define MADERA_SPK_OVERHEAT_EINT1_MASK                  0x0002
+#define MADERA_SPK_OVERHEAT_EINT1_SHIFT                      1
+#define MADERA_SPK_OVERHEAT_EINT1_WIDTH                      1
+#define MADERA_SPK_SHUTDOWN_EINT1                       0x0001
+#define MADERA_SPK_SHUTDOWN_EINT1_MASK                  0x0001
+#define MADERA_SPK_SHUTDOWN_EINT1_SHIFT                      0
+#define MADERA_SPK_SHUTDOWN_EINT1_WIDTH                      1
+
+/* (0x1820) - IRQ1 Status 33 */
+#define MADERA_DSP7_BUS_ERR_EINT1                       0x0040
+#define MADERA_DSP7_BUS_ERR_EINT1_MASK                  0x0040
+#define MADERA_DSP7_BUS_ERR_EINT1_SHIFT                      6
+#define MADERA_DSP7_BUS_ERR_EINT1_WIDTH                      1
+#define MADERA_DSP6_BUS_ERR_EINT1                       0x0020
+#define MADERA_DSP6_BUS_ERR_EINT1_MASK                  0x0020
+#define MADERA_DSP6_BUS_ERR_EINT1_SHIFT                      5
+#define MADERA_DSP6_BUS_ERR_EINT1_WIDTH                      1
+#define MADERA_DSP5_BUS_ERR_EINT1                       0x0010
+#define MADERA_DSP5_BUS_ERR_EINT1_MASK                  0x0010
+#define MADERA_DSP5_BUS_ERR_EINT1_SHIFT                      4
+#define MADERA_DSP5_BUS_ERR_EINT1_WIDTH                      1
+#define MADERA_DSP4_BUS_ERR_EINT1                       0x0008
+#define MADERA_DSP4_BUS_ERR_EINT1_MASK                  0x0008
+#define MADERA_DSP4_BUS_ERR_EINT1_SHIFT                      3
+#define MADERA_DSP4_BUS_ERR_EINT1_WIDTH                      1
+#define MADERA_DSP3_BUS_ERR_EINT1                       0x0004
+#define MADERA_DSP3_BUS_ERR_EINT1_MASK                  0x0004
+#define MADERA_DSP3_BUS_ERR_EINT1_SHIFT                      2
+#define MADERA_DSP3_BUS_ERR_EINT1_WIDTH                      1
+#define MADERA_DSP2_BUS_ERR_EINT1                       0x0002
+#define MADERA_DSP2_BUS_ERR_EINT1_MASK                  0x0002
+#define MADERA_DSP2_BUS_ERR_EINT1_SHIFT                      1
+#define MADERA_DSP2_BUS_ERR_EINT1_WIDTH                      1
+#define MADERA_DSP1_BUS_ERR_EINT1                       0x0001
+#define MADERA_DSP1_BUS_ERR_EINT1_MASK                  0x0001
+#define MADERA_DSP1_BUS_ERR_EINT1_SHIFT                      0
+#define MADERA_DSP1_BUS_ERR_EINT1_WIDTH                      1
+
+/* (0x1845)  IRQ1_Mask_6 */
+#define MADERA_IM_MICDET2_EINT1                         0x0200
+#define MADERA_IM_MICDET2_EINT1_MASK                    0x0200
+#define MADERA_IM_MICDET2_EINT1_SHIFT                        9
+#define MADERA_IM_MICDET2_EINT1_WIDTH                        1
+#define MADERA_IM_MICDET1_EINT1                         0x0100
+#define MADERA_IM_MICDET1_EINT1_MASK                    0x0100
+#define MADERA_IM_MICDET1_EINT1_SHIFT                        8
+#define MADERA_IM_MICDET1_EINT1_WIDTH                        1
+#define MADERA_IM_HPDET_EINT1                           0x0001
+#define MADERA_IM_HPDET_EINT1_MASK                      0x0001
+#define MADERA_IM_HPDET_EINT1_SHIFT                          0
+#define MADERA_IM_HPDET_EINT1_WIDTH                          1
+/* (0x184E)  IRQ1_Mask_15 */
+#define MADERA_IM_SPK_OVERHEAT_WARN_EINT1               0x0004
+#define MADERA_IM_SPK_OVERHEAT_WARN_EINT1_MASK          0x0004
+#define MADERA_IM_SPK_OVERHEAT_WARN_EINT1_SHIFT              2
+#define MADERA_IM_SPK_OVERHEAT_WARN_EINT1_WIDTH              1
+#define MADERA_IM_SPK_OVERHEAT_EINT1                    0x0002
+#define MADERA_IM_SPK_OVERHEAT_EINT1_MASK               0x0002
+#define MADERA_IM_SPK_OVERHEAT_EINT1_SHIFT                   1
+#define MADERA_IM_SPK_OVERHEAT_EINT1_WIDTH                   1
+#define MADERA_IM_SPK_SHUTDOWN_EINT1                    0x0001
+#define MADERA_IM_SPK_SHUTDOWN_EINT1_MASK               0x0001
+#define MADERA_IM_SPK_SHUTDOWN_EINT1_SHIFT                   0
+#define MADERA_IM_SPK_SHUTDOWN_EINT1_WIDTH                   1
+
+/* (0x1880) - IRQ1 Raw Status 1 */
+#define MADERA_CTRLIF_ERR_STS1                          0x1000
+#define MADERA_CTRLIF_ERR_STS1_MASK                     0x1000
+#define MADERA_CTRLIF_ERR_STS1_SHIFT                        12
+#define MADERA_CTRLIF_ERR_STS1_WIDTH                         1
+#define MADERA_SYSCLK_FAIL_STS1                         0x0200
+#define MADERA_SYSCLK_FAIL_STS1_MASK                    0x0200
+#define MADERA_SYSCLK_FAIL_STS1_SHIFT                        9
+#define MADERA_SYSCLK_FAIL_STS1_WIDTH                        1
+#define MADERA_CLOCK_DETECT_STS1                        0x0100
+#define MADERA_CLOCK_DETECT_STS1_MASK                   0x0100
+#define MADERA_CLOCK_DETECT_STS1_SHIFT                       8
+#define MADERA_CLOCK_DETECT_STS1_WIDTH                       1
+#define MADERA_BOOT_DONE_STS1                           0x0080
+#define MADERA_BOOT_DONE_STS1_MASK                      0x0080
+#define MADERA_BOOT_DONE_STS1_SHIFT                          7
+#define MADERA_BOOT_DONE_STS1_WIDTH                          1
+
+/* (0x1881) - IRQ1 Raw Status 2 */
+#define MADERA_FLL3_LOCK_STS1                           0x0400
+#define MADERA_FLL3_LOCK_STS1_MASK                      0x0400
+#define MADERA_FLL3_LOCK_STS1_SHIFT                         10
+#define MADERA_FLL3_LOCK_STS1_WIDTH                          1
+#define MADERA_FLL2_LOCK_STS1                           0x0200
+#define MADERA_FLL2_LOCK_STS1_MASK                      0x0200
+#define MADERA_FLL2_LOCK_STS1_SHIFT                          9
+#define MADERA_FLL2_LOCK_STS1_WIDTH                          1
+#define MADERA_FLL1_LOCK_STS1                           0x0100
+#define MADERA_FLL1_LOCK_STS1_MASK                      0x0100
+#define MADERA_FLL1_LOCK_STS1_SHIFT                          8
+#define MADERA_FLL1_LOCK_STS1_WIDTH                          1
+
+/* (0x1886) - IRQ1 Raw Status 7 */
+#define MADERA_MICD_CLAMP_FALL_STS1                     0x0020
+#define MADERA_MICD_CLAMP_FALL_STS1_MASK                0x0020
+#define MADERA_MICD_CLAMP_FALL_STS1_SHIFT                    5
+#define MADERA_MICD_CLAMP_FALL_STS1_WIDTH                    1
+#define MADERA_MICD_CLAMP_RISE_STS1                     0x0010
+#define MADERA_MICD_CLAMP_RISE_STS1_MASK                0x0010
+#define MADERA_MICD_CLAMP_RISE_STS1_SHIFT                    4
+#define MADERA_MICD_CLAMP_RISE_STS1_WIDTH                    1
+#define MADERA_JD2_FALL_STS1                            0x0008
+#define MADERA_JD2_FALL_STS1_MASK                       0x0008
+#define MADERA_JD2_FALL_STS1_SHIFT                           3
+#define MADERA_JD2_FALL_STS1_WIDTH                           1
+#define MADERA_JD2_RISE_STS1                            0x0004
+#define MADERA_JD2_RISE_STS1_MASK                       0x0004
+#define MADERA_JD2_RISE_STS1_SHIFT                           2
+#define MADERA_JD2_RISE_STS1_WIDTH                           1
+#define MADERA_JD1_FALL_STS1                            0x0002
+#define MADERA_JD1_FALL_STS1_MASK                       0x0002
+#define MADERA_JD1_FALL_STS1_SHIFT                           1
+#define MADERA_JD1_FALL_STS1_WIDTH                           1
+#define MADERA_JD1_RISE_STS1                            0x0001
+#define MADERA_JD1_RISE_STS1_MASK                       0x0001
+#define MADERA_JD1_RISE_STS1_SHIFT                           0
+#define MADERA_JD1_RISE_STS1_WIDTH                           1
+
+/* (0x188E) - IRQ1 Raw Status 15 */
+#define MADERA_SPK_OVERHEAT_WARN_STS1                   0x0004
+#define MADERA_SPK_OVERHEAT_WARN_STS1_MASK              0x0004
+#define MADERA_SPK_OVERHEAT_WARN_STS1_SHIFT                  2
+#define MADERA_SPK_OVERHEAT_WARN_STS1_WIDTH                  1
+#define MADERA_SPK_OVERHEAT_STS1                        0x0002
+#define MADERA_SPK_OVERHEAT_STS1_MASK                   0x0002
+#define MADERA_SPK_OVERHEAT_STS1_SHIFT                       1
+#define MADERA_SPK_OVERHEAT_STS1_WIDTH                       1
+#define MADERA_SPK_SHUTDOWN_STS1                        0x0001
+#define MADERA_SPK_SHUTDOWN_STS1_MASK                   0x0001
+#define MADERA_SPK_SHUTDOWN_STS1_SHIFT                       0
+#define MADERA_SPK_SHUTDOWN_STS1_WIDTH                       1
+
+/* (0x1A06)  Interrupt_Debounce_7 */
+#define MADERA_MICD_CLAMP_DB                            0x0010
+#define MADERA_MICD_CLAMP_DB_MASK                       0x0010
+#define MADERA_MICD_CLAMP_DB_SHIFT                           4
+#define MADERA_MICD_CLAMP_DB_WIDTH                           1
+#define MADERA_JD2_DB                                   0x0004
+#define MADERA_JD2_DB_MASK                              0x0004
+#define MADERA_JD2_DB_SHIFT                                  2
+#define MADERA_JD2_DB_WIDTH                                  1
+#define MADERA_JD1_DB                                   0x0001
+#define MADERA_JD1_DB_MASK                              0x0001
+#define MADERA_JD1_DB_SHIFT                                  0
+#define MADERA_JD1_DB_WIDTH                                  1
+
+/* (0x1A0E)  Interrupt_Debounce_15 */
+#define MADERA_SPK_OVERHEAT_WARN_DB                     0x0004
+#define MADERA_SPK_OVERHEAT_WARN_DB_MASK                0x0004
+#define MADERA_SPK_OVERHEAT_WARN_DB_SHIFT                    2
+#define MADERA_SPK_OVERHEAT_WARN_DB_WIDTH                    1
+#define MADERA_SPK_OVERHEAT_DB                          0x0002
+#define MADERA_SPK_OVERHEAT_DB_MASK                     0x0002
+#define MADERA_SPK_OVERHEAT_DB_SHIFT                         1
+#define MADERA_SPK_OVERHEAT_DB_WIDTH                         1
+
+/* (0x1A80)  IRQ1_CTRL */
+#define MADERA_IM_IRQ1                                  0x0800
+#define MADERA_IM_IRQ1_MASK                             0x0800
+#define MADERA_IM_IRQ1_SHIFT                                11
+#define MADERA_IM_IRQ1_WIDTH                                 1
+#define MADERA_IRQ_POL                                  0x0400
+#define MADERA_IRQ_POL_MASK                             0x0400
+#define MADERA_IRQ_POL_SHIFT                                10
+#define MADERA_IRQ_POL_WIDTH                                 1
+
+/* (0x20004)  OTP_HPDET_Cal_1 */
+#define MADERA_OTP_HPDET_CALIB_OFFSET_11            0xFF000000
+#define MADERA_OTP_HPDET_CALIB_OFFSET_11_MASK       0xFF000000
+#define MADERA_OTP_HPDET_CALIB_OFFSET_11_SHIFT              24
+#define MADERA_OTP_HPDET_CALIB_OFFSET_11_WIDTH               8
+#define MADERA_OTP_HPDET_CALIB_OFFSET_10            0x00FF0000
+#define MADERA_OTP_HPDET_CALIB_OFFSET_10_MASK       0x00FF0000
+#define MADERA_OTP_HPDET_CALIB_OFFSET_10_SHIFT              16
+#define MADERA_OTP_HPDET_CALIB_OFFSET_10_WIDTH               8
+#define MADERA_OTP_HPDET_CALIB_OFFSET_01            0x0000FF00
+#define MADERA_OTP_HPDET_CALIB_OFFSET_01_MASK       0x0000FF00
+#define MADERA_OTP_HPDET_CALIB_OFFSET_01_SHIFT               8
+#define MADERA_OTP_HPDET_CALIB_OFFSET_01_WIDTH               8
+#define MADERA_OTP_HPDET_CALIB_OFFSET_00            0x000000FF
+#define MADERA_OTP_HPDET_CALIB_OFFSET_00_MASK       0x000000FF
+#define MADERA_OTP_HPDET_CALIB_OFFSET_00_SHIFT               0
+#define MADERA_OTP_HPDET_CALIB_OFFSET_00_WIDTH               8
+
+/* (0x20006)  OTP_HPDET_Cal_2 */
+#define MADERA_OTP_HPDET_GRADIENT_1X                0x0000FF00
+#define MADERA_OTP_HPDET_GRADIENT_1X_MASK           0x0000FF00
+#define MADERA_OTP_HPDET_GRADIENT_1X_SHIFT                   8
+#define MADERA_OTP_HPDET_GRADIENT_1X_WIDTH                   8
+#define MADERA_OTP_HPDET_GRADIENT_0X                0x000000FF
+#define MADERA_OTP_HPDET_GRADIENT_0X_MASK           0x000000FF
+#define MADERA_OTP_HPDET_GRADIENT_0X_SHIFT                   0
+#define MADERA_OTP_HPDET_GRADIENT_0X_WIDTH                   8
+
+#endif
diff --git a/include/linux/mfd/rave-sp.h b/include/linux/mfd/rave-sp.h
index fe0ce7bc59cf..11eef77ef976 100644
--- a/include/linux/mfd/rave-sp.h
+++ b/include/linux/mfd/rave-sp.h
@@ -21,6 +21,7 @@ enum rave_sp_command {
         RAVE_SP_CMD_STATUS                      = 0xA0,
         RAVE_SP_CMD_SW_WDT                      = 0xA1,
         RAVE_SP_CMD_PET_WDT                     = 0xA2,
+        RAVE_SP_CMD_RMB_EEPROM                  = 0xA4,
         RAVE_SP_CMD_SET_BACKLIGHT               = 0xA6,
         RAVE_SP_CMD_RESET                       = 0xA7,
         RAVE_SP_CMD_RESET_REASON                = 0xA8,
diff --git a/include/linux/mfd/rohm-bd718x7.h b/include/linux/mfd/rohm-bd718x7.h
new file mode 100644
index 000000000000..a528747f8aed
--- /dev/null
+++ b/include/linux/mfd/rohm-bd718x7.h
@@ -0,0 +1,332 @@
+/* SPDX-License-Identifier: GPL-2.0-or-later */
+/* Copyright (C) 2018 ROHM Semiconductors */
+
+#ifndef __LINUX_MFD_BD71837_H__
+#define __LINUX_MFD_BD71837_H__
+
+#include <linux/regmap.h>
+
+enum {
+        BD71837_BUCK1   =       0,
+        BD71837_BUCK2,
+        BD71837_BUCK3,
+        BD71837_BUCK4,
+        BD71837_BUCK5,
+        BD71837_BUCK6,
+        BD71837_BUCK7,
+        BD71837_BUCK8,
+        BD71837_LDO1,
+        BD71837_LDO2,
+        BD71837_LDO3,
+        BD71837_LDO4,
+        BD71837_LDO5,
+        BD71837_LDO6,
+        BD71837_LDO7,
+        BD71837_REGULATOR_CNT,
+};
+
+#define BD71837_BUCK1_VOLTAGE_NUM       0x40
+#define BD71837_BUCK2_VOLTAGE_NUM       0x40
+#define BD71837_BUCK3_VOLTAGE_NUM       0x40
+#define BD71837_BUCK4_VOLTAGE_NUM       0x40
+
+#define BD71837_BUCK5_VOLTAGE_NUM       0x08
+#define BD71837_BUCK6_VOLTAGE_NUM       0x04
+#define BD71837_BUCK7_VOLTAGE_NUM       0x08
+#define BD71837_BUCK8_VOLTAGE_NUM       0x40
+
+#define BD71837_LDO1_VOLTAGE_NUM        0x04
+#define BD71837_LDO2_VOLTAGE_NUM        0x02
+#define BD71837_LDO3_VOLTAGE_NUM        0x10
+#define BD71837_LDO4_VOLTAGE_NUM        0x10
+#define BD71837_LDO5_VOLTAGE_NUM        0x10
+#define BD71837_LDO6_VOLTAGE_NUM        0x10
+#define BD71837_LDO7_VOLTAGE_NUM        0x10
+
+enum {
+        BD71837_REG_REV                = 0x00,
+        BD71837_REG_SWRESET            = 0x01,
+        BD71837_REG_I2C_DEV            = 0x02,
+        BD71837_REG_PWRCTRL0           = 0x03,
+        BD71837_REG_PWRCTRL1           = 0x04,
+        BD71837_REG_BUCK1_CTRL         = 0x05,
+        BD71837_REG_BUCK2_CTRL         = 0x06,
+        BD71837_REG_BUCK3_CTRL         = 0x07,
+        BD71837_REG_BUCK4_CTRL         = 0x08,
+        BD71837_REG_BUCK5_CTRL         = 0x09,
+        BD71837_REG_BUCK6_CTRL         = 0x0A,
+        BD71837_REG_BUCK7_CTRL         = 0x0B,
+        BD71837_REG_BUCK8_CTRL         = 0x0C,
+        BD71837_REG_BUCK1_VOLT_RUN     = 0x0D,
+        BD71837_REG_BUCK1_VOLT_IDLE    = 0x0E,
+        BD71837_REG_BUCK1_VOLT_SUSP    = 0x0F,
+        BD71837_REG_BUCK2_VOLT_RUN     = 0x10,
+        BD71837_REG_BUCK2_VOLT_IDLE    = 0x11,
+        BD71837_REG_BUCK3_VOLT_RUN     = 0x12,
+        BD71837_REG_BUCK4_VOLT_RUN     = 0x13,
+        BD71837_REG_BUCK5_VOLT         = 0x14,
+        BD71837_REG_BUCK6_VOLT         = 0x15,
+        BD71837_REG_BUCK7_VOLT         = 0x16,
+        BD71837_REG_BUCK8_VOLT         = 0x17,
+        BD71837_REG_LDO1_VOLT          = 0x18,
+        BD71837_REG_LDO2_VOLT          = 0x19,
+        BD71837_REG_LDO3_VOLT          = 0x1A,
+        BD71837_REG_LDO4_VOLT          = 0x1B,
+        BD71837_REG_LDO5_VOLT          = 0x1C,
+        BD71837_REG_LDO6_VOLT          = 0x1D,
+        BD71837_REG_LDO7_VOLT          = 0x1E,
+        BD71837_REG_TRANS_COND0        = 0x1F,
+        BD71837_REG_TRANS_COND1        = 0x20,
+        BD71837_REG_VRFAULTEN          = 0x21,
+        BD71837_REG_MVRFLTMASK0        = 0x22,
+        BD71837_REG_MVRFLTMASK1        = 0x23,
+        BD71837_REG_MVRFLTMASK2        = 0x24,
+        BD71837_REG_RCVCFG             = 0x25,
+        BD71837_REG_RCVNUM             = 0x26,
+        BD71837_REG_PWRONCONFIG0       = 0x27,
+        BD71837_REG_PWRONCONFIG1       = 0x28,
+        BD71837_REG_RESETSRC           = 0x29,
+        BD71837_REG_MIRQ               = 0x2A,
+        BD71837_REG_IRQ                = 0x2B,
+        BD71837_REG_IN_MON             = 0x2C,
+        BD71837_REG_POW_STATE          = 0x2D,
+        BD71837_REG_OUT32K             = 0x2E,
+        BD71837_REG_REGLOCK            = 0x2F,
+        BD71837_REG_OTPVER             = 0xFF,
+        BD71837_MAX_REGISTER           = 0x100,
+};
+
+#define REGLOCK_PWRSEQ  0x1
+#define REGLOCK_VREG    0x10
+
+/* Generic BUCK control masks */
+#define BD71837_BUCK_SEL        0x02
+#define BD71837_BUCK_EN         0x01
+#define BD71837_BUCK_RUN_ON     0x04
+
+/* Generic LDO masks */
+#define BD71837_LDO_SEL         0x80
+#define BD71837_LDO_EN          0x40
+
+/* BD71837 BUCK ramp rate CTRL reg bits */
+#define BUCK_RAMPRATE_MASK      0xC0
+#define BUCK_RAMPRATE_10P00MV   0x0
+#define BUCK_RAMPRATE_5P00MV    0x1
+#define BUCK_RAMPRATE_2P50MV    0x2
+#define BUCK_RAMPRATE_1P25MV    0x3
+
+/* BD71837_REG_BUCK1_VOLT_RUN bits */
+#define BUCK1_RUN_MASK          0x3F
+#define BUCK1_RUN_DEFAULT       0x14
+
+/* BD71837_REG_BUCK1_VOLT_SUSP bits */
+#define BUCK1_SUSP_MASK         0x3F
+#define BUCK1_SUSP_DEFAULT      0x14
+
+/* BD71837_REG_BUCK1_VOLT_IDLE bits */
+#define BUCK1_IDLE_MASK         0x3F
+#define BUCK1_IDLE_DEFAULT      0x14
+
+/* BD71837_REG_BUCK2_VOLT_RUN bits */
+#define BUCK2_RUN_MASK          0x3F
+#define BUCK2_RUN_DEFAULT       0x1E
+
+/* BD71837_REG_BUCK2_VOLT_IDLE bits */
+#define BUCK2_IDLE_MASK         0x3F
+#define BUCK2_IDLE_DEFAULT      0x14
+
+/* BD71837_REG_BUCK3_VOLT_RUN bits */
+#define BUCK3_RUN_MASK          0x3F
+#define BUCK3_RUN_DEFAULT       0x1E
+
+/* BD71837_REG_BUCK4_VOLT_RUN bits */
+#define BUCK4_RUN_MASK          0x3F
+#define BUCK4_RUN_DEFAULT       0x1E
+
+/* BD71837_REG_BUCK5_VOLT bits */
+#define BUCK5_MASK              0x07
+#define BUCK5_DEFAULT           0x02
+
+/* BD71837_REG_BUCK6_VOLT bits */
+#define BUCK6_MASK              0x03
+#define BUCK6_DEFAULT           0x03
+
+/* BD71837_REG_BUCK7_VOLT bits */
+#define BUCK7_MASK              0x07
+#define BUCK7_DEFAULT           0x03
+
+/* BD71837_REG_BUCK8_VOLT bits */
+#define BUCK8_MASK              0x3F
+#define BUCK8_DEFAULT           0x1E
+
+/* BD71837_REG_IRQ bits */
+#define IRQ_SWRST               0x40
+#define IRQ_PWRON_S             0x20
+#define IRQ_PWRON_L             0x10
+#define IRQ_PWRON               0x08
+#define IRQ_WDOG                0x04
+#define IRQ_ON_REQ              0x02
+#define IRQ_STBY_REQ            0x01
+
+/* BD71837_REG_OUT32K bits */
+#define BD71837_OUT32K_EN       0x01
+
+/* BD71837 gated clock rate */
+#define BD71837_CLK_RATE 32768
+
+/* ROHM BD71837 irqs */
+enum {
+        BD71837_INT_STBY_REQ,
+        BD71837_INT_ON_REQ,
+        BD71837_INT_WDOG,
+        BD71837_INT_PWRBTN,
+        BD71837_INT_PWRBTN_L,
+        BD71837_INT_PWRBTN_S,
+        BD71837_INT_SWRST
+};
+
+/* ROHM BD71837 interrupt masks */
+#define BD71837_INT_SWRST_MASK          0x40
+#define BD71837_INT_PWRBTN_S_MASK       0x20
+#define BD71837_INT_PWRBTN_L_MASK       0x10
+#define BD71837_INT_PWRBTN_MASK         0x8
+#define BD71837_INT_WDOG_MASK           0x4
+#define BD71837_INT_ON_REQ_MASK         0x2
+#define BD71837_INT_STBY_REQ_MASK       0x1
+
+/* BD71837_REG_LDO1_VOLT bits */
+#define LDO1_MASK               0x03
+
+/* BD71837_REG_LDO1_VOLT bits */
+#define LDO2_MASK               0x20
+
+/* BD71837_REG_LDO3_VOLT bits */
+#define LDO3_MASK               0x0F
+
+/* BD71837_REG_LDO4_VOLT bits */
+#define LDO4_MASK               0x0F
+
+/* BD71837_REG_LDO5_VOLT bits */
+#define LDO5_MASK               0x0F
+
+/* BD71837_REG_LDO6_VOLT bits */
+#define LDO6_MASK               0x0F
+
+/* BD71837_REG_LDO7_VOLT bits */
+#define LDO7_MASK               0x0F
+
+/* Register write induced reset settings */
+
+/*
+ * Even though the bit zero is not SWRESET type we still want to write zero
+ * to it when changing type. Bit zero is 'SWRESET' trigger bit and if we
+ * write 1 to it we will trigger the action. So always write 0 to it when
+ * changning SWRESET action - no matter what we read from it.
+ */
+#define BD71837_SWRESET_TYPE_MASK       7
+#define BD71837_SWRESET_TYPE_DISABLED   0
+#define BD71837_SWRESET_TYPE_COLD       4
+#define BD71837_SWRESET_TYPE_WARM       6
+
+#define BD71837_SWRESET_RESET_MASK      1
+#define BD71837_SWRESET_RESET           1
+
+/* Poweroff state transition conditions */
+
+#define BD718XX_ON_REQ_POWEROFF_MASK    1
+#define BD718XX_SWRESET_POWEROFF_MASK   2
+#define BD718XX_WDOG_POWEROFF_MASK      4
+#define BD718XX_KEY_L_POWEROFF_MASK     8
+
+#define BD718XX_POWOFF_TO_SNVS  0
+#define BD718XX_POWOFF_TO_RDY   0xF
+
+#define BD718XX_POWOFF_TIME_MASK 0xF0
+enum {
+        BD718XX_POWOFF_TIME_5MS = 0,
+        BD718XX_POWOFF_TIME_10MS,
+        BD718XX_POWOFF_TIME_15MS,
+        BD718XX_POWOFF_TIME_20MS,
+        BD718XX_POWOFF_TIME_25MS,
+        BD718XX_POWOFF_TIME_30MS,
+        BD718XX_POWOFF_TIME_35MS,
+        BD718XX_POWOFF_TIME_40MS,
+        BD718XX_POWOFF_TIME_45MS,
+        BD718XX_POWOFF_TIME_50MS,
+        BD718XX_POWOFF_TIME_75MS,
+        BD718XX_POWOFF_TIME_100MS,
+        BD718XX_POWOFF_TIME_250MS,
+        BD718XX_POWOFF_TIME_500MS,
+        BD718XX_POWOFF_TIME_750MS,
+        BD718XX_POWOFF_TIME_1500MS
+};
+
+/* Poweron sequence state transition conditions */
+#define BD718XX_RDY_TO_SNVS_MASK 0xF
+#define BD718XX_SNVS_TO_RUN_MASK 0xF0
+
+#define BD718XX_PWR_TRIG_KEY_L          1
+#define BD718XX_PWR_TRIG_KEY_S          2
+#define BD718XX_PWR_TRIG_PMIC_ON        4
+#define BD718XX_PWR_TRIG_VSYS_UVLO      8
+#define BD718XX_RDY_TO_SNVS_SIFT        0
+#define BD718XX_SNVS_TO_RUN_SIFT        4
+
+#define BD718XX_PWRBTN_PRESS_DURATION_MASK 0xF
+
+/* Timeout value for detecting short press */
+enum {
+        BD718XX_PWRBTN_SHORT_PRESS_10MS = 0,
+        BD718XX_PWRBTN_SHORT_PRESS_500MS,
+        BD718XX_PWRBTN_SHORT_PRESS_1000MS,
+        BD718XX_PWRBTN_SHORT_PRESS_1500MS,
+        BD718XX_PWRBTN_SHORT_PRESS_2000MS,
+        BD718XX_PWRBTN_SHORT_PRESS_2500MS,
+        BD718XX_PWRBTN_SHORT_PRESS_3000MS,
+        BD718XX_PWRBTN_SHORT_PRESS_3500MS,
+        BD718XX_PWRBTN_SHORT_PRESS_4000MS,
+        BD718XX_PWRBTN_SHORT_PRESS_4500MS,
+        BD718XX_PWRBTN_SHORT_PRESS_5000MS,
+        BD718XX_PWRBTN_SHORT_PRESS_5500MS,
+        BD718XX_PWRBTN_SHORT_PRESS_6000MS,
+        BD718XX_PWRBTN_SHORT_PRESS_6500MS,
+        BD718XX_PWRBTN_SHORT_PRESS_7000MS,
+        BD718XX_PWRBTN_SHORT_PRESS_7500MS
+};
+
+/* Timeout value for detecting LONG press */
+enum {
+        BD718XX_PWRBTN_LONG_PRESS_10MS = 0,
+        BD718XX_PWRBTN_LONG_PRESS_1S,
+        BD718XX_PWRBTN_LONG_PRESS_2S,
+        BD718XX_PWRBTN_LONG_PRESS_3S,
+        BD718XX_PWRBTN_LONG_PRESS_4S,
+        BD718XX_PWRBTN_LONG_PRESS_5S,
+        BD718XX_PWRBTN_LONG_PRESS_6S,
+        BD718XX_PWRBTN_LONG_PRESS_7S,
+        BD718XX_PWRBTN_LONG_PRESS_8S,
+        BD718XX_PWRBTN_LONG_PRESS_9S,
+        BD718XX_PWRBTN_LONG_PRESS_10S,
+        BD718XX_PWRBTN_LONG_PRESS_11S,
+        BD718XX_PWRBTN_LONG_PRESS_12S,
+        BD718XX_PWRBTN_LONG_PRESS_13S,
+        BD718XX_PWRBTN_LONG_PRESS_14S,
+        BD718XX_PWRBTN_LONG_PRESS_15S
+};
+
+struct bd71837_pmic;
+struct bd71837_clk;
+
+struct bd71837 {
+        struct device *dev;
+        struct regmap *regmap;
+        unsigned long int id;
+
+        int chip_irq;
+        struct regmap_irq_chip_data *irq_data;
+
+        struct bd71837_pmic *pmic;
+        struct bd71837_clk *clk;
+};
+
+#endif /* __LINUX_MFD_BD71837_H__ */
diff --git a/include/linux/mfd/syscon/imx6q-iomuxc-gpr.h b/include/linux/mfd/syscon/imx6q-iomuxc-gpr.h
index e06f5f79eaef..6c1ad160ed87 100644
--- a/include/linux/mfd/syscon/imx6q-iomuxc-gpr.h
+++ b/include/linux/mfd/syscon/imx6q-iomuxc-gpr.h
@@ -457,4 +457,7 @@
 #define MCLK_DIR(x) (x == 1 ? IMX6UL_GPR1_SAI1_MCLK_DIR : x == 2 ? \
                      IMX6UL_GPR1_SAI2_MCLK_DIR : IMX6UL_GPR1_SAI3_MCLK_DIR)
 
+/* For imx6sll iomux gpr register field define */
+#define IMX6SLL_GPR5_AFCG_X_BYPASS_MASK         (0x1f << 11)
+
 #endif /* __LINUX_IMX6Q_IOMUXC_GPR_H */
diff --git a/include/linux/mfd/tmio.h b/include/linux/mfd/tmio.h
index 91f92215ca74..77866214ab51 100644
--- a/include/linux/mfd/tmio.h
+++ b/include/linux/mfd/tmio.h
@@ -90,6 +90,9 @@
 /* Some controllers have a CBSY bit */
 #define TMIO_MMC_HAVE_CBSY              BIT(11)
 
+/* Some controllers that support HS400 use use 4 taps while others use 8. */
+#define TMIO_MMC_HAVE_4TAP_HS400        BIT(13)
+
 int tmio_core_mmc_enable(void __iomem *cnf, int shift, unsigned long base);
 int tmio_core_mmc_resume(void __iomem *cnf, int shift, unsigned long base);
 void tmio_core_mmc_pwr(void __iomem *cnf, int shift, int state);
diff --git a/include/linux/mfd/wm8994/pdata.h b/include/linux/mfd/wm8994/pdata.h
index 90c60524a496..b19c370fe81a 100644
--- a/include/linux/mfd/wm8994/pdata.h
+++ b/include/linux/mfd/wm8994/pdata.h
@@ -222,6 +222,12 @@ struct wm8994_pdata {
          */
         bool spkmode_pu;
 
+        /*
+         * CS/ADDR must be pulled internally by the device on this
+         * system.
+         */
+        bool csnaddr_pd;
+
         /**
          * Maximum number of channels clocks will be generated for,
          * useful for systems where and I2S bus with multiple data
diff --git a/include/linux/mlx4/device.h b/include/linux/mlx4/device.h
index 122e7e9d3091..dca6ab4eaa99 100644
--- a/include/linux/mlx4/device.h
+++ b/include/linux/mlx4/device.h
@@ -630,6 +630,7 @@ struct mlx4_caps {
         u32                     vf_caps;
         bool                    wol_port[MLX4_MAX_PORTS + 1];
         struct mlx4_rate_limit_caps rl_caps;
+        u32                     health_buffer_addrs;
 };
 
 struct mlx4_buf_list {
@@ -851,6 +852,12 @@ struct mlx4_vf_dev {
         u8                      n_ports;
 };
 
+struct mlx4_fw_crdump {
+        bool snapshot_enable;
+        struct devlink_region *region_crspace;
+        struct devlink_region *region_fw_health;
+};
+
 enum mlx4_pci_status {
         MLX4_PCI_STATUS_DISABLED,
         MLX4_PCI_STATUS_ENABLED,
@@ -871,6 +878,7 @@ struct mlx4_dev_persistent {
         u8      interface_state;
         struct mutex            pci_status_mutex; /* sync pci state */
         enum mlx4_pci_status    pci_status;
+        struct mlx4_fw_crdump   crdump;
 };
 
 struct mlx4_dev {
diff --git a/include/linux/mlx5/device.h b/include/linux/mlx5/device.h
index 02f72ebf31a7..11fa4e66afc5 100644
--- a/include/linux/mlx5/device.h
+++ b/include/linux/mlx5/device.h
@@ -332,6 +332,13 @@ enum mlx5_event {
 
         MLX5_EVENT_TYPE_FPGA_ERROR         = 0x20,
         MLX5_EVENT_TYPE_FPGA_QP_ERROR      = 0x21,
+
+        MLX5_EVENT_TYPE_DEVICE_TRACER      = 0x26,
+};
+
+enum {
+        MLX5_TRACER_SUBTYPE_OWNERSHIP_CHANGE = 0x0,
+        MLX5_TRACER_SUBTYPE_TRACES_AVAILABLE = 0x1,
 };
 
 enum {
@@ -750,7 +757,7 @@ enum {
 
 #define MLX5_MINI_CQE_ARRAY_SIZE 8
 
-static inline int mlx5_get_cqe_format(struct mlx5_cqe64 *cqe)
+static inline u8 mlx5_get_cqe_format(struct mlx5_cqe64 *cqe)
 {
         return (cqe->op_own >> 2) & 0x3;
 }
@@ -770,14 +777,14 @@ static inline u8 get_cqe_l3_hdr_type(struct mlx5_cqe64 *cqe)
         return (cqe->l4_l3_hdr_type >> 2) & 0x3;
 }
 
-static inline u8 cqe_is_tunneled(struct mlx5_cqe64 *cqe)
+static inline bool cqe_is_tunneled(struct mlx5_cqe64 *cqe)
 {
         return cqe->outer_l3_tunneled & 0x1;
 }
 
-static inline int cqe_has_vlan(struct mlx5_cqe64 *cqe)
+static inline bool cqe_has_vlan(struct mlx5_cqe64 *cqe)
 {
-        return !!(cqe->l4_l3_hdr_type & 0x1);
+        return cqe->l4_l3_hdr_type & 0x1;
 }
 
 static inline u64 get_cqe_ts(struct mlx5_cqe64 *cqe)
@@ -939,9 +946,9 @@ enum {
 };
 
 enum {
-        MLX5_ESW_VPORT_ADMIN_STATE_DOWN  = 0x0,
-        MLX5_ESW_VPORT_ADMIN_STATE_UP    = 0x1,
-        MLX5_ESW_VPORT_ADMIN_STATE_AUTO  = 0x2,
+        MLX5_VPORT_ADMIN_STATE_DOWN  = 0x0,
+        MLX5_VPORT_ADMIN_STATE_UP    = 0x1,
+        MLX5_VPORT_ADMIN_STATE_AUTO  = 0x2,
 };
 
 enum {
@@ -1071,6 +1078,9 @@ enum mlx5_qcam_feature_groups {
 #define MLX5_CAP_GEN(mdev, cap) \
         MLX5_GET(cmd_hca_cap, mdev->caps.hca_cur[MLX5_CAP_GENERAL], cap)
 
+#define MLX5_CAP_GEN_64(mdev, cap) \
+        MLX5_GET64(cmd_hca_cap, mdev->caps.hca_cur[MLX5_CAP_GENERAL], cap)
+
 #define MLX5_CAP_GEN_MAX(mdev, cap) \
         MLX5_GET(cmd_hca_cap, mdev->caps.hca_max[MLX5_CAP_GENERAL], cap)
 
diff --git a/include/linux/mlx5/driver.h b/include/linux/mlx5/driver.h
index 83957920653a..7a452716de4b 100644
--- a/include/linux/mlx5/driver.h
+++ b/include/linux/mlx5/driver.h
@@ -138,9 +138,14 @@ enum {
         MLX5_REG_HOST_ENDIANNESS = 0x7004,
         MLX5_REG_MCIA            = 0x9014,
         MLX5_REG_MLCR            = 0x902b,
+        MLX5_REG_MTRC_CAP        = 0x9040,
+        MLX5_REG_MTRC_CONF       = 0x9041,
+        MLX5_REG_MTRC_STDB       = 0x9042,
+        MLX5_REG_MTRC_CTRL       = 0x9043,
         MLX5_REG_MPCNT           = 0x9051,
         MLX5_REG_MTPPS           = 0x9053,
         MLX5_REG_MTPPSE          = 0x9054,
+        MLX5_REG_MPEGC           = 0x9056,
         MLX5_REG_MCQI            = 0x9061,
         MLX5_REG_MCC             = 0x9062,
         MLX5_REG_MCDA            = 0x9063,
@@ -812,6 +817,9 @@ struct mlx5_clock {
         struct mlx5_pps            pps_info;
 };
 
+struct mlx5_fw_tracer;
+struct mlx5_vxlan;
+
 struct mlx5_core_dev {
         struct pci_dev         *pdev;
         /* sync pci state */
@@ -843,6 +851,7 @@ struct mlx5_core_dev {
         atomic_t                num_qps;
         u32                     issi;
         struct mlx5e_resources  mlx5e_res;
+        struct mlx5_vxlan       *vxlan;
         struct {
                 struct mlx5_rsvd_gids   reserved_gids;
                 u32                     roce_en;
@@ -856,6 +865,7 @@ struct mlx5_core_dev {
         struct mlx5_clock        clock;
         struct mlx5_ib_clock_info  *clock_info;
         struct page             *clock_info_page;
+        struct mlx5_fw_tracer   *tracer;
 };
 
 struct mlx5_db {
@@ -1079,8 +1089,6 @@ int mlx5_core_destroy_mkey(struct mlx5_core_dev *dev,
                            struct mlx5_core_mkey *mkey);
 int mlx5_core_query_mkey(struct mlx5_core_dev *dev, struct mlx5_core_mkey *mkey,
                          u32 *out, int outlen);
-int mlx5_core_dump_fill_mkey(struct mlx5_core_dev *dev, struct mlx5_core_mkey *_mkey,
-                             u32 *mkey);
 int mlx5_core_alloc_pd(struct mlx5_core_dev *dev, u32 *pdn);
 int mlx5_core_dealloc_pd(struct mlx5_core_dev *dev, u32 pdn);
 int mlx5_core_mad_ifc(struct mlx5_core_dev *dev, const void *inb, void *outb,
@@ -1227,14 +1235,11 @@ struct net_device *mlx5_rdma_netdev_alloc(struct mlx5_core_dev *mdev,
 {
         return ERR_PTR(-EOPNOTSUPP);
 }
-
-static inline void mlx5_rdma_netdev_free(struct net_device *netdev) {}
 #else
 struct net_device *mlx5_rdma_netdev_alloc(struct mlx5_core_dev *mdev,
                                           struct ib_device *ibdev,
                                           const char *name,
                                           void (*setup)(struct net_device *));
-void mlx5_rdma_netdev_free(struct net_device *netdev);
 #endif /* CONFIG_MLX5_CORE_IPOIB */
 
 struct mlx5_profile {
diff --git a/include/linux/mlx5/fs.h b/include/linux/mlx5/fs.h
index 757b4a30281e..804516e4f483 100644
--- a/include/linux/mlx5/fs.h
+++ b/include/linux/mlx5/fs.h
@@ -89,6 +89,7 @@ struct mlx5_flow_destination {
         enum mlx5_flow_destination_type type;
         union {
                 u32                     tir_num;
+                u32                     ft_num;
                 struct mlx5_flow_table  *ft;
                 struct mlx5_fc          *counter;
                 struct {
@@ -152,6 +153,8 @@ struct mlx5_fs_vlan {
         u8  prio;
 };
 
+#define MLX5_FS_VLAN_DEPTH      2
+
 struct mlx5_flow_act {
         u32 action;
         bool has_flow_tag;
@@ -159,7 +162,7 @@ struct mlx5_flow_act {
         u32 encap_id;
         u32 modify_id;
         uintptr_t esp_id;
-        struct mlx5_fs_vlan vlan;
+        struct mlx5_fs_vlan vlan[MLX5_FS_VLAN_DEPTH];
         struct ib_counters *counters;
 };
 
@@ -175,7 +178,7 @@ mlx5_add_flow_rules(struct mlx5_flow_table *ft,
                     struct mlx5_flow_spec *spec,
                     struct mlx5_flow_act *flow_act,
                     struct mlx5_flow_destination *dest,
-                    int dest_num);
+                    int num_dest);
 void mlx5_del_flow_rules(struct mlx5_flow_handle *fr);
 
 int mlx5_modify_rule_destination(struct mlx5_flow_handle *handler,
diff --git a/include/linux/mlx5/mlx5_ifc.h b/include/linux/mlx5/mlx5_ifc.h
index ac281f5ec9b8..f043d65b9bac 100644
--- a/include/linux/mlx5/mlx5_ifc.h
+++ b/include/linux/mlx5/mlx5_ifc.h
@@ -76,6 +76,16 @@ enum {
 };
 
 enum {
+        MLX5_GENERAL_OBJ_TYPES_CAP_UCTX = (1ULL << 4),
+        MLX5_GENERAL_OBJ_TYPES_CAP_UMEM = (1ULL << 5),
+};
+
+enum {
+        MLX5_OBJ_TYPE_UCTX = 0x0004,
+        MLX5_OBJ_TYPE_UMEM = 0x0005,
+};
+
+enum {
         MLX5_CMD_OP_QUERY_HCA_CAP                 = 0x100,
         MLX5_CMD_OP_QUERY_ADAPTER                 = 0x101,
         MLX5_CMD_OP_INIT_HCA                      = 0x102,
@@ -237,11 +247,16 @@ enum {
         MLX5_CMD_OP_DEALLOC_ENCAP_HEADER          = 0x93e,
         MLX5_CMD_OP_ALLOC_MODIFY_HEADER_CONTEXT   = 0x940,
         MLX5_CMD_OP_DEALLOC_MODIFY_HEADER_CONTEXT = 0x941,
+        MLX5_CMD_OP_QUERY_MODIFY_HEADER_CONTEXT   = 0x942,
         MLX5_CMD_OP_FPGA_CREATE_QP                = 0x960,
         MLX5_CMD_OP_FPGA_MODIFY_QP                = 0x961,
         MLX5_CMD_OP_FPGA_QUERY_QP                 = 0x962,
         MLX5_CMD_OP_FPGA_DESTROY_QP               = 0x963,
         MLX5_CMD_OP_FPGA_QUERY_QP_COUNTERS        = 0x964,
+        MLX5_CMD_OP_CREATE_GENERAL_OBJECT         = 0xa00,
+        MLX5_CMD_OP_MODIFY_GENERAL_OBJECT         = 0xa01,
+        MLX5_CMD_OP_QUERY_GENERAL_OBJECT          = 0xa02,
+        MLX5_CMD_OP_DESTROY_GENERAL_OBJECT        = 0xa03,
         MLX5_CMD_OP_MAX
 };
 
@@ -326,7 +341,10 @@ struct mlx5_ifc_flow_table_prop_layout_bits {
         u8         reserved_at_9[0x1];
         u8         pop_vlan[0x1];
         u8         push_vlan[0x1];
-        u8         reserved_at_c[0x14];
+        u8         reserved_at_c[0x1];
+        u8         pop_vlan_2[0x1];
+        u8         push_vlan_2[0x1];
+        u8         reserved_at_f[0x11];
 
         u8         reserved_at_20[0x2];
         u8         log_max_ft_size[0x6];
@@ -654,7 +672,9 @@ struct mlx5_ifc_per_protocol_networking_offload_caps_bits {
         u8         swp[0x1];
         u8         swp_csum[0x1];
         u8         swp_lso[0x1];
-        u8         reserved_at_23[0x1b];
+        u8         reserved_at_23[0xd];
+        u8         max_vxlan_udp_ports[0x8];
+        u8         reserved_at_38[0x6];
         u8         max_geneve_opt_len[0x1];
         u8         tunnel_stateless_geneve_rx[0x1];
 
@@ -874,7 +894,9 @@ struct mlx5_ifc_cmd_hca_cap_bits {
         u8         log_max_eq_sz[0x8];
         u8         reserved_at_e8[0x2];
         u8         log_max_mkey[0x6];
-        u8         reserved_at_f0[0xc];
+        u8         reserved_at_f0[0x8];
+        u8         dump_fill_mkey[0x1];
+        u8         reserved_at_f9[0x3];
         u8         log_max_eq[0x4];
 
         u8         max_indirection[0x8];
@@ -1113,7 +1135,12 @@ struct mlx5_ifc_cmd_hca_cap_bits {
         u8         reserved_at_3f8[0x3];
         u8         log_max_current_uc_list[0x5];
 
-        u8         reserved_at_400[0x80];
+        u8         general_obj_types[0x40];
+
+        u8         reserved_at_440[0x20];
+
+        u8         reserved_at_460[0x10];
+        u8         max_num_eqs[0x10];
 
         u8         reserved_at_480[0x3];
         u8         log_max_l2_table[0x5];
@@ -1162,6 +1189,7 @@ enum mlx5_flow_destination_type {
 
         MLX5_FLOW_DESTINATION_TYPE_PORT         = 0x99,
         MLX5_FLOW_DESTINATION_TYPE_COUNTER      = 0x100,
+        MLX5_FLOW_DESTINATION_TYPE_FLOW_TABLE_NUM = 0x101,
 };
 
 struct mlx5_ifc_dest_format_struct_bits {
@@ -1668,7 +1696,11 @@ struct mlx5_ifc_eth_extended_cntrs_grp_data_layout_bits {
 
         u8         rx_buffer_full_low[0x20];
 
-        u8         reserved_at_1c0[0x600];
+        u8         rx_icrc_encapsulated_high[0x20];
+
+        u8         rx_icrc_encapsulated_low[0x20];
+
+        u8         reserved_at_200[0x5c0];
 };
 
 struct mlx5_ifc_eth_3635_cntrs_grp_data_layout_bits {
@@ -2367,6 +2399,8 @@ enum {
         MLX5_FLOW_CONTEXT_ACTION_MOD_HDR   = 0x40,
         MLX5_FLOW_CONTEXT_ACTION_VLAN_POP  = 0x80,
         MLX5_FLOW_CONTEXT_ACTION_VLAN_PUSH = 0x100,
+        MLX5_FLOW_CONTEXT_ACTION_VLAN_POP_2  = 0x400,
+        MLX5_FLOW_CONTEXT_ACTION_VLAN_PUSH_2 = 0x800,
 };
 
 struct mlx5_ifc_vlan_bits {
@@ -2397,7 +2431,9 @@ struct mlx5_ifc_flow_context_bits {
 
         u8         modify_header_id[0x20];
 
-        u8         reserved_at_100[0x100];
+        struct mlx5_ifc_vlan_bits push_vlan_2;
+
+        u8         reserved_at_120[0xe0];
 
         struct mlx5_ifc_fte_match_param_bits match_value;
 
@@ -3733,8 +3769,8 @@ struct mlx5_ifc_query_vport_state_out_bits {
 };
 
 enum {
-        MLX5_QUERY_VPORT_STATE_IN_OP_MOD_VNIC_VPORT  = 0x0,
-        MLX5_QUERY_VPORT_STATE_IN_OP_MOD_ESW_VPORT   = 0x1,
+        MLX5_VPORT_STATE_OP_MOD_VNIC_VPORT  = 0x0,
+        MLX5_VPORT_STATE_OP_MOD_ESW_VPORT   = 0x1,
 };
 
 struct mlx5_ifc_query_vport_state_in_bits {
@@ -8030,9 +8066,23 @@ struct mlx5_ifc_peir_reg_bits {
         u8         error_type[0x8];
 };
 
-struct mlx5_ifc_pcam_enhanced_features_bits {
-        u8         reserved_at_0[0x76];
+struct mlx5_ifc_mpegc_reg_bits {
+        u8         reserved_at_0[0x30];
+        u8         field_select[0x10];
 
+        u8         tx_overflow_sense[0x1];
+        u8         mark_cqe[0x1];
+        u8         mark_cnp[0x1];
+        u8         reserved_at_43[0x1b];
+        u8         tx_lossy_overflow_oper[0x2];
+
+        u8         reserved_at_60[0x100];
+};
+
+struct mlx5_ifc_pcam_enhanced_features_bits {
+        u8         reserved_at_0[0x6d];
+        u8         rx_icrc_encapsulated_counter[0x1];
+        u8         reserved_at_6e[0x8];
         u8         pfcc_mask[0x1];
         u8         reserved_at_77[0x4];
         u8         rx_buffer_fullness_counters[0x1];
@@ -8077,7 +8127,11 @@ struct mlx5_ifc_pcam_reg_bits {
 };
 
 struct mlx5_ifc_mcam_enhanced_features_bits {
-        u8         reserved_at_0[0x7b];
+        u8         reserved_at_0[0x74];
+        u8         mark_tx_action_cnp[0x1];
+        u8         mark_tx_action_cqe[0x1];
+        u8         dynamic_tx_overflow[0x1];
+        u8         reserved_at_77[0x4];
         u8         pcie_outbound_stalled[0x1];
         u8         tx_overflow_buffer_pkt[0x1];
         u8         mtpps_enh_out_per_adj[0x1];
@@ -8092,7 +8146,11 @@ struct mlx5_ifc_mcam_access_reg_bits {
         u8         mcqi[0x1];
         u8         reserved_at_1f[0x1];
 
-        u8         regs_95_to_64[0x20];
+        u8         regs_95_to_87[0x9];
+        u8         mpegc[0x1];
+        u8         regs_85_to_68[0x12];
+        u8         tracer_registers[0x4];
+
         u8         regs_63_to_32[0x20];
         u8         regs_31_to_0[0x20];
 };
@@ -9115,4 +9173,113 @@ struct mlx5_ifc_dealloc_memic_out_bits {
         u8         reserved_at_40[0x40];
 };
 
+struct mlx5_ifc_general_obj_in_cmd_hdr_bits {
+        u8         opcode[0x10];
+        u8         uid[0x10];
+
+        u8         reserved_at_20[0x10];
+        u8         obj_type[0x10];
+
+        u8         obj_id[0x20];
+
+        u8         reserved_at_60[0x20];
+};
+
+struct mlx5_ifc_general_obj_out_cmd_hdr_bits {
+        u8         status[0x8];
+        u8         reserved_at_8[0x18];
+
+        u8         syndrome[0x20];
+
+        u8         obj_id[0x20];
+
+        u8         reserved_at_60[0x20];
+};
+
+struct mlx5_ifc_umem_bits {
+        u8         modify_field_select[0x40];
+
+        u8         reserved_at_40[0x5b];
+        u8         log_page_size[0x5];
+
+        u8         page_offset[0x20];
+
+        u8         num_of_mtt[0x40];
+
+        struct mlx5_ifc_mtt_bits  mtt[0];
+};
+
+struct mlx5_ifc_uctx_bits {
+        u8         modify_field_select[0x40];
+
+        u8         reserved_at_40[0x1c0];
+};
+
+struct mlx5_ifc_create_umem_in_bits {
+        struct mlx5_ifc_general_obj_in_cmd_hdr_bits   hdr;
+        struct mlx5_ifc_umem_bits                     umem;
+};
+
+struct mlx5_ifc_create_uctx_in_bits {
+        struct mlx5_ifc_general_obj_in_cmd_hdr_bits   hdr;
+        struct mlx5_ifc_uctx_bits                     uctx;
+};
+
+struct mlx5_ifc_mtrc_string_db_param_bits {
+        u8         string_db_base_address[0x20];
+
+        u8         reserved_at_20[0x8];
+        u8         string_db_size[0x18];
+};
+
+struct mlx5_ifc_mtrc_cap_bits {
+        u8         trace_owner[0x1];
+        u8         trace_to_memory[0x1];
+        u8         reserved_at_2[0x4];
+        u8         trc_ver[0x2];
+        u8         reserved_at_8[0x14];
+        u8         num_string_db[0x4];
+
+        u8         first_string_trace[0x8];
+        u8         num_string_trace[0x8];
+        u8         reserved_at_30[0x28];
+
+        u8         log_max_trace_buffer_size[0x8];
+
+        u8         reserved_at_60[0x20];
+
+        struct mlx5_ifc_mtrc_string_db_param_bits string_db_param[8];
+
+        u8         reserved_at_280[0x180];
+};
+
+struct mlx5_ifc_mtrc_conf_bits {
+        u8         reserved_at_0[0x1c];
+        u8         trace_mode[0x4];
+        u8         reserved_at_20[0x18];
+        u8         log_trace_buffer_size[0x8];
+        u8         trace_mkey[0x20];
+        u8         reserved_at_60[0x3a0];
+};
+
+struct mlx5_ifc_mtrc_stdb_bits {
+        u8         string_db_index[0x4];
+        u8         reserved_at_4[0x4];
+        u8         read_size[0x18];
+        u8         start_offset[0x20];
+        u8         string_db_data[0];
+};
+
+struct mlx5_ifc_mtrc_ctrl_bits {
+        u8         trace_status[0x2];
+        u8         reserved_at_2[0x2];
+        u8         arm_event[0x1];
+        u8         reserved_at_5[0xb];
+        u8         modify_field_select[0x10];
+        u8         reserved_at_20[0x2b];
+        u8         current_timestamp52_32[0x15];
+        u8         current_timestamp31_0[0x20];
+        u8         reserved_at_80[0x180];
+};
+
 #endif /* MLX5_IFC_H */
diff --git a/include/linux/mlx5/mlx5_ifc_fpga.h b/include/linux/mlx5/mlx5_ifc_fpga.h
index 64d0f40d4cc3..37e065a80a43 100644
--- a/include/linux/mlx5/mlx5_ifc_fpga.h
+++ b/include/linux/mlx5/mlx5_ifc_fpga.h
@@ -576,6 +576,7 @@ struct mlx5_ifc_fpga_ipsec_sa {
 enum fpga_tls_cmds {
         CMD_SETUP_STREAM                = 0x1001,
         CMD_TEARDOWN_STREAM             = 0x1002,
+        CMD_RESYNC_RX                   = 0x1003,
 };
 
 #define MLX5_TLS_1_2 (0)
diff --git a/include/linux/mlx5/vport.h b/include/linux/mlx5/vport.h
index 9208cb8809ac..7e7c6dfcfb09 100644
--- a/include/linux/mlx5/vport.h
+++ b/include/linux/mlx5/vport.h
@@ -43,8 +43,6 @@ enum {
 };
 
 u8 mlx5_query_vport_state(struct mlx5_core_dev *mdev, u8 opmod, u16 vport);
-u8 mlx5_query_vport_admin_state(struct mlx5_core_dev *mdev, u8 opmod,
-                                u16 vport);
 int mlx5_modify_vport_admin_state(struct mlx5_core_dev *mdev, u8 opmod,
                                   u16 vport, u8 state);
 int mlx5_query_nic_vport_mac_address(struct mlx5_core_dev *mdev,
diff --git a/include/linux/mm.h b/include/linux/mm.h
index 68a5121694ef..a61ebe8ad4ca 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -456,6 +456,7 @@ static inline void vma_init(struct vm_area_struct *vma, struct mm_struct *mm)
 {
         static const struct vm_operations_struct dummy_vm_ops = {};
 
+        memset(vma, 0, sizeof(*vma));
         vma->vm_mm = mm;
         vma->vm_ops = &dummy_vm_ops;
         INIT_LIST_HEAD(&vma->anon_vma_chain);
@@ -727,10 +728,10 @@ static inline pte_t maybe_mkwrite(pte_t pte, struct vm_area_struct *vma)
         return pte;
 }
 
-int alloc_set_pte(struct vm_fault *vmf, struct mem_cgroup *memcg,
+vm_fault_t alloc_set_pte(struct vm_fault *vmf, struct mem_cgroup *memcg,
                 struct page *page);
-int finish_fault(struct vm_fault *vmf);
-int finish_mkwrite_fault(struct vm_fault *vmf);
+vm_fault_t finish_fault(struct vm_fault *vmf);
+vm_fault_t finish_mkwrite_fault(struct vm_fault *vmf);
 #endif
 
 /*
@@ -959,15 +960,6 @@ static inline int page_zone_id(struct page *page)
         return (page->flags >> ZONEID_PGSHIFT) & ZONEID_MASK;
 }
 
-static inline int zone_to_nid(struct zone *zone)
-{
-#ifdef CONFIG_NUMA
-        return zone->node;
-#else
-        return 0;
-#endif
-}
-
 #ifdef NODE_NOT_IN_PAGE_FLAGS
 extern int page_to_nid(const struct page *page);
 #else
@@ -1411,8 +1403,8 @@ int generic_error_remove_page(struct address_space *mapping, struct page *page);
 int invalidate_inode_page(struct page *page);
 
 #ifdef CONFIG_MMU
-extern int handle_mm_fault(struct vm_area_struct *vma, unsigned long address,
-                unsigned int flags);
+extern vm_fault_t handle_mm_fault(struct vm_area_struct *vma,
+                        unsigned long address, unsigned int flags);
 extern int fixup_user_fault(struct task_struct *tsk, struct mm_struct *mm,
                             unsigned long address, unsigned int fault_flags,
                             bool *unlocked);
@@ -1421,7 +1413,7 @@ void unmap_mapping_pages(struct address_space *mapping,
 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,
+static inline vm_fault_t handle_mm_fault(struct vm_area_struct *vma,
                 unsigned long address, unsigned int flags)
 {
         /* should never happen if there's no MMU */
@@ -2023,7 +2015,7 @@ static inline spinlock_t *pud_lock(struct mm_struct *mm, pud_t *pud)
 
 extern void __init pagecache_init(void);
 extern void free_area_init(unsigned long * zones_size);
-extern void free_area_init_node(int nid, unsigned long * zones_size,
+extern void __init free_area_init_node(int nid, unsigned long * zones_size,
                 unsigned long zone_start_pfn, unsigned long *zholes_size);
 extern void free_initmem(void);
 
@@ -2571,7 +2563,7 @@ static inline struct page *follow_page(struct vm_area_struct *vma,
 #define FOLL_COW        0x4000  /* internal GUP flag */
 #define FOLL_ANON       0x8000  /* don't do file mappings */
 
-static inline int vm_fault_to_errno(int vm_fault, int foll_flags)
+static inline int vm_fault_to_errno(vm_fault_t vm_fault, int foll_flags)
 {
         if (vm_fault & VM_FAULT_OOM)
                 return -ENOMEM;
@@ -2665,12 +2657,7 @@ extern int randomize_va_space;
 const char * arch_vma_name(struct vm_area_struct *vma);
 void print_vma_addr(char *prefix, unsigned long rip);
 
-void sparse_mem_maps_populate_node(struct page **map_map,
-                                   unsigned long pnum_begin,
-                                   unsigned long pnum_end,
-                                   unsigned long map_count,
-                                   int nodeid);
-
+void *sparse_buffer_alloc(unsigned long size);
 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);
@@ -2744,6 +2731,7 @@ enum mf_action_page_type {
         MF_MSG_TRUNCATED_LRU,
         MF_MSG_BUDDY,
         MF_MSG_BUDDY_2ND,
+        MF_MSG_DAX,
         MF_MSG_UNKNOWN,
 };
 
@@ -2752,7 +2740,8 @@ extern void clear_huge_page(struct page *page,
                             unsigned long addr_hint,
                             unsigned int pages_per_huge_page);
 extern void copy_user_huge_page(struct page *dst, struct page *src,
-                                unsigned long addr, struct vm_area_struct *vma,
+                                unsigned long addr_hint,
+                                struct vm_area_struct *vma,
                                 unsigned int pages_per_huge_page);
 extern long copy_huge_page_from_user(struct page *dst_page,
                                 const void __user *usr_src,
diff --git a/include/linux/mm_types.h b/include/linux/mm_types.h
index efdc24dd9e97..cd2bc939efd0 100644
--- a/include/linux/mm_types.h
+++ b/include/linux/mm_types.h
@@ -139,7 +139,10 @@ struct page {
                         unsigned long _pt_pad_1;        /* compound_head */
                         pgtable_t pmd_huge_pte; /* protected by page->ptl */
                         unsigned long _pt_pad_2;        /* mapping */
-                        struct mm_struct *pt_mm;        /* x86 pgds only */
+                        union {
+                                struct mm_struct *pt_mm; /* x86 pgds only */
+                                atomic_t pt_frag_refcount; /* powerpc */
+                        };
 #if ALLOC_SPLIT_PTLOCKS
                         spinlock_t *ptl;
 #else
diff --git a/include/linux/mmc/host.h b/include/linux/mmc/host.h
index 64300a48dcce..beed7121c781 100644
--- a/include/linux/mmc/host.h
+++ b/include/linux/mmc/host.h
@@ -146,6 +146,13 @@ struct mmc_host_ops {
 
         /* Prepare HS400 target operating frequency depending host driver */
         int     (*prepare_hs400_tuning)(struct mmc_host *host, struct mmc_ios *ios);
+
+        /* Prepare for switching from HS400 to HS200 */
+        void    (*hs400_downgrade)(struct mmc_host *host);
+
+        /* Complete selection of HS400 */
+        void    (*hs400_complete)(struct mmc_host *host);
+
         /* Prepare enhanced strobe depending host driver */
         void    (*hs400_enhanced_strobe)(struct mmc_host *host,
                                          struct mmc_ios *ios);
@@ -474,9 +481,6 @@ static inline void *mmc_priv(struct mmc_host *host)
 #define mmc_classdev(x) (&(x)->class_dev)
 #define mmc_hostname(x) (dev_name(&(x)->class_dev))
 
-int mmc_power_save_host(struct mmc_host *host);
-int mmc_power_restore_host(struct mmc_host *host);
-
 void mmc_detect_change(struct mmc_host *, unsigned long delay);
 void mmc_request_done(struct mmc_host *, struct mmc_request *);
 void mmc_command_done(struct mmc_host *host, struct mmc_request *mrq);
diff --git a/include/linux/mmc/mmc.h b/include/linux/mmc/mmc.h
index 3ffc27aaeeaf..897a87c4c827 100644
--- a/include/linux/mmc/mmc.h
+++ b/include/linux/mmc/mmc.h
@@ -144,7 +144,7 @@ static inline bool mmc_op_multi(u32 opcode)
 #define R1_WP_ERASE_SKIP        (1 << 15)       /* sx, c */
 #define R1_CARD_ECC_DISABLED    (1 << 14)       /* sx, a */
 #define R1_ERASE_RESET          (1 << 13)       /* sr, c */
-#define R1_STATUS(x)            (x & 0xFFFFE000)
+#define R1_STATUS(x)            (x & 0xFFF9A000)
 #define R1_CURRENT_STATE(x)     ((x & 0x00001E00) >> 9) /* sx, b (4 bits) */
 #define R1_READY_FOR_DATA       (1 << 8)        /* sx, a */
 #define R1_SWITCH_ERROR         (1 << 7)        /* sx, c */
diff --git a/include/linux/mmu_notifier.h b/include/linux/mmu_notifier.h
index 392e6af82701..133ba78820ee 100644
--- a/include/linux/mmu_notifier.h
+++ b/include/linux/mmu_notifier.h
@@ -151,13 +151,15 @@ struct mmu_notifier_ops {
          * 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.
+         * If blockable argument is set to false then the callback cannot
+         * sleep and has to return with -EAGAIN. 0 should be returned
+         * otherwise.
+         *
          */
-        void (*invalidate_range_start)(struct mmu_notifier *mn,
+        int (*invalidate_range_start)(struct mmu_notifier *mn,
                                        struct mm_struct *mm,
-                                       unsigned long start, unsigned long end);
+                                       unsigned long start, unsigned long end,
+                                       bool blockable);
         void (*invalidate_range_end)(struct mmu_notifier *mn,
                                      struct mm_struct *mm,
                                      unsigned long start, unsigned long end);
@@ -229,8 +231,9 @@ extern int __mmu_notifier_test_young(struct mm_struct *mm,
                                      unsigned long address);
 extern void __mmu_notifier_change_pte(struct mm_struct *mm,
                                       unsigned long address, pte_t pte);
-extern void __mmu_notifier_invalidate_range_start(struct mm_struct *mm,
-                                  unsigned long start, unsigned long end);
+extern int __mmu_notifier_invalidate_range_start(struct mm_struct *mm,
+                                  unsigned long start, unsigned long end,
+                                  bool blockable);
 extern void __mmu_notifier_invalidate_range_end(struct mm_struct *mm,
                                   unsigned long start, unsigned long end,
                                   bool only_end);
@@ -281,7 +284,15 @@ static inline void mmu_notifier_invalidate_range_start(struct mm_struct *mm,
                                   unsigned long start, unsigned long end)
 {
         if (mm_has_notifiers(mm))
-                __mmu_notifier_invalidate_range_start(mm, start, end);
+                __mmu_notifier_invalidate_range_start(mm, start, end, true);
+}
+
+static inline int mmu_notifier_invalidate_range_start_nonblock(struct mm_struct *mm,
+                                  unsigned long start, unsigned long end)
+{
+        if (mm_has_notifiers(mm))
+                return __mmu_notifier_invalidate_range_start(mm, start, end, false);
+        return 0;
 }
 
 static inline void mmu_notifier_invalidate_range_end(struct mm_struct *mm,
@@ -461,6 +472,12 @@ static inline void mmu_notifier_invalidate_range_start(struct mm_struct *mm,
 {
 }
 
+static inline int mmu_notifier_invalidate_range_start_nonblock(struct mm_struct *mm,
+                                  unsigned long start, unsigned long end)
+{
+        return 0;
+}
+
 static inline void mmu_notifier_invalidate_range_end(struct mm_struct *mm,
                                   unsigned long start, unsigned long end)
 {
diff --git a/include/linux/mmzone.h b/include/linux/mmzone.h
index 32699b2dc52a..1e22d96734e0 100644
--- a/include/linux/mmzone.h
+++ b/include/linux/mmzone.h
@@ -755,25 +755,6 @@ static inline bool pgdat_is_empty(pg_data_t *pgdat)
         return !pgdat->node_start_pfn && !pgdat->node_spanned_pages;
 }
 
-static inline int zone_id(const struct zone *zone)
-{
-        struct pglist_data *pgdat = zone->zone_pgdat;
-
-        return zone - pgdat->node_zones;
-}
-
-#ifdef CONFIG_ZONE_DEVICE
-static inline bool is_dev_zone(const struct zone *zone)
-{
-        return zone_id(zone) == ZONE_DEVICE;
-}
-#else
-static inline bool is_dev_zone(const struct zone *zone)
-{
-        return false;
-}
-#endif
-
 #include <linux/memory_hotplug.h>
 
 void build_all_zonelists(pg_data_t *pgdat);
@@ -824,6 +805,18 @@ static inline int local_memory_node(int node_id) { return node_id; };
  */
 #define zone_idx(zone)          ((zone) - (zone)->zone_pgdat->node_zones)
 
+#ifdef CONFIG_ZONE_DEVICE
+static inline bool is_dev_zone(const struct zone *zone)
+{
+        return zone_idx(zone) == ZONE_DEVICE;
+}
+#else
+static inline bool is_dev_zone(const struct zone *zone)
+{
+        return false;
+}
+#endif
+
 /*
  * Returns true if a zone has pages managed by the buddy allocator.
  * All the reclaim decisions have to use this function rather than
@@ -841,6 +834,25 @@ static inline bool populated_zone(struct zone *zone)
         return zone->present_pages;
 }
 
+#ifdef CONFIG_NUMA
+static inline int zone_to_nid(struct zone *zone)
+{
+        return zone->node;
+}
+
+static inline void zone_set_nid(struct zone *zone, int nid)
+{
+        zone->node = nid;
+}
+#else
+static inline int zone_to_nid(struct zone *zone)
+{
+        return 0;
+}
+
+static inline void zone_set_nid(struct zone *zone, int nid) {}
+#endif
+
 extern int movable_zone;
 
 #ifdef CONFIG_HIGHMEM
@@ -956,12 +968,7 @@ static inline int zonelist_zone_idx(struct zoneref *zoneref)
 
 static inline int zonelist_node_idx(struct zoneref *zoneref)
 {
-#ifdef CONFIG_NUMA
-        /* zone_to_nid not available in this context */
-        return zoneref->zone->node;
-#else
-        return 0;
-#endif /* CONFIG_NUMA */
+        return zone_to_nid(zoneref->zone);
 }
 
 struct zoneref *__next_zones_zonelist(struct zoneref *z,
diff --git a/include/linux/mod_devicetable.h b/include/linux/mod_devicetable.h
index 96a71a648eed..1298a7daa57d 100644
--- a/include/linux/mod_devicetable.h
+++ b/include/linux/mod_devicetable.h
@@ -746,4 +746,19 @@ struct tb_service_id {
 #define TBSVC_MATCH_PROTOCOL_VERSION    0x0004
 #define TBSVC_MATCH_PROTOCOL_REVISION   0x0008
 
+/* USB Type-C Alternate Modes */
+
+#define TYPEC_ANY_MODE  0x7
+
+/**
+ * struct typec_device_id - USB Type-C alternate mode identifiers
+ * @svid: Standard or Vendor ID
+ * @mode: Mode index
+ */
+struct typec_device_id {
+        __u16 svid;
+        __u8 mode;
+        kernel_ulong_t driver_data;
+};
+
 #endif /* LINUX_MOD_DEVICETABLE_H */
diff --git a/include/linux/module.h b/include/linux/module.h
index d44df9b2c131..f807f15bebbe 100644
--- a/include/linux/module.h
+++ b/include/linux/module.h
@@ -266,7 +266,7 @@ extern int modules_disabled; /* for sysctl */
 /* Get/put a kernel symbol (calls must be symmetric) */
 void *__symbol_get(const char *symbol);
 void *__symbol_get_gpl(const char *symbol);
-#define symbol_get(x) ((typeof(&x))(__symbol_get(VMLINUX_SYMBOL_STR(x))))
+#define symbol_get(x) ((typeof(&x))(__symbol_get(__stringify(x))))
 
 /* modules using other modules: kdb wants to see this. */
 struct module_use {
@@ -575,7 +575,7 @@ extern void __noreturn __module_put_and_exit(struct module *mod,
 #ifdef CONFIG_MODULE_UNLOAD
 int module_refcount(struct module *mod);
 void __symbol_put(const char *symbol);
-#define symbol_put(x) __symbol_put(VMLINUX_SYMBOL_STR(x))
+#define symbol_put(x) __symbol_put(__stringify(x))
 void symbol_put_addr(void *addr);
 
 /* Sometimes we know we already have a refcount, and it's easier not
diff --git a/include/linux/mroute_base.h b/include/linux/mroute_base.h
index d633f737b3c6..6675b9f81979 100644
--- a/include/linux/mroute_base.h
+++ b/include/linux/mroute_base.h
@@ -2,7 +2,7 @@
 #define __LINUX_MROUTE_BASE_H
 
 #include <linux/netdevice.h>
-#include <linux/rhashtable.h>
+#include <linux/rhashtable-types.h>
 #include <linux/spinlock.h>
 #include <net/net_namespace.h>
 #include <net/sock.h>
@@ -254,6 +254,7 @@ struct mr_table {
         atomic_t                cache_resolve_queue_len;
         bool                    mroute_do_assert;
         bool                    mroute_do_pim;
+        bool                    mroute_do_wrvifwhole;
         int                     mroute_reg_vif_num;
 };
 
diff --git a/include/linux/mtd/mtd.h b/include/linux/mtd/mtd.h
index a86c4fa93115..cd0be91bdefa 100644
--- a/include/linux/mtd/mtd.h
+++ b/include/linux/mtd/mtd.h
@@ -67,9 +67,11 @@ struct mtd_erase_region_info {
  * @datbuf:     data buffer - if NULL only oob data are read/written
  * @oobbuf:     oob data buffer
  *
- * Note, it is allowed to read more than one OOB area at one go, but not write.
- * The interface assumes that the OOB write requests program only one page's
- * OOB area.
+ * Note, some MTD drivers do not allow you to write more than one OOB area at
+ * one go. If you try to do that on such an MTD device, -EINVAL will be
+ * returned. If you want to make your implementation portable on all kind of MTD
+ * devices you should split the write request into several sub-requests when the
+ * request crosses a page boundary.
  */
 struct mtd_oob_ops {
         unsigned int    mode;
diff --git a/include/linux/mtd/rawnand.h b/include/linux/mtd/rawnand.h
index 3e8ec3b8a39c..efb2345359bb 100644
--- a/include/linux/mtd/rawnand.h
+++ b/include/linux/mtd/rawnand.h
@@ -21,11 +21,10 @@
 #include <linux/mtd/mtd.h>
 #include <linux/mtd/flashchip.h>
 #include <linux/mtd/bbm.h>
+#include <linux/of.h>
 #include <linux/types.h>
 
-struct mtd_info;
 struct nand_flash_dev;
-struct device_node;
 
 /* Scan and identify a NAND device */
 int nand_scan_with_ids(struct mtd_info *mtd, int max_chips,
@@ -36,17 +35,6 @@ static inline int nand_scan(struct mtd_info *mtd, int max_chips)
         return nand_scan_with_ids(mtd, max_chips, NULL);
 }
 
-/*
- * Separate phases of nand_scan(), allowing board driver to intervene
- * and override command or ECC setup according to flash type.
- */
-int nand_scan_ident(struct mtd_info *mtd, int max_chips,
-                           struct nand_flash_dev *table);
-int nand_scan_tail(struct mtd_info *mtd);
-
-/* Unregister the MTD device and free resources held by the NAND device */
-void nand_release(struct mtd_info *mtd);
-
 /* Internal helper for board drivers which need to override command function */
 void nand_wait_ready(struct mtd_info *mtd);
 
@@ -121,6 +109,7 @@ enum nand_ecc_algo {
         NAND_ECC_UNKNOWN,
         NAND_ECC_HAMMING,
         NAND_ECC_BCH,
+        NAND_ECC_RS,
 };
 
 /*
@@ -218,6 +207,12 @@ enum nand_ecc_algo {
  */
 #define NAND_WAIT_TCCS          0x00200000
 
+/*
+ * Whether the NAND chip is a boot medium. Drivers might use this information
+ * to select ECC algorithms supported by the boot ROM or similar restrictions.
+ */
+#define NAND_IS_BOOT_MEDIUM     0x00400000
+
 /* Options set by nand scan */
 /* Nand scan has allocated controller struct */
 #define NAND_CONTROLLER_ALLOC   0x80000000
@@ -230,6 +225,17 @@ enum nand_ecc_algo {
 /* Keep gcc happy */
 struct nand_chip;
 
+/* ONFI version bits */
+#define ONFI_VERSION_1_0                BIT(1)
+#define ONFI_VERSION_2_0                BIT(2)
+#define ONFI_VERSION_2_1                BIT(3)
+#define ONFI_VERSION_2_2                BIT(4)
+#define ONFI_VERSION_2_3                BIT(5)
+#define ONFI_VERSION_3_0                BIT(6)
+#define ONFI_VERSION_3_1                BIT(7)
+#define ONFI_VERSION_3_2                BIT(8)
+#define ONFI_VERSION_4_0                BIT(9)
+
 /* ONFI features */
 #define ONFI_FEATURE_16_BIT_BUS         (1 << 0)
 #define ONFI_FEATURE_EXT_PARAM_PAGE     (1 << 7)
@@ -470,13 +476,13 @@ struct onfi_params {
  */
 struct nand_parameters {
         /* Generic parameters */
-        char model[100];
+        const char *model;
         bool supports_set_get_features;
         DECLARE_BITMAP(set_feature_list, ONFI_FEATURE_NUMBER);
         DECLARE_BITMAP(get_feature_list, ONFI_FEATURE_NUMBER);
 
         /* ONFI parameters */
-        struct onfi_params onfi;
+        struct onfi_params *onfi;
 };
 
 /* The maximum expected count of bytes in the NAND ID sequence */
@@ -493,20 +499,42 @@ struct nand_id {
 };
 
 /**
- * struct nand_hw_control - Control structure for hardware controller (e.g ECC generator) shared among independent devices
+ * struct nand_controller_ops - Controller operations
+ *
+ * @attach_chip: this method is called after the NAND detection phase after
+ *               flash ID and MTD fields such as erase size, page size and OOB
+ *               size have been set up. ECC requirements are available if
+ *               provided by the NAND chip or device tree. Typically used to
+ *               choose the appropriate ECC configuration and allocate
+ *               associated resources.
+ *               This hook is optional.
+ * @detach_chip: free all resources allocated/claimed in
+ *               nand_controller_ops->attach_chip().
+ *               This hook is optional.
+ */
+struct nand_controller_ops {
+        int (*attach_chip)(struct nand_chip *chip);
+        void (*detach_chip)(struct nand_chip *chip);
+};
+
+/**
+ * struct nand_controller - Structure used to describe a NAND controller
+ *
  * @lock:               protection lock
  * @active:             the mtd device which holds the controller currently
  * @wq:                 wait queue to sleep on if a NAND operation is in
  *                      progress used instead of the per chip wait queue
  *                      when a hw controller is available.
+ * @ops:                NAND controller operations.
  */
-struct nand_hw_control {
+struct nand_controller {
         spinlock_t lock;
         struct nand_chip *active;
         wait_queue_head_t wq;
+        const struct nand_controller_ops *ops;
 };
 
-static inline void nand_hw_control_init(struct nand_hw_control *nfc)
+static inline void nand_controller_init(struct nand_controller *nfc)
 {
         nfc->active = NULL;
         spin_lock_init(&nfc->lock);
@@ -778,11 +806,15 @@ nand_get_sdr_timings(const struct nand_data_interface *conf)
  *        implementation) if any.
  * @cleanup: the ->init() function may have allocated resources, ->cleanup()
  *           is here to let vendor specific code release those resources.
+ * @fixup_onfi_param_page: apply vendor specific fixups to the ONFI parameter
+ *                         page. This is called after the checksum is verified.
  */
 struct nand_manufacturer_ops {
         void (*detect)(struct nand_chip *chip);
         int (*init)(struct nand_chip *chip);
         void (*cleanup)(struct nand_chip *chip);
+        void (*fixup_onfi_param_page)(struct nand_chip *chip,
+                                      struct nand_onfi_params *p);
 };
 
 /**
@@ -986,14 +1018,14 @@ struct nand_subop {
         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);
+unsigned int nand_subop_get_addr_start_off(const struct nand_subop *subop,
+                                           unsigned int op_id);
+unsigned int nand_subop_get_num_addr_cyc(const struct nand_subop *subop,
+                                         unsigned int op_id);
+unsigned int nand_subop_get_data_start_off(const struct nand_subop *subop,
+                                           unsigned int op_id);
+unsigned 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
@@ -1176,9 +1208,9 @@ int nand_op_parser_exec_op(struct nand_chip *chip,
  *                      setting the read-retry mode. Mostly needed for MLC NAND.
  * @ecc:                [BOARDSPECIFIC] ECC control structure
  * @buf_align:          minimum buffer alignment required by a platform
- * @hwcontrol:          platform-specific hardware control structure
+ * @dummy_controller:   dummy controller implementation for drivers that can
+ *                      only control a single chip
  * @erase:              [REPLACEABLE] erase function
- * @scan_bbt:           [REPLACEABLE] function to scan bad block table
  * @chip_delay:         [BOARDSPECIFIC] chip dependent delay for transferring
  *                      data from array to read regs (tR).
  * @state:              [INTERN] the current state of the NAND device
@@ -1271,7 +1303,6 @@ struct nand_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 (*set_features)(struct mtd_info *mtd, struct nand_chip *chip,
                             int feature_addr, uint8_t *subfeature_para);
         int (*get_features)(struct mtd_info *mtd, struct nand_chip *chip,
@@ -1314,11 +1345,11 @@ struct nand_chip {
         flstate_t state;
 
         uint8_t *oob_poi;
-        struct nand_hw_control *controller;
+        struct nand_controller *controller;
 
         struct nand_ecc_ctrl ecc;
         unsigned long buf_align;
-        struct nand_hw_control hwcontrol;
+        struct nand_controller dummy_controller;
 
         uint8_t *bbt;
         struct nand_bbt_descr *bbt_td;
@@ -1517,14 +1548,12 @@ extern const struct nand_manufacturer_ops micron_nand_manuf_ops;
 extern const struct nand_manufacturer_ops amd_nand_manuf_ops;
 extern const struct nand_manufacturer_ops macronix_nand_manuf_ops;
 
-int nand_default_bbt(struct mtd_info *mtd);
+int nand_create_bbt(struct nand_chip *chip);
 int nand_markbad_bbt(struct mtd_info *mtd, loff_t offs);
 int nand_isreserved_bbt(struct mtd_info *mtd, loff_t offs);
 int nand_isbad_bbt(struct mtd_info *mtd, loff_t offs, int allowbbt);
 int nand_erase_nand(struct mtd_info *mtd, struct erase_info *instr,
                     int allowbbt);
-int nand_do_read(struct mtd_info *mtd, loff_t from, size_t len,
-                 size_t *retlen, uint8_t *buf);
 
 /**
  * struct platform_nand_chip - chip level device structure
@@ -1555,14 +1584,12 @@ struct platform_device;
  * struct platform_nand_ctrl - controller level device structure
  * @probe:              platform specific function to probe/setup hardware
  * @remove:             platform specific function to remove/teardown hardware
- * @hwcontrol:          platform specific hardware control structure
  * @dev_ready:          platform specific function to read ready/busy pin
  * @select_chip:        platform specific chip select function
  * @cmd_ctrl:           platform specific function for controlling
  *                      ALE/CLE/nCE. Also used to write command and address
  * @write_buf:          platform specific function for write buffer
  * @read_buf:           platform specific function for read buffer
- * @read_byte:          platform specific function to read one byte from chip
  * @priv:               private data to transport driver specific settings
  *
  * All fields are optional and depend on the hardware driver requirements
@@ -1570,13 +1597,11 @@ struct platform_device;
 struct platform_nand_ctrl {
         int (*probe)(struct platform_device *pdev);
         void (*remove)(struct platform_device *pdev);
-        void (*hwcontrol)(struct mtd_info *mtd, int cmd);
         int (*dev_ready)(struct mtd_info *mtd);
         void (*select_chip)(struct mtd_info *mtd, int chip);
         void (*cmd_ctrl)(struct mtd_info *mtd, int dat, unsigned int ctrl);
         void (*write_buf)(struct mtd_info *mtd, const uint8_t *buf, int len);
         void (*read_buf)(struct mtd_info *mtd, uint8_t *buf, int len);
-        unsigned char (*read_byte)(struct mtd_info *mtd);
         void *priv;
 };
 
@@ -1593,10 +1618,10 @@ struct platform_nand_data {
 /* return the supported asynchronous timing mode. */
 static inline int onfi_get_async_timing_mode(struct nand_chip *chip)
 {
-        if (!chip->parameters.onfi.version)
+        if (!chip->parameters.onfi)
                 return ONFI_TIMING_MODE_UNKNOWN;
 
-        return chip->parameters.onfi.async_timing_mode;
+        return chip->parameters.onfi->async_timing_mode;
 }
 
 int onfi_fill_data_interface(struct nand_chip *chip,
@@ -1641,14 +1666,8 @@ int nand_check_erased_ecc_chunk(void *data, int datalen,
                                 void *extraoob, int extraooblen,
                                 int threshold);
 
-int nand_check_ecc_caps(struct nand_chip *chip,
-                        const struct nand_ecc_caps *caps, int oobavail);
-
-int nand_match_ecc_req(struct nand_chip *chip,
-                       const struct nand_ecc_caps *caps,  int oobavail);
-
-int nand_maximize_ecc(struct nand_chip *chip,
-                      const struct nand_ecc_caps *caps, int oobavail);
+int nand_ecc_choose_conf(struct nand_chip *chip,
+                         const struct nand_ecc_caps *caps, int oobavail);
 
 /* Default write_oob implementation */
 int nand_write_oob_std(struct mtd_info *mtd, struct nand_chip *chip, int page);
@@ -1674,10 +1693,14 @@ int nand_get_set_features_notsupp(struct mtd_info *mtd, struct nand_chip *chip,
 /* Default read_page_raw implementation */
 int nand_read_page_raw(struct mtd_info *mtd, struct nand_chip *chip,
                        uint8_t *buf, int oob_required, int page);
+int nand_read_page_raw_notsupp(struct mtd_info *mtd, struct nand_chip *chip,
+                               u8 *buf, int oob_required, int page);
 
 /* Default write_page_raw implementation */
 int nand_write_page_raw(struct mtd_info *mtd, struct nand_chip *chip,
                         const uint8_t *buf, int oob_required, int page);
+int nand_write_page_raw_notsupp(struct mtd_info *mtd, struct nand_chip *chip,
+                                const u8 *buf, int oob_required, int page);
 
 /* Reset and initialize a NAND device */
 int nand_reset(struct nand_chip *chip, int chipnr);
@@ -1711,8 +1734,13 @@ int nand_read_data_op(struct nand_chip *chip, void *buf, unsigned int len,
 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 */
+/*
+ * Free resources held by the NAND device, must be called on error after a
+ * sucessful nand_scan().
+ */
 void nand_cleanup(struct nand_chip *chip);
+/* Unregister the MTD device and calls nand_cleanup() */
+void nand_release(struct mtd_info *mtd);
 
 /* Default extended ID decoding function */
 void nand_decode_ext_id(struct nand_chip *chip);
diff --git a/include/linux/mtd/spi-nor.h b/include/linux/mtd/spi-nor.h
index e60da0d34cc1..c922e97f205a 100644
--- a/include/linux/mtd/spi-nor.h
+++ b/include/linux/mtd/spi-nor.h
@@ -235,6 +235,7 @@ enum spi_nor_option_flags {
         SNOR_F_S3AN_ADDR_DEFAULT = BIT(3),
         SNOR_F_READY_XSR_RDY    = BIT(4),
         SNOR_F_USE_CLSR         = BIT(5),
+        SNOR_F_BROKEN_RESET     = BIT(6),
 };
 
 /**
diff --git a/include/linux/mtd/spinand.h b/include/linux/mtd/spinand.h
new file mode 100644
index 000000000000..088ff96c3eb6
--- /dev/null
+++ b/include/linux/mtd/spinand.h
@@ -0,0 +1,421 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Copyright (c) 2016-2017 Micron Technology, Inc.
+ *
+ *  Authors:
+ *      Peter Pan <peterpandong@micron.com>
+ */
+#ifndef __LINUX_MTD_SPINAND_H
+#define __LINUX_MTD_SPINAND_H
+
+#include <linux/mutex.h>
+#include <linux/bitops.h>
+#include <linux/device.h>
+#include <linux/mtd/mtd.h>
+#include <linux/mtd/nand.h>
+#include <linux/spi/spi.h>
+#include <linux/spi/spi-mem.h>
+
+/**
+ * Standard SPI NAND flash operations
+ */
+
+#define SPINAND_RESET_OP                                                \
+        SPI_MEM_OP(SPI_MEM_OP_CMD(0xff, 1),                             \
+                   SPI_MEM_OP_NO_ADDR,                                  \
+                   SPI_MEM_OP_NO_DUMMY,                                 \
+                   SPI_MEM_OP_NO_DATA)
+
+#define SPINAND_WR_EN_DIS_OP(enable)                                    \
+        SPI_MEM_OP(SPI_MEM_OP_CMD((enable) ? 0x06 : 0x04, 1),           \
+                   SPI_MEM_OP_NO_ADDR,                                  \
+                   SPI_MEM_OP_NO_DUMMY,                                 \
+                   SPI_MEM_OP_NO_DATA)
+
+#define SPINAND_READID_OP(ndummy, buf, len)                             \
+        SPI_MEM_OP(SPI_MEM_OP_CMD(0x9f, 1),                             \
+                   SPI_MEM_OP_NO_ADDR,                                  \
+                   SPI_MEM_OP_DUMMY(ndummy, 1),                         \
+                   SPI_MEM_OP_DATA_IN(len, buf, 1))
+
+#define SPINAND_SET_FEATURE_OP(reg, valptr)                             \
+        SPI_MEM_OP(SPI_MEM_OP_CMD(0x1f, 1),                             \
+                   SPI_MEM_OP_ADDR(1, reg, 1),                          \
+                   SPI_MEM_OP_NO_DUMMY,                                 \
+                   SPI_MEM_OP_DATA_OUT(1, valptr, 1))
+
+#define SPINAND_GET_FEATURE_OP(reg, valptr)                             \
+        SPI_MEM_OP(SPI_MEM_OP_CMD(0x0f, 1),                             \
+                   SPI_MEM_OP_ADDR(1, reg, 1),                          \
+                   SPI_MEM_OP_NO_DUMMY,                                 \
+                   SPI_MEM_OP_DATA_IN(1, valptr, 1))
+
+#define SPINAND_BLK_ERASE_OP(addr)                                      \
+        SPI_MEM_OP(SPI_MEM_OP_CMD(0xd8, 1),                             \
+                   SPI_MEM_OP_ADDR(3, addr, 1),                         \
+                   SPI_MEM_OP_NO_DUMMY,                                 \
+                   SPI_MEM_OP_NO_DATA)
+
+#define SPINAND_PAGE_READ_OP(addr)                                      \
+        SPI_MEM_OP(SPI_MEM_OP_CMD(0x13, 1),                             \
+                   SPI_MEM_OP_ADDR(3, addr, 1),                         \
+                   SPI_MEM_OP_NO_DUMMY,                                 \
+                   SPI_MEM_OP_NO_DATA)
+
+#define SPINAND_PAGE_READ_FROM_CACHE_OP(fast, addr, ndummy, buf, len)   \
+        SPI_MEM_OP(SPI_MEM_OP_CMD(fast ? 0x0b : 0x03, 1),               \
+                   SPI_MEM_OP_ADDR(2, addr, 1),                         \
+                   SPI_MEM_OP_DUMMY(ndummy, 1),                         \
+                   SPI_MEM_OP_DATA_IN(len, buf, 1))
+
+#define SPINAND_PAGE_READ_FROM_CACHE_X2_OP(addr, ndummy, buf, len)      \
+        SPI_MEM_OP(SPI_MEM_OP_CMD(0x3b, 1),                             \
+                   SPI_MEM_OP_ADDR(2, addr, 1),                         \
+                   SPI_MEM_OP_DUMMY(ndummy, 1),                         \
+                   SPI_MEM_OP_DATA_IN(len, buf, 2))
+
+#define SPINAND_PAGE_READ_FROM_CACHE_X4_OP(addr, ndummy, buf, len)      \
+        SPI_MEM_OP(SPI_MEM_OP_CMD(0x6b, 1),                             \
+                   SPI_MEM_OP_ADDR(2, addr, 1),                         \
+                   SPI_MEM_OP_DUMMY(ndummy, 1),                         \
+                   SPI_MEM_OP_DATA_IN(len, buf, 4))
+
+#define SPINAND_PAGE_READ_FROM_CACHE_DUALIO_OP(addr, ndummy, buf, len)  \
+        SPI_MEM_OP(SPI_MEM_OP_CMD(0xbb, 1),                             \
+                   SPI_MEM_OP_ADDR(2, addr, 2),                         \
+                   SPI_MEM_OP_DUMMY(ndummy, 2),                         \
+                   SPI_MEM_OP_DATA_IN(len, buf, 2))
+
+#define SPINAND_PAGE_READ_FROM_CACHE_QUADIO_OP(addr, ndummy, buf, len)  \
+        SPI_MEM_OP(SPI_MEM_OP_CMD(0xeb, 1),                             \
+                   SPI_MEM_OP_ADDR(2, addr, 4),                         \
+                   SPI_MEM_OP_DUMMY(ndummy, 4),                         \
+                   SPI_MEM_OP_DATA_IN(len, buf, 4))
+
+#define SPINAND_PROG_EXEC_OP(addr)                                      \
+        SPI_MEM_OP(SPI_MEM_OP_CMD(0x10, 1),                             \
+                   SPI_MEM_OP_ADDR(3, addr, 1),                         \
+                   SPI_MEM_OP_NO_DUMMY,                                 \
+                   SPI_MEM_OP_NO_DATA)
+
+#define SPINAND_PROG_LOAD(reset, addr, buf, len)                        \
+        SPI_MEM_OP(SPI_MEM_OP_CMD(reset ? 0x02 : 0x84, 1),              \
+                   SPI_MEM_OP_ADDR(2, addr, 1),                         \
+                   SPI_MEM_OP_NO_DUMMY,                                 \
+                   SPI_MEM_OP_DATA_OUT(len, buf, 1))
+
+#define SPINAND_PROG_LOAD_X4(reset, addr, buf, len)                     \
+        SPI_MEM_OP(SPI_MEM_OP_CMD(reset ? 0x32 : 0x34, 1),              \
+                   SPI_MEM_OP_ADDR(2, addr, 1),                         \
+                   SPI_MEM_OP_NO_DUMMY,                                 \
+                   SPI_MEM_OP_DATA_OUT(len, buf, 4))
+
+/**
+ * Standard SPI NAND flash commands
+ */
+#define SPINAND_CMD_PROG_LOAD_X4                0x32
+#define SPINAND_CMD_PROG_LOAD_RDM_DATA_X4       0x34
+
+/* feature register */
+#define REG_BLOCK_LOCK          0xa0
+#define BL_ALL_UNLOCKED         0x00
+
+/* configuration register */
+#define REG_CFG                 0xb0
+#define CFG_OTP_ENABLE          BIT(6)
+#define CFG_ECC_ENABLE          BIT(4)
+#define CFG_QUAD_ENABLE         BIT(0)
+
+/* status register */
+#define REG_STATUS              0xc0
+#define STATUS_BUSY             BIT(0)
+#define STATUS_ERASE_FAILED     BIT(2)
+#define STATUS_PROG_FAILED      BIT(3)
+#define STATUS_ECC_MASK         GENMASK(5, 4)
+#define STATUS_ECC_NO_BITFLIPS  (0 << 4)
+#define STATUS_ECC_HAS_BITFLIPS (1 << 4)
+#define STATUS_ECC_UNCOR_ERROR  (2 << 4)
+
+struct spinand_op;
+struct spinand_device;
+
+#define SPINAND_MAX_ID_LEN      4
+
+/**
+ * struct spinand_id - SPI NAND id structure
+ * @data: buffer containing the id bytes. Currently 4 bytes large, but can
+ *        be extended if required
+ * @len: ID length
+ *
+ * struct_spinand_id->data contains all bytes returned after a READ_ID command,
+ * including dummy bytes if the chip does not emit ID bytes right after the
+ * READ_ID command. The responsibility to extract real ID bytes is left to
+ * struct_manufacurer_ops->detect().
+ */
+struct spinand_id {
+        u8 data[SPINAND_MAX_ID_LEN];
+        int len;
+};
+
+/**
+ * struct manufacurer_ops - SPI NAND manufacturer specific operations
+ * @detect: detect a SPI NAND device. Every time a SPI NAND device is probed
+ *          the core calls the struct_manufacurer_ops->detect() hook of each
+ *          registered manufacturer until one of them return 1. Note that
+ *          the first thing to check in this hook is that the manufacturer ID
+ *          in struct_spinand_device->id matches the manufacturer whose
+ *          ->detect() hook has been called. Should return 1 if there's a
+ *          match, 0 if the manufacturer ID does not match and a negative
+ *          error code otherwise. When true is returned, the core assumes
+ *          that properties of the NAND chip (spinand->base.memorg and
+ *          spinand->base.eccreq) have been filled
+ * @init: initialize a SPI NAND device
+ * @cleanup: cleanup a SPI NAND device
+ *
+ * Each SPI NAND manufacturer driver should implement this interface so that
+ * NAND chips coming from this vendor can be detected and initialized properly.
+ */
+struct spinand_manufacturer_ops {
+        int (*detect)(struct spinand_device *spinand);
+        int (*init)(struct spinand_device *spinand);
+        void (*cleanup)(struct spinand_device *spinand);
+};
+
+/**
+ * struct spinand_manufacturer - SPI NAND manufacturer instance
+ * @id: manufacturer ID
+ * @name: manufacturer name
+ * @ops: manufacturer operations
+ */
+struct spinand_manufacturer {
+        u8 id;
+        char *name;
+        const struct spinand_manufacturer_ops *ops;
+};
+
+/* SPI NAND manufacturers */
+extern const struct spinand_manufacturer macronix_spinand_manufacturer;
+extern const struct spinand_manufacturer micron_spinand_manufacturer;
+extern const struct spinand_manufacturer winbond_spinand_manufacturer;
+
+/**
+ * struct spinand_op_variants - SPI NAND operation variants
+ * @ops: the list of variants for a given operation
+ * @nops: the number of variants
+ *
+ * Some operations like read-from-cache/write-to-cache have several variants
+ * depending on the number of IO lines you use to transfer data or address
+ * cycles. This structure is a way to describe the different variants supported
+ * by a chip and let the core pick the best one based on the SPI mem controller
+ * capabilities.
+ */
+struct spinand_op_variants {
+        const struct spi_mem_op *ops;
+        unsigned int nops;
+};
+
+#define SPINAND_OP_VARIANTS(name, ...)                                  \
+        const struct spinand_op_variants name = {                       \
+                .ops = (struct spi_mem_op[]) { __VA_ARGS__ },           \
+                .nops = sizeof((struct spi_mem_op[]){ __VA_ARGS__ }) /  \
+                        sizeof(struct spi_mem_op),                      \
+        }
+
+/**
+ * spinand_ecc_info - description of the on-die ECC implemented by a SPI NAND
+ *                    chip
+ * @get_status: get the ECC status. Should return a positive number encoding
+ *              the number of corrected bitflips if correction was possible or
+ *              -EBADMSG if there are uncorrectable errors. I can also return
+ *              other negative error codes if the error is not caused by
+ *              uncorrectable bitflips
+ * @ooblayout: the OOB layout used by the on-die ECC implementation
+ */
+struct spinand_ecc_info {
+        int (*get_status)(struct spinand_device *spinand, u8 status);
+        const struct mtd_ooblayout_ops *ooblayout;
+};
+
+#define SPINAND_HAS_QE_BIT              BIT(0)
+
+/**
+ * struct spinand_info - Structure used to describe SPI NAND chips
+ * @model: model name
+ * @devid: device ID
+ * @flags: OR-ing of the SPINAND_XXX flags
+ * @memorg: memory organization
+ * @eccreq: ECC requirements
+ * @eccinfo: on-die ECC info
+ * @op_variants: operations variants
+ * @op_variants.read_cache: variants of the read-cache operation
+ * @op_variants.write_cache: variants of the write-cache operation
+ * @op_variants.update_cache: variants of the update-cache operation
+ * @select_target: function used to select a target/die. Required only for
+ *                 multi-die chips
+ *
+ * Each SPI NAND manufacturer driver should have a spinand_info table
+ * describing all the chips supported by the driver.
+ */
+struct spinand_info {
+        const char *model;
+        u8 devid;
+        u32 flags;
+        struct nand_memory_organization memorg;
+        struct nand_ecc_req eccreq;
+        struct spinand_ecc_info eccinfo;
+        struct {
+                const struct spinand_op_variants *read_cache;
+                const struct spinand_op_variants *write_cache;
+                const struct spinand_op_variants *update_cache;
+        } op_variants;
+        int (*select_target)(struct spinand_device *spinand,
+                             unsigned int target);
+};
+
+#define SPINAND_INFO_OP_VARIANTS(__read, __write, __update)             \
+        {                                                               \
+                .read_cache = __read,                                   \
+                .write_cache = __write,                                 \
+                .update_cache = __update,                               \
+        }
+
+#define SPINAND_ECCINFO(__ooblayout, __get_status)                      \
+        .eccinfo = {                                                    \
+                .ooblayout = __ooblayout,                               \
+                .get_status = __get_status,                             \
+        }
+
+#define SPINAND_SELECT_TARGET(__func)                                   \
+        .select_target = __func,
+
+#define SPINAND_INFO(__model, __id, __memorg, __eccreq, __op_variants,  \
+                     __flags, ...)                                      \
+        {                                                               \
+                .model = __model,                                       \
+                .devid = __id,                                          \
+                .memorg = __memorg,                                     \
+                .eccreq = __eccreq,                                     \
+                .op_variants = __op_variants,                           \
+                .flags = __flags,                                       \
+                __VA_ARGS__                                             \
+        }
+
+/**
+ * struct spinand_device - SPI NAND device instance
+ * @base: NAND device instance
+ * @spimem: pointer to the SPI mem object
+ * @lock: lock used to serialize accesses to the NAND
+ * @id: NAND ID as returned by READ_ID
+ * @flags: NAND flags
+ * @op_templates: various SPI mem op templates
+ * @op_templates.read_cache: read cache op template
+ * @op_templates.write_cache: write cache op template
+ * @op_templates.update_cache: update cache op template
+ * @select_target: select a specific target/die. Usually called before sending
+ *                 a command addressing a page or an eraseblock embedded in
+ *                 this die. Only required if your chip exposes several dies
+ * @cur_target: currently selected target/die
+ * @eccinfo: on-die ECC information
+ * @cfg_cache: config register cache. One entry per die
+ * @databuf: bounce buffer for data
+ * @oobbuf: bounce buffer for OOB data
+ * @scratchbuf: buffer used for everything but page accesses. This is needed
+ *              because the spi-mem interface explicitly requests that buffers
+ *              passed in spi_mem_op be DMA-able, so we can't based the bufs on
+ *              the stack
+ * @manufacturer: SPI NAND manufacturer information
+ * @priv: manufacturer private data
+ */
+struct spinand_device {
+        struct nand_device base;
+        struct spi_mem *spimem;
+        struct mutex lock;
+        struct spinand_id id;
+        u32 flags;
+
+        struct {
+                const struct spi_mem_op *read_cache;
+                const struct spi_mem_op *write_cache;
+                const struct spi_mem_op *update_cache;
+        } op_templates;
+
+        int (*select_target)(struct spinand_device *spinand,
+                             unsigned int target);
+        unsigned int cur_target;
+
+        struct spinand_ecc_info eccinfo;
+
+        u8 *cfg_cache;
+        u8 *databuf;
+        u8 *oobbuf;
+        u8 *scratchbuf;
+        const struct spinand_manufacturer *manufacturer;
+        void *priv;
+};
+
+/**
+ * mtd_to_spinand() - Get the SPI NAND device attached to an MTD instance
+ * @mtd: MTD instance
+ *
+ * Return: the SPI NAND device attached to @mtd.
+ */
+static inline struct spinand_device *mtd_to_spinand(struct mtd_info *mtd)
+{
+        return container_of(mtd_to_nanddev(mtd), struct spinand_device, base);
+}
+
+/**
+ * spinand_to_mtd() - Get the MTD device embedded in a SPI NAND device
+ * @spinand: SPI NAND device
+ *
+ * Return: the MTD device embedded in @spinand.
+ */
+static inline struct mtd_info *spinand_to_mtd(struct spinand_device *spinand)
+{
+        return nanddev_to_mtd(&spinand->base);
+}
+
+/**
+ * nand_to_spinand() - Get the SPI NAND device embedding an NAND object
+ * @nand: NAND object
+ *
+ * Return: the SPI NAND device embedding @nand.
+ */
+static inline struct spinand_device *nand_to_spinand(struct nand_device *nand)
+{
+        return container_of(nand, struct spinand_device, base);
+}
+
+/**
+ * spinand_to_nand() - Get the NAND device embedded in a SPI NAND object
+ * @spinand: SPI NAND device
+ *
+ * Return: the NAND device embedded in @spinand.
+ */
+static inline struct nand_device *
+spinand_to_nand(struct spinand_device *spinand)
+{
+        return &spinand->base;
+}
+
+/**
+ * spinand_set_of_node - Attach a DT node to a SPI NAND device
+ * @spinand: SPI NAND device
+ * @np: DT node
+ *
+ * Attach a DT node to a SPI NAND device.
+ */
+static inline void spinand_set_of_node(struct spinand_device *spinand,
+                                       struct device_node *np)
+{
+        nanddev_set_of_node(&spinand->base, np);
+}
+
+int spinand_match_and_init(struct spinand_device *dev,
+                           const struct spinand_info *table,
+                           unsigned int table_size, u8 devid);
+
+int spinand_upd_cfg(struct spinand_device *spinand, u8 mask, u8 val);
+int spinand_select_target(struct spinand_device *spinand, unsigned int target);
+
+#endif /* __LINUX_MTD_SPINAND_H */
diff --git a/include/linux/net.h b/include/linux/net.h
index 6554d3ba4396..e0930678c8bf 100644
--- a/include/linux/net.h
+++ b/include/linux/net.h
@@ -114,7 +114,7 @@ struct socket {
 
         unsigned long           flags;
 
-        struct socket_wq __rcu  *wq;
+        struct socket_wq        *wq;
 
         struct file             *file;
         struct sock             *sk;
diff --git a/include/linux/net_dim.h b/include/linux/net_dim.h
index db99240d00bd..c79e859408e6 100644
--- a/include/linux/net_dim.h
+++ b/include/linux/net_dim.h
@@ -363,7 +363,6 @@ static inline void net_dim_sample(u16 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,
diff --git a/include/linux/netdev_features.h b/include/linux/netdev_features.h
index 623bb8ced060..2b2a6dce1630 100644
--- a/include/linux/netdev_features.h
+++ b/include/linux/netdev_features.h
@@ -79,6 +79,7 @@ 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_HW_TLS_TX_BIT,          /* Hardware TLS TX offload */
+        NETIF_F_HW_TLS_RX_BIT,          /* Hardware TLS RX offload */
 
         NETIF_F_GRO_HW_BIT,             /* Hardware Generic receive offload */
         NETIF_F_HW_TLS_RECORD_BIT,      /* Offload TLS record */
@@ -151,6 +152,7 @@ enum {
 #define NETIF_F_HW_TLS_RECORD   __NETIF_F(HW_TLS_RECORD)
 #define NETIF_F_GSO_UDP_L4      __NETIF_F(GSO_UDP_L4)
 #define NETIF_F_HW_TLS_TX       __NETIF_F(HW_TLS_TX)
+#define NETIF_F_HW_TLS_RX       __NETIF_F(HW_TLS_RX)
 
 #define for_each_netdev_feature(mask_addr, bit) \
         for_each_set_bit(bit, (unsigned long *)mask_addr, NETDEV_FEATURE_COUNT)
diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h
index 3d0cc0b5cec2..ca5ab98053c8 100644
--- a/include/linux/netdevice.h
+++ b/include/linux/netdevice.h
@@ -302,6 +302,17 @@ struct netdev_boot_setup {
 
 int __init netdev_boot_setup(char *str);
 
+struct gro_list {
+        struct list_head        list;
+        int                     count;
+};
+
+/*
+ * size of gro hash buckets, must less than bit number of
+ * napi_struct::gro_bitmask
+ */
+#define GRO_HASH_BUCKETS        8
+
 /*
  * Structure for NAPI scheduling similar to tasklet but with weighting
  */
@@ -316,13 +327,13 @@ struct napi_struct {
 
         unsigned long           state;
         int                     weight;
-        unsigned int            gro_count;
+        unsigned long           gro_bitmask;
         int                     (*poll)(struct napi_struct *, int);
 #ifdef CONFIG_NETPOLL
         int                     poll_owner;
 #endif
         struct net_device       *dev;
-        struct sk_buff          *gro_list;
+        struct gro_list         gro_hash[GRO_HASH_BUCKETS];
         struct sk_buff          *skb;
         struct hrtimer          timer;
         struct list_head        dev_list;
@@ -569,6 +580,9 @@ struct netdev_queue {
          * (/sys/class/net/DEV/Q/trans_timeout)
          */
         unsigned long           trans_timeout;
+
+        /* Subordinate device that the queue has been assigned to */
+        struct net_device       *sb_dev;
 /*
  * write-mostly part
  */
@@ -730,10 +744,15 @@ struct xps_map {
  */
 struct xps_dev_maps {
         struct rcu_head rcu;
-        struct xps_map __rcu *cpu_map[0];
+        struct xps_map __rcu *attr_map[0]; /* Either CPUs map or RXQs map */
 };
-#define XPS_DEV_MAPS_SIZE(_tcs) (sizeof(struct xps_dev_maps) +          \
+
+#define XPS_CPU_DEV_MAPS_SIZE(_tcs) (sizeof(struct xps_dev_maps) +      \
         (nr_cpu_ids * (_tcs) * sizeof(struct xps_map *)))
+
+#define XPS_RXQ_DEV_MAPS_SIZE(_tcs, _rxqs) (sizeof(struct xps_dev_maps) +\
+        (_rxqs * (_tcs) * sizeof(struct xps_map *)))
+
 #endif /* CONFIG_XPS */
 
 #define TC_MAX_QUEUE    16
@@ -779,7 +798,8 @@ static inline bool netdev_phys_item_id_same(struct netdev_phys_item_id *a,
 }
 
 typedef u16 (*select_queue_fallback_t)(struct net_device *dev,
-                                       struct sk_buff *skb);
+                                       struct sk_buff *skb,
+                                       struct net_device *sb_dev);
 
 enum tc_setup_type {
         TC_SETUP_QDISC_MQPRIO,
@@ -792,6 +812,7 @@ enum tc_setup_type {
         TC_SETUP_QDISC_RED,
         TC_SETUP_QDISC_PRIO,
         TC_SETUP_QDISC_MQ,
+        TC_SETUP_QDISC_ETF,
 };
 
 /* These structures hold the attributes of bpf state that are being passed
@@ -807,11 +828,8 @@ enum bpf_netdev_command {
          */
         XDP_SETUP_PROG,
         XDP_SETUP_PROG_HW,
-        /* Check if a bpf program is set on the device.  The callee should
-         * set @prog_attached to one of XDP_ATTACHED_* values, note that "true"
-         * is equivalent to XDP_ATTACHED_DRV.
-         */
         XDP_QUERY_PROG,
+        XDP_QUERY_PROG_HW,
         /* BPF program for offload callbacks, invoked at program load time. */
         BPF_OFFLOAD_VERIFIER_PREP,
         BPF_OFFLOAD_TRANSLATE,
@@ -835,9 +853,8 @@ struct netdev_bpf {
                         struct bpf_prog *prog;
                         struct netlink_ext_ack *extack;
                 };
-                /* XDP_QUERY_PROG */
+                /* XDP_QUERY_PROG, XDP_QUERY_PROG_HW */
                 struct {
-                        u8 prog_attached;
                         u32 prog_id;
                         /* flags with which program was installed */
                         u32 prog_flags;
@@ -855,10 +872,10 @@ struct netdev_bpf {
                 struct {
                         struct bpf_offloaded_map *offmap;
                 };
-                /* XDP_SETUP_XSK_UMEM */
+                /* XDP_QUERY_XSK_UMEM, XDP_SETUP_XSK_UMEM */
                 struct {
-                        struct xdp_umem *umem;
-                        u16 queue_id;
+                        struct xdp_umem *umem; /* out for query*/
+                        u16 queue_id; /* in for query */
                 } xsk;
         };
 };
@@ -891,6 +908,8 @@ struct tlsdev_ops {
         void (*tls_dev_del)(struct net_device *netdev,
                             struct tls_context *ctx,
                             enum tls_offload_ctx_dir direction);
+        void (*tls_dev_resync_rx)(struct net_device *netdev,
+                                  struct sock *sk, u32 seq, u64 rcd_sn);
 };
 #endif
 
@@ -942,7 +961,8 @@ struct dev_ifalias {
  *      those the driver believes to be appropriate.
  *
  * u16 (*ndo_select_queue)(struct net_device *dev, struct sk_buff *skb,
- *                         void *accel_priv, select_queue_fallback_t fallback);
+ *                         struct net_device *sb_dev,
+ *                         select_queue_fallback_t fallback);
  *      Called to decide which queue to use when device supports multiple
  *      transmit queues.
  *
@@ -1214,7 +1234,7 @@ struct net_device_ops {
                                                       netdev_features_t features);
         u16                     (*ndo_select_queue)(struct net_device *dev,
                                                     struct sk_buff *skb,
-                                                    void *accel_priv,
+                                                    struct net_device *sb_dev,
                                                     select_queue_fallback_t fallback);
         void                    (*ndo_change_rx_flags)(struct net_device *dev,
                                                        int flags);
@@ -1909,7 +1929,8 @@ struct net_device {
         int                     watchdog_timeo;
 
 #ifdef CONFIG_XPS
-        struct xps_dev_maps __rcu *xps_maps;
+        struct xps_dev_maps __rcu *xps_cpus_map;
+        struct xps_dev_maps __rcu *xps_rxqs_map;
 #endif
 #ifdef CONFIG_NET_CLS_ACT
         struct mini_Qdisc __rcu *miniq_egress;
@@ -1978,7 +1999,7 @@ struct net_device {
 #ifdef CONFIG_DCB
         const struct dcbnl_rtnl_ops *dcbnl_ops;
 #endif
-        u8                      num_tc;
+        s16                     num_tc;
         struct netdev_tc_txq    tc_to_txq[TC_MAX_QUEUE];
         u8                      prio_tc_map[TC_BITMASK + 1];
 
@@ -2032,6 +2053,17 @@ int netdev_get_num_tc(struct net_device *dev)
         return dev->num_tc;
 }
 
+void netdev_unbind_sb_channel(struct net_device *dev,
+                              struct net_device *sb_dev);
+int netdev_bind_sb_channel_queue(struct net_device *dev,
+                                 struct net_device *sb_dev,
+                                 u8 tc, u16 count, u16 offset);
+int netdev_set_sb_channel(struct net_device *dev, u16 channel);
+static inline int netdev_get_sb_channel(struct net_device *dev)
+{
+        return max_t(int, -dev->num_tc, 0);
+}
+
 static inline
 struct netdev_queue *netdev_get_tx_queue(const struct net_device *dev,
                                          unsigned int index)
@@ -2076,7 +2108,7 @@ static inline void netdev_for_each_tx_queue(struct net_device *dev,
 
 struct netdev_queue *netdev_pick_tx(struct net_device *dev,
                                     struct sk_buff *skb,
-                                    void *accel_priv);
+                                    struct net_device *sb_dev);
 
 /* returns the headroom that the master device needs to take in account
  * when forwarding to this dev
@@ -2255,10 +2287,10 @@ static inline int gro_recursion_inc_test(struct sk_buff *skb)
         return ++NAPI_GRO_CB(skb)->recursion_counter == GRO_RECURSION_LIMIT;
 }
 
-typedef struct sk_buff **(*gro_receive_t)(struct sk_buff **, struct sk_buff *);
-static inline struct sk_buff **call_gro_receive(gro_receive_t cb,
-                                                struct sk_buff **head,
-                                                struct sk_buff *skb)
+typedef struct sk_buff *(*gro_receive_t)(struct list_head *, struct sk_buff *);
+static inline struct sk_buff *call_gro_receive(gro_receive_t cb,
+                                               struct list_head *head,
+                                               struct sk_buff *skb)
 {
         if (unlikely(gro_recursion_inc_test(skb))) {
                 NAPI_GRO_CB(skb)->flush |= 1;
@@ -2268,12 +2300,12 @@ static inline struct sk_buff **call_gro_receive(gro_receive_t cb,
         return cb(head, skb);
 }
 
-typedef struct sk_buff **(*gro_receive_sk_t)(struct sock *, struct sk_buff **,
-                                             struct sk_buff *);
-static inline struct sk_buff **call_gro_receive_sk(gro_receive_sk_t cb,
-                                                   struct sock *sk,
-                                                   struct sk_buff **head,
-                                                   struct sk_buff *skb)
+typedef struct sk_buff *(*gro_receive_sk_t)(struct sock *, struct list_head *,
+                                            struct sk_buff *);
+static inline struct sk_buff *call_gro_receive_sk(gro_receive_sk_t cb,
+                                                  struct sock *sk,
+                                                  struct list_head *head,
+                                                  struct sk_buff *skb)
 {
         if (unlikely(gro_recursion_inc_test(skb))) {
                 NAPI_GRO_CB(skb)->flush |= 1;
@@ -2290,6 +2322,9 @@ struct packet_type {
                                          struct net_device *,
                                          struct packet_type *,
                                          struct net_device *);
+        void                    (*list_func) (struct list_head *,
+                                              struct packet_type *,
+                                              struct net_device *);
         bool                    (*id_match)(struct packet_type *ptype,
                                             struct sock *sk);
         void                    *af_packet_priv;
@@ -2299,8 +2334,8 @@ struct packet_type {
 struct offload_callbacks {
         struct sk_buff          *(*gso_segment)(struct sk_buff *skb,
                                                 netdev_features_t features);
-        struct sk_buff          **(*gro_receive)(struct sk_buff **head,
-                                                 struct sk_buff *skb);
+        struct sk_buff          *(*gro_receive)(struct list_head *head,
+                                                struct sk_buff *skb);
         int                     (*gro_complete)(struct sk_buff *skb, int nhoff);
 };
 
@@ -2537,8 +2572,14 @@ void dev_close(struct net_device *dev);
 void dev_close_many(struct list_head *head, bool unlink);
 void dev_disable_lro(struct net_device *dev);
 int dev_loopback_xmit(struct net *net, struct sock *sk, struct sk_buff *newskb);
+u16 dev_pick_tx_zero(struct net_device *dev, struct sk_buff *skb,
+                     struct net_device *sb_dev,
+                     select_queue_fallback_t fallback);
+u16 dev_pick_tx_cpu_id(struct net_device *dev, struct sk_buff *skb,
+                       struct net_device *sb_dev,
+                       select_queue_fallback_t fallback);
 int dev_queue_xmit(struct sk_buff *skb);
-int dev_queue_xmit_accel(struct sk_buff *skb, void *accel_priv);
+int dev_queue_xmit_accel(struct sk_buff *skb, struct net_device *sb_dev);
 int dev_direct_xmit(struct sk_buff *skb, u16 queue_id);
 int register_netdevice(struct net_device *dev);
 void unregister_netdevice_queue(struct net_device *dev, struct list_head *head);
@@ -2568,7 +2609,7 @@ struct net_device *dev_get_by_index_rcu(struct net *net, int ifindex);
 struct net_device *dev_get_by_napi_id(unsigned int napi_id);
 int netdev_get_name(struct net *net, char *name, int ifindex);
 int dev_restart(struct net_device *dev);
-int skb_gro_receive(struct sk_buff **head, struct sk_buff *skb);
+int skb_gro_receive(struct sk_buff *p, struct sk_buff *skb);
 
 static inline unsigned int skb_gro_offset(const struct sk_buff *skb)
 {
@@ -2784,13 +2825,13 @@ static inline void skb_gro_remcsum_cleanup(struct sk_buff *skb,
 }
 
 #ifdef CONFIG_XFRM_OFFLOAD
-static inline void skb_gro_flush_final(struct sk_buff *skb, struct sk_buff **pp, int flush)
+static inline void skb_gro_flush_final(struct sk_buff *skb, struct sk_buff *pp, int flush)
 {
         if (PTR_ERR(pp) != -EINPROGRESS)
                 NAPI_GRO_CB(skb)->flush |= flush;
 }
 static inline void skb_gro_flush_final_remcsum(struct sk_buff *skb,
-                                               struct sk_buff **pp,
+                                               struct sk_buff *pp,
                                                int flush,
                                                struct gro_remcsum *grc)
 {
@@ -2801,12 +2842,12 @@ static inline void skb_gro_flush_final_remcsum(struct sk_buff *skb,
         }
 }
 #else
-static inline void skb_gro_flush_final(struct sk_buff *skb, struct sk_buff **pp, int flush)
+static inline void skb_gro_flush_final(struct sk_buff *skb, struct sk_buff *pp, int flush)
 {
         NAPI_GRO_CB(skb)->flush |= flush;
 }
 static inline void skb_gro_flush_final_remcsum(struct sk_buff *skb,
-                                               struct sk_buff **pp,
+                                               struct sk_buff *pp,
                                                int flush,
                                                struct gro_remcsum *grc)
 {
@@ -3278,6 +3319,92 @@ static inline void netif_wake_subqueue(struct net_device *dev, u16 queue_index)
 #ifdef CONFIG_XPS
 int netif_set_xps_queue(struct net_device *dev, const struct cpumask *mask,
                         u16 index);
+int __netif_set_xps_queue(struct net_device *dev, const unsigned long *mask,
+                          u16 index, bool is_rxqs_map);
+
+/**
+ *      netif_attr_test_mask - Test a CPU or Rx queue set in a mask
+ *      @j: CPU/Rx queue index
+ *      @mask: bitmask of all cpus/rx queues
+ *      @nr_bits: number of bits in the bitmask
+ *
+ * Test if a CPU or Rx queue index is set in a mask of all CPU/Rx queues.
+ */
+static inline bool netif_attr_test_mask(unsigned long j,
+                                        const unsigned long *mask,
+                                        unsigned int nr_bits)
+{
+        cpu_max_bits_warn(j, nr_bits);
+        return test_bit(j, mask);
+}
+
+/**
+ *      netif_attr_test_online - Test for online CPU/Rx queue
+ *      @j: CPU/Rx queue index
+ *      @online_mask: bitmask for CPUs/Rx queues that are online
+ *      @nr_bits: number of bits in the bitmask
+ *
+ * Returns true if a CPU/Rx queue is online.
+ */
+static inline bool netif_attr_test_online(unsigned long j,
+                                          const unsigned long *online_mask,
+                                          unsigned int nr_bits)
+{
+        cpu_max_bits_warn(j, nr_bits);
+
+        if (online_mask)
+                return test_bit(j, online_mask);
+
+        return (j < nr_bits);
+}
+
+/**
+ *      netif_attrmask_next - get the next CPU/Rx queue in a cpu/Rx queues mask
+ *      @n: CPU/Rx queue index
+ *      @srcp: the cpumask/Rx queue mask pointer
+ *      @nr_bits: number of bits in the bitmask
+ *
+ * Returns >= nr_bits if no further CPUs/Rx queues set.
+ */
+static inline unsigned int netif_attrmask_next(int n, const unsigned long *srcp,
+                                               unsigned int nr_bits)
+{
+        /* -1 is a legal arg here. */
+        if (n != -1)
+                cpu_max_bits_warn(n, nr_bits);
+
+        if (srcp)
+                return find_next_bit(srcp, nr_bits, n + 1);
+
+        return n + 1;
+}
+
+/**
+ *      netif_attrmask_next_and - get the next CPU/Rx queue in *src1p & *src2p
+ *      @n: CPU/Rx queue index
+ *      @src1p: the first CPUs/Rx queues mask pointer
+ *      @src2p: the second CPUs/Rx queues mask pointer
+ *      @nr_bits: number of bits in the bitmask
+ *
+ * Returns >= nr_bits if no further CPUs/Rx queues set in both.
+ */
+static inline int netif_attrmask_next_and(int n, const unsigned long *src1p,
+                                          const unsigned long *src2p,
+                                          unsigned int nr_bits)
+{
+        /* -1 is a legal arg here. */
+        if (n != -1)
+                cpu_max_bits_warn(n, nr_bits);
+
+        if (src1p && src2p)
+                return find_next_and_bit(src1p, src2p, nr_bits, n + 1);
+        else if (src1p)
+                return find_next_bit(src1p, nr_bits, n + 1);
+        else if (src2p)
+                return find_next_bit(src2p, nr_bits, n + 1);
+
+        return n + 1;
+}
 #else
 static inline int netif_set_xps_queue(struct net_device *dev,
                                       const struct cpumask *mask,
@@ -3285,6 +3412,13 @@ static inline int netif_set_xps_queue(struct net_device *dev,
 {
         return 0;
 }
+
+static inline int __netif_set_xps_queue(struct net_device *dev,
+                                        const unsigned long *mask,
+                                        u16 index, bool is_rxqs_map)
+{
+        return 0;
+}
 #endif
 
 /**
@@ -3304,8 +3438,9 @@ int netif_set_real_num_tx_queues(struct net_device *dev, unsigned int txq);
 int netif_set_real_num_rx_queues(struct net_device *dev, unsigned int rxq);
 #else
 static inline int netif_set_real_num_rx_queues(struct net_device *dev,
-                                                unsigned int rxq)
+                                                unsigned int rxqs)
 {
+        dev->real_num_rx_queues = rxqs;
         return 0;
 }
 #endif
@@ -3384,6 +3519,7 @@ int netif_rx(struct sk_buff *skb);
 int netif_rx_ni(struct sk_buff *skb);
 int netif_receive_skb(struct sk_buff *skb);
 int netif_receive_skb_core(struct sk_buff *skb);
+void netif_receive_skb_list(struct list_head *head);
 gro_result_t napi_gro_receive(struct napi_struct *napi, struct sk_buff *skb);
 void napi_gro_flush(struct napi_struct *napi, bool flush_old);
 struct sk_buff *napi_get_frags(struct napi_struct *napi);
@@ -3418,6 +3554,8 @@ int dev_set_alias(struct net_device *, const char *, size_t);
 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_ext(struct net_device *dev, int mtu,
+                    struct netlink_ext_ack *extack);
 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);
@@ -3435,8 +3573,9 @@ struct sk_buff *dev_hard_start_xmit(struct sk_buff *skb, struct net_device *dev,
 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);
-void __dev_xdp_query(struct net_device *dev, bpf_op_t xdp_op,
-                     struct netdev_bpf *xdp);
+u32 __dev_xdp_query(struct net_device *dev, bpf_op_t xdp_op,
+                    enum bpf_netdev_command cmd);
+int xdp_umem_query(struct net_device *dev, u16 queue_id);
 
 int __dev_forward_skb(struct net_device *dev, struct sk_buff *skb);
 int dev_forward_skb(struct net_device *dev, struct sk_buff *skb);
diff --git a/include/linux/netfilter.h b/include/linux/netfilter.h
index dd2052f0efb7..07efffd0c759 100644
--- a/include/linux/netfilter.h
+++ b/include/linux/netfilter.h
@@ -288,6 +288,24 @@ NF_HOOK(uint8_t pf, unsigned int hook, struct net *net, struct sock *sk, struct
         return ret;
 }
 
+static inline void
+NF_HOOK_LIST(uint8_t pf, unsigned int hook, struct net *net, struct sock *sk,
+             struct list_head *head, struct net_device *in, struct net_device *out,
+             int (*okfn)(struct net *, struct sock *, struct sk_buff *))
+{
+        struct sk_buff *skb, *next;
+        struct list_head sublist;
+
+        INIT_LIST_HEAD(&sublist);
+        list_for_each_entry_safe(skb, next, head, list) {
+                list_del(&skb->list);
+                if (nf_hook(pf, hook, net, sk, skb, in, out, okfn) == 1)
+                        list_add_tail(&skb->list, &sublist);
+        }
+        /* Put passed packets back on main list */
+        list_splice(&sublist, head);
+}
+
 /* Call setsockopt() */
 int nf_setsockopt(struct sock *sk, u_int8_t pf, int optval, char __user *opt,
                   unsigned int len);
@@ -369,6 +387,14 @@ NF_HOOK(uint8_t pf, unsigned int hook, struct net *net, struct sock *sk,
         return okfn(net, sk, skb);
 }
 
+static inline void
+NF_HOOK_LIST(uint8_t pf, unsigned int hook, struct net *net, struct sock *sk,
+             struct list_head *head, struct net_device *in, struct net_device *out,
+             int (*okfn)(struct net *, struct sock *, struct sk_buff *))
+{
+        /* nothing to do */
+}
+
 static inline int nf_hook(u_int8_t pf, unsigned int hook, struct net *net,
                           struct sock *sk, struct sk_buff *skb,
                           struct net_device *indev, struct net_device *outdev,
@@ -388,8 +414,17 @@ nf_nat_decode_session(struct sk_buff *skb, struct flowi *fl, u_int8_t family)
 
 extern void (*ip_ct_attach)(struct sk_buff *, const struct sk_buff *) __rcu;
 void nf_ct_attach(struct sk_buff *, const struct sk_buff *);
+struct nf_conntrack_tuple;
+bool nf_ct_get_tuple_skb(struct nf_conntrack_tuple *dst_tuple,
+                         const struct sk_buff *skb);
 #else
 static inline void nf_ct_attach(struct sk_buff *new, struct sk_buff *skb) {}
+struct nf_conntrack_tuple;
+static inline bool nf_ct_get_tuple_skb(struct nf_conntrack_tuple *dst_tuple,
+                                       const struct sk_buff *skb)
+{
+        return false;
+}
 #endif
 
 struct nf_conn;
@@ -398,6 +433,8 @@ enum ip_conntrack_info;
 struct nf_ct_hook {
         int (*update)(struct net *net, struct sk_buff *skb);
         void (*destroy)(struct nf_conntrack *);
+        bool (*get_tuple_skb)(struct nf_conntrack_tuple *,
+                              const struct sk_buff *);
 };
 extern struct nf_ct_hook __rcu *nf_ct_hook;
 
diff --git a/include/linux/netfilter/nfnetlink.h b/include/linux/netfilter/nfnetlink.h
index 3ecc3050be0e..4a520d3304a2 100644
--- a/include/linux/netfilter/nfnetlink.h
+++ b/include/linux/netfilter/nfnetlink.h
@@ -29,6 +29,7 @@ struct nfnetlink_subsystem {
         __u8 subsys_id;                 /* nfnetlink subsystem ID */
         __u8 cb_count;                  /* number of callbacks */
         const struct nfnl_callback *cb; /* callback for individual types */
+        struct module *owner;
         int (*commit)(struct net *net, struct sk_buff *skb);
         int (*abort)(struct net *net, struct sk_buff *skb);
         void (*cleanup)(struct net *net);
diff --git a/include/linux/netfilter/nf_osf.h b/include/linux/netfilter/nfnetlink_osf.h
index 0e114c492fb8..ecf7dab81e9e 100644
--- a/include/linux/netfilter/nf_osf.h
+++ b/include/linux/netfilter/nfnetlink_osf.h
@@ -1,16 +1,8 @@
-#include <uapi/linux/netfilter/nf_osf.h>
+/* SPDX-License-Identifier: GPL-2.0 */
+#ifndef _NFOSF_H
+#define _NFOSF_H
 
-/* Initial window size option state machine: multiple of mss, mtu or
- * plain numeric value. Can also be made as plain numeric value which
- * is not a multiple of specified value.
- */
-enum nf_osf_window_size_options {
-        OSF_WSS_PLAIN   = 0,
-        OSF_WSS_MSS,
-        OSF_WSS_MTU,
-        OSF_WSS_MODULO,
-        OSF_WSS_MAX,
-};
+#include <uapi/linux/netfilter/nfnetlink_osf.h>
 
 enum osf_fmatch_states {
         /* Packet does not match the fingerprint */
@@ -21,6 +13,8 @@ enum osf_fmatch_states {
         FMATCH_OPT_WRONG,
 };
 
+extern struct list_head nf_osf_fingers[2];
+
 struct nf_osf_finger {
         struct rcu_head                 rcu_head;
         struct list_head                finger_entry;
@@ -31,3 +25,8 @@ bool nf_osf_match(const struct sk_buff *skb, u_int8_t family,
                   int hooknum, struct net_device *in, struct net_device *out,
                   const struct nf_osf_info *info, struct net *net,
                   const struct list_head *nf_osf_fingers);
+
+const char *nf_osf_find(const struct sk_buff *skb,
+                        const struct list_head *nf_osf_fingers);
+
+#endif /* _NFOSF_H */
diff --git a/include/linux/netfilter_bridge.h b/include/linux/netfilter_bridge.h
index b671fdfd212b..fa0686500970 100644
--- a/include/linux/netfilter_bridge.h
+++ b/include/linux/netfilter_bridge.h
@@ -5,17 +5,6 @@
 #include <uapi/linux/netfilter_bridge.h>
 #include <linux/skbuff.h>
 
-enum nf_br_hook_priorities {
-        NF_BR_PRI_FIRST = INT_MIN,
-        NF_BR_PRI_NAT_DST_BRIDGED = -300,
-        NF_BR_PRI_FILTER_BRIDGED = -200,
-        NF_BR_PRI_BRNF = 0,
-        NF_BR_PRI_NAT_DST_OTHER = 100,
-        NF_BR_PRI_FILTER_OTHER = 200,
-        NF_BR_PRI_NAT_SRC = 300,
-        NF_BR_PRI_LAST = INT_MAX,
-};
-
 #if IS_ENABLED(CONFIG_BRIDGE_NETFILTER)
 
 int br_handle_frame_finish(struct net *net, struct sock *sk, struct sk_buff *skb);
diff --git a/include/linux/netfilter_ipv4.h b/include/linux/netfilter_ipv4.h
index b31dabfdb453..95ab5cc64422 100644
--- a/include/linux/netfilter_ipv4.h
+++ b/include/linux/netfilter_ipv4.h
@@ -23,9 +23,6 @@ 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);
@@ -35,14 +32,6 @@ static inline __sum16 nf_ip_checksum(struct sk_buff *skb, unsigned int hook,
 {
         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)
 {
diff --git a/include/linux/netfilter_ipv6.h b/include/linux/netfilter_ipv6.h
index 288c597e75b3..c0dc4dd78887 100644
--- a/include/linux/netfilter_ipv6.h
+++ b/include/linux/netfilter_ipv6.h
@@ -30,11 +30,6 @@ 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);
diff --git a/include/linux/netlink.h b/include/linux/netlink.h
index f3075d6c7e82..71f121b66ca8 100644
--- a/include/linux/netlink.h
+++ b/include/linux/netlink.h
@@ -170,7 +170,6 @@ netlink_skb_clone(struct sk_buff *skb, gfp_t gfp_mask)
 struct netlink_callback {
         struct sk_buff          *skb;
         const struct nlmsghdr   *nlh;
-        int                     (*start)(struct netlink_callback *);
         int                     (*dump)(struct sk_buff * skb,
                                         struct netlink_callback *cb);
         int                     (*done)(struct netlink_callback *cb);
diff --git a/include/linux/nfs4.h b/include/linux/nfs4.h
index 57ffaa20d564..1b06f0b28453 100644
--- a/include/linux/nfs4.h
+++ b/include/linux/nfs4.h
@@ -374,6 +374,13 @@ enum lock_type4 {
         NFS4_WRITEW_LT = 4
 };
 
+enum change_attr_type4 {
+        NFS4_CHANGE_TYPE_IS_MONOTONIC_INCR = 0,
+        NFS4_CHANGE_TYPE_IS_VERSION_COUNTER = 1,
+        NFS4_CHANGE_TYPE_IS_VERSION_COUNTER_NOPNFS = 2,
+        NFS4_CHANGE_TYPE_IS_TIME_METADATA = 3,
+        NFS4_CHANGE_TYPE_IS_UNDEFINED = 4
+};
 
 /* Mandatory Attributes */
 #define FATTR4_WORD0_SUPPORTED_ATTRS    (1UL << 0)
@@ -441,6 +448,7 @@ enum lock_type4 {
 #define FATTR4_WORD2_LAYOUT_BLKSIZE     (1UL << 1)
 #define FATTR4_WORD2_MDSTHRESHOLD       (1UL << 4)
 #define FATTR4_WORD2_CLONE_BLKSIZE      (1UL << 13)
+#define FATTR4_WORD2_CHANGE_ATTR_TYPE   (1UL << 15)
 #define FATTR4_WORD2_SECURITY_LABEL     (1UL << 16)
 #define FATTR4_WORD2_MODE_UMASK         (1UL << 17)
 
@@ -527,6 +535,7 @@ enum {
         NFSPROC4_CLNT_LAYOUTSTATS,
         NFSPROC4_CLNT_CLONE,
         NFSPROC4_CLNT_COPY,
+        NFSPROC4_CLNT_OFFLOAD_CANCEL,
 
         NFSPROC4_CLNT_LOOKUPP,
 };
diff --git a/include/linux/nfs_fs.h b/include/linux/nfs_fs.h
index 2f129bbfaae8..a0831e9d19c9 100644
--- a/include/linux/nfs_fs.h
+++ b/include/linux/nfs_fs.h
@@ -185,6 +185,17 @@ struct nfs_inode {
         struct inode            vfs_inode;
 };
 
+struct nfs4_copy_state {
+        struct list_head        copies;
+        nfs4_stateid            stateid;
+        struct completion       completion;
+        uint64_t                count;
+        struct nfs_writeverf    verf;
+        int                     error;
+        int                     flags;
+        struct nfs4_state       *parent_state;
+};
+
 /*
  * Access bit flags
  */
diff --git a/include/linux/nfs_fs_sb.h b/include/linux/nfs_fs_sb.h
index 74ae3e1d19a0..bf39d9c92201 100644
--- a/include/linux/nfs_fs_sb.h
+++ b/include/linux/nfs_fs_sb.h
@@ -28,7 +28,6 @@ struct nfs41_impl_id;
 struct nfs_client {
         refcount_t              cl_count;
         atomic_t                cl_mds_count;
-        seqcount_t              cl_callback_count;
         int                     cl_cons_state;  /* current construction state (-ve: init error) */
 #define NFS_CS_READY            0               /* ready to be used */
 #define NFS_CS_INITING          1               /* busy initialising */
@@ -122,6 +121,7 @@ struct nfs_client {
 #endif
 
         struct net              *cl_net;
+        struct list_head        pending_cb_stateids;
 };
 
 /*
@@ -209,6 +209,7 @@ struct nfs_server {
         struct list_head        state_owners_lru;
         struct list_head        layouts;
         struct list_head        delegations;
+        struct list_head        ss_copies;
 
         unsigned long           mig_gen;
         unsigned long           mig_status;
@@ -256,5 +257,6 @@ struct nfs_server {
 #define NFS_CAP_LAYOUTSTATS     (1U << 22)
 #define NFS_CAP_CLONE           (1U << 23)
 #define NFS_CAP_COPY            (1U << 24)
+#define NFS_CAP_OFFLOAD_CANCEL  (1U << 25)
 
 #endif
diff --git a/include/linux/nfs_xdr.h b/include/linux/nfs_xdr.h
index 712eed156d09..bd1c889a9ed9 100644
--- a/include/linux/nfs_xdr.h
+++ b/include/linux/nfs_xdr.h
@@ -271,7 +271,6 @@ struct nfs4_layoutget {
         struct nfs4_layoutget_args args;
         struct nfs4_layoutget_res res;
         struct rpc_cred *cred;
-        unsigned callback_count;
         gfp_t gfp_flags;
 };
 
@@ -1389,9 +1388,11 @@ struct nfs42_copy_args {
         u64                             dst_pos;
 
         u64                             count;
+        bool                            sync;
 };
 
 struct nfs42_write_res {
+        nfs4_stateid            stateid;
         u64                     count;
         struct nfs_writeverf    verifier;
 };
@@ -1404,6 +1405,18 @@ struct nfs42_copy_res {
         struct nfs_commitres            commit_res;
 };
 
+struct nfs42_offload_status_args {
+        struct nfs4_sequence_args       osa_seq_args;
+        struct nfs_fh                   *osa_src_fh;
+        nfs4_stateid                    osa_stateid;
+};
+
+struct nfs42_offload_status_res {
+        struct nfs4_sequence_res        osr_seq_res;
+        uint64_t                        osr_count;
+        int                             osr_status;
+};
+
 struct nfs42_seek_args {
         struct nfs4_sequence_args       seq_args;
 
diff --git a/include/linux/node.h b/include/linux/node.h
index 6d336e38d155..257bb3d6d014 100644
--- a/include/linux/node.h
+++ b/include/linux/node.h
@@ -33,10 +33,10 @@ typedef  void (*node_registration_func_t)(struct node *);
 
 #if defined(CONFIG_MEMORY_HOTPLUG_SPARSE) && defined(CONFIG_NUMA)
 extern int link_mem_sections(int nid, unsigned long start_pfn,
-                             unsigned long nr_pages, bool check_nid);
+                             unsigned long end_pfn);
 #else
 static inline int link_mem_sections(int nid, unsigned long start_pfn,
-                                    unsigned long nr_pages, bool check_nid)
+                                    unsigned long end_pfn)
 {
         return 0;
 }
@@ -54,12 +54,14 @@ static inline int register_one_node(int nid)
 
         if (node_online(nid)) {
                 struct pglist_data *pgdat = NODE_DATA(nid);
+                unsigned long start_pfn = pgdat->node_start_pfn;
+                unsigned long end_pfn = start_pfn + pgdat->node_spanned_pages;
 
                 error = __register_one_node(nid);
                 if (error)
                         return error;
                 /* link memory sections under this node */
-                error = link_mem_sections(nid, pgdat->node_start_pfn, pgdat->node_spanned_pages, true);
+                error = link_mem_sections(nid, start_pfn, end_pfn);
         }
 
         return error;
@@ -69,7 +71,7 @@ extern void unregister_one_node(int nid);
 extern int register_cpu_under_node(unsigned int cpu, unsigned int nid);
 extern int unregister_cpu_under_node(unsigned int cpu, unsigned int nid);
 extern int register_mem_sect_under_node(struct memory_block *mem_blk,
-                                                int nid, bool check_nid);
+                                                void *arg);
 extern int unregister_mem_sect_under_nodes(struct memory_block *mem_blk,
                                            unsigned long phys_index);
 
@@ -99,7 +101,7 @@ static inline int unregister_cpu_under_node(unsigned int cpu, unsigned int nid)
         return 0;
 }
 static inline int register_mem_sect_under_node(struct memory_block *mem_blk,
-                                                        int nid, bool check_nid)
+                                                        void *arg)
 {
         return 0;
 }
diff --git a/include/linux/nodemask.h b/include/linux/nodemask.h
index 1fbde8a880d9..5a30ad594ccc 100644
--- a/include/linux/nodemask.h
+++ b/include/linux/nodemask.h
@@ -518,7 +518,7 @@ static inline int node_random(const nodemask_t *mask)
  * NODEMASK_ALLOC(type, name) allocates an object with a specified type and
  * name.
  */
-#if NODES_SHIFT > 8 /* nodemask_t > 256 bytes */
+#if NODES_SHIFT > 8 /* nodemask_t > 32 bytes */
 #define NODEMASK_ALLOC(type, name, gfp_flags)   \
                         type *name = kmalloc(sizeof(*name), gfp_flags)
 #define NODEMASK_FREE(m)                        kfree(m)
diff --git a/include/linux/nvme.h b/include/linux/nvme.h
index 2950ce957656..68e91ef5494c 100644
--- a/include/linux/nvme.h
+++ b/include/linux/nvme.h
@@ -242,7 +242,12 @@ struct nvme_id_ctrl {
         __le32                  sanicap;
         __le32                  hmminds;
         __le16                  hmmaxd;
-        __u8                    rsvd338[174];
+        __u8                    rsvd338[4];
+        __u8                    anatt;
+        __u8                    anacap;
+        __le32                  anagrpmax;
+        __le32                  nanagrpid;
+        __u8                    rsvd352[160];
         __u8                    sqes;
         __u8                    cqes;
         __le16                  maxcmd;
@@ -254,11 +259,12 @@ struct nvme_id_ctrl {
         __le16                  awun;
         __le16                  awupf;
         __u8                    nvscc;
-        __u8                    rsvd531;
+        __u8                    nwpc;
         __le16                  acwu;
         __u8                    rsvd534[2];
         __le32                  sgls;
-        __u8                    rsvd540[228];
+        __le32                  mnan;
+        __u8                    rsvd544[224];
         char                    subnqn[256];
         __u8                    rsvd1024[768];
         __le32                  ioccsz;
@@ -312,7 +318,11 @@ struct nvme_id_ns {
         __le16                  nabspf;
         __le16                  noiob;
         __u8                    nvmcap[16];
-        __u8                    rsvd64[40];
+        __u8                    rsvd64[28];
+        __le32                  anagrpid;
+        __u8                    rsvd96[3];
+        __u8                    nsattr;
+        __u8                    rsvd100[4];
         __u8                    nguid[16];
         __u8                    eui64[8];
         struct nvme_lbaf        lbaf[16];
@@ -425,6 +435,32 @@ struct nvme_effects_log {
         __u8   resv[2048];
 };
 
+enum nvme_ana_state {
+        NVME_ANA_OPTIMIZED              = 0x01,
+        NVME_ANA_NONOPTIMIZED           = 0x02,
+        NVME_ANA_INACCESSIBLE           = 0x03,
+        NVME_ANA_PERSISTENT_LOSS        = 0x04,
+        NVME_ANA_CHANGE                 = 0x0f,
+};
+
+struct nvme_ana_group_desc {
+        __le32  grpid;
+        __le32  nnsids;
+        __le64  chgcnt;
+        __u8    state;
+        __u8    rsvd17[15];
+        __le32  nsids[];
+};
+
+/* flag for the log specific field of the ANA log */
+#define NVME_ANA_LOG_RGO        (1 << 0)
+
+struct nvme_ana_rsp_hdr {
+        __le64  chgcnt;
+        __le16  ngrps;
+        __le16  rsvd10[3];
+};
+
 enum {
         NVME_SMART_CRIT_SPARE           = 1 << 0,
         NVME_SMART_CRIT_TEMPERATURE     = 1 << 1,
@@ -444,11 +480,13 @@ enum {
 enum {
         NVME_AER_NOTICE_NS_CHANGED      = 0x00,
         NVME_AER_NOTICE_FW_ACT_STARTING = 0x01,
+        NVME_AER_NOTICE_ANA             = 0x03,
 };
 
 enum {
         NVME_AEN_CFG_NS_ATTR            = 1 << 8,
         NVME_AEN_CFG_FW_ACT             = 1 << 9,
+        NVME_AEN_CFG_ANA_CHANGE         = 1 << 11,
 };
 
 struct nvme_lba_range_type {
@@ -749,15 +787,22 @@ enum {
         NVME_FEAT_HOST_MEM_BUF  = 0x0d,
         NVME_FEAT_TIMESTAMP     = 0x0e,
         NVME_FEAT_KATO          = 0x0f,
+        NVME_FEAT_HCTM          = 0x10,
+        NVME_FEAT_NOPSC         = 0x11,
+        NVME_FEAT_RRL           = 0x12,
+        NVME_FEAT_PLM_CONFIG    = 0x13,
+        NVME_FEAT_PLM_WINDOW    = 0x14,
         NVME_FEAT_SW_PROGRESS   = 0x80,
         NVME_FEAT_HOST_ID       = 0x81,
         NVME_FEAT_RESV_MASK     = 0x82,
         NVME_FEAT_RESV_PERSIST  = 0x83,
+        NVME_FEAT_WRITE_PROTECT = 0x84,
         NVME_LOG_ERROR          = 0x01,
         NVME_LOG_SMART          = 0x02,
         NVME_LOG_FW_SLOT        = 0x03,
         NVME_LOG_CHANGED_NS     = 0x04,
         NVME_LOG_CMD_EFFECTS    = 0x05,
+        NVME_LOG_ANA            = 0x0c,
         NVME_LOG_DISC           = 0x70,
         NVME_LOG_RESERVATION    = 0x80,
         NVME_FWACT_REPL         = (0 << 3),
@@ -765,6 +810,14 @@ enum {
         NVME_FWACT_ACTV         = (2 << 3),
 };
 
+/* NVMe Namespace Write Protect State */
+enum {
+        NVME_NS_NO_WRITE_PROTECT = 0,
+        NVME_NS_WRITE_PROTECT,
+        NVME_NS_WRITE_PROTECT_POWER_CYCLE,
+        NVME_NS_WRITE_PROTECT_PERMANENT,
+};
+
 #define NVME_MAX_CHANGED_NAMESPACES     1024
 
 struct nvme_identify {
@@ -880,7 +933,7 @@ struct nvme_get_log_page_command {
         __u64                   rsvd2[2];
         union nvme_data_ptr     dptr;
         __u8                    lid;
-        __u8                    rsvd10;
+        __u8                    lsp; /* upper 4 bits reserved */
         __le16                  numdl;
         __le16                  numdu;
         __u16                   rsvd11;
@@ -1111,6 +1164,8 @@ enum {
         NVME_SC_SGL_INVALID_OFFSET      = 0x16,
         NVME_SC_SGL_INVALID_SUBTYPE     = 0x17,
 
+        NVME_SC_NS_WRITE_PROTECTED      = 0x20,
+
         NVME_SC_LBA_RANGE               = 0x80,
         NVME_SC_CAP_EXCEEDED            = 0x81,
         NVME_SC_NS_NOT_READY            = 0x82,
@@ -1180,6 +1235,13 @@ enum {
         NVME_SC_ACCESS_DENIED           = 0x286,
         NVME_SC_UNWRITTEN_BLOCK         = 0x287,
 
+        /*
+         * Path-related Errors:
+         */
+        NVME_SC_ANA_PERSISTENT_LOSS     = 0x301,
+        NVME_SC_ANA_INACCESSIBLE        = 0x302,
+        NVME_SC_ANA_TRANSITION          = 0x303,
+
         NVME_SC_DNR                     = 0x4000,
 };
 
diff --git a/include/linux/of.h b/include/linux/of.h
index 4d25e4f952d9..99b0ebf49632 100644
--- a/include/linux/of.h
+++ b/include/linux/of.h
@@ -256,6 +256,9 @@ static inline unsigned long of_read_ulong(const __be32 *cell, int size)
 #define OF_IS_DYNAMIC(x) test_bit(OF_DYNAMIC, &x->_flags)
 #define OF_MARK_DYNAMIC(x) set_bit(OF_DYNAMIC, &x->_flags)
 
+extern bool of_node_name_eq(const struct device_node *np, const char *name);
+extern bool of_node_name_prefix(const struct device_node *np, const char *prefix);
+
 static inline const char *of_node_full_name(const struct device_node *np)
 {
         return np ? np->full_name : "<no-node>";
@@ -290,6 +293,8 @@ extern struct device_node *of_get_next_child(const struct device_node *node,
 extern struct device_node *of_get_next_available_child(
         const struct device_node *node, struct device_node *prev);
 
+extern struct device_node *of_get_compatible_child(const struct device_node *parent,
+                                        const char *compatible);
 extern struct device_node *of_get_child_by_name(const struct device_node *node,
                                         const char *name);
 
@@ -561,6 +566,16 @@ static inline struct device_node *to_of_node(const struct fwnode_handle *fwnode)
         return NULL;
 }
 
+static inline bool of_node_name_eq(const struct device_node *np, const char *name)
+{
+        return false;
+}
+
+static inline bool of_node_name_prefix(const struct device_node *np, const char *prefix)
+{
+        return false;
+}
+
 static inline const char* of_node_full_name(const struct device_node *np)
 {
         return "<no-node>";
@@ -632,6 +647,12 @@ static inline bool of_have_populated_dt(void)
         return false;
 }
 
+static inline struct device_node *of_get_compatible_child(const struct device_node *parent,
+                                        const char *compatible)
+{
+        return NULL;
+}
+
 static inline struct device_node *of_get_child_by_name(
                                         const struct device_node *node,
                                         const char *name)
@@ -967,6 +988,18 @@ static inline struct device_node *of_find_matching_node(
         return of_find_matching_node_and_match(from, matches, NULL);
 }
 
+static inline const char *of_node_get_device_type(const struct device_node *np)
+{
+        return of_get_property(np, "type", NULL);
+}
+
+static inline bool of_node_is_type(const struct device_node *np, const char *type)
+{
+        const char *match = of_node_get_device_type(np);
+
+        return np && match && type && !strcmp(match, type);
+}
+
 /**
  * of_property_count_u8_elems - Count the number of u8 elements in a property
  *
diff --git a/include/linux/of_iommu.h b/include/linux/of_iommu.h
index 4fa654e4b5a9..f3d40dd7bb66 100644
--- a/include/linux/of_iommu.h
+++ b/include/linux/of_iommu.h
@@ -32,8 +32,4 @@ static inline const struct iommu_ops *of_iommu_configure(struct device *dev,
 
 #endif  /* CONFIG_OF_IOMMU */
 
-extern struct of_device_id __iommu_of_table;
-
-#define IOMMU_OF_DECLARE(name, compat)  OF_DECLARE_1(iommu, name, compat, NULL)
-
 #endif /* __OF_IOMMU_H */
diff --git a/include/linux/omap-mailbox.h b/include/linux/omap-mailbox.h
index c726bd833761..6dbcd2da0332 100644
--- a/include/linux/omap-mailbox.h
+++ b/include/linux/omap-mailbox.h
@@ -1,9 +1,6 @@
+/* SPDX-License-Identifier: GPL-2.0 */
 /*
  * omap-mailbox: interprocessor communication module for OMAP
- *
- * 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 OMAP_MAILBOX_H
diff --git a/include/linux/oom.h b/include/linux/oom.h
index 6adac113e96d..69864a547663 100644
--- a/include/linux/oom.h
+++ b/include/linux/oom.h
@@ -88,14 +88,14 @@ static inline bool mm_is_oom_victim(struct mm_struct *mm)
  *
  * Return 0 when the PF is safe VM_FAULT_SIGBUS otherwise.
  */
-static inline int check_stable_address_space(struct mm_struct *mm)
+static inline vm_fault_t check_stable_address_space(struct mm_struct *mm)
 {
         if (unlikely(test_bit(MMF_UNSTABLE, &mm->flags)))
                 return VM_FAULT_SIGBUS;
         return 0;
 }
 
-void __oom_reap_task_mm(struct mm_struct *mm);
+bool __oom_reap_task_mm(struct mm_struct *mm);
 
 extern unsigned long oom_badness(struct task_struct *p,
                 struct mem_cgroup *memcg, const nodemask_t *nodemask,
diff --git a/include/linux/openvswitch.h b/include/linux/openvswitch.h
index e6b240b6196c..379affc63e24 100644
--- a/include/linux/openvswitch.h
+++ b/include/linux/openvswitch.h
@@ -21,4 +21,9 @@
 
 #include <uapi/linux/openvswitch.h>
 
+#define OVS_CLONE_ATTR_EXEC      0   /* Specify an u32 value. When nonzero,
+                                      * actions in clone will not change flow
+                                      * keys. False otherwise.
+                                      */
+
 #endif /* _LINUX_OPENVSWITCH_H */
diff --git a/include/linux/overflow.h b/include/linux/overflow.h
index 8712ff70995f..40b48e2133cb 100644
--- a/include/linux/overflow.h
+++ b/include/linux/overflow.h
@@ -202,6 +202,37 @@
 
 #endif /* COMPILER_HAS_GENERIC_BUILTIN_OVERFLOW */
 
+/** check_shl_overflow() - Calculate a left-shifted value and check overflow
+ *
+ * @a: Value to be shifted
+ * @s: How many bits left to shift
+ * @d: Pointer to where to store the result
+ *
+ * Computes *@d = (@a << @s)
+ *
+ * Returns true if '*d' cannot hold the result or when 'a << s' doesn't
+ * make sense. Example conditions:
+ * - 'a << s' causes bits to be lost when stored in *d.
+ * - 's' is garbage (e.g. negative) or so large that the result of
+ *   'a << s' is guaranteed to be 0.
+ * - 'a' is negative.
+ * - 'a << s' sets the sign bit, if any, in '*d'.
+ *
+ * '*d' will hold the results of the attempted shift, but is not
+ * considered "safe for use" if false is returned.
+ */
+#define check_shl_overflow(a, s, d) ({                                  \
+        typeof(a) _a = a;                                               \
+        typeof(s) _s = s;                                               \
+        typeof(d) _d = d;                                               \
+        u64 _a_full = _a;                                               \
+        unsigned int _to_shift =                                        \
+                _s >= 0 && _s < 8 * sizeof(*d) ? _s : 0;                \
+        *_d = (_a_full << _to_shift);                                   \
+        (_to_shift != _s || *_d < 0 || _a < 0 ||                        \
+                (*_d >> _to_shift) != _a);                              \
+})
+
 /**
  * array_size() - Calculate size of 2-dimensional array.
  *
diff --git a/include/linux/page-flags.h b/include/linux/page-flags.h
index 901943e4754b..74bee8cecf4c 100644
--- a/include/linux/page-flags.h
+++ b/include/linux/page-flags.h
@@ -369,8 +369,13 @@ PAGEFLAG_FALSE(Uncached)
 PAGEFLAG(HWPoison, hwpoison, PF_ANY)
 TESTSCFLAG(HWPoison, hwpoison, PF_ANY)
 #define __PG_HWPOISON (1UL << PG_hwpoison)
+extern bool set_hwpoison_free_buddy_page(struct page *page);
 #else
 PAGEFLAG_FALSE(HWPoison)
+static inline bool set_hwpoison_free_buddy_page(struct page *page)
+{
+        return 0;
+}
 #define __PG_HWPOISON 0
 #endif
 
diff --git a/include/linux/page_ext.h b/include/linux/page_ext.h
index ca5461efae2f..f84f167ec04c 100644
--- a/include/linux/page_ext.h
+++ b/include/linux/page_ext.h
@@ -16,18 +16,7 @@ struct page_ext_operations {
 
 #ifdef CONFIG_PAGE_EXTENSION
 
-/*
- * page_ext->flags bits:
- *
- * PAGE_EXT_DEBUG_POISON is set for poisoned pages. This is used to
- * implement generic debug pagealloc feature. The pages are filled with
- * poison patterns and set this flag after free_pages(). The poisoned
- * pages are verified whether the patterns are not corrupted and clear
- * the flag before alloc_pages().
- */
-
 enum page_ext_flags {
-        PAGE_EXT_DEBUG_POISON,          /* Page is poisoned */
         PAGE_EXT_DEBUG_GUARD,
         PAGE_EXT_OWNER,
 #if defined(CONFIG_IDLE_PAGE_TRACKING) && !defined(CONFIG_64BIT)
@@ -61,7 +50,7 @@ static inline void page_ext_init(void)
 }
 #endif
 
-struct page_ext *lookup_page_ext(struct page *page);
+struct page_ext *lookup_page_ext(const struct page *page);
 
 #else /* !CONFIG_PAGE_EXTENSION */
 struct page_ext;
@@ -70,7 +59,7 @@ static inline void pgdat_page_ext_init(struct pglist_data *pgdat)
 {
 }
 
-static inline struct page_ext *lookup_page_ext(struct page *page)
+static inline struct page_ext *lookup_page_ext(const struct page *page)
 {
         return NULL;
 }
diff --git a/include/linux/pci-dma-compat.h b/include/linux/pci-dma-compat.h
index 0dd1a3f7b309..c3f1b44ade29 100644
--- a/include/linux/pci-dma-compat.h
+++ b/include/linux/pci-dma-compat.h
@@ -8,10 +8,10 @@
 #include <linux/dma-mapping.h>
 
 /* This defines the direction arg to the DMA mapping routines. */
-#define PCI_DMA_BIDIRECTIONAL   0
-#define PCI_DMA_TODEVICE        1
-#define PCI_DMA_FROMDEVICE      2
-#define PCI_DMA_NONE            3
+#define PCI_DMA_BIDIRECTIONAL   DMA_BIDIRECTIONAL
+#define PCI_DMA_TODEVICE        DMA_TO_DEVICE
+#define PCI_DMA_FROMDEVICE      DMA_FROM_DEVICE
+#define PCI_DMA_NONE            DMA_NONE
 
 static inline void *
 pci_alloc_consistent(struct pci_dev *hwdev, size_t size,
diff --git a/include/linux/pci-epc.h b/include/linux/pci-epc.h
index 243eaa5a66ff..37dab8116901 100644
--- a/include/linux/pci-epc.h
+++ b/include/linux/pci-epc.h
@@ -17,6 +17,7 @@ enum pci_epc_irq_type {
         PCI_EPC_IRQ_UNKNOWN,
         PCI_EPC_IRQ_LEGACY,
         PCI_EPC_IRQ_MSI,
+        PCI_EPC_IRQ_MSIX,
 };
 
 /**
@@ -30,7 +31,11 @@ enum pci_epc_irq_type {
  *           capability register
  * @get_msi: ops to get the number of MSI interrupts allocated by the RC from
  *           the MSI capability register
- * @raise_irq: ops to raise a legacy or MSI interrupt
+ * @set_msix: ops to set the requested number of MSI-X interrupts in the
+ *           MSI-X capability register
+ * @get_msix: ops to get the number of MSI-X interrupts allocated by the RC
+ *           from the MSI-X capability register
+ * @raise_irq: ops to raise a legacy, MSI or MSI-X interrupt
  * @start: ops to start the PCI link
  * @stop: ops to stop the PCI link
  * @owner: the module owner containing the ops
@@ -48,8 +53,10 @@ struct pci_epc_ops {
                               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     (*set_msix)(struct pci_epc *epc, u8 func_no, u16 interrupts);
+        int     (*get_msix)(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);
+                             enum pci_epc_irq_type type, u16 interrupt_num);
         int     (*start)(struct pci_epc *epc);
         void    (*stop)(struct pci_epc *epc);
         struct module *owner;
@@ -95,6 +102,7 @@ struct pci_epc {
 
 #define EPC_FEATURE_NO_LINKUP_NOTIFIER          BIT(0)
 #define EPC_FEATURE_BAR_MASK                    (BIT(1) | BIT(2) | BIT(3))
+#define EPC_FEATURE_MSIX_AVAILABLE              BIT(4)
 #define EPC_FEATURE_SET_BAR(features, bar)      \
                 (features |= (EPC_FEATURE_BAR_MASK & (bar << 1)))
 #define EPC_FEATURE_GET_BAR(features)           \
@@ -144,8 +152,10 @@ 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_set_msix(struct pci_epc *epc, u8 func_no, u16 interrupts);
+int pci_epc_get_msix(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);
+                      enum pci_epc_irq_type type, u16 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 4e7764935fa8..ec02f58758c8 100644
--- a/include/linux/pci-epf.h
+++ b/include/linux/pci-epf.h
@@ -119,6 +119,7 @@ struct pci_epf {
         struct pci_epf_header   *header;
         struct pci_epf_bar      bar[6];
         u8                      msi_interrupts;
+        u16                     msix_interrupts;
         u8                      func_no;
 
         struct pci_epc          *epc;
diff --git a/include/linux/pci.h b/include/linux/pci.h
index c133ccfa002e..e72ca8dd6241 100644
--- a/include/linux/pci.h
+++ b/include/linux/pci.h
@@ -261,6 +261,9 @@ enum pci_bus_speed {
         PCI_SPEED_UNKNOWN               = 0xff,
 };
 
+enum pci_bus_speed pcie_get_speed_cap(struct pci_dev *dev);
+enum pcie_link_width pcie_get_width_cap(struct pci_dev *dev);
+
 struct pci_cap_saved_data {
         u16             cap_nr;
         bool            cap_extended;
@@ -299,6 +302,7 @@ struct pci_dev {
         u8              hdr_type;       /* PCI header type (`multi' flag masked out) */
 #ifdef CONFIG_PCIEAER
         u16             aer_cap;        /* AER capability offset */
+        struct aer_stats *aer_stats;    /* AER stats for this device */
 #endif
         u8              pcie_cap;       /* PCIe capability offset */
         u8              msi_cap;        /* MSI capability offset */
@@ -350,6 +354,7 @@ struct pci_dev {
         unsigned int    ltr_path:1;     /* Latency Tolerance Reporting
                                            supported from root to here */
 #endif
+        unsigned int    eetlp_prefix_path:1;    /* End-to-End TLP Prefix */
 
         pci_channel_state_t error_state;        /* Current connectivity state */
         struct device   dev;                    /* Generic device interface */
@@ -387,6 +392,7 @@ struct pci_dev {
         unsigned int    is_virtfn:1;
         unsigned int    reset_fn:1;
         unsigned int    is_hotplug_bridge:1;
+        unsigned int    shpc_managed:1;         /* SHPC owned by shpchp */
         unsigned int    is_thunderbolt:1;       /* Thunderbolt controller */
         unsigned int    __aer_firmware_first_valid:1;
         unsigned int    __aer_firmware_first:1;
@@ -818,6 +824,21 @@ struct pci_driver {
         .vendor = PCI_VENDOR_ID_##vend, .device = (dev), \
         .subvendor = PCI_ANY_ID, .subdevice = PCI_ANY_ID, 0, 0
 
+/**
+ * PCI_DEVICE_DATA - macro used to describe a specific PCI device in very short form
+ * @vend: the vendor name (without PCI_VENDOR_ID_ prefix)
+ * @dev: the device name (without PCI_DEVICE_ID_<vend>_ prefix)
+ * @data: the driver data to be filled
+ *
+ * This macro is used to create a struct pci_device_id that matches a
+ * specific PCI device.  The subvendor, and subdevice fields will be set
+ * to PCI_ANY_ID.
+ */
+#define PCI_DEVICE_DATA(vend, dev, data) \
+        .vendor = PCI_VENDOR_ID_##vend, .device = PCI_DEVICE_ID_##vend##_##dev, \
+        .subvendor = PCI_ANY_ID, .subdevice = PCI_ANY_ID, 0, 0, \
+        .driver_data = (kernel_ulong_t)(data)
+
 enum {
         PCI_REASSIGN_ALL_RSRC   = 0x00000001,   /* Ignore firmware setup */
         PCI_REASSIGN_ALL_BUS    = 0x00000002,   /* Reassign all bus numbers */
@@ -1088,20 +1109,17 @@ u32 pcie_bandwidth_available(struct pci_dev *dev, struct pci_dev **limiting_dev,
                              enum pci_bus_speed *speed,
                              enum pcie_link_width *width);
 void pcie_print_link_status(struct pci_dev *dev);
+bool pcie_has_flr(struct pci_dev *dev);
 int pcie_flr(struct pci_dev *dev);
 int __pci_reset_function_locked(struct pci_dev *dev);
 int pci_reset_function(struct pci_dev *dev);
 int pci_reset_function_locked(struct pci_dev *dev);
 int pci_try_reset_function(struct pci_dev *dev);
 int pci_probe_reset_slot(struct pci_slot *slot);
-int pci_reset_slot(struct pci_slot *slot);
-int pci_try_reset_slot(struct pci_slot *slot);
 int pci_probe_reset_bus(struct pci_bus *bus);
-int pci_reset_bus(struct pci_bus *bus);
-int pci_try_reset_bus(struct pci_bus *bus);
+int pci_reset_bus(struct pci_dev *dev);
 void pci_reset_secondary_bus(struct pci_dev *dev);
 void pcibios_reset_secondary_bus(struct pci_dev *dev);
-int pci_reset_bridge_secondary_bus(struct pci_dev *dev);
 void pci_update_resource(struct pci_dev *dev, int resno);
 int __must_check pci_assign_resource(struct pci_dev *dev, int i);
 int __must_check pci_reassign_resource(struct pci_dev *dev, int i, resource_size_t add_size, resource_size_t align);
@@ -1121,7 +1139,6 @@ int pci_enable_rom(struct pci_dev *pdev);
 void pci_disable_rom(struct pci_dev *pdev);
 void __iomem __must_check *pci_map_rom(struct pci_dev *pdev, size_t *size);
 void pci_unmap_rom(struct pci_dev *pdev, void __iomem *rom);
-size_t pci_get_rom_size(struct pci_dev *pdev, void __iomem *rom, size_t size);
 void __iomem __must_check *pci_platform_rom(struct pci_dev *pdev, size_t *size);
 
 /* Power management related routines */
@@ -1469,13 +1486,9 @@ static inline bool pcie_aspm_support_enabled(void) { return false; }
 #endif
 
 #ifdef CONFIG_PCIEAER
-void pci_no_aer(void);
 bool pci_aer_available(void);
-int pci_aer_init(struct pci_dev *dev);
 #else
-static inline void pci_no_aer(void) { }
 static inline bool pci_aer_available(void) { return false; }
-static inline int pci_aer_init(struct pci_dev *d) { return -ENODEV; }
 #endif
 
 #ifdef CONFIG_PCIE_ECRC
@@ -1796,7 +1809,11 @@ struct pci_fixup {
         u16 device;                     /* Or PCI_ANY_ID */
         u32 class;                      /* Or PCI_ANY_ID */
         unsigned int class_shift;       /* should be 0, 8, 16 */
+#ifdef CONFIG_HAVE_ARCH_PREL32_RELOCATIONS
+        int hook_offset;
+#else
         void (*hook)(struct pci_dev *dev);
+#endif
 };
 
 enum pci_fixup_pass {
@@ -1810,12 +1827,28 @@ enum pci_fixup_pass {
         pci_fixup_suspend_late, /* pci_device_suspend_late() */
 };
 
+#ifdef CONFIG_HAVE_ARCH_PREL32_RELOCATIONS
+#define __DECLARE_PCI_FIXUP_SECTION(sec, name, vendor, device, class,   \
+                                    class_shift, hook)                  \
+        __ADDRESSABLE(hook)                                             \
+        asm(".section " #sec ", \"a\"                           \n"     \
+            ".balign    16                                      \n"     \
+            ".short "   #vendor ", " #device "                  \n"     \
+            ".long "    #class ", " #class_shift "              \n"     \
+            ".long "    #hook " - .                             \n"     \
+            ".previous                                          \n");
+#define DECLARE_PCI_FIXUP_SECTION(sec, name, vendor, device, class,     \
+                                  class_shift, hook)                    \
+        __DECLARE_PCI_FIXUP_SECTION(sec, name, vendor, device, class,   \
+                                  class_shift, hook)
+#else
 /* Anonymous variables would be nice... */
 #define DECLARE_PCI_FIXUP_SECTION(section, name, vendor, device, class, \
                                   class_shift, hook)                    \
         static const struct pci_fixup __PASTE(__pci_fixup_##name,__LINE__) __used       \
         __attribute__((__section__(#section), aligned((sizeof(void *)))))    \
                 = { vendor, device, class, class_shift, hook };
+#endif
 
 #define DECLARE_PCI_FIXUP_CLASS_EARLY(vendor, device, class,            \
                                          class_shift, hook)             \
@@ -1877,20 +1910,9 @@ enum pci_fixup_pass {
 
 #ifdef CONFIG_PCI_QUIRKS
 void pci_fixup_device(enum pci_fixup_pass pass, struct pci_dev *dev);
-int pci_dev_specific_acs_enabled(struct pci_dev *dev, u16 acs_flags);
-int pci_dev_specific_enable_acs(struct pci_dev *dev);
 #else
 static inline void pci_fixup_device(enum pci_fixup_pass pass,
                                     struct pci_dev *dev) { }
-static inline int pci_dev_specific_acs_enabled(struct pci_dev *dev,
-                                               u16 acs_flags)
-{
-        return -ENOTTY;
-}
-static inline int pci_dev_specific_enable_acs(struct pci_dev *dev)
-{
-        return -ENOTTY;
-}
 #endif
 
 void __iomem *pcim_iomap(struct pci_dev *pdev, int bar, unsigned long maxlen);
diff --git a/include/linux/pci_hotplug.h b/include/linux/pci_hotplug.h
index cf5e22103f68..a6d6650a0490 100644
--- a/include/linux/pci_hotplug.h
+++ b/include/linux/pci_hotplug.h
@@ -80,15 +80,12 @@ struct hotplug_slot_info {
  * @ops: pointer to the &struct hotplug_slot_ops to be used for this slot
  * @info: pointer to the &struct hotplug_slot_info for the initial values for
  * this slot.
- * @release: called during pci_hp_deregister to free memory allocated in a
- * hotplug_slot structure.
  * @private: used by the hotplug pci controller driver to store whatever it
  * needs.
  */
 struct hotplug_slot {
         struct hotplug_slot_ops         *ops;
         struct hotplug_slot_info        *info;
-        void (*release) (struct hotplug_slot *slot);
         void                            *private;
 
         /* Variables below this are for use only by the hotplug pci core. */
@@ -104,13 +101,23 @@ static inline const char *hotplug_slot_name(const struct hotplug_slot *slot)
 int __pci_hp_register(struct hotplug_slot *slot, struct pci_bus *pbus, int nr,
                       const char *name, struct module *owner,
                       const char *mod_name);
-int pci_hp_deregister(struct hotplug_slot *slot);
+int __pci_hp_initialize(struct hotplug_slot *slot, struct pci_bus *bus, int nr,
+                        const char *name, struct module *owner,
+                        const char *mod_name);
+int pci_hp_add(struct hotplug_slot *slot);
+
+void pci_hp_del(struct hotplug_slot *slot);
+void pci_hp_destroy(struct hotplug_slot *slot);
+void pci_hp_deregister(struct hotplug_slot *slot);
+
 int __must_check pci_hp_change_slot_info(struct hotplug_slot *slot,
                                          struct hotplug_slot_info *info);
 
 /* use a define to avoid include chaining to get THIS_MODULE & friends */
 #define pci_hp_register(slot, pbus, devnr, name) \
         __pci_hp_register(slot, pbus, devnr, name, THIS_MODULE, KBUILD_MODNAME)
+#define pci_hp_initialize(slot, bus, nr, name) \
+        __pci_hp_initialize(slot, bus, nr, name, THIS_MODULE, KBUILD_MODNAME)
 
 /* PCI Setting Record (Type 0) */
 struct hpp_type0 {
diff --git a/include/linux/pci_ids.h b/include/linux/pci_ids.h
index 29502238e510..d157983b84cf 100644
--- a/include/linux/pci_ids.h
+++ b/include/linux/pci_ids.h
@@ -1668,6 +1668,7 @@
 #define PCI_DEVICE_ID_COMPEX_ENET100VG4 0x0112
 
 #define PCI_VENDOR_ID_PMC_Sierra        0x11f8
+#define PCI_VENDOR_ID_MICROSEMI         0x11f8
 
 #define PCI_VENDOR_ID_RP                0x11fe
 #define PCI_DEVICE_ID_RP32INTF          0x0001
@@ -2541,6 +2542,7 @@
 #define PCI_DEVICE_ID_NETRONOME_NFP3200 0x3200
 #define PCI_DEVICE_ID_NETRONOME_NFP3240 0x3240
 #define PCI_DEVICE_ID_NETRONOME_NFP4000 0x4000
+#define PCI_DEVICE_ID_NETRONOME_NFP5000 0x5000
 #define PCI_DEVICE_ID_NETRONOME_NFP6000 0x6000
 #define PCI_DEVICE_ID_NETRONOME_NFP6000_VF      0x6003
 
@@ -3082,4 +3084,6 @@
 
 #define PCI_VENDOR_ID_OCZ               0x1b85
 
+#define PCI_VENDOR_ID_NCUBE             0x10ff
+
 #endif /* _LINUX_PCI_IDS_H */
diff --git a/include/linux/percpu.h b/include/linux/percpu.h
index 296bbe49d5d1..70b7123f38c7 100644
--- a/include/linux/percpu.h
+++ b/include/linux/percpu.h
@@ -149,4 +149,6 @@ extern phys_addr_t per_cpu_ptr_to_phys(void *addr);
         (typeof(type) __percpu *)__alloc_percpu(sizeof(type),           \
                                                 __alignof__(type))
 
+extern unsigned long pcpu_nr_pages(void);
+
 #endif /* __LINUX_PERCPU_H */
diff --git a/include/linux/percpu_ida.h b/include/linux/percpu_ida.h
deleted file mode 100644
index 07d78e4653bc..000000000000
--- a/include/linux/percpu_ida.h
+++ /dev/null
@@ -1,83 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-#ifndef __PERCPU_IDA_H__
-#define __PERCPU_IDA_H__
-
-#include <linux/types.h>
-#include <linux/bitops.h>
-#include <linux/init.h>
-#include <linux/sched.h>
-#include <linux/spinlock_types.h>
-#include <linux/wait.h>
-#include <linux/cpumask.h>
-
-struct percpu_ida_cpu;
-
-struct percpu_ida {
-        /*
-         * number of tags available to be allocated, as passed to
-         * percpu_ida_init()
-         */
-        unsigned                        nr_tags;
-        unsigned                        percpu_max_size;
-        unsigned                        percpu_batch_size;
-
-        struct percpu_ida_cpu __percpu  *tag_cpu;
-
-        /*
-         * Bitmap of cpus that (may) have tags on their percpu freelists:
-         * steal_tags() uses this to decide when to steal tags, and which cpus
-         * to try stealing from.
-         *
-         * It's ok for a freelist to be empty when its bit is set - steal_tags()
-         * will just keep looking - but the bitmap _must_ be set whenever a
-         * percpu freelist does have tags.
-         */
-        cpumask_t                       cpus_have_tags;
-
-        struct {
-                spinlock_t              lock;
-                /*
-                 * When we go to steal tags from another cpu (see steal_tags()),
-                 * we want to pick a cpu at random. Cycling through them every
-                 * time we steal is a bit easier and more or less equivalent:
-                 */
-                unsigned                cpu_last_stolen;
-
-                /* For sleeping on allocation failure */
-                wait_queue_head_t       wait;
-
-                /*
-                 * Global freelist - it's a stack where nr_free points to the
-                 * top
-                 */
-                unsigned                nr_free;
-                unsigned                *freelist;
-        } ____cacheline_aligned_in_smp;
-};
-
-/*
- * Number of tags we move between the percpu freelist and the global freelist at
- * a time
- */
-#define IDA_DEFAULT_PCPU_BATCH_MOVE     32U
-/* Max size of percpu freelist, */
-#define IDA_DEFAULT_PCPU_SIZE   ((IDA_DEFAULT_PCPU_BATCH_MOVE * 3) / 2)
-
-int percpu_ida_alloc(struct percpu_ida *pool, int state);
-void percpu_ida_free(struct percpu_ida *pool, unsigned tag);
-
-void percpu_ida_destroy(struct percpu_ida *pool);
-int __percpu_ida_init(struct percpu_ida *pool, unsigned long nr_tags,
-        unsigned long max_size, unsigned long batch_size);
-static inline int percpu_ida_init(struct percpu_ida *pool, unsigned long nr_tags)
-{
-        return __percpu_ida_init(pool, nr_tags, IDA_DEFAULT_PCPU_SIZE,
-                IDA_DEFAULT_PCPU_BATCH_MOVE);
-}
-
-typedef int (*percpu_ida_cb)(unsigned, void *);
-int percpu_ida_for_each_free(struct percpu_ida *pool, percpu_ida_cb fn,
-        void *data);
-
-unsigned percpu_ida_free_tags(struct percpu_ida *pool, int cpu);
-#endif /* __PERCPU_IDA_H__ */
diff --git a/include/linux/perf/arm_pmu.h b/include/linux/perf/arm_pmu.h
index ad5444491975..10f92e1d8e7b 100644
--- a/include/linux/perf/arm_pmu.h
+++ b/include/linux/perf/arm_pmu.h
@@ -25,6 +25,12 @@
  */
 #define ARMPMU_MAX_HWEVENTS             32
 
+/*
+ * ARM PMU hw_event flags
+ */
+/* Event uses a 64bit counter */
+#define ARMPMU_EVT_64BIT                1
+
 #define HW_OP_UNSUPPORTED               0xFFFF
 #define C(_x)                           PERF_COUNT_HW_CACHE_##_x
 #define CACHE_OP_UNSUPPORTED            0xFFFF
@@ -87,14 +93,13 @@ struct arm_pmu {
                                          struct perf_event *event);
         int             (*set_event_filter)(struct hw_perf_event *evt,
                                             struct perf_event_attr *attr);
-        u32             (*read_counter)(struct perf_event *event);
-        void            (*write_counter)(struct perf_event *event, u32 val);
+        u64             (*read_counter)(struct perf_event *event);
+        void            (*write_counter)(struct perf_event *event, u64 val);
         void            (*start)(struct arm_pmu *);
         void            (*stop)(struct arm_pmu *);
         void            (*reset)(void *);
         int             (*map_event)(struct perf_event *event);
         int             num_events;
-        u64             max_period;
         bool            secure_access; /* 32-bit ARM only */
 #define ARMV8_PMUV3_MAX_COMMON_EVENTS 0x40
         DECLARE_BITMAP(pmceid_bitmap, ARMV8_PMUV3_MAX_COMMON_EVENTS);
diff --git a/include/linux/phy.h b/include/linux/phy.h
index 6cd09098427c..cd6f637cbbfb 100644
--- a/include/linux/phy.h
+++ b/include/linux/phy.h
@@ -825,6 +825,16 @@ static inline bool phy_interrupt_is_valid(struct phy_device *phydev)
 }
 
 /**
+ * phy_polling_mode - Convenience function for testing whether polling is
+ * used to detect PHY status changes
+ * @phydev: the phy_device struct
+ */
+static inline bool phy_polling_mode(struct phy_device *phydev)
+{
+        return phydev->irq == PHY_POLL;
+}
+
+/**
  * phy_is_internal - Convenience function for testing if a PHY is internal
  * @phydev: the phy_device struct
  */
@@ -942,6 +952,8 @@ void phy_start(struct phy_device *phydev);
 void phy_stop(struct phy_device *phydev);
 int phy_start_aneg(struct phy_device *phydev);
 int phy_aneg_done(struct phy_device *phydev);
+int phy_speed_down(struct phy_device *phydev, bool sync);
+int phy_speed_up(struct phy_device *phydev);
 
 int phy_stop_interrupts(struct phy_device *phydev);
 int phy_restart_aneg(struct phy_device *phydev);
diff --git a/include/linux/phylink.h b/include/linux/phylink.h
index 50eeae025f1e..021fc6595856 100644
--- a/include/linux/phylink.h
+++ b/include/linux/phylink.h
@@ -234,5 +234,6 @@ int phylink_mii_ioctl(struct phylink *, struct ifreq *, int);
 #define phylink_test(bm, mode)  __phylink_do_bit(test_bit, bm, mode)
 
 void phylink_set_port_modes(unsigned long *bits);
+void phylink_helper_basex_speed(struct phylink_link_state *state);
 
 #endif
diff --git a/include/linux/pid.h b/include/linux/pid.h
index 7633d55d9a24..14a9a39da9c7 100644
--- a/include/linux/pid.h
+++ b/include/linux/pid.h
@@ -7,11 +7,10 @@
 enum pid_type
 {
         PIDTYPE_PID,
+        PIDTYPE_TGID,
         PIDTYPE_PGID,
         PIDTYPE_SID,
         PIDTYPE_MAX,
-        /* only valid to __task_pid_nr_ns() */
-        __PIDTYPE_TGID
 };
 
 /*
@@ -67,12 +66,6 @@ struct pid
 
 extern struct pid init_struct_pid;
 
-struct pid_link
-{
-        struct hlist_node node;
-        struct pid *pid;
-};
-
 static inline struct pid *get_pid(struct pid *pid)
 {
         if (pid)
@@ -177,7 +170,7 @@ pid_t pid_vnr(struct pid *pid);
         do {                                                            \
                 if ((pid) != NULL)                                      \
                         hlist_for_each_entry_rcu((task),                \
-                                &(pid)->tasks[type], pids[type].node) {
+                                &(pid)->tasks[type], pid_links[type]) {
 
                         /*
                          * Both old and new leaders may be attached to
diff --git a/include/linux/pinctrl/pinconf.h b/include/linux/pinctrl/pinconf.h
index 09eb80f2574a..8dd85d302b90 100644
--- a/include/linux/pinctrl/pinconf.h
+++ b/include/linux/pinctrl/pinconf.h
@@ -28,7 +28,8 @@ struct seq_file;
  *      is not available on this controller this should return -ENOTSUPP
  *      and if it is available but disabled it should return -EINVAL
  * @pin_config_set: configure an individual pin
- * @pin_config_group_get: get configurations for an entire pin group
+ * @pin_config_group_get: get configurations for an entire pin group; should
+ *      return -ENOTSUPP and -EINVAL using the same rules as pin_config_get.
  * @pin_config_group_set: configure all pins in a group
  * @pin_config_dbg_parse_modify: optional debugfs to modify a pin configuration
  * @pin_config_dbg_show: optional debugfs display hook that will provide
diff --git a/include/linux/platform_data/ams-delta-fiq.h b/include/linux/platform_data/ams-delta-fiq.h
new file mode 100644
index 000000000000..cf4589ccb720
--- /dev/null
+++ b/include/linux/platform_data/ams-delta-fiq.h
@@ -0,0 +1,58 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+
+/*
+ * include/linux/platform_data/ams-delta-fiq.h
+ *
+ * Taken from the original Amstrad modifications to fiq.h
+ *
+ * Copyright (c) 2004 Amstrad Plc
+ * Copyright (c) 2006 Matt Callow
+ * Copyright (c) 2010 Janusz Krzysztofik
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ */
+#ifndef __LINUX_PLATFORM_DATA_AMS_DELTA_FIQ_H
+#define __LINUX_PLATFORM_DATA_AMS_DELTA_FIQ_H
+
+/*
+ * These are the offsets from the beginning of the fiq_buffer. They are put here
+ * since the buffer and header need to be accessed by drivers servicing devices
+ * which generate GPIO interrupts - e.g. keyboard, modem, hook switch.
+ */
+#define FIQ_MASK                 0
+#define FIQ_STATE                1
+#define FIQ_KEYS_CNT             2
+#define FIQ_TAIL_OFFSET          3
+#define FIQ_HEAD_OFFSET          4
+#define FIQ_BUF_LEN              5
+#define FIQ_KEY                  6
+#define FIQ_MISSED_KEYS          7
+#define FIQ_BUFFER_START         8
+#define FIQ_GPIO_INT_MASK        9
+#define FIQ_KEYS_HICNT          10
+#define FIQ_IRQ_PEND            11
+#define FIQ_SIR_CODE_L1         12
+#define IRQ_SIR_CODE_L2         13
+
+#define FIQ_CNT_INT_00          14
+#define FIQ_CNT_INT_KEY         15
+#define FIQ_CNT_INT_MDM         16
+#define FIQ_CNT_INT_03          17
+#define FIQ_CNT_INT_HSW         18
+#define FIQ_CNT_INT_05          19
+#define FIQ_CNT_INT_06          20
+#define FIQ_CNT_INT_07          21
+#define FIQ_CNT_INT_08          22
+#define FIQ_CNT_INT_09          23
+#define FIQ_CNT_INT_10          24
+#define FIQ_CNT_INT_11          25
+#define FIQ_CNT_INT_12          26
+#define FIQ_CNT_INT_13          27
+#define FIQ_CNT_INT_14          28
+#define FIQ_CNT_INT_15          29
+
+#define FIQ_CIRC_BUFF           30      /*Start of circular buffer */
+
+#endif
diff --git a/include/linux/platform_data/bt-nokia-h4p.h b/include/linux/platform_data/bt-nokia-h4p.h
deleted file mode 100644
index 30d169dfadf3..000000000000
--- a/include/linux/platform_data/bt-nokia-h4p.h
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
- * This file is part of Nokia H4P bluetooth driver
- *
- * Copyright (C) 2010 Nokia Corporation.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * version 2 as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
- * 02110-1301 USA
- *
- */
-
-
-/**
- * struct hci_h4p_platform data - hci_h4p Platform data structure
- */
-struct hci_h4p_platform_data {
-        int chip_type;
-        int bt_sysclk;
-        unsigned int bt_wakeup_gpio;
-        unsigned int host_wakeup_gpio;
-        unsigned int reset_gpio;
-        int reset_gpio_shared;
-        unsigned int uart_irq;
-        phys_addr_t uart_base;
-        const char *uart_iclk;
-        const char *uart_fclk;
-        void (*set_pm_limits)(struct device *dev, bool set);
-};
diff --git a/include/linux/platform_data/gpio-davinci.h b/include/linux/platform_data/gpio-davinci.h
index 90ae19ca828f..57a5a35e0073 100644
--- a/include/linux/platform_data/gpio-davinci.h
+++ b/include/linux/platform_data/gpio-davinci.h
@@ -22,6 +22,7 @@
 #include <asm-generic/gpio.h>
 
 #define MAX_REGS_BANKS          5
+#define MAX_INT_PER_BANK 32
 
 struct davinci_gpio_platform_data {
         u32     ngpio;
@@ -41,7 +42,7 @@ struct davinci_gpio_controller {
         spinlock_t              lock;
         void __iomem            *regs[MAX_REGS_BANKS];
         int                     gpio_unbanked;
-        unsigned int            base_irq;
+        int                     irqs[MAX_INT_PER_BANK];
         unsigned int            base;
 };
 
diff --git a/include/linux/platform_data/i2c-hid.h b/include/linux/platform_data/i2c-hid.h
index 1fb088239d12..c628bb5e1061 100644
--- a/include/linux/platform_data/i2c-hid.h
+++ b/include/linux/platform_data/i2c-hid.h
@@ -12,14 +12,13 @@
 #ifndef __LINUX_I2C_HID_H
 #define __LINUX_I2C_HID_H
 
+#include <linux/regulator/consumer.h>
 #include <linux/types.h>
 
-struct regulator;
-
 /**
  * struct i2chid_platform_data - used by hid over i2c implementation.
  * @hid_descriptor_address: i2c register where the HID descriptor is stored.
- * @supply: regulator for powering on the device.
+ * @supplies: regulators for powering on the device.
  * @post_power_delay_ms: delay after powering on before device is usable.
  *
  * Note that it is the responsibility of the platform driver (or the acpi 5.0
@@ -35,7 +34,7 @@ struct regulator;
  */
 struct i2c_hid_platform_data {
         u16 hid_descriptor_address;
-        struct regulator *supply;
+        struct regulator_bulk_data supplies[2];
         int post_power_delay_ms;
 };
 
diff --git a/include/linux/platform_data/i2c-ocores.h b/include/linux/platform_data/i2c-ocores.h
index 01edd96fe1f7..113d6b12f650 100644
--- a/include/linux/platform_data/i2c-ocores.h
+++ b/include/linux/platform_data/i2c-ocores.h
@@ -1,7 +1,7 @@
 /*
  * i2c-ocores.h - definitions for the i2c-ocores interface
  *
- * Peter Korsgaard <jacmet@sunsite.dk>
+ * Peter Korsgaard <peter@korsgaard.com>
  *
  * This file is licensed under the terms of the GNU General Public License
  * version 2.  This program is licensed "as is" without any warranty of any
diff --git a/include/linux/platform_data/ina2xx.h b/include/linux/platform_data/ina2xx.h
index 9abc0ca7259b..9f0aa1b48c78 100644
--- a/include/linux/platform_data/ina2xx.h
+++ b/include/linux/platform_data/ina2xx.h
@@ -1,7 +1,7 @@
 /*
  * Driver for Texas Instruments INA219, INA226 power monitor chips
  *
- * Copyright (C) 2012 Lothar Felten <l-felten@ti.com>
+ * Copyright (C) 2012 Lothar Felten <lothar.felten@gmail.com>
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 as
diff --git a/include/linux/platform_data/jz4740/jz4740_nand.h b/include/linux/platform_data/jz4740/jz4740_nand.h
new file mode 100644
index 000000000000..bc571f6d5ced
--- /dev/null
+++ b/include/linux/platform_data/jz4740/jz4740_nand.h
@@ -0,0 +1,34 @@
+/*
+ *  Copyright (C) 2009-2010, Lars-Peter Clausen <lars@metafoo.de>
+ *  JZ4740 SoC NAND controller driver
+ *
+ *  This program is free software; you can redistribute  it and/or modify it
+ *  under  the terms of  the GNU General  Public License as published by the
+ *  Free Software Foundation;  either version 2 of the  License, or (at your
+ *  option) any later version.
+ *
+ *  You should have received a copy of the  GNU General Public License along
+ *  with this program; if not, write  to the Free Software Foundation, Inc.,
+ *  675 Mass Ave, Cambridge, MA 02139, USA.
+ *
+ */
+
+#ifndef __JZ4740_NAND_H__
+#define __JZ4740_NAND_H__
+
+#include <linux/mtd/rawnand.h>
+#include <linux/mtd/partitions.h>
+
+#define JZ_NAND_NUM_BANKS 4
+
+struct jz_nand_platform_data {
+        int                     num_partitions;
+        struct mtd_partition    *partitions;
+
+        unsigned char banks[JZ_NAND_NUM_BANKS];
+
+        void (*ident_callback)(struct platform_device *, struct mtd_info *,
+                                struct mtd_partition **, int *num_partitions);
+};
+
+#endif
diff --git a/include/linux/platform_data/media/sii9234.h b/include/linux/platform_data/media/sii9234.h
deleted file mode 100644
index 6a4a809fe9a3..000000000000
--- a/include/linux/platform_data/media/sii9234.h
+++ /dev/null
@@ -1,24 +0,0 @@
-/*
- * Driver header for SII9234 MHL converter chip.
- *
- * Copyright (c) 2011 Samsung Electronics, Co. Ltd
- * Contact: Tomasz Stanislawski <t.stanislaws@samsung.com>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- */
-
-#ifndef SII9234_H
-#define SII9234_H
-
-/**
- * @gpio_n_reset: GPIO driving nRESET pin
- */
-
-struct sii9234_platform_data {
-        int gpio_n_reset;
-};
-
-#endif /* SII9234_H */
diff --git a/include/linux/platform_data/mmc-esdhc-imx.h b/include/linux/platform_data/mmc-esdhc-imx.h
index 7daa78a2f342..640dec8b5b0c 100644
--- a/include/linux/platform_data/mmc-esdhc-imx.h
+++ b/include/linux/platform_data/mmc-esdhc-imx.h
@@ -34,7 +34,6 @@ enum cd_types {
  * @cd_gpio:    gpio for card_detect interrupt
  * @wp_type:    type of write_protect method (see wp_types enum above)
  * @cd_type:    type of card_detect method (see cd_types enum above)
- * @support_vsel:  indicate it supports 1.8v switching
  */
 
 struct esdhc_platform_data {
@@ -43,7 +42,6 @@ struct esdhc_platform_data {
         enum wp_types wp_type;
         enum cd_types cd_type;
         int max_bus_width;
-        bool support_vsel;
         unsigned int delay_line;
         unsigned int tuning_step;       /* The delay cell steps in tuning procedure */
         unsigned int tuning_start_tap;  /* The start delay cell point in tuning procedure */
diff --git a/include/linux/platform_data/mmp_dma.h b/include/linux/platform_data/mmp_dma.h
index d1397c8ed94e..6397b9c8149a 100644
--- a/include/linux/platform_data/mmp_dma.h
+++ b/include/linux/platform_data/mmp_dma.h
@@ -12,9 +12,13 @@
 #ifndef MMP_DMA_H
 #define MMP_DMA_H
 
+struct dma_slave_map;
+
 struct mmp_dma_platdata {
         int dma_channels;
         int nb_requestors;
+        int slave_map_cnt;
+        const struct dma_slave_map *slave_map;
 };
 
 #endif /* MMP_DMA_H */
diff --git a/include/linux/platform_data/mtd-davinci-aemif.h b/include/linux/platform_data/mtd-davinci-aemif.h
index 97948ac2bb9b..a403dd51dacc 100644
--- a/include/linux/platform_data/mtd-davinci-aemif.h
+++ b/include/linux/platform_data/mtd-davinci-aemif.h
@@ -33,5 +33,4 @@ struct davinci_aemif_timing {
         u8      ta;
 };
 
-int davinci_aemif_setup(struct platform_device *pdev);
 #endif
diff --git a/include/linux/platform_data/mtd-orion_nand.h b/include/linux/platform_data/mtd-orion_nand.h
index a7ce77c7c1a8..34828eb85982 100644
--- a/include/linux/platform_data/mtd-orion_nand.h
+++ b/include/linux/platform_data/mtd-orion_nand.h
@@ -12,7 +12,6 @@
  */
 struct orion_nand_data {
         struct mtd_partition *parts;
-        int (*dev_ready)(struct mtd_info *mtd);
         u32 nr_parts;
         u8 ale;         /* address line number connected to ALE */
         u8 cle;         /* address line number connected to CLE */
diff --git a/include/linux/platform_data/pm33xx.h b/include/linux/platform_data/pm33xx.h
index f9bed2a0af9d..fbf5ed73c7cc 100644
--- a/include/linux/platform_data/pm33xx.h
+++ b/include/linux/platform_data/pm33xx.h
@@ -12,6 +12,29 @@
 #include <linux/kbuild.h>
 #include <linux/types.h>
 
+/*
+ * WFI Flags for sleep code control
+ *
+ * These flags allow PM code to exclude certain operations from happening
+ * in the low level ASM code found in sleep33xx.S and sleep43xx.S
+ *
+ * WFI_FLAG_FLUSH_CACHE: Flush the ARM caches and disable caching. Only
+ *                       needed when MPU will lose context.
+ * WFI_FLAG_SELF_REFRESH: Let EMIF place DDR memory into self-refresh and
+ *                        disable EMIF.
+ * WFI_FLAG_SAVE_EMIF: Save context of all EMIF registers and restore in
+ *                     resume path. Only needed if PER domain loses context
+ *                     and must also have WFI_FLAG_SELF_REFRESH set.
+ * WFI_FLAG_WAKE_M3: Disable MPU clock or clockdomain to cause wkup_m3 to
+ *                   execute when WFI instruction executes.
+ * WFI_FLAG_RTC_ONLY: Configure the RTC to enter RTC+DDR mode.
+ */
+#define WFI_FLAG_FLUSH_CACHE            BIT(0)
+#define WFI_FLAG_SELF_REFRESH           BIT(1)
+#define WFI_FLAG_SAVE_EMIF              BIT(2)
+#define WFI_FLAG_WAKE_M3                BIT(3)
+#define WFI_FLAG_RTC_ONLY               BIT(4)
+
 #ifndef __ASSEMBLER__
 struct am33xx_pm_sram_addr {
         void (*do_wfi)(void);
@@ -19,12 +42,15 @@ struct am33xx_pm_sram_addr {
         unsigned long *resume_offset;
         unsigned long *emif_sram_table;
         unsigned long *ro_sram_data;
+        unsigned long resume_address;
 };
 
 struct am33xx_pm_platform_data {
         int     (*init)(void);
-        int     (*soc_suspend)(unsigned int state, int (*fn)(unsigned long));
+        int     (*soc_suspend)(unsigned int state, int (*fn)(unsigned long),
+                               unsigned long args);
         struct  am33xx_pm_sram_addr *(*get_sram_addrs)(void);
+        void __iomem *(*get_rtc_base_addr)(void);
 };
 
 struct am33xx_pm_sram_data {
@@ -36,6 +62,7 @@ struct am33xx_pm_sram_data {
 struct am33xx_pm_ro_sram_data {
         u32 amx3_pm_sram_data_virt;
         u32 amx3_pm_sram_data_phys;
+        void __iomem *rtc_base_virt;
 } __packed __aligned(8);
 
 #endif /* __ASSEMBLER__ */
diff --git a/include/linux/platform_data/sh_ipmmu.h b/include/linux/platform_data/sh_ipmmu.h
deleted file mode 100644
index 39f7405cdac5..000000000000
--- a/include/linux/platform_data/sh_ipmmu.h
+++ /dev/null
@@ -1,18 +0,0 @@
-/* sh_ipmmu.h
- *
- * Copyright (C) 2012  Hideki EIRAKU
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; version 2 of the License.
- */
-
-#ifndef __SH_IPMMU_H__
-#define __SH_IPMMU_H__
-
-struct shmobile_ipmmu_platform_data {
-        const char * const *dev_names;
-        unsigned int num_dev_names;
-};
-
-#endif /* __SH_IPMMU_H__ */
diff --git a/include/linux/platform_data/ti-sysc.h b/include/linux/platform_data/ti-sysc.h
index 990aad477458..2efa3470a451 100644
--- a/include/linux/platform_data/ti-sysc.h
+++ b/include/linux/platform_data/ti-sysc.h
@@ -14,6 +14,7 @@ enum ti_sysc_module_type {
         TI_SYSC_OMAP4_SR,
         TI_SYSC_OMAP4_MCASP,
         TI_SYSC_OMAP4_USB_HOST_FS,
+        TI_SYSC_DRA7_MCAN,
 };
 
 struct ti_sysc_cookie {
diff --git a/include/linux/platform_data/txx9/ndfmc.h b/include/linux/platform_data/txx9/ndfmc.h
new file mode 100644
index 000000000000..fc172627d54e
--- /dev/null
+++ b/include/linux/platform_data/txx9/ndfmc.h
@@ -0,0 +1,30 @@
+/*
+ * 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.
+ *
+ * (C) Copyright TOSHIBA CORPORATION 2007
+ */
+#ifndef __TXX9_NDFMC_H
+#define __TXX9_NDFMC_H
+
+#define NDFMC_PLAT_FLAG_USE_BSPRT       0x01
+#define NDFMC_PLAT_FLAG_NO_RSTR         0x02
+#define NDFMC_PLAT_FLAG_HOLDADD         0x04
+#define NDFMC_PLAT_FLAG_DUMMYWRITE      0x08
+
+struct txx9ndfmc_platform_data {
+        unsigned int shift;
+        unsigned int gbus_clock;
+        unsigned int hold;              /* hold time in nanosecond */
+        unsigned int spw;               /* strobe pulse width in nanosecond */
+        unsigned int flags;
+        unsigned char ch_mask;          /* available channel bitmask */
+        unsigned char wp_mask;          /* write-protect bitmask */
+        unsigned char wide_mask;        /* 16bit-nand bitmask */
+};
+
+void txx9_ndfmc_init(unsigned long baseaddr,
+                     const struct txx9ndfmc_platform_data *plat_data);
+
+#endif /* __TXX9_NDFMC_H */
diff --git a/include/linux/platform_device.h b/include/linux/platform_device.h
index 3097c943fab9..1a9f38f27f65 100644
--- a/include/linux/platform_device.h
+++ b/include/linux/platform_device.h
@@ -12,13 +12,13 @@
 #define _PLATFORM_DEVICE_H_
 
 #include <linux/device.h>
-#include <linux/mod_devicetable.h>
 
 #define PLATFORM_DEVID_NONE     (-1)
 #define PLATFORM_DEVID_AUTO     (-2)
 
 struct mfd_cell;
 struct property_entry;
+struct platform_device_id;
 
 struct platform_device {
         const char      *name;
diff --git a/include/linux/pm_domain.h b/include/linux/pm_domain.h
index cb8d84090cfb..776c546d581a 100644
--- a/include/linux/pm_domain.h
+++ b/include/linux/pm_domain.h
@@ -239,6 +239,8 @@ unsigned int of_genpd_opp_to_performance_state(struct device *dev,
 int genpd_dev_pm_attach(struct device *dev);
 struct device *genpd_dev_pm_attach_by_id(struct device *dev,
                                          unsigned int index);
+struct device *genpd_dev_pm_attach_by_name(struct device *dev,
+                                           char *name);
 #else /* !CONFIG_PM_GENERIC_DOMAINS_OF */
 static inline int of_genpd_add_provider_simple(struct device_node *np,
                                         struct generic_pm_domain *genpd)
@@ -290,6 +292,12 @@ static inline struct device *genpd_dev_pm_attach_by_id(struct device *dev,
         return NULL;
 }
 
+static inline struct device *genpd_dev_pm_attach_by_name(struct device *dev,
+                                                         char *name)
+{
+        return NULL;
+}
+
 static inline
 struct generic_pm_domain *of_genpd_remove_last(struct device_node *np)
 {
@@ -301,6 +309,8 @@ struct generic_pm_domain *of_genpd_remove_last(struct device_node *np)
 int dev_pm_domain_attach(struct device *dev, bool power_on);
 struct device *dev_pm_domain_attach_by_id(struct device *dev,
                                           unsigned int index);
+struct device *dev_pm_domain_attach_by_name(struct device *dev,
+                                            char *name);
 void dev_pm_domain_detach(struct device *dev, bool power_off);
 void dev_pm_domain_set(struct device *dev, struct dev_pm_domain *pd);
 #else
@@ -313,6 +323,11 @@ static inline struct device *dev_pm_domain_attach_by_id(struct device *dev,
 {
         return NULL;
 }
+static inline struct device *dev_pm_domain_attach_by_name(struct device *dev,
+                                                          char *name)
+{
+        return NULL;
+}
 static inline void dev_pm_domain_detach(struct device *dev, bool power_off) {}
 static inline void dev_pm_domain_set(struct device *dev,
                                      struct dev_pm_domain *pd) {}
diff --git a/include/linux/power_supply.h b/include/linux/power_supply.h
index b21c4bd96b84..f80769175c56 100644
--- a/include/linux/power_supply.h
+++ b/include/linux/power_supply.h
@@ -269,6 +269,7 @@ struct power_supply {
         spinlock_t changed_lock;
         bool changed;
         bool initialized;
+        bool removing;
         atomic_t use_cnt;
 #ifdef CONFIG_THERMAL
         struct thermal_zone_device *tzd;
diff --git a/include/linux/preempt.h b/include/linux/preempt.h
index 5bd3f151da78..c01813c3fbe9 100644
--- a/include/linux/preempt.h
+++ b/include/linux/preempt.h
@@ -150,7 +150,7 @@
  */
 #define in_atomic_preempt_off() (preempt_count() != PREEMPT_DISABLE_OFFSET)
 
-#if defined(CONFIG_DEBUG_PREEMPT) || defined(CONFIG_PREEMPT_TRACER)
+#if defined(CONFIG_DEBUG_PREEMPT) || defined(CONFIG_TRACE_PREEMPT_TOGGLE)
 extern void preempt_count_add(int val);
 extern void preempt_count_sub(int val);
 #define preempt_count_dec_and_test() \
diff --git a/include/linux/printk.h b/include/linux/printk.h
index 6d7e800affd8..cf3eccfe1543 100644
--- a/include/linux/printk.h
+++ b/include/linux/printk.h
@@ -50,15 +50,15 @@ static inline const char *printk_skip_headers(const char *buffer)
 /* We show everything that is MORE important than this.. */
 #define CONSOLE_LOGLEVEL_SILENT  0 /* Mum's the word */
 #define CONSOLE_LOGLEVEL_MIN     1 /* Minimum loglevel we let people use */
-#define CONSOLE_LOGLEVEL_QUIET   4 /* Shhh ..., when booted with "quiet" */
 #define CONSOLE_LOGLEVEL_DEBUG  10 /* issue debug messages */
 #define CONSOLE_LOGLEVEL_MOTORMOUTH 15  /* You can't shut this one up */
 
 /*
- * Default used to be hard-coded at 7, we're now allowing it to be set from
- * kernel config.
+ * Default used to be hard-coded at 7, quiet used to be hardcoded at 4,
+ * we're now allowing both to be set from kernel config.
  */
 #define CONSOLE_LOGLEVEL_DEFAULT CONFIG_CONSOLE_LOGLEVEL_DEFAULT
+#define CONSOLE_LOGLEVEL_QUIET   CONFIG_CONSOLE_LOGLEVEL_QUIET
 
 extern int console_printk[];
 
@@ -148,9 +148,13 @@ void early_printk(const char *s, ...) { }
 #ifdef CONFIG_PRINTK_NMI
 extern void printk_nmi_enter(void);
 extern void printk_nmi_exit(void);
+extern void printk_nmi_direct_enter(void);
+extern void printk_nmi_direct_exit(void);
 #else
 static inline void printk_nmi_enter(void) { }
 static inline void printk_nmi_exit(void) { }
+static inline void printk_nmi_direct_enter(void) { }
+static inline void printk_nmi_direct_exit(void) { }
 #endif /* PRINTK_NMI */
 
 #ifdef CONFIG_PRINTK
diff --git a/include/linux/proc_fs.h b/include/linux/proc_fs.h
index 626fc65c4336..d0e1f1522a78 100644
--- a/include/linux/proc_fs.h
+++ b/include/linux/proc_fs.h
@@ -129,7 +129,7 @@ int open_related_ns(struct ns_common *ns,
                    struct ns_common *(*get_ns)(struct ns_common *ns));
 
 /* get the associated pid namespace for a file in procfs */
-static inline struct pid_namespace *proc_pid_ns(struct inode *inode)
+static inline struct pid_namespace *proc_pid_ns(const struct inode *inode)
 {
         return inode->i_sb->s_fs_info;
 }
diff --git a/include/linux/ptrace.h b/include/linux/ptrace.h
index 037bf0ef1ae9..4f36431c380b 100644
--- a/include/linux/ptrace.h
+++ b/include/linux/ptrace.h
@@ -214,8 +214,6 @@ static inline void ptrace_init_task(struct task_struct *child, bool ptrace)
                         task_set_jobctl_pending(child, JOBCTL_TRAP_STOP);
                 else
                         sigaddset(&child->pending.signal, SIGSTOP);
-
-                set_tsk_thread_flag(child, TIF_SIGPENDING);
         }
         else
                 child->ptracer_cred = NULL;
diff --git a/include/linux/pxa2xx_ssp.h b/include/linux/pxa2xx_ssp.h
index 8461b18e4608..13b4244d44c1 100644
--- a/include/linux/pxa2xx_ssp.h
+++ b/include/linux/pxa2xx_ssp.h
@@ -171,6 +171,14 @@
 #define SSACD_SCDB              (1 << 3)        /* SSPSYSCLK Divider Bypass */
 #define SSACD_ACPS(x)           ((x) << 4)      /* Audio clock PLL select */
 #define SSACD_ACDS(x)           ((x) << 0)      /* Audio clock divider select */
+#define SSACD_ACDS_1            (0)
+#define SSACD_ACDS_2            (1)
+#define SSACD_ACDS_4            (2)
+#define SSACD_ACDS_8            (3)
+#define SSACD_ACDS_16           (4)
+#define SSACD_ACDS_32           (5)
+#define SSACD_SCDB_4X           (0)
+#define SSACD_SCDB_1X           (1)
 #define SSACD_SCDX8             (1 << 7)        /* SYSCLK division ratio select */
 
 /* LPSS SSP */
@@ -212,8 +220,6 @@ struct ssp_device {
         int             type;
         int             use_count;
         int             irq;
-        int             drcmr_rx;
-        int             drcmr_tx;
 
         struct device_node      *of_node;
 };
diff --git a/include/linux/qcom_scm.h b/include/linux/qcom_scm.h
index b401b962afff..5d65521260b3 100644
--- a/include/linux/qcom_scm.h
+++ b/include/linux/qcom_scm.h
@@ -87,6 +87,10 @@ static inline int qcom_scm_pas_mem_setup(u32 peripheral, phys_addr_t addr,
 static inline int
 qcom_scm_pas_auth_and_reset(u32 peripheral) { return -ENODEV; }
 static inline int qcom_scm_pas_shutdown(u32 peripheral) { return -ENODEV; }
+static inline int qcom_scm_assign_mem(phys_addr_t mem_addr, size_t mem_sz,
+                                      unsigned int *src,
+                                      struct qcom_scm_vmperm *newvm,
+                                      int dest_cnt) { return -ENODEV; }
 static inline void qcom_scm_cpu_power_down(u32 flags) {}
 static inline u32 qcom_scm_get_version(void) { return 0; }
 static inline u32
diff --git a/include/linux/qed/qed_eth_if.h b/include/linux/qed/qed_eth_if.h
index 2978fa4add42..a1310482c4ed 100644
--- a/include/linux/qed/qed_eth_if.h
+++ b/include/linux/qed/qed_eth_if.h
@@ -39,6 +39,10 @@
 #include <linux/qed/qed_if.h>
 #include <linux/qed/qed_iov_if.h>
 
+/* 64 max queues * (1 rx + 4 tx-cos + 1 xdp) */
+#define QED_MIN_L2_CONS (2 + NUM_PHYS_TCS_4PORT_K2)
+#define QED_MAX_L2_CONS (64 * (QED_MIN_L2_CONS))
+
 struct qed_queue_start_common_params {
         /* Should always be relative to entity sending this. */
         u8 vport_id;
@@ -49,6 +53,8 @@ struct qed_queue_start_common_params {
 
         struct qed_sb_info *p_sb;
         u8 sb_idx;
+
+        u8 tc;
 };
 
 struct qed_rxq_start_ret_params {
diff --git a/include/linux/qed/qed_if.h b/include/linux/qed/qed_if.h
index b4040023cbfb..8cd34645e892 100644
--- a/include/linux/qed/qed_if.h
+++ b/include/linux/qed/qed_if.h
@@ -759,6 +759,9 @@ struct qed_generic_tlvs {
         u8 mac[QED_TLV_MAC_COUNT][ETH_ALEN];
 };
 
+#define QED_I2C_DEV_ADDR_A0 0xA0
+#define QED_I2C_DEV_ADDR_A2 0xA2
+
 #define QED_NVM_SIGNATURE 0x12435687
 
 enum qed_nvm_flash_cmd {
@@ -1026,6 +1029,18 @@ struct qed_common_ops {
  * @param enabled - true iff WoL should be enabled.
  */
         int (*update_wol) (struct qed_dev *cdev, bool enabled);
+
+/**
+ * @brief read_module_eeprom
+ *
+ * @param cdev
+ * @param buf - buffer
+ * @param dev_addr - PHY device memory region
+ * @param offset - offset into eeprom contents to be read
+ * @param len - buffer length, i.e., max bytes to be read
+ */
+        int (*read_module_eeprom)(struct qed_dev *cdev,
+                                  char *buf, u8 dev_addr, u32 offset, u32 len);
 };
 
 #define MASK_FIELD(_name, _value) \
diff --git a/include/linux/quota.h b/include/linux/quota.h
index ca9772c8e48b..f32dd270b8e3 100644
--- a/include/linux/quota.h
+++ b/include/linux/quota.h
@@ -408,13 +408,7 @@ struct qc_type_state {
 
 struct qc_state {
         unsigned int s_incoredqs;       /* Number of dquots in core */
-        /*
-         * Per quota type information. The array should really have
-         * max(MAXQUOTAS, XQM_MAXQUOTAS) entries. BUILD_BUG_ON in
-         * quota_getinfo() makes sure XQM_MAXQUOTAS is large enough.  Once VFS
-         * supports project quotas, this can be changed to MAXQUOTAS
-         */
-        struct qc_type_state s_state[XQM_MAXQUOTAS];
+        struct qc_type_state s_state[MAXQUOTAS];  /* Per quota type information */
 };
 
 /* Structure for communicating via ->set_info */
diff --git a/include/linux/random.h b/include/linux/random.h
index 2ddf13b4281e..445a0ea4ff49 100644
--- a/include/linux/random.h
+++ b/include/linux/random.h
@@ -36,9 +36,10 @@ extern void add_interrupt_randomness(int irq, int irq_flags) __latent_entropy;
 
 extern void get_random_bytes(void *buf, int nbytes);
 extern int wait_for_random_bytes(void);
+extern bool rng_is_initialized(void);
 extern int add_random_ready_callback(struct random_ready_callback *rdy);
 extern void del_random_ready_callback(struct random_ready_callback *rdy);
-extern void get_random_bytes_arch(void *buf, int nbytes);
+extern int __must_check get_random_bytes_arch(void *buf, int nbytes);
 
 #ifndef MODULE
 extern const struct file_operations random_fops, urandom_fops;
diff --git a/include/linux/reciprocal_div.h b/include/linux/reciprocal_div.h
index e031e9f2f9d8..585ce89c0f33 100644
--- a/include/linux/reciprocal_div.h
+++ b/include/linux/reciprocal_div.h
@@ -25,6 +25,9 @@ struct reciprocal_value {
         u8 sh1, sh2;
 };
 
+/* "reciprocal_value" and "reciprocal_divide" together implement the basic
+ * version of the algorithm described in Figure 4.1 of the paper.
+ */
 struct reciprocal_value reciprocal_value(u32 d);
 
 static inline u32 reciprocal_divide(u32 a, struct reciprocal_value R)
@@ -33,4 +36,69 @@ static inline u32 reciprocal_divide(u32 a, struct reciprocal_value R)
         return (t + ((a - t) >> R.sh1)) >> R.sh2;
 }
 
+struct reciprocal_value_adv {
+        u32 m;
+        u8 sh, exp;
+        bool is_wide_m;
+};
+
+/* "reciprocal_value_adv" implements the advanced version of the algorithm
+ * described in Figure 4.2 of the paper except when "divisor > (1U << 31)" whose
+ * ceil(log2(d)) result will be 32 which then requires u128 divide on host. The
+ * exception case could be easily handled before calling "reciprocal_value_adv".
+ *
+ * The advanced version requires more complex calculation to get the reciprocal
+ * multiplier and other control variables, but then could reduce the required
+ * emulation operations.
+ *
+ * It makes no sense to use this advanced version for host divide emulation,
+ * those extra complexities for calculating multiplier etc could completely
+ * waive our saving on emulation operations.
+ *
+ * However, it makes sense to use it for JIT divide code generation for which
+ * we are willing to trade performance of JITed code with that of host. As shown
+ * by the following pseudo code, the required emulation operations could go down
+ * from 6 (the basic version) to 3 or 4.
+ *
+ * To use the result of "reciprocal_value_adv", suppose we want to calculate
+ * n/d, the pseudo C code will be:
+ *
+ *   struct reciprocal_value_adv rvalue;
+ *   u8 pre_shift, exp;
+ *
+ *   // handle exception case.
+ *   if (d >= (1U << 31)) {
+ *     result = n >= d;
+ *     return;
+ *   }
+ *
+ *   rvalue = reciprocal_value_adv(d, 32)
+ *   exp = rvalue.exp;
+ *   if (rvalue.is_wide_m && !(d & 1)) {
+ *     // floor(log2(d & (2^32 -d)))
+ *     pre_shift = fls(d & -d) - 1;
+ *     rvalue = reciprocal_value_adv(d >> pre_shift, 32 - pre_shift);
+ *   } else {
+ *     pre_shift = 0;
+ *   }
+ *
+ *   // code generation starts.
+ *   if (imm == 1U << exp) {
+ *     result = n >> exp;
+ *   } else if (rvalue.is_wide_m) {
+ *     // pre_shift must be zero when reached here.
+ *     t = (n * rvalue.m) >> 32;
+ *     result = n - t;
+ *     result >>= 1;
+ *     result += t;
+ *     result >>= rvalue.sh - 1;
+ *   } else {
+ *     if (pre_shift)
+ *       result = n >> pre_shift;
+ *     result = ((u64)result * rvalue.m) >> 32;
+ *     result >>= rvalue.sh;
+ *   }
+ */
+struct reciprocal_value_adv reciprocal_value_adv(u32 d, u8 prec);
+
 #endif /* _LINUX_RECIPROCAL_DIV_H */
diff --git a/include/linux/regmap.h b/include/linux/regmap.h
index 4f38068ffb71..379505a53722 100644
--- a/include/linux/regmap.h
+++ b/include/linux/regmap.h
@@ -268,6 +268,13 @@ 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).
+ * @readable_noinc_reg: Optional callback returning true if the register
+ *                      supports multiple read operations without incrementing
+ *                      the register number. If this field is NULL but
+ *                      rd_noinc_table (see below) is not, the check is
+ *                      performed on such table (a register is no increment
+ *                      readable if it belongs to one of the ranges specified
+ *                      by rd_noinc_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.
@@ -295,6 +302,7 @@ typedef void (*regmap_unlock)(void *);
  * @rd_table:     As above, for read access.
  * @volatile_table: As above, for volatile registers.
  * @precious_table: As above, for precious registers.
+ * @rd_noinc_table: As above, for no increment readable registers.
  * @reg_defaults: Power on reset values for registers (for use with
  *                register cache support).
  * @num_reg_defaults: Number of elements in reg_defaults.
@@ -344,6 +352,7 @@ 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 (*readable_noinc_reg)(struct device *dev, unsigned int reg);
 
         bool disable_locking;
         regmap_lock lock;
@@ -360,6 +369,7 @@ struct regmap_config {
         const struct regmap_access_table *rd_table;
         const struct regmap_access_table *volatile_table;
         const struct regmap_access_table *precious_table;
+        const struct regmap_access_table *rd_noinc_table;
         const struct reg_default *reg_defaults;
         unsigned int num_reg_defaults;
         enum regcache_type cache_type;
@@ -514,6 +524,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_sccb(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,
@@ -558,6 +572,10 @@ struct regmap *__devm_regmap_init_i2c(struct i2c_client *i2c,
                                       const struct regmap_config *config,
                                       struct lock_class_key *lock_key,
                                       const char *lock_name);
+struct regmap *__devm_regmap_init_sccb(struct i2c_client *i2c,
+                                       const struct regmap_config *config,
+                                       struct lock_class_key *lock_key,
+                                       const char *lock_name);
 struct regmap *__devm_regmap_init_spi(struct spi_device *dev,
                                       const struct regmap_config *config,
                                       struct lock_class_key *lock_key,
@@ -646,6 +664,19 @@ int regmap_attach_dev(struct device *dev, struct regmap *map,
                                 i2c, config)
 
 /**
+ * regmap_init_sccb() - Initialise register map
+ *
+ * @i2c: 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_sccb(i2c, config)                                   \
+        __regmap_lockdep_wrapper(__regmap_init_sccb, #config,           \
+                                i2c, config)
+
+/**
  * regmap_init_slimbus() - Initialise register map
  *
  * @slimbus: Device that will be interacted with
@@ -798,6 +829,20 @@ bool regmap_ac97_default_volatile(struct device *dev, unsigned int reg);
                                 i2c, config)
 
 /**
+ * devm_regmap_init_sccb() - Initialise managed register map
+ *
+ * @i2c: 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_sccb(i2c, config)                              \
+        __regmap_lockdep_wrapper(__devm_regmap_init_sccb, #config,      \
+                                i2c, config)
+
+/**
  * devm_regmap_init_spi() - Initialise register map
  *
  * @dev: Device that will be interacted with
@@ -946,6 +991,8 @@ int regmap_raw_write_async(struct regmap *map, unsigned int reg,
 int regmap_read(struct regmap *map, unsigned int reg, unsigned int *val);
 int regmap_raw_read(struct regmap *map, unsigned int reg,
                     void *val, size_t val_len);
+int regmap_noinc_read(struct regmap *map, unsigned int reg,
+                      void *val, size_t val_len);
 int regmap_bulk_read(struct regmap *map, unsigned int reg, void *val,
                      size_t val_count);
 int regmap_update_bits_base(struct regmap *map, unsigned int reg,
@@ -1196,6 +1243,13 @@ static inline int regmap_raw_read(struct regmap *map, unsigned int reg,
         return -EINVAL;
 }
 
+static inline int regmap_noinc_read(struct regmap *map, unsigned int reg,
+                                    void *val, size_t val_len)
+{
+        WARN_ONCE(1, "regmap API is disabled");
+        return -EINVAL;
+}
+
 static inline int regmap_bulk_read(struct regmap *map, unsigned int reg,
                                    void *val, size_t val_count)
 {
diff --git a/include/linux/regulator/driver.h b/include/linux/regulator/driver.h
index fc2dc8df476f..0fd8fbb74763 100644
--- a/include/linux/regulator/driver.h
+++ b/include/linux/regulator/driver.h
@@ -46,7 +46,7 @@ enum regulator_status {
 /**
  * struct regulator_linear_range - specify linear voltage ranges
  *
- * Specify a range of voltages for regulator_map_linar_range() and
+ * Specify a range of voltages for regulator_map_linear_range() and
  * regulator_list_linear_range().
  *
  * @min_uV:  Lowest voltage in range
@@ -220,7 +220,7 @@ 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 (*resume)(struct regulator_dev *rdev);
 
         int (*set_pull_down) (struct regulator_dev *);
 };
diff --git a/include/linux/regulator/pfuze100.h b/include/linux/regulator/pfuze100.h
index e0ccf46f66cf..cb5aecd40f07 100644
--- a/include/linux/regulator/pfuze100.h
+++ b/include/linux/regulator/pfuze100.h
@@ -64,6 +64,17 @@
 #define PFUZE3000_VLDO3         11
 #define PFUZE3000_VLDO4         12
 
+#define PFUZE3001_SW1           0
+#define PFUZE3001_SW2           1
+#define PFUZE3001_SW3           2
+#define PFUZE3001_VSNVS         3
+#define PFUZE3001_VLDO1         4
+#define PFUZE3001_VLDO2         5
+#define PFUZE3001_VCCSD         6
+#define PFUZE3001_V33           7
+#define PFUZE3001_VLDO3         8
+#define PFUZE3001_VLDO4         9
+
 struct regulator_init_data;
 
 struct pfuze_regulator_platform_data {
diff --git a/include/linux/remoteproc.h b/include/linux/remoteproc.h
index dfdaede9139e..e3c5d856b6da 100644
--- a/include/linux/remoteproc.h
+++ b/include/linux/remoteproc.h
@@ -477,15 +477,19 @@ struct rproc {
 /**
  * struct rproc_subdev - subdevice tied to a remoteproc
  * @node: list node related to the rproc subdevs list
- * @probe: probe function, called as the rproc is started
- * @remove: remove function, called as the rproc is being stopped, the @crashed
- *          parameter indicates if this originates from the a recovery
+ * @prepare: prepare function, called before the rproc is started
+ * @start: start function, called after the rproc has been started
+ * @stop: stop function, called before the rproc is stopped; the @crashed
+ *          parameter indicates if this originates from a recovery
+ * @unprepare: unprepare function, called after the rproc has been stopped
  */
 struct rproc_subdev {
         struct list_head node;
 
-        int (*probe)(struct rproc_subdev *subdev);
-        void (*remove)(struct rproc_subdev *subdev, bool crashed);
+        int (*prepare)(struct rproc_subdev *subdev);
+        int (*start)(struct rproc_subdev *subdev);
+        void (*stop)(struct rproc_subdev *subdev, bool crashed);
+        void (*unprepare)(struct rproc_subdev *subdev);
 };
 
 /* we currently support only two vrings per rvdev */
@@ -566,10 +570,7 @@ static inline struct rproc *vdev_to_rproc(struct virtio_device *vdev)
         return rvdev->rproc;
 }
 
-void rproc_add_subdev(struct rproc *rproc,
-                      struct rproc_subdev *subdev,
-                      int (*probe)(struct rproc_subdev *subdev),
-                      void (*remove)(struct rproc_subdev *subdev, bool crashed));
+void rproc_add_subdev(struct rproc *rproc, struct rproc_subdev *subdev);
 
 void rproc_remove_subdev(struct rproc *rproc, struct rproc_subdev *subdev);
 
diff --git a/include/linux/rfkill.h b/include/linux/rfkill.h
index e6a0031d1b1f..8ad2487a86d5 100644
--- a/include/linux/rfkill.h
+++ b/include/linux/rfkill.h
@@ -66,7 +66,7 @@ struct rfkill_ops {
 
 #if defined(CONFIG_RFKILL) || defined(CONFIG_RFKILL_MODULE)
 /**
- * rfkill_alloc - allocate rfkill structure
+ * rfkill_alloc - Allocate rfkill structure
  * @name: name of the struct -- the string is not copied internally
  * @parent: device that has rf switch on it
  * @type: type of the switch (RFKILL_TYPE_*)
@@ -112,7 +112,7 @@ void rfkill_pause_polling(struct rfkill *rfkill);
 /**
  * rfkill_resume_polling(struct rfkill *rfkill)
  *
- * Pause polling -- say transmitter is off for other reasons.
+ * Resume polling
  * NOTE: not necessary for suspend/resume -- in that case the
  * core stops polling anyway
  */
@@ -130,7 +130,7 @@ void rfkill_resume_polling(struct rfkill *rfkill);
 void rfkill_unregister(struct rfkill *rfkill);
 
 /**
- * rfkill_destroy - free rfkill structure
+ * rfkill_destroy - Free rfkill structure
  * @rfkill: rfkill structure to be destroyed
  *
  * Destroys the rfkill structure.
@@ -140,7 +140,7 @@ void rfkill_destroy(struct rfkill *rfkill);
 /**
  * rfkill_set_hw_state - Set the internal rfkill hardware block state
  * @rfkill: pointer to the rfkill class to modify.
- * @state: the current hardware block state to set
+ * @blocked: the current hardware block state to set
  *
  * rfkill drivers that get events when the hard-blocked state changes
  * use this function to notify the rfkill core (and through that also
@@ -161,7 +161,7 @@ bool rfkill_set_hw_state(struct rfkill *rfkill, bool blocked);
 /**
  * rfkill_set_sw_state - Set the internal rfkill software block state
  * @rfkill: pointer to the rfkill class to modify.
- * @state: the current software block state to set
+ * @blocked: the current software block state to set
  *
  * rfkill drivers that get events when the soft-blocked state changes
  * (yes, some platforms directly act on input but allow changing again)
@@ -183,7 +183,7 @@ bool rfkill_set_sw_state(struct rfkill *rfkill, bool blocked);
 /**
  * rfkill_init_sw_state - Initialize persistent software block state
  * @rfkill: pointer to the rfkill class to modify.
- * @state: the current software block state to set
+ * @blocked: the current software block state to set
  *
  * rfkill drivers that preserve their software block state over power off
  * use this function to notify the rfkill core (and through that also
@@ -208,17 +208,17 @@ void rfkill_init_sw_state(struct rfkill *rfkill, bool blocked);
 void rfkill_set_states(struct rfkill *rfkill, bool sw, bool hw);
 
 /**
- * rfkill_blocked - query rfkill block
+ * rfkill_blocked - Query rfkill block state
  *
  * @rfkill: rfkill struct to query
  */
 bool rfkill_blocked(struct rfkill *rfkill);
 
 /**
- * rfkill_find_type - Helpper for finding rfkill type by name
+ * rfkill_find_type - Helper for finding rfkill type by name
  * @name: the name of the type
  *
- * Returns enum rfkill_type that conrresponds the name.
+ * Returns enum rfkill_type that corresponds to the name.
  */
 enum rfkill_type rfkill_find_type(const char *name);
 
@@ -296,7 +296,7 @@ static inline enum rfkill_type rfkill_find_type(const char *name)
 const char *rfkill_get_led_trigger_name(struct rfkill *rfkill);
 
 /**
- * rfkill_set_led_trigger_name -- set the LED trigger name
+ * rfkill_set_led_trigger_name - Set the LED trigger name
  * @rfkill: rfkill struct
  * @name: LED trigger name
  *
diff --git a/include/linux/rhashtable-types.h b/include/linux/rhashtable-types.h
new file mode 100644
index 000000000000..763d613ce2c2
--- /dev/null
+++ b/include/linux/rhashtable-types.h
@@ -0,0 +1,137 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Resizable, Scalable, Concurrent Hash Table
+ *
+ * Simple structures that might be needed in include
+ * files.
+ */
+
+#ifndef _LINUX_RHASHTABLE_TYPES_H
+#define _LINUX_RHASHTABLE_TYPES_H
+
+#include <linux/atomic.h>
+#include <linux/compiler.h>
+#include <linux/mutex.h>
+#include <linux/workqueue.h>
+
+struct rhash_head {
+        struct rhash_head __rcu         *next;
+};
+
+struct rhlist_head {
+        struct rhash_head               rhead;
+        struct rhlist_head __rcu        *next;
+};
+
+struct bucket_table;
+
+/**
+ * struct rhashtable_compare_arg - Key for the function rhashtable_compare
+ * @ht: Hash table
+ * @key: Key to compare against
+ */
+struct rhashtable_compare_arg {
+        struct rhashtable *ht;
+        const void *key;
+};
+
+typedef u32 (*rht_hashfn_t)(const void *data, u32 len, u32 seed);
+typedef u32 (*rht_obj_hashfn_t)(const void *data, u32 len, u32 seed);
+typedef int (*rht_obj_cmpfn_t)(struct rhashtable_compare_arg *arg,
+                               const void *obj);
+
+/**
+ * struct rhashtable_params - Hash table construction parameters
+ * @nelem_hint: Hint on number of elements, should be 75% of desired size
+ * @key_len: Length of key
+ * @key_offset: Offset of key in struct to be hashed
+ * @head_offset: Offset of rhash_head in struct to be hashed
+ * @max_size: Maximum size while expanding
+ * @min_size: Minimum size while shrinking
+ * @locks_mul: Number of bucket locks to allocate per cpu (default: 32)
+ * @automatic_shrinking: Enable automatic shrinking of tables
+ * @hashfn: Hash function (default: jhash2 if !(key_len % 4), or jhash)
+ * @obj_hashfn: Function to hash object
+ * @obj_cmpfn: Function to compare key with object
+ */
+struct rhashtable_params {
+        u16                     nelem_hint;
+        u16                     key_len;
+        u16                     key_offset;
+        u16                     head_offset;
+        unsigned int            max_size;
+        u16                     min_size;
+        bool                    automatic_shrinking;
+        u8                      locks_mul;
+        rht_hashfn_t            hashfn;
+        rht_obj_hashfn_t        obj_hashfn;
+        rht_obj_cmpfn_t         obj_cmpfn;
+};
+
+/**
+ * struct rhashtable - Hash table handle
+ * @tbl: Bucket table
+ * @key_len: Key length for hashfn
+ * @max_elems: Maximum number of elements in table
+ * @p: Configuration parameters
+ * @rhlist: True if this is an rhltable
+ * @run_work: Deferred worker to expand/shrink asynchronously
+ * @mutex: Mutex to protect current/future table swapping
+ * @lock: Spin lock to protect walker list
+ * @nelems: Number of elements in table
+ */
+struct rhashtable {
+        struct bucket_table __rcu       *tbl;
+        unsigned int                    key_len;
+        unsigned int                    max_elems;
+        struct rhashtable_params        p;
+        bool                            rhlist;
+        struct work_struct              run_work;
+        struct mutex                    mutex;
+        spinlock_t                      lock;
+        atomic_t                        nelems;
+};
+
+/**
+ * struct rhltable - Hash table with duplicate objects in a list
+ * @ht: Underlying rhtable
+ */
+struct rhltable {
+        struct rhashtable ht;
+};
+
+/**
+ * struct rhashtable_walker - Hash table walker
+ * @list: List entry on list of walkers
+ * @tbl: The table that we were walking over
+ */
+struct rhashtable_walker {
+        struct list_head list;
+        struct bucket_table *tbl;
+};
+
+/**
+ * struct rhashtable_iter - Hash table iterator
+ * @ht: Table to iterate through
+ * @p: Current pointer
+ * @list: Current hash list pointer
+ * @walker: Associated rhashtable walker
+ * @slot: Current slot
+ * @skip: Number of entries to skip in slot
+ */
+struct rhashtable_iter {
+        struct rhashtable *ht;
+        struct rhash_head *p;
+        struct rhlist_head *list;
+        struct rhashtable_walker walker;
+        unsigned int slot;
+        unsigned int skip;
+        bool end_of_table;
+};
+
+int rhashtable_init(struct rhashtable *ht,
+                    const struct rhashtable_params *params);
+int rhltable_init(struct rhltable *hlt,
+                  const struct rhashtable_params *params);
+
+#endif /* _LINUX_RHASHTABLE_TYPES_H */
diff --git a/include/linux/rhashtable.h b/include/linux/rhashtable.h
index 4e1f535c2034..eb7111039247 100644
--- a/include/linux/rhashtable.h
+++ b/include/linux/rhashtable.h
@@ -1,3 +1,4 @@
+/* SPDX-License-Identifier: GPL-2.0 */
 /*
  * Resizable, Scalable, Concurrent Hash Table
  *
@@ -17,37 +18,18 @@
 #ifndef _LINUX_RHASHTABLE_H
 #define _LINUX_RHASHTABLE_H
 
-#include <linux/atomic.h>
-#include <linux/compiler.h>
 #include <linux/err.h>
 #include <linux/errno.h>
 #include <linux/jhash.h>
 #include <linux/list_nulls.h>
 #include <linux/workqueue.h>
-#include <linux/mutex.h>
 #include <linux/rculist.h>
 
+#include <linux/rhashtable-types.h>
 /*
  * The end of the chain is marked with a special nulls marks which has
- * the following format:
- *
- * +-------+-----------------------------------------------------+-+
- * | Base  |                      Hash                           |1|
- * +-------+-----------------------------------------------------+-+
- *
- * Base (4 bits) : Reserved to distinguish between multiple tables.
- *                 Specified via &struct rhashtable_params.nulls_base.
- * Hash (27 bits): Full hash (unmasked) of first element added to bucket
- * 1 (1 bit)     : Nulls marker (always set)
- *
- * The remaining bits of the next pointer remain unused for now.
+ * the least significant bit set.
  */
-#define RHT_BASE_BITS           4
-#define RHT_HASH_BITS           27
-#define RHT_BASE_SHIFT          RHT_HASH_BITS
-
-/* Base bits plus 1 bit for nulls marker */
-#define RHT_HASH_RESERVED_SPACE (RHT_BASE_BITS + 1)
 
 /* Maximum chain length before rehash
  *
@@ -64,15 +46,6 @@
  */
 #define RHT_ELASTICITY  16u
 
-struct rhash_head {
-        struct rhash_head __rcu         *next;
-};
-
-struct rhlist_head {
-        struct rhash_head               rhead;
-        struct rhlist_head __rcu        *next;
-};
-
 /**
  * struct bucket_table - Table of hash buckets
  * @size: Number of hash buckets
@@ -102,132 +75,14 @@ struct bucket_table {
         struct rhash_head __rcu *buckets[] ____cacheline_aligned_in_smp;
 };
 
-/**
- * struct rhashtable_compare_arg - Key for the function rhashtable_compare
- * @ht: Hash table
- * @key: Key to compare against
- */
-struct rhashtable_compare_arg {
-        struct rhashtable *ht;
-        const void *key;
-};
-
-typedef u32 (*rht_hashfn_t)(const void *data, u32 len, u32 seed);
-typedef u32 (*rht_obj_hashfn_t)(const void *data, u32 len, u32 seed);
-typedef int (*rht_obj_cmpfn_t)(struct rhashtable_compare_arg *arg,
-                               const void *obj);
-
-struct rhashtable;
-
-/**
- * struct rhashtable_params - Hash table construction parameters
- * @nelem_hint: Hint on number of elements, should be 75% of desired size
- * @key_len: Length of key
- * @key_offset: Offset of key in struct to be hashed
- * @head_offset: Offset of rhash_head in struct to be hashed
- * @max_size: Maximum size while expanding
- * @min_size: Minimum size while shrinking
- * @locks_mul: Number of bucket locks to allocate per cpu (default: 32)
- * @automatic_shrinking: Enable automatic shrinking of tables
- * @nulls_base: Base value to generate nulls marker
- * @hashfn: Hash function (default: jhash2 if !(key_len % 4), or jhash)
- * @obj_hashfn: Function to hash object
- * @obj_cmpfn: Function to compare key with object
- */
-struct rhashtable_params {
-        u16                     nelem_hint;
-        u16                     key_len;
-        u16                     key_offset;
-        u16                     head_offset;
-        unsigned int            max_size;
-        u16                     min_size;
-        bool                    automatic_shrinking;
-        u8                      locks_mul;
-        u32                     nulls_base;
-        rht_hashfn_t            hashfn;
-        rht_obj_hashfn_t        obj_hashfn;
-        rht_obj_cmpfn_t         obj_cmpfn;
-};
-
-/**
- * struct rhashtable - Hash table handle
- * @tbl: Bucket table
- * @key_len: Key length for hashfn
- * @max_elems: Maximum number of elements in table
- * @p: Configuration parameters
- * @rhlist: True if this is an rhltable
- * @run_work: Deferred worker to expand/shrink asynchronously
- * @mutex: Mutex to protect current/future table swapping
- * @lock: Spin lock to protect walker list
- * @nelems: Number of elements in table
- */
-struct rhashtable {
-        struct bucket_table __rcu       *tbl;
-        unsigned int                    key_len;
-        unsigned int                    max_elems;
-        struct rhashtable_params        p;
-        bool                            rhlist;
-        struct work_struct              run_work;
-        struct mutex                    mutex;
-        spinlock_t                      lock;
-        atomic_t                        nelems;
-};
-
-/**
- * struct rhltable - Hash table with duplicate objects in a list
- * @ht: Underlying rhtable
- */
-struct rhltable {
-        struct rhashtable ht;
-};
-
-/**
- * struct rhashtable_walker - Hash table walker
- * @list: List entry on list of walkers
- * @tbl: The table that we were walking over
- */
-struct rhashtable_walker {
-        struct list_head list;
-        struct bucket_table *tbl;
-};
-
-/**
- * struct rhashtable_iter - Hash table iterator
- * @ht: Table to iterate through
- * @p: Current pointer
- * @list: Current hash list pointer
- * @walker: Associated rhashtable walker
- * @slot: Current slot
- * @skip: Number of entries to skip in slot
- */
-struct rhashtable_iter {
-        struct rhashtable *ht;
-        struct rhash_head *p;
-        struct rhlist_head *list;
-        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)
-{
-        return NULLS_MARKER(ht->p.nulls_base + hash);
-}
-
-#define INIT_RHT_NULLS_HEAD(ptr, ht, hash) \
-        ((ptr) = (typeof(ptr)) rht_marker(ht, hash))
+#define INIT_RHT_NULLS_HEAD(ptr)        \
+        ((ptr) = (typeof(ptr)) NULLS_MARKER(0))
 
 static inline bool rht_is_a_nulls(const struct rhash_head *ptr)
 {
         return ((unsigned long) ptr & 1);
 }
 
-static inline unsigned long rht_get_nulls_value(const struct rhash_head *ptr)
-{
-        return ((unsigned long) ptr) >> 1;
-}
-
 static inline void *rht_obj(const struct rhashtable *ht,
                             const struct rhash_head *he)
 {
@@ -237,7 +92,7 @@ static inline void *rht_obj(const struct rhashtable *ht,
 static inline unsigned int rht_bucket_index(const struct bucket_table *tbl,
                                             unsigned int hash)
 {
-        return (hash >> RHT_HASH_RESERVED_SPACE) & (tbl->size - 1);
+        return hash & (tbl->size - 1);
 }
 
 static inline unsigned int rht_key_get_hash(struct rhashtable *ht,
@@ -376,11 +231,6 @@ static inline int lockdep_rht_bucket_is_held(const struct bucket_table *tbl,
 }
 #endif /* CONFIG_PROVE_LOCKING */
 
-int rhashtable_init(struct rhashtable *ht,
-                    const struct rhashtable_params *params);
-int rhltable_init(struct rhltable *hlt,
-                  const struct rhashtable_params *params);
-
 void *rhashtable_insert_slow(struct rhashtable *ht, const void *key,
                              struct rhash_head *obj);
 
@@ -745,7 +595,7 @@ static inline void *__rhashtable_insert_fast(
         lock = rht_bucket_lock(tbl, hash);
         spin_lock_bh(lock);
 
-        if (unlikely(rht_dereference_bucket(tbl->future_tbl, tbl, hash))) {
+        if (unlikely(rcu_access_pointer(tbl->future_tbl))) {
 slow_path:
                 spin_unlock_bh(lock);
                 rcu_read_unlock();
diff --git a/include/linux/ring_buffer.h b/include/linux/ring_buffer.h
index 003d09ab308d..0940fda59872 100644
--- a/include/linux/ring_buffer.h
+++ b/include/linux/ring_buffer.h
@@ -164,8 +164,8 @@ void ring_buffer_record_disable(struct ring_buffer *buffer);
 void ring_buffer_record_enable(struct ring_buffer *buffer);
 void ring_buffer_record_off(struct ring_buffer *buffer);
 void ring_buffer_record_on(struct ring_buffer *buffer);
-int ring_buffer_record_is_on(struct ring_buffer *buffer);
-int ring_buffer_record_is_set_on(struct ring_buffer *buffer);
+bool ring_buffer_record_is_on(struct ring_buffer *buffer);
+bool ring_buffer_record_is_set_on(struct ring_buffer *buffer);
 void ring_buffer_record_disable_cpu(struct ring_buffer *buffer, int cpu);
 void ring_buffer_record_enable_cpu(struct ring_buffer *buffer, int cpu);
 
diff --git a/include/linux/rtc.h b/include/linux/rtc.h
index 6268208760e9..6aedc30003e7 100644
--- a/include/linux/rtc.h
+++ b/include/linux/rtc.h
@@ -87,16 +87,11 @@ struct rtc_class_ops {
         int (*set_offset)(struct device *, long offset);
 };
 
-typedef struct rtc_task {
-        void (*func)(void *private_data);
-        void *private_data;
-} rtc_task_t;
-
-
 struct rtc_timer {
-        struct rtc_task task;
         struct timerqueue_node node;
         ktime_t period;
+        void (*func)(void *private_data);
+        void *private_data;
         int enabled;
 };
 
@@ -121,8 +116,6 @@ struct rtc_device {
         wait_queue_head_t irq_queue;
         struct fasync_struct *async_queue;
 
-        struct rtc_task *irq_task;
-        spinlock_t irq_task_lock;
         int irq_freq;
         int max_user_freq;
 
@@ -204,14 +197,8 @@ extern void rtc_update_irq(struct rtc_device *rtc,
 extern struct rtc_device *rtc_class_open(const char *name);
 extern void rtc_class_close(struct rtc_device *rtc);
 
-extern int rtc_irq_register(struct rtc_device *rtc,
-                                struct rtc_task *task);
-extern void rtc_irq_unregister(struct rtc_device *rtc,
-                                struct rtc_task *task);
-extern int rtc_irq_set_state(struct rtc_device *rtc,
-                                struct rtc_task *task, int enabled);
-extern int rtc_irq_set_freq(struct rtc_device *rtc,
-                                struct rtc_task *task, int freq);
+extern int rtc_irq_set_state(struct rtc_device *rtc, int enabled);
+extern int rtc_irq_set_freq(struct rtc_device *rtc, int freq);
 extern int rtc_update_irq_enable(struct rtc_device *rtc, unsigned int enabled);
 extern int rtc_alarm_irq_enable(struct rtc_device *rtc, unsigned int enabled);
 extern int rtc_dev_update_irq_enable_emul(struct rtc_device *rtc,
diff --git a/include/linux/sbitmap.h b/include/linux/sbitmap.h
index e6539536dea9..804a50983ec5 100644
--- a/include/linux/sbitmap.h
+++ b/include/linux/sbitmap.h
@@ -23,6 +23,8 @@
 #include <linux/kernel.h>
 #include <linux/slab.h>
 
+struct seq_file;
+
 /**
  * struct sbitmap_word - Word in a &struct sbitmap.
  */
diff --git a/include/linux/sched.h b/include/linux/sched.h
index dac5086e3815..977cb57d7bc9 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -722,8 +722,8 @@ struct task_struct {
         unsigned                        restore_sigmask:1;
 #endif
 #ifdef CONFIG_MEMCG
-        unsigned                        memcg_may_oom:1;
-#ifndef CONFIG_SLOB
+        unsigned                        in_user_fault:1;
+#ifdef CONFIG_MEMCG_KMEM
         unsigned                        memcg_kmem_skip_account:1;
 #endif
 #endif
@@ -734,6 +734,10 @@ struct task_struct {
         /* disallow userland-initiated cgroup migration */
         unsigned                        no_cgroup_migration:1;
 #endif
+#ifdef CONFIG_BLK_CGROUP
+        /* to be used once the psi infrastructure lands upstream. */
+        unsigned                        use_memdelay:1;
+#endif
 
         unsigned long                   atomic_flags; /* Flags requiring atomic access. */
 
@@ -775,7 +779,8 @@ struct task_struct {
         struct list_head                ptrace_entry;
 
         /* PID/PID hash table linkage. */
-        struct pid_link                 pids[PIDTYPE_MAX];
+        struct pid                      *thread_pid;
+        struct hlist_node               pid_links[PIDTYPE_MAX];
         struct list_head                thread_group;
         struct list_head                thread_node;
 
@@ -849,6 +854,7 @@ struct task_struct {
 #endif
 #ifdef CONFIG_DETECT_HUNG_TASK
         unsigned long                   last_switch_count;
+        unsigned long                   last_switch_time;
 #endif
         /* Filesystem information: */
         struct fs_struct                *fs;
@@ -1148,6 +1154,13 @@ struct task_struct {
 
         /* Number of pages to reclaim on returning to userland: */
         unsigned int                    memcg_nr_pages_over_high;
+
+        /* Used by memcontrol for targeted memcg charge: */
+        struct mem_cgroup               *active_memcg;
+#endif
+
+#ifdef CONFIG_BLK_CGROUP
+        struct request_queue            *throttle_queue;
 #endif
 
 #ifdef CONFIG_UPROBES
@@ -1198,27 +1211,7 @@ struct task_struct {
 
 static inline struct pid *task_pid(struct task_struct *task)
 {
-        return task->pids[PIDTYPE_PID].pid;
-}
-
-static inline struct pid *task_tgid(struct task_struct *task)
-{
-        return task->group_leader->pids[PIDTYPE_PID].pid;
-}
-
-/*
- * Without tasklist or RCU lock it is not safe to dereference
- * the result of task_pgrp/task_session even if task == current,
- * we can race with another thread doing sys_setsid/sys_setpgid.
- */
-static inline struct pid *task_pgrp(struct task_struct *task)
-{
-        return task->group_leader->pids[PIDTYPE_PGID].pid;
-}
-
-static inline struct pid *task_session(struct task_struct *task)
-{
-        return task->group_leader->pids[PIDTYPE_SID].pid;
+        return task->thread_pid;
 }
 
 /*
@@ -1267,7 +1260,7 @@ static inline pid_t task_tgid_nr(struct task_struct *tsk)
  */
 static inline int pid_alive(const struct task_struct *p)
 {
-        return p->pids[PIDTYPE_PID].pid != NULL;
+        return p->thread_pid != NULL;
 }
 
 static inline pid_t task_pgrp_nr_ns(struct task_struct *tsk, struct pid_namespace *ns)
@@ -1293,12 +1286,12 @@ static inline pid_t task_session_vnr(struct task_struct *tsk)
 
 static inline pid_t task_tgid_nr_ns(struct task_struct *tsk, struct pid_namespace *ns)
 {
-        return __task_pid_nr_ns(tsk, __PIDTYPE_TGID, ns);
+        return __task_pid_nr_ns(tsk, PIDTYPE_TGID, ns);
 }
 
 static inline pid_t task_tgid_vnr(struct task_struct *tsk)
 {
-        return __task_pid_nr_ns(tsk, __PIDTYPE_TGID, NULL);
+        return __task_pid_nr_ns(tsk, PIDTYPE_TGID, NULL);
 }
 
 static inline pid_t task_ppid_nr_ns(const struct task_struct *tsk, struct pid_namespace *ns)
diff --git a/include/linux/sched/mm.h b/include/linux/sched/mm.h
index 44d356f5e47c..aebb370a0006 100644
--- a/include/linux/sched/mm.h
+++ b/include/linux/sched/mm.h
@@ -248,6 +248,43 @@ static inline void memalloc_noreclaim_restore(unsigned int flags)
         current->flags = (current->flags & ~PF_MEMALLOC) | flags;
 }
 
+#ifdef CONFIG_MEMCG
+/**
+ * memalloc_use_memcg - Starts the remote memcg charging scope.
+ * @memcg: memcg to charge.
+ *
+ * This function marks the beginning of the remote memcg charging scope. All the
+ * __GFP_ACCOUNT allocations till the end of the scope will be charged to the
+ * given memcg.
+ *
+ * NOTE: This function is not nesting safe.
+ */
+static inline void memalloc_use_memcg(struct mem_cgroup *memcg)
+{
+        WARN_ON_ONCE(current->active_memcg);
+        current->active_memcg = memcg;
+}
+
+/**
+ * memalloc_unuse_memcg - Ends the remote memcg charging scope.
+ *
+ * This function marks the end of the remote memcg charging scope started by
+ * memalloc_use_memcg().
+ */
+static inline void memalloc_unuse_memcg(void)
+{
+        current->active_memcg = NULL;
+}
+#else
+static inline void memalloc_use_memcg(struct mem_cgroup *memcg)
+{
+}
+
+static inline void memalloc_unuse_memcg(void)
+{
+}
+#endif
+
 #ifdef CONFIG_MEMBARRIER
 enum {
         MEMBARRIER_STATE_PRIVATE_EXPEDITED_READY                = (1U << 0),
diff --git a/include/linux/sched/signal.h b/include/linux/sched/signal.h
index 113d1ad1ced7..1be35729c2c5 100644
--- a/include/linux/sched/signal.h
+++ b/include/linux/sched/signal.h
@@ -69,6 +69,11 @@ struct thread_group_cputimer {
         bool checking_timer;
 };
 
+struct multiprocess_signals {
+        sigset_t signal;
+        struct hlist_node node;
+};
+
 /*
  * NOTE! "signal_struct" does not have its own
  * locking, because a shared signal_struct always
@@ -90,6 +95,9 @@ struct signal_struct {
         /* shared signal handling: */
         struct sigpending       shared_pending;
 
+        /* For collecting multiprocess signals during fork */
+        struct hlist_head       multiprocess;
+
         /* thread group exit support */
         int                     group_exit_code;
         /* overloaded:
@@ -146,7 +154,8 @@ struct signal_struct {
 
 #endif
 
-        struct pid *leader_pid;
+        /* PID/PID hash table linkage. */
+        struct pid *pids[PIDTYPE_MAX];
 
 #ifdef CONFIG_NO_HZ_FULL
         atomic_t tick_dep_mask;
@@ -314,7 +323,7 @@ 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 void force_sigsegv(int sig, struct task_struct *p);
 extern int force_sig_info(int, struct siginfo *, struct task_struct *);
 extern int __kill_pgrp_info(int sig, struct siginfo *info, struct pid *pgrp);
 extern int kill_pid_info(int sig, struct siginfo *info, struct pid *pid);
@@ -329,7 +338,7 @@ extern int send_sig(int, struct task_struct *, int);
 extern int zap_other_threads(struct task_struct *p);
 extern struct sigqueue *sigqueue_alloc(void);
 extern void sigqueue_free(struct sigqueue *);
-extern int send_sigqueue(struct sigqueue *,  struct task_struct *, int group);
+extern int send_sigqueue(struct sigqueue *, struct pid *, enum pid_type);
 extern int do_sigaction(int, struct k_sigaction *, struct k_sigaction *);
 
 static inline int restart_syscall(void)
@@ -371,6 +380,7 @@ static inline int signal_pending_state(long state, struct task_struct *p)
  */
 extern void recalc_sigpending_and_wake(struct task_struct *t);
 extern void recalc_sigpending(void);
+extern void calculate_sigpending(void);
 
 extern void signal_wake_up_state(struct task_struct *t, unsigned int state);
 
@@ -383,6 +393,8 @@ static inline void ptrace_signal_wake_up(struct task_struct *t, bool resume)
         signal_wake_up_state(t, resume ? __TASK_TRACED : 0);
 }
 
+void task_join_group_stop(struct task_struct *task);
+
 #ifdef TIF_RESTORE_SIGMASK
 /*
  * Legacy restore_sigmask accessors.  These are inefficient on
@@ -556,6 +568,37 @@ extern bool current_is_single_threaded(void);
 typedef int (*proc_visitor)(struct task_struct *p, void *data);
 void walk_process_tree(struct task_struct *top, proc_visitor, void *);
 
+static inline
+struct pid *task_pid_type(struct task_struct *task, enum pid_type type)
+{
+        struct pid *pid;
+        if (type == PIDTYPE_PID)
+                pid = task_pid(task);
+        else
+                pid = task->signal->pids[type];
+        return pid;
+}
+
+static inline struct pid *task_tgid(struct task_struct *task)
+{
+        return task->signal->pids[PIDTYPE_TGID];
+}
+
+/*
+ * Without tasklist or RCU lock it is not safe to dereference
+ * the result of task_pgrp/task_session even if task == current,
+ * we can race with another thread doing sys_setsid/sys_setpgid.
+ */
+static inline struct pid *task_pgrp(struct task_struct *task)
+{
+        return task->signal->pids[PIDTYPE_PGID];
+}
+
+static inline struct pid *task_session(struct task_struct *task)
+{
+        return task->signal->pids[PIDTYPE_SID];
+}
+
 static inline int get_nr_threads(struct task_struct *tsk)
 {
         return tsk->signal->nr_threads;
@@ -574,7 +617,7 @@ static inline bool thread_group_leader(struct task_struct *p)
  */
 static inline bool has_group_leader_pid(struct task_struct *p)
 {
-        return task_pid(p) == p->signal->leader_pid;
+        return task_pid(p) == task_tgid(p);
 }
 
 static inline
diff --git a/include/linux/sched/sysctl.h b/include/linux/sched/sysctl.h
index 913488d828cb..a9c32daeb9d8 100644
--- a/include/linux/sched/sysctl.h
+++ b/include/linux/sched/sysctl.h
@@ -10,6 +10,7 @@ struct ctl_table;
 extern int           sysctl_hung_task_check_count;
 extern unsigned int  sysctl_hung_task_panic;
 extern unsigned long sysctl_hung_task_timeout_secs;
+extern unsigned long sysctl_hung_task_check_interval_secs;
 extern int sysctl_hung_task_warnings;
 extern int proc_dohung_task_timeout_secs(struct ctl_table *table, int write,
                                          void __user *buffer,
diff --git a/include/linux/sched/user.h b/include/linux/sched/user.h
index 96fe289c4c6e..39ad98c09c58 100644
--- a/include/linux/sched/user.h
+++ b/include/linux/sched/user.h
@@ -4,6 +4,7 @@
 
 #include <linux/uidgid.h>
 #include <linux/atomic.h>
+#include <linux/refcount.h>
 #include <linux/ratelimit.h>
 
 struct key;
@@ -12,7 +13,7 @@ struct key;
  * Some day this will be a full-fledged user tracking system..
  */
 struct user_struct {
-        atomic_t __count;       /* reference count */
+        refcount_t __count;     /* reference count */
         atomic_t processes;     /* How many processes does this user have? */
         atomic_t sigpending;    /* How many pending signals does this user have? */
 #ifdef CONFIG_FANOTIFY
@@ -59,7 +60,7 @@ extern struct user_struct root_user;
 extern struct user_struct * alloc_uid(kuid_t);
 static inline struct user_struct *get_uid(struct user_struct *u)
 {
-        atomic_inc(&u->__count);
+        refcount_inc(&u->__count);
         return u;
 }
 extern void free_uid(struct user_struct *);
diff --git a/include/linux/sctp.h b/include/linux/sctp.h
index b36c76635f18..83d94341e003 100644
--- a/include/linux/sctp.h
+++ b/include/linux/sctp.h
@@ -801,4 +801,11 @@ struct sctp_strreset_resptsn {
         __be32 receivers_next_tsn;
 };
 
+enum {
+        SCTP_DSCP_SET_MASK = 0x1,
+        SCTP_DSCP_VAL_MASK = 0xfc,
+        SCTP_FLOWLABEL_SET_MASK = 0x100000,
+        SCTP_FLOWLABEL_VAL_MASK = 0xfffff
+};
+
 #endif /* __LINUX_SCTP_H__ */
diff --git a/include/linux/security.h b/include/linux/security.h
index 63030c85ee19..75f4156c84d7 100644
--- a/include/linux/security.h
+++ b/include/linux/security.h
@@ -159,6 +159,27 @@ extern int mmap_min_addr_handler(struct ctl_table *table, int write,
 typedef int (*initxattrs) (struct inode *inode,
                            const struct xattr *xattr_array, void *fs_data);
 
+
+/* Keep the kernel_load_data_id enum in sync with kernel_read_file_id */
+#define __data_id_enumify(ENUM, dummy) LOADING_ ## ENUM,
+#define __data_id_stringify(dummy, str) #str,
+
+enum kernel_load_data_id {
+        __kernel_read_file_id(__data_id_enumify)
+};
+
+static const char * const kernel_load_data_str[] = {
+        __kernel_read_file_id(__data_id_stringify)
+};
+
+static inline const char *kernel_load_data_id_str(enum kernel_load_data_id id)
+{
+        if ((unsigned)id >= LOADING_MAX_ID)
+                return kernel_load_data_str[LOADING_UNKNOWN];
+
+        return kernel_load_data_str[id];
+}
+
 #ifdef CONFIG_SECURITY
 
 struct security_mnt_opts {
@@ -309,7 +330,7 @@ void security_file_set_fowner(struct file *file);
 int security_file_send_sigiotask(struct task_struct *tsk,
                                  struct fown_struct *fown, int sig);
 int security_file_receive(struct file *file);
-int security_file_open(struct file *file, const struct cred *cred);
+int security_file_open(struct file *file);
 int security_task_alloc(struct task_struct *task, unsigned long clone_flags);
 void security_task_free(struct task_struct *task);
 int security_cred_alloc_blank(struct cred *cred, gfp_t gfp);
@@ -320,6 +341,7 @@ void security_cred_getsecid(const struct cred *c, u32 *secid);
 int security_kernel_act_as(struct cred *new, u32 secid);
 int security_kernel_create_files_as(struct cred *new, struct inode *inode);
 int security_kernel_module_request(char *kmod_name);
+int security_kernel_load_data(enum kernel_load_data_id id);
 int security_kernel_read_file(struct file *file, enum kernel_read_file_id id);
 int security_kernel_post_read_file(struct file *file, char *buf, loff_t size,
                                    enum kernel_read_file_id id);
@@ -858,8 +880,7 @@ static inline int security_file_receive(struct file *file)
         return 0;
 }
 
-static inline int security_file_open(struct file *file,
-                                     const struct cred *cred)
+static inline int security_file_open(struct file *file)
 {
         return 0;
 }
@@ -909,6 +930,11 @@ static inline int security_kernel_module_request(char *kmod_name)
         return 0;
 }
 
+static inline int security_kernel_load_data(enum kernel_load_data_id id)
+{
+        return 0;
+}
+
 static inline int security_kernel_read_file(struct file *file,
                                             enum kernel_read_file_id id)
 {
diff --git a/include/linux/selection.h b/include/linux/selection.h
index 5b278ce99d8d..a8f5b97b216f 100644
--- a/include/linux/selection.h
+++ b/include/linux/selection.h
@@ -32,6 +32,7 @@ extern unsigned char default_blu[];
 
 extern unsigned short *screen_pos(struct vc_data *vc, int w_offset, int viewed);
 extern u16 screen_glyph(struct vc_data *vc, int offset);
+extern u32 screen_glyph_unicode(struct vc_data *vc, int offset);
 extern void complement_pos(struct vc_data *vc, int offset);
 extern void invert_screen(struct vc_data *vc, int offset, int count, int shift);
 
@@ -42,4 +43,9 @@ extern u16 vcs_scr_readw(struct vc_data *vc, const u16 *org);
 extern void vcs_scr_writew(struct vc_data *vc, u16 val, u16 *org);
 extern void vcs_scr_updated(struct vc_data *vc);
 
+extern int vc_uniscr_check(struct vc_data *vc);
+extern void vc_uniscr_copy_line(struct vc_data *vc, void *dest, int viewed,
+                                unsigned int row, unsigned int col,
+                                unsigned int nr);
+
 #endif
diff --git a/include/linux/serial_8250.h b/include/linux/serial_8250.h
index 76b9db71e489..18e21427bce4 100644
--- a/include/linux/serial_8250.h
+++ b/include/linux/serial_8250.h
@@ -160,6 +160,9 @@ extern void serial8250_do_shutdown(struct uart_port *port);
 extern void serial8250_do_pm(struct uart_port *port, unsigned int state,
                              unsigned int oldstate);
 extern void serial8250_do_set_mctrl(struct uart_port *port, unsigned int mctrl);
+extern void serial8250_do_set_divisor(struct uart_port *port, unsigned int baud,
+                                      unsigned int quot,
+                                      unsigned int quot_frac);
 extern int fsl8250_handle_irq(struct uart_port *port);
 int serial8250_handle_irq(struct uart_port *port, unsigned int iir);
 unsigned char serial8250_rx_chars(struct uart_8250_port *up, unsigned char lsr);
diff --git a/include/linux/serial_core.h b/include/linux/serial_core.h
index 06ea4eeb09ab..406edae44ca3 100644
--- a/include/linux/serial_core.h
+++ b/include/linux/serial_core.h
@@ -127,6 +127,13 @@ struct uart_port {
                                              struct ktermios *);
         unsigned int            (*get_mctrl)(struct uart_port *);
         void                    (*set_mctrl)(struct uart_port *, unsigned int);
+        unsigned int            (*get_divisor)(struct uart_port *,
+                                               unsigned int baud,
+                                               unsigned int *frac);
+        void                    (*set_divisor)(struct uart_port *,
+                                               unsigned int baud,
+                                               unsigned int quot,
+                                               unsigned int quot_frac);
         int                     (*startup)(struct uart_port *port);
         void                    (*shutdown)(struct uart_port *port);
         void                    (*throttle)(struct uart_port *port);
diff --git a/include/linux/set_memory.h b/include/linux/set_memory.h
index da5178216da5..2a986d282a97 100644
--- a/include/linux/set_memory.h
+++ b/include/linux/set_memory.h
@@ -17,6 +17,20 @@ static inline int set_memory_x(unsigned long addr,  int numpages) { return 0; }
 static inline int set_memory_nx(unsigned long addr, int numpages) { return 0; }
 #endif
 
+#ifndef set_mce_nospec
+static inline int set_mce_nospec(unsigned long pfn)
+{
+        return 0;
+}
+#endif
+
+#ifndef clear_mce_nospec
+static inline int clear_mce_nospec(unsigned long pfn)
+{
+        return 0;
+}
+#endif
+
 #ifndef CONFIG_ARCH_HAS_MEM_ENCRYPT
 static inline int set_memory_encrypted(unsigned long addr, int numpages)
 {
diff --git a/include/linux/sfp.h b/include/linux/sfp.h
index ebce9e24906a..d37518e89db2 100644
--- a/include/linux/sfp.h
+++ b/include/linux/sfp.h
@@ -231,6 +231,50 @@ struct sfp_eeprom_id {
         struct sfp_eeprom_ext ext;
 } __packed;
 
+struct sfp_diag {
+        __be16 temp_high_alarm;
+        __be16 temp_low_alarm;
+        __be16 temp_high_warn;
+        __be16 temp_low_warn;
+        __be16 volt_high_alarm;
+        __be16 volt_low_alarm;
+        __be16 volt_high_warn;
+        __be16 volt_low_warn;
+        __be16 bias_high_alarm;
+        __be16 bias_low_alarm;
+        __be16 bias_high_warn;
+        __be16 bias_low_warn;
+        __be16 txpwr_high_alarm;
+        __be16 txpwr_low_alarm;
+        __be16 txpwr_high_warn;
+        __be16 txpwr_low_warn;
+        __be16 rxpwr_high_alarm;
+        __be16 rxpwr_low_alarm;
+        __be16 rxpwr_high_warn;
+        __be16 rxpwr_low_warn;
+        __be16 laser_temp_high_alarm;
+        __be16 laser_temp_low_alarm;
+        __be16 laser_temp_high_warn;
+        __be16 laser_temp_low_warn;
+        __be16 tec_cur_high_alarm;
+        __be16 tec_cur_low_alarm;
+        __be16 tec_cur_high_warn;
+        __be16 tec_cur_low_warn;
+        __be32 cal_rxpwr4;
+        __be32 cal_rxpwr3;
+        __be32 cal_rxpwr2;
+        __be32 cal_rxpwr1;
+        __be32 cal_rxpwr0;
+        __be16 cal_txi_slope;
+        __be16 cal_txi_offset;
+        __be16 cal_txpwr_slope;
+        __be16 cal_txpwr_offset;
+        __be16 cal_t_slope;
+        __be16 cal_t_offset;
+        __be16 cal_v_slope;
+        __be16 cal_v_offset;
+} __packed;
+
 /* SFP EEPROM registers */
 enum {
         SFP_PHYS_ID                     = 0x00,
@@ -384,7 +428,33 @@ enum {
         SFP_TEC_CUR                     = 0x6c,
 
         SFP_STATUS                      = 0x6e,
-        SFP_ALARM                       = 0x70,
+        SFP_ALARM0                      = 0x70,
+        SFP_ALARM0_TEMP_HIGH            = BIT(7),
+        SFP_ALARM0_TEMP_LOW             = BIT(6),
+        SFP_ALARM0_VCC_HIGH             = BIT(5),
+        SFP_ALARM0_VCC_LOW              = BIT(4),
+        SFP_ALARM0_TX_BIAS_HIGH         = BIT(3),
+        SFP_ALARM0_TX_BIAS_LOW          = BIT(2),
+        SFP_ALARM0_TXPWR_HIGH           = BIT(1),
+        SFP_ALARM0_TXPWR_LOW            = BIT(0),
+
+        SFP_ALARM1                      = 0x71,
+        SFP_ALARM1_RXPWR_HIGH           = BIT(7),
+        SFP_ALARM1_RXPWR_LOW            = BIT(6),
+
+        SFP_WARN0                       = 0x74,
+        SFP_WARN0_TEMP_HIGH             = BIT(7),
+        SFP_WARN0_TEMP_LOW              = BIT(6),
+        SFP_WARN0_VCC_HIGH              = BIT(5),
+        SFP_WARN0_VCC_LOW               = BIT(4),
+        SFP_WARN0_TX_BIAS_HIGH          = BIT(3),
+        SFP_WARN0_TX_BIAS_LOW           = BIT(2),
+        SFP_WARN0_TXPWR_HIGH            = BIT(1),
+        SFP_WARN0_TXPWR_LOW             = BIT(0),
+
+        SFP_WARN1                       = 0x75,
+        SFP_WARN1_RXPWR_HIGH            = BIT(7),
+        SFP_WARN1_RXPWR_LOW             = BIT(6),
 
         SFP_EXT_STATUS                  = 0x76,
         SFP_VSL                         = 0x78,
diff --git a/include/linux/shrinker.h b/include/linux/shrinker.h
index 6794490f25b2..9443cafd1969 100644
--- a/include/linux/shrinker.h
+++ b/include/linux/shrinker.h
@@ -12,6 +12,9 @@
 struct shrink_control {
         gfp_t gfp_mask;
 
+        /* current node being shrunk (for NUMA aware shrinkers) */
+        int nid;
+
         /*
          * How many objects scan_objects should scan and try to reclaim.
          * This is reset before every call, so it is safe for callees
@@ -26,20 +29,20 @@ struct shrink_control {
          */
         unsigned long nr_scanned;
 
-        /* current node being shrunk (for NUMA aware shrinkers) */
-        int nid;
-
         /* current memcg being shrunk (for memcg aware shrinkers) */
         struct mem_cgroup *memcg;
 };
 
 #define SHRINK_STOP (~0UL)
+#define SHRINK_EMPTY (~0UL - 1)
 /*
  * A callback you can register to apply pressure to ageable caches.
  *
  * @count_objects should return the number of freeable items in the cache. If
- * there are no objects to free or the number of freeable items cannot be
- * determined, it should return 0. No deadlock checks should be done during the
+ * there are no objects to free, it should return SHRINK_EMPTY, while 0 is
+ * returned in cases of the number of freeable items cannot be determined
+ * or shrinker should skip this cache for this time (e.g., their number
+ * is below shrinkable limit). No deadlock checks should be done during the
  * count callback - the shrinker relies on aggregating scan counts that couldn't
  * be executed due to potential deadlocks to be run at a later call when the
  * deadlock condition is no longer pending.
@@ -60,12 +63,16 @@ struct shrinker {
         unsigned long (*scan_objects)(struct shrinker *,
                                       struct shrink_control *sc);
 
-        int seeks;      /* seeks to recreate an obj */
         long batch;     /* reclaim batch size, 0 = default */
-        unsigned long flags;
+        int seeks;      /* seeks to recreate an obj */
+        unsigned flags;
 
         /* These are for internal use */
         struct list_head list;
+#ifdef CONFIG_MEMCG_KMEM
+        /* ID in shrinker_idr */
+        int id;
+#endif
         /* objs pending delete, per node */
         atomic_long_t *nr_deferred;
 };
diff --git a/include/linux/signal.h b/include/linux/signal.h
index 3c5200137b24..3d4cd5db30a9 100644
--- a/include/linux/signal.h
+++ b/include/linux/signal.h
@@ -254,18 +254,20 @@ static inline int valid_signal(unsigned long sig)
 
 struct timespec;
 struct pt_regs;
+enum pid_type;
 
 extern int next_signal(struct sigpending *pending, sigset_t *mask);
 extern int do_send_sig_info(int sig, struct siginfo *info,
-                                struct task_struct *p, bool group);
-extern int group_send_sig_info(int sig, struct siginfo *info, struct task_struct *p);
+                                struct task_struct *p, enum pid_type type);
+extern int group_send_sig_info(int sig, struct siginfo *info,
+                               struct task_struct *p, enum pid_type type);
 extern int __group_send_sig_info(int, struct siginfo *, struct task_struct *);
 extern int sigprocmask(int, sigset_t *, sigset_t *);
 extern void set_current_blocked(sigset_t *);
 extern void __set_current_blocked(const sigset_t *);
 extern int show_unhandled_signals;
 
-extern int get_signal(struct ksignal *ksig);
+extern bool get_signal(struct ksignal *ksig);
 extern void signal_setup_done(int failed, struct ksignal *ksig, int stepping);
 extern void exit_signals(struct task_struct *tsk);
 extern void kernel_sigaction(int, __sighandler_t);
@@ -287,7 +289,7 @@ static inline void disallow_signal(int sig)
 
 extern struct kmem_cache *sighand_cachep;
 
-int unhandled_signal(struct task_struct *tsk, int sig);
+extern bool unhandled_signal(struct task_struct *tsk, int sig);
 
 /*
  * In POSIX a signal is sent either to a specific thread (Linux task)
diff --git a/include/linux/skbuff.h b/include/linux/skbuff.h
index 610a201126ee..17a13e4785fc 100644
--- a/include/linux/skbuff.h
+++ b/include/linux/skbuff.h
@@ -641,6 +641,7 @@ typedef unsigned char *sk_buff_data_t;
  *      @no_fcs:  Request NIC to treat last 4 bytes as Ethernet FCS
  *      @csum_not_inet: use CRC32c to resolve CHECKSUM_PARTIAL
  *      @dst_pending_confirm: need to confirm neighbour
+ *      @decrypted: Decrypted SKB
   *     @napi_id: id of the NAPI struct this skb came from
  *      @secmark: security marking
  *      @mark: Generic packet mark
@@ -675,12 +676,16 @@ struct sk_buff {
                                  * UDP receive path is one user.
                                  */
                                 unsigned long           dev_scratch;
-                                int                     ip_defrag_offset;
                         };
                 };
-                struct rb_node  rbnode; /* used in netem & tcp stack */
+                struct rb_node          rbnode; /* used in netem, ip4 defrag, and tcp stack */
+                struct list_head        list;
+        };
+
+        union {
+                struct sock             *sk;
+                int                     ip_defrag_offset;
         };
-        struct sock             *sk;
 
         union {
                 ktime_t         tstamp;
@@ -791,6 +796,9 @@ struct sk_buff {
         __u8                    tc_redirected:1;
         __u8                    tc_from_ingress:1;
 #endif
+#ifdef CONFIG_TLS_DEVICE
+        __u8                    decrypted:1;
+#endif
 
 #ifdef CONFIG_NET_SCHED
         __u16                   tc_index;       /* traffic control index */
@@ -1030,6 +1038,7 @@ static inline struct sk_buff *alloc_skb_fclone(unsigned int size,
 }
 
 struct sk_buff *skb_morph(struct sk_buff *dst, struct sk_buff *src);
+void skb_headers_offset_update(struct sk_buff *skb, int off);
 int skb_copy_ubufs(struct sk_buff *skb, gfp_t gfp_mask);
 struct sk_buff *skb_clone(struct sk_buff *skb, gfp_t priority);
 void skb_copy_header(struct sk_buff *new, const struct sk_buff *old);
@@ -2354,7 +2363,7 @@ static inline void skb_probe_transport_header(struct sk_buff *skb,
         if (skb_transport_header_was_set(skb))
                 return;
 
-        if (skb_flow_dissect_flow_keys_basic(skb, &keys, 0, 0, 0, 0, 0))
+        if (skb_flow_dissect_flow_keys_basic(skb, &keys, NULL, 0, 0, 0, 0))
                 skb_set_transport_header(skb, keys.control.thoff);
         else
                 skb_set_transport_header(skb, offset_hint);
@@ -2580,7 +2589,7 @@ static inline void __skb_queue_purge(struct sk_buff_head *list)
                 kfree_skb(skb);
 }
 
-void skb_rbtree_purge(struct rb_root *root);
+unsigned int skb_rbtree_purge(struct rb_root *root);
 
 void *netdev_alloc_frag(unsigned int fragsz);
 
diff --git a/include/linux/slab.h b/include/linux/slab.h
index 14e3fe4bd6a1..ed9cbddeb4a6 100644
--- a/include/linux/slab.h
+++ b/include/linux/slab.h
@@ -97,7 +97,7 @@
 # define SLAB_FAILSLAB          0
 #endif
 /* Account to memcg */
-#if defined(CONFIG_MEMCG) && !defined(CONFIG_SLOB)
+#ifdef CONFIG_MEMCG_KMEM
 # define SLAB_ACCOUNT           ((slab_flags_t __force)0x04000000U)
 #else
 # define SLAB_ACCOUNT           0
diff --git a/include/linux/slimbus.h b/include/linux/slimbus.h
index c36cf121d2cd..12c9719b2a55 100644
--- a/include/linux/slimbus.h
+++ b/include/linux/slimbus.h
@@ -14,16 +14,16 @@ 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
+ * @dev_index: Device index
+ * @prod_code: Product code
+ * @manf_id: Manufacturer Id for the device
  */
 struct slim_eaddr {
-        u16 manf_id;
-        u16 prod_code;
-        u8 dev_index;
         u8 instance;
+        u8 dev_index;
+        u16 prod_code;
+        u16 manf_id;
 } __packed;
 
 /**
@@ -48,6 +48,8 @@ struct slim_controller;
  * @ctrl: slim controller instance.
  * @laddr: 1-byte Logical address of this device.
  * @is_laddr_valid: indicates if the laddr is valid or not
+ * @stream_list: List of streams on this device
+ * @stream_list_lock: lock to protect the stream list
  *
  * This is the client/device handle returned when a SLIMbus
  * device is registered with a controller.
@@ -60,6 +62,8 @@ struct slim_device {
         enum slim_device_status status;
         u8                      laddr;
         bool                    is_laddr_valid;
+        struct list_head        stream_list;
+        spinlock_t stream_list_lock;
 };
 
 #define to_slim_device(d) container_of(d, struct slim_device, dev)
@@ -108,6 +112,36 @@ struct slim_val_inf {
         struct  completion      *comp;
 };
 
+#define SLIM_DEVICE_MAX_CHANNELS        256
+/* A SLIMBus Device may have frmo 0 to 31 Ports (inclusive) */
+#define SLIM_DEVICE_MAX_PORTS           32
+
+/**
+ * struct slim_stream_config - SLIMbus stream configuration
+ *      Configuring a stream is done at hw_params or prepare call
+ *      from audio drivers where they have all the required information
+ *      regarding rate, number of channels and so on.
+ *      There is a 1:1 mapping of channel and ports.
+ *
+ * @rate: data rate
+ * @bps: bits per data sample
+ * @ch_count: number of channels
+ * @chs: pointer to list of channel numbers
+ * @port_mask: port mask of ports to use for this stream
+ * @direction: direction of the stream, SNDRV_PCM_STREAM_PLAYBACK
+ *      or SNDRV_PCM_STREAM_CAPTURE.
+ */
+struct slim_stream_config {
+        unsigned int rate;
+        unsigned int bps;
+        /* MAX 256 channels */
+        unsigned int ch_count;
+        unsigned int *chs;
+        /* Max 32 ports per device */
+        unsigned long port_mask;
+        int direction;
+};
+
 /*
  * use a macro to avoid include chaining to get THIS_MODULE
  */
@@ -138,6 +172,8 @@ static inline void slim_set_devicedata(struct slim_device *dev, void *data)
         dev_set_drvdata(&dev->dev, data);
 }
 
+struct slim_device *of_slim_get_device(struct slim_controller *ctrl,
+                                       struct device_node *np);
 struct slim_device *slim_get_device(struct slim_controller *ctrl,
                                     struct slim_eaddr *e_addr);
 int slim_get_logical_addr(struct slim_device *sbdev);
@@ -161,4 +197,16 @@ 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);
+
+/* SLIMbus Stream apis */
+struct slim_stream_runtime;
+struct slim_stream_runtime *slim_stream_allocate(struct slim_device *dev,
+                                                 const char *sname);
+int slim_stream_prepare(struct slim_stream_runtime *stream,
+                        struct slim_stream_config *c);
+int slim_stream_enable(struct slim_stream_runtime *stream);
+int slim_stream_disable(struct slim_stream_runtime *stream);
+int slim_stream_unprepare(struct slim_stream_runtime *stream);
+int slim_stream_free(struct slim_stream_runtime *stream);
+
 #endif /* _LINUX_SLIMBUS_H */
diff --git a/include/linux/soc/qcom/llcc-qcom.h b/include/linux/soc/qcom/llcc-qcom.h
new file mode 100644
index 000000000000..7e3b9c605ab2
--- /dev/null
+++ b/include/linux/soc/qcom/llcc-qcom.h
@@ -0,0 +1,180 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Copyright (c) 2017-2018, The Linux Foundation. All rights reserved.
+ *
+ */
+
+#include <linux/platform_device.h>
+#ifndef __LLCC_QCOM__
+#define __LLCC_QCOM__
+
+#define LLCC_CPUSS       1
+#define LLCC_VIDSC0      2
+#define LLCC_VIDSC1      3
+#define LLCC_ROTATOR     4
+#define LLCC_VOICE       5
+#define LLCC_AUDIO       6
+#define LLCC_MDMHPGRW    7
+#define LLCC_MDM         8
+#define LLCC_CMPT        10
+#define LLCC_GPUHTW      11
+#define LLCC_GPU         12
+#define LLCC_MMUHWT      13
+#define LLCC_CMPTDMA     15
+#define LLCC_DISP        16
+#define LLCC_VIDFW       17
+#define LLCC_MDMHPFX     20
+#define LLCC_MDMPNG      21
+#define LLCC_AUDHW       22
+
+/**
+ * llcc_slice_desc - Cache slice descriptor
+ * @slice_id: llcc slice id
+ * @slice_size: Size allocated for the llcc slice
+ */
+struct llcc_slice_desc {
+        u32 slice_id;
+        size_t slice_size;
+};
+
+/**
+ * llcc_slice_config - Data associated with the llcc slice
+ * @usecase_id: usecase id for which the llcc slice is used
+ * @slice_id: llcc slice id assigned to each slice
+ * @max_cap: maximum capacity of the llcc slice
+ * @priority: priority of the llcc slice
+ * @fixed_size: whether the llcc slice can grow beyond its size
+ * @bonus_ways: bonus ways associated with llcc slice
+ * @res_ways: reserved ways associated with llcc slice
+ * @cache_mode: mode of the llcc slice
+ * @probe_target_ways: Probe only reserved and bonus ways on a cache miss
+ * @dis_cap_alloc: Disable capacity based allocation
+ * @retain_on_pc: Retain through power collapse
+ * @activate_on_init: activate the slice on init
+ */
+struct llcc_slice_config {
+        u32 usecase_id;
+        u32 slice_id;
+        u32 max_cap;
+        u32 priority;
+        bool fixed_size;
+        u32 bonus_ways;
+        u32 res_ways;
+        u32 cache_mode;
+        u32 probe_target_ways;
+        bool dis_cap_alloc;
+        bool retain_on_pc;
+        bool activate_on_init;
+};
+
+/**
+ * llcc_drv_data - Data associated with the llcc driver
+ * @regmap: regmap associated with the llcc device
+ * @cfg: pointer to the data structure for slice configuration
+ * @lock: mutex associated with each slice
+ * @cfg_size: size of the config data table
+ * @max_slices: max slices as read from device tree
+ * @bcast_off: Offset of the broadcast bank
+ * @num_banks: Number of llcc banks
+ * @bitmap: Bit map to track the active slice ids
+ * @offsets: Pointer to the bank offsets array
+ */
+struct llcc_drv_data {
+        struct regmap *regmap;
+        const struct llcc_slice_config *cfg;
+        struct mutex lock;
+        u32 cfg_size;
+        u32 max_slices;
+        u32 bcast_off;
+        u32 num_banks;
+        unsigned long *bitmap;
+        u32 *offsets;
+};
+
+#if IS_ENABLED(CONFIG_QCOM_LLCC)
+/**
+ * llcc_slice_getd - get llcc slice descriptor
+ * @uid: usecase_id of the client
+ */
+struct llcc_slice_desc *llcc_slice_getd(u32 uid);
+
+/**
+ * llcc_slice_putd - llcc slice descritpor
+ * @desc: Pointer to llcc slice descriptor
+ */
+void llcc_slice_putd(struct llcc_slice_desc *desc);
+
+/**
+ * llcc_get_slice_id - get slice id
+ * @desc: Pointer to llcc slice descriptor
+ */
+int llcc_get_slice_id(struct llcc_slice_desc *desc);
+
+/**
+ * llcc_get_slice_size - llcc slice size
+ * @desc: Pointer to llcc slice descriptor
+ */
+size_t llcc_get_slice_size(struct llcc_slice_desc *desc);
+
+/**
+ * llcc_slice_activate - Activate the llcc slice
+ * @desc: Pointer to llcc slice descriptor
+ */
+int llcc_slice_activate(struct llcc_slice_desc *desc);
+
+/**
+ * llcc_slice_deactivate - Deactivate the llcc slice
+ * @desc: Pointer to llcc slice descriptor
+ */
+int llcc_slice_deactivate(struct llcc_slice_desc *desc);
+
+/**
+ * qcom_llcc_probe - program the sct table
+ * @pdev: platform device pointer
+ * @table: soc sct table
+ * @sz: Size of the config table
+ */
+int qcom_llcc_probe(struct platform_device *pdev,
+                      const struct llcc_slice_config *table, u32 sz);
+#else
+static inline struct llcc_slice_desc *llcc_slice_getd(u32 uid)
+{
+        return NULL;
+}
+
+static inline void llcc_slice_putd(struct llcc_slice_desc *desc)
+{
+
+};
+
+static inline int llcc_get_slice_id(struct llcc_slice_desc *desc)
+{
+        return -EINVAL;
+}
+
+static inline size_t llcc_get_slice_size(struct llcc_slice_desc *desc)
+{
+        return 0;
+}
+static inline int llcc_slice_activate(struct llcc_slice_desc *desc)
+{
+        return -EINVAL;
+}
+
+static inline int llcc_slice_deactivate(struct llcc_slice_desc *desc)
+{
+        return -EINVAL;
+}
+static inline int qcom_llcc_probe(struct platform_device *pdev,
+                      const struct llcc_slice_config *table, u32 sz)
+{
+        return -ENODEV;
+}
+
+static inline int qcom_llcc_remove(struct platform_device *pdev)
+{
+        return -ENODEV;
+}
+#endif
+
+#endif
diff --git a/include/linux/soc/qcom/mdt_loader.h b/include/linux/soc/qcom/mdt_loader.h
index 5b98bbdabc25..944b06aefb0f 100644
--- a/include/linux/soc/qcom/mdt_loader.h
+++ b/include/linux/soc/qcom/mdt_loader.h
@@ -17,4 +17,8 @@ int qcom_mdt_load(struct device *dev, const struct firmware *fw,
                   phys_addr_t mem_phys, size_t mem_size,
                   phys_addr_t *reloc_base);
 
+int qcom_mdt_load_no_init(struct device *dev, const struct firmware *fw,
+                          const char *fw_name, int pas_id, void *mem_region,
+                          phys_addr_t mem_phys, size_t mem_size,
+                          phys_addr_t *reloc_base);
 #endif
diff --git a/include/linux/soc/renesas/rcar-sysc.h b/include/linux/soc/renesas/rcar-sysc.h
index 8a6086d2e9c3..00fae6fd234d 100644
--- a/include/linux/soc/renesas/rcar-sysc.h
+++ b/include/linux/soc/renesas/rcar-sysc.h
@@ -2,16 +2,7 @@
 #ifndef __LINUX_SOC_RENESAS_RCAR_SYSC_H__
 #define __LINUX_SOC_RENESAS_RCAR_SYSC_H__
 
-#include <linux/types.h>
-
-struct rcar_sysc_ch {
-        u16 chan_offs;
-        u8 chan_bit;
-        u8 isr_bit;
-};
-
-int rcar_sysc_power_down(const struct rcar_sysc_ch *sysc_ch);
-int rcar_sysc_power_up(const struct rcar_sysc_ch *sysc_ch);
-void rcar_sysc_init(phys_addr_t base, u32 syscier);
+int rcar_sysc_power_down_cpu(unsigned int cpu);
+int rcar_sysc_power_up_cpu(unsigned int cpu);
 
 #endif /* __LINUX_SOC_RENESAS_RCAR_SYSC_H__ */
diff --git a/include/linux/soc/samsung/exynos-regs-pmu.h b/include/linux/soc/samsung/exynos-regs-pmu.h
index 66dcb9ec273a..5addaf5ccbce 100644
--- a/include/linux/soc/samsung/exynos-regs-pmu.h
+++ b/include/linux/soc/samsung/exynos-regs-pmu.h
@@ -42,7 +42,9 @@
 #define EXYNOS_SWRESET                          0x0400
 
 #define S5P_WAKEUP_STAT                         0x0600
-#define S5P_EINT_WAKEUP_MASK                    0x0604
+/* Value for EXYNOS_EINT_WAKEUP_MASK disabling all external wakeup interrupts */
+#define EXYNOS_EINT_WAKEUP_MASK_DISABLED        0xffffffff
+#define EXYNOS_EINT_WAKEUP_MASK                 0x0604
 #define S5P_WAKEUP_MASK                         0x0608
 #define S5P_WAKEUP_MASK2                                0x0614
 
@@ -180,6 +182,9 @@
 #define S5P_CORE_WAKEUP_FROM_LOCAL_CFG          (0x3 << 8)
 #define S5P_CORE_AUTOWAKEUP_EN                  (1 << 31)
 
+/* Only for S5Pv210 */
+#define S5PV210_EINT_WAKEUP_MASK        0xC004
+
 /* Only for EXYNOS4210 */
 #define S5P_CMU_CLKSTOP_LCD1_LOWPWR     0x1154
 #define S5P_CMU_RESET_LCD1_LOWPWR       0x1174
@@ -641,6 +646,7 @@
                                          | EXYNOS5420_KFC_USE_STANDBY_WFI3)
 
 /* For EXYNOS5433 */
+#define EXYNOS5433_EINT_WAKEUP_MASK                             (0x060C)
 #define EXYNOS5433_USBHOST30_PHY_CONTROL                        (0x0728)
 #define EXYNOS5433_PAD_RETENTION_AUD_OPTION                     (0x3028)
 #define EXYNOS5433_PAD_RETENTION_MMC2_OPTION                    (0x30C8)
diff --git a/include/linux/spi/adi_spi3.h b/include/linux/spi/adi_spi3.h
deleted file mode 100644
index c84123aa1d06..000000000000
--- a/include/linux/spi/adi_spi3.h
+++ /dev/null
@@ -1,254 +0,0 @@
-/*
- * Analog Devices SPI3 controller driver
- *
- * Copyright (c) 2014 Analog Devices Inc.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- */
-
-#ifndef _ADI_SPI3_H_
-#define _ADI_SPI3_H_
-
-#include <linux/types.h>
-
-/* SPI_CONTROL */
-#define SPI_CTL_EN                  0x00000001    /* Enable */
-#define SPI_CTL_MSTR                0x00000002    /* Master/Slave */
-#define SPI_CTL_PSSE                0x00000004    /* controls modf error in master mode */
-#define SPI_CTL_ODM                 0x00000008    /* Open Drain Mode */
-#define SPI_CTL_CPHA                0x00000010    /* Clock Phase */
-#define SPI_CTL_CPOL                0x00000020    /* Clock Polarity */
-#define SPI_CTL_ASSEL               0x00000040    /* Slave Select Pin Control */
-#define SPI_CTL_SELST               0x00000080    /* Slave Select Polarity in-between transfers */
-#define SPI_CTL_EMISO               0x00000100    /* Enable MISO */
-#define SPI_CTL_SIZE                0x00000600    /* Word Transfer Size */
-#define SPI_CTL_SIZE08              0x00000000    /* SIZE: 8 bits */
-#define SPI_CTL_SIZE16              0x00000200    /* SIZE: 16 bits */
-#define SPI_CTL_SIZE32              0x00000400    /* SIZE: 32 bits */
-#define SPI_CTL_LSBF                0x00001000    /* LSB First */
-#define SPI_CTL_FCEN                0x00002000    /* Flow-Control Enable */
-#define SPI_CTL_FCCH                0x00004000    /* Flow-Control Channel Selection */
-#define SPI_CTL_FCPL                0x00008000    /* Flow-Control Polarity */
-#define SPI_CTL_FCWM                0x00030000    /* Flow-Control Water-Mark */
-#define SPI_CTL_FIFO0               0x00000000    /* FCWM: TFIFO empty or RFIFO Full */
-#define SPI_CTL_FIFO1               0x00010000    /* FCWM: TFIFO 75% or more empty or RFIFO 75% or more full */
-#define SPI_CTL_FIFO2               0x00020000    /* FCWM: TFIFO 50% or more empty or RFIFO 50% or more full */
-#define SPI_CTL_FMODE               0x00040000    /* Fast-mode Enable */
-#define SPI_CTL_MIOM                0x00300000    /* Multiple I/O Mode */
-#define SPI_CTL_MIO_DIS             0x00000000    /* MIOM: Disable */
-#define SPI_CTL_MIO_DUAL            0x00100000    /* MIOM: Enable DIOM (Dual I/O Mode) */
-#define SPI_CTL_MIO_QUAD            0x00200000    /* MIOM: Enable QUAD (Quad SPI Mode) */
-#define SPI_CTL_SOSI                0x00400000    /* Start on MOSI */
-/* SPI_RX_CONTROL */
-#define SPI_RXCTL_REN               0x00000001    /* Receive Channel Enable */
-#define SPI_RXCTL_RTI               0x00000004    /* Receive Transfer Initiate */
-#define SPI_RXCTL_RWCEN             0x00000008    /* Receive Word Counter Enable */
-#define SPI_RXCTL_RDR               0x00000070    /* Receive Data Request */
-#define SPI_RXCTL_RDR_DIS           0x00000000    /* RDR: Disabled */
-#define SPI_RXCTL_RDR_NE            0x00000010    /* RDR: RFIFO not empty */
-#define SPI_RXCTL_RDR_25            0x00000020    /* RDR: RFIFO 25% full */
-#define SPI_RXCTL_RDR_50            0x00000030    /* RDR: RFIFO 50% full */
-#define SPI_RXCTL_RDR_75            0x00000040    /* RDR: RFIFO 75% full */
-#define SPI_RXCTL_RDR_FULL          0x00000050    /* RDR: RFIFO full */
-#define SPI_RXCTL_RDO               0x00000100    /* Receive Data Over-Run */
-#define SPI_RXCTL_RRWM              0x00003000    /* FIFO Regular Water-Mark */
-#define SPI_RXCTL_RWM_0             0x00000000    /* RRWM: RFIFO Empty */
-#define SPI_RXCTL_RWM_25            0x00001000    /* RRWM: RFIFO 25% full */
-#define SPI_RXCTL_RWM_50            0x00002000    /* RRWM: RFIFO 50% full */
-#define SPI_RXCTL_RWM_75            0x00003000    /* RRWM: RFIFO 75% full */
-#define SPI_RXCTL_RUWM              0x00070000    /* FIFO Urgent Water-Mark */
-#define SPI_RXCTL_UWM_DIS           0x00000000    /* RUWM: Disabled */
-#define SPI_RXCTL_UWM_25            0x00010000    /* RUWM: RFIFO 25% full */
-#define SPI_RXCTL_UWM_50            0x00020000    /* RUWM: RFIFO 50% full */
-#define SPI_RXCTL_UWM_75            0x00030000    /* RUWM: RFIFO 75% full */
-#define SPI_RXCTL_UWM_FULL          0x00040000    /* RUWM: RFIFO full */
-/* SPI_TX_CONTROL */
-#define SPI_TXCTL_TEN               0x00000001    /* Transmit Channel Enable */
-#define SPI_TXCTL_TTI               0x00000004    /* Transmit Transfer Initiate */
-#define SPI_TXCTL_TWCEN             0x00000008    /* Transmit Word Counter Enable */
-#define SPI_TXCTL_TDR               0x00000070    /* Transmit Data Request */
-#define SPI_TXCTL_TDR_DIS           0x00000000    /* TDR: Disabled */
-#define SPI_TXCTL_TDR_NF            0x00000010    /* TDR: TFIFO not full */
-#define SPI_TXCTL_TDR_25            0x00000020    /* TDR: TFIFO 25% empty */
-#define SPI_TXCTL_TDR_50            0x00000030    /* TDR: TFIFO 50% empty */
-#define SPI_TXCTL_TDR_75            0x00000040    /* TDR: TFIFO 75% empty */
-#define SPI_TXCTL_TDR_EMPTY         0x00000050    /* TDR: TFIFO empty */
-#define SPI_TXCTL_TDU               0x00000100    /* Transmit Data Under-Run */
-#define SPI_TXCTL_TRWM              0x00003000    /* FIFO Regular Water-Mark */
-#define SPI_TXCTL_RWM_FULL          0x00000000    /* TRWM: TFIFO full */
-#define SPI_TXCTL_RWM_25            0x00001000    /* TRWM: TFIFO 25% empty */
-#define SPI_TXCTL_RWM_50            0x00002000    /* TRWM: TFIFO 50% empty */
-#define SPI_TXCTL_RWM_75            0x00003000    /* TRWM: TFIFO 75% empty */
-#define SPI_TXCTL_TUWM              0x00070000    /* FIFO Urgent Water-Mark */
-#define SPI_TXCTL_UWM_DIS           0x00000000    /* TUWM: Disabled */
-#define SPI_TXCTL_UWM_25            0x00010000    /* TUWM: TFIFO 25% empty */
-#define SPI_TXCTL_UWM_50            0x00020000    /* TUWM: TFIFO 50% empty */
-#define SPI_TXCTL_UWM_75            0x00030000    /* TUWM: TFIFO 75% empty */
-#define SPI_TXCTL_UWM_EMPTY         0x00040000    /* TUWM: TFIFO empty */
-/* SPI_CLOCK */
-#define SPI_CLK_BAUD                0x0000FFFF    /* Baud Rate */
-/* SPI_DELAY */
-#define SPI_DLY_STOP                0x000000FF    /* Transfer delay time in multiples of SCK period */
-#define SPI_DLY_LEADX               0x00000100    /* Extended (1 SCK) LEAD Control */
-#define SPI_DLY_LAGX                0x00000200    /* Extended (1 SCK) LAG control */
-/* SPI_SSEL */
-#define SPI_SLVSEL_SSE1             0x00000002    /* SPISSEL1 Enable */
-#define SPI_SLVSEL_SSE2             0x00000004    /* SPISSEL2 Enable */
-#define SPI_SLVSEL_SSE3             0x00000008    /* SPISSEL3 Enable */
-#define SPI_SLVSEL_SSE4             0x00000010    /* SPISSEL4 Enable */
-#define SPI_SLVSEL_SSE5             0x00000020    /* SPISSEL5 Enable */
-#define SPI_SLVSEL_SSE6             0x00000040    /* SPISSEL6 Enable */
-#define SPI_SLVSEL_SSE7             0x00000080    /* SPISSEL7 Enable */
-#define SPI_SLVSEL_SSEL1            0x00000200    /* SPISSEL1 Value */
-#define SPI_SLVSEL_SSEL2            0x00000400    /* SPISSEL2 Value */
-#define SPI_SLVSEL_SSEL3            0x00000800    /* SPISSEL3 Value */
-#define SPI_SLVSEL_SSEL4            0x00001000    /* SPISSEL4 Value */
-#define SPI_SLVSEL_SSEL5            0x00002000    /* SPISSEL5 Value */
-#define SPI_SLVSEL_SSEL6            0x00004000    /* SPISSEL6 Value */
-#define SPI_SLVSEL_SSEL7            0x00008000    /* SPISSEL7 Value */
-/* SPI_RWC */
-#define SPI_RWC_VALUE               0x0000FFFF    /* Received Word-Count */
-/* SPI_RWCR */
-#define SPI_RWCR_VALUE              0x0000FFFF    /* Received Word-Count Reload */
-/* SPI_TWC */
-#define SPI_TWC_VALUE               0x0000FFFF    /* Transmitted Word-Count */
-/* SPI_TWCR */
-#define SPI_TWCR_VALUE              0x0000FFFF    /* Transmitted Word-Count Reload */
-/* SPI_IMASK */
-#define SPI_IMSK_RUWM               0x00000002    /* Receive Urgent Water-Mark Interrupt Mask */
-#define SPI_IMSK_TUWM               0x00000004    /* Transmit Urgent Water-Mark Interrupt Mask */
-#define SPI_IMSK_ROM                0x00000010    /* Receive Over-Run Error Interrupt Mask */
-#define SPI_IMSK_TUM                0x00000020    /* Transmit Under-Run Error Interrupt Mask */
-#define SPI_IMSK_TCM                0x00000040    /* Transmit Collision Error Interrupt Mask */
-#define SPI_IMSK_MFM                0x00000080    /* Mode Fault Error Interrupt Mask */
-#define SPI_IMSK_RSM                0x00000100    /* Receive Start Interrupt Mask */
-#define SPI_IMSK_TSM                0x00000200    /* Transmit Start Interrupt Mask */
-#define SPI_IMSK_RFM                0x00000400    /* Receive Finish Interrupt Mask */
-#define SPI_IMSK_TFM                0x00000800    /* Transmit Finish Interrupt Mask */
-/* SPI_IMASKCL */
-#define SPI_IMSK_CLR_RUW            0x00000002    /* Receive Urgent Water-Mark Interrupt Mask */
-#define SPI_IMSK_CLR_TUWM           0x00000004    /* Transmit Urgent Water-Mark Interrupt Mask */
-#define SPI_IMSK_CLR_ROM            0x00000010    /* Receive Over-Run Error Interrupt Mask */
-#define SPI_IMSK_CLR_TUM            0x00000020    /* Transmit Under-Run Error Interrupt Mask */
-#define SPI_IMSK_CLR_TCM            0x00000040    /* Transmit Collision Error Interrupt Mask */
-#define SPI_IMSK_CLR_MFM            0x00000080    /* Mode Fault Error Interrupt Mask */
-#define SPI_IMSK_CLR_RSM            0x00000100    /* Receive Start Interrupt Mask */
-#define SPI_IMSK_CLR_TSM            0x00000200    /* Transmit Start Interrupt Mask */
-#define SPI_IMSK_CLR_RFM            0x00000400    /* Receive Finish Interrupt Mask */
-#define SPI_IMSK_CLR_TFM            0x00000800    /* Transmit Finish Interrupt Mask */
-/* SPI_IMASKST */
-#define SPI_IMSK_SET_RUWM           0x00000002    /* Receive Urgent Water-Mark Interrupt Mask */
-#define SPI_IMSK_SET_TUWM           0x00000004    /* Transmit Urgent Water-Mark Interrupt Mask */
-#define SPI_IMSK_SET_ROM            0x00000010    /* Receive Over-Run Error Interrupt Mask */
-#define SPI_IMSK_SET_TUM            0x00000020    /* Transmit Under-Run Error Interrupt Mask */
-#define SPI_IMSK_SET_TCM            0x00000040    /* Transmit Collision Error Interrupt Mask */
-#define SPI_IMSK_SET_MFM            0x00000080    /* Mode Fault Error Interrupt Mask */
-#define SPI_IMSK_SET_RSM            0x00000100    /* Receive Start Interrupt Mask */
-#define SPI_IMSK_SET_TSM            0x00000200    /* Transmit Start Interrupt Mask */
-#define SPI_IMSK_SET_RFM            0x00000400    /* Receive Finish Interrupt Mask */
-#define SPI_IMSK_SET_TFM            0x00000800    /* Transmit Finish Interrupt Mask */
-/* SPI_STATUS */
-#define SPI_STAT_SPIF               0x00000001    /* SPI Finished */
-#define SPI_STAT_RUWM               0x00000002    /* Receive Urgent Water-Mark Breached */
-#define SPI_STAT_TUWM               0x00000004    /* Transmit Urgent Water-Mark Breached */
-#define SPI_STAT_ROE                0x00000010    /* Receive Over-Run Error Indication */
-#define SPI_STAT_TUE                0x00000020    /* Transmit Under-Run Error Indication */
-#define SPI_STAT_TCE                0x00000040    /* Transmit Collision Error Indication */
-#define SPI_STAT_MODF               0x00000080    /* Mode Fault Error Indication */
-#define SPI_STAT_RS                 0x00000100    /* Receive Start Indication */
-#define SPI_STAT_TS                 0x00000200    /* Transmit Start Indication */
-#define SPI_STAT_RF                 0x00000400    /* Receive Finish Indication */
-#define SPI_STAT_TF                 0x00000800    /* Transmit Finish Indication */
-#define SPI_STAT_RFS                0x00007000    /* SPI_RFIFO status */
-#define SPI_STAT_RFIFO_EMPTY        0x00000000    /* RFS: RFIFO Empty */
-#define SPI_STAT_RFIFO_25           0x00001000    /* RFS: RFIFO 25% Full */
-#define SPI_STAT_RFIFO_50           0x00002000    /* RFS: RFIFO 50% Full */
-#define SPI_STAT_RFIFO_75           0x00003000    /* RFS: RFIFO 75% Full */
-#define SPI_STAT_RFIFO_FULL         0x00004000    /* RFS: RFIFO Full */
-#define SPI_STAT_TFS                0x00070000    /* SPI_TFIFO status */
-#define SPI_STAT_TFIFO_FULL         0x00000000    /* TFS: TFIFO full */
-#define SPI_STAT_TFIFO_25           0x00010000    /* TFS: TFIFO 25% empty */
-#define SPI_STAT_TFIFO_50           0x00020000    /* TFS: TFIFO 50% empty */
-#define SPI_STAT_TFIFO_75           0x00030000    /* TFS: TFIFO 75% empty */
-#define SPI_STAT_TFIFO_EMPTY        0x00040000    /* TFS: TFIFO empty */
-#define SPI_STAT_FCS                0x00100000    /* Flow-Control Stall Indication */
-#define SPI_STAT_RFE                0x00400000    /* SPI_RFIFO Empty */
-#define SPI_STAT_TFF                0x00800000    /* SPI_TFIFO Full */
-/* SPI_ILAT */
-#define SPI_ILAT_RUWMI              0x00000002    /* Receive Urgent Water Mark Interrupt */
-#define SPI_ILAT_TUWMI              0x00000004    /* Transmit Urgent Water Mark Interrupt */
-#define SPI_ILAT_ROI                0x00000010    /* Receive Over-Run Error Indication */
-#define SPI_ILAT_TUI                0x00000020    /* Transmit Under-Run Error Indication */
-#define SPI_ILAT_TCI                0x00000040    /* Transmit Collision Error Indication */
-#define SPI_ILAT_MFI                0x00000080    /* Mode Fault Error Indication */
-#define SPI_ILAT_RSI                0x00000100    /* Receive Start Indication */
-#define SPI_ILAT_TSI                0x00000200    /* Transmit Start Indication */
-#define SPI_ILAT_RFI                0x00000400    /* Receive Finish Indication */
-#define SPI_ILAT_TFI                0x00000800    /* Transmit Finish Indication */
-/* SPI_ILATCL */
-#define SPI_ILAT_CLR_RUWMI          0x00000002    /* Receive Urgent Water Mark Interrupt */
-#define SPI_ILAT_CLR_TUWMI          0x00000004    /* Transmit Urgent Water Mark Interrupt */
-#define SPI_ILAT_CLR_ROI            0x00000010    /* Receive Over-Run Error Indication */
-#define SPI_ILAT_CLR_TUI            0x00000020    /* Transmit Under-Run Error Indication */
-#define SPI_ILAT_CLR_TCI            0x00000040    /* Transmit Collision Error Indication */
-#define SPI_ILAT_CLR_MFI            0x00000080    /* Mode Fault Error Indication */
-#define SPI_ILAT_CLR_RSI            0x00000100    /* Receive Start Indication */
-#define SPI_ILAT_CLR_TSI            0x00000200    /* Transmit Start Indication */
-#define SPI_ILAT_CLR_RFI            0x00000400    /* Receive Finish Indication */
-#define SPI_ILAT_CLR_TFI            0x00000800    /* Transmit Finish Indication */
-
-/*
- * adi spi3 registers layout
- */
-struct adi_spi_regs {
-        u32 revid;
-        u32 control;
-        u32 rx_control;
-        u32 tx_control;
-        u32 clock;
-        u32 delay;
-        u32 ssel;
-        u32 rwc;
-        u32 rwcr;
-        u32 twc;
-        u32 twcr;
-        u32 reserved0;
-        u32 emask;
-        u32 emaskcl;
-        u32 emaskst;
-        u32 reserved1;
-        u32 status;
-        u32 elat;
-        u32 elatcl;
-        u32 reserved2;
-        u32 rfifo;
-        u32 reserved3;
-        u32 tfifo;
-};
-
-#define MAX_CTRL_CS          8  /* cs in spi controller */
-
-/* device.platform_data for SSP controller devices */
-struct adi_spi3_master {
-        u16 num_chipselect;
-        u16 pin_req[7];
-};
-
-/* spi_board_info.controller_data for SPI slave devices,
- * copied to spi_device.platform_data ... mostly for dma tuning
- */
-struct adi_spi3_chip {
-        u32 control;
-        u16 cs_chg_udelay; /* Some devices require 16-bit delays */
-        u32 tx_dummy_val; /* tx value for rx only transfer */
-        bool enable_dma;
-};
-
-#endif /* _ADI_SPI3_H_ */
diff --git a/include/linux/spi/spi-mem.h b/include/linux/spi/spi-mem.h
index bb4bd15ae1f6..b2bd4b4127c4 100644
--- a/include/linux/spi/spi-mem.h
+++ b/include/linux/spi/spi-mem.h
@@ -3,7 +3,9 @@
  * Copyright (C) 2018 Exceet Electronics GmbH
  * Copyright (C) 2018 Bootlin
  *
- * Author: Boris Brezillon <boris.brezillon@bootlin.com>
+ * Author:
+ *      Peter Pan <peterpandong@micron.com>
+ *      Boris Brezillon <boris.brezillon@bootlin.com>
  */
 
 #ifndef __LINUX_SPI_MEM_H
@@ -122,7 +124,8 @@ struct spi_mem_op {
 /**
  * struct spi_mem - describes a SPI memory device
  * @spi: the underlying SPI device
- * @drvpriv: spi_mem_drviver private data
+ * @drvpriv: spi_mem_driver private data
+ * @name: name of the SPI memory device
  *
  * Extra information that describe the SPI memory device and may be needed by
  * the controller to properly handle this device should be placed here.
@@ -133,6 +136,7 @@ struct spi_mem_op {
 struct spi_mem {
         struct spi_device *spi;
         void *drvpriv;
+        const char *name;
 };
 
 /**
@@ -165,6 +169,13 @@ static inline void *spi_mem_get_drvdata(struct spi_mem *mem)
  *                  limitations)
  * @supports_op: check if an operation is supported by the controller
  * @exec_op: execute a SPI memory operation
+ * @get_name: get a custom name for the SPI mem device from the controller.
+ *            This might be needed if the controller driver has been ported
+ *            to use the SPI mem layer and a custom name is used to keep
+ *            mtdparts compatible.
+ *            Note that if the implementation of this function allocates memory
+ *            dynamically, then it should do so with devm_xxx(), as we don't
+ *            have a ->free_name() function.
  *
  * This interface should be implemented by SPI controllers providing an
  * high-level interface to execute SPI memory operation, which is usually the
@@ -176,6 +187,7 @@ struct spi_controller_mem_ops {
                             const struct spi_mem_op *op);
         int (*exec_op)(struct spi_mem *mem,
                        const struct spi_mem_op *op);
+        const char *(*get_name)(struct spi_mem *mem);
 };
 
 /**
@@ -234,6 +246,8 @@ bool spi_mem_supports_op(struct spi_mem *mem,
 int spi_mem_exec_op(struct spi_mem *mem,
                     const struct spi_mem_op *op);
 
+const char *spi_mem_get_name(struct spi_mem *mem);
+
 int spi_mem_driver_register_with_owner(struct spi_mem_driver *drv,
                                        struct module *owner);
 
diff --git a/include/linux/spi/spi_bitbang.h b/include/linux/spi/spi_bitbang.h
index 51d8c060e513..b7e021b274dc 100644
--- a/include/linux/spi/spi_bitbang.h
+++ b/include/linux/spi/spi_bitbang.h
@@ -8,7 +8,7 @@ struct spi_bitbang {
         struct mutex            lock;
         u8                      busy;
         u8                      use_dma;
-        u8                      flags;          /* extra spi->mode support */
+        u16                     flags;          /* extra spi->mode support */
 
         struct spi_master       *master;
 
@@ -30,7 +30,8 @@ struct spi_bitbang {
         /* txrx_word[SPI_MODE_*]() just looks like a shift register */
         u32     (*txrx_word[4])(struct spi_device *spi,
                         unsigned nsecs,
-                        u32 word, u8 bits);
+                        u32 word, u8 bits, unsigned flags);
+        int     (*set_line_direction)(struct spi_device *spi, bool output);
 };
 
 /* you can call these default bitbang->master methods from your custom
diff --git a/include/linux/spinlock.h b/include/linux/spinlock.h
index 3190997df9ca..e089157dcf97 100644
--- a/include/linux/spinlock.h
+++ b/include/linux/spinlock.h
@@ -451,9 +451,20 @@ extern int _atomic_dec_and_lock_irqsave(atomic_t *atomic, spinlock_t *lock,
 #define atomic_dec_and_lock_irqsave(atomic, lock, flags) \
                 __cond_lock(lock, _atomic_dec_and_lock_irqsave(atomic, lock, &(flags)))
 
-int alloc_bucket_spinlocks(spinlock_t **locks, unsigned int *lock_mask,
-                           size_t max_size, unsigned int cpu_mult,
-                           gfp_t gfp);
+int __alloc_bucket_spinlocks(spinlock_t **locks, unsigned int *lock_mask,
+                             size_t max_size, unsigned int cpu_mult,
+                             gfp_t gfp, const char *name,
+                             struct lock_class_key *key);
+
+#define alloc_bucket_spinlocks(locks, lock_mask, max_size, cpu_mult, gfp)    \
+        ({                                                                   \
+                static struct lock_class_key key;                            \
+                int ret;                                                     \
+                                                                             \
+                ret = __alloc_bucket_spinlocks(locks, lock_mask, max_size,   \
+                                               cpu_mult, gfp, #locks, &key); \
+                ret;                                                         \
+        })
 
 void free_bucket_spinlocks(spinlock_t *locks);
 
diff --git a/include/linux/srcu.h b/include/linux/srcu.h
index 3e72a291c401..67135d4a8a30 100644
--- a/include/linux/srcu.h
+++ b/include/linux/srcu.h
@@ -170,6 +170,11 @@ static inline int srcu_read_lock_held(const struct srcu_struct *sp)
 #define srcu_dereference(p, sp) srcu_dereference_check((p), (sp), 0)
 
 /**
+ * srcu_dereference_notrace - no tracing and no lockdep calls from here
+ */
+#define srcu_dereference_notrace(p, sp) srcu_dereference_check((p), (sp), 1)
+
+/**
  * srcu_read_lock - register a new reader for an SRCU-protected structure.
  * @sp: srcu_struct in which to register the new reader.
  *
diff --git a/include/linux/ssb/ssb.h b/include/linux/ssb/ssb.h
index 3b43655cabe6..0d5a2691e7e9 100644
--- a/include/linux/ssb/ssb.h
+++ b/include/linux/ssb/ssb.h
@@ -499,11 +499,9 @@ struct ssb_bus {
 
         /* Internal-only stuff follows. Do not touch. */
         struct list_head list;
-#ifdef CONFIG_SSB_DEBUG
         /* Is the bus already powered up? */
         bool powered_up;
         int power_warn_count;
-#endif /* DEBUG */
 };
 
 enum ssb_quirks {
diff --git a/include/linux/stmmac.h b/include/linux/stmmac.h
index 32feac5bbd75..c43e9a01b892 100644
--- a/include/linux/stmmac.h
+++ b/include/linux/stmmac.h
@@ -190,5 +190,6 @@ struct plat_stmmacenet_data {
         bool tso_en;
         int mac_port_sel_speed;
         bool en_tx_lpi_clockgating;
+        int has_xgmac;
 };
 #endif
diff --git a/include/linux/sunrpc/auth.h b/include/linux/sunrpc/auth.h
index d9af474a857d..58a6765c1c5e 100644
--- a/include/linux/sunrpc/auth.h
+++ b/include/linux/sunrpc/auth.h
@@ -125,7 +125,8 @@ struct rpc_authops {
         struct module           *owner;
         rpc_authflavor_t        au_flavor;      /* flavor (RPC_AUTH_*) */
         char *                  au_name;
-        struct rpc_auth *       (*create)(struct rpc_auth_create_args *, struct rpc_clnt *);
+        struct rpc_auth *       (*create)(const struct rpc_auth_create_args *,
+                                          struct rpc_clnt *);
         void                    (*destroy)(struct rpc_auth *);
 
         int                     (*hash_cred)(struct auth_cred *, unsigned int);
@@ -174,7 +175,7 @@ struct rpc_cred *	rpc_lookup_generic_cred(struct auth_cred *, int, gfp_t);
 struct rpc_cred *       rpc_lookup_machine_cred(const char *service_name);
 int                     rpcauth_register(const struct rpc_authops *);
 int                     rpcauth_unregister(const struct rpc_authops *);
-struct rpc_auth *       rpcauth_create(struct rpc_auth_create_args *,
+struct rpc_auth *       rpcauth_create(const struct rpc_auth_create_args *,
                                 struct rpc_clnt *);
 void                    rpcauth_release(struct rpc_auth *);
 rpc_authflavor_t        rpcauth_get_pseudoflavor(rpc_authflavor_t,
diff --git a/include/linux/sunrpc/clnt.h b/include/linux/sunrpc/clnt.h
index 9b11b6a0978c..73d5c4a870fa 100644
--- a/include/linux/sunrpc/clnt.h
+++ b/include/linux/sunrpc/clnt.h
@@ -156,6 +156,7 @@ int		rpc_switch_client_transport(struct rpc_clnt *,
 
 void            rpc_shutdown_client(struct rpc_clnt *);
 void            rpc_release_client(struct rpc_clnt *);
+void            rpc_task_release_transport(struct rpc_task *);
 void            rpc_task_release_client(struct rpc_task *);
 
 int             rpcb_create_local(struct net *);
diff --git a/include/linux/sunrpc/metrics.h b/include/linux/sunrpc/metrics.h
index 9baed7b355b2..1b3751327575 100644
--- a/include/linux/sunrpc/metrics.h
+++ b/include/linux/sunrpc/metrics.h
@@ -82,7 +82,7 @@ void			rpc_count_iostats(const struct rpc_task *,
                                           struct rpc_iostats *);
 void                    rpc_count_iostats_metrics(const struct rpc_task *,
                                           struct rpc_iostats *);
-void                    rpc_print_iostats(struct seq_file *, struct rpc_clnt *);
+void                    rpc_clnt_show_stats(struct seq_file *, struct rpc_clnt *);
 void                    rpc_free_iostats(struct rpc_iostats *);
 
 #else  /*  CONFIG_PROC_FS  */
@@ -95,7 +95,7 @@ static inline void rpc_count_iostats_metrics(const struct rpc_task *task,
 {
 }
 
-static inline void rpc_print_iostats(struct seq_file *seq, struct rpc_clnt *clnt) {}
+static inline void rpc_clnt_show_stats(struct seq_file *seq, struct rpc_clnt *clnt) {}
 static inline void rpc_free_iostats(struct rpc_iostats *stats) {}
 
 #endif  /*  CONFIG_PROC_FS  */
diff --git a/include/linux/sunrpc/svc.h b/include/linux/sunrpc/svc.h
index 574368e8a16f..73e130a840ce 100644
--- a/include/linux/sunrpc/svc.h
+++ b/include/linux/sunrpc/svc.h
@@ -496,9 +496,11 @@ void		   svc_reserve(struct svc_rqst *rqstp, int space);
 struct svc_pool *  svc_pool_for_cpu(struct svc_serv *serv, int cpu);
 char *             svc_print_addr(struct svc_rqst *, char *, size_t);
 unsigned int       svc_fill_write_vector(struct svc_rqst *rqstp,
+                                         struct page **pages,
                                          struct kvec *first, size_t total);
 char              *svc_fill_symlink_pathname(struct svc_rqst *rqstp,
-                                             struct kvec *first, size_t total);
+                                             struct kvec *first, void *p,
+                                             size_t total);
 
 #define RPC_MAX_ADDRBUFLEN      (63U)
 
diff --git a/include/linux/sunrpc/svcauth.h b/include/linux/sunrpc/svcauth.h
index 7c3656505847..04e404a07882 100644
--- a/include/linux/sunrpc/svcauth.h
+++ b/include/linux/sunrpc/svcauth.h
@@ -31,6 +31,7 @@ struct svc_cred {
         /* name of form servicetype@hostname, passed down by
          * rpc.svcgssd, or computed from the above: */
         char                    *cr_principal;
+        char                    *cr_targ_princ;
         struct gss_api_mech     *cr_gss_mech;
 };
 
@@ -39,6 +40,7 @@ static inline void init_svc_cred(struct svc_cred *cred)
         cred->cr_group_info = NULL;
         cred->cr_raw_principal = NULL;
         cred->cr_principal = NULL;
+        cred->cr_targ_princ = NULL;
         cred->cr_gss_mech = NULL;
 }
 
@@ -48,6 +50,7 @@ static inline void free_svc_cred(struct svc_cred *cred)
                 put_group_info(cred->cr_group_info);
         kfree(cred->cr_raw_principal);
         kfree(cred->cr_principal);
+        kfree(cred->cr_targ_princ);
         gss_mech_put(cred->cr_gss_mech);
         init_svc_cred(cred);
 }
diff --git a/include/linux/suspend.h b/include/linux/suspend.h
index 440b62f7502e..5a28ac9284f0 100644
--- a/include/linux/suspend.h
+++ b/include/linux/suspend.h
@@ -414,7 +414,7 @@ static inline bool hibernation_available(void) { return false; }
 #define PM_RESTORE_PREPARE      0x0005 /* Going to restore a saved image */
 #define PM_POST_RESTORE         0x0006 /* Restore failed */
 
-extern struct mutex pm_mutex;
+extern struct mutex system_transition_mutex;
 
 #ifdef CONFIG_PM_SLEEP
 void save_processor_state(void);
diff --git a/include/linux/swap.h b/include/linux/swap.h
index c063443d8638..8e2c11e692ba 100644
--- a/include/linux/swap.h
+++ b/include/linux/swap.h
@@ -447,7 +447,7 @@ extern void si_swapinfo(struct sysinfo *);
 extern swp_entry_t get_swap_page(struct page *page);
 extern void put_swap_page(struct page *page, swp_entry_t entry);
 extern swp_entry_t get_swap_page_of_type(int);
-extern int get_swap_pages(int n, bool cluster, swp_entry_t swp_entries[]);
+extern int get_swap_pages(int n, swp_entry_t swp_entries[], int entry_size);
 extern int add_swap_count_continuation(swp_entry_t, gfp_t);
 extern void swap_shmem_alloc(swp_entry_t);
 extern int swap_duplicate(swp_entry_t);
@@ -629,7 +629,6 @@ static inline int mem_cgroup_swappiness(struct mem_cgroup *memcg)
 
         return memcg->swappiness;
 }
-
 #else
 static inline int mem_cgroup_swappiness(struct mem_cgroup *mem)
 {
@@ -637,6 +636,16 @@ static inline int mem_cgroup_swappiness(struct mem_cgroup *mem)
 }
 #endif
 
+#if defined(CONFIG_SWAP) && defined(CONFIG_MEMCG) && defined(CONFIG_BLK_CGROUP)
+extern void mem_cgroup_throttle_swaprate(struct mem_cgroup *memcg, int node,
+                                         gfp_t gfp_mask);
+#else
+static inline void mem_cgroup_throttle_swaprate(struct mem_cgroup *memcg,
+                                                int node, gfp_t gfp_mask)
+{
+}
+#endif
+
 #ifdef CONFIG_MEMCG_SWAP
 extern void mem_cgroup_swapout(struct page *page, swp_entry_t entry);
 extern int mem_cgroup_try_charge_swap(struct page *page, swp_entry_t entry);
diff --git a/include/linux/swapfile.h b/include/linux/swapfile.h
index 06bd7b096167..e06febf62978 100644
--- a/include/linux/swapfile.h
+++ b/include/linux/swapfile.h
@@ -10,5 +10,7 @@ extern spinlock_t swap_lock;
 extern struct plist_head swap_active_head;
 extern struct swap_info_struct *swap_info[];
 extern int try_to_unuse(unsigned int, bool, unsigned long);
+extern unsigned long generic_max_swapfile_size(void);
+extern unsigned long max_swapfile_size(void);
 
 #endif /* _LINUX_SWAPFILE_H */
diff --git a/include/linux/swapops.h b/include/linux/swapops.h
index 1d3877c39a00..22af9d8a84ae 100644
--- a/include/linux/swapops.h
+++ b/include/linux/swapops.h
@@ -4,6 +4,7 @@
 
 #include <linux/radix-tree.h>
 #include <linux/bug.h>
+#include <linux/mm_types.h>
 
 /*
  * swapcache pages are stored in the swapper_space radix tree.  We want to
@@ -134,7 +135,7 @@ static inline struct page *device_private_entry_to_page(swp_entry_t entry)
         return pfn_to_page(swp_offset(entry));
 }
 
-int device_private_entry_fault(struct vm_area_struct *vma,
+vm_fault_t device_private_entry_fault(struct vm_area_struct *vma,
                        unsigned long addr,
                        swp_entry_t entry,
                        unsigned int flags,
@@ -169,7 +170,7 @@ static inline struct page *device_private_entry_to_page(swp_entry_t entry)
         return NULL;
 }
 
-static inline int device_private_entry_fault(struct vm_area_struct *vma,
+static inline vm_fault_t device_private_entry_fault(struct vm_area_struct *vma,
                                      unsigned long addr,
                                      swp_entry_t entry,
                                      unsigned int flags,
@@ -340,11 +341,6 @@ static inline int is_hwpoison_entry(swp_entry_t entry)
         return swp_type(entry) == SWP_HWPOISON;
 }
 
-static inline bool test_set_page_hwpoison(struct page *page)
-{
-        return TestSetPageHWPoison(page);
-}
-
 static inline void num_poisoned_pages_inc(void)
 {
         atomic_long_inc(&num_poisoned_pages);
@@ -367,11 +363,6 @@ static inline int is_hwpoison_entry(swp_entry_t swp)
         return 0;
 }
 
-static inline bool test_set_page_hwpoison(struct page *page)
-{
-        return false;
-}
-
 static inline void num_poisoned_pages_inc(void)
 {
 }
diff --git a/include/linux/switchtec.h b/include/linux/switchtec.h
index ec93e93371fa..ab400af6f0ce 100644
--- a/include/linux/switchtec.h
+++ b/include/linux/switchtec.h
@@ -19,10 +19,6 @@
 #include <linux/pci.h>
 #include <linux/cdev.h>
 
-#define MICROSEMI_VENDOR_ID         0x11f8
-#define MICROSEMI_NTB_CLASSCODE     0x068000
-#define MICROSEMI_MGMT_CLASSCODE    0x058000
-
 #define SWITCHTEC_MRPC_PAYLOAD_SIZE 1024
 #define SWITCHTEC_MAX_PFF_CSR 48
 
diff --git a/include/linux/syscalls.h b/include/linux/syscalls.h
index ebb2f24027e8..2ff814c92f7f 100644
--- a/include/linux/syscalls.h
+++ b/include/linux/syscalls.h
@@ -81,6 +81,7 @@ union bpf_attr;
 #include <linux/unistd.h>
 #include <linux/quota.h>
 #include <linux/key.h>
+#include <linux/personality.h>
 #include <trace/syscall.h>
 
 #ifdef CONFIG_ARCH_HAS_SYSCALL_WRAPPER
@@ -1282,4 +1283,14 @@ static inline long ksys_truncate(const char __user *pathname, loff_t length)
         return do_sys_truncate(pathname, length);
 }
 
+static inline unsigned int ksys_personality(unsigned int personality)
+{
+        unsigned int old = current->personality;
+
+        if (personality != 0xffffffff)
+                set_personality(personality);
+
+        return old;
+}
+
 #endif
diff --git a/include/linux/sysfs.h b/include/linux/sysfs.h
index b8bfdc173ec0..987cefa337de 100644
--- a/include/linux/sysfs.h
+++ b/include/linux/sysfs.h
@@ -91,9 +91,9 @@ struct attribute_group {
         struct bin_attribute    **bin_attrs;
 };
 
-/**
- * Use these macros to make defining attributes easier. See include/linux/device.h
- * for examples..
+/*
+ * Use these macros to make defining attributes easier.
+ * See include/linux/device.h for examples..
  */
 
 #define SYSFS_PREALLOC 010000
@@ -237,6 +237,9 @@ int __must_check sysfs_create_files(struct kobject *kobj,
                                    const struct attribute **attr);
 int __must_check sysfs_chmod_file(struct kobject *kobj,
                                   const struct attribute *attr, umode_t mode);
+struct kernfs_node *sysfs_break_active_protection(struct kobject *kobj,
+                                                  const struct attribute *attr);
+void sysfs_unbreak_active_protection(struct kernfs_node *kn);
 void sysfs_remove_file_ns(struct kobject *kobj, const struct attribute *attr,
                           const void *ns);
 bool sysfs_remove_file_self(struct kobject *kobj, const struct attribute *attr);
@@ -350,6 +353,17 @@ static inline int sysfs_chmod_file(struct kobject *kobj,
         return 0;
 }
 
+static inline struct kernfs_node *
+sysfs_break_active_protection(struct kobject *kobj,
+                              const struct attribute *attr)
+{
+        return NULL;
+}
+
+static inline void sysfs_unbreak_active_protection(struct kernfs_node *kn)
+{
+}
+
 static inline void sysfs_remove_file_ns(struct kobject *kobj,
                                         const struct attribute *attr,
                                         const void *ns)
diff --git a/include/linux/t10-pi.h b/include/linux/t10-pi.h
index c6aa8a3c42ed..b9626aa7e90c 100644
--- a/include/linux/t10-pi.h
+++ b/include/linux/t10-pi.h
@@ -37,9 +37,33 @@ struct t10_pi_tuple {
 #define T10_PI_APP_ESCAPE cpu_to_be16(0xffff)
 #define T10_PI_REF_ESCAPE cpu_to_be32(0xffffffff)
 
+static inline u32 t10_pi_ref_tag(struct request *rq)
+{
+#ifdef CONFIG_BLK_DEV_INTEGRITY
+        return blk_rq_pos(rq) >>
+                (rq->q->integrity.interval_exp - 9) & 0xffffffff;
+#else
+        return -1U;
+#endif
+}
+
 extern const struct blk_integrity_profile t10_pi_type1_crc;
 extern const struct blk_integrity_profile t10_pi_type1_ip;
 extern const struct blk_integrity_profile t10_pi_type3_crc;
 extern const struct blk_integrity_profile t10_pi_type3_ip;
 
+#ifdef CONFIG_BLK_DEV_INTEGRITY
+extern void t10_pi_prepare(struct request *rq, u8 protection_type);
+extern void t10_pi_complete(struct request *rq, u8 protection_type,
+                            unsigned int intervals);
+#else
+static inline void t10_pi_complete(struct request *rq, u8 protection_type,
+                                   unsigned int intervals)
+{
+}
+static inline void t10_pi_prepare(struct request *rq, u8 protection_type)
+{
+}
+#endif
+
 #endif
diff --git a/include/linux/tcp.h b/include/linux/tcp.h
index 72705eaf4b84..263e37271afd 100644
--- a/include/linux/tcp.h
+++ b/include/linux/tcp.h
@@ -89,7 +89,7 @@ struct tcp_sack_block {
 
 struct tcp_options_received {
 /*      PAWS/RTTM data  */
-        long    ts_recent_stamp;/* Time we stored ts_recent (for aging) */
+        int     ts_recent_stamp;/* Time we stored ts_recent (for aging) */
         u32     ts_recent;      /* Time stamp to echo next              */
         u32     rcv_tsval;      /* Time stamp value                     */
         u32     rcv_tsecr;      /* Time stamp echo reply                */
@@ -181,10 +181,16 @@ struct tcp_sock {
         u32     data_segs_out;  /* RFC4898 tcpEStatsPerfDataSegsOut
                                  * total number of data segments sent.
                                  */
+        u64     bytes_sent;     /* RFC4898 tcpEStatsPerfHCDataOctetsOut
+                                 * total number of data bytes sent.
+                                 */
         u64     bytes_acked;    /* RFC4898 tcpEStatsAppHCThruOctetsAcked
                                  * sum(delta(snd_una)), or how many bytes
                                  * were acked.
                                  */
+        u32     dsack_dups;     /* RFC4898 tcpEStatsStackDSACKDups
+                                 * total number of DSACK blocks received
+                                 */
         u32     snd_una;        /* First byte we want an ack for        */
         u32     snd_sml;        /* Last byte of the most recently transmitted small packet */
         u32     rcv_tstamp;     /* timestamp of last received ACK (for keepalives) */
@@ -214,8 +220,7 @@ struct tcp_sock {
 #define TCP_RACK_RECOVERY_THRESH 16
                 u8 reo_wnd_persist:5, /* No. of recovery since last adj */
                    dsack_seen:1, /* Whether DSACK seen after last adj */
-                   advanced:1,   /* mstamp advanced since last lost marking */
-                   reord:1;      /* reordering detected */
+                   advanced:1;   /* mstamp advanced since last lost marking */
         } rack;
         u16     advmss;         /* Advertised MSS                       */
         u8      compressed_ack;
@@ -261,6 +266,7 @@ struct tcp_sock {
         u8      ecn_flags;      /* ECN status bits.                     */
         u8      keepalive_probes; /* num of allowed keep alive probes   */
         u32     reordering;     /* Packet reordering metric.            */
+        u32     reord_seen;     /* number of data packet reordering events */
         u32     snd_up;         /* Urgent pointer               */
 
 /*
@@ -330,6 +336,9 @@ struct tcp_sock {
                                  * the first SYN. */
         u32     undo_marker;    /* snd_una upon a new recovery episode. */
         int     undo_retrans;   /* number of undoable retransmissions. */
+        u64     bytes_retrans;  /* RFC4898 tcpEStatsPerfOctetsRetrans
+                                 * Total data bytes retransmitted
+                                 */
         u32     total_retrans;  /* Total retransmits for entire connection */
 
         u32     urg_seq;        /* Seq of received urgent pointer */
@@ -350,6 +359,7 @@ struct tcp_sock {
 #endif
 
 /* Receiver side RTT estimation */
+        u32 rcv_rtt_last_tsecr;
         struct {
                 u32     rtt_us;
                 u32     seq;
@@ -425,7 +435,7 @@ struct tcp_timewait_sock {
         /* The time we sent the last out-of-window ACK: */
         u32                       tw_last_oow_ack_time;
 
-        long                      tw_ts_recent_stamp;
+        int                       tw_ts_recent_stamp;
 #ifdef CONFIG_TCP_MD5SIG
         struct tcp_md5sig_key     *tw_md5_key;
 #endif
diff --git a/include/linux/time32.h b/include/linux/time32.h
index 0b14f936100a..d1ae43c13e25 100644
--- a/include/linux/time32.h
+++ b/include/linux/time32.h
@@ -207,4 +207,19 @@ static inline s64 timeval_to_ns(const struct timeval *tv)
 extern struct timeval ns_to_timeval(const s64 nsec);
 extern struct __kernel_old_timeval ns_to_kernel_old_timeval(s64 nsec);
 
+/*
+ * New aliases for compat time functions. These will be used to replace
+ * the compat code so it can be shared between 32-bit and 64-bit builds
+ * both of which provide compatibility with old 32-bit tasks.
+ */
+#define old_time32_t            compat_time_t
+#define old_timeval32           compat_timeval
+#define old_timespec32          compat_timespec
+#define old_itimerspec32        compat_itimerspec
+#define ns_to_old_timeval32     ns_to_compat_timeval
+#define get_old_itimerspec32    get_compat_itimerspec64
+#define put_old_itimerspec32    put_compat_itimerspec64
+#define get_old_timespec32      compat_get_timespec64
+#define put_old_timespec32      compat_put_timespec64
+
 #endif
diff --git a/include/linux/timekeeping.h b/include/linux/timekeeping.h
index e79861418fd7..a5a3cfc3c2fa 100644
--- a/include/linux/timekeeping.h
+++ b/include/linux/timekeeping.h
@@ -21,6 +21,21 @@ extern int do_sys_settimeofday64(const struct timespec64 *tv,
                                  const struct timezone *tz);
 
 /*
+ * ktime_get() family: read the current time in a multitude of ways,
+ *
+ * The default time reference is CLOCK_MONOTONIC, starting at
+ * boot time but not counting the time spent in suspend.
+ * For other references, use the functions with "real", "clocktai",
+ * "boottime" and "raw" suffixes.
+ *
+ * To get the time in a different format, use the ones wit
+ * "ns", "ts64" and "seconds" suffix.
+ *
+ * See Documentation/core-api/timekeeping.rst for more details.
+ */
+
+
+/*
  * timespec64 based interfaces
  */
 extern void ktime_get_raw_ts64(struct timespec64 *ts);
@@ -243,8 +258,8 @@ extern void ktime_get_snapshot(struct system_time_snapshot *systime_snapshot);
 extern int persistent_clock_is_local;
 
 extern void read_persistent_clock64(struct timespec64 *ts);
-void read_persistent_clock_and_boot_offset(struct timespec64 *wall_clock,
-                                           struct timespec64 *boot_offset);
+void read_persistent_wall_and_boot_offset(struct timespec64 *wall_clock,
+                                          struct timespec64 *boot_offset);
 extern int update_persistent_clock64(struct timespec64 now);
 
 /*
diff --git a/include/linux/tpm.h b/include/linux/tpm.h
index 06639fb6ab85..4609b94142d4 100644
--- a/include/linux/tpm.h
+++ b/include/linux/tpm.h
@@ -43,6 +43,8 @@ struct tpm_class_ops {
         u8 (*status) (struct tpm_chip *chip);
         bool (*update_timeouts)(struct tpm_chip *chip,
                                 unsigned long *timeout_cap);
+        int (*go_idle)(struct tpm_chip *chip);
+        int (*cmd_ready)(struct tpm_chip *chip);
         int (*request_locality)(struct tpm_chip *chip, int loc);
         int (*relinquish_locality)(struct tpm_chip *chip, int loc);
         void (*clk_enable)(struct tpm_chip *chip, bool value);
@@ -61,6 +63,7 @@ extern int tpm_seal_trusted(struct tpm_chip *chip,
 extern int tpm_unseal_trusted(struct tpm_chip *chip,
                               struct trusted_key_payload *payload,
                               struct trusted_key_options *options);
+extern struct tpm_chip *tpm_default_chip(void);
 #else
 static inline int tpm_is_tpm2(struct tpm_chip *chip)
 {
@@ -96,5 +99,9 @@ static inline int tpm_unseal_trusted(struct tpm_chip *chip,
 {
         return -ENODEV;
 }
+static inline struct tpm_chip *tpm_default_chip(void)
+{
+        return NULL;
+}
 #endif
 #endif
diff --git a/include/linux/tracehook.h b/include/linux/tracehook.h
index 4a8841963c2e..05589a3e37f4 100644
--- a/include/linux/tracehook.h
+++ b/include/linux/tracehook.h
@@ -51,6 +51,7 @@
 #include <linux/security.h>
 #include <linux/task_work.h>
 #include <linux/memcontrol.h>
+#include <linux/blk-cgroup.h>
 struct linux_binprm;
 
 /*
@@ -192,6 +193,7 @@ static inline void tracehook_notify_resume(struct pt_regs *regs)
                 task_work_run();
 
         mem_cgroup_handle_over_high();
+        blkcg_maybe_throttle_current();
 }
 
 #endif  /* <linux/tracehook.h> */
diff --git a/include/linux/tracepoint.h b/include/linux/tracepoint.h
index 19a690b559ca..041f7e56a289 100644
--- a/include/linux/tracepoint.h
+++ b/include/linux/tracepoint.h
@@ -15,6 +15,7 @@
  */
 
 #include <linux/smp.h>
+#include <linux/srcu.h>
 #include <linux/errno.h>
 #include <linux/types.h>
 #include <linux/cpumask.h>
@@ -33,6 +34,8 @@ struct trace_eval_map {
 
 #define TRACEPOINT_DEFAULT_PRIO 10
 
+extern struct srcu_struct tracepoint_srcu;
+
 extern int
 tracepoint_probe_register(struct tracepoint *tp, void *probe, void *data);
 extern int
@@ -75,10 +78,16 @@ int unregister_tracepoint_module_notifier(struct notifier_block *nb)
  * probe unregistration and the end of module exit to make sure there is no
  * caller executing a probe when it is freed.
  */
+#ifdef CONFIG_TRACEPOINTS
 static inline void tracepoint_synchronize_unregister(void)
 {
+        synchronize_srcu(&tracepoint_srcu);
         synchronize_sched();
 }
+#else
+static inline void tracepoint_synchronize_unregister(void)
+{ }
+#endif
 
 #ifdef CONFIG_HAVE_SYSCALL_TRACEPOINTS
 extern int syscall_regfunc(void);
@@ -129,18 +138,33 @@ extern void syscall_unregfunc(void);
  * as "(void *, void)". The DECLARE_TRACE_NOARGS() will pass in just
  * "void *data", where as the DECLARE_TRACE() will pass in "void *data, proto".
  */
-#define __DO_TRACE(tp, proto, args, cond, rcucheck)                     \
+#define __DO_TRACE(tp, proto, args, cond, rcuidle)                      \
         do {                                                            \
                 struct tracepoint_func *it_func_ptr;                    \
                 void *it_func;                                          \
                 void *__data;                                           \
+                int __maybe_unused idx = 0;                             \
                                                                         \
                 if (!(cond))                                            \
                         return;                                         \
-                if (rcucheck)                                           \
+                                                                        \
+                /* srcu can't be used from NMI */                       \
+                WARN_ON_ONCE(rcuidle && in_nmi());                      \
+                                                                        \
+                /* keep srcu and sched-rcu usage consistent */          \
+                preempt_disable_notrace();                              \
+                                                                        \
+                /*                                                      \
+                 * For rcuidle callers, use srcu since sched-rcu        \
+                 * doesn't work from the idle path.                     \
+                 */                                                     \
+                if (rcuidle) {                                          \
+                        idx = srcu_read_lock_notrace(&tracepoint_srcu); \
                         rcu_irq_enter_irqson();                         \
-                rcu_read_lock_sched_notrace();                          \
-                it_func_ptr = rcu_dereference_sched((tp)->funcs);       \
+                }                                                       \
+                                                                        \
+                it_func_ptr = rcu_dereference_raw((tp)->funcs);         \
+                                                                        \
                 if (it_func_ptr) {                                      \
                         do {                                            \
                                 it_func = (it_func_ptr)->func;          \
@@ -148,9 +172,13 @@ extern void syscall_unregfunc(void);
                                 ((void(*)(proto))(it_func))(args);      \
                         } while ((++it_func_ptr)->func);                \
                 }                                                       \
-                rcu_read_unlock_sched_notrace();                        \
-                if (rcucheck)                                           \
+                                                                        \
+                if (rcuidle) {                                          \
                         rcu_irq_exit_irqson();                          \
+                        srcu_read_unlock_notrace(&tracepoint_srcu, idx);\
+                }                                                       \
+                                                                        \
+                preempt_enable_notrace();                               \
         } while (0)
 
 #ifndef MODULE
@@ -225,6 +253,19 @@ extern void syscall_unregfunc(void);
                 return static_key_false(&__tracepoint_##name.key);      \
         }
 
+#ifdef CONFIG_HAVE_ARCH_PREL32_RELOCATIONS
+#define __TRACEPOINT_ENTRY(name)                                        \
+        asm("   .section \"__tracepoints_ptrs\", \"a\"          \n"     \
+            "   .balign 4                                       \n"     \
+            "   .long   __tracepoint_" #name " - .              \n"     \
+            "   .previous                                       \n")
+#else
+#define __TRACEPOINT_ENTRY(name)                                         \
+        static struct tracepoint * const __tracepoint_ptr_##name __used  \
+        __attribute__((section("__tracepoints_ptrs"))) =                 \
+                &__tracepoint_##name
+#endif
+
 /*
  * We have no guarantee that gcc and the linker won't up-align the tracepoint
  * structures, so we create an array of pointers that will be used for iteration
@@ -234,11 +275,9 @@ extern void syscall_unregfunc(void);
         static const char __tpstrtab_##name[]                            \
         __attribute__((section("__tracepoints_strings"))) = #name;       \
         struct tracepoint __tracepoint_##name                            \
-        __attribute__((section("__tracepoints"))) =                      \
+        __attribute__((section("__tracepoints"), used)) =                \
                 { __tpstrtab_##name, STATIC_KEY_INIT_FALSE, reg, unreg, NULL };\
-        static struct tracepoint * const __tracepoint_ptr_##name __used  \
-        __attribute__((section("__tracepoints_ptrs"))) =                 \
-                &__tracepoint_##name;
+        __TRACEPOINT_ENTRY(name);
 
 #define DEFINE_TRACE(name)                                              \
         DEFINE_TRACE_FN(name, NULL, NULL);
diff --git a/include/linux/tty_ldisc.h b/include/linux/tty_ldisc.h
index 1ef64d4ad887..840894ca3fc0 100644
--- a/include/linux/tty_ldisc.h
+++ b/include/linux/tty_ldisc.h
@@ -119,13 +119,13 @@
 
 #include <linux/fs.h>
 #include <linux/wait.h>
-
+#include <linux/atomic.h>
 
 /*
  * the semaphore definition
  */
 struct ld_semaphore {
-        long                    count;
+        atomic_long_t           count;
         raw_spinlock_t          wait_lock;
         unsigned int            wait_readers;
         struct list_head        read_wait;
diff --git a/include/linux/udp.h b/include/linux/udp.h
index ca840345571b..320d49d85484 100644
--- a/include/linux/udp.h
+++ b/include/linux/udp.h
@@ -74,8 +74,8 @@ struct udp_sock {
         void (*encap_destroy)(struct sock *sk);
 
         /* GRO functions for UDP socket */
-        struct sk_buff **       (*gro_receive)(struct sock *sk,
-                                               struct sk_buff **head,
+        struct sk_buff *        (*gro_receive)(struct sock *sk,
+                                               struct list_head *head,
                                                struct sk_buff *skb);
         int                     (*gro_complete)(struct sock *sk,
                                                 struct sk_buff *skb,
diff --git a/include/linux/uprobes.h b/include/linux/uprobes.h
index 0a294e950df8..bb9d2084af03 100644
--- a/include/linux/uprobes.h
+++ b/include/linux/uprobes.h
@@ -121,7 +121,7 @@ extern bool is_swbp_insn(uprobe_opcode_t *insn);
 extern bool is_trap_insn(uprobe_opcode_t *insn);
 extern unsigned long uprobe_get_swbp_addr(struct pt_regs *regs);
 extern unsigned long uprobe_get_trap_addr(struct pt_regs *regs);
-extern int uprobe_write_opcode(struct mm_struct *mm, unsigned long vaddr, uprobe_opcode_t);
+extern int uprobe_write_opcode(struct arch_uprobe *auprobe, struct mm_struct *mm, unsigned long vaddr, uprobe_opcode_t);
 extern int uprobe_register(struct inode *inode, loff_t offset, struct uprobe_consumer *uc);
 extern int uprobe_apply(struct inode *inode, loff_t offset, struct uprobe_consumer *uc, bool);
 extern void uprobe_unregister(struct inode *inode, loff_t offset, struct uprobe_consumer *uc);
diff --git a/include/linux/usb/audio-v3.h b/include/linux/usb/audio-v3.h
index a710e28b5215..6b708434b7f9 100644
--- a/include/linux/usb/audio-v3.h
+++ b/include/linux/usb/audio-v3.h
@@ -387,6 +387,12 @@ struct uac3_interrupt_data_msg {
 #define UAC3_CONNECTORS                 0x0f
 #define UAC3_POWER_DOMAIN               0x10
 
+/* A.20 PROCESSING UNIT PROCESS TYPES */
+#define UAC3_PROCESS_UNDEFINED          0x00
+#define UAC3_PROCESS_UP_DOWNMIX         0x01
+#define UAC3_PROCESS_STEREO_EXTENDER    0x02
+#define UAC3_PROCESS_MULTI_FUNCTION     0x03
+
 /* A.22 AUDIO CLASS-SPECIFIC REQUEST CODES */
 /* see audio-v2.h for the rest, which is identical to v2 */
 #define UAC3_CS_REQ_INTEN                       0x04
@@ -406,6 +412,15 @@ struct uac3_interrupt_data_msg {
 #define UAC3_TE_OVERFLOW                        0x04
 #define UAC3_TE_LATENCY                         0x05
 
+/* A.23.10 PROCESSING UNITS CONTROL SELECTROS */
+
+/* Up/Down Mixer */
+#define UAC3_UD_MODE_SELECT                     0x01
+
+/* Stereo Extender */
+#define UAC3_EXT_WIDTH_CONTROL                  0x01
+
+
 /* BADD predefined Unit/Terminal values */
 #define UAC3_BADD_IT_ID1        1  /* Input Terminal ID1: bTerminalID = 1 */
 #define UAC3_BADD_FU_ID2        2  /* Feature Unit ID2: bUnitID = 2 */
@@ -432,4 +447,8 @@ struct uac3_interrupt_data_msg {
 /* BADD sample rate is always fixed to 48kHz */
 #define UAC3_BADD_SAMPLING_RATE                         48000
 
+/* BADD power domains recovery times in 50us increments */
+#define UAC3_BADD_PD_RECOVER_D1D0                       0x0258  /* 30ms */
+#define UAC3_BADD_PD_RECOVER_D2D0                       0x1770  /* 300ms */
+
 #endif /* __LINUX_USB_AUDIO_V3_H */
diff --git a/include/linux/usb/hcd.h b/include/linux/usb/hcd.h
index 34a6ded6f319..97e2ddec18b1 100644
--- a/include/linux/usb/hcd.h
+++ b/include/linux/usb/hcd.h
@@ -322,6 +322,7 @@ struct hc_driver {
         int     (*bus_suspend)(struct usb_hcd *);
         int     (*bus_resume)(struct usb_hcd *);
         int     (*start_port_reset)(struct usb_hcd *, unsigned port_num);
+        unsigned long   (*get_resuming_ports)(struct usb_hcd *);
 
                 /* force handover of high-speed port to full-speed companion */
         void    (*relinquish_port)(struct usb_hcd *, int);
diff --git a/include/linux/usb/pd.h b/include/linux/usb/pd.h
index 09b570feb297..f2162e0fe531 100644
--- a/include/linux/usb/pd.h
+++ b/include/linux/usb/pd.h
@@ -15,6 +15,7 @@
 #ifndef __LINUX_USB_PD_H
 #define __LINUX_USB_PD_H
 
+#include <linux/kernel.h>
 #include <linux/types.h>
 #include <linux/usb/typec.h>
 
diff --git a/include/linux/usb/tcpm.h b/include/linux/usb/tcpm.h
index b231b9314240..7e7fbfb84e8e 100644
--- a/include/linux/usb/tcpm.h
+++ b/include/linux/usb/tcpm.h
@@ -98,18 +98,10 @@ struct tcpc_config {
 #define TCPC_MUX_DP_ENABLED             BIT(1)  /* DP enabled */
 #define TCPC_MUX_POLARITY_INVERTED      BIT(2)  /* Polarity inverted */
 
-/* Mux modes, decoded to attributes */
-enum tcpc_mux_mode {
-        TYPEC_MUX_NONE  = 0,                            /* Open switch */
-        TYPEC_MUX_USB   = TCPC_MUX_USB_ENABLED,         /* USB only */
-        TYPEC_MUX_DP    = TCPC_MUX_DP_ENABLED,          /* DP only */
-        TYPEC_MUX_DOCK  = TCPC_MUX_USB_ENABLED |        /* Both USB and DP */
-                          TCPC_MUX_DP_ENABLED,
-};
-
 /**
  * struct tcpc_dev - Port configuration and callback functions
  * @config:     Pointer to port configuration
+ * @fwnode:     Pointer to port fwnode
  * @get_vbus:   Called to read current VBUS state
  * @get_current_limit:
  *              Optional; called by the tcpm core when configured as a snk
@@ -138,6 +130,7 @@ enum tcpc_mux_mode {
  */
 struct tcpc_dev {
         const struct tcpc_config *config;
+        struct fwnode_handle *fwnode;
 
         int (*init)(struct tcpc_dev *dev);
         int (*get_vbus)(struct tcpc_dev *dev);
diff --git a/include/linux/usb/typec.h b/include/linux/usb/typec.h
index 672b39bb0adc..7df4ecabc78a 100644
--- a/include/linux/usb/typec.h
+++ b/include/linux/usb/typec.h
@@ -5,21 +5,18 @@
 
 #include <linux/types.h>
 
-/* XXX: Once we have a header for USB Power Delivery, this belongs there */
-#define ALTMODE_MAX_MODES       6
-
 /* USB Type-C Specification releases */
 #define USB_TYPEC_REV_1_0       0x100 /* 1.0 */
 #define USB_TYPEC_REV_1_1       0x110 /* 1.1 */
 #define USB_TYPEC_REV_1_2       0x120 /* 1.2 */
 
-struct typec_altmode;
 struct typec_partner;
 struct typec_cable;
 struct typec_plug;
 struct typec_port;
 
 struct fwnode_handle;
+struct device;
 
 enum typec_port_type {
         TYPEC_PORT_SRC,
@@ -93,39 +90,21 @@ int typec_partner_set_identity(struct typec_partner *partner);
 int typec_cable_set_identity(struct typec_cable *cable);
 
 /*
- * struct typec_mode_desc - Individual Mode of an Alternate Mode
- * @index: Index of the Mode within the SVID
- * @vdo: VDO returned by Discover Modes USB PD command
- * @desc: Optional human readable description of the mode
- * @roles: Only for ports. DRP if the mode is available in both roles
- *
- * Description of a mode of an Alternate Mode which a connector, cable plug or
- * partner supports. Every mode will have it's own sysfs group. The details are
- * the VDO returned by discover modes command, description for the mode and
- * active flag telling has the mode being entered or not.
- */
-struct typec_mode_desc {
-        int                     index;
-        u32                     vdo;
-        char                    *desc;
-        /* Only used with ports */
-        enum typec_port_type    roles;
-};
-
-/*
  * struct typec_altmode_desc - USB Type-C Alternate Mode Descriptor
  * @svid: Standard or Vendor ID
- * @n_modes: Number of modes
- * @modes: Array of modes supported by the Alternate Mode
+ * @mode: Index of the Mode
+ * @vdo: VDO returned by Discover Modes USB PD command
+ * @roles: Only for ports. DRP if the mode is available in both roles
  *
- * Representation of an Alternate Mode that has SVID assigned by USB-IF. The
- * array of modes will list the modes of a particular SVID that are supported by
- * a connector, partner of a cable plug.
+ * Description of an Alternate Mode which a connector, cable plug or partner
+ * supports.
  */
 struct typec_altmode_desc {
         u16                     svid;
-        int                     n_modes;
-        struct typec_mode_desc  modes[ALTMODE_MAX_MODES];
+        u8                      mode;
+        u32                     vdo;
+        /* Only used with ports */
+        enum typec_port_data    roles;
 };
 
 struct typec_altmode
@@ -141,8 +120,7 @@ void typec_unregister_altmode(struct typec_altmode *altmode);
 
 struct typec_port *typec_altmode2port(struct typec_altmode *alt);
 
-void typec_altmode_update_active(struct typec_altmode *alt, int mode,
-                                 bool active);
+void typec_altmode_update_active(struct typec_altmode *alt, bool active);
 
 enum typec_plug_index {
         TYPEC_PLUG_SOP_P,
@@ -205,7 +183,6 @@ struct typec_partner_desc {
  * @dr_set: Set Data Role
  * @pr_set: Set Power Role
  * @vconn_set: Set VCONN Role
- * @activate_mode: Enter/exit given Alternate Mode
  * @port_type_set: Set port type
  *
  * Static capabilities of a single USB Type-C port.
@@ -231,12 +208,8 @@ struct typec_capability {
                                   enum typec_role);
         int             (*vconn_set)(const struct typec_capability *,
                                      enum typec_role);
-
-        int             (*activate_mode)(const struct typec_capability *,
-                                         int mode, int activate);
         int             (*port_type_set)(const struct typec_capability *,
-                                        enum typec_port_type);
-
+                                         enum typec_port_type);
 };
 
 /* Specific to try_role(). Indicates the user want's to clear the preference. */
@@ -265,6 +238,10 @@ void typec_set_pwr_opmode(struct typec_port *port, enum typec_pwr_opmode mode);
 
 int typec_set_orientation(struct typec_port *port,
                           enum typec_orientation orientation);
+enum typec_orientation typec_get_orientation(struct typec_port *port);
 int typec_set_mode(struct typec_port *port, int mode);
 
+int typec_find_port_power_role(const char *name);
+int typec_find_power_role(const char *name);
+int typec_find_port_data_role(const char *name);
 #endif /* __LINUX_USB_TYPEC_H */
diff --git a/include/linux/usb/typec_altmode.h b/include/linux/usb/typec_altmode.h
new file mode 100644
index 000000000000..9a88c74a1d0d
--- /dev/null
+++ b/include/linux/usb/typec_altmode.h
@@ -0,0 +1,160 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+
+#ifndef __USB_TYPEC_ALTMODE_H
+#define __USB_TYPEC_ALTMODE_H
+
+#include <linux/mod_devicetable.h>
+#include <linux/usb/typec.h>
+#include <linux/device.h>
+
+#define MODE_DISCOVERY_MAX      6
+
+struct typec_altmode_ops;
+
+/**
+ * struct typec_altmode - USB Type-C alternate mode device
+ * @dev: Driver model's view of this device
+ * @svid: Standard or Vendor ID (SVID) of the alternate mode
+ * @mode: Index of the Mode
+ * @vdo: VDO returned by Discover Modes USB PD command
+ * @active: Tells has the mode been entered or not
+ * @desc: Optional human readable description of the mode
+ * @ops: Operations vector from the driver
+ */
+struct typec_altmode {
+        struct device                   dev;
+        u16                             svid;
+        int                             mode;
+        u32                             vdo;
+        unsigned int                    active:1;
+
+        char                            *desc;
+        const struct typec_altmode_ops  *ops;
+};
+
+#define to_typec_altmode(d) container_of(d, struct typec_altmode, dev)
+
+static inline void typec_altmode_set_drvdata(struct typec_altmode *altmode,
+                                             void *data)
+{
+        dev_set_drvdata(&altmode->dev, data);
+}
+
+static inline void *typec_altmode_get_drvdata(struct typec_altmode *altmode)
+{
+        return dev_get_drvdata(&altmode->dev);
+}
+
+/**
+ * struct typec_altmode_ops - Alternate mode specific operations vector
+ * @enter: Operations to be executed with Enter Mode Command
+ * @exit: Operations to be executed with Exit Mode Command
+ * @attention: Callback for Attention Command
+ * @vdm: Callback for SVID specific commands
+ * @notify: Communication channel for platform and the alternate mode
+ * @activate: User callback for Enter/Exit Mode
+ */
+struct typec_altmode_ops {
+        int (*enter)(struct typec_altmode *altmode);
+        int (*exit)(struct typec_altmode *altmode);
+        void (*attention)(struct typec_altmode *altmode, u32 vdo);
+        int (*vdm)(struct typec_altmode *altmode, const u32 hdr,
+                   const u32 *vdo, int cnt);
+        int (*notify)(struct typec_altmode *altmode, unsigned long conf,
+                      void *data);
+        int (*activate)(struct typec_altmode *altmode, int activate);
+};
+
+int typec_altmode_enter(struct typec_altmode *altmode);
+int typec_altmode_exit(struct typec_altmode *altmode);
+void typec_altmode_attention(struct typec_altmode *altmode, u32 vdo);
+int typec_altmode_vdm(struct typec_altmode *altmode,
+                      const u32 header, const u32 *vdo, int count);
+int typec_altmode_notify(struct typec_altmode *altmode, unsigned long conf,
+                         void *data);
+const struct typec_altmode *
+typec_altmode_get_partner(struct typec_altmode *altmode);
+
+/*
+ * These are the connector states (USB, Safe and Alt Mode) defined in USB Type-C
+ * Specification. SVID specific connector states are expected to follow and
+ * start from the value TYPEC_STATE_MODAL.
+ */
+enum {
+        TYPEC_STATE_SAFE,       /* USB Safe State */
+        TYPEC_STATE_USB,        /* USB Operation */
+        TYPEC_STATE_MODAL,      /* Alternate Modes */
+};
+
+/*
+ * For the muxes there is no difference between Accessory Modes and Alternate
+ * Modes, so the Accessory Modes are supplied with specific modal state values
+ * here. Unlike with Alternate Modes, where the mux will be linked with the
+ * alternate mode device, the mux for Accessory Modes will be linked with the
+ * port device instead.
+ *
+ * Port drivers can use TYPEC_MODE_AUDIO and TYPEC_MODE_DEBUG as the mode
+ * value for typec_set_mode() when accessory modes are supported.
+ */
+enum {
+        TYPEC_MODE_AUDIO = TYPEC_STATE_MODAL,   /* Audio Accessory */
+        TYPEC_MODE_DEBUG,                       /* Debug Accessory */
+};
+
+#define TYPEC_MODAL_STATE(_state_)      ((_state_) + TYPEC_STATE_MODAL)
+
+struct typec_altmode *typec_altmode_get_plug(struct typec_altmode *altmode,
+                                             enum typec_plug_index index);
+void typec_altmode_put_plug(struct typec_altmode *plug);
+
+struct typec_altmode *typec_match_altmode(struct typec_altmode **altmodes,
+                                          size_t n, u16 svid, u8 mode);
+
+struct typec_altmode *
+typec_altmode_register_notifier(struct device *dev, u16 svid, u8 mode,
+                                struct notifier_block *nb);
+
+void typec_altmode_unregister_notifier(struct typec_altmode *adev,
+                                       struct notifier_block *nb);
+
+/**
+ * typec_altmode_get_orientation - Get cable plug orientation
+ * altmode: Handle to the alternate mode
+ */
+static inline enum typec_orientation
+typec_altmode_get_orientation(struct typec_altmode *altmode)
+{
+        return typec_get_orientation(typec_altmode2port(altmode));
+}
+
+/**
+ * struct typec_altmode_driver - USB Type-C alternate mode device driver
+ * @id_table: Null terminated array of SVIDs
+ * @probe: Callback for device binding
+ * @remove: Callback for device unbinding
+ * @driver: Device driver model driver
+ *
+ * These drivers will be bind to the partner alternate mode devices. They will
+ * handle all SVID specific communication.
+ */
+struct typec_altmode_driver {
+        const struct typec_device_id *id_table;
+        int (*probe)(struct typec_altmode *altmode);
+        void (*remove)(struct typec_altmode *altmode);
+        struct device_driver driver;
+};
+
+#define to_altmode_driver(d) container_of(d, struct typec_altmode_driver, \
+                                          driver)
+
+#define typec_altmode_register_driver(drv) \
+                __typec_altmode_register_driver(drv, THIS_MODULE)
+int __typec_altmode_register_driver(struct typec_altmode_driver *drv,
+                                    struct module *module);
+void typec_altmode_unregister_driver(struct typec_altmode_driver *drv);
+
+#define module_typec_altmode_driver(__typec_altmode_driver) \
+        module_driver(__typec_altmode_driver, typec_altmode_register_driver, \
+                      typec_altmode_unregister_driver)
+
+#endif /* __USB_TYPEC_ALTMODE_H */
diff --git a/include/linux/usb/typec_dp.h b/include/linux/usb/typec_dp.h
new file mode 100644
index 000000000000..55ae781d60a9
--- /dev/null
+++ b/include/linux/usb/typec_dp.h
@@ -0,0 +1,95 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+#ifndef __USB_TYPEC_DP_H
+#define __USB_TYPEC_DP_H
+
+#include <linux/usb/typec_altmode.h>
+
+#define USB_TYPEC_DP_SID        0xff01
+#define USB_TYPEC_DP_MODE       1
+
+/*
+ * Connector states matching the pin assignments in DisplayPort Alt Mode
+ * Specification.
+ *
+ * These values are meant primarily to be used by the mux drivers, but they are
+ * also used as the "value" part in the alternate mode notification chain, so
+ * receivers of those notifications will always see them.
+ *
+ * Note. DisplayPort USB Type-C Alt Mode Specification version 1.0b deprecated
+ * pin assignments A, B and F, but they are still defined here for legacy
+ * purposes.
+ */
+enum {
+        TYPEC_DP_STATE_A = TYPEC_STATE_MODAL,   /* Not supported after v1.0b */
+        TYPEC_DP_STATE_B,                       /* Not supported after v1.0b */
+        TYPEC_DP_STATE_C,
+        TYPEC_DP_STATE_D,
+        TYPEC_DP_STATE_E,
+        TYPEC_DP_STATE_F,                       /* Not supported after v1.0b */
+};
+
+/*
+ * struct typec_displayport_data - DisplayPort Alt Mode specific data
+ * @status: Status Update command VDO content
+ * @conf: Configure command VDO content
+ *
+ * This structure is delivered as the data part with the notifications. It
+ * contains the VDOs from the two DisplayPort Type-C alternate mode specific
+ * commands: Status Update and Configure.
+ *
+ * @status will show for example the status of the HPD signal.
+ */
+struct typec_displayport_data {
+        u32 status;
+        u32 conf;
+};
+
+enum {
+        DP_PIN_ASSIGN_A, /* Not supported after v1.0b */
+        DP_PIN_ASSIGN_B, /* Not supported after v1.0b */
+        DP_PIN_ASSIGN_C,
+        DP_PIN_ASSIGN_D,
+        DP_PIN_ASSIGN_E,
+        DP_PIN_ASSIGN_F, /* Not supported after v1.0b */
+};
+
+/* DisplayPort alt mode specific commands */
+#define DP_CMD_STATUS_UPDATE            VDO_CMD_VENDOR(0)
+#define DP_CMD_CONFIGURE                VDO_CMD_VENDOR(1)
+
+/* DisplayPort Capabilities VDO bits (returned with Discover Modes) */
+#define DP_CAP_CAPABILITY(_cap_)        ((_cap_) & 3)
+#define   DP_CAP_UFP_D                  1
+#define   DP_CAP_DFP_D                  2
+#define   DP_CAP_DFP_D_AND_UFP_D        3
+#define DP_CAP_DP_SIGNALING             BIT(2) /* Always set */
+#define DP_CAP_GEN2                     BIT(3) /* Reserved after v1.0b */
+#define DP_CAP_RECEPTACLE               BIT(6)
+#define DP_CAP_USB                      BIT(7)
+#define DP_CAP_DFP_D_PIN_ASSIGN(_cap_)  (((_cap_) & GENMASK(15, 8)) >> 8)
+#define DP_CAP_UFP_D_PIN_ASSIGN(_cap_)  (((_cap_) & GENMASK(23, 16)) >> 16)
+
+/* DisplayPort Status Update VDO bits */
+#define DP_STATUS_CONNECTION(_status_)  ((_status_) & 3)
+#define   DP_STATUS_CON_DISABLED        0
+#define   DP_STATUS_CON_DFP_D           1
+#define   DP_STATUS_CON_UFP_D           2
+#define   DP_STATUS_CON_BOTH            3
+#define DP_STATUS_POWER_LOW             BIT(2)
+#define DP_STATUS_ENABLED               BIT(3)
+#define DP_STATUS_PREFER_MULTI_FUNC     BIT(4)
+#define DP_STATUS_SWITCH_TO_USB         BIT(5)
+#define DP_STATUS_EXIT_DP_MODE          BIT(6)
+#define DP_STATUS_HPD_STATE             BIT(7) /* 0 = HPD_Low, 1 = HPD_High */
+#define DP_STATUS_IRQ_HPD               BIT(8)
+
+/* DisplayPort Configurations VDO bits */
+#define DP_CONF_CURRENTLY(_conf_)       ((_conf_) & 3)
+#define DP_CONF_UFP_U_AS_DFP_D          BIT(0)
+#define DP_CONF_UFP_U_AS_UFP_D          BIT(1)
+#define DP_CONF_SIGNALING_DP            BIT(2)
+#define DP_CONF_SIGNALING_GEN_2         BIT(3) /* Reserved after v1.0b */
+#define DP_CONF_PIN_ASSIGNEMENT_SHIFT   8
+#define DP_CONF_PIN_ASSIGNEMENT_MASK    GENMASK(15, 8)
+
+#endif /* __USB_TYPEC_DP_H */
diff --git a/include/linux/usb/typec_mux.h b/include/linux/usb/typec_mux.h
index 12c1b057834b..79293f630ee1 100644
--- a/include/linux/usb/typec_mux.h
+++ b/include/linux/usb/typec_mux.h
@@ -47,7 +47,7 @@ void typec_switch_put(struct typec_switch *sw);
 int typec_switch_register(struct typec_switch *sw);
 void typec_switch_unregister(struct typec_switch *sw);
 
-struct typec_mux *typec_mux_get(struct device *dev);
+struct typec_mux *typec_mux_get(struct device *dev, const char *name);
 void typec_mux_put(struct typec_mux *mux);
 int typec_mux_register(struct typec_mux *mux);
 void typec_mux_unregister(struct typec_mux *mux);
diff --git a/include/linux/userfaultfd_k.h b/include/linux/userfaultfd_k.h
index e091f0a11b11..37c9eba75c98 100644
--- a/include/linux/userfaultfd_k.h
+++ b/include/linux/userfaultfd_k.h
@@ -28,7 +28,7 @@
 #define UFFD_SHARED_FCNTL_FLAGS (O_CLOEXEC | O_NONBLOCK)
 #define UFFD_FLAGS_SET (EFD_SHARED_FCNTL_FLAGS)
 
-extern int handle_userfault(struct vm_fault *vmf, unsigned long reason);
+extern vm_fault_t handle_userfault(struct vm_fault *vmf, unsigned long reason);
 
 extern ssize_t mcopy_atomic(struct mm_struct *dst_mm, unsigned long dst_start,
                             unsigned long src_start, unsigned long len,
@@ -77,7 +77,8 @@ extern void userfaultfd_unmap_complete(struct mm_struct *mm,
 #else /* CONFIG_USERFAULTFD */
 
 /* mm helpers */
-static inline int handle_userfault(struct vm_fault *vmf, unsigned long reason)
+static inline vm_fault_t handle_userfault(struct vm_fault *vmf,
+                                unsigned long reason)
 {
         return VM_FAULT_SIGBUS;
 }
diff --git a/include/linux/verification.h b/include/linux/verification.h
index a10549a6c7cd..cfa4730d607a 100644
--- a/include/linux/verification.h
+++ b/include/linux/verification.h
@@ -13,6 +13,12 @@
 #define _LINUX_VERIFICATION_H
 
 /*
+ * Indicate that both builtin trusted keys and secondary trusted keys
+ * should be used.
+ */
+#define VERIFY_USE_SECONDARY_KEYRING ((struct key *)1UL)
+
+/*
  * The use to which an asymmetric key is being put.
  */
 enum key_being_used_for {
diff --git a/include/linux/vga_switcheroo.h b/include/linux/vga_switcheroo.h
index 77f0f0af3a71..a34539b7f750 100644
--- a/include/linux/vga_switcheroo.h
+++ b/include/linux/vga_switcheroo.h
@@ -84,8 +84,8 @@ enum vga_switcheroo_state {
  * Client identifier. Audio clients use the same identifier & 0x100.
  */
 enum vga_switcheroo_client_id {
-        VGA_SWITCHEROO_UNKNOWN_ID = -1,
-        VGA_SWITCHEROO_IGD,
+        VGA_SWITCHEROO_UNKNOWN_ID = 0x1000,
+        VGA_SWITCHEROO_IGD = 0,
         VGA_SWITCHEROO_DIS,
         VGA_SWITCHEROO_MAX_CLIENTS,
 };
@@ -151,7 +151,7 @@ int vga_switcheroo_register_client(struct pci_dev *dev,
                                    bool driver_power_control);
 int vga_switcheroo_register_audio_client(struct pci_dev *pdev,
                                          const struct vga_switcheroo_client_ops *ops,
-                                         enum vga_switcheroo_client_id id);
+                                         struct pci_dev *vga_dev);
 
 void vga_switcheroo_client_fb_set(struct pci_dev *dev,
                                   struct fb_info *info);
@@ -180,7 +180,7 @@ static inline int vga_switcheroo_register_handler(const struct vga_switcheroo_ha
                 enum vga_switcheroo_handler_flags_t handler_flags) { return 0; }
 static inline int vga_switcheroo_register_audio_client(struct pci_dev *pdev,
         const struct vga_switcheroo_client_ops *ops,
-        enum vga_switcheroo_client_id id) { return 0; }
+        struct pci_dev *vga_dev) { return 0; }
 static inline void vga_switcheroo_unregister_handler(void) {}
 static inline enum vga_switcheroo_handler_flags_t vga_switcheroo_handler_flags(void) { return 0; }
 static inline int vga_switcheroo_lock_ddc(struct pci_dev *pdev) { return -ENODEV; }
diff --git a/include/linux/virtio_config.h b/include/linux/virtio_config.h
index 5559a2d31c46..32baf8e26735 100644
--- a/include/linux/virtio_config.h
+++ b/include/linux/virtio_config.h
@@ -79,7 +79,8 @@ struct virtio_config_ops {
         u64 (*get_features)(struct virtio_device *vdev);
         int (*finalize_features)(struct virtio_device *vdev);
         const char *(*bus_name)(struct virtio_device *vdev);
-        int (*set_vq_affinity)(struct virtqueue *vq, int cpu);
+        int (*set_vq_affinity)(struct virtqueue *vq,
+                               const struct cpumask *cpu_mask);
         const struct cpumask *(*get_vq_affinity)(struct virtio_device *vdev,
                         int index);
 };
@@ -236,11 +237,11 @@ const char *virtio_bus_name(struct virtio_device *vdev)
  *
  */
 static inline
-int virtqueue_set_affinity(struct virtqueue *vq, int cpu)
+int virtqueue_set_affinity(struct virtqueue *vq, const struct cpumask *cpu_mask)
 {
         struct virtio_device *vdev = vq->vdev;
         if (vdev->config->set_vq_affinity)
-                return vdev->config->set_vq_affinity(vq, cpu);
+                return vdev->config->set_vq_affinity(vq, cpu_mask);
         return 0;
 }
 
diff --git a/include/linux/vmacache.h b/include/linux/vmacache.h
index a5b3aa8d281f..3e9a963edd6a 100644
--- a/include/linux/vmacache.h
+++ b/include/linux/vmacache.h
@@ -5,12 +5,6 @@
 #include <linux/sched.h>
 #include <linux/mm.h>
 
-/*
- * Hash based on the page number. Provides a good hit rate for
- * workloads with good locality and those with random accesses as well.
- */
-#define VMACACHE_HASH(addr) ((addr >> PAGE_SHIFT) & VMACACHE_MASK)
-
 static inline void vmacache_flush(struct task_struct *tsk)
 {
         memset(tsk->vmacache.vmas, 0, sizeof(tsk->vmacache.vmas));
diff --git a/include/linux/w1.h b/include/linux/w1.h
index 694101f744c7..3111585c371f 100644
--- a/include/linux/w1.h
+++ b/include/linux/w1.h
@@ -274,6 +274,8 @@ struct w1_family {
 
         struct w1_family_ops    *fops;
 
+        const struct of_device_id *of_match_table;
+
         atomic_t                refcnt;
 };
 
diff --git a/include/linux/wkup_m3_ipc.h b/include/linux/wkup_m3_ipc.h
index d6ba7d39a62f..e497e621dbb7 100644
--- a/include/linux/wkup_m3_ipc.h
+++ b/include/linux/wkup_m3_ipc.h
@@ -40,6 +40,12 @@ struct wkup_m3_ipc {
         struct mbox_chan *mbox;
 
         struct wkup_m3_ipc_ops *ops;
+        int is_rtc_only;
+};
+
+struct wkup_m3_wakeup_src {
+        int irq_nr;
+        char src[10];
 };
 
 struct wkup_m3_ipc_ops {
@@ -48,8 +54,11 @@ struct wkup_m3_ipc_ops {
         int (*prepare_low_power)(struct wkup_m3_ipc *m3_ipc, int state);
         int (*finish_low_power)(struct wkup_m3_ipc *m3_ipc);
         int (*request_pm_status)(struct wkup_m3_ipc *m3_ipc);
+        const char *(*request_wake_src)(struct wkup_m3_ipc *m3_ipc);
+        void (*set_rtc_only)(struct wkup_m3_ipc *m3_ipc);
 };
 
 struct wkup_m3_ipc *wkup_m3_ipc_get(void);
 void wkup_m3_ipc_put(struct wkup_m3_ipc *m3_ipc);
+void wkup_m3_set_rtc_only_mode(void);
 #endif /* _LINUX_WKUP_M3_IPC_H */
diff --git a/include/linux/ww_mutex.h b/include/linux/ww_mutex.h
index 39fda195bf78..3af7c0e03be5 100644
--- a/include/linux/ww_mutex.h
+++ b/include/linux/ww_mutex.h
@@ -6,8 +6,10 @@
  *
  *  Copyright (C) 2004, 2005, 2006 Red Hat, Inc., Ingo Molnar <mingo@redhat.com>
  *
- * Wound/wait implementation:
+ * Wait/Die implementation:
  *  Copyright (C) 2013 Canonical Ltd.
+ * Choice of algorithm:
+ *  Copyright (C) 2018 WMWare Inc.
  *
  * This file contains the main data structure and API definitions.
  */
@@ -23,14 +25,17 @@ struct ww_class {
         struct lock_class_key mutex_key;
         const char *acquire_name;
         const char *mutex_name;
+        unsigned int is_wait_die;
 };
 
 struct ww_acquire_ctx {
         struct task_struct *task;
         unsigned long stamp;
-        unsigned acquired;
+        unsigned int acquired;
+        unsigned short wounded;
+        unsigned short is_wait_die;
 #ifdef CONFIG_DEBUG_MUTEXES
-        unsigned done_acquire;
+        unsigned int done_acquire;
         struct ww_class *ww_class;
         struct ww_mutex *contending_lock;
 #endif
@@ -38,8 +43,8 @@ struct ww_acquire_ctx {
         struct lockdep_map dep_map;
 #endif
 #ifdef CONFIG_DEBUG_WW_MUTEX_SLOWPATH
-        unsigned deadlock_inject_interval;
-        unsigned deadlock_inject_countdown;
+        unsigned int deadlock_inject_interval;
+        unsigned int deadlock_inject_countdown;
 #endif
 };
 
@@ -58,17 +63,21 @@ struct ww_mutex {
 # define __WW_CLASS_MUTEX_INITIALIZER(lockname, class)
 #endif
 
-#define __WW_CLASS_INITIALIZER(ww_class) \
+#define __WW_CLASS_INITIALIZER(ww_class, _is_wait_die)      \
                 { .stamp = ATOMIC_LONG_INIT(0) \
                 , .acquire_name = #ww_class "_acquire" \
-                , .mutex_name = #ww_class "_mutex" }
+                , .mutex_name = #ww_class "_mutex" \
+                , .is_wait_die = _is_wait_die }
 
 #define __WW_MUTEX_INITIALIZER(lockname, class) \
                 { .base =  __MUTEX_INITIALIZER(lockname.base) \
                 __WW_CLASS_MUTEX_INITIALIZER(lockname, class) }
 
+#define DEFINE_WD_CLASS(classname) \
+        struct ww_class classname = __WW_CLASS_INITIALIZER(classname, 1)
+
 #define DEFINE_WW_CLASS(classname) \
-        struct ww_class classname = __WW_CLASS_INITIALIZER(classname)
+        struct ww_class classname = __WW_CLASS_INITIALIZER(classname, 0)
 
 #define DEFINE_WW_MUTEX(mutexname, ww_class) \
         struct ww_mutex mutexname = __WW_MUTEX_INITIALIZER(mutexname, ww_class)
@@ -102,7 +111,7 @@ static inline void ww_mutex_init(struct ww_mutex *lock,
  *
  * Context-based w/w mutex acquiring can be done in any order whatsoever within
  * a given lock class. Deadlocks will be detected and handled with the
- * wait/wound logic.
+ * wait/die logic.
  *
  * Mixing of context-based w/w mutex acquiring and single w/w mutex locking can
  * result in undetected deadlocks and is so forbidden. Mixing different contexts
@@ -123,6 +132,8 @@ static inline void ww_acquire_init(struct ww_acquire_ctx *ctx,
         ctx->task = current;
         ctx->stamp = atomic_long_inc_return_relaxed(&ww_class->stamp);
         ctx->acquired = 0;
+        ctx->wounded = false;
+        ctx->is_wait_die = ww_class->is_wait_die;
 #ifdef CONFIG_DEBUG_MUTEXES
         ctx->ww_class = ww_class;
         ctx->done_acquire = 0;
@@ -195,13 +206,13 @@ static inline void ww_acquire_fini(struct ww_acquire_ctx *ctx)
  * Lock the w/w mutex exclusively for this task.
  *
  * Deadlocks within a given w/w class of locks are detected and handled with the
- * wait/wound algorithm. If the lock isn't immediately avaiable this function
+ * wait/die algorithm. If the lock isn't immediately available this function
  * will either sleep until it is (wait case). Or it selects the current context
- * for backing off by returning -EDEADLK (wound case). Trying to acquire the
+ * for backing off by returning -EDEADLK (die case). Trying to acquire the
  * same lock with the same context twice is also detected and signalled by
  * returning -EALREADY. Returns 0 if the mutex was successfully acquired.
  *
- * In the wound case the caller must release all currently held w/w mutexes for
+ * In the die case the caller must release all currently held w/w mutexes for
  * the given context and then wait for this contending lock to be available by
  * calling ww_mutex_lock_slow. Alternatively callers can opt to not acquire this
  * lock and proceed with trying to acquire further w/w mutexes (e.g. when
@@ -226,14 +237,14 @@ extern int /* __must_check */ ww_mutex_lock(struct ww_mutex *lock, struct ww_acq
  * Lock the w/w mutex exclusively for this task.
  *
  * Deadlocks within a given w/w class of locks are detected and handled with the
- * wait/wound algorithm. If the lock isn't immediately avaiable this function
+ * wait/die algorithm. If the lock isn't immediately available this function
  * will either sleep until it is (wait case). Or it selects the current context
- * for backing off by returning -EDEADLK (wound case). Trying to acquire the
+ * for backing off by returning -EDEADLK (die case). Trying to acquire the
  * same lock with the same context twice is also detected and signalled by
  * returning -EALREADY. Returns 0 if the mutex was successfully acquired. If a
  * signal arrives while waiting for the lock then this function returns -EINTR.
  *
- * In the wound case the caller must release all currently held w/w mutexes for
+ * In the die case the caller must release all currently held w/w mutexes for
  * the given context and then wait for this contending lock to be available by
  * calling ww_mutex_lock_slow_interruptible. Alternatively callers can opt to
  * not acquire this lock and proceed with trying to acquire further w/w mutexes
@@ -256,7 +267,7 @@ extern int __must_check ww_mutex_lock_interruptible(struct ww_mutex *lock,
  * @lock: the mutex to be acquired
  * @ctx: w/w acquire context
  *
- * Acquires a w/w mutex with the given context after a wound case. This function
+ * Acquires a w/w mutex with the given context after a die case. This function
  * will sleep until the lock becomes available.
  *
  * The caller must have released all w/w mutexes already acquired with the
@@ -290,7 +301,7 @@ ww_mutex_lock_slow(struct ww_mutex *lock, struct ww_acquire_ctx *ctx)
  * @lock: the mutex to be acquired
  * @ctx: w/w acquire context
  *
- * Acquires a w/w mutex with the given context after a wound case. This function
+ * Acquires a w/w mutex with the given context after a die case. This function
  * will sleep until the lock becomes available and returns 0 when the lock has
  * been acquired. If a signal arrives while waiting for the lock then this
  * function returns -EINTR.