155 files changed, 2128 insertions, 811 deletions

diff --git a/include/linux/acpi.h b/include/linux/acpi.h
index 8758a2a9e6c1..e54f40974eb0 100644
--- a/include/linux/acpi.h
+++ b/include/linux/acpi.h
@@ -443,6 +443,9 @@ int acpi_check_resource_conflict(const struct resource *res);
 int acpi_check_region(resource_size_t start, resource_size_t n,
                       const char *name);
 
+acpi_status acpi_release_memory(acpi_handle handle, struct resource *res,
+                                u32 level);
+
 int acpi_resources_are_enforced(void);
 
 #ifdef CONFIG_HIBERNATION
@@ -1299,4 +1302,23 @@ static inline int lpit_read_residency_count_address(u64 *address)
 }
 #endif
 
+#ifdef CONFIG_ACPI_PPTT
+int find_acpi_cpu_topology(unsigned int cpu, int level);
+int find_acpi_cpu_topology_package(unsigned int cpu);
+int find_acpi_cpu_cache_topology(unsigned int cpu, int level);
+#else
+static inline int find_acpi_cpu_topology(unsigned int cpu, int level)
+{
+        return -EINVAL;
+}
+static inline int find_acpi_cpu_topology_package(unsigned int cpu)
+{
+        return -EINVAL;
+}
+static inline int find_acpi_cpu_cache_topology(unsigned int cpu, int level)
+{
+        return -EINVAL;
+}
+#endif
+
 #endif  /*_LINUX_ACPI_H*/
diff --git a/include/linux/arm-smccc.h b/include/linux/arm-smccc.h
index a031897fca76..ca1d2cc2cdfa 100644
--- a/include/linux/arm-smccc.h
+++ b/include/linux/arm-smccc.h
@@ -80,6 +80,11 @@
                            ARM_SMCCC_SMC_32,                            \
                            0, 0x8000)
 
+#define ARM_SMCCC_ARCH_WORKAROUND_2                                     \
+        ARM_SMCCC_CALL_VAL(ARM_SMCCC_FAST_CALL,                         \
+                           ARM_SMCCC_SMC_32,                            \
+                           0, 0x7fff)
+
 #ifndef __ASSEMBLY__
 
 #include <linux/linkage.h>
@@ -291,5 +296,10 @@ asmlinkage void __arm_smccc_hvc(unsigned long a0, unsigned long a1,
  */
 #define arm_smccc_1_1_hvc(...)  __arm_smccc_1_1(SMCCC_HVC_INST, __VA_ARGS__)
 
+/* Return codes defined in ARM DEN 0070A */
+#define SMCCC_RET_SUCCESS                       0
+#define SMCCC_RET_NOT_SUPPORTED                 -1
+#define SMCCC_RET_NOT_REQUIRED                  -2
+
 #endif /*__ASSEMBLY__*/
 #endif /*__LINUX_ARM_SMCCC_H*/
diff --git a/include/linux/assoc_array.h b/include/linux/assoc_array.h
index a89df3be1686..65e3832f96b2 100644
--- a/include/linux/assoc_array.h
+++ b/include/linux/assoc_array.h
@@ -1,6 +1,6 @@
 /* Generic associative array implementation.
  *
- * See Documentation/assoc_array.txt for information.
+ * See Documentation/core-api/assoc_array.rst for information.
  *
  * Copyright (C) 2013 Red Hat, Inc. All Rights Reserved.
  * Written by David Howells (dhowells@redhat.com)
diff --git a/include/linux/assoc_array_priv.h b/include/linux/assoc_array_priv.h
index 711275e6681c..a00a06550c10 100644
--- a/include/linux/assoc_array_priv.h
+++ b/include/linux/assoc_array_priv.h
@@ -1,6 +1,6 @@
 /* Private definitions for the generic associative array implementation.
  *
- * See Documentation/assoc_array.txt for information.
+ * See Documentation/core-api/assoc_array.rst for information.
  *
  * Copyright (C) 2013 Red Hat, Inc. All Rights Reserved.
  * Written by David Howells (dhowells@redhat.com)
diff --git a/include/linux/atmdev.h b/include/linux/atmdev.h
index 0c27515d2cf6..8124815eb121 100644
--- a/include/linux/atmdev.h
+++ b/include/linux/atmdev.h
@@ -214,6 +214,7 @@ struct atmphy_ops {
 struct atm_skb_data {
         struct atm_vcc  *vcc;           /* ATM VCC */
         unsigned long   atm_options;    /* ATM layer options */
+        unsigned int    acct_truesize;  /* truesize accounted to vcc */
 };
 
 #define VCC_HTABLE_SIZE 32
@@ -241,6 +242,20 @@ void vcc_insert_socket(struct sock *sk);
 
 void atm_dev_release_vccs(struct atm_dev *dev);
 
+static inline void atm_account_tx(struct atm_vcc *vcc, struct sk_buff *skb)
+{
+        /*
+         * Because ATM skbs may not belong to a sock (and we don't
+         * necessarily want to), skb->truesize may be adjusted,
+         * escaping the hack in pskb_expand_head() which avoids
+         * doing so for some cases. So stash the value of truesize
+         * at the time we accounted it, and atm_pop_raw() can use
+         * that value later, in case it changes.
+         */
+        refcount_add(skb->truesize, &sk_atm(vcc)->sk_wmem_alloc);
+        ATM_SKB(skb)->acct_truesize = skb->truesize;
+        ATM_SKB(skb)->atm_options = vcc->atm_options;
+}
 
 static inline void atm_force_charge(struct atm_vcc *vcc,int truesize)
 {
diff --git a/include/linux/backing-dev-defs.h b/include/linux/backing-dev-defs.h
index 0bd432a4d7bd..24251762c20c 100644
--- a/include/linux/backing-dev-defs.h
+++ b/include/linux/backing-dev-defs.h
@@ -22,7 +22,6 @@ struct dentry;
  */
 enum wb_state {
         WB_registered,          /* bdi_register() was done */
-        WB_shutting_down,       /* wb_shutdown() in progress */
         WB_writeback_running,   /* Writeback is in progress */
         WB_has_dirty_io,        /* Dirty inodes on ->b_{dirty|io|more_io} */
         WB_start_all,           /* nr_pages == 0 (all) work pending */
@@ -189,6 +188,7 @@ struct backing_dev_info {
 #ifdef CONFIG_CGROUP_WRITEBACK
         struct radix_tree_root cgwb_tree; /* radix tree of active cgroup wbs */
         struct rb_root cgwb_congested_tree; /* their congested states */
+        struct mutex cgwb_release_mutex;  /* protect shutdown of wb structs */
 #else
         struct bdi_writeback_congested *wb_congested;
 #endif
diff --git a/include/linux/backlight.h b/include/linux/backlight.h
index 2baab6f3861d..7fbf0539e14a 100644
--- a/include/linux/backlight.h
+++ b/include/linux/backlight.h
@@ -84,10 +84,6 @@ struct backlight_properties {
 
 #define BL_CORE_SUSPENDED       (1 << 0)        /* backlight is suspended */
 #define BL_CORE_FBBLANK         (1 << 1)        /* backlight is under an fb blank event */
-#define BL_CORE_DRIVER4         (1 << 28)       /* reserved for driver specific use */
-#define BL_CORE_DRIVER3         (1 << 29)       /* reserved for driver specific use */
-#define BL_CORE_DRIVER2         (1 << 30)       /* reserved for driver specific use */
-#define BL_CORE_DRIVER1         (1 << 31)       /* reserved for driver specific use */
 
 };
 
diff --git a/include/linux/bio.h b/include/linux/bio.h
index 397a38aca182..f08f5fe7bd08 100644
--- a/include/linux/bio.h
+++ b/include/linux/bio.h
@@ -422,6 +422,7 @@ enum {
 extern int bioset_init(struct bio_set *, unsigned int, unsigned int, int flags);
 extern void bioset_exit(struct bio_set *);
 extern int biovec_init_pool(mempool_t *pool, int pool_entries);
+extern int bioset_init_from_src(struct bio_set *bs, struct bio_set *src);
 
 extern struct bio *bio_alloc_bioset(gfp_t, unsigned int, struct bio_set *);
 extern void bio_put(struct bio *);
diff --git a/include/linux/blk-mq.h b/include/linux/blk-mq.h
index fb355173f3c7..e3147eb74222 100644
--- a/include/linux/blk-mq.h
+++ b/include/linux/blk-mq.h
@@ -281,8 +281,6 @@ void blk_freeze_queue_start(struct request_queue *q);
 void blk_mq_freeze_queue_wait(struct request_queue *q);
 int blk_mq_freeze_queue_wait_timeout(struct request_queue *q,
                                      unsigned long timeout);
-int blk_mq_tagset_iter(struct blk_mq_tag_set *set, void *data,
-                int (reinit_request)(void *, struct request *));
 
 int blk_mq_map_queues(struct blk_mq_tag_set *set);
 void blk_mq_update_nr_hw_queues(struct blk_mq_tag_set *set, int nr_hw_queues);
diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index bca3a92eb55f..79226ca8f80f 100644
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -127,6 +127,8 @@ typedef __u32 __bitwise req_flags_t;
 #define RQF_ZONE_WRITE_LOCKED   ((__force req_flags_t)(1 << 19))
 /* already slept for hybrid poll */
 #define RQF_MQ_POLL_SLEPT       ((__force req_flags_t)(1 << 20))
+/* ->timeout has been called, don't expire again */
+#define RQF_TIMED_OUT           ((__force req_flags_t)(1 << 21))
 
 /* flags that prevent us from merging requests: */
 #define RQF_NOMERGE_FLAGS \
@@ -560,7 +562,6 @@ struct request_queue {
         unsigned int            dma_alignment;
 
         struct blk_queue_tag    *queue_tags;
-        struct list_head        tag_busy_list;
 
         unsigned int            nr_sorted;
         unsigned int            in_flight[2];
@@ -1118,8 +1119,8 @@ static inline unsigned int blk_max_size_offset(struct request_queue *q,
         if (!q->limits.chunk_sectors)
                 return q->limits.max_sectors;
 
-        return q->limits.chunk_sectors -
-                        (offset & (q->limits.chunk_sectors - 1));
+        return min(q->limits.max_sectors, (unsigned int)(q->limits.chunk_sectors -
+                        (offset & (q->limits.chunk_sectors - 1))));
 }
 
 static inline unsigned int blk_rq_get_max_sectors(struct request *rq,
@@ -1373,7 +1374,6 @@ extern void blk_queue_end_tag(struct request_queue *, struct request *);
 extern int blk_queue_init_tags(struct request_queue *, int, struct blk_queue_tag *, int);
 extern void blk_queue_free_tags(struct request_queue *);
 extern int blk_queue_resize_tags(struct request_queue *, int);
-extern void blk_queue_invalidate_tags(struct request_queue *);
 extern struct blk_queue_tag *blk_init_tags(int, int);
 extern void blk_free_tags(struct blk_queue_tag *);
 
diff --git a/include/linux/bpf-cgroup.h b/include/linux/bpf-cgroup.h
index 975fb4cf1bb7..79795c5fa7c3 100644
--- a/include/linux/bpf-cgroup.h
+++ b/include/linux/bpf-cgroup.h
@@ -188,12 +188,38 @@ int __cgroup_bpf_check_dev_permission(short dev_type, u32 major, u32 minor,
                                                                               \
         __ret;                                                                \
 })
+int cgroup_bpf_prog_attach(const union bpf_attr *attr,
+                           enum bpf_prog_type ptype, struct bpf_prog *prog);
+int cgroup_bpf_prog_detach(const union bpf_attr *attr,
+                           enum bpf_prog_type ptype);
+int cgroup_bpf_prog_query(const union bpf_attr *attr,
+                          union bpf_attr __user *uattr);
 #else
 
+struct bpf_prog;
 struct cgroup_bpf {};
 static inline void cgroup_bpf_put(struct cgroup *cgrp) {}
 static inline int cgroup_bpf_inherit(struct cgroup *cgrp) { return 0; }
 
+static inline int cgroup_bpf_prog_attach(const union bpf_attr *attr,
+                                         enum bpf_prog_type ptype,
+                                         struct bpf_prog *prog)
+{
+        return -EINVAL;
+}
+
+static inline int cgroup_bpf_prog_detach(const union bpf_attr *attr,
+                                         enum bpf_prog_type ptype)
+{
+        return -EINVAL;
+}
+
+static inline int cgroup_bpf_prog_query(const union bpf_attr *attr,
+                                        union bpf_attr __user *uattr)
+{
+        return -EINVAL;
+}
+
 #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 995c3b1e59bf..8827e797ff97 100644
--- a/include/linux/bpf.h
+++ b/include/linux/bpf.h
@@ -488,12 +488,15 @@ void bpf_patch_call_args(struct bpf_insn *insn, u32 stack_depth);
 
 /* Map specifics */
 struct xdp_buff;
+struct sk_buff;
 
 struct bpf_dtab_netdev *__dev_map_lookup_elem(struct bpf_map *map, u32 key);
 void __dev_map_insert_ctx(struct bpf_map *map, u32 index);
 void __dev_map_flush(struct bpf_map *map);
 int dev_map_enqueue(struct bpf_dtab_netdev *dst, struct xdp_buff *xdp,
                     struct net_device *dev_rx);
+int dev_map_generic_redirect(struct bpf_dtab_netdev *dst, struct sk_buff *skb,
+                             struct bpf_prog *xdp_prog);
 
 struct bpf_cpu_map_entry *__cpu_map_lookup_elem(struct bpf_map *map, u32 key);
 void __cpu_map_insert_ctx(struct bpf_map *map, u32 index);
@@ -586,6 +589,15 @@ int dev_map_enqueue(struct bpf_dtab_netdev *dst, struct xdp_buff *xdp,
         return 0;
 }
 
+struct sk_buff;
+
+static inline int dev_map_generic_redirect(struct bpf_dtab_netdev *dst,
+                                           struct sk_buff *skb,
+                                           struct bpf_prog *xdp_prog)
+{
+        return 0;
+}
+
 static inline
 struct bpf_cpu_map_entry *__cpu_map_lookup_elem(struct bpf_map *map, u32 key)
 {
@@ -684,6 +696,8 @@ static inline void bpf_map_offload_map_free(struct bpf_map *map)
 struct sock  *__sock_map_lookup_elem(struct bpf_map *map, u32 key);
 struct sock  *__sock_hash_lookup_elem(struct bpf_map *map, void *key);
 int sock_map_prog(struct bpf_map *map, struct bpf_prog *prog, u32 type);
+int sockmap_get_from_fd(const union bpf_attr *attr, int type,
+                        struct bpf_prog *prog);
 #else
 static inline struct sock  *__sock_map_lookup_elem(struct bpf_map *map, u32 key)
 {
@@ -702,6 +716,12 @@ static inline int sock_map_prog(struct bpf_map *map,
 {
         return -EOPNOTSUPP;
 }
+
+static inline int sockmap_get_from_fd(const union bpf_attr *attr, int type,
+                                      struct bpf_prog *prog)
+{
+        return -EINVAL;
+}
 #endif
 
 #if defined(CONFIG_XDP_SOCKETS)
diff --git a/include/linux/bpf_lirc.h b/include/linux/bpf_lirc.h
index 5f8a4283092d..9d9ff755ec29 100644
--- a/include/linux/bpf_lirc.h
+++ b/include/linux/bpf_lirc.h
@@ -5,11 +5,12 @@
 #include <uapi/linux/bpf.h>
 
 #ifdef CONFIG_BPF_LIRC_MODE2
-int lirc_prog_attach(const union bpf_attr *attr);
+int lirc_prog_attach(const union bpf_attr *attr, struct bpf_prog *prog);
 int lirc_prog_detach(const union bpf_attr *attr);
 int lirc_prog_query(const union bpf_attr *attr, union bpf_attr __user *uattr);
 #else
-static inline int lirc_prog_attach(const union bpf_attr *attr)
+static inline int lirc_prog_attach(const union bpf_attr *attr,
+                                   struct bpf_prog *prog)
 {
         return -EINVAL;
 }
diff --git a/include/linux/cacheinfo.h b/include/linux/cacheinfo.h
index 3d9805297cda..70e19bc6cc9f 100644
--- a/include/linux/cacheinfo.h
+++ b/include/linux/cacheinfo.h
@@ -34,9 +34,8 @@ enum cache_type {
  * @shared_cpu_map: logical cpumask representing all the cpus sharing
  *      this cache node
  * @attributes: bitfield representing various cache attributes
- * @of_node: if devicetree is used, this represents either the cpu node in
- *      case there's no explicit cache node or the cache node itself in the
- *      device tree
+ * @fw_token: Unique value used to determine if different cacheinfo
+ *      structures represent a single hardware cache instance.
  * @disable_sysfs: indicates whether this node is visible to the user via
  *      sysfs or not
  * @priv: pointer to any private data structure specific to particular
@@ -65,8 +64,7 @@ struct cacheinfo {
 #define CACHE_ALLOCATE_POLICY_MASK      \
         (CACHE_READ_ALLOCATE | CACHE_WRITE_ALLOCATE)
 #define CACHE_ID                BIT(4)
-
-        struct device_node *of_node;
+        void *fw_token;
         bool disable_sysfs;
         void *priv;
 };
@@ -99,6 +97,23 @@ int func(unsigned int cpu)					\
 struct cpu_cacheinfo *get_cpu_cacheinfo(unsigned int cpu);
 int init_cache_level(unsigned int cpu);
 int populate_cache_leaves(unsigned int cpu);
+int cache_setup_acpi(unsigned int cpu);
+#ifndef CONFIG_ACPI_PPTT
+/*
+ * acpi_find_last_cache_level is only called on ACPI enabled
+ * platforms using the PPTT for topology. This means that if
+ * the platform supports other firmware configuration methods
+ * we need to stub out the call when ACPI is disabled.
+ * ACPI enabled platforms not using PPTT won't be making calls
+ * to this function so we need not worry about them.
+ */
+static inline int acpi_find_last_cache_level(unsigned int cpu)
+{
+        return 0;
+}
+#else
+int acpi_find_last_cache_level(unsigned int cpu);
+#endif
 
 const struct attribute_group *cache_get_priv_group(struct cacheinfo *this_leaf);
 
diff --git a/include/linux/ceph/ceph_fs.h b/include/linux/ceph/ceph_fs.h
index 7ecfc88314d8..4903deb0777a 100644
--- a/include/linux/ceph/ceph_fs.h
+++ b/include/linux/ceph/ceph_fs.h
@@ -628,6 +628,7 @@ int ceph_flags_to_mode(int flags);
                                  CEPH_CAP_XATTR_SHARED)
 #define CEPH_STAT_CAP_INLINE_DATA (CEPH_CAP_FILE_SHARED | \
                                    CEPH_CAP_FILE_RD)
+#define CEPH_STAT_RSTAT CEPH_CAP_FILE_WREXTEND
 
 #define CEPH_CAP_ANY_SHARED (CEPH_CAP_AUTH_SHARED |                     \
                               CEPH_CAP_LINK_SHARED |                    \
diff --git a/include/linux/ceph/osd_client.h b/include/linux/ceph/osd_client.h
index 96bb32285989..0d6ee04b4c41 100644
--- a/include/linux/ceph/osd_client.h
+++ b/include/linux/ceph/osd_client.h
@@ -170,6 +170,7 @@ struct ceph_osd_request {
         u64             r_tid;              /* unique for this client */
         struct rb_node  r_node;
         struct rb_node  r_mc_node;          /* map check */
+        struct work_struct r_complete_work;
         struct ceph_osd *r_osd;
 
         struct ceph_osd_request_target r_t;
@@ -201,7 +202,6 @@ struct ceph_osd_request {
         struct timespec r_mtime;              /* ditto */
         u64 r_data_offset;                    /* ditto */
         bool r_linger;                        /* don't resend on failure */
-        bool r_abort_on_full;                 /* return ENOSPC when full */
 
         /* internal */
         unsigned long r_stamp;                /* jiffies, send or check time */
@@ -347,6 +347,8 @@ struct ceph_osd_client {
         struct rb_root         linger_map_checks;
         atomic_t               num_requests;
         atomic_t               num_homeless;
+        bool                   abort_on_full; /* abort w/ ENOSPC when full */
+        int                    abort_err;
         struct delayed_work    timeout_work;
         struct delayed_work    osds_timeout_work;
 #ifdef CONFIG_DEBUG_FS
@@ -359,6 +361,7 @@ struct ceph_osd_client {
         struct ceph_msgpool     msgpool_op_reply;
 
         struct workqueue_struct *notify_wq;
+        struct workqueue_struct *completion_wq;
 };
 
 static inline bool ceph_osdmap_flag(struct ceph_osd_client *osdc, int flag)
@@ -378,6 +381,7 @@ extern void ceph_osdc_handle_reply(struct ceph_osd_client *osdc,
 extern void ceph_osdc_handle_map(struct ceph_osd_client *osdc,
                                  struct ceph_msg *msg);
 void ceph_osdc_update_epoch_barrier(struct ceph_osd_client *osdc, u32 eb);
+void ceph_osdc_abort_requests(struct ceph_osd_client *osdc, int err);
 
 extern void osd_req_op_init(struct ceph_osd_request *osd_req,
                             unsigned int which, u16 opcode, u32 flags);
@@ -440,7 +444,7 @@ extern void osd_req_op_cls_response_data_pages(struct ceph_osd_request *,
                                         struct page **pages, u64 length,
                                         u32 alignment, bool pages_from_pool,
                                         bool own_pages);
-extern void osd_req_op_cls_init(struct ceph_osd_request *osd_req,
+extern int osd_req_op_cls_init(struct ceph_osd_request *osd_req,
                                         unsigned int which, u16 opcode,
                                         const char *class, const char *method);
 extern int osd_req_op_xattr_init(struct ceph_osd_request *osd_req, unsigned int which,
diff --git a/include/linux/ceph/osdmap.h b/include/linux/ceph/osdmap.h
index e71fb222c7c3..5675b1f09bc5 100644
--- a/include/linux/ceph/osdmap.h
+++ b/include/linux/ceph/osdmap.h
@@ -279,10 +279,10 @@ bool ceph_osds_changed(const struct ceph_osds *old_acting,
                        const struct ceph_osds *new_acting,
                        bool any_change);
 
-int __ceph_object_locator_to_pg(struct ceph_pg_pool_info *pi,
-                                const struct ceph_object_id *oid,
-                                const struct ceph_object_locator *oloc,
-                                struct ceph_pg *raw_pgid);
+void __ceph_object_locator_to_pg(struct ceph_pg_pool_info *pi,
+                                 const struct ceph_object_id *oid,
+                                 const struct ceph_object_locator *oloc,
+                                 struct ceph_pg *raw_pgid);
 int ceph_object_locator_to_pg(struct ceph_osdmap *osdmap,
                               const struct ceph_object_id *oid,
                               const struct ceph_object_locator *oloc,
diff --git a/include/linux/circ_buf.h b/include/linux/circ_buf.h
index 7cf262a421c3..b3233e8202f9 100644
--- a/include/linux/circ_buf.h
+++ b/include/linux/circ_buf.h
@@ -1,6 +1,6 @@
 /* SPDX-License-Identifier: GPL-2.0 */
 /*
- * See Documentation/circular-buffers.txt for more information.
+ * See Documentation/core-api/circular-buffers.rst for more information.
  */
 
 #ifndef _LINUX_CIRC_BUF_H
diff --git a/include/linux/clk-provider.h b/include/linux/clk-provider.h
index 1d25e149c1c5..b7cfa037e593 100644
--- a/include/linux/clk-provider.h
+++ b/include/linux/clk-provider.h
@@ -13,6 +13,7 @@
 
 #include <linux/io.h>
 #include <linux/of.h>
+#include <linux/of_clk.h>
 
 #ifdef CONFIG_COMMON_CLK
 
@@ -218,7 +219,7 @@ struct clk_ops {
         int             (*get_phase)(struct clk_hw *hw);
         int             (*set_phase)(struct clk_hw *hw, int degrees);
         void            (*init)(struct clk_hw *hw);
-        int             (*debug_init)(struct clk_hw *hw, struct dentry *dentry);
+        void            (*debug_init)(struct clk_hw *hw, struct dentry *dentry);
 };
 
 /**
@@ -805,8 +806,6 @@ unsigned long clk_hw_round_rate(struct clk_hw *hw, unsigned long rate);
 
 struct of_device_id;
 
-typedef void (*of_clk_init_cb_t)(struct device_node *);
-
 struct clk_onecell_data {
         struct clk **clks;
         unsigned int clk_num;
@@ -893,13 +892,10 @@ struct clk_hw *of_clk_hw_simple_get(struct of_phandle_args *clkspec,
 struct clk *of_clk_src_onecell_get(struct of_phandle_args *clkspec, void *data);
 struct clk_hw *of_clk_hw_onecell_get(struct of_phandle_args *clkspec,
                                      void *data);
-unsigned int of_clk_get_parent_count(struct device_node *np);
 int of_clk_parent_fill(struct device_node *np, const char **parents,
                        unsigned int size);
-const char *of_clk_get_parent_name(struct device_node *np, int index);
 int of_clk_detect_critical(struct device_node *np, int index,
                             unsigned long *flags);
-void of_clk_init(const struct of_device_id *matches);
 
 #else /* !CONFIG_OF */
 
@@ -946,26 +942,16 @@ of_clk_hw_onecell_get(struct of_phandle_args *clkspec, void *data)
 {
         return ERR_PTR(-ENOENT);
 }
-static inline unsigned int of_clk_get_parent_count(struct device_node *np)
-{
-        return 0;
-}
 static inline int of_clk_parent_fill(struct device_node *np,
                                      const char **parents, unsigned int size)
 {
         return 0;
 }
-static inline const char *of_clk_get_parent_name(struct device_node *np,
-                                                 int index)
-{
-        return NULL;
-}
 static inline int of_clk_detect_critical(struct device_node *np, int index,
                                           unsigned long *flags)
 {
         return 0;
 }
-static inline void of_clk_init(const struct of_device_id *matches) {}
 #endif /* CONFIG_OF */
 
 /*
@@ -999,10 +985,5 @@ static inline void clk_writel(u32 val, u32 __iomem *reg)
 
 #endif  /* platform dependent I/O accessors */
 
-#ifdef CONFIG_DEBUG_FS
-struct dentry *clk_debugfs_add_file(struct clk_hw *hw, char *name, umode_t mode,
-                                void *data, const struct file_operations *fops);
-#endif
-
 #endif /* CONFIG_COMMON_CLK */
 #endif /* CLK_PROVIDER_H */
diff --git a/include/linux/clk/davinci.h b/include/linux/clk/davinci.h
new file mode 100644
index 000000000000..8a7b5cd7eac0
--- /dev/null
+++ b/include/linux/clk/davinci.h
@@ -0,0 +1,40 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Clock drivers for TI DaVinci PLL and PSC controllers
+ *
+ * Copyright (C) 2018 David Lechner <david@lechnology.com>
+ */
+
+#ifndef __LINUX_CLK_DAVINCI_PLL_H___
+#define __LINUX_CLK_DAVINCI_PLL_H___
+
+#include <linux/device.h>
+#include <linux/regmap.h>
+
+/* function for registering clocks in early boot */
+
+#ifdef CONFIG_ARCH_DAVINCI_DA830
+int da830_pll_init(struct device *dev, void __iomem *base, struct regmap *cfgchip);
+#endif
+#ifdef CONFIG_ARCH_DAVINCI_DA850
+int da850_pll0_init(struct device *dev, void __iomem *base, struct regmap *cfgchip);
+#endif
+#ifdef CONFIG_ARCH_DAVINCI_DM355
+int dm355_pll1_init(struct device *dev, void __iomem *base, struct regmap *cfgchip);
+int dm355_psc_init(struct device *dev, void __iomem *base);
+#endif
+#ifdef CONFIG_ARCH_DAVINCI_DM365
+int dm365_pll1_init(struct device *dev, void __iomem *base, struct regmap *cfgchip);
+int dm365_pll2_init(struct device *dev, void __iomem *base, struct regmap *cfgchip);
+int dm365_psc_init(struct device *dev, void __iomem *base);
+#endif
+#ifdef CONFIG_ARCH_DAVINCI_DM644x
+int dm644x_pll1_init(struct device *dev, void __iomem *base, struct regmap *cfgchip);
+int dm644x_psc_init(struct device *dev, void __iomem *base);
+#endif
+#ifdef CONFIG_ARCH_DAVINCI_DM646x
+int dm646x_pll1_init(struct device *dev, void __iomem *base, struct regmap *cfgchip);
+int dm646x_psc_init(struct device *dev, void __iomem *base);
+#endif
+
+#endif /* __LINUX_CLK_DAVINCI_PLL_H___ */
diff --git a/include/linux/compat.h b/include/linux/compat.h
index b1a5562b3215..c68acc47da57 100644
--- a/include/linux/compat.h
+++ b/include/linux/compat.h
@@ -72,6 +72,9 @@
  */
 #ifndef COMPAT_SYSCALL_DEFINEx
 #define COMPAT_SYSCALL_DEFINEx(x, name, ...)                                    \
+        __diag_push();                                                          \
+        __diag_ignore(GCC, 8, "-Wattribute-alias",                              \
+                      "Type aliasing is used to sanitize syscall arguments");\
         asmlinkage long compat_sys##name(__MAP(x,__SC_DECL,__VA_ARGS__));       \
         asmlinkage long compat_sys##name(__MAP(x,__SC_DECL,__VA_ARGS__))        \
                 __attribute__((alias(__stringify(__se_compat_sys##name))));     \
@@ -80,8 +83,11 @@
         asmlinkage long __se_compat_sys##name(__MAP(x,__SC_LONG,__VA_ARGS__));  \
         asmlinkage long __se_compat_sys##name(__MAP(x,__SC_LONG,__VA_ARGS__))   \
         {                                                                       \
-                return __do_compat_sys##name(__MAP(x,__SC_DELOUSE,__VA_ARGS__));\
+                long ret = __do_compat_sys##name(__MAP(x,__SC_DELOUSE,__VA_ARGS__));\
+                __MAP(x,__SC_TEST,__VA_ARGS__);                                 \
+                return ret;                                                     \
         }                                                                       \
+        __diag_pop();                                                           \
         static inline long __do_compat_sys##name(__MAP(x,__SC_DECL,__VA_ARGS__))
 #endif /* COMPAT_SYSCALL_DEFINEx */
 
diff --git a/include/linux/compiler-gcc.h b/include/linux/compiler-gcc.h
index f1a7492a5cc8..573f5a7d42d4 100644
--- a/include/linux/compiler-gcc.h
+++ b/include/linux/compiler-gcc.h
@@ -66,25 +66,40 @@
 #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
-#define __inline__ __inline__   __attribute__((always_inline,unused)) notrace
-#define __inline __inline       __attribute__((always_inline,unused)) notrace
+#define inline \
+        inline __attribute__((always_inline, unused)) notrace __gnu_inline
 #else
-/* A lot of inline functions can cause havoc with function tracing */
-#define inline inline           __attribute__((unused)) notrace
-#define __inline__ __inline__   __attribute__((unused)) notrace
-#define __inline __inline       __attribute__((unused)) notrace
+#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))
 
@@ -347,3 +362,28 @@
 #if GCC_VERSION >= 50100
 #define COMPILER_HAS_GENERIC_BUILTIN_OVERFLOW 1
 #endif
+
+/*
+ * Turn individual warnings and errors on and off locally, depending
+ * on version.
+ */
+#define __diag_GCC(version, severity, s) \
+        __diag_GCC_ ## version(__diag_GCC_ ## severity s)
+
+/* Severity used in pragma directives */
+#define __diag_GCC_ignore       ignored
+#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)
+#else
+#define __diag_GCC_8(s)
+#endif
diff --git a/include/linux/compiler_types.h b/include/linux/compiler_types.h
index 6b79a9bba9a7..a8ba6b04152c 100644
--- a/include/linux/compiler_types.h
+++ b/include/linux/compiler_types.h
@@ -271,4 +271,22 @@ struct ftrace_likely_data {
 # define __native_word(t) (sizeof(t) == sizeof(char) || sizeof(t) == sizeof(short) || sizeof(t) == sizeof(int) || sizeof(t) == sizeof(long))
 #endif
 
+#ifndef __diag
+#define __diag(string)
+#endif
+
+#ifndef __diag_GCC
+#define __diag_GCC(version, severity, string)
+#endif
+
+#define __diag_push()   __diag(push)
+#define __diag_pop()    __diag(pop)
+
+#define __diag_ignore(compiler, version, option, comment) \
+        __diag_ ## compiler(version, ignore, option)
+#define __diag_warn(compiler, version, option, comment) \
+        __diag_ ## compiler(version, warn, option)
+#define __diag_error(compiler, version, option, comment) \
+        __diag_ ## compiler(version, error, option)
+
 #endif /* __LINUX_COMPILER_TYPES_H */
diff --git a/include/linux/dax.h b/include/linux/dax.h
index 88504e87cd6c..deb0f663252f 100644
--- a/include/linux/dax.h
+++ b/include/linux/dax.h
@@ -20,6 +20,9 @@ struct dax_operations {
         /* copy_from_iter: required operation for fs-dax direct-i/o */
         size_t (*copy_from_iter)(struct dax_device *, pgoff_t, void *, size_t,
                         struct iov_iter *);
+        /* copy_to_iter: required operation for fs-dax direct-i/o */
+        size_t (*copy_to_iter)(struct dax_device *, pgoff_t, void *, size_t,
+                        struct iov_iter *);
 };
 
 extern struct attribute_group dax_attribute_group;
@@ -83,6 +86,8 @@ static inline void fs_put_dax(struct dax_device *dax_dev)
 struct dax_device *fs_dax_get_by_bdev(struct block_device *bdev);
 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);
 #else
 static inline bool bdev_dax_supported(struct block_device *bdev,
                 int blocksize)
@@ -104,6 +109,11 @@ static inline struct dax_device *fs_dax_get_by_bdev(struct block_device *bdev)
         return NULL;
 }
 
+static inline struct page *dax_layout_busy_page(struct address_space *mapping)
+{
+        return NULL;
+}
+
 static inline int dax_writeback_mapping_range(struct address_space *mapping,
                 struct block_device *bdev, struct writeback_control *wbc)
 {
@@ -119,11 +129,13 @@ long dax_direct_access(struct dax_device *dax_dev, pgoff_t pgoff, long nr_pages,
                 void **kaddr, pfn_t *pfn);
 size_t dax_copy_from_iter(struct dax_device *dax_dev, pgoff_t pgoff, void *addr,
                 size_t bytes, struct iov_iter *i);
+size_t dax_copy_to_iter(struct dax_device *dax_dev, pgoff_t pgoff, void *addr,
+                size_t bytes, struct iov_iter *i);
 void dax_flush(struct dax_device *dax_dev, void *addr, size_t size);
 
 ssize_t dax_iomap_rw(struct kiocb *iocb, struct iov_iter *iter,
                 const struct iomap_ops *ops);
-int dax_iomap_fault(struct vm_fault *vmf, enum page_entry_size pe_size,
+vm_fault_t dax_iomap_fault(struct vm_fault *vmf, enum page_entry_size pe_size,
                     pfn_t *pfnp, int *errp, const struct iomap_ops *ops);
 vm_fault_t dax_finish_sync_fault(struct vm_fault *vmf,
                 enum page_entry_size pe_size, pfn_t pfn);
diff --git a/include/linux/device-mapper.h b/include/linux/device-mapper.h
index 31fef7c34185..6fb0808e87c8 100644
--- a/include/linux/device-mapper.h
+++ b/include/linux/device-mapper.h
@@ -133,7 +133,7 @@ typedef int (*dm_busy_fn) (struct dm_target *ti);
  */
 typedef long (*dm_dax_direct_access_fn) (struct dm_target *ti, pgoff_t pgoff,
                 long nr_pages, void **kaddr, pfn_t *pfn);
-typedef size_t (*dm_dax_copy_from_iter_fn)(struct dm_target *ti, pgoff_t pgoff,
+typedef size_t (*dm_dax_copy_iter_fn)(struct dm_target *ti, pgoff_t pgoff,
                 void *addr, size_t bytes, struct iov_iter *i);
 #define PAGE_SECTORS (PAGE_SIZE / 512)
 
@@ -184,7 +184,8 @@ struct target_type {
         dm_iterate_devices_fn iterate_devices;
         dm_io_hints_fn io_hints;
         dm_dax_direct_access_fn direct_access;
-        dm_dax_copy_from_iter_fn dax_copy_from_iter;
+        dm_dax_copy_iter_fn dax_copy_from_iter;
+        dm_dax_copy_iter_fn dax_copy_to_iter;
 
         /* For internal device-mapper use. */
         struct list_head list;
diff --git a/include/linux/dma-contiguous.h b/include/linux/dma-contiguous.h
index b67bf6ac907d..3c5a4cb3eb95 100644
--- a/include/linux/dma-contiguous.h
+++ b/include/linux/dma-contiguous.h
@@ -48,7 +48,7 @@
  *   CMA should not be used by the device drivers directly. It is
  *   only a helper framework for dma-mapping subsystem.
  *
- *   For more information, see kernel-docs in drivers/base/dma-contiguous.c
+ *   For more information, see kernel-docs in kernel/dma/contiguous.c
  */
 
 #ifdef __KERNEL__
diff --git a/include/linux/dma/sprd-dma.h b/include/linux/dma/sprd-dma.h
new file mode 100644
index 000000000000..b0115e340fbc
--- /dev/null
+++ b/include/linux/dma/sprd-dma.h
@@ -0,0 +1,61 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+
+#ifndef _SPRD_DMA_H_
+#define _SPRD_DMA_H_
+
+#define SPRD_DMA_REQ_SHIFT 16
+#define SPRD_DMA_FLAGS(req_mode, int_type) \
+        ((req_mode) << SPRD_DMA_REQ_SHIFT | (int_type))
+
+/*
+ * enum sprd_dma_req_mode: define the DMA request mode
+ * @SPRD_DMA_FRAG_REQ: fragment request mode
+ * @SPRD_DMA_BLK_REQ: block request mode
+ * @SPRD_DMA_TRANS_REQ: transaction request mode
+ * @SPRD_DMA_LIST_REQ: link-list request mode
+ *
+ * We have 4 types request mode: fragment mode, block mode, transaction mode
+ * and linklist mode. One transaction can contain several blocks, one block can
+ * contain several fragments. Link-list mode means we can save several DMA
+ * configuration into one reserved memory, then DMA can fetch each DMA
+ * configuration automatically to start transfer.
+ */
+enum sprd_dma_req_mode {
+        SPRD_DMA_FRAG_REQ,
+        SPRD_DMA_BLK_REQ,
+        SPRD_DMA_TRANS_REQ,
+        SPRD_DMA_LIST_REQ,
+};
+
+/*
+ * enum sprd_dma_int_type: define the DMA interrupt type
+ * @SPRD_DMA_NO_INT: do not need generate DMA interrupts.
+ * @SPRD_DMA_FRAG_INT: fragment done interrupt when one fragment request
+ * is done.
+ * @SPRD_DMA_BLK_INT: block done interrupt when one block request is done.
+ * @SPRD_DMA_BLK_FRAG_INT: block and fragment interrupt when one fragment
+ * or one block request is done.
+ * @SPRD_DMA_TRANS_INT: tansaction done interrupt when one transaction
+ * request is done.
+ * @SPRD_DMA_TRANS_FRAG_INT: transaction and fragment interrupt when one
+ * transaction request or fragment request is done.
+ * @SPRD_DMA_TRANS_BLK_INT: transaction and block interrupt when one
+ * transaction request or block request is done.
+ * @SPRD_DMA_LIST_INT: link-list done interrupt when one link-list request
+ * is done.
+ * @SPRD_DMA_CFGERR_INT: configure error interrupt when configuration is
+ * incorrect.
+ */
+enum sprd_dma_int_type {
+        SPRD_DMA_NO_INT,
+        SPRD_DMA_FRAG_INT,
+        SPRD_DMA_BLK_INT,
+        SPRD_DMA_BLK_FRAG_INT,
+        SPRD_DMA_TRANS_INT,
+        SPRD_DMA_TRANS_FRAG_INT,
+        SPRD_DMA_TRANS_BLK_INT,
+        SPRD_DMA_LIST_INT,
+        SPRD_DMA_CFGERR_INT,
+};
+
+#endif
diff --git a/include/linux/filter.h b/include/linux/filter.h
index 45fc0f5000d8..300baad62c88 100644
--- a/include/linux/filter.h
+++ b/include/linux/filter.h
@@ -19,6 +19,7 @@
 #include <linux/cryptohash.h>
 #include <linux/set_memory.h>
 #include <linux/kallsyms.h>
+#include <linux/if_vlan.h>
 
 #include <net/sch_generic.h>
 
@@ -469,15 +470,16 @@ struct sock_fprog_kern {
 };
 
 struct bpf_binary_header {
-        unsigned int pages;
-        u8 image[];
+        u32 pages;
+        /* Some arches need word alignment for their instructions */
+        u8 image[] __aligned(4);
 };
 
 struct bpf_prog {
         u16                     pages;          /* Number of allocated pages */
         u16                     jited:1,        /* Is our filter JIT'ed? */
                                 jit_requested:1,/* archs need to JIT the prog */
-                                locked:1,       /* Program image locked? */
+                                undo_set_mem:1, /* Passed set_memory_ro() checkpoint */
                                 gpl_compatible:1, /* Is filter GPL compatible? */
                                 cb_access:1,    /* Is control block accessed? */
                                 dst_needed:1,   /* Do we need dst entry? */
@@ -671,50 +673,27 @@ bpf_ctx_narrow_access_ok(u32 off, u32 size, u32 size_default)
 
 #define bpf_classic_proglen(fprog) (fprog->len * sizeof(fprog->filter[0]))
 
-#ifdef CONFIG_ARCH_HAS_SET_MEMORY
-static inline void bpf_prog_lock_ro(struct bpf_prog *fp)
-{
-        fp->locked = 1;
-        WARN_ON_ONCE(set_memory_ro((unsigned long)fp, fp->pages));
-}
-
-static inline void bpf_prog_unlock_ro(struct bpf_prog *fp)
-{
-        if (fp->locked) {
-                WARN_ON_ONCE(set_memory_rw((unsigned long)fp, fp->pages));
-                /* In case set_memory_rw() fails, we want to be the first
-                 * to crash here instead of some random place later on.
-                 */
-                fp->locked = 0;
-        }
-}
-
-static inline void bpf_jit_binary_lock_ro(struct bpf_binary_header *hdr)
-{
-        WARN_ON_ONCE(set_memory_ro((unsigned long)hdr, hdr->pages));
-}
-
-static inline void bpf_jit_binary_unlock_ro(struct bpf_binary_header *hdr)
-{
-        WARN_ON_ONCE(set_memory_rw((unsigned long)hdr, hdr->pages));
-}
-#else
 static inline void bpf_prog_lock_ro(struct bpf_prog *fp)
 {
+        fp->undo_set_mem = 1;
+        set_memory_ro((unsigned long)fp, fp->pages);
 }
 
 static inline void bpf_prog_unlock_ro(struct bpf_prog *fp)
 {
+        if (fp->undo_set_mem)
+                set_memory_rw((unsigned long)fp, fp->pages);
 }
 
 static inline void bpf_jit_binary_lock_ro(struct bpf_binary_header *hdr)
 {
+        set_memory_ro((unsigned long)hdr, hdr->pages);
 }
 
 static inline void bpf_jit_binary_unlock_ro(struct bpf_binary_header *hdr)
 {
+        set_memory_rw((unsigned long)hdr, hdr->pages);
 }
-#endif /* CONFIG_ARCH_HAS_SET_MEMORY */
 
 static inline struct bpf_binary_header *
 bpf_jit_binary_hdr(const struct bpf_prog *fp)
@@ -786,6 +765,21 @@ 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);
 
+static inline int __xdp_generic_ok_fwd_dev(struct sk_buff *skb,
+                                           struct net_device *fwd)
+{
+        unsigned int len;
+
+        if (unlikely(!(fwd->flags & IFF_UP)))
+                return -ENETDOWN;
+
+        len = fwd->mtu + fwd->hard_header_len + VLAN_HLEN;
+        if (skb->len > len)
+                return -EMSGSIZE;
+
+        return 0;
+}
+
 /* The pair of xdp_do_redirect and xdp_do_flush_map MUST be called in the
  * same cpu context. Further for best results no more than a single map
  * for the do_redirect/do_flush pair should be used. This limitation is
@@ -961,6 +955,9 @@ static inline void bpf_prog_kallsyms_del(struct bpf_prog *fp)
 }
 #endif /* CONFIG_BPF_JIT */
 
+void bpf_prog_kallsyms_del_subprogs(struct bpf_prog *fp);
+void bpf_prog_kallsyms_del_all(struct bpf_prog *fp);
+
 #define BPF_ANC         BIT(15)
 
 static inline bool bpf_needs_clear_a(const struct sock_filter *first)
diff --git a/include/linux/fs.h b/include/linux/fs.h
index 7207de8c4e9a..d78d146a98da 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -207,9 +207,9 @@ struct iattr {
         kuid_t          ia_uid;
         kgid_t          ia_gid;
         loff_t          ia_size;
-        struct timespec ia_atime;
-        struct timespec ia_mtime;
-        struct timespec ia_ctime;
+        struct timespec64 ia_atime;
+        struct timespec64 ia_mtime;
+        struct timespec64 ia_ctime;
 
         /*
          * Not an attribute, but an auxiliary info for filesystems wanting to
@@ -604,9 +604,9 @@ struct inode {
         };
         dev_t                   i_rdev;
         loff_t                  i_size;
-        struct timespec         i_atime;
-        struct timespec         i_mtime;
-        struct timespec         i_ctime;
+        struct timespec64       i_atime;
+        struct timespec64       i_mtime;
+        struct timespec64       i_ctime;
         spinlock_t              i_lock; /* i_blocks, i_bytes, maybe i_size */
         unsigned short          i_bytes;
         unsigned int            i_blkbits;
@@ -1093,7 +1093,7 @@ extern int vfs_lock_file(struct file *, unsigned int, struct file_lock *, struct
 extern int vfs_cancel_lock(struct file *filp, struct file_lock *fl);
 extern int locks_lock_inode_wait(struct inode *inode, struct file_lock *fl);
 extern int __break_lease(struct inode *inode, unsigned int flags, unsigned int type);
-extern void lease_get_mtime(struct inode *, struct timespec *time);
+extern void lease_get_mtime(struct inode *, struct timespec64 *time);
 extern int generic_setlease(struct file *, long, struct file_lock **, void **priv);
 extern int vfs_setlease(struct file *, long, struct file_lock **, void **);
 extern int lease_modify(struct file_lock *, int, struct list_head *);
@@ -1208,7 +1208,8 @@ static inline int __break_lease(struct inode *inode, unsigned int mode, unsigned
         return 0;
 }
 
-static inline void lease_get_mtime(struct inode *inode, struct timespec *time)
+static inline void lease_get_mtime(struct inode *inode,
+                                   struct timespec64 *time)
 {
         return;
 }
@@ -1478,7 +1479,8 @@ static inline void i_gid_write(struct inode *inode, gid_t gid)
         inode->i_gid = make_kgid(inode->i_sb->s_user_ns, gid);
 }
 
-extern struct timespec current_time(struct inode *inode);
+extern struct timespec64 timespec64_trunc(struct timespec64 t, unsigned gran);
+extern struct timespec64 current_time(struct inode *inode);
 
 /*
  * Snapshotting support.
@@ -1718,8 +1720,6 @@ struct file_operations {
         int (*iterate) (struct file *, struct dir_context *);
         int (*iterate_shared) (struct file *, struct dir_context *);
         __poll_t (*poll) (struct file *, struct poll_table_struct *);
-        struct wait_queue_head * (*get_poll_head)(struct file *, __poll_t);
-        __poll_t (*poll_mask) (struct file *, __poll_t);
         long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
         long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
         int (*mmap) (struct file *, struct vm_area_struct *);
@@ -1773,7 +1773,7 @@ struct inode_operations {
         ssize_t (*listxattr) (struct dentry *, char *, size_t);
         int (*fiemap)(struct inode *, struct fiemap_extent_info *, u64 start,
                       u64 len);
-        int (*update_time)(struct inode *, struct timespec *, int);
+        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);
@@ -2217,7 +2217,7 @@ extern int current_umask(void);
 
 extern void ihold(struct inode * inode);
 extern void iput(struct inode *);
-extern int generic_update_time(struct inode *, struct timespec *, int);
+extern int generic_update_time(struct inode *, struct timespec64 *, int);
 
 /* /sys/fs */
 extern struct kobject *fs_kobj;
diff --git a/include/linux/fscrypt_notsupp.h b/include/linux/fscrypt_notsupp.h
index 25b6492de6e5..ee8b43e4c15a 100644
--- a/include/linux/fscrypt_notsupp.h
+++ b/include/linux/fscrypt_notsupp.h
@@ -25,6 +25,10 @@ static inline bool fscrypt_dummy_context_enabled(struct inode *inode)
 }
 
 /* crypto.c */
+static inline void fscrypt_enqueue_decrypt_work(struct work_struct *work)
+{
+}
+
 static inline struct fscrypt_ctx *fscrypt_get_ctx(const struct inode *inode,
                                                   gfp_t gfp_flags)
 {
@@ -150,10 +154,13 @@ static inline bool fscrypt_match_name(const struct fscrypt_name *fname,
 }
 
 /* bio.c */
-static inline void fscrypt_decrypt_bio_pages(struct fscrypt_ctx *ctx,
-                                             struct bio *bio)
+static inline void fscrypt_decrypt_bio(struct bio *bio)
+{
+}
+
+static inline void fscrypt_enqueue_decrypt_bio(struct fscrypt_ctx *ctx,
+                                               struct bio *bio)
 {
-        return;
 }
 
 static inline void fscrypt_pullback_bio_page(struct page **page, bool restore)
diff --git a/include/linux/fscrypt_supp.h b/include/linux/fscrypt_supp.h
index 5080cb1bec4c..6456c6b2005f 100644
--- a/include/linux/fscrypt_supp.h
+++ b/include/linux/fscrypt_supp.h
@@ -59,6 +59,7 @@ static inline bool fscrypt_dummy_context_enabled(struct inode *inode)
 }
 
 /* crypto.c */
+extern void fscrypt_enqueue_decrypt_work(struct work_struct *);
 extern struct fscrypt_ctx *fscrypt_get_ctx(const struct inode *, gfp_t);
 extern void fscrypt_release_ctx(struct fscrypt_ctx *);
 extern struct page *fscrypt_encrypt_page(const struct inode *, struct page *,
@@ -174,7 +175,9 @@ static inline bool fscrypt_match_name(const struct fscrypt_name *fname,
 }
 
 /* bio.c */
-extern void fscrypt_decrypt_bio_pages(struct fscrypt_ctx *, struct bio *);
+extern void fscrypt_decrypt_bio(struct bio *);
+extern void fscrypt_enqueue_decrypt_bio(struct fscrypt_ctx *ctx,
+                                        struct bio *bio);
 extern void fscrypt_pullback_bio_page(struct page **, bool);
 extern int fscrypt_zeroout_range(const struct inode *, pgoff_t, sector_t,
                                  unsigned int);
diff --git a/include/linux/fsnotify_backend.h b/include/linux/fsnotify_backend.h
index e64c0294f50b..b38964a7a521 100644
--- a/include/linux/fsnotify_backend.h
+++ b/include/linux/fsnotify_backend.h
@@ -98,8 +98,6 @@ struct fsnotify_iter_info;
 struct fsnotify_ops {
         int (*handle_event)(struct fsnotify_group *group,
                             struct inode *inode,
-                            struct fsnotify_mark *inode_mark,
-                            struct fsnotify_mark *vfsmount_mark,
                             u32 mask, const void *data, int data_type,
                             const unsigned char *file_name, u32 cookie,
                             struct fsnotify_iter_info *iter_info);
@@ -201,6 +199,57 @@ struct fsnotify_group {
 #define FSNOTIFY_EVENT_PATH     1
 #define FSNOTIFY_EVENT_INODE    2
 
+enum fsnotify_obj_type {
+        FSNOTIFY_OBJ_TYPE_INODE,
+        FSNOTIFY_OBJ_TYPE_VFSMOUNT,
+        FSNOTIFY_OBJ_TYPE_COUNT,
+        FSNOTIFY_OBJ_TYPE_DETACHED = FSNOTIFY_OBJ_TYPE_COUNT
+};
+
+#define FSNOTIFY_OBJ_TYPE_INODE_FL      (1U << FSNOTIFY_OBJ_TYPE_INODE)
+#define FSNOTIFY_OBJ_TYPE_VFSMOUNT_FL   (1U << FSNOTIFY_OBJ_TYPE_VFSMOUNT)
+#define FSNOTIFY_OBJ_ALL_TYPES_MASK     ((1U << FSNOTIFY_OBJ_TYPE_COUNT) - 1)
+
+struct fsnotify_iter_info {
+        struct fsnotify_mark *marks[FSNOTIFY_OBJ_TYPE_COUNT];
+        unsigned int report_mask;
+        int srcu_idx;
+};
+
+static inline bool fsnotify_iter_should_report_type(
+                struct fsnotify_iter_info *iter_info, int type)
+{
+        return (iter_info->report_mask & (1U << type));
+}
+
+static inline void fsnotify_iter_set_report_type(
+                struct fsnotify_iter_info *iter_info, int type)
+{
+        iter_info->report_mask |= (1U << type);
+}
+
+static inline void fsnotify_iter_set_report_type_mark(
+                struct fsnotify_iter_info *iter_info, int type,
+                struct fsnotify_mark *mark)
+{
+        iter_info->marks[type] = mark;
+        iter_info->report_mask |= (1U << type);
+}
+
+#define FSNOTIFY_ITER_FUNCS(name, NAME) \
+static inline struct fsnotify_mark *fsnotify_iter_##name##_mark( \
+                struct fsnotify_iter_info *iter_info) \
+{ \
+        return (iter_info->report_mask & FSNOTIFY_OBJ_TYPE_##NAME##_FL) ? \
+                iter_info->marks[FSNOTIFY_OBJ_TYPE_##NAME] : NULL; \
+}
+
+FSNOTIFY_ITER_FUNCS(inode, INODE)
+FSNOTIFY_ITER_FUNCS(vfsmount, VFSMOUNT)
+
+#define fsnotify_foreach_obj_type(type) \
+        for (type = 0; type < FSNOTIFY_OBJ_TYPE_COUNT; type++)
+
 /*
  * Inode / vfsmount point to this structure which tracks all marks attached to
  * the inode / vfsmount. The reference to inode / vfsmount is held by this
@@ -209,11 +258,7 @@ struct fsnotify_group {
  */
 struct fsnotify_mark_connector {
         spinlock_t lock;
-#define FSNOTIFY_OBJ_TYPE_INODE         0x01
-#define FSNOTIFY_OBJ_TYPE_VFSMOUNT      0x02
-#define FSNOTIFY_OBJ_ALL_TYPES          (FSNOTIFY_OBJ_TYPE_INODE | \
-                                         FSNOTIFY_OBJ_TYPE_VFSMOUNT)
-        unsigned int flags;     /* Type of object [lock] */
+        unsigned int type;      /* Type of object [lock] */
         union { /* Object pointer [lock] */
                 struct inode *inode;
                 struct vfsmount *mnt;
@@ -356,7 +401,21 @@ extern struct fsnotify_mark *fsnotify_find_mark(
 extern int fsnotify_add_mark(struct fsnotify_mark *mark, struct inode *inode,
                              struct vfsmount *mnt, int allow_dups);
 extern int fsnotify_add_mark_locked(struct fsnotify_mark *mark,
-                                    struct inode *inode, struct vfsmount *mnt, int allow_dups);
+                                    struct inode *inode, struct vfsmount *mnt,
+                                    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);
+}
+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);
+}
 /* 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,
                                   struct fsnotify_group *group);
@@ -369,12 +428,12 @@ extern void fsnotify_clear_marks_by_group(struct fsnotify_group *group, unsigned
 /* run all the marks in a group, and clear all of the vfsmount marks */
 static inline void fsnotify_clear_vfsmount_marks_by_group(struct fsnotify_group *group)
 {
-        fsnotify_clear_marks_by_group(group, FSNOTIFY_OBJ_TYPE_VFSMOUNT);
+        fsnotify_clear_marks_by_group(group, FSNOTIFY_OBJ_TYPE_VFSMOUNT_FL);
 }
 /* run all the marks in a group, and clear all of the inode marks */
 static inline void fsnotify_clear_inode_marks_by_group(struct fsnotify_group *group)
 {
-        fsnotify_clear_marks_by_group(group, FSNOTIFY_OBJ_TYPE_INODE);
+        fsnotify_clear_marks_by_group(group, FSNOTIFY_OBJ_TYPE_INODE_FL);
 }
 extern void fsnotify_get_mark(struct fsnotify_mark *mark);
 extern void fsnotify_put_mark(struct fsnotify_mark *mark);
diff --git a/include/linux/ftrace.h b/include/linux/ftrace.h
index 9c3c9a319e48..ebb77674be90 100644
--- a/include/linux/ftrace.h
+++ b/include/linux/ftrace.h
@@ -1,7 +1,7 @@
 /* SPDX-License-Identifier: GPL-2.0 */
 /*
  * Ftrace header.  For implementation details beyond the random comments
- * scattered below, see: Documentation/trace/ftrace-design.txt
+ * scattered below, see: Documentation/trace/ftrace-design.rst
  */
 
 #ifndef _LINUX_FTRACE_H
@@ -223,7 +223,6 @@ extern enum ftrace_tracing_type_t ftrace_tracing_type;
  */
 int register_ftrace_function(struct ftrace_ops *ops);
 int unregister_ftrace_function(struct ftrace_ops *ops);
-void clear_ftrace_function(void);
 
 extern void ftrace_stub(unsigned long a0, unsigned long a1,
                         struct ftrace_ops *op, struct pt_regs *regs);
@@ -239,7 +238,6 @@ static inline int ftrace_nr_registered_ops(void)
 {
         return 0;
 }
-static inline void clear_ftrace_function(void) { }
 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) { }
diff --git a/include/linux/gpio/consumer.h b/include/linux/gpio/consumer.h
index dbd065963296..243112c7fa7d 100644
--- a/include/linux/gpio/consumer.h
+++ b/include/linux/gpio/consumer.h
@@ -116,7 +116,7 @@ int gpiod_get_raw_array_value(unsigned int array_size,
                               struct gpio_desc **desc_array,
                               int *value_array);
 void gpiod_set_raw_value(struct gpio_desc *desc, int value);
-void gpiod_set_raw_array_value(unsigned int array_size,
+int gpiod_set_raw_array_value(unsigned int array_size,
                                struct gpio_desc **desc_array,
                                int *value_array);
 
@@ -134,7 +134,7 @@ int gpiod_get_raw_array_value_cansleep(unsigned int array_size,
                                        struct gpio_desc **desc_array,
                                        int *value_array);
 void gpiod_set_raw_value_cansleep(struct gpio_desc *desc, int value);
-void gpiod_set_raw_array_value_cansleep(unsigned int array_size,
+int gpiod_set_raw_array_value_cansleep(unsigned int array_size,
                                         struct gpio_desc **desc_array,
                                         int *value_array);
 
@@ -369,12 +369,13 @@ static inline void gpiod_set_raw_value(struct gpio_desc *desc, int value)
         /* GPIO can never have been requested */
         WARN_ON(1);
 }
-static inline void gpiod_set_raw_array_value(unsigned int array_size,
+static inline int gpiod_set_raw_array_value(unsigned int array_size,
                                              struct gpio_desc **desc_array,
                                              int *value_array)
 {
         /* GPIO can never have been requested */
         WARN_ON(1);
+        return 0;
 }
 
 static inline int gpiod_get_value_cansleep(const struct gpio_desc *desc)
@@ -423,12 +424,13 @@ static inline void gpiod_set_raw_value_cansleep(struct gpio_desc *desc,
         /* GPIO can never have been requested */
         WARN_ON(1);
 }
-static inline void gpiod_set_raw_array_value_cansleep(unsigned int array_size,
+static inline int gpiod_set_raw_array_value_cansleep(unsigned int array_size,
                                                 struct gpio_desc **desc_array,
                                                 int *value_array)
 {
         /* GPIO can never have been requested */
         WARN_ON(1);
+        return 0;
 }
 
 static inline int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce)
diff --git a/include/linux/gpio/machine.h b/include/linux/gpio/machine.h
index b2f2dc638463..daa44eac9241 100644
--- a/include/linux/gpio/machine.h
+++ b/include/linux/gpio/machine.h
@@ -39,6 +39,23 @@ struct gpiod_lookup_table {
         struct gpiod_lookup table[];
 };
 
+/**
+ * struct gpiod_hog - GPIO line hog table
+ * @chip_label: name of the chip the GPIO belongs to
+ * @chip_hwnum: hardware number (i.e. relative to the chip) of the GPIO
+ * @line_name: consumer name for the hogged line
+ * @lflags: mask of GPIO lookup flags
+ * @dflags: GPIO flags used to specify the direction and value
+ */
+struct gpiod_hog {
+        struct list_head list;
+        const char *chip_label;
+        u16 chip_hwnum;
+        const char *line_name;
+        enum gpio_lookup_flags lflags;
+        int dflags;
+};
+
 /*
  * Simple definition of a single GPIO under a con_id
  */
@@ -59,10 +76,23 @@ struct gpiod_lookup_table {
         .flags = _flags,                                                  \
 }
 
+/*
+ * Simple definition of a single GPIO hog in an array.
+ */
+#define GPIO_HOG(_chip_label, _chip_hwnum, _line_name, _lflags, _dflags)  \
+{                                                                         \
+        .chip_label = _chip_label,                                        \
+        .chip_hwnum = _chip_hwnum,                                        \
+        .line_name = _line_name,                                          \
+        .lflags = _lflags,                                                \
+        .dflags = _dflags,                                                \
+}
+
 #ifdef CONFIG_GPIOLIB
 void gpiod_add_lookup_table(struct gpiod_lookup_table *table);
 void gpiod_add_lookup_tables(struct gpiod_lookup_table **tables, size_t n);
 void gpiod_remove_lookup_table(struct gpiod_lookup_table *table);
+void gpiod_add_hogs(struct gpiod_hog *hogs);
 #else
 static inline
 void gpiod_add_lookup_table(struct gpiod_lookup_table *table) {}
@@ -70,6 +100,7 @@ static inline
 void gpiod_add_lookup_tables(struct gpiod_lookup_table **tables, size_t n) {}
 static inline
 void gpiod_remove_lookup_table(struct gpiod_lookup_table *table) {}
+static inline void gpiod_add_hogs(struct gpiod_hog *hogs) {}
 #endif
 
 #endif /* __LINUX_GPIO_MACHINE_H */
diff --git a/include/linux/hid.h b/include/linux/hid.h
index 773bcb1d4044..938d9ba6d7cd 100644
--- a/include/linux/hid.h
+++ b/include/linux/hid.h
@@ -894,6 +894,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/hwspinlock.h b/include/linux/hwspinlock.h
index 859d673d98c8..57537e67b468 100644
--- a/include/linux/hwspinlock.h
+++ b/include/linux/hwspinlock.h
@@ -1,18 +1,10 @@
+/* SPDX-License-Identifier: GPL-2.0 */
 /*
  * Hardware spinlock public header
  *
  * Copyright (C) 2010 Texas Instruments Incorporated - http://www.ti.com
  *
  * Contact: Ohad Ben-Cohen <ohad@wizery.com>
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms of the GNU General Public License version 2 as published
- * by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
  */
 
 #ifndef __LINUX_HWSPINLOCK_H
@@ -24,6 +16,7 @@
 /* hwspinlock mode argument */
 #define HWLOCK_IRQSTATE 0x01    /* Disable interrupts, save state */
 #define HWLOCK_IRQ      0x02    /* Disable interrupts, don't save state */
+#define HWLOCK_RAW      0x03
 
 struct device;
 struct device_node;
@@ -176,6 +169,25 @@ static inline int hwspin_trylock_irq(struct hwspinlock *hwlock)
 }
 
 /**
+ * hwspin_trylock_raw() - attempt to lock a specific hwspinlock
+ * @hwlock: an hwspinlock which we want to trylock
+ *
+ * This function attempts to lock an hwspinlock, and will immediately fail
+ * if the hwspinlock is already taken.
+ *
+ * Caution: User must protect the routine of getting hardware lock with mutex
+ * or spinlock to avoid dead-lock, that will let user can do some time-consuming
+ * or sleepable operations under the hardware lock.
+ *
+ * Returns 0 if we successfully locked the hwspinlock, -EBUSY if
+ * the hwspinlock was already taken, and -EINVAL if @hwlock is invalid.
+ */
+static inline int hwspin_trylock_raw(struct hwspinlock *hwlock)
+{
+        return __hwspin_trylock(hwlock, HWLOCK_RAW, NULL);
+}
+
+/**
  * hwspin_trylock() - attempt to lock a specific hwspinlock
  * @hwlock: an hwspinlock which we want to trylock
  *
@@ -243,6 +255,29 @@ int hwspin_lock_timeout_irq(struct hwspinlock *hwlock, unsigned int to)
 }
 
 /**
+ * hwspin_lock_timeout_raw() - lock an hwspinlock with timeout limit
+ * @hwlock: the hwspinlock to be locked
+ * @to: timeout value in msecs
+ *
+ * This function locks the underlying @hwlock. If the @hwlock
+ * is already taken, the function will busy loop waiting for it to
+ * be released, but give up when @timeout msecs have elapsed.
+ *
+ * Caution: User must protect the routine of getting hardware lock with mutex
+ * or spinlock to avoid dead-lock, that will let user can do some time-consuming
+ * or sleepable operations under the hardware lock.
+ *
+ * Returns 0 when the @hwlock was successfully taken, and an appropriate
+ * error code otherwise (most notably an -ETIMEDOUT if the @hwlock is still
+ * busy after @timeout msecs). The function will never sleep.
+ */
+static inline
+int hwspin_lock_timeout_raw(struct hwspinlock *hwlock, unsigned int to)
+{
+        return __hwspin_lock_timeout(hwlock, to, HWLOCK_RAW, NULL);
+}
+
+/**
  * hwspin_lock_timeout() - lock an hwspinlock with timeout limit
  * @hwlock: the hwspinlock to be locked
  * @to: timeout value in msecs
@@ -302,6 +337,21 @@ static inline void hwspin_unlock_irq(struct hwspinlock *hwlock)
 }
 
 /**
+ * hwspin_unlock_raw() - unlock hwspinlock
+ * @hwlock: a previously-acquired hwspinlock which we want to unlock
+ *
+ * This function will unlock a specific hwspinlock.
+ *
+ * @hwlock must be already locked (e.g. by hwspin_trylock()) before calling
+ * this function: it is a bug to call unlock on a @hwlock that is already
+ * unlocked.
+ */
+static inline void hwspin_unlock_raw(struct hwspinlock *hwlock)
+{
+        __hwspin_unlock(hwlock, HWLOCK_RAW, NULL);
+}
+
+/**
  * hwspin_unlock() - unlock hwspinlock
  * @hwlock: a previously-acquired hwspinlock which we want to unlock
  *
diff --git a/include/linux/hyperv.h b/include/linux/hyperv.h
index 11b5612dc066..3a3012f57be4 100644
--- a/include/linux/hyperv.h
+++ b/include/linux/hyperv.h
@@ -35,6 +35,7 @@
 #include <linux/device.h>
 #include <linux/mod_devicetable.h>
 #include <linux/interrupt.h>
+#include <linux/reciprocal_div.h>
 
 #define MAX_PAGE_BUFFER_COUNT                           32
 #define MAX_MULTIPAGE_BUFFER_COUNT                      32 /* 128K */
@@ -120,6 +121,7 @@ struct hv_ring_buffer {
 struct hv_ring_buffer_info {
         struct hv_ring_buffer *ring_buffer;
         u32 ring_size;                  /* Include the shared header */
+        struct reciprocal_value ring_size_div10_reciprocal;
         spinlock_t ring_lock;
 
         u32 ring_datasize;              /* < ring_size */
@@ -154,6 +156,16 @@ static inline u32 hv_get_bytes_to_write(const struct hv_ring_buffer_info *rbi)
         return write;
 }
 
+static inline u32 hv_get_avail_to_write_percent(
+                const struct hv_ring_buffer_info *rbi)
+{
+        u32 avail_write = hv_get_bytes_to_write(rbi);
+
+        return reciprocal_divide(
+                        (avail_write  << 3) + (avail_write << 1),
+                        rbi->ring_size_div10_reciprocal);
+}
+
 /*
  * VMBUS version is 32 bit entity broken up into
  * two 16 bit quantities: major_number. minor_number.
diff --git a/include/linux/i2c-pnx.h b/include/linux/i2c-pnx.h
deleted file mode 100644
index 5388326fbbff..000000000000
--- a/include/linux/i2c-pnx.h
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
- * Header file for I2C support on PNX010x/4008.
- *
- * Author: Dennis Kovalev <dkovalev@ru.mvista.com>
- *
- * 2004-2006 (c) MontaVista Software, Inc. This file is licensed under
- * the terms of the GNU General Public License version 2. This program
- * is licensed "as is" without any warranty of any kind, whether express
- * or implied.
- */
-
-#ifndef __I2C_PNX_H__
-#define __I2C_PNX_H__
-
-struct platform_device;
-struct clk;
-
-struct i2c_pnx_mif {
-        int                     ret;            /* Return value */
-        int                     mode;           /* Interface mode */
-        struct completion       complete;       /* I/O completion */
-        struct timer_list       timer;          /* Timeout */
-        u8 *                    buf;            /* Data buffer */
-        int                     len;            /* Length of data buffer */
-        int                     order;          /* RX Bytes to order via TX */
-};
-
-struct i2c_pnx_algo_data {
-        void __iomem            *ioaddr;
-        struct i2c_pnx_mif      mif;
-        int                     last;
-        struct clk              *clk;
-        struct i2c_adapter      adapter;
-        int                     irq;
-        u32                     timeout;
-};
-
-#endif /* __I2C_PNX_H__ */
diff --git a/include/linux/i2c.h b/include/linux/i2c.h
index 44ad14e016b5..254cd34eeae2 100644
--- a/include/linux/i2c.h
+++ b/include/linux/i2c.h
@@ -394,7 +394,6 @@ static inline bool i2c_detect_slave_mode(struct device *dev) { return false; }
  * @addr: stored in i2c_client.addr
  * @dev_name: Overrides the default <busnr>-<addr> dev_name if set
  * @platform_data: stored in i2c_client.dev.platform_data
- * @archdata: copied into i2c_client.dev.archdata
  * @of_node: pointer to OpenFirmware device node
  * @fwnode: device node supplied by the platform firmware
  * @properties: additional device properties for the device
@@ -419,7 +418,6 @@ struct i2c_board_info {
         unsigned short  addr;
         const char      *dev_name;
         void            *platform_data;
-        struct dev_archdata     *archdata;
         struct device_node *of_node;
         struct fwnode_handle *fwnode;
         const struct property_entry *properties;
@@ -903,6 +901,9 @@ extern const struct of_device_id
 *i2c_of_match_device(const struct of_device_id *matches,
                      struct i2c_client *client);
 
+int of_i2c_get_board_info(struct device *dev, struct device_node *node,
+                          struct i2c_board_info *info);
+
 #else
 
 static inline struct i2c_client *of_find_i2c_device_by_node(struct device_node *node)
@@ -927,6 +928,13 @@ static inline const struct of_device_id
         return NULL;
 }
 
+static inline int of_i2c_get_board_info(struct device *dev,
+                                        struct device_node *node,
+                                        struct i2c_board_info *info)
+{
+        return -ENOTSUPP;
+}
+
 #endif /* CONFIG_OF */
 
 #if IS_ENABLED(CONFIG_ACPI)
diff --git a/include/linux/iio/adc/ad_sigma_delta.h b/include/linux/iio/adc/ad_sigma_delta.h
index 1fc7abd28b0b..730ead1a46df 100644
--- a/include/linux/iio/adc/ad_sigma_delta.h
+++ b/include/linux/iio/adc/ad_sigma_delta.h
@@ -127,7 +127,7 @@ void ad_sd_cleanup_buffer_and_trigger(struct iio_dev *indio_dev);
 int ad_sd_validate_trigger(struct iio_dev *indio_dev, struct iio_trigger *trig);
 
 #define __AD_SD_CHANNEL(_si, _channel1, _channel2, _address, _bits, \
-        _storagebits, _shift, _extend_name, _type) \
+        _storagebits, _shift, _extend_name, _type, _mask_all) \
         { \
                 .type = (_type), \
                 .differential = (_channel2 == -1 ? 0 : 1), \
@@ -139,7 +139,7 @@ int ad_sd_validate_trigger(struct iio_dev *indio_dev, struct iio_trigger *trig);
                 .info_mask_separate = BIT(IIO_CHAN_INFO_RAW) | \
                         BIT(IIO_CHAN_INFO_OFFSET), \
                 .info_mask_shared_by_type = BIT(IIO_CHAN_INFO_SCALE), \
-                .info_mask_shared_by_all = BIT(IIO_CHAN_INFO_SAMP_FREQ), \
+                .info_mask_shared_by_all = _mask_all, \
                 .scan_index = (_si), \
                 .scan_type = { \
                         .sign = 'u', \
@@ -153,25 +153,35 @@ int ad_sd_validate_trigger(struct iio_dev *indio_dev, struct iio_trigger *trig);
 #define AD_SD_DIFF_CHANNEL(_si, _channel1, _channel2, _address, _bits, \
         _storagebits, _shift) \
         __AD_SD_CHANNEL(_si, _channel1, _channel2, _address, _bits, \
-                _storagebits, _shift, NULL, IIO_VOLTAGE)
+                _storagebits, _shift, NULL, IIO_VOLTAGE, \
+                BIT(IIO_CHAN_INFO_SAMP_FREQ))
 
 #define AD_SD_SHORTED_CHANNEL(_si, _channel, _address, _bits, \
         _storagebits, _shift) \
         __AD_SD_CHANNEL(_si, _channel, _channel, _address, _bits, \
-                _storagebits, _shift, "shorted", IIO_VOLTAGE)
+                _storagebits, _shift, "shorted", IIO_VOLTAGE, \
+                BIT(IIO_CHAN_INFO_SAMP_FREQ))
 
 #define AD_SD_CHANNEL(_si, _channel, _address, _bits, \
         _storagebits, _shift) \
         __AD_SD_CHANNEL(_si, _channel, -1, _address, _bits, \
-                _storagebits, _shift, NULL, IIO_VOLTAGE)
+                _storagebits, _shift, NULL, IIO_VOLTAGE, \
+                 BIT(IIO_CHAN_INFO_SAMP_FREQ))
+
+#define AD_SD_CHANNEL_NO_SAMP_FREQ(_si, _channel, _address, _bits, \
+        _storagebits, _shift) \
+        __AD_SD_CHANNEL(_si, _channel, -1, _address, _bits, \
+                _storagebits, _shift, NULL, IIO_VOLTAGE, 0)
 
 #define AD_SD_TEMP_CHANNEL(_si, _address, _bits, _storagebits, _shift) \
         __AD_SD_CHANNEL(_si, 0, -1, _address, _bits, \
-                _storagebits, _shift, NULL, IIO_TEMP)
+                _storagebits, _shift, NULL, IIO_TEMP, \
+                BIT(IIO_CHAN_INFO_SAMP_FREQ))
 
 #define AD_SD_SUPPLY_CHANNEL(_si, _channel, _address, _bits, _storagebits, \
         _shift) \
         __AD_SD_CHANNEL(_si, _channel, -1, _address, _bits, \
-                _storagebits, _shift, "supply", IIO_VOLTAGE)
+                _storagebits, _shift, "supply", IIO_VOLTAGE, \
+                BIT(IIO_CHAN_INFO_SAMP_FREQ))
 
 #endif
diff --git a/include/linux/iio/adc/stm32-dfsdm-adc.h b/include/linux/iio/adc/stm32-dfsdm-adc.h
index e7dc7a542a4e..0da298b41737 100644
--- a/include/linux/iio/adc/stm32-dfsdm-adc.h
+++ b/include/linux/iio/adc/stm32-dfsdm-adc.h
@@ -9,6 +9,8 @@
 #ifndef STM32_DFSDM_ADC_H
 #define STM32_DFSDM_ADC_H
 
+#include <linux/iio/iio.h>
+
 int stm32_dfsdm_get_buff_cb(struct iio_dev *iio_dev,
                             int (*cb)(const void *data, size_t size,
                                       void *private),
diff --git a/include/linux/iio/buffer-dma.h b/include/linux/iio/buffer-dma.h
index 767467d886de..67c75372b691 100644
--- a/include/linux/iio/buffer-dma.h
+++ b/include/linux/iio/buffer-dma.h
@@ -141,7 +141,7 @@ int iio_dma_buffer_read(struct iio_buffer *buffer, size_t n,
         char __user *user_buffer);
 size_t iio_dma_buffer_data_available(struct iio_buffer *buffer);
 int iio_dma_buffer_set_bytes_per_datum(struct iio_buffer *buffer, size_t bpd);
-int iio_dma_buffer_set_length(struct iio_buffer *buffer, int length);
+int iio_dma_buffer_set_length(struct iio_buffer *buffer, unsigned int length);
 int iio_dma_buffer_request_update(struct iio_buffer *buffer);
 
 int iio_dma_buffer_init(struct iio_dma_buffer_queue *queue,
diff --git a/include/linux/iio/common/cros_ec_sensors_core.h b/include/linux/iio/common/cros_ec_sensors_core.h
new file mode 100644
index 000000000000..ce16445411ac
--- /dev/null
+++ b/include/linux/iio/common/cros_ec_sensors_core.h
@@ -0,0 +1,180 @@
+/*
+ * ChromeOS EC sensor hub
+ *
+ * Copyright (C) 2016 Google, Inc
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#ifndef __CROS_EC_SENSORS_CORE_H
+#define __CROS_EC_SENSORS_CORE_H
+
+#include <linux/iio/iio.h>
+#include <linux/irqreturn.h>
+#include <linux/mfd/cros_ec.h>
+
+enum {
+        CROS_EC_SENSOR_X,
+        CROS_EC_SENSOR_Y,
+        CROS_EC_SENSOR_Z,
+        CROS_EC_SENSOR_MAX_AXIS,
+};
+
+/* EC returns sensor values using signed 16 bit registers */
+#define CROS_EC_SENSOR_BITS 16
+
+/*
+ * 4 16 bit channels are allowed.
+ * Good enough for current sensors, they use up to 3 16 bit vectors.
+ */
+#define CROS_EC_SAMPLE_SIZE  (sizeof(s64) * 2)
+
+/* Minimum sampling period to use when device is suspending */
+#define CROS_EC_MIN_SUSPEND_SAMPLING_FREQUENCY 1000  /* 1 second */
+
+/**
+ * struct cros_ec_sensors_core_state - state data for EC sensors IIO driver
+ * @ec:                         cros EC device structure
+ * @cmd_lock:                   lock used to prevent simultaneous access to the
+ *                              commands.
+ * @msg:                        cros EC command structure
+ * @param:                      motion sensor parameters structure
+ * @resp:                       motion sensor response structure
+ * @type:                       type of motion sensor
+ * @loc:                        location where the motion sensor is placed
+ * @calib:                      calibration parameters. Note that trigger
+ *                              captured data will always provide the calibrated
+ *                              data
+ * @samples:                    static array to hold data from a single capture.
+ *                              For each channel we need 2 bytes, except for
+ *                              the timestamp. The timestamp is always last and
+ *                              is always 8-byte aligned.
+ * @read_ec_sensors_data:       function used for accessing sensors values
+ * @cuur_sampl_freq:            current sampling period
+ */
+struct cros_ec_sensors_core_state {
+        struct cros_ec_device *ec;
+        struct mutex cmd_lock;
+
+        struct cros_ec_command *msg;
+        struct ec_params_motion_sense param;
+        struct ec_response_motion_sense *resp;
+
+        enum motionsensor_type type;
+        enum motionsensor_location loc;
+
+        s16 calib[CROS_EC_SENSOR_MAX_AXIS];
+
+        u8 samples[CROS_EC_SAMPLE_SIZE];
+
+        int (*read_ec_sensors_data)(struct iio_dev *indio_dev,
+                                    unsigned long scan_mask, s16 *data);
+
+        int curr_sampl_freq;
+};
+
+/**
+ * cros_ec_sensors_read_lpc() - retrieve data from EC shared memory
+ * @indio_dev:  pointer to IIO device
+ * @scan_mask:  bitmap of the sensor indices to scan
+ * @data:       location to store data
+ *
+ * This is the safe function for reading the EC data. It guarantees that the
+ * data sampled was not modified by the EC while being read.
+ *
+ * Return: 0 on success, -errno on failure.
+ */
+int cros_ec_sensors_read_lpc(struct iio_dev *indio_dev, unsigned long scan_mask,
+                             s16 *data);
+
+/**
+ * cros_ec_sensors_read_cmd() - retrieve data using the EC command protocol
+ * @indio_dev:  pointer to IIO device
+ * @scan_mask:  bitmap of the sensor indices to scan
+ * @data:       location to store data
+ *
+ * Return: 0 on success, -errno on failure.
+ */
+int cros_ec_sensors_read_cmd(struct iio_dev *indio_dev, unsigned long scan_mask,
+                             s16 *data);
+
+struct platform_device;
+/**
+ * cros_ec_sensors_core_init() - basic initialization of the core structure
+ * @pdev:               platform device created for the sensors
+ * @indio_dev:          iio device structure of the device
+ * @physical_device:    true if the device refers to a physical device
+ *
+ * Return: 0 on success, -errno on failure.
+ */
+int cros_ec_sensors_core_init(struct platform_device *pdev,
+                              struct iio_dev *indio_dev, bool physical_device);
+
+/**
+ * cros_ec_sensors_capture() - the trigger handler function
+ * @irq:        the interrupt number.
+ * @p:          a pointer to the poll function.
+ *
+ * On a trigger event occurring, if the pollfunc is attached then this
+ * handler is called as a threaded interrupt (and hence may sleep). It
+ * is responsible for grabbing data from the device and pushing it into
+ * the associated buffer.
+ *
+ * Return: IRQ_HANDLED
+ */
+irqreturn_t cros_ec_sensors_capture(int irq, void *p);
+
+/**
+ * cros_ec_motion_send_host_cmd() - send motion sense host command
+ * @st:         pointer to state information for device
+ * @opt_length: optional length to reduce the response size, useful on the data
+ *              path. Otherwise, the maximal allowed response size is used
+ *
+ * When called, the sub-command is assumed to be set in param->cmd.
+ *
+ * Return: 0 on success, -errno on failure.
+ */
+int cros_ec_motion_send_host_cmd(struct cros_ec_sensors_core_state *st,
+                                 u16 opt_length);
+
+/**
+ * cros_ec_sensors_core_read() - function to request a value from the sensor
+ * @st:         pointer to state information for device
+ * @chan:       channel specification structure table
+ * @val:        will contain one element making up the returned value
+ * @val2:       will contain another element making up the returned value
+ * @mask:       specifies which values to be requested
+ *
+ * Return:      the type of value returned by the device
+ */
+int cros_ec_sensors_core_read(struct cros_ec_sensors_core_state *st,
+                              struct iio_chan_spec const *chan,
+                              int *val, int *val2, long mask);
+
+/**
+ * cros_ec_sensors_core_write() - function to write a value to the sensor
+ * @st:         pointer to state information for device
+ * @chan:       channel specification structure table
+ * @val:        first part of value to write
+ * @val2:       second part of value to write
+ * @mask:       specifies which values to write
+ *
+ * Return:      the type of value returned by the device
+ */
+int cros_ec_sensors_core_write(struct cros_ec_sensors_core_state *st,
+                               struct iio_chan_spec const *chan,
+                               int val, int val2, long mask);
+
+extern const struct dev_pm_ops cros_ec_sensors_pm_ops;
+
+/* List of extended channel specification for all sensors */
+extern const struct iio_chan_spec_ext_info cros_ec_sensors_ext_info[];
+
+#endif  /* __CROS_EC_SENSORS_CORE_H */
diff --git a/include/linux/iio/iio.h b/include/linux/iio/iio.h
index 11579fd4126e..a74cb177dc6f 100644
--- a/include/linux/iio/iio.h
+++ b/include/linux/iio/iio.h
@@ -183,18 +183,18 @@ struct iio_event_spec {
  * @address:            Driver specific identifier.
  * @scan_index:         Monotonic index to give ordering in scans when read
  *                      from a buffer.
- * @scan_type:          sign:           's' or 'u' to specify signed or unsigned
- *                      realbits:       Number of valid bits of data
- *                      storagebits:    Realbits + padding
- *                      shift:          Shift right by this before masking out
- *                                      realbits.
- *                      repeat:         Number of times real/storage bits
- *                                      repeats. When the repeat element is
- *                                      more than 1, then the type element in
- *                                      sysfs will show a repeat value.
- *                                      Otherwise, the number of repetitions is
- *                                      omitted.
- *                      endianness:     little or big endian
+ * @scan_type:          struct describing the scan type
+ * @scan_type.sign:             's' or 'u' to specify signed or unsigned
+ * @scan_type.realbits:         Number of valid bits of data
+ * @scan_type.storagebits:      Realbits + padding
+ * @scan_type.shift:            Shift right by this before masking out
+ *                              realbits.
+ * @scan_type.repeat:           Number of times real/storage bits repeats.
+ *                              When the repeat element is more than 1, then
+ *                              the type element in sysfs will show a repeat
+ *                              value. Otherwise, the number of repetitions
+ *                              is omitted.
+ * @scan_type.endianness:       little or big endian
  * @info_mask_separate: What information is to be exported that is specific to
  *                      this channel.
  * @info_mask_separate_available: What availability information is to be
diff --git a/include/linux/input/mt.h b/include/linux/input/mt.h
index d7188de4db96..3f4bf60b0bb5 100644
--- a/include/linux/input/mt.h
+++ b/include/linux/input/mt.h
@@ -100,7 +100,7 @@ static inline bool input_is_mt_axis(int axis)
         return axis == ABS_MT_SLOT || input_is_mt_value(axis);
 }
 
-void input_mt_report_slot_state(struct input_dev *dev,
+bool input_mt_report_slot_state(struct input_dev *dev,
                                 unsigned int tool_type, bool active);
 
 void input_mt_report_finger_count(struct input_dev *dev, int count);
diff --git a/include/linux/intel-iommu.h b/include/linux/intel-iommu.h
index ef169d67df92..1df940196ab2 100644
--- a/include/linux/intel-iommu.h
+++ b/include/linux/intel-iommu.h
@@ -121,7 +121,6 @@
 #define ecap_srs(e)             ((e >> 31) & 0x1)
 #define ecap_ers(e)             ((e >> 30) & 0x1)
 #define ecap_prs(e)             ((e >> 29) & 0x1)
-#define ecap_broken_pasid(e)    ((e >> 28) & 0x1)
 #define ecap_dis(e)             ((e >> 27) & 0x1)
 #define ecap_nest(e)            ((e >> 26) & 0x1)
 #define ecap_mts(e)             ((e >> 25) & 0x1)
diff --git a/include/linux/irq.h b/include/linux/irq.h
index b2067083aa94..201de12a9957 100644
--- a/include/linux/irq.h
+++ b/include/linux/irq.h
@@ -503,6 +503,7 @@ struct irq_chip {
  * IRQCHIP_SKIP_SET_WAKE:       Skip chip.irq_set_wake(), for this irq chip
  * IRQCHIP_ONESHOT_SAFE:        One shot does not require mask/unmask
  * IRQCHIP_EOI_THREADED:        Chip requires eoi() on unmask in threaded mode
+ * IRQCHIP_SUPPORTS_LEVEL_MSI   Chip can provide two doorbells for Level MSIs
  */
 enum {
         IRQCHIP_SET_TYPE_MASKED         = (1 <<  0),
@@ -552,7 +553,12 @@ extern int irq_affinity_online_cpu(unsigned int cpu);
 #endif
 
 #if defined(CONFIG_SMP) && defined(CONFIG_GENERIC_PENDING_IRQ)
-void irq_move_irq(struct irq_data *data);
+void __irq_move_irq(struct irq_data *data);
+static inline void irq_move_irq(struct irq_data *data)
+{
+        if (unlikely(irqd_is_setaffinity_pending(data)))
+                __irq_move_irq(data);
+}
 void irq_move_masked_irq(struct irq_data *data);
 void irq_force_complete_move(struct irq_desc *desc);
 #else
diff --git a/include/linux/irqdesc.h b/include/linux/irqdesc.h
index 25b33b664537..dd1e40ddac7d 100644
--- a/include/linux/irqdesc.h
+++ b/include/linux/irqdesc.h
@@ -145,11 +145,6 @@ static inline void *irq_desc_get_handler_data(struct irq_desc *desc)
         return desc->irq_common_data.handler_data;
 }
 
-static inline struct msi_desc *irq_desc_get_msi_desc(struct irq_desc *desc)
-{
-        return desc->irq_common_data.msi_desc;
-}
-
 /*
  * Architectures call this to let the generic IRQ layer
  * handle an interrupt.
diff --git a/include/linux/kcov.h b/include/linux/kcov.h
index 3ecf6f5e3a5f..b76a1807028d 100644
--- a/include/linux/kcov.h
+++ b/include/linux/kcov.h
@@ -22,13 +22,27 @@ enum kcov_mode {
         KCOV_MODE_TRACE_CMP = 3,
 };
 
+#define KCOV_IN_CTXSW   (1 << 30)
+
 void kcov_task_init(struct task_struct *t);
 void kcov_task_exit(struct task_struct *t);
 
+#define kcov_prepare_switch(t)                  \
+do {                                            \
+        (t)->kcov_mode |= KCOV_IN_CTXSW;        \
+} while (0)
+
+#define kcov_finish_switch(t)                   \
+do {                                            \
+        (t)->kcov_mode &= ~KCOV_IN_CTXSW;       \
+} while (0)
+
 #else
 
 static inline void kcov_task_init(struct task_struct *t) {}
 static inline void kcov_task_exit(struct task_struct *t) {}
+static inline void kcov_prepare_switch(struct task_struct *t) {}
+static inline void kcov_finish_switch(struct task_struct *t) {}
 
 #endif /* CONFIG_KCOV */
 #endif /* _LINUX_KCOV_H */
diff --git a/include/linux/kernel.h b/include/linux/kernel.h
index 7c4e8f1f72d8..941dc0a5a877 100644
--- a/include/linux/kernel.h
+++ b/include/linux/kernel.h
@@ -666,7 +666,7 @@ do {									\
  * your code. (Extra memory is used for special buffers that are
  * allocated when trace_printk() is used.)
  *
- * A little optization trick is done here. If there's only one
+ * A little optimization trick is done here. If there's only one
  * argument, there's no need to scan the string for printf formats.
  * The trace_puts() will suffice. But how can we take advantage of
  * using trace_puts() when trace_printk() has only one argument?
@@ -966,6 +966,22 @@ static inline void ftrace_dump(enum ftrace_dump_mode oops_dump_mode) { }
                          "pointer type mismatch in container_of()");    \
         ((type *)(__mptr - offsetof(type, member))); })
 
+/**
+ * container_of_safe - cast a member of a structure out to the containing structure
+ * @ptr:        the pointer to the member.
+ * @type:       the type of the container struct this is embedded in.
+ * @member:     the name of the member within the struct.
+ *
+ * If IS_ERR_OR_NULL(ptr), ptr is returned unchanged.
+ */
+#define container_of_safe(ptr, type, member) ({                         \
+        void *__mptr = (void *)(ptr);                                   \
+        BUILD_BUG_ON_MSG(!__same_type(*(ptr), ((type *)0)->member) &&   \
+                         !__same_type(*(ptr), void),                    \
+                         "pointer type mismatch in container_of()");    \
+        IS_ERR_OR_NULL(__mptr) ? ERR_CAST(__mptr) :                     \
+                ((type *)(__mptr - offsetof(type, member))); })
+
 /* Rebuild everything on CONFIG_FTRACE_MCOUNT_RECORD */
 #ifdef CONFIG_FTRACE_MCOUNT_RECORD
 # define REBUILD_DUE_TO_FTRACE_MCOUNT_RECORD
diff --git a/include/linux/kthread.h b/include/linux/kthread.h
index 2803264c512f..c1961761311d 100644
--- a/include/linux/kthread.h
+++ b/include/linux/kthread.h
@@ -62,7 +62,6 @@ void *kthread_probe_data(struct task_struct *k);
 int kthread_park(struct task_struct *k);
 void kthread_unpark(struct task_struct *k);
 void kthread_parkme(void);
-void kthread_park_complete(struct task_struct *k);
 
 int kthreadd(void *unused);
 extern struct task_struct *kthreadd_task;
diff --git a/include/linux/kvm_host.h b/include/linux/kvm_host.h
index 6d6e79c59e68..4ee7bc548a83 100644
--- a/include/linux/kvm_host.h
+++ b/include/linux/kvm_host.h
@@ -19,6 +19,7 @@
 #include <linux/preempt.h>
 #include <linux/msi.h>
 #include <linux/slab.h>
+#include <linux/vmalloc.h>
 #include <linux/rcupdate.h>
 #include <linux/ratelimit.h>
 #include <linux/err.h>
@@ -730,13 +731,16 @@ void kvm_put_guest_fpu(struct kvm_vcpu *vcpu);
 
 void kvm_flush_remote_tlbs(struct kvm *kvm);
 void kvm_reload_remote_mmus(struct kvm *kvm);
+
+bool kvm_make_vcpus_request_mask(struct kvm *kvm, unsigned int req,
+                                 unsigned long *vcpu_bitmap, cpumask_var_t tmp);
 bool kvm_make_all_cpus_request(struct kvm *kvm, unsigned int req);
 
 long kvm_arch_dev_ioctl(struct file *filp,
                         unsigned int ioctl, unsigned long arg);
 long kvm_arch_vcpu_ioctl(struct file *filp,
                          unsigned int ioctl, unsigned long arg);
-int kvm_arch_vcpu_fault(struct kvm_vcpu *vcpu, struct vm_fault *vmf);
+vm_fault_t kvm_arch_vcpu_fault(struct kvm_vcpu *vcpu, struct vm_fault *vmf);
 
 int kvm_vm_ioctl_check_extension(struct kvm *kvm, long ext);
 
@@ -808,6 +812,10 @@ bool kvm_arch_vcpu_in_kernel(struct kvm_vcpu *vcpu);
 int kvm_arch_vcpu_should_kick(struct kvm_vcpu *vcpu);
 
 #ifndef __KVM_HAVE_ARCH_VM_ALLOC
+/*
+ * All architectures that want to use vzalloc currently also
+ * need their own kvm_arch_alloc_vm implementation.
+ */
 static inline struct kvm *kvm_arch_alloc_vm(void)
 {
         return kzalloc(sizeof(struct kvm), GFP_KERNEL);
@@ -1270,4 +1278,13 @@ static inline long kvm_arch_vcpu_async_ioctl(struct file *filp,
 void kvm_arch_mmu_notifier_invalidate_range(struct kvm *kvm,
                 unsigned long start, unsigned long end);
 
+#ifdef CONFIG_HAVE_KVM_VCPU_RUN_PID_CHANGE
+int kvm_arch_vcpu_run_pid_change(struct kvm_vcpu *vcpu);
+#else
+static inline int kvm_arch_vcpu_run_pid_change(struct kvm_vcpu *vcpu)
+{
+        return 0;
+}
+#endif /* CONFIG_HAVE_KVM_VCPU_RUN_PID_CHANGE */
+
 #endif
diff --git a/include/linux/libata.h b/include/linux/libata.h
index 9db904344c75..8b8946dd63b9 100644
--- a/include/linux/libata.h
+++ b/include/linux/libata.h
@@ -1130,6 +1130,8 @@ extern void ata_sas_async_probe(struct ata_port *ap);
 extern int ata_sas_sync_probe(struct ata_port *ap);
 extern int ata_sas_port_init(struct ata_port *);
 extern int ata_sas_port_start(struct ata_port *ap);
+extern int ata_sas_tport_add(struct device *parent, struct ata_port *ap);
+extern void ata_sas_tport_delete(struct ata_port *ap);
 extern void ata_sas_port_stop(struct ata_port *ap);
 extern int ata_sas_slave_configure(struct scsi_device *, struct ata_port *);
 extern int ata_sas_queuecmd(struct scsi_cmnd *cmd, struct ata_port *ap);
diff --git a/include/linux/linkage.h b/include/linux/linkage.h
index f68db9e450eb..d7618c41f74c 100644
--- a/include/linux/linkage.h
+++ b/include/linux/linkage.h
@@ -24,16 +24,16 @@
 
 #ifndef cond_syscall
 #define cond_syscall(x) asm(                            \
-        ".weak " VMLINUX_SYMBOL_STR(x) "\n\t"           \
-        ".set  " VMLINUX_SYMBOL_STR(x) ","              \
-                 VMLINUX_SYMBOL_STR(sys_ni_syscall))
+        ".weak " __stringify(x) "\n\t"                  \
+        ".set  " __stringify(x) ","                     \
+                 __stringify(sys_ni_syscall))
 #endif
 
 #ifndef SYSCALL_ALIAS
 #define SYSCALL_ALIAS(alias, name) asm(                 \
-        ".globl " VMLINUX_SYMBOL_STR(alias) "\n\t"      \
-        ".set   " VMLINUX_SYMBOL_STR(alias) ","         \
-                  VMLINUX_SYMBOL_STR(name))
+        ".globl " __stringify(alias) "\n\t"             \
+        ".set   " __stringify(alias) ","                \
+                  __stringify(name))
 #endif
 
 #define __page_aligned_data     __section(.data..page_aligned) __aligned(PAGE_SIZE)
diff --git a/include/linux/log2.h b/include/linux/log2.h
index 41a1ae010993..2af7f77866d0 100644
--- a/include/linux/log2.h
+++ b/include/linux/log2.h
@@ -72,16 +72,13 @@ unsigned long __rounddown_pow_of_two(unsigned long n)
 }
 
 /**
- * ilog2 - log base 2 of 32-bit or a 64-bit unsigned value
+ * const_ilog2 - log base 2 of 32-bit or a 64-bit constant unsigned value
  * @n: parameter
  *
- * constant-capable log of base 2 calculation
- * - this can be used to initialise global variables from constant data, hence
- * the massive ternary operator construction
- *
- * selects the appropriately-sized optimised version depending on sizeof(n)
+ * Use this where sparse expects a true constant expression, e.g. for array
+ * indices.
  */
-#define ilog2(n)                                \
+#define const_ilog2(n)                          \
 (                                               \
         __builtin_constant_p(n) ? (             \
                 (n) < 2 ? 0 :                   \
@@ -147,10 +144,26 @@ unsigned long __rounddown_pow_of_two(unsigned long n)
                 (n) & (1ULL <<  4) ?  4 :       \
                 (n) & (1ULL <<  3) ?  3 :       \
                 (n) & (1ULL <<  2) ?  2 :       \
-                1 ) :                           \
-        (sizeof(n) <= 4) ?                      \
-        __ilog2_u32(n) :                        \
-        __ilog2_u64(n)                          \
+                1) :                            \
+        -1)
+
+/**
+ * ilog2 - log base 2 of 32-bit or a 64-bit unsigned value
+ * @n: parameter
+ *
+ * constant-capable log of base 2 calculation
+ * - this can be used to initialise global variables from constant data, hence
+ * the massive ternary operator construction
+ *
+ * selects the appropriately-sized optimised version depending on sizeof(n)
+ */
+#define ilog2(n) \
+( \
+        __builtin_constant_p(n) ?       \
+        const_ilog2(n) :                \
+        (sizeof(n) <= 4) ?              \
+        __ilog2_u32(n) :                \
+        __ilog2_u64(n)                  \
  )
 
 /**
diff --git a/include/linux/memcontrol.h b/include/linux/memcontrol.h
index 4f52ec755725..6c6fb116e925 100644
--- a/include/linux/memcontrol.h
+++ b/include/linux/memcontrol.h
@@ -53,6 +53,7 @@ enum memcg_memory_event {
         MEMCG_HIGH,
         MEMCG_MAX,
         MEMCG_OOM,
+        MEMCG_OOM_KILL,
         MEMCG_SWAP_MAX,
         MEMCG_SWAP_FAIL,
         MEMCG_NR_MEMORY_EVENTS,
@@ -720,11 +721,8 @@ static inline void count_memcg_event_mm(struct mm_struct *mm,
 
         rcu_read_lock();
         memcg = mem_cgroup_from_task(rcu_dereference(mm->owner));
-        if (likely(memcg)) {
+        if (likely(memcg))
                 count_memcg_events(memcg, idx, 1);
-                if (idx == OOM_KILL)
-                        cgroup_file_notify(&memcg->events_file);
-        }
         rcu_read_unlock();
 }
 
@@ -735,6 +733,21 @@ static inline void memcg_memory_event(struct mem_cgroup *memcg,
         cgroup_file_notify(&memcg->events_file);
 }
 
+static inline void memcg_memory_event_mm(struct mm_struct *mm,
+                                         enum memcg_memory_event event)
+{
+        struct mem_cgroup *memcg;
+
+        if (mem_cgroup_disabled())
+                return;
+
+        rcu_read_lock();
+        memcg = mem_cgroup_from_task(rcu_dereference(mm->owner));
+        if (likely(memcg))
+                memcg_memory_event(memcg, event);
+        rcu_read_unlock();
+}
+
 #ifdef CONFIG_TRANSPARENT_HUGEPAGE
 void mem_cgroup_split_huge_fixup(struct page *head);
 #endif
@@ -756,6 +769,11 @@ static inline void memcg_memory_event(struct mem_cgroup *memcg,
 {
 }
 
+static inline void memcg_memory_event_mm(struct mm_struct *mm,
+                                         enum memcg_memory_event event)
+{
+}
+
 static inline enum mem_cgroup_protection mem_cgroup_protected(
         struct mem_cgroup *root, struct mem_cgroup *memcg)
 {
diff --git a/include/linux/memory.h b/include/linux/memory.h
index 31ca3e28b0eb..a6ddefc60517 100644
--- a/include/linux/memory.h
+++ b/include/linux/memory.h
@@ -38,6 +38,7 @@ struct memory_block {
 
 int arch_get_memory_phys_device(unsigned long start_pfn);
 unsigned long memory_block_size_bytes(void);
+int set_memory_block_size_order(unsigned int order);
 
 /* These states are exposed to userspace as text strings in sysfs */
 #define MEM_ONLINE              (1<<0) /* exposed to userspace */
diff --git a/include/linux/memremap.h b/include/linux/memremap.h
index 74ea5e2310a8..f91f9e763557 100644
--- a/include/linux/memremap.h
+++ b/include/linux/memremap.h
@@ -1,7 +1,6 @@
 /* SPDX-License-Identifier: GPL-2.0 */
 #ifndef _LINUX_MEMREMAP_H_
 #define _LINUX_MEMREMAP_H_
-#include <linux/mm.h>
 #include <linux/ioport.h>
 #include <linux/percpu-refcount.h>
 
@@ -30,13 +29,6 @@ struct vmem_altmap {
  * Specialize ZONE_DEVICE memory into multiple types each having differents
  * usage.
  *
- * MEMORY_DEVICE_HOST:
- * Persistent device memory (pmem): struct page might be allocated in different
- * memory and architecture might want to perform special actions. It is similar
- * to regular memory, in that the CPU can access it transparently. However,
- * it is likely to have different bandwidth and latency than regular memory.
- * See Documentation/nvdimm/nvdimm.txt for more information.
- *
  * MEMORY_DEVICE_PRIVATE:
  * Device memory that is not directly addressable by the CPU: CPU can neither
  * read nor write private memory. In this case, we do still have struct pages
@@ -53,11 +45,19 @@ struct vmem_altmap {
  * driver can hotplug the device memory using ZONE_DEVICE and with that memory
  * type. Any page of a process can be migrated to such memory. However no one
  * should be allow to pin such memory so that it can always be evicted.
+ *
+ * MEMORY_DEVICE_FS_DAX:
+ * Host memory that has similar access semantics as System RAM i.e. DMA
+ * coherent and supports page pinning. In support of coordinating page
+ * pinning vs other operations MEMORY_DEVICE_FS_DAX arranges for a
+ * wakeup event whenever a page is unpinned and becomes idle. This
+ * wakeup is used to coordinate physical address space management (ex:
+ * fs truncate/hole punch) vs pinned pages (ex: device dma).
  */
 enum memory_type {
-        MEMORY_DEVICE_HOST = 0,
-        MEMORY_DEVICE_PRIVATE,
+        MEMORY_DEVICE_PRIVATE = 1,
         MEMORY_DEVICE_PUBLIC,
+        MEMORY_DEVICE_FS_DAX,
 };
 
 /*
@@ -129,8 +129,6 @@ struct dev_pagemap *get_dev_pagemap(unsigned long pfn,
 
 unsigned long vmem_altmap_offset(struct vmem_altmap *altmap);
 void vmem_altmap_free(struct vmem_altmap *altmap, unsigned long nr_pfns);
-
-static inline bool is_zone_device_page(const struct page *page);
 #else
 static inline void *devm_memremap_pages(struct device *dev,
                 struct dev_pagemap *pgmap)
@@ -161,20 +159,6 @@ static inline void vmem_altmap_free(struct vmem_altmap *altmap,
 }
 #endif /* CONFIG_ZONE_DEVICE */
 
-#if defined(CONFIG_DEVICE_PRIVATE) || defined(CONFIG_DEVICE_PUBLIC)
-static inline bool is_device_private_page(const struct page *page)
-{
-        return is_zone_device_page(page) &&
-                page->pgmap->type == MEMORY_DEVICE_PRIVATE;
-}
-
-static inline bool is_device_public_page(const struct page *page)
-{
-        return is_zone_device_page(page) &&
-                page->pgmap->type == MEMORY_DEVICE_PUBLIC;
-}
-#endif /* CONFIG_DEVICE_PRIVATE || CONFIG_DEVICE_PUBLIC */
-
 static inline void put_dev_pagemap(struct dev_pagemap *pgmap)
 {
         if (pgmap)
diff --git a/include/linux/mfd/abx500.h b/include/linux/mfd/abx500.h
index 44412c9d26e1..aa09414756db 100644
--- a/include/linux/mfd/abx500.h
+++ b/include/linux/mfd/abx500.h
@@ -271,7 +271,6 @@ struct abx500_bm_data {
         bool autopower_cfg;
         bool ac_enabled;
         bool usb_enabled;
-        bool usb_power_path;
         bool no_maintenance;
         bool capacity_scaling;
         bool chg_unknown_bat;
diff --git a/include/linux/mfd/abx500/ab8500-bm.h b/include/linux/mfd/abx500/ab8500-bm.h
index e63681eb6c62..c06daf3d490a 100644
--- a/include/linux/mfd/abx500/ab8500-bm.h
+++ b/include/linux/mfd/abx500/ab8500-bm.h
@@ -248,8 +248,6 @@ enum bup_vch_sel {
 #define BAT_CTRL_20U_ENA                0x02
 #define BAT_CTRL_18U_ENA                0x01
 #define BAT_CTRL_16U_ENA                0x02
-#define BAT_CTRL_60U_ENA                0x01
-#define BAT_CTRL_120U_ENA               0x02
 #define BAT_CTRL_CMP_ENA                0x04
 #define FORCE_BAT_CTRL_CMP_HIGH         0x08
 #define BAT_CTRL_PULL_UP_ENA            0x10
diff --git a/include/linux/mfd/abx500/ux500_chargalg.h b/include/linux/mfd/abx500/ux500_chargalg.h
index 67703f23e7ba..669894f434f5 100644
--- a/include/linux/mfd/abx500/ux500_chargalg.h
+++ b/include/linux/mfd/abx500/ux500_chargalg.h
@@ -25,8 +25,6 @@ struct ux500_charger_ops {
         int (*check_enable) (struct ux500_charger *, int, int);
         int (*kick_wd) (struct ux500_charger *);
         int (*update_curr) (struct ux500_charger *, int);
-        int (*pp_enable) (struct ux500_charger *, bool);
-        int (*pre_chg_enable) (struct ux500_charger *, bool);
 };
 
 /**
@@ -37,7 +35,6 @@ struct ux500_charger_ops {
  * @max_out_curr        maximum output charger current in mA
  * @enabled             indicates if this charger is used or not
  * @external            external charger unit (pm2xxx)
- * @power_path          USB power path support
  */
 struct ux500_charger {
         struct power_supply *psy;
@@ -47,7 +44,6 @@ struct ux500_charger {
         int wdt_refresh;
         bool enabled;
         bool external;
-        bool power_path;
 };
 
 extern struct blocking_notifier_head charger_notifier_list;
diff --git a/include/linux/mfd/arizona/pdata.h b/include/linux/mfd/arizona/pdata.h
index f72dc53848d7..0013075d4cda 100644
--- a/include/linux/mfd/arizona/pdata.h
+++ b/include/linux/mfd/arizona/pdata.h
@@ -56,6 +56,7 @@
 #define ARIZONA_MAX_PDM_SPK 2
 
 struct regulator_init_data;
+struct gpio_desc;
 
 struct arizona_micbias {
         int mV;                    /** Regulated voltage */
@@ -77,7 +78,7 @@ struct arizona_micd_range {
 };
 
 struct arizona_pdata {
-        int reset;      /** GPIO controlling /RESET, if any */
+        struct gpio_desc *reset;      /** GPIO controlling /RESET, if any */
 
         /** Regulator configuration for MICVDD */
         struct arizona_micsupp_pdata micvdd;
diff --git a/include/linux/mfd/as3711.h b/include/linux/mfd/as3711.h
index 34cc85864be5..ddd0b953323b 100644
--- a/include/linux/mfd/as3711.h
+++ b/include/linux/mfd/as3711.h
@@ -108,9 +108,9 @@ struct as3711_regulator_pdata {
 };
 
 struct as3711_bl_pdata {
-        const char *su1_fb;
+        bool su1_fb;
         int su1_max_uA;
-        const char *su2_fb;
+        bool su2_fb;
         int su2_max_uA;
         enum as3711_su2_feedback su2_feedback;
         enum as3711_su2_fbprot su2_fbprot;
diff --git a/include/linux/mfd/axp20x.h b/include/linux/mfd/axp20x.h
index 82bf7747b312..517e60eecbcb 100644
--- a/include/linux/mfd/axp20x.h
+++ b/include/linux/mfd/axp20x.h
@@ -592,11 +592,11 @@ enum axp806_irqs {
         AXP806_IRQ_DCDCC_V_LOW,
         AXP806_IRQ_DCDCD_V_LOW,
         AXP806_IRQ_DCDCE_V_LOW,
-        AXP806_IRQ_PWROK_LONG,
-        AXP806_IRQ_PWROK_SHORT,
+        AXP806_IRQ_POK_LONG,
+        AXP806_IRQ_POK_SHORT,
         AXP806_IRQ_WAKEUP,
-        AXP806_IRQ_PWROK_FALL,
-        AXP806_IRQ_PWROK_RISE,
+        AXP806_IRQ_POK_FALL,
+        AXP806_IRQ_POK_RISE,
 };
 
 enum axp809_irqs {
@@ -642,7 +642,7 @@ struct axp20x_dev {
         struct regmap_irq_chip_data     *regmap_irqc;
         long                            variant;
         int                             nr_cells;
-        struct mfd_cell                 *cells;
+        const struct mfd_cell           *cells;
         const struct regmap_config      *regmap_cfg;
         const struct regmap_irq_chip    *regmap_irq_chip;
 };
diff --git a/include/linux/mfd/bd9571mwv.h b/include/linux/mfd/bd9571mwv.h
index f0708ba4cbba..eb05569f752b 100644
--- a/include/linux/mfd/bd9571mwv.h
+++ b/include/linux/mfd/bd9571mwv.h
@@ -33,6 +33,11 @@
 #define BD9571MWV_I2C_MD2_E1_BIT_2              0x12
 
 #define BD9571MWV_BKUP_MODE_CNT                 0x20
+#define BD9571MWV_BKUP_MODE_CNT_KEEPON_MASK     GENMASK(3, 0)
+#define BD9571MWV_BKUP_MODE_CNT_KEEPON_DDR0     BIT(0)
+#define BD9571MWV_BKUP_MODE_CNT_KEEPON_DDR1     BIT(1)
+#define BD9571MWV_BKUP_MODE_CNT_KEEPON_DDR0C    BIT(2)
+#define BD9571MWV_BKUP_MODE_CNT_KEEPON_DDR1C    BIT(3)
 #define BD9571MWV_BKUP_MODE_STATUS              0x21
 #define BD9571MWV_BKUP_RECOVERY_CNT             0x22
 #define BD9571MWV_BKUP_CTRL_TIM_CNT             0x23
diff --git a/include/linux/mfd/cros_ec.h b/include/linux/mfd/cros_ec.h
index f09e9cf2e4ab..32421dfeb996 100644
--- a/include/linux/mfd/cros_ec.h
+++ b/include/linux/mfd/cros_ec.h
@@ -329,23 +329,7 @@ extern struct attribute_group cros_ec_vbc_attr_group;
 /* debugfs stuff */
 int cros_ec_debugfs_init(struct cros_ec_dev *ec);
 void cros_ec_debugfs_remove(struct cros_ec_dev *ec);
-
-/* ACPI GPE handler */
-#ifdef CONFIG_ACPI
-
-int cros_ec_acpi_install_gpe_handler(struct device *dev);
-void cros_ec_acpi_remove_gpe_handler(void);
-void cros_ec_acpi_clear_gpe(void);
-
-#else /* CONFIG_ACPI */
-
-static inline int cros_ec_acpi_install_gpe_handler(struct device *dev)
-{
-        return -ENODEV;
-}
-static inline void cros_ec_acpi_remove_gpe_handler(void) {}
-static inline void cros_ec_acpi_clear_gpe(void) {}
-
-#endif /* CONFIG_ACPI */
+void cros_ec_debugfs_suspend(struct cros_ec_dev *ec);
+void cros_ec_debugfs_resume(struct cros_ec_dev *ec);
 
 #endif /* __LINUX_MFD_CROS_EC_H */
diff --git a/include/linux/mfd/lp8788.h b/include/linux/mfd/lp8788.h
index 786bf6679a28..2010e0de3e34 100644
--- a/include/linux/mfd/lp8788.h
+++ b/include/linux/mfd/lp8788.h
@@ -182,20 +182,6 @@ struct lp8788_buck2_dvs {
 };
 
 /*
- * struct lp8788_ldo_enable_pin
- *
- *   Basically, all LDOs are enabled through the I2C commands.
- *   But ALDO 1 ~ 5, 7, DLDO 7, 9, 11 can be enabled by external gpio pins.
- *
- * @gpio         : gpio number which is used for enabling ldos
- * @init_state   : initial gpio state (ex. GPIOF_OUT_INIT_LOW)
- */
-struct lp8788_ldo_enable_pin {
-        int gpio;
-        int init_state;
-};
-
-/*
  * struct lp8788_chg_param
  * @addr         : charging control register address (range : 0x11 ~ 0x1C)
  * @val          : charging parameter value
@@ -288,7 +274,6 @@ struct lp8788_vib_platform_data {
  * @aldo_data    : regulator initial data for analog ldo
  * @buck1_dvs    : gpio configurations for buck1 dvs
  * @buck2_dvs    : gpio configurations for buck2 dvs
- * @ldo_pin      : gpio configurations for enabling LDOs
  * @chg_pdata    : platform data for charger driver
  * @alarm_sel    : rtc alarm selection (1 or 2)
  * @bl_pdata     : configurable data for backlight driver
@@ -306,7 +291,6 @@ struct lp8788_platform_data {
         struct regulator_init_data *aldo_data[LP8788_NUM_ALDOS];
         struct lp8788_buck1_dvs *buck1_dvs;
         struct lp8788_buck2_dvs *buck2_dvs;
-        struct lp8788_ldo_enable_pin *ldo_pin[EN_LDOS_MAX];
 
         /* charger */
         struct lp8788_charger_platform_data *chg_pdata;
diff --git a/include/linux/mfd/rave-sp.h b/include/linux/mfd/rave-sp.h
index 796fb9794c9e..fe0ce7bc59cf 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_SET_BACKLIGHT               = 0xA6,
         RAVE_SP_CMD_RESET                       = 0xA7,
         RAVE_SP_CMD_RESET_REASON                = 0xA8,
 
diff --git a/include/linux/mfd/samsung/core.h b/include/linux/mfd/samsung/core.h
index 5a23dd4df432..28f4ae76271d 100644
--- a/include/linux/mfd/samsung/core.h
+++ b/include/linux/mfd/samsung/core.h
@@ -39,6 +39,8 @@
 #define STEP_12_5_MV            12500
 #define STEP_6_25_MV            6250
 
+struct gpio_desc;
+
 enum sec_device_type {
         S5M8751X,
         S5M8763X,
@@ -151,7 +153,7 @@ struct sec_regulator_data {
         int                             id;
         struct regulator_init_data      *initdata;
         struct device_node              *reg_node;
-        int                             ext_control_gpio;
+        struct gpio_desc                *ext_control_gpiod;
 };
 
 /*
diff --git a/include/linux/mfd/stm32-timers.h b/include/linux/mfd/stm32-timers.h
index 2aadab6f34a1..067d14655c28 100644
--- a/include/linux/mfd/stm32-timers.h
+++ b/include/linux/mfd/stm32-timers.h
@@ -8,6 +8,8 @@
 #define _LINUX_STM32_GPTIMER_H_
 
 #include <linux/clk.h>
+#include <linux/dmaengine.h>
+#include <linux/dma-mapping.h>
 #include <linux/regmap.h>
 
 #define TIM_CR1         0x00    /* Control Register 1      */
@@ -27,6 +29,8 @@
 #define TIM_CCR3        0x3C    /* Capt/Comp Register 3    */
 #define TIM_CCR4        0x40    /* Capt/Comp Register 4    */
 #define TIM_BDTR        0x44    /* Break and Dead-Time Reg */
+#define TIM_DCR         0x48    /* DMA control register    */
+#define TIM_DMAR        0x4C    /* DMA register for transfer */
 
 #define TIM_CR1_CEN     BIT(0)  /* Counter Enable          */
 #define TIM_CR1_DIR     BIT(4)  /* Counter Direction       */
@@ -36,17 +40,35 @@
 #define TIM_SMCR_SMS    (BIT(0) | BIT(1) | BIT(2)) /* Slave mode selection */
 #define TIM_SMCR_TS     (BIT(4) | BIT(5) | BIT(6)) /* Trigger selection */
 #define TIM_DIER_UIE    BIT(0)  /* Update interrupt        */
+#define TIM_DIER_UDE    BIT(8)  /* Update DMA request Enable */
+#define TIM_DIER_CC1DE  BIT(9)  /* CC1 DMA request Enable  */
+#define TIM_DIER_CC2DE  BIT(10) /* CC2 DMA request Enable  */
+#define TIM_DIER_CC3DE  BIT(11) /* CC3 DMA request Enable  */
+#define TIM_DIER_CC4DE  BIT(12) /* CC4 DMA request Enable  */
+#define TIM_DIER_COMDE  BIT(13) /* COM DMA request Enable  */
+#define TIM_DIER_TDE    BIT(14) /* Trigger DMA request Enable */
 #define TIM_SR_UIF      BIT(0)  /* Update interrupt flag   */
 #define TIM_EGR_UG      BIT(0)  /* Update Generation       */
 #define TIM_CCMR_PE     BIT(3)  /* Channel Preload Enable  */
 #define TIM_CCMR_M1     (BIT(6) | BIT(5))  /* Channel PWM Mode 1 */
+#define TIM_CCMR_CC1S           (BIT(0) | BIT(1)) /* Capture/compare 1 sel */
+#define TIM_CCMR_IC1PSC         GENMASK(3, 2)   /* Input capture 1 prescaler */
+#define TIM_CCMR_CC2S           (BIT(8) | BIT(9)) /* Capture/compare 2 sel */
+#define TIM_CCMR_IC2PSC         GENMASK(11, 10) /* Input capture 2 prescaler */
+#define TIM_CCMR_CC1S_TI1       BIT(0)  /* IC1/IC3 selects TI1/TI3 */
+#define TIM_CCMR_CC1S_TI2       BIT(1)  /* IC1/IC3 selects TI2/TI4 */
+#define TIM_CCMR_CC2S_TI2       BIT(8)  /* IC2/IC4 selects TI2/TI4 */
+#define TIM_CCMR_CC2S_TI1       BIT(9)  /* IC2/IC4 selects TI1/TI3 */
 #define TIM_CCER_CC1E   BIT(0)  /* Capt/Comp 1  out Ena    */
 #define TIM_CCER_CC1P   BIT(1)  /* Capt/Comp 1  Polarity   */
 #define TIM_CCER_CC1NE  BIT(2)  /* Capt/Comp 1N out Ena    */
 #define TIM_CCER_CC1NP  BIT(3)  /* Capt/Comp 1N Polarity   */
 #define TIM_CCER_CC2E   BIT(4)  /* Capt/Comp 2  out Ena    */
+#define TIM_CCER_CC2P   BIT(5)  /* Capt/Comp 2  Polarity   */
 #define TIM_CCER_CC3E   BIT(8)  /* Capt/Comp 3  out Ena    */
+#define TIM_CCER_CC3P   BIT(9)  /* Capt/Comp 3  Polarity   */
 #define TIM_CCER_CC4E   BIT(12) /* Capt/Comp 4  out Ena    */
+#define TIM_CCER_CC4P   BIT(13) /* Capt/Comp 4  Polarity   */
 #define TIM_CCER_CCXE   (BIT(0) | BIT(4) | BIT(8) | BIT(12))
 #define TIM_BDTR_BKE    BIT(12) /* Break input enable      */
 #define TIM_BDTR_BKP    BIT(13) /* Break input polarity    */
@@ -56,8 +78,11 @@
 #define TIM_BDTR_BK2F   (BIT(20) | BIT(21) | BIT(22) | BIT(23))
 #define TIM_BDTR_BK2E   BIT(24) /* Break 2 input enable    */
 #define TIM_BDTR_BK2P   BIT(25) /* Break 2 input polarity  */
+#define TIM_DCR_DBA     GENMASK(4, 0)   /* DMA base addr */
+#define TIM_DCR_DBL     GENMASK(12, 8)  /* DMA burst len */
 
 #define MAX_TIM_PSC             0xFFFF
+#define MAX_TIM_ICPSC           0x3
 #define TIM_CR2_MMS_SHIFT       4
 #define TIM_CR2_MMS2_SHIFT      20
 #define TIM_SMCR_TS_SHIFT       4
@@ -65,9 +90,54 @@
 #define TIM_BDTR_BKF_SHIFT      16
 #define TIM_BDTR_BK2F_SHIFT     20
 
+enum stm32_timers_dmas {
+        STM32_TIMERS_DMA_CH1,
+        STM32_TIMERS_DMA_CH2,
+        STM32_TIMERS_DMA_CH3,
+        STM32_TIMERS_DMA_CH4,
+        STM32_TIMERS_DMA_UP,
+        STM32_TIMERS_DMA_TRIG,
+        STM32_TIMERS_DMA_COM,
+        STM32_TIMERS_MAX_DMAS,
+};
+
+/**
+ * struct stm32_timers_dma - STM32 timer DMA handling.
+ * @completion:         end of DMA transfer completion
+ * @phys_base:          control registers physical base address
+ * @lock:               protect DMA access
+ * @chan:               DMA channel in use
+ * @chans:              DMA channels available for this timer instance
+ */
+struct stm32_timers_dma {
+        struct completion completion;
+        phys_addr_t phys_base;
+        struct mutex lock;
+        struct dma_chan *chan;
+        struct dma_chan *chans[STM32_TIMERS_MAX_DMAS];
+};
+
 struct stm32_timers {
         struct clk *clk;
         struct regmap *regmap;
         u32 max_arr;
+        struct stm32_timers_dma dma; /* Only to be used by the parent */
 };
+
+#if IS_REACHABLE(CONFIG_MFD_STM32_TIMERS)
+int stm32_timers_dma_burst_read(struct device *dev, u32 *buf,
+                                enum stm32_timers_dmas id, u32 reg,
+                                unsigned int num_reg, unsigned int bursts,
+                                unsigned long tmo_ms);
+#else
+static inline int stm32_timers_dma_burst_read(struct device *dev, u32 *buf,
+                                              enum stm32_timers_dmas id,
+                                              u32 reg,
+                                              unsigned int num_reg,
+                                              unsigned int bursts,
+                                              unsigned long tmo_ms)
+{
+        return -ENODEV;
+}
+#endif
 #endif
diff --git a/include/linux/mfd/syscon/exynos4-pmu.h b/include/linux/mfd/syscon/exynos4-pmu.h
deleted file mode 100644
index 278b1b1549e9..000000000000
--- a/include/linux/mfd/syscon/exynos4-pmu.h
+++ /dev/null
@@ -1,21 +0,0 @@
-/*
- * Copyright (C) 2015 Samsung Electronics Co., Ltd.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- */
-
-#ifndef _LINUX_MFD_SYSCON_PMU_EXYNOS4_H_
-#define _LINUX_MFD_SYSCON_PMU_EXYNOS4_H_
-
-/* Exynos4 PMU register definitions */
-
-/* MIPI_PHYn_CONTROL register offset: n = 0..1 */
-#define EXYNOS4_MIPI_PHY_CONTROL(n)     (0x710 + (n) * 4)
-#define EXYNOS4_MIPI_PHY_ENABLE         (1 << 0)
-#define EXYNOS4_MIPI_PHY_SRESETN        (1 << 1)
-#define EXYNOS4_MIPI_PHY_MRESETN        (1 << 2)
-#define EXYNOS4_MIPI_PHY_RESET_MASK     (3 << 1)
-
-#endif /* _LINUX_MFD_SYSCON_PMU_EXYNOS4_H_ */
diff --git a/include/linux/mfd/syscon/exynos5-pmu.h b/include/linux/mfd/syscon/exynos5-pmu.h
deleted file mode 100644
index b4942a32b81d..000000000000
--- a/include/linux/mfd/syscon/exynos5-pmu.h
+++ /dev/null
@@ -1,19 +0,0 @@
-/*
- * Exynos5 SoC series Power Management Unit (PMU) register offsets
- * and bit definitions.
- *
- * Copyright (C) 2014 Samsung Electronics Co., Ltd.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- */
-
-#ifndef _LINUX_MFD_SYSCON_PMU_EXYNOS5_H_
-#define _LINUX_MFD_SYSCON_PMU_EXYNOS5_H_
-
-#define EXYNOS5_PHY_ENABLE                      BIT(0)
-#define EXYNOS5_MIPI_PHY_S_RESETN               BIT(1)
-#define EXYNOS5_MIPI_PHY_M_RESETN               BIT(2)
-
-#endif /* _LINUX_MFD_SYSCON_PMU_EXYNOS5_H_ */
diff --git a/include/linux/mfd/tps65090.h b/include/linux/mfd/tps65090.h
index 67d144b3b8f9..f05bf4a146e2 100644
--- a/include/linux/mfd/tps65090.h
+++ b/include/linux/mfd/tps65090.h
@@ -83,6 +83,8 @@ enum {
 #define TPS65090_MAX_REG        TPS65090_REG_AD_OUT2
 #define TPS65090_NUM_REGS       (TPS65090_MAX_REG + 1)
 
+struct gpio_desc;
+
 struct tps65090 {
         struct device           *dev;
         struct regmap           *rmap;
@@ -95,8 +97,8 @@ struct tps65090 {
  * @reg_init_data: The regulator init data.
  * @enable_ext_control: Enable extrenal control or not. Only available for
  *     DCDC1, DCDC2 and DCDC3.
- * @gpio: Gpio number if external control is enabled and controlled through
- *     gpio.
+ * @gpiod: Gpio descriptor if external control is enabled and controlled through
+ *     gpio
  * @overcurrent_wait_valid: True if the overcurrent_wait should be applied.
  * @overcurrent_wait: Value to set as the overcurrent wait time.  This is the
  *     actual bitfield value, not a time in ms (valid value are 0 - 3).
@@ -104,7 +106,7 @@ struct tps65090 {
 struct tps65090_regulator_plat_data {
         struct regulator_init_data *reg_init_data;
         bool enable_ext_control;
-        int gpio;
+        struct gpio_desc *gpiod;
         bool overcurrent_wait_valid;
         int overcurrent_wait;
 };
diff --git a/include/linux/mfd/tps65218.h b/include/linux/mfd/tps65218.h
index f069c518c0ed..c204d9a79436 100644
--- a/include/linux/mfd/tps65218.h
+++ b/include/linux/mfd/tps65218.h
@@ -205,10 +205,10 @@ enum tps65218_regulator_id {
         TPS65218_DCDC_4,
         TPS65218_DCDC_5,
         TPS65218_DCDC_6,
-        /* LS's */
-        TPS65218_LS_3,
         /* LDOs */
         TPS65218_LDO_1,
+        /* LS's */
+        TPS65218_LS_3,
 };
 
 #define TPS65218_MAX_REG_ID             TPS65218_LDO_1
diff --git a/include/linux/mfd/tps6586x.h b/include/linux/mfd/tps6586x.h
index 2fe68e481230..b19c2801a30e 100644
--- a/include/linux/mfd/tps6586x.h
+++ b/include/linux/mfd/tps6586x.h
@@ -18,6 +18,7 @@
 #define TPS658621A      0x15
 #define TPS658621CD     0x2c
 #define TPS658623       0x1b
+#define TPS658624       0x0a
 #define TPS658640       0x01
 #define TPS658640v2     0x02
 #define TPS658643       0x03
diff --git a/include/linux/mfd/tps68470.h b/include/linux/mfd/tps68470.h
index 44f9d9f647ed..ffe81127d91c 100644
--- a/include/linux/mfd/tps68470.h
+++ b/include/linux/mfd/tps68470.h
@@ -1,17 +1,6 @@
-/*
- * Copyright (c) 2017 Intel Corporation
- *
- * Functions to access TPS68470 power management chip.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation version 2.
- *
- * This program is distributed "as is" WITHOUT ANY WARRANTY of any
- * kind, whether express or implied; without even the implied warranty
- * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- */
+/* SPDX-License-Identifier: GPL-2.0 */
+/* Copyright (C) 2017 Intel Corporation */
+/* Functions to access TPS68470 power management chip. */
 
 #ifndef __LINUX_MFD_TPS68470_H
 #define __LINUX_MFD_TPS68470_H
diff --git a/include/linux/mlx5/eswitch.h b/include/linux/mlx5/eswitch.h
index d3c9db492b30..fab5121ffb8f 100644
--- a/include/linux/mlx5/eswitch.h
+++ b/include/linux/mlx5/eswitch.h
@@ -8,6 +8,8 @@
 
 #include <linux/mlx5/driver.h>
 
+#define MLX5_ESWITCH_MANAGER(mdev) MLX5_CAP_GEN(mdev, eswitch_manager)
+
 enum {
         SRIOV_NONE,
         SRIOV_LEGACY,
diff --git a/include/linux/mlx5/mlx5_ifc.h b/include/linux/mlx5/mlx5_ifc.h
index 27134c4fcb76..ac281f5ec9b8 100644
--- a/include/linux/mlx5/mlx5_ifc.h
+++ b/include/linux/mlx5/mlx5_ifc.h
@@ -922,7 +922,7 @@ struct mlx5_ifc_cmd_hca_cap_bits {
         u8         vnic_env_queue_counters[0x1];
         u8         ets[0x1];
         u8         nic_flow_table[0x1];
-        u8         eswitch_flow_table[0x1];
+        u8         eswitch_manager[0x1];
         u8         device_memory[0x1];
         u8         mcam_reg[0x1];
         u8         pcam_reg[0x1];
diff --git a/include/linux/mm.h b/include/linux/mm.h
index 4c3881b44ef1..a0fbb9ffe380 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -575,6 +575,11 @@ static inline void *kvmalloc_array(size_t n, size_t size, gfp_t flags)
         return kvmalloc(bytes, flags);
 }
 
+static inline void *kvcalloc(size_t n, size_t size, gfp_t flags)
+{
+        return kvmalloc_array(n, size, flags | __GFP_ZERO);
+}
+
 extern void kvfree(const void *addr);
 
 static inline atomic_t *compound_mapcount_ptr(struct page *page)
@@ -830,27 +835,65 @@ static inline bool is_zone_device_page(const struct page *page)
 }
 #endif
 
-#if defined(CONFIG_DEVICE_PRIVATE) || defined(CONFIG_DEVICE_PUBLIC)
-void put_zone_device_private_or_public_page(struct page *page);
-DECLARE_STATIC_KEY_FALSE(device_private_key);
-#define IS_HMM_ENABLED static_branch_unlikely(&device_private_key)
-static inline bool is_device_private_page(const struct page *page);
-static inline bool is_device_public_page(const struct page *page);
-#else /* CONFIG_DEVICE_PRIVATE || CONFIG_DEVICE_PUBLIC */
-static inline void put_zone_device_private_or_public_page(struct page *page)
+#ifdef CONFIG_DEV_PAGEMAP_OPS
+void dev_pagemap_get_ops(void);
+void dev_pagemap_put_ops(void);
+void __put_devmap_managed_page(struct page *page);
+DECLARE_STATIC_KEY_FALSE(devmap_managed_key);
+static inline bool put_devmap_managed_page(struct page *page)
 {
+        if (!static_branch_unlikely(&devmap_managed_key))
+                return false;
+        if (!is_zone_device_page(page))
+                return false;
+        switch (page->pgmap->type) {
+        case MEMORY_DEVICE_PRIVATE:
+        case MEMORY_DEVICE_PUBLIC:
+        case MEMORY_DEVICE_FS_DAX:
+                __put_devmap_managed_page(page);
+                return true;
+        default:
+                break;
+        }
+        return false;
 }
-#define IS_HMM_ENABLED 0
+
 static inline bool is_device_private_page(const struct page *page)
 {
-        return false;
+        return is_zone_device_page(page) &&
+                page->pgmap->type == MEMORY_DEVICE_PRIVATE;
 }
+
 static inline bool is_device_public_page(const struct page *page)
 {
+        return is_zone_device_page(page) &&
+                page->pgmap->type == MEMORY_DEVICE_PUBLIC;
+}
+
+#else /* CONFIG_DEV_PAGEMAP_OPS */
+static inline void dev_pagemap_get_ops(void)
+{
+}
+
+static inline void dev_pagemap_put_ops(void)
+{
+}
+
+static inline bool put_devmap_managed_page(struct page *page)
+{
+        return false;
+}
+
+static inline bool is_device_private_page(const struct page *page)
+{
         return false;
 }
-#endif /* CONFIG_DEVICE_PRIVATE || CONFIG_DEVICE_PUBLIC */
 
+static inline bool is_device_public_page(const struct page *page)
+{
+        return false;
+}
+#endif /* CONFIG_DEV_PAGEMAP_OPS */
 
 static inline void get_page(struct page *page)
 {
@@ -868,16 +911,13 @@ static inline void put_page(struct page *page)
         page = compound_head(page);
 
         /*
-         * For private device pages we need to catch refcount transition from
-         * 2 to 1, when refcount reach one it means the private device page is
-         * free and we need to inform the device driver through callback. See
+         * For devmap managed pages we need to catch refcount transition from
+         * 2 to 1, when refcount reach one it means the page is free and we
+         * need to inform the device driver through callback. See
          * include/linux/memremap.h and HMM for details.
          */
-        if (IS_HMM_ENABLED && unlikely(is_device_private_page(page) ||
-            unlikely(is_device_public_page(page)))) {
-                put_zone_device_private_or_public_page(page);
+        if (put_devmap_managed_page(page))
                 return;
-        }
 
         if (put_page_testzero(page))
                 __put_page(page);
diff --git a/include/linux/mod_devicetable.h b/include/linux/mod_devicetable.h
index 2014bd19f28e..96a71a648eed 100644
--- a/include/linux/mod_devicetable.h
+++ b/include/linux/mod_devicetable.h
@@ -501,6 +501,7 @@ enum dmi_field {
         DMI_PRODUCT_VERSION,
         DMI_PRODUCT_SERIAL,
         DMI_PRODUCT_UUID,
+        DMI_PRODUCT_SKU,
         DMI_PRODUCT_FAMILY,
         DMI_BOARD_VENDOR,
         DMI_BOARD_NAME,
diff --git a/include/linux/mtd/nand.h b/include/linux/mtd/nand.h
index 792ea5c26329..abe975c87b90 100644
--- a/include/linux/mtd/nand.h
+++ b/include/linux/mtd/nand.h
@@ -86,6 +86,7 @@ struct nand_pos {
  * @ooboffs: the OOB offset within the page
  * @ooblen: the number of OOB bytes to read from/write to this page
  * @oobbuf: buffer to store OOB data in or get OOB data from
+ * @mode: one of the %MTD_OPS_XXX mode
  *
  * This object is used to pass per-page I/O requests to NAND sub-layers. This
  * way all useful information are already formatted in a useful way and
@@ -106,6 +107,7 @@ struct nand_page_io_req {
                 const void *out;
                 void *in;
         } oobbuf;
+        int mode;
 };
 
 /**
@@ -599,6 +601,7 @@ static inline void nanddev_io_iter_init(struct nand_device *nand,
 {
         struct mtd_info *mtd = nanddev_to_mtd(nand);
 
+        iter->req.mode = req->mode;
         iter->req.dataoffs = nanddev_offs_to_pos(nand, offs, &iter->req.pos);
         iter->req.ooboffs = req->ooboffs;
         iter->oobbytes_per_page = mtd_oobavail(mtd, req);
diff --git a/include/linux/mtd/rawnand.h b/include/linux/mtd/rawnand.h
index 17c919436f48..3e8ec3b8a39c 100644
--- a/include/linux/mtd/rawnand.h
+++ b/include/linux/mtd/rawnand.h
@@ -28,7 +28,14 @@ struct nand_flash_dev;
 struct device_node;
 
 /* Scan and identify a NAND device */
-int nand_scan(struct mtd_info *mtd, int max_chips);
+int nand_scan_with_ids(struct mtd_info *mtd, int max_chips,
+                       struct nand_flash_dev *ids);
+
+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.
@@ -740,8 +747,9 @@ enum nand_data_interface_type {
 
 /**
  * struct nand_data_interface - NAND interface timing
- * @type:       type of the timing
- * @timings:    The timing, type according to @type
+ * @type:        type of the timing
+ * @timings:     The timing, type according to @type
+ * @timings.sdr: Use it when @type is %NAND_SDR_IFACE.
  */
 struct nand_data_interface {
         enum nand_data_interface_type type;
@@ -798,8 +806,9 @@ struct nand_op_addr_instr {
 /**
  * struct nand_op_data_instr - Definition of a data instruction
  * @len: number of data bytes to move
- * @in: buffer to fill when reading from the NAND chip
- * @out: buffer to read from when writing to the NAND chip
+ * @buf: buffer to fill
+ * @buf.in: buffer to fill when reading from the NAND chip
+ * @buf.out: buffer to read from when writing to the NAND chip
  * @force_8bit: force 8-bit access
  *
  * Please note that "in" and "out" are inverted from the ONFI specification
@@ -842,9 +851,13 @@ enum nand_op_instr_type {
 /**
  * struct nand_op_instr - Instruction object
  * @type: the instruction type
- * @cmd/@addr/@data/@waitrdy: extra data associated to the instruction.
- *                            You'll have to use the appropriate element
- *                            depending on @type
+ * @ctx:  extra data associated to the instruction. You'll have to use the
+ *        appropriate element depending on @type
+ * @ctx.cmd: use it if @type is %NAND_OP_CMD_INSTR
+ * @ctx.addr: use it if @type is %NAND_OP_ADDR_INSTR
+ * @ctx.data: use it if @type is %NAND_OP_DATA_IN_INSTR
+ *            or %NAND_OP_DATA_OUT_INSTR
+ * @ctx.waitrdy: use it if @type is %NAND_OP_WAITRDY_INSTR
  * @delay_ns: delay the controller should apply after the instruction has been
  *            issued on the bus. Most modern controllers have internal timings
  *            control logic, and in this case, the controller driver can ignore
@@ -1003,7 +1016,9 @@ struct nand_op_parser_data_constraints {
  * struct nand_op_parser_pattern_elem - One element of a pattern
  * @type: the instructuction type
  * @optional: whether this element of the pattern is optional or mandatory
- * @addr/@data: address or data constraint (number of cycles or data length)
+ * @ctx: address or data constraint
+ * @ctx.addr: address constraint (number of cycles)
+ * @ctx.data: data constraint (data length)
  */
 struct nand_op_parser_pattern_elem {
         enum nand_op_instr_type type;
@@ -1230,6 +1245,8 @@ int nand_op_parser_exec_op(struct nand_chip *chip,
  *                      devices.
  * @priv:               [OPTIONAL] pointer to private chip data
  * @manufacturer:       [INTERN] Contains manufacturer information
+ * @manufacturer.desc:  [INTERN] Contains manufacturer's description
+ * @manufacturer.priv:  [INTERN] Contains manufacturer private information
  */
 
 struct nand_chip {
diff --git a/include/linux/mtd/spi-nor.h b/include/linux/mtd/spi-nor.h
index de36969eb359..e60da0d34cc1 100644
--- a/include/linux/mtd/spi-nor.h
+++ b/include/linux/mtd/spi-nor.h
@@ -62,6 +62,8 @@
 #define SPINOR_OP_RDCR          0x35    /* Read configuration register */
 #define SPINOR_OP_RDFSR         0x70    /* Read flag status register */
 #define SPINOR_OP_CLFSR         0x50    /* Clear flag status register */
+#define SPINOR_OP_RDEAR         0xc8    /* Read Extended Address Register */
+#define SPINOR_OP_WREAR         0xc5    /* Write Extended Address Register */
 
 /* 4-byte address opcodes - used on Spansion and some Macronix flashes. */
 #define SPINOR_OP_READ_4B       0x13    /* Read data bytes (low frequency) */
diff --git a/include/linux/namei.h b/include/linux/namei.h
index a982bb7cd480..a78606e8e3df 100644
--- a/include/linux/namei.h
+++ b/include/linux/namei.h
@@ -81,6 +81,7 @@ extern void done_path_create(struct path *, struct dentry *);
 extern struct dentry *kern_path_locked(const char *, struct path *);
 extern int kern_path_mountpoint(int, const char *, struct path *, unsigned int);
 
+extern struct dentry *try_lookup_one_len(const char *, struct dentry *, int);
 extern struct dentry *lookup_one_len(const char *, struct dentry *, int);
 extern struct dentry *lookup_one_len_unlocked(const char *, struct dentry *, int);
 
diff --git a/include/linux/net.h b/include/linux/net.h
index 08b6eb964dd6..6554d3ba4396 100644
--- a/include/linux/net.h
+++ b/include/linux/net.h
@@ -147,7 +147,6 @@ struct proto_ops {
         int             (*getname)   (struct socket *sock,
                                       struct sockaddr *addr,
                                       int peer);
-        __poll_t        (*poll_mask) (struct socket *sock, __poll_t events);
         __poll_t        (*poll)      (struct file *file, struct socket *sock,
                                       struct poll_table_struct *wait);
         int             (*ioctl)     (struct socket *sock, unsigned int cmd,
diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h
index 3ec9850c7936..3d0cc0b5cec2 100644
--- a/include/linux/netdevice.h
+++ b/include/linux/netdevice.h
@@ -2789,11 +2789,31 @@ static inline void skb_gro_flush_final(struct sk_buff *skb, struct sk_buff **pp,
         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,
+                                               int flush,
+                                               struct gro_remcsum *grc)
+{
+        if (PTR_ERR(pp) != -EINPROGRESS) {
+                NAPI_GRO_CB(skb)->flush |= flush;
+                skb_gro_remcsum_cleanup(skb, grc);
+                skb->remcsum_offload = 0;
+        }
+}
 #else
 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,
+                                               int flush,
+                                               struct gro_remcsum *grc)
+{
+        NAPI_GRO_CB(skb)->flush |= flush;
+        skb_gro_remcsum_cleanup(skb, grc);
+        skb->remcsum_offload = 0;
+}
 #endif
 
 static inline int dev_hard_header(struct sk_buff *skb, struct net_device *dev,
diff --git a/include/linux/netfilter.h b/include/linux/netfilter.h
index 04551af2ff23..dd2052f0efb7 100644
--- a/include/linux/netfilter.h
+++ b/include/linux/netfilter.h
@@ -345,7 +345,7 @@ nf_nat_decode_session(struct sk_buff *skb, struct flowi *fl, u_int8_t family)
 
         rcu_read_lock();
         nat_hook = rcu_dereference(nf_nat_hook);
-        if (nat_hook->decode_session)
+        if (nat_hook && nat_hook->decode_session)
                 nat_hook->decode_session(skb, fl);
         rcu_read_unlock();
 #endif
diff --git a/include/linux/netfilter/ipset/ip_set_timeout.h b/include/linux/netfilter/ipset/ip_set_timeout.h
index bfb3531fd88a..8ce271e187b6 100644
--- a/include/linux/netfilter/ipset/ip_set_timeout.h
+++ b/include/linux/netfilter/ipset/ip_set_timeout.h
@@ -23,6 +23,9 @@
 /* Set is defined with timeout support: timeout value may be 0 */
 #define IPSET_NO_TIMEOUT        UINT_MAX
 
+/* Max timeout value, see msecs_to_jiffies() in jiffies.h */
+#define IPSET_MAX_TIMEOUT       (UINT_MAX >> 1)/MSEC_PER_SEC
+
 #define ip_set_adt_opt_timeout(opt, set)        \
 ((opt)->ext.timeout != IPSET_NO_TIMEOUT ? (opt)->ext.timeout : (set)->timeout)
 
@@ -32,11 +35,10 @@ ip_set_timeout_uget(struct nlattr *tb)
         unsigned int timeout = ip_set_get_h32(tb);
 
         /* Normalize to fit into jiffies */
-        if (timeout > UINT_MAX/MSEC_PER_SEC)
-                timeout = UINT_MAX/MSEC_PER_SEC;
+        if (timeout > IPSET_MAX_TIMEOUT)
+                timeout = IPSET_MAX_TIMEOUT;
 
-        /* Userspace supplied TIMEOUT parameter: adjust crazy size */
-        return timeout == IPSET_NO_TIMEOUT ? IPSET_NO_TIMEOUT - 1 : timeout;
+        return timeout;
 }
 
 static inline bool
@@ -65,8 +67,14 @@ ip_set_timeout_set(unsigned long *timeout, u32 value)
 static inline u32
 ip_set_timeout_get(const unsigned long *timeout)
 {
-        return *timeout == IPSET_ELEM_PERMANENT ? 0 :
-                jiffies_to_msecs(*timeout - jiffies)/MSEC_PER_SEC;
+        u32 t;
+
+        if (*timeout == IPSET_ELEM_PERMANENT)
+                return 0;
+
+        t = jiffies_to_msecs(*timeout - jiffies)/MSEC_PER_SEC;
+        /* Zero value in userspace means no timeout */
+        return t == 0 ? 1 : t;
 }
 
 #endif  /* __KERNEL__ */
diff --git a/include/linux/nfs_fs_sb.h b/include/linux/nfs_fs_sb.h
index 4e735be53e70..74ae3e1d19a0 100644
--- a/include/linux/nfs_fs_sb.h
+++ b/include/linux/nfs_fs_sb.h
@@ -28,6 +28,7 @@ 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 */
@@ -235,6 +236,7 @@ struct nfs_server {
 #define NFS_CAP_ACLS            (1U << 3)
 #define NFS_CAP_ATOMIC_OPEN     (1U << 4)
 /* #define NFS_CAP_CHANGE_ATTR  (1U << 5) */
+#define NFS_CAP_LGOPEN          (1U << 5)
 #define NFS_CAP_FILEID          (1U << 6)
 #define NFS_CAP_MODE            (1U << 7)
 #define NFS_CAP_NLINK           (1U << 8)
diff --git a/include/linux/nfs_xdr.h b/include/linux/nfs_xdr.h
index 34d28564ecf3..712eed156d09 100644
--- a/include/linux/nfs_xdr.h
+++ b/include/linux/nfs_xdr.h
@@ -259,6 +259,7 @@ struct nfs4_layoutget_args {
 
 struct nfs4_layoutget_res {
         struct nfs4_sequence_res seq_res;
+        int status;
         __u32 return_on_close;
         struct pnfs_layout_range range;
         __u32 type;
@@ -270,6 +271,7 @@ struct nfs4_layoutget {
         struct nfs4_layoutget_args args;
         struct nfs4_layoutget_res res;
         struct rpc_cred *cred;
+        unsigned callback_count;
         gfp_t gfp_flags;
 };
 
@@ -435,6 +437,7 @@ struct nfs_openargs {
         enum createmode4        createmode;
         const struct nfs4_label *label;
         umode_t                 umask;
+        struct nfs4_layoutget_args *lg_args;
 };
 
 struct nfs_openres {
@@ -457,6 +460,7 @@ struct nfs_openres {
         __u32                   access_request;
         __u32                   access_supported;
         __u32                   access_result;
+        struct nfs4_layoutget_res *lg_res;
 };
 
 /*
@@ -1434,6 +1438,8 @@ enum {
         NFS_IOHDR_EOF,
         NFS_IOHDR_REDO,
         NFS_IOHDR_STAT,
+        NFS_IOHDR_RESEND_PNFS,
+        NFS_IOHDR_RESEND_MDS,
 };
 
 struct nfs_io_completion;
@@ -1577,7 +1583,8 @@ struct nfs_rpc_ops {
         struct dentry *(*try_mount) (int, const char *, struct nfs_mount_info *,
                                      struct nfs_subversion *);
         int     (*getattr) (struct nfs_server *, struct nfs_fh *,
-                            struct nfs_fattr *, struct nfs4_label *);
+                            struct nfs_fattr *, struct nfs4_label *,
+                            struct inode *);
         int     (*setattr) (struct dentry *, struct nfs_fattr *,
                             struct iattr *);
         int     (*lookup)  (struct inode *, const struct qstr *,
@@ -1591,7 +1598,7 @@ struct nfs_rpc_ops {
         int     (*create)  (struct inode *, struct dentry *,
                             struct iattr *, int);
         int     (*remove)  (struct inode *, struct dentry *);
-        void    (*unlink_setup)  (struct rpc_message *, struct dentry *);
+        void    (*unlink_setup)  (struct rpc_message *, struct dentry *, struct inode *);
         void    (*unlink_rpc_prepare) (struct rpc_task *, struct nfs_unlinkdata *);
         int     (*unlink_done) (struct rpc_task *, struct inode *);
         void    (*rename_setup)  (struct rpc_message *msg,
@@ -1620,9 +1627,11 @@ struct nfs_rpc_ops {
                                     struct nfs_pgio_header *);
         void    (*read_setup)(struct nfs_pgio_header *, struct rpc_message *);
         int     (*read_done)(struct rpc_task *, struct nfs_pgio_header *);
-        void    (*write_setup)(struct nfs_pgio_header *, struct rpc_message *);
+        void    (*write_setup)(struct nfs_pgio_header *, struct rpc_message *,
+                                struct rpc_clnt **);
         int     (*write_done)(struct rpc_task *, struct nfs_pgio_header *);
-        void    (*commit_setup) (struct nfs_commit_data *, struct rpc_message *);
+        void    (*commit_setup) (struct nfs_commit_data *, struct rpc_message *,
+                                struct rpc_clnt **);
         void    (*commit_rpc_prepare)(struct rpc_task *, struct nfs_commit_data *);
         int     (*commit_done) (struct rpc_task *, struct nfs_commit_data *);
         int     (*lock)(struct file *, int, struct file_lock *);
diff --git a/include/linux/of_clk.h b/include/linux/of_clk.h
new file mode 100644
index 000000000000..b27da9f164cb
--- /dev/null
+++ b/include/linux/of_clk.h
@@ -0,0 +1,30 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * OF clock helpers
+ */
+
+#ifndef __LINUX_OF_CLK_H
+#define __LINUX_OF_CLK_H
+
+#if defined(CONFIG_COMMON_CLK) && defined(CONFIG_OF)
+
+unsigned int of_clk_get_parent_count(struct device_node *np);
+const char *of_clk_get_parent_name(struct device_node *np, int index);
+void of_clk_init(const struct of_device_id *matches);
+
+#else /* !CONFIG_COMMON_CLK || !CONFIG_OF */
+
+static inline unsigned int of_clk_get_parent_count(struct device_node *np)
+{
+        return 0;
+}
+static inline const char *of_clk_get_parent_name(struct device_node *np,
+                                                 int index)
+{
+        return NULL;
+}
+static inline void of_clk_init(const struct of_device_id *matches) {}
+
+#endif /* !CONFIG_COMMON_CLK || !CONFIG_OF */
+
+#endif /* __LINUX_OF_CLK_H */
diff --git a/include/linux/perf/arm_pmu.h b/include/linux/perf/arm_pmu.h
index 40036a57d072..ad5444491975 100644
--- a/include/linux/perf/arm_pmu.h
+++ b/include/linux/perf/arm_pmu.h
@@ -78,7 +78,7 @@ struct arm_pmu {
         struct pmu      pmu;
         cpumask_t       supported_cpus;
         char            *name;
-        irqreturn_t     (*handle_irq)(int irq_num, void *dev);
+        irqreturn_t     (*handle_irq)(struct arm_pmu *pmu);
         void            (*enable)(struct perf_event *event);
         void            (*disable)(struct perf_event *event);
         int             (*get_event_idx)(struct pmu_hw_events *hw_events,
diff --git a/include/linux/platform_data/gpio-dwapb.h b/include/linux/platform_data/gpio-dwapb.h
index 2dc7f4a8ab09..419cfacb4b42 100644
--- a/include/linux/platform_data/gpio-dwapb.h
+++ b/include/linux/platform_data/gpio-dwapb.h
@@ -19,7 +19,8 @@ struct dwapb_port_property {
         unsigned int    idx;
         unsigned int    ngpio;
         unsigned int    gpio_base;
-        unsigned int    irq;
+        int             irq[32];
+        bool            has_irq;
         bool            irq_shared;
 };
 
diff --git a/include/linux/i2c-gpio.h b/include/linux/platform_data/i2c-gpio.h
index 352c1426fd4d..352c1426fd4d 100644
--- a/include/linux/i2c-gpio.h
+++ b/include/linux/platform_data/i2c-gpio.h
diff --git a/include/linux/i2c-mux-gpio.h b/include/linux/platform_data/i2c-mux-gpio.h
index 4406108201fe..4406108201fe 100644
--- a/include/linux/i2c-mux-gpio.h
+++ b/include/linux/platform_data/i2c-mux-gpio.h
diff --git a/include/linux/i2c-ocores.h b/include/linux/platform_data/i2c-ocores.h
index 01edd96fe1f7..01edd96fe1f7 100644
--- a/include/linux/i2c-ocores.h
+++ b/include/linux/platform_data/i2c-ocores.h
diff --git a/include/linux/i2c-omap.h b/include/linux/platform_data/i2c-omap.h
index 3444265ee8ee..3444265ee8ee 100644
--- a/include/linux/i2c-omap.h
+++ b/include/linux/platform_data/i2c-omap.h
diff --git a/include/linux/i2c-pca-platform.h b/include/linux/platform_data/i2c-pca-platform.h
index c37329432a8e..c37329432a8e 100644
--- a/include/linux/i2c-pca-platform.h
+++ b/include/linux/platform_data/i2c-pca-platform.h
diff --git a/include/linux/i2c-xiic.h b/include/linux/platform_data/i2c-xiic.h
index 4f9f2256a97e..4f9f2256a97e 100644
--- a/include/linux/i2c-xiic.h
+++ b/include/linux/platform_data/i2c-xiic.h
diff --git a/include/linux/platform_data/media/ir-rx51.h b/include/linux/platform_data/media/ir-rx51.h
deleted file mode 100644
index 9d127aa648e7..000000000000
--- a/include/linux/platform_data/media/ir-rx51.h
+++ /dev/null
@@ -1,9 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-#ifndef _IR_RX51_H
-#define _IR_RX51_H
-
-struct ir_rx51_platform_data {
-        int(*set_max_mpu_wakeup_lat)(struct device *dev, long t);
-};
-
-#endif
diff --git a/include/linux/platform_data/mlxreg.h b/include/linux/platform_data/mlxreg.h
index 2744cff1b297..19f5cb618c55 100644
--- a/include/linux/platform_data/mlxreg.h
+++ b/include/linux/platform_data/mlxreg.h
@@ -58,11 +58,10 @@ struct mlxreg_hotplug_device {
  * struct mlxreg_core_data - attributes control data:
  *
  * @label: attribute label;
- * @label: attribute register offset;
  * @reg: attribute register;
  * @mask: attribute access mask;
- * @mode: access mode;
  * @bit: attribute effective bit;
+ * @mode: access mode;
  * @np - pointer to node platform associated with attribute;
  * @hpdev - hotplug device data;
  * @health_cntr: dynamic device health indication counter;
diff --git a/include/linux/platform_data/mtd-davinci.h b/include/linux/platform_data/mtd-davinci.h
index f1a2cf655bdb..1bbfa27cccb4 100644
--- a/include/linux/platform_data/mtd-davinci.h
+++ b/include/linux/platform_data/mtd-davinci.h
@@ -56,6 +56,16 @@ struct davinci_nand_pdata {		/* platform_data */
         uint32_t                mask_ale;
         uint32_t                mask_cle;
 
+        /*
+         * 0-indexed chip-select number of the asynchronous
+         * interface to which the NAND device has been connected.
+         *
+         * So, if you have NAND connected to CS3 of DA850, you
+         * will pass '1' here. Since the asynchronous interface
+         * on DA850 starts from CS2.
+         */
+        uint32_t                core_chipsel;
+
         /* for packages using two chipselects */
         uint32_t                mask_chipsel;
 
diff --git a/include/linux/platform_data/sc18is602.h b/include/linux/platform_data/sc18is602.h
index 997b06634152..18602cab7799 100644
--- a/include/linux/platform_data/sc18is602.h
+++ b/include/linux/platform_data/sc18is602.h
@@ -7,7 +7,7 @@
  * it under the terms of the GNU General Public License version 2 as
  * published by the Free Software Foundation.
  *
- * For further information, see the Documentation/spi/sc18is602 file.
+ * For further information, see the Documentation/spi/spi-sc18is602 file.
  */
 
 /**
diff --git a/include/linux/platform_data/shmob_drm.h b/include/linux/platform_data/shmob_drm.h
index 7c686d335c12..ee495d707f17 100644
--- a/include/linux/platform_data/shmob_drm.h
+++ b/include/linux/platform_data/shmob_drm.h
@@ -18,9 +18,6 @@
 
 #include <drm/drm_mode.h>
 
-struct sh_mobile_meram_cfg;
-struct sh_mobile_meram_info;
-
 enum shmob_drm_clk_source {
         SHMOB_DRM_CLK_BUS,
         SHMOB_DRM_CLK_PERIPHERAL,
@@ -93,7 +90,6 @@ struct shmob_drm_platform_data {
         struct shmob_drm_interface_data iface;
         struct shmob_drm_panel_data panel;
         struct shmob_drm_backlight_data backlight;
-        const struct sh_mobile_meram_cfg *meram;
 };
 
 #endif /* __SHMOB_DRM_H__ */
diff --git a/include/linux/platform_data/spi-imx.h b/include/linux/platform_data/spi-imx.h
index 6f012fefa1a2..328f670d10bd 100644
--- a/include/linux/platform_data/spi-imx.h
+++ b/include/linux/platform_data/spi-imx.h
@@ -5,24 +5,29 @@
 
 /*
  * struct spi_imx_master - device.platform_data for SPI controller devices.
- * @chipselect: Array of chipselects for this master. Numbers >= 0 mean gpio
- *              pins, numbers < 0 mean internal CSPI chipselects according
- *              to MXC_SPI_CS(). Normally you want to use gpio based chip
- *              selects as the CSPI module tries to be intelligent about
- *              when to assert the chipselect: The CSPI module deasserts the
- *              chipselect once it runs out of input data. The other problem
- *              is that it is not possible to mix between high active and low
- *              active chipselects on one single bus using the internal
- *              chipselects. Unfortunately Freescale decided to put some
+ * @chipselect: Array of chipselects for this master or NULL.  Numbers >= 0
+ *              mean GPIO pins, -ENOENT means internal CSPI chipselect
+ *              matching the position in the array.  E.g., if chipselect[1] =
+ *              -ENOENT then a SPI slave using chip select 1 will use the
+ *              native SS1 line of the CSPI.  Omitting the array will use
+ *              all native chip selects.
+
+ *              Normally you want to use gpio based chip selects as the CSPI
+ *              module tries to be intelligent about when to assert the
+ *              chipselect:  The CSPI module deasserts the chipselect once it
+ *              runs out of input data.  The other problem is that it is not
+ *              possible to mix between high active and low active chipselects
+ *              on one single bus using the internal chipselects.
+ *              Unfortunately, on some SoCs, Freescale decided to put some
  *              chipselects on dedicated pins which are not usable as gpios,
  *              so we have to support the internal chipselects.
- * @num_chipselect: ARRAY_SIZE(chipselect)
+ *
+ * @num_chipselect: If @chipselect is specified, ARRAY_SIZE(chipselect),
+ *                  otherwise the number of native chip selects.
  */
 struct spi_imx_master {
         int     *chipselect;
         int     num_chipselect;
 };
 
-#define MXC_SPI_CS(no)  ((no) - 32)
-
 #endif /* __MACH_SPI_H_*/
diff --git a/include/linux/platform_data/ti-aemif.h b/include/linux/platform_data/ti-aemif.h
index ac72e115093c..e6407bafcbf8 100644
--- a/include/linux/platform_data/ti-aemif.h
+++ b/include/linux/platform_data/ti-aemif.h
@@ -16,8 +16,33 @@
 
 #include <linux/of_platform.h>
 
+/**
+ * struct aemif_abus_data - Async bus configuration parameters.
+ *
+ * @cs - Chip-select number.
+ */
+struct aemif_abus_data {
+        u32 cs;
+};
+
+/**
+ * struct aemif_platform_data - Data to set up the TI aemif driver.
+ *
+ * @dev_lookup: of_dev_auxdata passed to of_platform_populate() for aemif
+ *              subdevices.
+ * @cs_offset: Lowest allowed chip-select number.
+ * @abus_data: Array of async bus configuration entries.
+ * @num_abus_data: Number of abus entries.
+ * @sub_devices: Array of platform subdevices.
+ * @num_sub_devices: Number of subdevices.
+ */
 struct aemif_platform_data {
         struct of_dev_auxdata *dev_lookup;
+        u32 cs_offset;
+        struct aemif_abus_data *abus_data;
+        size_t num_abus_data;
+        struct platform_device *sub_devices;
+        size_t num_sub_devices;
 };
 
 #endif /* __TI_DAVINCI_AEMIF_DATA_H__ */
diff --git a/include/linux/platform_data/ti-sysc.h b/include/linux/platform_data/ti-sysc.h
index 80ce28d40832..990aad477458 100644
--- a/include/linux/platform_data/ti-sysc.h
+++ b/include/linux/platform_data/ti-sysc.h
@@ -45,6 +45,7 @@ struct sysc_regbits {
         s8 emufree_shift;
 };
 
+#define SYSC_QUIRK_RESOURCE_PROVIDER    BIT(9)
 #define SYSC_QUIRK_LEGACY_IDLE          BIT(8)
 #define SYSC_QUIRK_RESET_STATUS         BIT(7)
 #define SYSC_QUIRK_NO_IDLE_ON_INIT      BIT(6)
diff --git a/include/linux/platform_data/tsl2772.h b/include/linux/platform_data/tsl2772.h
new file mode 100644
index 000000000000..f8ade15a35e2
--- /dev/null
+++ b/include/linux/platform_data/tsl2772.h
@@ -0,0 +1,101 @@
+/* SPDX-License-Identifier: GPL-2.0+ */
+/*
+ * Device driver for monitoring ambient light intensity (lux)
+ * and proximity (prox) within the TAOS TSL2772 family of devices.
+ *
+ * Copyright (c) 2012, TAOS Corporation.
+ * Copyright (c) 2017-2018 Brian Masney <masneyb@onstation.org>
+ */
+
+#ifndef __TSL2772_H
+#define __TSL2772_H
+
+struct tsl2772_lux {
+        unsigned int ch0;
+        unsigned int ch1;
+};
+
+/* Max number of segments allowable in LUX table */
+#define TSL2772_MAX_LUX_TABLE_SIZE              6
+/* The default LUX tables all have 3 elements.  */
+#define TSL2772_DEF_LUX_TABLE_SZ                3
+#define TSL2772_DEFAULT_TABLE_BYTES (sizeof(struct tsl2772_lux) * \
+                                     TSL2772_DEF_LUX_TABLE_SZ)
+
+/* Proximity diode to use */
+#define TSL2772_DIODE0                  0x01
+#define TSL2772_DIODE1                  0x02
+#define TSL2772_DIODE_BOTH              0x03
+
+/* LED Power */
+#define TSL2772_100_mA                  0x00
+#define TSL2772_50_mA                   0x01
+#define TSL2772_25_mA                   0x02
+#define TSL2772_13_mA                   0x03
+
+/**
+ * struct tsl2772_settings - Settings for the tsl2772 driver
+ *  @als_time:              Integration time of the ALS channel ADCs in 2.73 ms
+ *                          increments. Total integration time is
+ *                          (256 - als_time) * 2.73.
+ *  @als_gain:              Index into the tsl2772_als_gain array.
+ *  @als_gain_trim:         Default gain trim to account for aperture effects.
+ *  @wait_time:             Time between proximity and ALS cycles in 2.73
+ *                          periods.
+ *  @prox_time:             Integration time of the proximity ADC in 2.73 ms
+ *                          increments. Total integration time is
+ *                          (256 - prx_time) * 2.73.
+ *  @prox_gain:             Index into the tsl2772_prx_gain array.
+ *  @als_prox_config:       The value of the ALS / Proximity configuration
+ *                          register.
+ *  @als_cal_target:        Known external ALS reading for calibration.
+ *  @als_persistence:       H/W Filters, Number of 'out of limits' ALS readings.
+ *  @als_interrupt_en:      Enable/Disable ALS interrupts
+ *  @als_thresh_low:        CH0 'low' count to trigger interrupt.
+ *  @als_thresh_high:       CH0 'high' count to trigger interrupt.
+ *  @prox_persistence:      H/W Filters, Number of 'out of limits' proximity
+ *                          readings.
+ *  @prox_interrupt_en:     Enable/Disable proximity interrupts.
+ *  @prox_thres_low:        Low threshold proximity detection.
+ *  @prox_thres_high:       High threshold proximity detection.
+ *  @prox_pulse_count:      Number if proximity emitter pulses.
+ *  @prox_max_samples_cal:  The number of samples that are taken when performing
+ *                          a proximity calibration.
+ *  @prox_diode             Which diode(s) to use for driving the external
+ *                          LED(s) for proximity sensing.
+ *  @prox_power             The amount of power to use for the external LED(s).
+ */
+struct tsl2772_settings {
+        int als_time;
+        int als_gain;
+        int als_gain_trim;
+        int wait_time;
+        int prox_time;
+        int prox_gain;
+        int als_prox_config;
+        int als_cal_target;
+        u8 als_persistence;
+        bool als_interrupt_en;
+        int als_thresh_low;
+        int als_thresh_high;
+        u8 prox_persistence;
+        bool prox_interrupt_en;
+        int prox_thres_low;
+        int prox_thres_high;
+        int prox_pulse_count;
+        int prox_max_samples_cal;
+        int prox_diode;
+        int prox_power;
+};
+
+/**
+ * struct tsl2772_platform_data - Platform callback, glass and defaults
+ * @platform_lux_table:        Device specific glass coefficents
+ * @platform_default_settings: Device specific power on defaults
+ */
+struct tsl2772_platform_data {
+        struct tsl2772_lux platform_lux_table[TSL2772_MAX_LUX_TABLE_SIZE];
+        struct tsl2772_settings *platform_default_settings;
+};
+
+#endif /* __TSL2772_H */
diff --git a/include/linux/pm_domain.h b/include/linux/pm_domain.h
index 42e0d649e653..cb8d84090cfb 100644
--- a/include/linux/pm_domain.h
+++ b/include/linux/pm_domain.h
@@ -234,9 +234,11 @@ struct generic_pm_domain *of_genpd_remove_last(struct device_node *np);
 int of_genpd_parse_idle_states(struct device_node *dn,
                                struct genpd_power_state **states, int *n);
 unsigned int of_genpd_opp_to_performance_state(struct device *dev,
-                                struct device_node *opp_node);
+                                struct device_node *np);
 
 int genpd_dev_pm_attach(struct device *dev);
+struct device *genpd_dev_pm_attach_by_id(struct device *dev,
+                                         unsigned int index);
 #else /* !CONFIG_PM_GENERIC_DOMAINS_OF */
 static inline int of_genpd_add_provider_simple(struct device_node *np,
                                         struct generic_pm_domain *genpd)
@@ -272,9 +274,9 @@ static inline int of_genpd_parse_idle_states(struct device_node *dn,
 
 static inline unsigned int
 of_genpd_opp_to_performance_state(struct device *dev,
-                                  struct device_node *opp_node)
+                                  struct device_node *np)
 {
-        return -ENODEV;
+        return 0;
 }
 
 static inline int genpd_dev_pm_attach(struct device *dev)
@@ -282,6 +284,12 @@ static inline int genpd_dev_pm_attach(struct device *dev)
         return 0;
 }
 
+static inline struct device *genpd_dev_pm_attach_by_id(struct device *dev,
+                                                       unsigned int index)
+{
+        return NULL;
+}
+
 static inline
 struct generic_pm_domain *of_genpd_remove_last(struct device_node *np)
 {
@@ -291,6 +299,8 @@ struct generic_pm_domain *of_genpd_remove_last(struct device_node *np)
 
 #ifdef CONFIG_PM
 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);
 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
@@ -298,6 +308,11 @@ static inline int dev_pm_domain_attach(struct device *dev, bool power_on)
 {
         return 0;
 }
+static inline struct device *dev_pm_domain_attach_by_id(struct device *dev,
+                                                        unsigned int index)
+{
+        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/pm_runtime.h b/include/linux/pm_runtime.h
index db5dbbf7a48d..f0fc4700b6ff 100644
--- a/include/linux/pm_runtime.h
+++ b/include/linux/pm_runtime.h
@@ -56,7 +56,8 @@ extern void pm_runtime_update_max_time_suspended(struct device *dev,
                                                  s64 delta_ns);
 extern void pm_runtime_set_memalloc_noio(struct device *dev, bool enable);
 extern void pm_runtime_clean_up_links(struct device *dev);
-extern void pm_runtime_resume_suppliers(struct device *dev);
+extern void pm_runtime_get_suppliers(struct device *dev);
+extern void pm_runtime_put_suppliers(struct device *dev);
 extern void pm_runtime_new_link(struct device *dev);
 extern void pm_runtime_drop_link(struct device *dev);
 
@@ -172,7 +173,8 @@ static inline unsigned long pm_runtime_autosuspend_expiration(
 static inline void pm_runtime_set_memalloc_noio(struct device *dev,
                                                 bool enable){}
 static inline void pm_runtime_clean_up_links(struct device *dev) {}
-static inline void pm_runtime_resume_suppliers(struct device *dev) {}
+static inline void pm_runtime_get_suppliers(struct device *dev) {}
+static inline void pm_runtime_put_suppliers(struct device *dev) {}
 static inline void pm_runtime_new_link(struct device *dev) {}
 static inline void pm_runtime_drop_link(struct device *dev) {}
 
diff --git a/include/linux/poll.h b/include/linux/poll.h
index fdf86b4cbc71..7e0fdcf905d2 100644
--- a/include/linux/poll.h
+++ b/include/linux/poll.h
@@ -74,18 +74,18 @@ static inline void init_poll_funcptr(poll_table *pt, poll_queue_proc qproc)
         pt->_key   = ~(__poll_t)0; /* all events enabled */
 }
 
-static inline bool file_has_poll_mask(struct file *file)
+static inline bool file_can_poll(struct file *file)
 {
-        return file->f_op->get_poll_head && file->f_op->poll_mask;
+        return file->f_op->poll;
 }
 
-static inline bool file_can_poll(struct file *file)
+static inline __poll_t vfs_poll(struct file *file, struct poll_table_struct *pt)
 {
-        return file->f_op->poll || file_has_poll_mask(file);
+        if (unlikely(!file->f_op->poll))
+                return DEFAULT_POLLMASK;
+        return file->f_op->poll(file, pt);
 }
 
-__poll_t vfs_poll(struct file *file, struct poll_table_struct *pt);
-
 struct poll_table_entry {
         struct file *filp;
         __poll_t key;
diff --git a/include/linux/power/bq27xxx_battery.h b/include/linux/power/bq27xxx_battery.h
index 01fbf1b16258..d6355f49fbae 100644
--- a/include/linux/power/bq27xxx_battery.h
+++ b/include/linux/power/bq27xxx_battery.h
@@ -24,8 +24,9 @@ enum bq27xxx_chip {
         BQ27546,
         BQ27742,
         BQ27545, /* bq27545 */
-        BQ27421, /* bq27421, bq27425, bq27441, bq27621 */
+        BQ27421, /* bq27421, bq27441, bq27621 */
         BQ27425,
+        BQ27426,
         BQ27441,
         BQ27621,
 };
diff --git a/include/linux/proc_fs.h b/include/linux/proc_fs.h
index e518352137e7..626fc65c4336 100644
--- a/include/linux/proc_fs.h
+++ b/include/linux/proc_fs.h
@@ -14,6 +14,8 @@ struct seq_operations;
 
 #ifdef CONFIG_PROC_FS
 
+typedef int (*proc_write_t)(struct file *, char *, size_t);
+
 extern void proc_root_init(void);
 extern void proc_flush_task(struct task_struct *);
 
@@ -61,6 +63,16 @@ struct proc_dir_entry *proc_create_net_data(const char *name, umode_t mode,
 struct proc_dir_entry *proc_create_net_single(const char *name, umode_t mode,
                 struct proc_dir_entry *parent,
                 int (*show)(struct seq_file *, void *), void *data);
+struct proc_dir_entry *proc_create_net_data_write(const char *name, umode_t mode,
+                                                  struct proc_dir_entry *parent,
+                                                  const struct seq_operations *ops,
+                                                  proc_write_t write,
+                                                  unsigned int state_size, void *data);
+struct proc_dir_entry *proc_create_net_single_write(const char *name, umode_t mode,
+                                                    struct proc_dir_entry *parent,
+                                                    int (*show)(struct seq_file *, void *),
+                                                    proc_write_t write,
+                                                    void *data);
 
 #else /* CONFIG_PROC_FS */
 
diff --git a/include/linux/pstore.h b/include/linux/pstore.h
index 61f806a7fe29..a15bc4d48752 100644
--- a/include/linux/pstore.h
+++ b/include/linux/pstore.h
@@ -71,7 +71,7 @@ struct pstore_record {
         struct pstore_info      *psi;
         enum pstore_type_id     type;
         u64                     id;
-        struct timespec         time;
+        struct timespec64       time;
         char                    *buf;
         ssize_t                 size;
         ssize_t                 ecc_notice_size;
diff --git a/include/linux/pwm_backlight.h b/include/linux/pwm_backlight.h
index e8afbd71a140..8ea265a022fd 100644
--- a/include/linux/pwm_backlight.h
+++ b/include/linux/pwm_backlight.h
@@ -14,6 +14,8 @@ struct platform_pwm_backlight_data {
         unsigned int lth_brightness;
         unsigned int pwm_period_ns;
         unsigned int *levels;
+        unsigned int post_pwm_on_delay;
+        unsigned int pwm_off_delay;
         /* TODO remove once all users are switched to gpiod_* API */
         int enable_gpio;
         int (*init)(struct device *dev);
diff --git a/include/linux/qcom-geni-se.h b/include/linux/qcom-geni-se.h
new file mode 100644
index 000000000000..5d6144977828
--- /dev/null
+++ b/include/linux/qcom-geni-se.h
@@ -0,0 +1,425 @@
+/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
+/*
+ * Copyright (c) 2017-2018, The Linux Foundation. All rights reserved.
+ */
+
+#ifndef _LINUX_QCOM_GENI_SE
+#define _LINUX_QCOM_GENI_SE
+
+/* Transfer mode supported by GENI Serial Engines */
+enum geni_se_xfer_mode {
+        GENI_SE_INVALID,
+        GENI_SE_FIFO,
+        GENI_SE_DMA,
+};
+
+/* Protocols supported by GENI Serial Engines */
+enum geni_se_protocol_type {
+        GENI_SE_NONE,
+        GENI_SE_SPI,
+        GENI_SE_UART,
+        GENI_SE_I2C,
+        GENI_SE_I3C,
+};
+
+struct geni_wrapper;
+struct clk;
+
+/**
+ * struct geni_se - GENI Serial Engine
+ * @base:               Base Address of the Serial Engine's register block
+ * @dev:                Pointer to the Serial Engine device
+ * @wrapper:            Pointer to the parent QUP Wrapper core
+ * @clk:                Handle to the core serial engine clock
+ * @num_clk_levels:     Number of valid clock levels in clk_perf_tbl
+ * @clk_perf_tbl:       Table of clock frequency input to serial engine clock
+ */
+struct geni_se {
+        void __iomem *base;
+        struct device *dev;
+        struct geni_wrapper *wrapper;
+        struct clk *clk;
+        unsigned int num_clk_levels;
+        unsigned long *clk_perf_tbl;
+};
+
+/* Common SE registers */
+#define GENI_FORCE_DEFAULT_REG          0x20
+#define SE_GENI_STATUS                  0x40
+#define GENI_SER_M_CLK_CFG              0x48
+#define GENI_SER_S_CLK_CFG              0x4c
+#define GENI_FW_REVISION_RO             0x68
+#define SE_GENI_CLK_SEL                 0x7c
+#define SE_GENI_DMA_MODE_EN             0x258
+#define SE_GENI_M_CMD0                  0x600
+#define SE_GENI_M_CMD_CTRL_REG          0x604
+#define SE_GENI_M_IRQ_STATUS            0x610
+#define SE_GENI_M_IRQ_EN                0x614
+#define SE_GENI_M_IRQ_CLEAR             0x618
+#define SE_GENI_S_CMD0                  0x630
+#define SE_GENI_S_CMD_CTRL_REG          0x634
+#define SE_GENI_S_IRQ_STATUS            0x640
+#define SE_GENI_S_IRQ_EN                0x644
+#define SE_GENI_S_IRQ_CLEAR             0x648
+#define SE_GENI_TX_FIFOn                0x700
+#define SE_GENI_RX_FIFOn                0x780
+#define SE_GENI_TX_FIFO_STATUS          0x800
+#define SE_GENI_RX_FIFO_STATUS          0x804
+#define SE_GENI_TX_WATERMARK_REG        0x80c
+#define SE_GENI_RX_WATERMARK_REG        0x810
+#define SE_GENI_RX_RFR_WATERMARK_REG    0x814
+#define SE_GENI_IOS                     0x908
+#define SE_DMA_TX_IRQ_STAT              0xc40
+#define SE_DMA_TX_IRQ_CLR               0xc44
+#define SE_DMA_TX_FSM_RST               0xc58
+#define SE_DMA_RX_IRQ_STAT              0xd40
+#define SE_DMA_RX_IRQ_CLR               0xd44
+#define SE_DMA_RX_FSM_RST               0xd58
+#define SE_HW_PARAM_0                   0xe24
+#define SE_HW_PARAM_1                   0xe28
+
+/* GENI_FORCE_DEFAULT_REG fields */
+#define FORCE_DEFAULT   BIT(0)
+
+/* GENI_STATUS fields */
+#define M_GENI_CMD_ACTIVE               BIT(0)
+#define S_GENI_CMD_ACTIVE               BIT(12)
+
+/* GENI_SER_M_CLK_CFG/GENI_SER_S_CLK_CFG */
+#define SER_CLK_EN                      BIT(0)
+#define CLK_DIV_MSK                     GENMASK(15, 4)
+#define CLK_DIV_SHFT                    4
+
+/* GENI_FW_REVISION_RO fields */
+#define FW_REV_PROTOCOL_MSK             GENMASK(15, 8)
+#define FW_REV_PROTOCOL_SHFT            8
+
+/* GENI_CLK_SEL fields */
+#define CLK_SEL_MSK                     GENMASK(2, 0)
+
+/* SE_GENI_DMA_MODE_EN */
+#define GENI_DMA_MODE_EN                BIT(0)
+
+/* GENI_M_CMD0 fields */
+#define M_OPCODE_MSK                    GENMASK(31, 27)
+#define M_OPCODE_SHFT                   27
+#define M_PARAMS_MSK                    GENMASK(26, 0)
+
+/* GENI_M_CMD_CTRL_REG */
+#define M_GENI_CMD_CANCEL               BIT(2)
+#define M_GENI_CMD_ABORT                BIT(1)
+#define M_GENI_DISABLE                  BIT(0)
+
+/* GENI_S_CMD0 fields */
+#define S_OPCODE_MSK                    GENMASK(31, 27)
+#define S_OPCODE_SHFT                   27
+#define S_PARAMS_MSK                    GENMASK(26, 0)
+
+/* GENI_S_CMD_CTRL_REG */
+#define S_GENI_CMD_CANCEL               BIT(2)
+#define S_GENI_CMD_ABORT                BIT(1)
+#define S_GENI_DISABLE                  BIT(0)
+
+/* GENI_M_IRQ_EN fields */
+#define M_CMD_DONE_EN                   BIT(0)
+#define M_CMD_OVERRUN_EN                BIT(1)
+#define M_ILLEGAL_CMD_EN                BIT(2)
+#define M_CMD_FAILURE_EN                BIT(3)
+#define M_CMD_CANCEL_EN                 BIT(4)
+#define M_CMD_ABORT_EN                  BIT(5)
+#define M_TIMESTAMP_EN                  BIT(6)
+#define M_RX_IRQ_EN                     BIT(7)
+#define M_GP_SYNC_IRQ_0_EN              BIT(8)
+#define M_GP_IRQ_0_EN                   BIT(9)
+#define M_GP_IRQ_1_EN                   BIT(10)
+#define M_GP_IRQ_2_EN                   BIT(11)
+#define M_GP_IRQ_3_EN                   BIT(12)
+#define M_GP_IRQ_4_EN                   BIT(13)
+#define M_GP_IRQ_5_EN                   BIT(14)
+#define M_IO_DATA_DEASSERT_EN           BIT(22)
+#define M_IO_DATA_ASSERT_EN             BIT(23)
+#define M_RX_FIFO_RD_ERR_EN             BIT(24)
+#define M_RX_FIFO_WR_ERR_EN             BIT(25)
+#define M_RX_FIFO_WATERMARK_EN          BIT(26)
+#define M_RX_FIFO_LAST_EN               BIT(27)
+#define M_TX_FIFO_RD_ERR_EN             BIT(28)
+#define M_TX_FIFO_WR_ERR_EN             BIT(29)
+#define M_TX_FIFO_WATERMARK_EN          BIT(30)
+#define M_SEC_IRQ_EN                    BIT(31)
+#define M_COMMON_GENI_M_IRQ_EN  (GENMASK(6, 1) | \
+                                M_IO_DATA_DEASSERT_EN | \
+                                M_IO_DATA_ASSERT_EN | M_RX_FIFO_RD_ERR_EN | \
+                                M_RX_FIFO_WR_ERR_EN | M_TX_FIFO_RD_ERR_EN | \
+                                M_TX_FIFO_WR_ERR_EN)
+
+/* GENI_S_IRQ_EN fields */
+#define S_CMD_DONE_EN                   BIT(0)
+#define S_CMD_OVERRUN_EN                BIT(1)
+#define S_ILLEGAL_CMD_EN                BIT(2)
+#define S_CMD_FAILURE_EN                BIT(3)
+#define S_CMD_CANCEL_EN                 BIT(4)
+#define S_CMD_ABORT_EN                  BIT(5)
+#define S_GP_SYNC_IRQ_0_EN              BIT(8)
+#define S_GP_IRQ_0_EN                   BIT(9)
+#define S_GP_IRQ_1_EN                   BIT(10)
+#define S_GP_IRQ_2_EN                   BIT(11)
+#define S_GP_IRQ_3_EN                   BIT(12)
+#define S_GP_IRQ_4_EN                   BIT(13)
+#define S_GP_IRQ_5_EN                   BIT(14)
+#define S_IO_DATA_DEASSERT_EN           BIT(22)
+#define S_IO_DATA_ASSERT_EN             BIT(23)
+#define S_RX_FIFO_RD_ERR_EN             BIT(24)
+#define S_RX_FIFO_WR_ERR_EN             BIT(25)
+#define S_RX_FIFO_WATERMARK_EN          BIT(26)
+#define S_RX_FIFO_LAST_EN               BIT(27)
+#define S_COMMON_GENI_S_IRQ_EN  (GENMASK(5, 1) | GENMASK(13, 9) | \
+                                 S_RX_FIFO_RD_ERR_EN | S_RX_FIFO_WR_ERR_EN)
+
+/*  GENI_/TX/RX/RX_RFR/_WATERMARK_REG fields */
+#define WATERMARK_MSK                   GENMASK(5, 0)
+
+/* GENI_TX_FIFO_STATUS fields */
+#define TX_FIFO_WC                      GENMASK(27, 0)
+
+/*  GENI_RX_FIFO_STATUS fields */
+#define RX_LAST                         BIT(31)
+#define RX_LAST_BYTE_VALID_MSK          GENMASK(30, 28)
+#define RX_LAST_BYTE_VALID_SHFT         28
+#define RX_FIFO_WC_MSK                  GENMASK(24, 0)
+
+/* SE_GENI_IOS fields */
+#define IO2_DATA_IN                     BIT(1)
+#define RX_DATA_IN                      BIT(0)
+
+/* SE_DMA_TX_IRQ_STAT Register fields */
+#define TX_DMA_DONE                     BIT(0)
+#define TX_EOT                          BIT(1)
+#define TX_SBE                          BIT(2)
+#define TX_RESET_DONE                   BIT(3)
+
+/* SE_DMA_RX_IRQ_STAT Register fields */
+#define RX_DMA_DONE                     BIT(0)
+#define RX_EOT                          BIT(1)
+#define RX_SBE                          BIT(2)
+#define RX_RESET_DONE                   BIT(3)
+#define RX_FLUSH_DONE                   BIT(4)
+#define RX_GENI_GP_IRQ                  GENMASK(10, 5)
+#define RX_GENI_CANCEL_IRQ              BIT(11)
+#define RX_GENI_GP_IRQ_EXT              GENMASK(13, 12)
+
+/* SE_HW_PARAM_0 fields */
+#define TX_FIFO_WIDTH_MSK               GENMASK(29, 24)
+#define TX_FIFO_WIDTH_SHFT              24
+#define TX_FIFO_DEPTH_MSK               GENMASK(21, 16)
+#define TX_FIFO_DEPTH_SHFT              16
+
+/* SE_HW_PARAM_1 fields */
+#define RX_FIFO_WIDTH_MSK               GENMASK(29, 24)
+#define RX_FIFO_WIDTH_SHFT              24
+#define RX_FIFO_DEPTH_MSK               GENMASK(21, 16)
+#define RX_FIFO_DEPTH_SHFT              16
+
+#define HW_VER_MAJOR_MASK               GENMASK(31, 28)
+#define HW_VER_MAJOR_SHFT               28
+#define HW_VER_MINOR_MASK               GENMASK(27, 16)
+#define HW_VER_MINOR_SHFT               16
+#define HW_VER_STEP_MASK                GENMASK(15, 0)
+
+#if IS_ENABLED(CONFIG_QCOM_GENI_SE)
+
+u32 geni_se_get_qup_hw_version(struct geni_se *se);
+
+#define geni_se_get_wrapper_version(se, major, minor, step) do { \
+        u32 ver; \
+\
+        ver = geni_se_get_qup_hw_version(se); \
+        major = (ver & HW_VER_MAJOR_MASK) >> HW_VER_MAJOR_SHFT; \
+        minor = (ver & HW_VER_MINOR_MASK) >> HW_VER_MINOR_SHFT; \
+        step = version & HW_VER_STEP_MASK; \
+} while (0)
+
+/**
+ * geni_se_read_proto() - Read the protocol configured for a serial engine
+ * @se:         Pointer to the concerned serial engine.
+ *
+ * Return: Protocol value as configured in the serial engine.
+ */
+static inline u32 geni_se_read_proto(struct geni_se *se)
+{
+        u32 val;
+
+        val = readl_relaxed(se->base + GENI_FW_REVISION_RO);
+
+        return (val & FW_REV_PROTOCOL_MSK) >> FW_REV_PROTOCOL_SHFT;
+}
+
+/**
+ * geni_se_setup_m_cmd() - Setup the primary sequencer
+ * @se:         Pointer to the concerned serial engine.
+ * @cmd:        Command/Operation to setup in the primary sequencer.
+ * @params:     Parameter for the sequencer command.
+ *
+ * This function is used to configure the primary sequencer with the
+ * command and its associated parameters.
+ */
+static inline void geni_se_setup_m_cmd(struct geni_se *se, u32 cmd, u32 params)
+{
+        u32 m_cmd;
+
+        m_cmd = (cmd << M_OPCODE_SHFT) | (params & M_PARAMS_MSK);
+        writel_relaxed(m_cmd, se->base + SE_GENI_M_CMD0);
+}
+
+/**
+ * geni_se_setup_s_cmd() - Setup the secondary sequencer
+ * @se:         Pointer to the concerned serial engine.
+ * @cmd:        Command/Operation to setup in the secondary sequencer.
+ * @params:     Parameter for the sequencer command.
+ *
+ * This function is used to configure the secondary sequencer with the
+ * command and its associated parameters.
+ */
+static inline void geni_se_setup_s_cmd(struct geni_se *se, u32 cmd, u32 params)
+{
+        u32 s_cmd;
+
+        s_cmd = readl_relaxed(se->base + SE_GENI_S_CMD0);
+        s_cmd &= ~(S_OPCODE_MSK | S_PARAMS_MSK);
+        s_cmd |= (cmd << S_OPCODE_SHFT);
+        s_cmd |= (params & S_PARAMS_MSK);
+        writel_relaxed(s_cmd, se->base + SE_GENI_S_CMD0);
+}
+
+/**
+ * geni_se_cancel_m_cmd() - Cancel the command configured in the primary
+ *                          sequencer
+ * @se: Pointer to the concerned serial engine.
+ *
+ * This function is used to cancel the currently configured command in the
+ * primary sequencer.
+ */
+static inline void geni_se_cancel_m_cmd(struct geni_se *se)
+{
+        writel_relaxed(M_GENI_CMD_CANCEL, se->base + SE_GENI_M_CMD_CTRL_REG);
+}
+
+/**
+ * geni_se_cancel_s_cmd() - Cancel the command configured in the secondary
+ *                          sequencer
+ * @se: Pointer to the concerned serial engine.
+ *
+ * This function is used to cancel the currently configured command in the
+ * secondary sequencer.
+ */
+static inline void geni_se_cancel_s_cmd(struct geni_se *se)
+{
+        writel_relaxed(S_GENI_CMD_CANCEL, se->base + SE_GENI_S_CMD_CTRL_REG);
+}
+
+/**
+ * geni_se_abort_m_cmd() - Abort the command configured in the primary sequencer
+ * @se: Pointer to the concerned serial engine.
+ *
+ * This function is used to force abort the currently configured command in the
+ * primary sequencer.
+ */
+static inline void geni_se_abort_m_cmd(struct geni_se *se)
+{
+        writel_relaxed(M_GENI_CMD_ABORT, se->base + SE_GENI_M_CMD_CTRL_REG);
+}
+
+/**
+ * geni_se_abort_s_cmd() - Abort the command configured in the secondary
+ *                         sequencer
+ * @se: Pointer to the concerned serial engine.
+ *
+ * This function is used to force abort the currently configured command in the
+ * secondary sequencer.
+ */
+static inline void geni_se_abort_s_cmd(struct geni_se *se)
+{
+        writel_relaxed(S_GENI_CMD_ABORT, se->base + SE_GENI_S_CMD_CTRL_REG);
+}
+
+/**
+ * geni_se_get_tx_fifo_depth() - Get the TX fifo depth of the serial engine
+ * @se: Pointer to the concerned serial engine.
+ *
+ * This function is used to get the depth i.e. number of elements in the
+ * TX fifo of the serial engine.
+ *
+ * Return: TX fifo depth in units of FIFO words.
+ */
+static inline u32 geni_se_get_tx_fifo_depth(struct geni_se *se)
+{
+        u32 val;
+
+        val = readl_relaxed(se->base + SE_HW_PARAM_0);
+
+        return (val & TX_FIFO_DEPTH_MSK) >> TX_FIFO_DEPTH_SHFT;
+}
+
+/**
+ * geni_se_get_tx_fifo_width() - Get the TX fifo width of the serial engine
+ * @se: Pointer to the concerned serial engine.
+ *
+ * This function is used to get the width i.e. word size per element in the
+ * TX fifo of the serial engine.
+ *
+ * Return: TX fifo width in bits
+ */
+static inline u32 geni_se_get_tx_fifo_width(struct geni_se *se)
+{
+        u32 val;
+
+        val = readl_relaxed(se->base + SE_HW_PARAM_0);
+
+        return (val & TX_FIFO_WIDTH_MSK) >> TX_FIFO_WIDTH_SHFT;
+}
+
+/**
+ * geni_se_get_rx_fifo_depth() - Get the RX fifo depth of the serial engine
+ * @se: Pointer to the concerned serial engine.
+ *
+ * This function is used to get the depth i.e. number of elements in the
+ * RX fifo of the serial engine.
+ *
+ * Return: RX fifo depth in units of FIFO words
+ */
+static inline u32 geni_se_get_rx_fifo_depth(struct geni_se *se)
+{
+        u32 val;
+
+        val = readl_relaxed(se->base + SE_HW_PARAM_1);
+
+        return (val & RX_FIFO_DEPTH_MSK) >> RX_FIFO_DEPTH_SHFT;
+}
+
+void geni_se_init(struct geni_se *se, u32 rx_wm, u32 rx_rfr);
+
+void geni_se_select_mode(struct geni_se *se, enum geni_se_xfer_mode mode);
+
+void geni_se_config_packing(struct geni_se *se, int bpw, int pack_words,
+                            bool msb_to_lsb, bool tx_cfg, bool rx_cfg);
+
+int geni_se_resources_off(struct geni_se *se);
+
+int geni_se_resources_on(struct geni_se *se);
+
+int geni_se_clk_tbl_get(struct geni_se *se, unsigned long **tbl);
+
+int geni_se_clk_freq_match(struct geni_se *se, unsigned long req_freq,
+                           unsigned int *index, unsigned long *res_freq,
+                           bool exact);
+
+int geni_se_tx_dma_prep(struct geni_se *se, void *buf, size_t len,
+                        dma_addr_t *iova);
+
+int geni_se_rx_dma_prep(struct geni_se *se, void *buf, size_t len,
+                        dma_addr_t *iova);
+
+void geni_se_tx_dma_unprep(struct geni_se *se, dma_addr_t iova, size_t len);
+
+void geni_se_rx_dma_unprep(struct geni_se *se, dma_addr_t iova, size_t len);
+#endif
+#endif
diff --git a/include/linux/rculist.h b/include/linux/rculist.h
index 127f534fec94..36df6ccbc874 100644
--- a/include/linux/rculist.h
+++ b/include/linux/rculist.h
@@ -404,6 +404,19 @@ static inline void list_splice_tail_init_rcu(struct list_head *list,
              pos = list_entry_rcu(pos->member.next, typeof(*pos), member))
 
 /**
+ * list_for_each_entry_from_rcu - iterate over a list from current point
+ * @pos:        the type * to use as a loop cursor.
+ * @head:       the head for your list.
+ * @member:     the name of the list_node within the struct.
+ *
+ * Iterate over the tail of a list starting from a given position,
+ * which must have been in the list when the RCU read lock was taken.
+ */
+#define list_for_each_entry_from_rcu(pos, head, member)                 \
+        for (; &(pos)->member != (head);                                        \
+                pos = list_entry_rcu(pos->member.next, typeof(*(pos)), member))
+
+/**
  * hlist_del_rcu - deletes entry from hash list without re-initialization
  * @n: the element to delete from the hash list.
  *
diff --git a/include/linux/rculist_nulls.h b/include/linux/rculist_nulls.h
index e4b257ff881b..bc8206a8f30e 100644
--- a/include/linux/rculist_nulls.h
+++ b/include/linux/rculist_nulls.h
@@ -109,7 +109,7 @@ static inline void hlist_nulls_add_head_rcu(struct hlist_nulls_node *n,
  *
  * The barrier() is needed to make sure compiler doesn't cache first element [1],
  * as this loop can be restarted [2]
- * [1] Documentation/atomic_ops.txt around line 114
+ * [1] Documentation/core-api/atomic_ops.rst around line 114
  * [2] Documentation/RCU/rculist_nulls.txt around line 146
  */
 #define hlist_nulls_for_each_entry_rcu(tpos, pos, head, member)                 \
diff --git a/include/linux/rcupdate.h b/include/linux/rcupdate.h
index e679b175b411..65163aa0bb04 100644
--- a/include/linux/rcupdate.h
+++ b/include/linux/rcupdate.h
@@ -652,9 +652,7 @@ static inline void rcu_read_lock(void)
  * Unfortunately, this function acquires the scheduler's runqueue and
  * priority-inheritance spinlocks.  This means that deadlock could result
  * if the caller of rcu_read_unlock() already holds one of these locks or
- * any lock that is ever acquired while holding them; or any lock which
- * can be taken from interrupt context because rcu_boost()->rt_mutex_lock()
- * does not disable irqs while taking ->wait_lock.
+ * any lock that is ever acquired while holding them.
  *
  * That said, RCU readers are never priority boosted unless they were
  * preempted.  Therefore, one way to avoid deadlock is to make sure
diff --git a/include/linux/refcount.h b/include/linux/refcount.h
index 4193c41e383a..a685da2c4522 100644
--- a/include/linux/refcount.h
+++ b/include/linux/refcount.h
@@ -98,5 +98,7 @@ extern __must_check bool refcount_dec_if_one(refcount_t *r);
 extern __must_check bool refcount_dec_not_one(refcount_t *r);
 extern __must_check bool refcount_dec_and_mutex_lock(refcount_t *r, struct mutex *lock);
 extern __must_check bool refcount_dec_and_lock(refcount_t *r, spinlock_t *lock);
-
+extern __must_check bool refcount_dec_and_lock_irqsave(refcount_t *r,
+                                                       spinlock_t *lock,
+                                                       unsigned long *flags);
 #endif /* _LINUX_REFCOUNT_H */
diff --git a/include/linux/regulator/ab8500.h b/include/linux/regulator/ab8500.h
index d8ecefaf63ca..6d46f962685d 100644
--- a/include/linux/regulator/ab8500.h
+++ b/include/linux/regulator/ab8500.h
@@ -49,47 +49,7 @@ enum ab8505_regulator_id {
         AB8505_NUM_REGULATORS,
 };
 
-/* AB9540 regulators */
-enum ab9540_regulator_id {
-        AB9540_LDO_AUX1,
-        AB9540_LDO_AUX2,
-        AB9540_LDO_AUX3,
-        AB9540_LDO_AUX4,
-        AB9540_LDO_INTCORE,
-        AB9540_LDO_TVOUT,
-        AB9540_LDO_USB,
-        AB9540_LDO_AUDIO,
-        AB9540_LDO_ANAMIC1,
-        AB9540_LDO_ANAMIC2,
-        AB9540_LDO_DMIC,
-        AB9540_LDO_ANA,
-        AB9540_SYSCLKREQ_2,
-        AB9540_SYSCLKREQ_4,
-        AB9540_NUM_REGULATORS,
-};
-
-/* AB8540 regulators */
-enum ab8540_regulator_id {
-        AB8540_LDO_AUX1,
-        AB8540_LDO_AUX2,
-        AB8540_LDO_AUX3,
-        AB8540_LDO_AUX4,
-        AB8540_LDO_AUX5,
-        AB8540_LDO_AUX6,
-        AB8540_LDO_INTCORE,
-        AB8540_LDO_TVOUT,
-        AB8540_LDO_AUDIO,
-        AB8540_LDO_ANAMIC1,
-        AB8540_LDO_ANAMIC2,
-        AB8540_LDO_DMIC,
-        AB8540_LDO_ANA,
-        AB8540_LDO_SDIO,
-        AB8540_SYSCLKREQ_2,
-        AB8540_SYSCLKREQ_4,
-        AB8540_NUM_REGULATORS,
-};
-
-/* AB8500, AB8505, and AB9540 register initialization */
+/* AB8500 and AB8505 register initialization */
 struct ab8500_regulator_reg_init {
         int id;
         u8 mask;
@@ -185,121 +145,6 @@ enum ab8505_regulator_reg {
         AB8505_NUM_REGULATOR_REGISTERS,
 };
 
-/* AB9540 registers */
-enum ab9540_regulator_reg {
-        AB9540_REGUREQUESTCTRL1,
-        AB9540_REGUREQUESTCTRL2,
-        AB9540_REGUREQUESTCTRL3,
-        AB9540_REGUREQUESTCTRL4,
-        AB9540_REGUSYSCLKREQ1HPVALID1,
-        AB9540_REGUSYSCLKREQ1HPVALID2,
-        AB9540_REGUHWHPREQ1VALID1,
-        AB9540_REGUHWHPREQ1VALID2,
-        AB9540_REGUHWHPREQ2VALID1,
-        AB9540_REGUHWHPREQ2VALID2,
-        AB9540_REGUSWHPREQVALID1,
-        AB9540_REGUSWHPREQVALID2,
-        AB9540_REGUSYSCLKREQVALID1,
-        AB9540_REGUSYSCLKREQVALID2,
-        AB9540_REGUVAUX4REQVALID,
-        AB9540_REGUMISC1,
-        AB9540_VAUDIOSUPPLY,
-        AB9540_REGUCTRL1VAMIC,
-        AB9540_VSMPS1REGU,
-        AB9540_VSMPS2REGU,
-        AB9540_VSMPS3REGU, /* NOTE! PRCMU register */
-        AB9540_VPLLVANAREGU,
-        AB9540_EXTSUPPLYREGU,
-        AB9540_VAUX12REGU,
-        AB9540_VRF1VAUX3REGU,
-        AB9540_VSMPS1SEL1,
-        AB9540_VSMPS1SEL2,
-        AB9540_VSMPS1SEL3,
-        AB9540_VSMPS2SEL1,
-        AB9540_VSMPS2SEL2,
-        AB9540_VSMPS2SEL3,
-        AB9540_VSMPS3SEL1, /* NOTE! PRCMU register */
-        AB9540_VSMPS3SEL2, /* NOTE! PRCMU register */
-        AB9540_VAUX1SEL,
-        AB9540_VAUX2SEL,
-        AB9540_VRF1VAUX3SEL,
-        AB9540_REGUCTRL2SPARE,
-        AB9540_VAUX4REQCTRL,
-        AB9540_VAUX4REGU,
-        AB9540_VAUX4SEL,
-        AB9540_REGUCTRLDISCH,
-        AB9540_REGUCTRLDISCH2,
-        AB9540_REGUCTRLDISCH3,
-        AB9540_NUM_REGULATOR_REGISTERS,
-};
-
-/* AB8540 registers */
-enum ab8540_regulator_reg {
-        AB8540_REGUREQUESTCTRL1,
-        AB8540_REGUREQUESTCTRL2,
-        AB8540_REGUREQUESTCTRL3,
-        AB8540_REGUREQUESTCTRL4,
-        AB8540_REGUSYSCLKREQ1HPVALID1,
-        AB8540_REGUSYSCLKREQ1HPVALID2,
-        AB8540_REGUHWHPREQ1VALID1,
-        AB8540_REGUHWHPREQ1VALID2,
-        AB8540_REGUHWHPREQ2VALID1,
-        AB8540_REGUHWHPREQ2VALID2,
-        AB8540_REGUSWHPREQVALID1,
-        AB8540_REGUSWHPREQVALID2,
-        AB8540_REGUSYSCLKREQVALID1,
-        AB8540_REGUSYSCLKREQVALID2,
-        AB8540_REGUVAUX4REQVALID,
-        AB8540_REGUVAUX5REQVALID,
-        AB8540_REGUVAUX6REQVALID,
-        AB8540_REGUVCLKBREQVALID,
-        AB8540_REGUVRF1REQVALID,
-        AB8540_REGUMISC1,
-        AB8540_VAUDIOSUPPLY,
-        AB8540_REGUCTRL1VAMIC,
-        AB8540_VHSIC,
-        AB8540_VSDIO,
-        AB8540_VSMPS1REGU,
-        AB8540_VSMPS2REGU,
-        AB8540_VSMPS3REGU,
-        AB8540_VPLLVANAREGU,
-        AB8540_EXTSUPPLYREGU,
-        AB8540_VAUX12REGU,
-        AB8540_VRF1VAUX3REGU,
-        AB8540_VSMPS1SEL1,
-        AB8540_VSMPS1SEL2,
-        AB8540_VSMPS1SEL3,
-        AB8540_VSMPS2SEL1,
-        AB8540_VSMPS2SEL2,
-        AB8540_VSMPS2SEL3,
-        AB8540_VSMPS3SEL1,
-        AB8540_VSMPS3SEL2,
-        AB8540_VAUX1SEL,
-        AB8540_VAUX2SEL,
-        AB8540_VRF1VAUX3SEL,
-        AB8540_REGUCTRL2SPARE,
-        AB8540_VAUX4REQCTRL,
-        AB8540_VAUX4REGU,
-        AB8540_VAUX4SEL,
-        AB8540_VAUX5REQCTRL,
-        AB8540_VAUX5REGU,
-        AB8540_VAUX5SEL,
-        AB8540_VAUX6REQCTRL,
-        AB8540_VAUX6REGU,
-        AB8540_VAUX6SEL,
-        AB8540_VCLKBREQCTRL,
-        AB8540_VCLKBREGU,
-        AB8540_VCLKBSEL,
-        AB8540_VRF1REQCTRL,
-        AB8540_REGUCTRLDISCH,
-        AB8540_REGUCTRLDISCH2,
-        AB8540_REGUCTRLDISCH3,
-        AB8540_REGUCTRLDISCH4,
-        AB8540_VSIMSYSCLKCTRL,
-        AB8540_VANAVPLLSEL,
-        AB8540_NUM_REGULATOR_REGISTERS,
-};
-
 /* AB8500 external regulators */
 struct ab8500_ext_regulator_cfg {
         bool hwreq; /* requires hw mode or high power mode */
diff --git a/include/linux/regulator/arizona-ldo1.h b/include/linux/regulator/arizona-ldo1.h
index c685f1277c63..fe74ab9990e6 100644
--- a/include/linux/regulator/arizona-ldo1.h
+++ b/include/linux/regulator/arizona-ldo1.h
@@ -14,9 +14,6 @@
 struct regulator_init_data;
 
 struct arizona_ldo1_pdata {
-        /** GPIO controlling LDOENA, if any */
-        int ldoena;
-
         /** Regulator configuration for LDO1 */
         const struct regulator_init_data *init_data;
 };
diff --git a/include/linux/regulator/consumer.h b/include/linux/regulator/consumer.h
index df176d7c2b87..25602afd4844 100644
--- a/include/linux/regulator/consumer.h
+++ b/include/linux/regulator/consumer.h
@@ -80,6 +80,7 @@ struct regmap;
  * These modes can be OR'ed together to make up a mask of valid register modes.
  */
 
+#define REGULATOR_MODE_INVALID                  0x0
 #define REGULATOR_MODE_FAST                     0x1
 #define REGULATOR_MODE_NORMAL                   0x2
 #define REGULATOR_MODE_IDLE                     0x4
diff --git a/include/linux/regulator/driver.h b/include/linux/regulator/driver.h
index 4fc96cb8e5d7..fc2dc8df476f 100644
--- a/include/linux/regulator/driver.h
+++ b/include/linux/regulator/driver.h
@@ -15,6 +15,8 @@
 #ifndef __LINUX_REGULATOR_DRIVER_H_
 #define __LINUX_REGULATOR_DRIVER_H_
 
+#define MAX_COUPLED             4
+
 #include <linux/device.h>
 #include <linux/notifier.h>
 #include <linux/regulator/consumer.h>
@@ -81,9 +83,12 @@ struct regulator_linear_range {
  * @set_voltage_sel: Set the voltage for the regulator using the specified
  *                   selector.
  * @map_voltage: Convert a voltage into a selector
- * @get_voltage: Return the currently configured voltage for the regulator.
+ * @get_voltage: Return the currently configured voltage for the regulator;
+ *                   return -ENOTRECOVERABLE if regulator can't be read at
+ *                   bootup and hasn't been set yet.
  * @get_voltage_sel: Return the currently configured voltage selector for the
- *                   regulator.
+ *                   regulator; return -ENOTRECOVERABLE if regulator can't
+ *                   be read at bootup and hasn't been set yet.
  * @list_voltage: Return one of the supported voltages, in microvolts; zero
  *      if the selector indicates a voltage that is unusable on this system;
  *      or negative errno.  Selectors range from zero to one less than
@@ -407,6 +412,20 @@ struct regulator_config {
 };
 
 /*
+ * struct coupling_desc
+ *
+ * Describes coupling of regulators. Each regulator should have
+ * at least a pointer to itself in coupled_rdevs array.
+ * When a new coupled regulator is resolved, n_resolved is
+ * incremented.
+ */
+struct coupling_desc {
+        struct regulator_dev *coupled_rdevs[MAX_COUPLED];
+        int n_resolved;
+        int n_coupled;
+};
+
+/*
  * struct regulator_dev
  *
  * Voltage / Current regulator class device. One for each
@@ -429,8 +448,12 @@ struct regulator_dev {
         /* lists we own */
         struct list_head consumer_list; /* consumers we supply */
 
+        struct coupling_desc coupling_desc;
+
         struct blocking_notifier_head notifier;
         struct mutex mutex; /* consumer lock */
+        struct task_struct *mutex_owner;
+        int ref_cnt;
         struct module *owner;
         struct device dev;
         struct regulation_constraints *constraints;
diff --git a/include/linux/regulator/machine.h b/include/linux/regulator/machine.h
index 93a04893c739..3468703d663a 100644
--- a/include/linux/regulator/machine.h
+++ b/include/linux/regulator/machine.h
@@ -103,6 +103,7 @@ struct regulator_state {
  * @ilim_uA: Maximum input current.
  * @system_load: Load that isn't captured by any consumer requests.
  *
+ * @max_spread: Max possible spread between coupled regulators
  * @valid_modes_mask: Mask of modes which may be configured by consumers.
  * @valid_ops_mask: Operations which may be performed by consumers.
  *
@@ -154,6 +155,9 @@ struct regulation_constraints {
 
         int system_load;
 
+        /* used for coupled regulators */
+        int max_spread;
+
         /* valid regulator operating modes for this machine */
         unsigned int valid_modes_mask;
 
diff --git a/include/linux/regulator/max8952.h b/include/linux/regulator/max8952.h
index 4dbb63a1d4ab..686c42c041b5 100644
--- a/include/linux/regulator/max8952.h
+++ b/include/linux/regulator/max8952.h
@@ -120,7 +120,6 @@ enum {
 struct max8952_platform_data {
         int gpio_vid0;
         int gpio_vid1;
-        int gpio_en;
 
         u32 default_mode;
         u32 dvs_mode[MAX8952_NUM_DVS_MODE]; /* MAX8952_DVS_MODEx_XXXXmV */
diff --git a/include/linux/rmi.h b/include/linux/rmi.h
index 64125443f8a6..5ef5c7c412a7 100644
--- a/include/linux/rmi.h
+++ b/include/linux/rmi.h
@@ -354,6 +354,8 @@ struct rmi_driver_data {
         struct mutex irq_mutex;
         struct input_dev *input;
 
+        struct irq_domain *irqdomain;
+
         u8 pdt_props;
 
         u8 num_rx_electrodes;
diff --git a/include/linux/rpmsg.h b/include/linux/rpmsg.h
index ca07366c4c33..9fe156d1c018 100644
--- a/include/linux/rpmsg.h
+++ b/include/linux/rpmsg.h
@@ -1,35 +1,10 @@
+/* SPDX-License-Identifier: BSD-3-Clause */
 /*
  * Remote processor messaging
  *
  * Copyright (C) 2011 Texas Instruments, Inc.
  * Copyright (C) 2011 Google, Inc.
  * All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * * Redistributions of source code must retain the above copyright
- *   notice, this list of conditions and the following disclaimer.
- * * Redistributions in binary form must reproduce the above copyright
- *   notice, this list of conditions and the following disclaimer in
- *   the documentation and/or other materials provided with the
- *   distribution.
- * * Neither the name Texas Instruments nor the names of its
- *   contributors may be used to endorse or promote products derived
- *   from this software without specific prior written permission.
- *
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
- * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
- * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
- * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
- * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
- * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
- * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
- * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef _LINUX_RPMSG_H
diff --git a/include/linux/rpmsg/qcom_glink.h b/include/linux/rpmsg/qcom_glink.h
index a622f029836e..96e26d94719f 100644
--- a/include/linux/rpmsg/qcom_glink.h
+++ b/include/linux/rpmsg/qcom_glink.h
@@ -1,3 +1,5 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+
 #ifndef _LINUX_RPMSG_QCOM_GLINK_H
 #define _LINUX_RPMSG_QCOM_GLINK_H
 
diff --git a/include/linux/rtc.h b/include/linux/rtc.h
index 4c007f69082f..6268208760e9 100644
--- a/include/linux/rtc.h
+++ b/include/linux/rtc.h
@@ -285,7 +285,7 @@ void rtc_nvmem_unregister(struct rtc_device *rtc);
 static inline int rtc_nvmem_register(struct rtc_device *rtc,
                                      struct nvmem_config *nvmem_config)
 {
-        return -ENODEV;
+        return 0;
 }
 static inline void rtc_nvmem_unregister(struct rtc_device *rtc) {}
 #endif
diff --git a/include/linux/scatterlist.h b/include/linux/scatterlist.h
index 51f52020ad5f..093aa57120b0 100644
--- a/include/linux/scatterlist.h
+++ b/include/linux/scatterlist.h
@@ -9,9 +9,6 @@
 #include <asm/io.h>
 
 struct scatterlist {
-#ifdef CONFIG_DEBUG_SG
-        unsigned long   sg_magic;
-#endif
         unsigned long   page_link;
         unsigned int    offset;
         unsigned int    length;
@@ -64,7 +61,6 @@ struct sg_table {
  *
  */
 
-#define SG_MAGIC        0x87654321
 #define SG_CHAIN        0x01UL
 #define SG_END          0x02UL
 
@@ -98,7 +94,6 @@ static inline void sg_assign_page(struct scatterlist *sg, struct page *page)
          */
         BUG_ON((unsigned long) page & (SG_CHAIN | SG_END));
 #ifdef CONFIG_DEBUG_SG
-        BUG_ON(sg->sg_magic != SG_MAGIC);
         BUG_ON(sg_is_chain(sg));
 #endif
         sg->page_link = page_link | (unsigned long) page;
@@ -129,7 +124,6 @@ static inline void sg_set_page(struct scatterlist *sg, struct page *page,
 static inline struct page *sg_page(struct scatterlist *sg)
 {
 #ifdef CONFIG_DEBUG_SG
-        BUG_ON(sg->sg_magic != SG_MAGIC);
         BUG_ON(sg_is_chain(sg));
 #endif
         return (struct page *)((sg)->page_link & ~(SG_CHAIN | SG_END));
@@ -195,9 +189,6 @@ static inline void sg_chain(struct scatterlist *prv, unsigned int prv_nents,
  **/
 static inline void sg_mark_end(struct scatterlist *sg)
 {
-#ifdef CONFIG_DEBUG_SG
-        BUG_ON(sg->sg_magic != SG_MAGIC);
-#endif
         /*
          * Set termination bit, clear potential chain bit
          */
@@ -215,9 +206,6 @@ static inline void sg_mark_end(struct scatterlist *sg)
  **/
 static inline void sg_unmark_end(struct scatterlist *sg)
 {
-#ifdef CONFIG_DEBUG_SG
-        BUG_ON(sg->sg_magic != SG_MAGIC);
-#endif
         sg->page_link &= ~SG_END;
 }
 
@@ -260,12 +248,6 @@ static inline void *sg_virt(struct scatterlist *sg)
 static inline void sg_init_marker(struct scatterlist *sgl,
                                   unsigned int nents)
 {
-#ifdef CONFIG_DEBUG_SG
-        unsigned int i;
-
-        for (i = 0; i < nents; i++)
-                sgl[i].sg_magic = SG_MAGIC;
-#endif
         sg_mark_end(&sgl[nents - 1]);
 }
 
diff --git a/include/linux/sched.h b/include/linux/sched.h
index 14e4f9c12337..43731fe51c97 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -27,6 +27,7 @@
 #include <linux/signal_types.h>
 #include <linux/mm_types_task.h>
 #include <linux/task_io_accounting.h>
+#include <linux/rseq.h>
 
 /* task_struct member predeclarations (sorted alphabetically): */
 struct audit_context;
@@ -117,7 +118,7 @@ struct task_group;
  * the comment with set_special_state().
  */
 #define is_special_task_state(state)                            \
-        ((state) & (__TASK_STOPPED | __TASK_TRACED | TASK_DEAD))
+        ((state) & (__TASK_STOPPED | __TASK_TRACED | TASK_PARKED | TASK_DEAD))
 
 #define __set_current_state(state_value)                        \
         do {                                                    \
@@ -741,7 +742,7 @@ struct task_struct {
         pid_t                           pid;
         pid_t                           tgid;
 
-#ifdef CONFIG_CC_STACKPROTECTOR
+#ifdef CONFIG_STACKPROTECTOR
         /* Canary value for the -fstack-protector GCC feature: */
         unsigned long                   stack_canary;
 #endif
@@ -1047,6 +1048,17 @@ struct task_struct {
         unsigned long                   numa_pages_migrated;
 #endif /* CONFIG_NUMA_BALANCING */
 
+#ifdef CONFIG_RSEQ
+        struct rseq __user *rseq;
+        u32 rseq_len;
+        u32 rseq_sig;
+        /*
+         * RmW on rseq_event_mask must be performed atomically
+         * with respect to preemption.
+         */
+        unsigned long rseq_event_mask;
+#endif
+
         struct tlbflush_unmap_batch     tlb_ubc;
 
         struct rcu_head                 rcu;
@@ -1118,7 +1130,7 @@ struct task_struct {
 
 #ifdef CONFIG_KCOV
         /* Coverage collection mode enabled for this task (0 if disabled): */
-        enum kcov_mode                  kcov_mode;
+        unsigned int                    kcov_mode;
 
         /* Size of the kcov_area: */
         unsigned int                    kcov_size;
@@ -1627,6 +1639,12 @@ static inline void clear_tsk_thread_flag(struct task_struct *tsk, int flag)
         clear_ti_thread_flag(task_thread_info(tsk), flag);
 }
 
+static inline void update_tsk_thread_flag(struct task_struct *tsk, int flag,
+                                          bool value)
+{
+        update_ti_thread_flag(task_thread_info(tsk), flag, value);
+}
+
 static inline int test_and_set_tsk_thread_flag(struct task_struct *tsk, int flag)
 {
         return test_and_set_ti_thread_flag(task_thread_info(tsk), flag);
@@ -1757,4 +1775,127 @@ extern long sched_getaffinity(pid_t pid, struct cpumask *mask);
 #define TASK_SIZE_OF(tsk)       TASK_SIZE
 #endif
 
+#ifdef CONFIG_RSEQ
+
+/*
+ * Map the event mask on the user-space ABI enum rseq_cs_flags
+ * for direct mask checks.
+ */
+enum rseq_event_mask_bits {
+        RSEQ_EVENT_PREEMPT_BIT  = RSEQ_CS_FLAG_NO_RESTART_ON_PREEMPT_BIT,
+        RSEQ_EVENT_SIGNAL_BIT   = RSEQ_CS_FLAG_NO_RESTART_ON_SIGNAL_BIT,
+        RSEQ_EVENT_MIGRATE_BIT  = RSEQ_CS_FLAG_NO_RESTART_ON_MIGRATE_BIT,
+};
+
+enum rseq_event_mask {
+        RSEQ_EVENT_PREEMPT      = (1U << RSEQ_EVENT_PREEMPT_BIT),
+        RSEQ_EVENT_SIGNAL       = (1U << RSEQ_EVENT_SIGNAL_BIT),
+        RSEQ_EVENT_MIGRATE      = (1U << RSEQ_EVENT_MIGRATE_BIT),
+};
+
+static inline void rseq_set_notify_resume(struct task_struct *t)
+{
+        if (t->rseq)
+                set_tsk_thread_flag(t, TIF_NOTIFY_RESUME);
+}
+
+void __rseq_handle_notify_resume(struct ksignal *sig, struct pt_regs *regs);
+
+static inline void rseq_handle_notify_resume(struct ksignal *ksig,
+                                             struct pt_regs *regs)
+{
+        if (current->rseq)
+                __rseq_handle_notify_resume(ksig, regs);
+}
+
+static inline void rseq_signal_deliver(struct ksignal *ksig,
+                                       struct pt_regs *regs)
+{
+        preempt_disable();
+        __set_bit(RSEQ_EVENT_SIGNAL_BIT, &current->rseq_event_mask);
+        preempt_enable();
+        rseq_handle_notify_resume(ksig, regs);
+}
+
+/* rseq_preempt() requires preemption to be disabled. */
+static inline void rseq_preempt(struct task_struct *t)
+{
+        __set_bit(RSEQ_EVENT_PREEMPT_BIT, &t->rseq_event_mask);
+        rseq_set_notify_resume(t);
+}
+
+/* rseq_migrate() requires preemption to be disabled. */
+static inline void rseq_migrate(struct task_struct *t)
+{
+        __set_bit(RSEQ_EVENT_MIGRATE_BIT, &t->rseq_event_mask);
+        rseq_set_notify_resume(t);
+}
+
+/*
+ * If parent process has a registered restartable sequences area, the
+ * child inherits. Only applies when forking a process, not a thread.
+ */
+static inline void rseq_fork(struct task_struct *t, unsigned long clone_flags)
+{
+        if (clone_flags & CLONE_THREAD) {
+                t->rseq = NULL;
+                t->rseq_len = 0;
+                t->rseq_sig = 0;
+                t->rseq_event_mask = 0;
+        } else {
+                t->rseq = current->rseq;
+                t->rseq_len = current->rseq_len;
+                t->rseq_sig = current->rseq_sig;
+                t->rseq_event_mask = current->rseq_event_mask;
+        }
+}
+
+static inline void rseq_execve(struct task_struct *t)
+{
+        t->rseq = NULL;
+        t->rseq_len = 0;
+        t->rseq_sig = 0;
+        t->rseq_event_mask = 0;
+}
+
+#else
+
+static inline void rseq_set_notify_resume(struct task_struct *t)
+{
+}
+static inline void rseq_handle_notify_resume(struct ksignal *ksig,
+                                             struct pt_regs *regs)
+{
+}
+static inline void rseq_signal_deliver(struct ksignal *ksig,
+                                       struct pt_regs *regs)
+{
+}
+static inline void rseq_preempt(struct task_struct *t)
+{
+}
+static inline void rseq_migrate(struct task_struct *t)
+{
+}
+static inline void rseq_fork(struct task_struct *t, unsigned long clone_flags)
+{
+}
+static inline void rseq_execve(struct task_struct *t)
+{
+}
+
+#endif
+
+#ifdef CONFIG_DEBUG_RSEQ
+
+void rseq_syscall(struct pt_regs *regs);
+
+#else
+
+static inline void rseq_syscall(struct pt_regs *regs)
+{
+}
+
+#endif
+
 #endif
diff --git a/include/linux/scmi_protocol.h b/include/linux/scmi_protocol.h
index b458c87b866c..f4c9fc0fc755 100644
--- a/include/linux/scmi_protocol.h
+++ b/include/linux/scmi_protocol.h
@@ -85,8 +85,8 @@ struct scmi_clk_ops {
  * @level_set: sets the performance level of a domain
  * @level_get: gets the performance level of a domain
  * @device_domain_id: gets the scmi domain id for a given device
- * @get_transition_latency: gets the DVFS transition latency for a given device
- * @add_opps_to_device: adds all the OPPs for a given device
+ * @transition_latency_get: gets the DVFS transition latency for a given device
+ * @device_opps_add: adds all the OPPs for a given device
  * @freq_set: sets the frequency for a given device using sustained frequency
  *      to sustained performance level mapping
  * @freq_get: gets the frequency for a given device using sustained frequency
@@ -102,10 +102,10 @@ struct scmi_perf_ops {
         int (*level_get)(const struct scmi_handle *handle, u32 domain,
                          u32 *level, bool poll);
         int (*device_domain_id)(struct device *dev);
-        int (*get_transition_latency)(const struct scmi_handle *handle,
+        int (*transition_latency_get)(const struct scmi_handle *handle,
                                       struct device *dev);
-        int (*add_opps_to_device)(const struct scmi_handle *handle,
-                                  struct device *dev);
+        int (*device_opps_add)(const struct scmi_handle *handle,
+                               struct device *dev);
         int (*freq_set)(const struct scmi_handle *handle, u32 domain,
                         unsigned long rate, bool poll);
         int (*freq_get)(const struct scmi_handle *handle, u32 domain,
@@ -189,6 +189,14 @@ struct scmi_sensor_ops {
  * @perf_ops: pointer to set of performance protocol operations
  * @clk_ops: pointer to set of clock protocol operations
  * @sensor_ops: pointer to set of sensor protocol operations
+ * @perf_priv: pointer to private data structure specific to performance
+ *      protocol(for internal use only)
+ * @clk_priv: pointer to private data structure specific to clock
+ *      protocol(for internal use only)
+ * @power_priv: pointer to private data structure specific to power
+ *      protocol(for internal use only)
+ * @sensor_priv: pointer to private data structure specific to sensors
+ *      protocol(for internal use only)
  */
 struct scmi_handle {
         struct device *dev;
diff --git a/include/linux/skbuff.h b/include/linux/skbuff.h
index c86885954994..164cdedf6012 100644
--- a/include/linux/skbuff.h
+++ b/include/linux/skbuff.h
@@ -3252,7 +3252,8 @@ struct sk_buff *__skb_recv_datagram(struct sock *sk, unsigned flags,
                                     int *peeked, int *off, int *err);
 struct sk_buff *skb_recv_datagram(struct sock *sk, unsigned flags, int noblock,
                                   int *err);
-__poll_t datagram_poll_mask(struct socket *sock, __poll_t events);
+__poll_t datagram_poll(struct file *file, struct socket *sock,
+                           struct poll_table_struct *wait);
 int skb_copy_datagram_iter(const struct sk_buff *from, int offset,
                            struct iov_iter *to, int size);
 static inline int skb_copy_datagram_msg(const struct sk_buff *from, int offset,
diff --git a/include/linux/slab.h b/include/linux/slab.h
index 4d759e1ddc33..14e3fe4bd6a1 100644
--- a/include/linux/slab.h
+++ b/include/linux/slab.h
@@ -600,6 +600,7 @@ struct memcg_cache_params {
                         struct memcg_cache_array __rcu *memcg_caches;
                         struct list_head __root_caches_node;
                         struct list_head children;
+                        bool dying;
                 };
                 struct {
                         struct mem_cgroup *memcg;
diff --git a/include/linux/slub_def.h b/include/linux/slub_def.h
index 09fa2c6f0e68..3a1a1dbc6f49 100644
--- a/include/linux/slub_def.h
+++ b/include/linux/slub_def.h
@@ -155,8 +155,12 @@ struct kmem_cache {
 
 #ifdef CONFIG_SYSFS
 #define SLAB_SUPPORTS_SYSFS
+void sysfs_slab_unlink(struct kmem_cache *);
 void sysfs_slab_release(struct kmem_cache *);
 #else
+static inline void sysfs_slab_unlink(struct kmem_cache *s)
+{
+}
 static inline void sysfs_slab_release(struct kmem_cache *s)
 {
 }
diff --git a/include/linux/soc/qcom/smem.h b/include/linux/soc/qcom/smem.h
index c1657ed27b30..86e1b358688a 100644
--- a/include/linux/soc/qcom/smem.h
+++ b/include/linux/soc/qcom/smem.h
@@ -9,4 +9,6 @@ void *qcom_smem_get(unsigned host, unsigned item, size_t *size);
 
 int qcom_smem_get_free_space(unsigned host);
 
+phys_addr_t qcom_smem_virt_to_phys(void *p);
+
 #endif
diff --git a/include/linux/soc/ti/ti_sci_protocol.h b/include/linux/soc/ti/ti_sci_protocol.h
index 0ccbc138c26a..18435e5c6364 100644
--- a/include/linux/soc/ti/ti_sci_protocol.h
+++ b/include/linux/soc/ti/ti_sci_protocol.h
@@ -1,17 +1,9 @@
+// SPDX-License-Identifier: GPL-2.0
 /*
  * Texas Instruments System Control Interface Protocol
  *
  * Copyright (C) 2015-2016 Texas Instruments Incorporated - http://www.ti.com/
  *      Nishanth Menon
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- *
- * This program is distributed "as is" WITHOUT ANY WARRANTY of any
- * kind, whether express or implied; without even the implied warranty
- * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
  */
 
 #ifndef __TISCI_PROTOCOL_H
diff --git a/include/linux/spinlock.h b/include/linux/spinlock.h
index 1e8a46435838..fd57888d4942 100644
--- a/include/linux/spinlock.h
+++ b/include/linux/spinlock.h
@@ -427,6 +427,11 @@ extern int _atomic_dec_and_lock(atomic_t *atomic, spinlock_t *lock);
 #define atomic_dec_and_lock(atomic, lock) \
                 __cond_lock(lock, _atomic_dec_and_lock(atomic, lock))
 
+extern int _atomic_dec_and_lock_irqsave(atomic_t *atomic, spinlock_t *lock,
+                                        unsigned long *flags);
+#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);
diff --git a/include/linux/stackprotector.h b/include/linux/stackprotector.h
index 03696c729fb4..6b792d080eee 100644
--- a/include/linux/stackprotector.h
+++ b/include/linux/stackprotector.h
@@ -6,7 +6,7 @@
 #include <linux/sched.h>
 #include <linux/random.h>
 
-#ifdef CONFIG_CC_STACKPROTECTOR
+#ifdef CONFIG_STACKPROTECTOR
 # include <asm/stackprotector.h>
 #else
 static inline void boot_init_stack_canary(void)
diff --git a/include/linux/stat.h b/include/linux/stat.h
index 22484e44544d..765573dc17d6 100644
--- a/include/linux/stat.h
+++ b/include/linux/stat.h
@@ -41,10 +41,10 @@ struct kstat {
         kuid_t          uid;
         kgid_t          gid;
         loff_t          size;
-        struct timespec atime;
-        struct timespec mtime;
-        struct timespec ctime;
-        struct timespec btime;                  /* File creation time */
+        struct timespec64 atime;
+        struct timespec64 mtime;
+        struct timespec64 ctime;
+        struct timespec64 btime;                        /* File creation time */
         u64             blocks;
 };
 
diff --git a/include/linux/ste_modem_shm.h b/include/linux/ste_modem_shm.h
deleted file mode 100644
index 8444a4eff1bb..000000000000
--- a/include/linux/ste_modem_shm.h
+++ /dev/null
@@ -1,56 +0,0 @@
-/*
- * Copyright (C) ST-Ericsson AB 2012
- * Author: Sjur Brendeland / sjur.brandeland@stericsson.com
- *
- * License terms: GNU General Public License (GPL) version 2
- */
-
-#ifndef __INC_MODEM_DEV_H
-#define __INC_MODEM_DEV_H
-#include <linux/types.h>
-#include <linux/platform_device.h>
-
-struct ste_modem_device;
-
-/**
- * struct ste_modem_dev_cb - Callbacks for modem initiated events.
- * @kick: Called when the modem kicks the host.
- *
- * This structure contains callbacks for actions triggered by the modem.
- */
-struct ste_modem_dev_cb {
-        void (*kick)(struct ste_modem_device *mdev, int notify_id);
-};
-
-/**
- * struct ste_modem_dev_ops - Functions to control modem and modem interface.
- *
- * @power:      Main power switch, used for cold-start or complete power off.
- * @kick:       Kick the modem.
- * @kick_subscribe: Subscribe for notifications from the modem.
- * @setup:      Provide callback functions to modem device.
- *
- * This structure contains functions used by the ste remoteproc driver
- * to manage the modem.
- */
-struct ste_modem_dev_ops {
-        int (*power)(struct ste_modem_device *mdev, bool on);
-        int (*kick)(struct ste_modem_device *mdev, int notify_id);
-        int (*kick_subscribe)(struct ste_modem_device *mdev, int notify_id);
-        int (*setup)(struct ste_modem_device *mdev,
-                     struct ste_modem_dev_cb *cfg);
-};
-
-/**
- * struct ste_modem_device - represent the STE modem device
- * @pdev: Reference to platform device
- * @ops: Operations used to manage the modem.
- * @drv_data: Driver private data.
- */
-struct ste_modem_device {
-        struct platform_device pdev;
-        struct ste_modem_dev_ops ops;
-        void *drv_data;
-};
-
-#endif /*INC_MODEM_DEV_H*/
diff --git a/include/linux/string_helpers.h b/include/linux/string_helpers.h
index 4397c52ec4a4..d23c5030901a 100644
--- a/include/linux/string_helpers.h
+++ b/include/linux/string_helpers.h
@@ -5,6 +5,7 @@
 #include <linux/types.h>
 
 struct file;
+struct task_struct;
 
 /* Descriptions of the types of units to
  * print in */
diff --git a/include/linux/sunrpc/rpc_rdma.h b/include/linux/sunrpc/rpc_rdma.h
index 8f144db73e38..92d182fd8e3b 100644
--- a/include/linux/sunrpc/rpc_rdma.h
+++ b/include/linux/sunrpc/rpc_rdma.h
@@ -1,3 +1,4 @@
+/* SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause */
 /*
  * Copyright (c) 2015-2017 Oracle. All rights reserved.
  * Copyright (c) 2003-2007 Network Appliance, Inc. All rights reserved.
diff --git a/include/linux/sunrpc/svc_rdma.h b/include/linux/sunrpc/svc_rdma.h
index 7337e1221590..fd78f78df5c6 100644
--- a/include/linux/sunrpc/svc_rdma.h
+++ b/include/linux/sunrpc/svc_rdma.h
@@ -1,3 +1,4 @@
+/* SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause */
 /*
  * Copyright (c) 2005-2006 Network Appliance, Inc. All rights reserved.
  *
@@ -70,37 +71,16 @@ extern atomic_t rdma_stat_rq_prod;
 extern atomic_t rdma_stat_sq_poll;
 extern atomic_t rdma_stat_sq_prod;
 
-/*
- * Contexts are built when an RDMA request is created and are a
- * record of the resources that can be recovered when the request
- * completes.
- */
-struct svc_rdma_op_ctxt {
-        struct list_head list;
-        struct xdr_buf arg;
-        struct ib_cqe cqe;
-        u32 byte_len;
-        struct svcxprt_rdma *xprt;
-        enum dma_data_direction direction;
-        int count;
-        unsigned int mapped_sges;
-        int hdr_count;
-        struct ib_send_wr send_wr;
-        struct ib_sge sge[1 + RPCRDMA_MAX_INLINE_THRESH / PAGE_SIZE];
-        struct page *pages[RPCSVC_MAXPAGES];
-};
-
 struct svcxprt_rdma {
         struct svc_xprt      sc_xprt;           /* SVC transport structure */
         struct rdma_cm_id    *sc_cm_id;         /* RDMA connection id */
         struct list_head     sc_accept_q;       /* Conn. waiting accept */
         int                  sc_ord;            /* RDMA read limit */
-        int                  sc_max_sge;
+        int                  sc_max_send_sges;
         bool                 sc_snd_w_inv;      /* OK to use Send With Invalidate */
 
         atomic_t             sc_sq_avail;       /* SQEs ready to be consumed */
         unsigned int         sc_sq_depth;       /* Depth of SQ */
-        unsigned int         sc_rq_depth;       /* Depth of RQ */
         __be32               sc_fc_credits;     /* Forward credits */
         u32                  sc_max_requests;   /* Max requests */
         u32                  sc_max_bc_requests;/* Backward credits */
@@ -109,9 +89,8 @@ struct svcxprt_rdma {
 
         struct ib_pd         *sc_pd;
 
-        spinlock_t           sc_ctxt_lock;
-        struct list_head     sc_ctxts;
-        int                  sc_ctxt_used;
+        spinlock_t           sc_send_lock;
+        struct list_head     sc_send_ctxts;
         spinlock_t           sc_rw_ctxt_lock;
         struct list_head     sc_rw_ctxts;
 
@@ -127,6 +106,9 @@ struct svcxprt_rdma {
         unsigned long        sc_flags;
         struct list_head     sc_read_complete_q;
         struct work_struct   sc_work;
+
+        spinlock_t           sc_recv_lock;
+        struct list_head     sc_recv_ctxts;
 };
 /* sc_flags */
 #define RDMAXPRT_CONN_PENDING   3
@@ -141,12 +123,30 @@ struct svcxprt_rdma {
 
 #define RPCSVC_MAXPAYLOAD_RDMA  RPCSVC_MAXPAYLOAD
 
-/* Track DMA maps for this transport and context */
-static inline void svc_rdma_count_mappings(struct svcxprt_rdma *rdma,
-                                           struct svc_rdma_op_ctxt *ctxt)
-{
-        ctxt->mapped_sges++;
-}
+struct svc_rdma_recv_ctxt {
+        struct list_head        rc_list;
+        struct ib_recv_wr       rc_recv_wr;
+        struct ib_cqe           rc_cqe;
+        struct ib_sge           rc_recv_sge;
+        void                    *rc_recv_buf;
+        struct xdr_buf          rc_arg;
+        bool                    rc_temp;
+        u32                     rc_byte_len;
+        unsigned int            rc_page_count;
+        unsigned int            rc_hdr_count;
+        struct page             *rc_pages[RPCSVC_MAXPAGES];
+};
+
+struct svc_rdma_send_ctxt {
+        struct list_head        sc_list;
+        struct ib_send_wr       sc_send_wr;
+        struct ib_cqe           sc_cqe;
+        void                    *sc_xprt_buf;
+        int                     sc_page_count;
+        int                     sc_cur_sge_no;
+        struct page             *sc_pages[RPCSVC_MAXPAGES];
+        struct ib_sge           sc_sges[];
+};
 
 /* svc_rdma_backchannel.c */
 extern int svc_rdma_handle_bc_reply(struct rpc_xprt *xprt,
@@ -154,13 +154,18 @@ extern int svc_rdma_handle_bc_reply(struct rpc_xprt *xprt,
                                     struct xdr_buf *rcvbuf);
 
 /* svc_rdma_recvfrom.c */
+extern void svc_rdma_recv_ctxts_destroy(struct svcxprt_rdma *rdma);
+extern bool svc_rdma_post_recvs(struct svcxprt_rdma *rdma);
+extern void svc_rdma_recv_ctxt_put(struct svcxprt_rdma *rdma,
+                                   struct svc_rdma_recv_ctxt *ctxt);
+extern void svc_rdma_flush_recv_queues(struct svcxprt_rdma *rdma);
 extern int svc_rdma_recvfrom(struct svc_rqst *);
 
 /* svc_rdma_rw.c */
 extern void svc_rdma_destroy_rw_ctxts(struct svcxprt_rdma *rdma);
 extern int svc_rdma_recv_read_chunk(struct svcxprt_rdma *rdma,
                                     struct svc_rqst *rqstp,
-                                    struct svc_rdma_op_ctxt *head, __be32 *p);
+                                    struct svc_rdma_recv_ctxt *head, __be32 *p);
 extern int svc_rdma_send_write_chunk(struct svcxprt_rdma *rdma,
                                      __be32 *wr_ch, struct xdr_buf *xdr);
 extern int svc_rdma_send_reply_chunk(struct svcxprt_rdma *rdma,
@@ -168,24 +173,22 @@ extern int svc_rdma_send_reply_chunk(struct svcxprt_rdma *rdma,
                                      struct xdr_buf *xdr);
 
 /* svc_rdma_sendto.c */
-extern int svc_rdma_map_reply_hdr(struct svcxprt_rdma *rdma,
-                                  struct svc_rdma_op_ctxt *ctxt,
-                                  __be32 *rdma_resp, unsigned int len);
-extern int svc_rdma_post_send_wr(struct svcxprt_rdma *rdma,
-                                 struct svc_rdma_op_ctxt *ctxt,
-                                 int num_sge, u32 inv_rkey);
+extern void svc_rdma_send_ctxts_destroy(struct svcxprt_rdma *rdma);
+extern struct svc_rdma_send_ctxt *
+                svc_rdma_send_ctxt_get(struct svcxprt_rdma *rdma);
+extern void svc_rdma_send_ctxt_put(struct svcxprt_rdma *rdma,
+                                   struct svc_rdma_send_ctxt *ctxt);
+extern int svc_rdma_send(struct svcxprt_rdma *rdma, struct ib_send_wr *wr);
+extern void svc_rdma_sync_reply_hdr(struct svcxprt_rdma *rdma,
+                                    struct svc_rdma_send_ctxt *ctxt,
+                                    unsigned int len);
+extern int svc_rdma_map_reply_msg(struct svcxprt_rdma *rdma,
+                                  struct svc_rdma_send_ctxt *ctxt,
+                                  struct xdr_buf *xdr, __be32 *wr_lst);
 extern int svc_rdma_sendto(struct svc_rqst *);
 
 /* svc_rdma_transport.c */
-extern void svc_rdma_wc_send(struct ib_cq *, struct ib_wc *);
-extern void svc_rdma_wc_reg(struct ib_cq *, struct ib_wc *);
-extern void svc_rdma_wc_read(struct ib_cq *, struct ib_wc *);
-extern void svc_rdma_wc_inv(struct ib_cq *, struct ib_wc *);
-extern int svc_rdma_send(struct svcxprt_rdma *, struct ib_send_wr *);
 extern int svc_rdma_create_listen(struct svc_serv *, int, struct sockaddr *);
-extern struct svc_rdma_op_ctxt *svc_rdma_get_context(struct svcxprt_rdma *);
-extern void svc_rdma_put_context(struct svc_rdma_op_ctxt *, int);
-extern void svc_rdma_unmap_dma(struct svc_rdma_op_ctxt *ctxt);
 extern void svc_sq_reap(struct svcxprt_rdma *);
 extern void svc_rq_reap(struct svcxprt_rdma *);
 extern void svc_rdma_prep_reply_hdr(struct svc_rqst *);
diff --git a/include/linux/sunrpc/xprt.h b/include/linux/sunrpc/xprt.h
index 5fea0fb420df..336fd1a19cca 100644
--- a/include/linux/sunrpc/xprt.h
+++ b/include/linux/sunrpc/xprt.h
@@ -84,7 +84,6 @@ struct rpc_rqst {
         void (*rq_release_snd_buf)(struct rpc_rqst *); /* release rq_enc_pages */
         struct list_head        rq_list;
 
-        void                    *rq_xprtdata;   /* Per-xprt private data */
         void                    *rq_buffer;     /* Call XDR encode buffer */
         size_t                  rq_callsize;
         void                    *rq_rbuffer;    /* Reply XDR decode buffer */
@@ -127,6 +126,8 @@ struct rpc_xprt_ops {
         int             (*reserve_xprt)(struct rpc_xprt *xprt, struct rpc_task *task);
         void            (*release_xprt)(struct rpc_xprt *xprt, struct rpc_task *task);
         void            (*alloc_slot)(struct rpc_xprt *xprt, struct rpc_task *task);
+        void            (*free_slot)(struct rpc_xprt *xprt,
+                                     struct rpc_rqst *req);
         void            (*rpcbind)(struct rpc_task *task);
         void            (*set_port)(struct rpc_xprt *xprt, unsigned short port);
         void            (*connect)(struct rpc_xprt *xprt, struct rpc_task *task);
@@ -324,10 +325,13 @@ struct xprt_class {
 struct rpc_xprt         *xprt_create_transport(struct xprt_create *args);
 void                    xprt_connect(struct rpc_task *task);
 void                    xprt_reserve(struct rpc_task *task);
+void                    xprt_request_init(struct rpc_task *task);
 void                    xprt_retry_reserve(struct rpc_task *task);
 int                     xprt_reserve_xprt(struct rpc_xprt *xprt, struct rpc_task *task);
 int                     xprt_reserve_xprt_cong(struct rpc_xprt *xprt, struct rpc_task *task);
 void                    xprt_alloc_slot(struct rpc_xprt *xprt, struct rpc_task *task);
+void                    xprt_free_slot(struct rpc_xprt *xprt,
+                                       struct rpc_rqst *req);
 void                    xprt_lock_and_alloc_slot(struct rpc_xprt *xprt, struct rpc_task *task);
 bool                    xprt_prepare_transmit(struct rpc_task *task);
 void                    xprt_transmit(struct rpc_task *task);
diff --git a/include/linux/sunrpc/xprtrdma.h b/include/linux/sunrpc/xprtrdma.h
index 5859563e3c1f..86fc38ff0355 100644
--- a/include/linux/sunrpc/xprtrdma.h
+++ b/include/linux/sunrpc/xprtrdma.h
@@ -1,3 +1,4 @@
+/* SPDX-License-Identifier: GPL-2.0 OR BSD-3-Clause */
 /*
  * Copyright (c) 2003-2007 Network Appliance, Inc. All rights reserved.
  *
diff --git a/include/linux/syscalls.h b/include/linux/syscalls.h
index 390e814fdc8d..a368a68cb667 100644
--- a/include/linux/syscalls.h
+++ b/include/linux/syscalls.h
@@ -66,6 +66,7 @@ struct old_linux_dirent;
 struct perf_event_attr;
 struct file_handle;
 struct sigaltstack;
+struct rseq;
 union bpf_attr;
 
 #include <linux/types.h>
@@ -230,6 +231,9 @@ static inline int is_syscall_trace_event(struct trace_event_call *tp_event)
  */
 #ifndef __SYSCALL_DEFINEx
 #define __SYSCALL_DEFINEx(x, name, ...)                                 \
+        __diag_push();                                                  \
+        __diag_ignore(GCC, 8, "-Wattribute-alias",                      \
+                      "Type aliasing is used to sanitize syscall arguments");\
         asmlinkage long sys##name(__MAP(x,__SC_DECL,__VA_ARGS__))       \
                 __attribute__((alias(__stringify(__se_sys##name))));    \
         ALLOW_ERROR_INJECTION(sys##name, ERRNO);                        \
@@ -242,6 +246,7 @@ static inline int is_syscall_trace_event(struct trace_event_call *tp_event)
                 __PROTECT(x, ret,__MAP(x,__SC_ARGS,__VA_ARGS__));       \
                 return ret;                                             \
         }                                                               \
+        __diag_pop();                                                   \
         static inline long __do_sys##name(__MAP(x,__SC_DECL,__VA_ARGS__))
 #endif /* __SYSCALL_DEFINEx */
 
@@ -897,7 +902,8 @@ asmlinkage long sys_pkey_alloc(unsigned long flags, unsigned long init_val);
 asmlinkage long sys_pkey_free(int pkey);
 asmlinkage long sys_statx(int dfd, const char __user *path, unsigned flags,
                           unsigned mask, struct statx __user *buffer);
-
+asmlinkage long sys_rseq(struct rseq __user *rseq, uint32_t rseq_len,
+                         int flags, uint32_t sig);
 
 /*
  * Architecture-specific system calls
diff --git a/include/linux/thermal.h b/include/linux/thermal.h
index 7834be668d80..5f4705f46c2f 100644
--- a/include/linux/thermal.h
+++ b/include/linux/thermal.h
@@ -1,25 +1,10 @@
+/* SPDX-License-Identifier: GPL-2.0 */
 /*
  *  thermal.h  ($Revision: 0 $)
  *
  *  Copyright (C) 2008  Intel Corp
  *  Copyright (C) 2008  Zhang Rui <rui.zhang@intel.com>
  *  Copyright (C) 2008  Sujith Thomas <sujith.thomas@intel.com>
- *
- * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- *  This program is free software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License as published by
- *  the Free Software Foundation; version 2 of the License.
- *
- *  This program is distributed in the hope that it will be useful, but
- *  WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- *  General Public License for more details.
- *
- *  You should have received a copy of the GNU General Public License along
- *  with this program; if not, write to the Free Software Foundation, Inc.,
- *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
- *
- * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  */
 
 #ifndef __THERMAL_H__
diff --git a/include/linux/thread_info.h b/include/linux/thread_info.h
index cf2862bd134a..8d8821b3689a 100644
--- a/include/linux/thread_info.h
+++ b/include/linux/thread_info.h
@@ -60,6 +60,15 @@ static inline void clear_ti_thread_flag(struct thread_info *ti, int flag)
         clear_bit(flag, (unsigned long *)&ti->flags);
 }
 
+static inline void update_ti_thread_flag(struct thread_info *ti, int flag,
+                                         bool value)
+{
+        if (value)
+                set_ti_thread_flag(ti, flag);
+        else
+                clear_ti_thread_flag(ti, flag);
+}
+
 static inline int test_and_set_ti_thread_flag(struct thread_info *ti, int flag)
 {
         return test_and_set_bit(flag, (unsigned long *)&ti->flags);
@@ -79,6 +88,8 @@ static inline int test_ti_thread_flag(struct thread_info *ti, int flag)
         set_ti_thread_flag(current_thread_info(), flag)
 #define clear_thread_flag(flag) \
         clear_ti_thread_flag(current_thread_info(), flag)
+#define update_thread_flag(flag, value) \
+        update_ti_thread_flag(current_thread_info(), flag, value)
 #define test_and_set_thread_flag(flag) \
         test_and_set_ti_thread_flag(current_thread_info(), flag)
 #define test_and_clear_thread_flag(flag) \
diff --git a/include/linux/tracepoint.h b/include/linux/tracepoint.h
index c94f466d57ef..19a690b559ca 100644
--- a/include/linux/tracepoint.h
+++ b/include/linux/tracepoint.h
@@ -4,7 +4,7 @@
 /*
  * Kernel Tracepoint API.
  *
- * See Documentation/trace/tracepoints.txt.
+ * See Documentation/trace/tracepoints.rst.
  *
  * Copyright (C) 2008-2014 Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
  *
diff --git a/include/linux/uio.h b/include/linux/uio.h
index f5766e853a77..409c845d4cd3 100644
--- a/include/linux/uio.h
+++ b/include/linux/uio.h
@@ -155,7 +155,7 @@ size_t _copy_from_iter_flushcache(void *addr, size_t bytes, struct iov_iter *i);
 #endif
 
 #ifdef CONFIG_ARCH_HAS_UACCESS_MCSAFE
-size_t _copy_to_iter_mcsafe(void *addr, size_t bytes, struct iov_iter *i);
+size_t _copy_to_iter_mcsafe(const void *addr, size_t bytes, struct iov_iter *i);
 #else
 #define _copy_to_iter_mcsafe _copy_to_iter
 #endif
diff --git a/include/linux/virtio_net.h b/include/linux/virtio_net.h
index f144216febc6..9397628a1967 100644
--- a/include/linux/virtio_net.h
+++ b/include/linux/virtio_net.h
@@ -58,7 +58,8 @@ static inline int virtio_net_hdr_to_skb(struct sk_buff *skb,
 static inline int virtio_net_hdr_from_skb(const struct sk_buff *skb,
                                           struct virtio_net_hdr *hdr,
                                           bool little_endian,
-                                          bool has_data_valid)
+                                          bool has_data_valid,
+                                          int vlan_hlen)
 {
         memset(hdr, 0, sizeof(*hdr));   /* no info leak */
 
@@ -83,12 +84,8 @@ static inline int virtio_net_hdr_from_skb(const struct sk_buff *skb,
 
         if (skb->ip_summed == CHECKSUM_PARTIAL) {
                 hdr->flags = VIRTIO_NET_HDR_F_NEEDS_CSUM;
-                if (skb_vlan_tag_present(skb))
-                        hdr->csum_start = __cpu_to_virtio16(little_endian,
-                                skb_checksum_start_offset(skb) + VLAN_HLEN);
-                else
-                        hdr->csum_start = __cpu_to_virtio16(little_endian,
-                                skb_checksum_start_offset(skb));
+                hdr->csum_start = __cpu_to_virtio16(little_endian,
+                        skb_checksum_start_offset(skb) + vlan_hlen);
                 hdr->csum_offset = __cpu_to_virtio16(little_endian,
                                 skb->csum_offset);
         } else if (has_data_valid &&
diff --git a/include/linux/virtio_ring.h b/include/linux/virtio_ring.h
index bbf32524ab27..fab02133a919 100644
--- a/include/linux/virtio_ring.h
+++ b/include/linux/virtio_ring.h
@@ -35,7 +35,7 @@ static inline void virtio_rmb(bool weak_barriers)
         if (weak_barriers)
                 virt_rmb();
         else
-                rmb();
+                dma_rmb();
 }
 
 static inline void virtio_wmb(bool weak_barriers)
@@ -43,7 +43,7 @@ static inline void virtio_wmb(bool weak_barriers)
         if (weak_barriers)
                 virt_wmb();
         else
-                wmb();
+                dma_wmb();
 }
 
 static inline void virtio_store_mb(bool weak_barriers,