306 files changed, 6482 insertions, 3220 deletions

diff --git a/include/linux/acpi.h b/include/linux/acpi.h
index de8d3d3fa651..ed80f147bd50 100644
--- a/include/linux/acpi.h
+++ b/include/linux/acpi.h
@@ -831,8 +831,6 @@ static inline int acpi_dma_configure(struct device *dev,
         return 0;
 }
 
-static inline void acpi_dma_deconfigure(struct device *dev) { }
-
 #define ACPI_PTR(_ptr)  (NULL)
 
 static inline void acpi_device_set_enumerated(struct acpi_device *adev)
@@ -1074,6 +1072,15 @@ static inline int acpi_node_get_property_reference(
                 NR_FWNODE_REFERENCE_ARGS, args);
 }
 
+static inline bool acpi_dev_has_props(const struct acpi_device *adev)
+{
+        return !list_empty(&adev->data.properties);
+}
+
+struct acpi_device_properties *
+acpi_data_add_props(struct acpi_device_data *data, const guid_t *guid,
+                    const union acpi_object *properties);
+
 int acpi_node_prop_get(const struct fwnode_handle *fwnode, const char *propname,
                        void **valptr);
 int acpi_dev_prop_read_single(struct acpi_device *adev,
diff --git a/include/linux/adxl.h b/include/linux/adxl.h
new file mode 100644
index 000000000000..2a629acb4c3f
--- /dev/null
+++ b/include/linux/adxl.h
@@ -0,0 +1,13 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Address translation interface via ACPI DSM.
+ * Copyright (C) 2018 Intel Corporation
+ */
+
+#ifndef _LINUX_ADXL_H
+#define _LINUX_ADXL_H
+
+const char * const *adxl_get_component_names(void);
+int adxl_decode(u64 addr, u64 component_values[]);
+
+#endif /* _LINUX_ADXL_H */
diff --git a/include/linux/amba/mmci.h b/include/linux/amba/mmci.h
index da8357ba11bc..c92ebc39fc1f 100644
--- a/include/linux/amba/mmci.h
+++ b/include/linux/amba/mmci.h
@@ -18,20 +18,13 @@
  * mask into a value to be binary (or set some other custom bits
  * in MMCIPWR) or:ed and written into the MMCIPWR register of the
  * block.  May also control external power based on the power_mode.
- * @status: if no GPIO read function was given to the block in
- * gpio_wp (below) this function will be called to determine
- * whether a card is present in the MMC slot or not
- * @gpio_wp: read this GPIO pin to see if the card is write protected
- * @gpio_cd: read this GPIO pin to detect card insertion
- * @cd_invert: true if the gpio_cd pin value is active low
+ * @status: if no GPIO line was given to the block in this function will
+ * be called to determine whether a card is present in the MMC slot or not
  */
 struct mmci_platform_data {
         unsigned int ocr_mask;
         int (*ios_handler)(struct device *, struct mmc_ios *);
         unsigned int (*status)(struct device *);
-        int     gpio_wp;
-        int     gpio_cd;
-        bool    cd_invert;
 };
 
 #endif
diff --git a/include/linux/amifd.h b/include/linux/amifd.h
deleted file mode 100644
index 202a77dbe46d..000000000000
--- a/include/linux/amifd.h
+++ /dev/null
@@ -1,63 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-#ifndef _AMIFD_H
-#define _AMIFD_H
-
-/* Definitions for the Amiga floppy driver */
-
-#include <linux/fd.h>
-
-#define FD_MAX_UNITS    4       /* Max. Number of drives */
-#define FLOPPY_MAX_SECTORS      22      /* Max. Number of sectors per track */
-
-#ifndef ASSEMBLER
-
-struct fd_data_type {
-    char *name;                 /* description of data type */
-    int sects;                  /* sectors per track */
-#ifdef __STDC__
-    int (*read_fkt)(int);
-    void (*write_fkt)(int);
-#else
-    int (*read_fkt)();          /* read whole track */
-    void (*write_fkt)();                /* write whole track */
-#endif
-};
-
-/*
-** Floppy type descriptions
-*/
-
-struct fd_drive_type {
-    unsigned long code;         /* code returned from drive */
-    char *name;                 /* description of drive */
-    unsigned int tracks;        /* number of tracks */
-    unsigned int heads;         /* number of heads */
-    unsigned int read_size;     /* raw read size for one track */
-    unsigned int write_size;    /* raw write size for one track */
-    unsigned int sect_mult;     /* sectors and gap multiplier (HD = 2) */
-    unsigned int precomp1;      /* start track for precomp 1 */
-    unsigned int precomp2;      /* start track for precomp 2 */
-    unsigned int step_delay;    /* time (in ms) for delay after step */
-    unsigned int settle_time;   /* time to settle after dir change */
-    unsigned int side_time;     /* time needed to change sides */
-};
-
-struct amiga_floppy_struct {
-    struct fd_drive_type *type; /* type of floppy for this unit */
-    struct fd_data_type *dtype; /* type of floppy for this unit */
-    int track;                  /* current track (-1 == unknown) */
-    unsigned char *trackbuf;    /* current track (kmaloc()'d */
-
-    int blocks;                 /* total # blocks on disk */
-
-    int changed;                /* true when not known */
-    int disk;                   /* disk in drive (-1 == unknown) */
-    int motor;                  /* true when motor is at speed */
-    int busy;                   /* true when drive is active */
-    int dirty;                  /* true when trackbuf is not on disk */
-    int status;                 /* current error code for unit */
-    struct gendisk *gendisk;
-};
-#endif
-
-#endif
diff --git a/include/linux/amifdreg.h b/include/linux/amifdreg.h
deleted file mode 100644
index 9b514d05ec70..000000000000
--- a/include/linux/amifdreg.h
+++ /dev/null
@@ -1,82 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-#ifndef _LINUX_AMIFDREG_H
-#define _LINUX_AMIFDREG_H
-
-/*
-** CIAAPRA bits (read only)
-*/
-
-#define DSKRDY      (0x1<<5)        /* disk ready when low */
-#define DSKTRACK0   (0x1<<4)        /* head at track zero when low */
-#define DSKPROT     (0x1<<3)        /* disk protected when low */
-#define DSKCHANGE   (0x1<<2)        /* low when disk removed */
-
-/*
-** CIAAPRB bits (read/write)
-*/
-
-#define DSKMOTOR    (0x1<<7)        /* motor on when low */
-#define DSKSEL3     (0x1<<6)        /* select drive 3 when low */
-#define DSKSEL2     (0x1<<5)        /* select drive 2 when low */
-#define DSKSEL1     (0x1<<4)        /* select drive 1 when low */
-#define DSKSEL0     (0x1<<3)        /* select drive 0 when low */
-#define DSKSIDE     (0x1<<2)        /* side selection: 0 = upper, 1 = lower */
-#define DSKDIREC    (0x1<<1)        /* step direction: 0=in, 1=out (to trk 0) */
-#define DSKSTEP     (0x1)           /* pulse low to step head 1 track */
-
-/*
-** DSKBYTR bits (read only)
-*/
-
-#define DSKBYT      (1<<15)         /* register contains valid byte when set */
-#define DMAON       (1<<14)         /* disk DMA enabled */
-#define DISKWRITE   (1<<13)         /* disk write bit in DSKLEN enabled */
-#define WORDEQUAL   (1<<12)         /* DSKSYNC register match when true */
-/* bits 7-0 are data */
-
-/*
-** ADKCON/ADKCONR bits
-*/
-
-#ifndef SETCLR
-#define ADK_SETCLR      (1<<15)     /* control bit */
-#endif
-#define ADK_PRECOMP1    (1<<14)     /* precompensation selection */
-#define ADK_PRECOMP0    (1<<13)     /* 00=none, 01=140ns, 10=280ns, 11=500ns */
-#define ADK_MFMPREC     (1<<12)     /* 0=GCR precomp., 1=MFM precomp. */
-#define ADK_WORDSYNC    (1<<10)     /* enable DSKSYNC auto DMA */
-#define ADK_MSBSYNC     (1<<9)      /* when 1, enable sync on MSbit (for GCR) */
-#define ADK_FAST        (1<<8)      /* bit cell: 0=2us (GCR), 1=1us (MFM) */
- 
-/*
-** DSKLEN bits
-*/
-
-#define DSKLEN_DMAEN    (1<<15)
-#define DSKLEN_WRITE    (1<<14)
-
-/*
-** INTENA/INTREQ bits
-*/
-
-#define DSKINDEX    (0x1<<4)        /* DSKINDEX bit */
-
-/*
-** Misc
-*/
- 
-#define MFM_SYNC    0x4489          /* standard MFM sync value */
-
-/* Values for FD_COMMAND */
-#define FD_RECALIBRATE          0x07    /* move to track 0 */
-#define FD_SEEK                 0x0F    /* seek track */
-#define FD_READ                 0xE6    /* read with MT, MFM, SKip deleted */
-#define FD_WRITE                0xC5    /* write with MT, MFM */
-#define FD_SENSEI               0x08    /* Sense Interrupt Status */
-#define FD_SPECIFY              0x03    /* specify HUT etc */
-#define FD_FORMAT               0x4D    /* format one track */
-#define FD_VERSION              0x10    /* get version code */
-#define FD_CONFIGURE            0x13    /* configure FIFO operation */
-#define FD_PERPENDICULAR        0x12    /* perpendicular r/w mode */
-
-#endif /* _LINUX_AMIFDREG_H */
diff --git a/include/linux/arch_topology.h b/include/linux/arch_topology.h
index 2b709416de05..d9bdc1a7f4e7 100644
--- a/include/linux/arch_topology.h
+++ b/include/linux/arch_topology.h
@@ -9,6 +9,7 @@
 #include <linux/percpu.h>
 
 void topology_normalize_cpu_scale(void);
+int topology_update_cpu_topology(void);
 
 struct device_node;
 bool topology_parse_cpu_capacity(struct device_node *cpu_node, int cpu);
diff --git a/include/linux/avf/virtchnl.h b/include/linux/avf/virtchnl.h
index 212b3822d180..2c9756bd9c4c 100644
--- a/include/linux/avf/virtchnl.h
+++ b/include/linux/avf/virtchnl.h
@@ -252,6 +252,8 @@ VIRTCHNL_CHECK_STRUCT_LEN(16, virtchnl_vsi_resource);
 #define VIRTCHNL_VF_OFFLOAD_RX_ENCAP_CSUM       0X00400000
 #define VIRTCHNL_VF_OFFLOAD_ADQ                 0X00800000
 
+/* Define below the capability flags that are not offloads */
+#define VIRTCHNL_VF_CAP_ADV_LINK_SPEED          0x00000080
 #define VF_BASE_MODE_OFFLOADS (VIRTCHNL_VF_OFFLOAD_L2 | \
                                VIRTCHNL_VF_OFFLOAD_VLAN | \
                                VIRTCHNL_VF_OFFLOAD_RSS_PF)
@@ -573,7 +575,7 @@ struct virtchnl_filter {
         enum    virtchnl_flow_type flow_type;
         enum    virtchnl_action action;
         u32     action_meta;
-        __u8    field_flags;
+        u8      field_flags;
 };
 
 VIRTCHNL_CHECK_STRUCT_LEN(272, virtchnl_filter);
@@ -596,10 +598,23 @@ enum virtchnl_event_codes {
 struct virtchnl_pf_event {
         enum virtchnl_event_codes event;
         union {
+                /* If the PF driver does not support the new speed reporting
+                 * capabilities then use link_event else use link_event_adv to
+                 * get the speed and link information. The ability to understand
+                 * new speeds is indicated by setting the capability flag
+                 * VIRTCHNL_VF_CAP_ADV_LINK_SPEED in vf_cap_flags parameter
+                 * in virtchnl_vf_resource struct and can be used to determine
+                 * which link event struct to use below.
+                 */
                 struct {
                         enum virtchnl_link_speed link_speed;
                         bool link_status;
                 } link_event;
+                struct {
+                        /* link_speed provided in Mbps */
+                        u32 link_speed;
+                        u8 link_status;
+                } link_event_adv;
         } event_data;
 
         int severity;
diff --git a/include/linux/binfmts.h b/include/linux/binfmts.h
index c05f24fac4f6..e9f5fe69df31 100644
--- a/include/linux/binfmts.h
+++ b/include/linux/binfmts.h
@@ -78,7 +78,7 @@ struct linux_binprm {
 
 /* Function parameter for binfmt->coredump */
 struct coredump_params {
-        const siginfo_t *siginfo;
+        const kernel_siginfo_t *siginfo;
         struct pt_regs *regs;
         struct file *file;
         unsigned long limit;
diff --git a/include/linux/bio.h b/include/linux/bio.h
index 51371740d2a8..b47c7f716731 100644
--- a/include/linux/bio.h
+++ b/include/linux/bio.h
@@ -21,12 +21,8 @@
 #include <linux/highmem.h>
 #include <linux/mempool.h>
 #include <linux/ioprio.h>
-#include <linux/bug.h>
 
 #ifdef CONFIG_BLOCK
-
-#include <asm/io.h>
-
 /* struct bio, bio_vec and BIO_* flags are defined in blk_types.h */
 #include <linux/blk_types.h>
 
@@ -133,32 +129,6 @@ static inline bool bio_full(struct bio *bio)
 }
 
 /*
- * will die
- */
-#define bvec_to_phys(bv)        (page_to_phys((bv)->bv_page) + (unsigned long) (bv)->bv_offset)
-
-/*
- * merge helpers etc
- */
-
-/* Default implementation of BIOVEC_PHYS_MERGEABLE */
-#define __BIOVEC_PHYS_MERGEABLE(vec1, vec2)     \
-        ((bvec_to_phys((vec1)) + (vec1)->bv_len) == bvec_to_phys((vec2)))
-
-/*
- * allow arch override, for eg virtualized architectures (put in asm/io.h)
- */
-#ifndef BIOVEC_PHYS_MERGEABLE
-#define BIOVEC_PHYS_MERGEABLE(vec1, vec2)       \
-        __BIOVEC_PHYS_MERGEABLE(vec1, vec2)
-#endif
-
-#define __BIO_SEG_BOUNDARY(addr1, addr2, mask) \
-        (((addr1) | (mask)) == (((addr2) - 1) | (mask)))
-#define BIOVEC_SEG_BOUNDARY(q, b1, b2) \
-        __BIO_SEG_BOUNDARY(bvec_to_phys((b1)), bvec_to_phys((b2)) + (b2)->bv_len, queue_segment_boundary((q)))
-
-/*
  * drivers should _never_ use the all version - the bio may have been split
  * before it got to the driver and the driver won't own all of it
  */
@@ -170,27 +140,11 @@ static inline void bio_advance_iter(struct bio *bio, struct bvec_iter *iter,
 {
         iter->bi_sector += bytes >> 9;
 
-        if (bio_no_advance_iter(bio)) {
+        if (bio_no_advance_iter(bio))
                 iter->bi_size -= bytes;
-                iter->bi_done += bytes;
-        } else {
+        else
                 bvec_iter_advance(bio->bi_io_vec, iter, bytes);
                 /* TODO: It is reasonable to complete bio with error here. */
-        }
-}
-
-static inline bool bio_rewind_iter(struct bio *bio, struct bvec_iter *iter,
-                unsigned int bytes)
-{
-        iter->bi_sector -= bytes >> 9;
-
-        if (bio_no_advance_iter(bio)) {
-                iter->bi_size += bytes;
-                iter->bi_done -= bytes;
-                return true;
-        }
-
-        return bvec_iter_rewind(bio->bi_io_vec, iter, bytes);
 }
 
 #define __bio_for_each_segment(bvl, bio, iter, start)                   \
@@ -353,6 +307,8 @@ struct bio_integrity_payload {
         unsigned short          bip_max_vcnt;   /* integrity bio_vec slots */
         unsigned short          bip_flags;      /* control flags */
 
+        struct bvec_iter        bio_iter;       /* for rewinding parent bio */
+
         struct work_struct      bip_work;       /* I/O completion */
 
         struct bio_vec          *bip_vec;
@@ -547,23 +503,31 @@ do {						\
         disk_devt((bio)->bi_disk)
 
 #if defined(CONFIG_MEMCG) && defined(CONFIG_BLK_CGROUP)
-int bio_associate_blkcg_from_page(struct bio *bio, struct page *page);
+int bio_associate_blkg_from_page(struct bio *bio, struct page *page);
 #else
-static inline int bio_associate_blkcg_from_page(struct bio *bio,
-                                                struct page *page) {  return 0; }
+static inline int bio_associate_blkg_from_page(struct bio *bio,
+                                               struct page *page) { return 0; }
 #endif
 
 #ifdef CONFIG_BLK_CGROUP
-int bio_associate_blkcg(struct bio *bio, struct cgroup_subsys_state *blkcg_css);
 int bio_associate_blkg(struct bio *bio, struct blkcg_gq *blkg);
+int bio_associate_blkg_from_css(struct bio *bio,
+                                struct cgroup_subsys_state *css);
+int bio_associate_create_blkg(struct request_queue *q, struct bio *bio);
+int bio_reassociate_blkg(struct request_queue *q, struct bio *bio);
 void bio_disassociate_task(struct bio *bio);
-void bio_clone_blkcg_association(struct bio *dst, struct bio *src);
+void bio_clone_blkg_association(struct bio *dst, struct bio *src);
 #else   /* CONFIG_BLK_CGROUP */
-static inline int bio_associate_blkcg(struct bio *bio,
-                        struct cgroup_subsys_state *blkcg_css) { return 0; }
+static inline int bio_associate_blkg_from_css(struct bio *bio,
+                                              struct cgroup_subsys_state *css)
+{ return 0; }
+static inline int bio_associate_create_blkg(struct request_queue *q,
+                                            struct bio *bio) { return 0; }
+static inline int bio_reassociate_blkg(struct request_queue *q, struct bio *bio)
+{ return 0; }
 static inline void bio_disassociate_task(struct bio *bio) { }
-static inline void bio_clone_blkcg_association(struct bio *dst,
-                        struct bio *src) { }
+static inline void bio_clone_blkg_association(struct bio *dst,
+                                              struct bio *src) { }
 #endif  /* CONFIG_BLK_CGROUP */
 
 #ifdef CONFIG_HIGHMEM
diff --git a/include/linux/blk-cgroup.h b/include/linux/blk-cgroup.h
index 6d766a19f2bb..1e76ceebeb5d 100644
--- a/include/linux/blk-cgroup.h
+++ b/include/linux/blk-cgroup.h
@@ -126,7 +126,7 @@ struct blkcg_gq {
         struct request_list             rl;
 
         /* reference count */
-        atomic_t                        refcnt;
+        struct percpu_ref               refcnt;
 
         /* is this blkg online? protected by both blkcg and q locks */
         bool                            online;
@@ -184,6 +184,8 @@ extern struct cgroup_subsys_state * const blkcg_root_css;
 
 struct blkcg_gq *blkg_lookup_slowpath(struct blkcg *blkcg,
                                       struct request_queue *q, bool update_hint);
+struct blkcg_gq *__blkg_lookup_create(struct blkcg *blkcg,
+                                      struct request_queue *q);
 struct blkcg_gq *blkg_lookup_create(struct blkcg *blkcg,
                                     struct request_queue *q);
 int blkcg_init_queue(struct request_queue *q);
@@ -230,22 +232,59 @@ int blkg_conf_prep(struct blkcg *blkcg, const struct blkcg_policy *pol,
                    char *input, struct blkg_conf_ctx *ctx);
 void blkg_conf_finish(struct blkg_conf_ctx *ctx);
 
+/**
+ * blkcg_css - find the current css
+ *
+ * Find the css associated with either the kthread or the current task.
+ * This may return a dying css, so it is up to the caller to use tryget logic
+ * to confirm it is alive and well.
+ */
+static inline struct cgroup_subsys_state *blkcg_css(void)
+{
+        struct cgroup_subsys_state *css;
+
+        css = kthread_blkcg();
+        if (css)
+                return css;
+        return task_css(current, io_cgrp_id);
+}
 
 static inline struct blkcg *css_to_blkcg(struct cgroup_subsys_state *css)
 {
         return css ? container_of(css, struct blkcg, css) : NULL;
 }
 
-static inline struct blkcg *bio_blkcg(struct bio *bio)
+/**
+ * __bio_blkcg - internal version of bio_blkcg for bfq and cfq
+ *
+ * DO NOT USE.
+ * There is a flaw using this version of the function.  In particular, this was
+ * used in a broken paradigm where association was called on the given css.  It
+ * is possible though that the returned css from task_css() is in the process
+ * of dying due to migration of the current task.  So it is improper to assume
+ * *_get() is going to succeed.  Both BFQ and CFQ rely on this logic and will
+ * take additional work to handle more gracefully.
+ */
+static inline struct blkcg *__bio_blkcg(struct bio *bio)
 {
-        struct cgroup_subsys_state *css;
+        if (bio && bio->bi_blkg)
+                return bio->bi_blkg->blkcg;
+        return css_to_blkcg(blkcg_css());
+}
 
-        if (bio && bio->bi_css)
-                return css_to_blkcg(bio->bi_css);
-        css = kthread_blkcg();
-        if (css)
-                return css_to_blkcg(css);
-        return css_to_blkcg(task_css(current, io_cgrp_id));
+/**
+ * bio_blkcg - grab the blkcg associated with a bio
+ * @bio: target bio
+ *
+ * This returns the blkcg associated with a bio, NULL if not associated.
+ * Callers are expected to either handle NULL or know association has been
+ * done prior to calling this.
+ */
+static inline struct blkcg *bio_blkcg(struct bio *bio)
+{
+        if (bio && bio->bi_blkg)
+                return bio->bi_blkg->blkcg;
+        return NULL;
 }
 
 static inline bool blk_cgroup_congested(void)
@@ -451,26 +490,35 @@ static inline int blkg_path(struct blkcg_gq *blkg, char *buf, int buflen)
  */
 static inline void blkg_get(struct blkcg_gq *blkg)
 {
-        WARN_ON_ONCE(atomic_read(&blkg->refcnt) <= 0);
-        atomic_inc(&blkg->refcnt);
+        percpu_ref_get(&blkg->refcnt);
 }
 
 /**
- * blkg_try_get - try and get a blkg reference
+ * blkg_tryget - try and get a blkg reference
  * @blkg: blkg to get
  *
  * This is for use when doing an RCU lookup of the blkg.  We may be in the midst
  * of freeing this blkg, so we can only use it if the refcnt is not zero.
  */
-static inline struct blkcg_gq *blkg_try_get(struct blkcg_gq *blkg)
+static inline bool blkg_tryget(struct blkcg_gq *blkg)
 {
-        if (atomic_inc_not_zero(&blkg->refcnt))
-                return blkg;
-        return NULL;
+        return percpu_ref_tryget(&blkg->refcnt);
 }
 
+/**
+ * blkg_tryget_closest - try and get a blkg ref on the closet blkg
+ * @blkg: blkg to get
+ *
+ * This walks up the blkg tree to find the closest non-dying blkg and returns
+ * the blkg that it did association with as it may not be the passed in blkg.
+ */
+static inline struct blkcg_gq *blkg_tryget_closest(struct blkcg_gq *blkg)
+{
+        while (!percpu_ref_tryget(&blkg->refcnt))
+                blkg = blkg->parent;
 
-void __blkg_release_rcu(struct rcu_head *rcu);
+        return blkg;
+}
 
 /**
  * blkg_put - put a blkg reference
@@ -478,9 +526,7 @@ void __blkg_release_rcu(struct rcu_head *rcu);
  */
 static inline void blkg_put(struct blkcg_gq *blkg)
 {
-        WARN_ON_ONCE(atomic_read(&blkg->refcnt) <= 0);
-        if (atomic_dec_and_test(&blkg->refcnt))
-                call_rcu(&blkg->rcu_head, __blkg_release_rcu);
+        percpu_ref_put(&blkg->refcnt);
 }
 
 /**
@@ -533,25 +579,36 @@ static inline struct request_list *blk_get_rl(struct request_queue *q,
 
         rcu_read_lock();
 
-        blkcg = bio_blkcg(bio);
+        if (bio && bio->bi_blkg) {
+                blkcg = bio->bi_blkg->blkcg;
+                if (blkcg == &blkcg_root)
+                        goto rl_use_root;
+
+                blkg_get(bio->bi_blkg);
+                rcu_read_unlock();
+                return &bio->bi_blkg->rl;
+        }
 
-        /* bypass blkg lookup and use @q->root_rl directly for root */
+        blkcg = css_to_blkcg(blkcg_css());
         if (blkcg == &blkcg_root)
-                goto root_rl;
+                goto rl_use_root;
 
-        /*
-         * Try to use blkg->rl.  blkg lookup may fail under memory pressure
-         * or if either the blkcg or queue is going away.  Fall back to
-         * root_rl in such cases.
-         */
         blkg = blkg_lookup(blkcg, q);
         if (unlikely(!blkg))
-                goto root_rl;
+                blkg = __blkg_lookup_create(blkcg, q);
+
+        if (blkg->blkcg == &blkcg_root || !blkg_tryget(blkg))
+                goto rl_use_root;
 
-        blkg_get(blkg);
         rcu_read_unlock();
         return &blkg->rl;
-root_rl:
+
+        /*
+         * Each blkg has its own request_list, however, the root blkcg
+         * uses the request_queue's root_rl.  This is to avoid most
+         * overhead for the root blkcg.
+         */
+rl_use_root:
         rcu_read_unlock();
         return &q->root_rl;
 }
@@ -797,32 +854,26 @@ static inline bool blk_throtl_bio(struct request_queue *q, struct blkcg_gq *blkg
                                   struct bio *bio) { return false; }
 #endif
 
+
+static inline void blkcg_bio_issue_init(struct bio *bio)
+{
+        bio_issue_init(&bio->bi_issue, bio_sectors(bio));
+}
+
 static inline bool blkcg_bio_issue_check(struct request_queue *q,
                                          struct bio *bio)
 {
-        struct blkcg *blkcg;
         struct blkcg_gq *blkg;
         bool throtl = false;
 
         rcu_read_lock();
-        blkcg = bio_blkcg(bio);
-
-        /* associate blkcg if bio hasn't attached one */
-        bio_associate_blkcg(bio, &blkcg->css);
 
-        blkg = blkg_lookup(blkcg, q);
-        if (unlikely(!blkg)) {
-                spin_lock_irq(q->queue_lock);
-                blkg = blkg_lookup_create(blkcg, q);
-                if (IS_ERR(blkg))
-                        blkg = NULL;
-                spin_unlock_irq(q->queue_lock);
-        }
+        bio_associate_create_blkg(q, bio);
+        blkg = bio->bi_blkg;
 
         throtl = blk_throtl_bio(q, blkg, bio);
 
         if (!throtl) {
-                blkg = blkg ?: q->root_blkg;
                 /*
                  * If the bio is flagged with BIO_QUEUE_ENTERED it means this
                  * is a split bio and we would have already accounted for the
@@ -834,6 +885,8 @@ static inline bool blkcg_bio_issue_check(struct request_queue *q,
                 blkg_rwstat_add(&blkg->stat_ios, bio->bi_opf, 1);
         }
 
+        blkcg_bio_issue_init(bio);
+
         rcu_read_unlock();
         return !throtl;
 }
@@ -930,6 +983,7 @@ static inline int blkcg_activate_policy(struct request_queue *q,
 static inline void blkcg_deactivate_policy(struct request_queue *q,
                                            const struct blkcg_policy *pol) { }
 
+static inline struct blkcg *__bio_blkcg(struct bio *bio) { return NULL; }
 static inline struct blkcg *bio_blkcg(struct bio *bio) { return NULL; }
 
 static inline struct blkg_policy_data *blkg_to_pd(struct blkcg_gq *blkg,
@@ -945,6 +999,7 @@ static inline void blk_put_rl(struct request_list *rl) { }
 static inline void blk_rq_set_rl(struct request *rq, struct request_list *rl) { }
 static inline struct request_list *blk_rq_rl(struct request *rq) { return &rq->q->root_rl; }
 
+static inline void blkcg_bio_issue_init(struct bio *bio) { }
 static inline bool blkcg_bio_issue_check(struct request_queue *q,
                                          struct bio *bio) { return true; }
 
diff --git a/include/linux/blk-mq.h b/include/linux/blk-mq.h
index 1da59c16f637..2286dc12c6bc 100644
--- a/include/linux/blk-mq.h
+++ b/include/linux/blk-mq.h
@@ -203,6 +203,10 @@ enum {
 struct request_queue *blk_mq_init_queue(struct blk_mq_tag_set *);
 struct request_queue *blk_mq_init_allocated_queue(struct blk_mq_tag_set *set,
                                                   struct request_queue *q);
+struct request_queue *blk_mq_init_sq_queue(struct blk_mq_tag_set *set,
+                                                const struct blk_mq_ops *ops,
+                                                unsigned int queue_depth,
+                                                unsigned int set_flags);
 int blk_mq_register_dev(struct device *, struct request_queue *);
 void blk_mq_unregister_dev(struct device *, struct request_queue *);
 
diff --git a/include/linux/blk-pm.h b/include/linux/blk-pm.h
new file mode 100644
index 000000000000..b80c65aba249
--- /dev/null
+++ b/include/linux/blk-pm.h
@@ -0,0 +1,24 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+
+#ifndef _BLK_PM_H_
+#define _BLK_PM_H_
+
+struct device;
+struct request_queue;
+
+/*
+ * block layer runtime pm functions
+ */
+#ifdef CONFIG_PM
+extern void blk_pm_runtime_init(struct request_queue *q, struct device *dev);
+extern int blk_pre_runtime_suspend(struct request_queue *q);
+extern void blk_post_runtime_suspend(struct request_queue *q, int err);
+extern void blk_pre_runtime_resume(struct request_queue *q);
+extern void blk_post_runtime_resume(struct request_queue *q, int err);
+extern void blk_set_runtime_active(struct request_queue *q);
+#else
+static inline void blk_pm_runtime_init(struct request_queue *q,
+                                       struct device *dev) {}
+#endif
+
+#endif /* _BLK_PM_H_ */
diff --git a/include/linux/blk_types.h b/include/linux/blk_types.h
index f6dfb30737d8..093a818c5b68 100644
--- a/include/linux/blk_types.h
+++ b/include/linux/blk_types.h
@@ -178,7 +178,6 @@ struct bio {
          * release.  Read comment on top of bio_associate_current().
          */
         struct io_context       *bi_ioc;
-        struct cgroup_subsys_state *bi_css;
         struct blkcg_gq         *bi_blkg;
         struct bio_issue        bi_issue;
 #endif
@@ -284,8 +283,6 @@ enum req_opf {
         REQ_OP_FLUSH            = 2,
         /* discard sectors */
         REQ_OP_DISCARD          = 3,
-        /* get zone information */
-        REQ_OP_ZONE_REPORT      = 4,
         /* securely erase sectors */
         REQ_OP_SECURE_ERASE     = 5,
         /* seset a zone write pointer */
diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
index d6869e0e2b64..4293dc1cd160 100644
--- a/include/linux/blkdev.h
+++ b/include/linux/blkdev.h
@@ -54,7 +54,7 @@ struct blk_stat_callback;
  * Maximum number of blkcg policies allowed to be registered concurrently.
  * Defined here to simplify include dependency.
  */
-#define BLKCG_MAX_POLS          3
+#define BLKCG_MAX_POLS          5
 
 typedef void (rq_end_io_fn)(struct request *, blk_status_t);
 
@@ -108,7 +108,7 @@ typedef __u32 __bitwise req_flags_t;
 #define RQF_QUIET               ((__force req_flags_t)(1 << 11))
 /* elevator private data attached */
 #define RQF_ELVPRIV             ((__force req_flags_t)(1 << 12))
-/* account I/O stat */
+/* account into disk and partition IO statistics */
 #define RQF_IO_STAT             ((__force req_flags_t)(1 << 13))
 /* request came from our alloc pool */
 #define RQF_ALLOCED             ((__force req_flags_t)(1 << 14))
@@ -116,7 +116,7 @@ typedef __u32 __bitwise req_flags_t;
 #define RQF_PM                  ((__force req_flags_t)(1 << 15))
 /* on IO scheduler merge hash */
 #define RQF_HASHED              ((__force req_flags_t)(1 << 16))
-/* IO stats tracking on */
+/* track IO completion time */
 #define RQF_STATS               ((__force req_flags_t)(1 << 17))
 /* Look at ->special_vec for the actual data payload instead of the
    bio chain. */
@@ -396,16 +396,13 @@ struct queue_limits {
 
 #ifdef CONFIG_BLK_DEV_ZONED
 
-struct blk_zone_report_hdr {
-        unsigned int    nr_zones;
-        u8              padding[60];
-};
-
+extern unsigned int blkdev_nr_zones(struct block_device *bdev);
 extern int blkdev_report_zones(struct block_device *bdev,
                                sector_t sector, struct blk_zone *zones,
                                unsigned int *nr_zones, gfp_t gfp_mask);
 extern int blkdev_reset_zones(struct block_device *bdev, sector_t sectors,
                               sector_t nr_sectors, gfp_t gfp_mask);
+extern int blk_revalidate_disk_zones(struct gendisk *disk);
 
 extern int blkdev_report_zones_ioctl(struct block_device *bdev, fmode_t mode,
                                      unsigned int cmd, unsigned long arg);
@@ -414,6 +411,16 @@ extern int blkdev_reset_zones_ioctl(struct block_device *bdev, fmode_t mode,
 
 #else /* CONFIG_BLK_DEV_ZONED */
 
+static inline unsigned int blkdev_nr_zones(struct block_device *bdev)
+{
+        return 0;
+}
+
+static inline int blk_revalidate_disk_zones(struct gendisk *disk)
+{
+        return 0;
+}
+
 static inline int blkdev_report_zones_ioctl(struct block_device *bdev,
                                             fmode_t mode, unsigned int cmd,
                                             unsigned long arg)
@@ -504,6 +511,12 @@ struct request_queue {
          * various queue flags, see QUEUE_* below
          */
         unsigned long           queue_flags;
+        /*
+         * Number of contexts that have called blk_set_pm_only(). If this
+         * counter is above zero then only RQF_PM and RQF_PREEMPT requests are
+         * processed.
+         */
+        atomic_t                pm_only;
 
         /*
          * ida allocated id for this queue.  Used to index queues from
@@ -679,7 +692,7 @@ struct request_queue {
 #define QUEUE_FLAG_FAIL_IO      7       /* fake timeout */
 #define QUEUE_FLAG_NONROT       9       /* non-rotational device (SSD) */
 #define QUEUE_FLAG_VIRT        QUEUE_FLAG_NONROT /* paravirt device */
-#define QUEUE_FLAG_IO_STAT     10       /* do IO stats */
+#define QUEUE_FLAG_IO_STAT     10       /* do disk/partitions IO accounting */
 #define QUEUE_FLAG_DISCARD     11       /* supports DISCARD */
 #define QUEUE_FLAG_NOXMERGES   12       /* No extended merges */
 #define QUEUE_FLAG_ADD_RANDOM  13       /* Contributes to random pool */
@@ -693,12 +706,12 @@ struct request_queue {
 #define QUEUE_FLAG_FUA         21       /* device supports FUA writes */
 #define QUEUE_FLAG_FLUSH_NQ    22       /* flush not queueuable */
 #define QUEUE_FLAG_DAX         23       /* device supports DAX */
-#define QUEUE_FLAG_STATS       24       /* track rq completion times */
+#define QUEUE_FLAG_STATS       24       /* track IO start and completion times */
 #define QUEUE_FLAG_POLL_STATS  25       /* collecting stats for hybrid polling */
 #define QUEUE_FLAG_REGISTERED  26       /* queue has been registered to a disk */
 #define QUEUE_FLAG_SCSI_PASSTHROUGH 27  /* queue supports SCSI commands */
 #define QUEUE_FLAG_QUIESCED    28       /* queue has been quiesced */
-#define QUEUE_FLAG_PREEMPT_ONLY 29      /* only process REQ_PREEMPT requests */
+#define QUEUE_FLAG_PCI_P2PDMA  29       /* device supports PCI p2p requests */
 
 #define QUEUE_FLAG_DEFAULT      ((1 << QUEUE_FLAG_IO_STAT) |            \
                                  (1 << QUEUE_FLAG_SAME_COMP)    |       \
@@ -731,17 +744,18 @@ bool blk_queue_flag_test_and_clear(unsigned int flag, struct request_queue *q);
 #define blk_queue_dax(q)        test_bit(QUEUE_FLAG_DAX, &(q)->queue_flags)
 #define blk_queue_scsi_passthrough(q)   \
         test_bit(QUEUE_FLAG_SCSI_PASSTHROUGH, &(q)->queue_flags)
+#define blk_queue_pci_p2pdma(q) \
+        test_bit(QUEUE_FLAG_PCI_P2PDMA, &(q)->queue_flags)
 
 #define blk_noretry_request(rq) \
         ((rq)->cmd_flags & (REQ_FAILFAST_DEV|REQ_FAILFAST_TRANSPORT| \
                              REQ_FAILFAST_DRIVER))
 #define blk_queue_quiesced(q)   test_bit(QUEUE_FLAG_QUIESCED, &(q)->queue_flags)
-#define blk_queue_preempt_only(q)                               \
-        test_bit(QUEUE_FLAG_PREEMPT_ONLY, &(q)->queue_flags)
+#define blk_queue_pm_only(q)    atomic_read(&(q)->pm_only)
 #define blk_queue_fua(q)        test_bit(QUEUE_FLAG_FUA, &(q)->queue_flags)
 
-extern int blk_set_preempt_only(struct request_queue *q);
-extern void blk_clear_preempt_only(struct request_queue *q);
+extern void blk_set_pm_only(struct request_queue *q);
+extern void blk_clear_pm_only(struct request_queue *q);
 
 static inline int queue_in_flight(struct request_queue *q)
 {
@@ -799,6 +813,11 @@ static inline unsigned int blk_queue_zone_sectors(struct request_queue *q)
 }
 
 #ifdef CONFIG_BLK_DEV_ZONED
+static inline unsigned int blk_queue_nr_zones(struct request_queue *q)
+{
+        return blk_queue_is_zoned(q) ? q->nr_zones : 0;
+}
+
 static inline unsigned int blk_queue_zone_no(struct request_queue *q,
                                              sector_t sector)
 {
@@ -814,6 +833,11 @@ static inline bool blk_queue_zone_is_seq(struct request_queue *q,
                 return false;
         return test_bit(blk_queue_zone_no(q, sector), q->seq_zones_bitmap);
 }
+#else /* CONFIG_BLK_DEV_ZONED */
+static inline unsigned int blk_queue_nr_zones(struct request_queue *q)
+{
+        return 0;
+}
 #endif /* CONFIG_BLK_DEV_ZONED */
 
 static inline bool rq_is_sync(struct request *rq)
@@ -1281,29 +1305,6 @@ extern void blk_put_queue(struct request_queue *);
 extern void blk_set_queue_dying(struct request_queue *);
 
 /*
- * block layer runtime pm functions
- */
-#ifdef CONFIG_PM
-extern void blk_pm_runtime_init(struct request_queue *q, struct device *dev);
-extern int blk_pre_runtime_suspend(struct request_queue *q);
-extern void blk_post_runtime_suspend(struct request_queue *q, int err);
-extern void blk_pre_runtime_resume(struct request_queue *q);
-extern void blk_post_runtime_resume(struct request_queue *q, int err);
-extern void blk_set_runtime_active(struct request_queue *q);
-#else
-static inline void blk_pm_runtime_init(struct request_queue *q,
-        struct device *dev) {}
-static inline int blk_pre_runtime_suspend(struct request_queue *q)
-{
-        return -ENOSYS;
-}
-static inline void blk_post_runtime_suspend(struct request_queue *q, int err) {}
-static inline void blk_pre_runtime_resume(struct request_queue *q) {}
-static inline void blk_post_runtime_resume(struct request_queue *q, int err) {}
-static inline void blk_set_runtime_active(struct request_queue *q) {}
-#endif
-
-/*
  * blk_plug permits building a queue of related requests by holding the I/O
  * fragments for a short period. This allows merging of sequential requests
  * into single larger request. As the requests are moved from a per-task list to
@@ -1676,94 +1677,6 @@ static inline void put_dev_sector(Sector p)
         put_page(p.v);
 }
 
-static inline bool __bvec_gap_to_prev(struct request_queue *q,
-                                struct bio_vec *bprv, unsigned int offset)
-{
-        return offset ||
-                ((bprv->bv_offset + bprv->bv_len) & queue_virt_boundary(q));
-}
-
-/*
- * Check if adding a bio_vec after bprv with offset would create a gap in
- * the SG list. Most drivers don't care about this, but some do.
- */
-static inline bool bvec_gap_to_prev(struct request_queue *q,
-                                struct bio_vec *bprv, unsigned int offset)
-{
-        if (!queue_virt_boundary(q))
-                return false;
-        return __bvec_gap_to_prev(q, bprv, offset);
-}
-
-/*
- * Check if the two bvecs from two bios can be merged to one segment.
- * If yes, no need to check gap between the two bios since the 1st bio
- * and the 1st bvec in the 2nd bio can be handled in one segment.
- */
-static inline bool bios_segs_mergeable(struct request_queue *q,
-                struct bio *prev, struct bio_vec *prev_last_bv,
-                struct bio_vec *next_first_bv)
-{
-        if (!BIOVEC_PHYS_MERGEABLE(prev_last_bv, next_first_bv))
-                return false;
-        if (!BIOVEC_SEG_BOUNDARY(q, prev_last_bv, next_first_bv))
-                return false;
-        if (prev->bi_seg_back_size + next_first_bv->bv_len >
-                        queue_max_segment_size(q))
-                return false;
-        return true;
-}
-
-static inline bool bio_will_gap(struct request_queue *q,
-                                struct request *prev_rq,
-                                struct bio *prev,
-                                struct bio *next)
-{
-        if (bio_has_data(prev) && queue_virt_boundary(q)) {
-                struct bio_vec pb, nb;
-
-                /*
-                 * don't merge if the 1st bio starts with non-zero
-                 * offset, otherwise it is quite difficult to respect
-                 * sg gap limit. We work hard to merge a huge number of small
-                 * single bios in case of mkfs.
-                 */
-                if (prev_rq)
-                        bio_get_first_bvec(prev_rq->bio, &pb);
-                else
-                        bio_get_first_bvec(prev, &pb);
-                if (pb.bv_offset)
-                        return true;
-
-                /*
-                 * We don't need to worry about the situation that the
-                 * merged segment ends in unaligned virt boundary:
-                 *
-                 * - if 'pb' ends aligned, the merged segment ends aligned
-                 * - if 'pb' ends unaligned, the next bio must include
-                 *   one single bvec of 'nb', otherwise the 'nb' can't
-                 *   merge with 'pb'
-                 */
-                bio_get_last_bvec(prev, &pb);
-                bio_get_first_bvec(next, &nb);
-
-                if (!bios_segs_mergeable(q, prev, &pb, &nb))
-                        return __bvec_gap_to_prev(q, &pb, nb.bv_offset);
-        }
-
-        return false;
-}
-
-static inline bool req_gap_back_merge(struct request *req, struct bio *bio)
-{
-        return bio_will_gap(req->q, req, req->biotail, bio);
-}
-
-static inline bool req_gap_front_merge(struct request *req, struct bio *bio)
-{
-        return bio_will_gap(req->q, NULL, bio, req->bio);
-}
-
 int kblockd_schedule_work(struct work_struct *work);
 int kblockd_schedule_work_on(int cpu, struct work_struct *work);
 int kblockd_mod_delayed_work_on(int cpu, struct delayed_work *dwork, unsigned long delay);
@@ -1843,26 +1756,6 @@ queue_max_integrity_segments(struct request_queue *q)
         return q->limits.max_integrity_segments;
 }
 
-static inline bool integrity_req_gap_back_merge(struct request *req,
-                                                struct bio *next)
-{
-        struct bio_integrity_payload *bip = bio_integrity(req->bio);
-        struct bio_integrity_payload *bip_next = bio_integrity(next);
-
-        return bvec_gap_to_prev(req->q, &bip->bip_vec[bip->bip_vcnt - 1],
-                                bip_next->bip_vec[0].bv_offset);
-}
-
-static inline bool integrity_req_gap_front_merge(struct request *req,
-                                                 struct bio *bio)
-{
-        struct bio_integrity_payload *bip = bio_integrity(bio);
-        struct bio_integrity_payload *bip_next = bio_integrity(req->bio);
-
-        return bvec_gap_to_prev(req->q, &bip->bip_vec[bip->bip_vcnt - 1],
-                                bip_next->bip_vec[0].bv_offset);
-}
-
 /**
  * bio_integrity_intervals - Return number of integrity intervals for a bio
  * @bi:         blk_integrity profile for device
@@ -1947,17 +1840,6 @@ static inline bool blk_integrity_merge_bio(struct request_queue *rq,
         return true;
 }
 
-static inline bool integrity_req_gap_back_merge(struct request *req,
-                                                struct bio *next)
-{
-        return false;
-}
-static inline bool integrity_req_gap_front_merge(struct request *req,
-                                                 struct bio *bio)
-{
-        return false;
-}
-
 static inline unsigned int bio_integrity_intervals(struct blk_integrity *bi,
                                                    unsigned int sectors)
 {
@@ -1987,6 +1869,9 @@ struct block_device_operations {
         int (*getgeo)(struct block_device *, struct hd_geometry *);
         /* this callback is with swap_lock and sometimes page table lock held */
         void (*swap_slot_free_notify) (struct block_device *, unsigned long);
+        int (*report_zones)(struct gendisk *, sector_t sector,
+                            struct blk_zone *zones, unsigned int *nr_zones,
+                            gfp_t gfp_mask);
         struct module *owner;
         const struct pr_ops *pr_ops;
 };
diff --git a/include/linux/bpf-cgroup.h b/include/linux/bpf-cgroup.h
index f91b0f8ff3a9..588dd5f0bd85 100644
--- a/include/linux/bpf-cgroup.h
+++ b/include/linux/bpf-cgroup.h
@@ -2,6 +2,7 @@
 #ifndef _BPF_CGROUP_H
 #define _BPF_CGROUP_H
 
+#include <linux/bpf.h>
 #include <linux/errno.h>
 #include <linux/jump_label.h>
 #include <linux/percpu.h>
@@ -22,7 +23,11 @@ struct bpf_cgroup_storage;
 extern struct static_key_false cgroup_bpf_enabled_key;
 #define cgroup_bpf_enabled static_branch_unlikely(&cgroup_bpf_enabled_key)
 
-DECLARE_PER_CPU(void*, bpf_cgroup_storage);
+DECLARE_PER_CPU(struct bpf_cgroup_storage*,
+                bpf_cgroup_storage[MAX_BPF_CGROUP_STORAGE_TYPE]);
+
+#define for_each_cgroup_storage_type(stype) \
+        for (stype = 0; stype < MAX_BPF_CGROUP_STORAGE_TYPE; stype++)
 
 struct bpf_cgroup_storage_map;
 
@@ -32,7 +37,10 @@ struct bpf_storage_buffer {
 };
 
 struct bpf_cgroup_storage {
-        struct bpf_storage_buffer *buf;
+        union {
+                struct bpf_storage_buffer *buf;
+                void __percpu *percpu_buf;
+        };
         struct bpf_cgroup_storage_map *map;
         struct bpf_cgroup_storage_key key;
         struct list_head list;
@@ -43,7 +51,7 @@ struct bpf_cgroup_storage {
 struct bpf_prog_list {
         struct list_head node;
         struct bpf_prog *prog;
-        struct bpf_cgroup_storage *storage;
+        struct bpf_cgroup_storage *storage[MAX_BPF_CGROUP_STORAGE_TYPE];
 };
 
 struct bpf_prog_array;
@@ -101,18 +109,26 @@ int __cgroup_bpf_run_filter_sock_ops(struct sock *sk,
 int __cgroup_bpf_check_dev_permission(short dev_type, u32 major, u32 minor,
                                       short access, enum bpf_attach_type type);
 
-static inline void bpf_cgroup_storage_set(struct bpf_cgroup_storage *storage)
+static inline enum bpf_cgroup_storage_type cgroup_storage_type(
+        struct bpf_map *map)
 {
-        struct bpf_storage_buffer *buf;
+        if (map->map_type == BPF_MAP_TYPE_PERCPU_CGROUP_STORAGE)
+                return BPF_CGROUP_STORAGE_PERCPU;
+
+        return BPF_CGROUP_STORAGE_SHARED;
+}
 
-        if (!storage)
-                return;
+static inline void bpf_cgroup_storage_set(struct bpf_cgroup_storage
+                                          *storage[MAX_BPF_CGROUP_STORAGE_TYPE])
+{
+        enum bpf_cgroup_storage_type stype;
 
-        buf = READ_ONCE(storage->buf);
-        this_cpu_write(bpf_cgroup_storage, &buf->data[0]);
+        for_each_cgroup_storage_type(stype)
+                this_cpu_write(bpf_cgroup_storage[stype], storage[stype]);
 }
 
-struct bpf_cgroup_storage *bpf_cgroup_storage_alloc(struct bpf_prog *prog);
+struct bpf_cgroup_storage *bpf_cgroup_storage_alloc(struct bpf_prog *prog,
+                                        enum bpf_cgroup_storage_type stype);
 void bpf_cgroup_storage_free(struct bpf_cgroup_storage *storage);
 void bpf_cgroup_storage_link(struct bpf_cgroup_storage *storage,
                              struct cgroup *cgroup,
@@ -121,6 +137,10 @@ void bpf_cgroup_storage_unlink(struct bpf_cgroup_storage *storage);
 int bpf_cgroup_storage_assign(struct bpf_prog *prog, struct bpf_map *map);
 void bpf_cgroup_storage_release(struct bpf_prog *prog, struct bpf_map *map);
 
+int bpf_percpu_cgroup_storage_copy(struct bpf_map *map, void *key, void *value);
+int bpf_percpu_cgroup_storage_update(struct bpf_map *map, void *key,
+                                     void *value, u64 flags);
+
 /* Wrappers for __cgroup_bpf_run_filter_skb() guarded by cgroup_bpf_enabled. */
 #define BPF_CGROUP_RUN_PROG_INET_INGRESS(sk, skb)                             \
 ({                                                                            \
@@ -265,15 +285,24 @@ static inline int cgroup_bpf_prog_query(const union bpf_attr *attr,
         return -EINVAL;
 }
 
-static inline void bpf_cgroup_storage_set(struct bpf_cgroup_storage *storage) {}
+static inline void bpf_cgroup_storage_set(
+        struct bpf_cgroup_storage *storage[MAX_BPF_CGROUP_STORAGE_TYPE]) {}
 static inline int bpf_cgroup_storage_assign(struct bpf_prog *prog,
                                             struct bpf_map *map) { return 0; }
 static inline void bpf_cgroup_storage_release(struct bpf_prog *prog,
                                               struct bpf_map *map) {}
 static inline struct bpf_cgroup_storage *bpf_cgroup_storage_alloc(
-        struct bpf_prog *prog) { return 0; }
+        struct bpf_prog *prog, enum bpf_cgroup_storage_type stype) { return 0; }
 static inline void bpf_cgroup_storage_free(
         struct bpf_cgroup_storage *storage) {}
+static inline int bpf_percpu_cgroup_storage_copy(struct bpf_map *map, void *key,
+                                                 void *value) {
+        return 0;
+}
+static inline int bpf_percpu_cgroup_storage_update(struct bpf_map *map,
+                                        void *key, void *value, u64 flags) {
+        return 0;
+}
 
 #define cgroup_bpf_enabled (0)
 #define BPF_CGROUP_PRE_CONNECT_ENABLED(sk) (0)
@@ -293,6 +322,8 @@ static inline void bpf_cgroup_storage_free(
 #define BPF_CGROUP_RUN_PROG_SOCK_OPS(sock_ops) ({ 0; })
 #define BPF_CGROUP_RUN_PROG_DEVICE_CGROUP(type,major,minor,access) ({ 0; })
 
+#define for_each_cgroup_storage_type(stype) for (; false; )
+
 #endif /* CONFIG_CGROUP_BPF */
 
 #endif /* _BPF_CGROUP_H */
diff --git a/include/linux/bpf.h b/include/linux/bpf.h
index 523481a3471b..33014ae73103 100644
--- a/include/linux/bpf.h
+++ b/include/linux/bpf.h
@@ -39,6 +39,9 @@ struct bpf_map_ops {
         void *(*map_lookup_elem)(struct bpf_map *map, void *key);
         int (*map_update_elem)(struct bpf_map *map, void *key, void *value, u64 flags);
         int (*map_delete_elem)(struct bpf_map *map, void *key);
+        int (*map_push_elem)(struct bpf_map *map, void *value, u64 flags);
+        int (*map_pop_elem)(struct bpf_map *map, void *value);
+        int (*map_peek_elem)(struct bpf_map *map, void *value);
 
         /* funcs called by prog_array and perf_event_array map */
         void *(*map_fd_get_ptr)(struct bpf_map *map, struct file *map_file,
@@ -138,6 +141,7 @@ enum bpf_arg_type {
         ARG_CONST_MAP_PTR,      /* const argument used as pointer to bpf_map */
         ARG_PTR_TO_MAP_KEY,     /* pointer to stack used as map key */
         ARG_PTR_TO_MAP_VALUE,   /* pointer to stack used as map value */
+        ARG_PTR_TO_UNINIT_MAP_VALUE,    /* pointer to valid memory used to store a map value */
 
         /* the following constraints used to prototype bpf_memcmp() and other
          * functions that access data on eBPF program stack
@@ -154,6 +158,7 @@ enum bpf_arg_type {
 
         ARG_PTR_TO_CTX,         /* pointer to context */
         ARG_ANYTHING,           /* any (initialized) argument is ok */
+        ARG_PTR_TO_SOCKET,      /* pointer to bpf_sock */
 };
 
 /* type of values returned from helper functions */
@@ -162,6 +167,7 @@ enum bpf_return_type {
         RET_VOID,                       /* function doesn't return anything */
         RET_PTR_TO_MAP_VALUE,           /* returns a pointer to map elem value */
         RET_PTR_TO_MAP_VALUE_OR_NULL,   /* returns a pointer to map elem value or NULL */
+        RET_PTR_TO_SOCKET_OR_NULL,      /* returns a pointer to a socket or NULL */
 };
 
 /* eBPF function prototype used by verifier to allow BPF_CALLs from eBPF programs
@@ -212,6 +218,9 @@ enum bpf_reg_type {
         PTR_TO_PACKET_META,      /* skb->data - meta_len */
         PTR_TO_PACKET,           /* reg points to skb->data */
         PTR_TO_PACKET_END,       /* skb->data + headlen */
+        PTR_TO_FLOW_KEYS,        /* reg points to bpf_flow_keys */
+        PTR_TO_SOCKET,           /* reg points to struct bpf_sock */
+        PTR_TO_SOCKET_OR_NULL,   /* reg points to struct bpf_sock or NULL */
 };
 
 /* The information passed from prog-specific *_is_valid_access
@@ -258,6 +267,7 @@ struct bpf_verifier_ops {
 struct bpf_prog_offload_ops {
         int (*insn_hook)(struct bpf_verifier_env *env,
                          int insn_idx, int prev_insn_idx);
+        int (*finalize)(struct bpf_verifier_env *env);
 };
 
 struct bpf_prog_offload {
@@ -271,6 +281,14 @@ struct bpf_prog_offload {
         u32                     jited_len;
 };
 
+enum bpf_cgroup_storage_type {
+        BPF_CGROUP_STORAGE_SHARED,
+        BPF_CGROUP_STORAGE_PERCPU,
+        __BPF_CGROUP_STORAGE_MAX
+};
+
+#define MAX_BPF_CGROUP_STORAGE_TYPE __BPF_CGROUP_STORAGE_MAX
+
 struct bpf_prog_aux {
         atomic_t refcnt;
         u32 used_map_cnt;
@@ -288,7 +306,7 @@ struct bpf_prog_aux {
         struct bpf_prog *prog;
         struct user_struct *user;
         u64 load_time; /* ns since boottime */
-        struct bpf_map *cgroup_storage;
+        struct bpf_map *cgroup_storage[MAX_BPF_CGROUP_STORAGE_TYPE];
         char name[BPF_OBJ_NAME_LEN];
 #ifdef CONFIG_SECURITY
         void *security;
@@ -334,6 +352,11 @@ const struct bpf_func_proto *bpf_get_trace_printk_proto(void);
 
 typedef unsigned long (*bpf_ctx_copy_t)(void *dst, const void *src,
                                         unsigned long off, unsigned long len);
+typedef u32 (*bpf_convert_ctx_access_t)(enum bpf_access_type type,
+                                        const struct bpf_insn *src,
+                                        struct bpf_insn *dst,
+                                        struct bpf_prog *prog,
+                                        u32 *target_size);
 
 u64 bpf_event_output(struct bpf_map *map, u64 flags, void *meta, u64 meta_size,
                      void *ctx, u64 ctx_size, bpf_ctx_copy_t ctx_copy);
@@ -357,7 +380,7 @@ int bpf_prog_test_run_skb(struct bpf_prog *prog, const union bpf_attr *kattr,
  */
 struct bpf_prog_array_item {
         struct bpf_prog *prog;
-        struct bpf_cgroup_storage *cgroup_storage;
+        struct bpf_cgroup_storage *cgroup_storage[MAX_BPF_CGROUP_STORAGE_TYPE];
 };
 
 struct bpf_prog_array {
@@ -718,33 +741,18 @@ static inline void bpf_map_offload_map_free(struct bpf_map *map)
 }
 #endif /* CONFIG_NET && CONFIG_BPF_SYSCALL */
 
-#if defined(CONFIG_STREAM_PARSER) && defined(CONFIG_BPF_SYSCALL) && defined(CONFIG_INET)
-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);
+#if defined(CONFIG_BPF_STREAM_PARSER)
+int sock_map_prog_update(struct bpf_map *map, struct bpf_prog *prog, u32 which);
+int sock_map_get_from_fd(const union bpf_attr *attr, struct bpf_prog *prog);
 #else
-static inline struct sock  *__sock_map_lookup_elem(struct bpf_map *map, u32 key)
-{
-        return NULL;
-}
-
-static inline struct sock  *__sock_hash_lookup_elem(struct bpf_map *map,
-                                                    void *key)
-{
-        return NULL;
-}
-
-static inline int sock_map_prog(struct bpf_map *map,
-                                struct bpf_prog *prog,
-                                u32 type)
+static inline int sock_map_prog_update(struct bpf_map *map,
+                                       struct bpf_prog *prog, u32 which)
 {
         return -EOPNOTSUPP;
 }
 
-static inline int sockmap_get_from_fd(const union bpf_attr *attr, int type,
-                                      struct bpf_prog *prog)
+static inline int sock_map_get_from_fd(const union bpf_attr *attr,
+                                       struct bpf_prog *prog)
 {
         return -EINVAL;
 }
@@ -806,6 +814,9 @@ static inline int bpf_fd_reuseport_array_update_elem(struct bpf_map *map,
 extern const struct bpf_func_proto bpf_map_lookup_elem_proto;
 extern const struct bpf_func_proto bpf_map_update_elem_proto;
 extern const struct bpf_func_proto bpf_map_delete_elem_proto;
+extern const struct bpf_func_proto bpf_map_push_elem_proto;
+extern const struct bpf_func_proto bpf_map_pop_elem_proto;
+extern const struct bpf_func_proto bpf_map_peek_elem_proto;
 
 extern const struct bpf_func_proto bpf_get_prandom_u32_proto;
 extern const struct bpf_func_proto bpf_get_smp_processor_id_proto;
@@ -820,6 +831,10 @@ extern const struct bpf_func_proto bpf_get_stack_proto;
 extern const struct bpf_func_proto bpf_sock_map_update_proto;
 extern const struct bpf_func_proto bpf_sock_hash_update_proto;
 extern const struct bpf_func_proto bpf_get_current_cgroup_id_proto;
+extern const struct bpf_func_proto bpf_msg_redirect_hash_proto;
+extern const struct bpf_func_proto bpf_msg_redirect_map_proto;
+extern const struct bpf_func_proto bpf_sk_redirect_hash_proto;
+extern const struct bpf_func_proto bpf_sk_redirect_map_proto;
 
 extern const struct bpf_func_proto bpf_get_local_storage_proto;
 
@@ -827,4 +842,29 @@ extern const struct bpf_func_proto bpf_get_local_storage_proto;
 void bpf_user_rnd_init_once(void);
 u64 bpf_user_rnd_u32(u64 r1, u64 r2, u64 r3, u64 r4, u64 r5);
 
+#if defined(CONFIG_NET)
+bool bpf_sock_is_valid_access(int off, int size, enum bpf_access_type type,
+                              struct bpf_insn_access_aux *info);
+u32 bpf_sock_convert_ctx_access(enum bpf_access_type type,
+                                const struct bpf_insn *si,
+                                struct bpf_insn *insn_buf,
+                                struct bpf_prog *prog,
+                                u32 *target_size);
+#else
+static inline bool bpf_sock_is_valid_access(int off, int size,
+                                            enum bpf_access_type type,
+                                            struct bpf_insn_access_aux *info)
+{
+        return false;
+}
+static inline u32 bpf_sock_convert_ctx_access(enum bpf_access_type type,
+                                              const struct bpf_insn *si,
+                                              struct bpf_insn *insn_buf,
+                                              struct bpf_prog *prog,
+                                              u32 *target_size)
+{
+        return 0;
+}
+#endif
+
 #endif /* _LINUX_BPF_H */
diff --git a/include/linux/bpf_types.h b/include/linux/bpf_types.h
index cd26c090e7c0..44d9ab4809bd 100644
--- a/include/linux/bpf_types.h
+++ b/include/linux/bpf_types.h
@@ -16,6 +16,7 @@ BPF_PROG_TYPE(BPF_PROG_TYPE_LWT_SEG6LOCAL, lwt_seg6local)
 BPF_PROG_TYPE(BPF_PROG_TYPE_SOCK_OPS, sock_ops)
 BPF_PROG_TYPE(BPF_PROG_TYPE_SK_SKB, sk_skb)
 BPF_PROG_TYPE(BPF_PROG_TYPE_SK_MSG, sk_msg)
+BPF_PROG_TYPE(BPF_PROG_TYPE_FLOW_DISSECTOR, flow_dissector)
 #endif
 #ifdef CONFIG_BPF_EVENTS
 BPF_PROG_TYPE(BPF_PROG_TYPE_KPROBE, kprobe)
@@ -42,6 +43,7 @@ BPF_MAP_TYPE(BPF_MAP_TYPE_CGROUP_ARRAY, cgroup_array_map_ops)
 #endif
 #ifdef CONFIG_CGROUP_BPF
 BPF_MAP_TYPE(BPF_MAP_TYPE_CGROUP_STORAGE, cgroup_storage_map_ops)
+BPF_MAP_TYPE(BPF_MAP_TYPE_PERCPU_CGROUP_STORAGE, cgroup_storage_map_ops)
 #endif
 BPF_MAP_TYPE(BPF_MAP_TYPE_HASH, htab_map_ops)
 BPF_MAP_TYPE(BPF_MAP_TYPE_PERCPU_HASH, htab_percpu_map_ops)
@@ -49,13 +51,13 @@ BPF_MAP_TYPE(BPF_MAP_TYPE_LRU_HASH, htab_lru_map_ops)
 BPF_MAP_TYPE(BPF_MAP_TYPE_LRU_PERCPU_HASH, htab_lru_percpu_map_ops)
 BPF_MAP_TYPE(BPF_MAP_TYPE_LPM_TRIE, trie_map_ops)
 #ifdef CONFIG_PERF_EVENTS
-BPF_MAP_TYPE(BPF_MAP_TYPE_STACK_TRACE, stack_map_ops)
+BPF_MAP_TYPE(BPF_MAP_TYPE_STACK_TRACE, stack_trace_map_ops)
 #endif
 BPF_MAP_TYPE(BPF_MAP_TYPE_ARRAY_OF_MAPS, array_of_maps_map_ops)
 BPF_MAP_TYPE(BPF_MAP_TYPE_HASH_OF_MAPS, htab_of_maps_map_ops)
 #ifdef CONFIG_NET
 BPF_MAP_TYPE(BPF_MAP_TYPE_DEVMAP, dev_map_ops)
-#if defined(CONFIG_STREAM_PARSER) && defined(CONFIG_INET)
+#if defined(CONFIG_BPF_STREAM_PARSER)
 BPF_MAP_TYPE(BPF_MAP_TYPE_SOCKMAP, sock_map_ops)
 BPF_MAP_TYPE(BPF_MAP_TYPE_SOCKHASH, sock_hash_ops)
 #endif
@@ -67,3 +69,5 @@ BPF_MAP_TYPE(BPF_MAP_TYPE_XSKMAP, xsk_map_ops)
 BPF_MAP_TYPE(BPF_MAP_TYPE_REUSEPORT_SOCKARRAY, reuseport_array_ops)
 #endif
 #endif
+BPF_MAP_TYPE(BPF_MAP_TYPE_QUEUE, queue_map_ops)
+BPF_MAP_TYPE(BPF_MAP_TYPE_STACK, stack_map_ops)
diff --git a/include/linux/bpf_verifier.h b/include/linux/bpf_verifier.h
index 38b04f559ad3..9e8056ec20fa 100644
--- a/include/linux/bpf_verifier.h
+++ b/include/linux/bpf_verifier.h
@@ -41,6 +41,7 @@ enum bpf_reg_liveness {
 };
 
 struct bpf_reg_state {
+        /* Ordering of fields matters.  See states_equal() */
         enum bpf_reg_type type;
         union {
                 /* valid when type == PTR_TO_PACKET */
@@ -57,9 +58,10 @@ struct bpf_reg_state {
          * offset, so they can share range knowledge.
          * For PTR_TO_MAP_VALUE_OR_NULL this is used to share which map value we
          * came from, when one is tested for != NULL.
+         * For PTR_TO_SOCKET this is used to share which pointers retain the
+         * same reference to the socket, to determine proper reference freeing.
          */
         u32 id;
-        /* Ordering of fields matters.  See states_equal() */
         /* For scalar types (SCALAR_VALUE), this represents our knowledge of
          * the actual value.
          * For pointer types, this represents the variable part of the offset
@@ -76,15 +78,15 @@ struct bpf_reg_state {
         s64 smax_value; /* maximum possible (s64)value */
         u64 umin_value; /* minimum possible (u64)value */
         u64 umax_value; /* maximum possible (u64)value */
+        /* parentage chain for liveness checking */
+        struct bpf_reg_state *parent;
         /* Inside the callee two registers can be both PTR_TO_STACK like
          * R1=fp-8 and R2=fp-8, but one of them points to this function stack
          * while another to the caller's stack. To differentiate them 'frameno'
          * is used which is an index in bpf_verifier_state->frame[] array
          * pointing to bpf_func_state.
-         * This field must be second to last, for states_equal() reasons.
          */
         u32 frameno;
-        /* This field must be last, for states_equal() reasons. */
         enum bpf_reg_liveness live;
 };
 
@@ -102,12 +104,22 @@ struct bpf_stack_state {
         u8 slot_type[BPF_REG_SIZE];
 };
 
+struct bpf_reference_state {
+        /* Track each reference created with a unique id, even if the same
+         * instruction creates the reference multiple times (eg, via CALL).
+         */
+        int id;
+        /* Instruction where the allocation of this reference occurred. This
+         * is used purely to inform the user of a reference leak.
+         */
+        int insn_idx;
+};
+
 /* state of the program:
  * type of all registers and stack info
  */
 struct bpf_func_state {
         struct bpf_reg_state regs[MAX_BPF_REG];
-        struct bpf_verifier_state *parent;
         /* index of call instruction that called into this func */
         int callsite;
         /* stack frame number of this function state from pov of
@@ -120,7 +132,9 @@ struct bpf_func_state {
          */
         u32 subprogno;
 
-        /* should be second to last. See copy_func_state() */
+        /* The following fields should be last. See copy_func_state() */
+        int acquired_refs;
+        struct bpf_reference_state *refs;
         int allocated_stack;
         struct bpf_stack_state *stack;
 };
@@ -129,10 +143,20 @@ struct bpf_func_state {
 struct bpf_verifier_state {
         /* call stack tracking */
         struct bpf_func_state *frame[MAX_CALL_FRAMES];
-        struct bpf_verifier_state *parent;
         u32 curframe;
 };
 
+#define bpf_get_spilled_reg(slot, frame)                                \
+        (((slot < frame->allocated_stack / BPF_REG_SIZE) &&             \
+          (frame->stack[slot].slot_type[0] == STACK_SPILL))             \
+         ? &frame->stack[slot].spilled_ptr : NULL)
+
+/* Iterate over 'frame', setting 'reg' to either NULL or a spilled register. */
+#define bpf_for_each_spilled_reg(iter, frame, reg)                      \
+        for (iter = 0, reg = bpf_get_spilled_reg(iter, frame);          \
+             iter < frame->allocated_stack / BPF_REG_SIZE;              \
+             iter++, reg = bpf_get_spilled_reg(iter, frame))
+
 /* linked list of verifier states used to prune search */
 struct bpf_verifier_state_list {
         struct bpf_verifier_state state;
@@ -206,15 +230,21 @@ __printf(2, 0) void bpf_verifier_vlog(struct bpf_verifier_log *log,
 __printf(2, 3) void bpf_verifier_log_write(struct bpf_verifier_env *env,
                                            const char *fmt, ...);
 
-static inline struct bpf_reg_state *cur_regs(struct bpf_verifier_env *env)
+static inline struct bpf_func_state *cur_func(struct bpf_verifier_env *env)
 {
         struct bpf_verifier_state *cur = env->cur_state;
 
-        return cur->frame[cur->curframe]->regs;
+        return cur->frame[cur->curframe];
+}
+
+static inline struct bpf_reg_state *cur_regs(struct bpf_verifier_env *env)
+{
+        return cur_func(env)->regs;
 }
 
 int bpf_prog_offload_verifier_prep(struct bpf_verifier_env *env);
 int bpf_prog_offload_verify_insn(struct bpf_verifier_env *env,
                                  int insn_idx, int prev_insn_idx);
+int bpf_prog_offload_finalize(struct bpf_verifier_env *env);
 
 #endif /* _LINUX_BPF_VERIFIER_H */
diff --git a/include/linux/buffer_head.h b/include/linux/buffer_head.h
index 96225a77c112..7b73ef7f902d 100644
--- a/include/linux/buffer_head.h
+++ b/include/linux/buffer_head.h
@@ -242,7 +242,7 @@ int block_commit_write(struct page *page, unsigned from, unsigned to);
 int block_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf,
                                 get_block_t get_block);
 /* Convert errno to return value from ->page_mkwrite() call */
-static inline int block_page_mkwrite_return(int err)
+static inline vm_fault_t block_page_mkwrite_return(int err)
 {
         if (err == 0)
                 return VM_FAULT_LOCKED;
diff --git a/include/linux/bvec.h b/include/linux/bvec.h
index fe7a22dd133b..02c73c6aa805 100644
--- a/include/linux/bvec.h
+++ b/include/linux/bvec.h
@@ -40,8 +40,6 @@ struct bvec_iter {
 
         unsigned int            bi_idx;         /* current index into bvl_vec */
 
-        unsigned int            bi_done;        /* number of bytes completed */
-
         unsigned int            bi_bvec_done;   /* number of bytes completed in
                                                    current bvec */
 };
@@ -85,7 +83,6 @@ static inline bool bvec_iter_advance(const struct bio_vec *bv,
                 bytes -= len;
                 iter->bi_size -= len;
                 iter->bi_bvec_done += len;
-                iter->bi_done += len;
 
                 if (iter->bi_bvec_done == __bvec_iter_bvec(bv, *iter)->bv_len) {
                         iter->bi_bvec_done = 0;
diff --git a/include/linux/cgroup-defs.h b/include/linux/cgroup-defs.h
index ff20b677fb9f..5e1694fe035b 100644
--- a/include/linux/cgroup-defs.h
+++ b/include/linux/cgroup-defs.h
@@ -20,6 +20,7 @@
 #include <linux/u64_stats_sync.h>
 #include <linux/workqueue.h>
 #include <linux/bpf-cgroup.h>
+#include <linux/psi_types.h>
 
 #ifdef CONFIG_CGROUPS
 
@@ -412,6 +413,7 @@ struct cgroup {
          * specific task are charged to the dom_cgrp.
          */
         struct cgroup *dom_cgrp;
+        struct cgroup *old_dom_cgrp;            /* used while enabling threaded */
 
         /* per-cpu recursive resource statistics */
         struct cgroup_rstat_cpu __percpu *rstat_cpu;
@@ -435,6 +437,9 @@ struct cgroup {
         /* used to schedule release agent */
         struct work_struct release_agent_work;
 
+        /* used to track pressure stalls */
+        struct psi_group psi;
+
         /* used to store eBPF programs */
         struct cgroup_bpf bpf;
 
diff --git a/include/linux/cgroup.h b/include/linux/cgroup.h
index 32c553556bbd..9968332cceed 100644
--- a/include/linux/cgroup.h
+++ b/include/linux/cgroup.h
@@ -93,6 +93,8 @@ extern struct css_set init_css_set;
 
 bool css_has_online_children(struct cgroup_subsys_state *css);
 struct cgroup_subsys_state *css_from_id(int id, struct cgroup_subsys *ss);
+struct cgroup_subsys_state *cgroup_e_css(struct cgroup *cgroup,
+                                         struct cgroup_subsys *ss);
 struct cgroup_subsys_state *cgroup_get_e_css(struct cgroup *cgroup,
                                              struct cgroup_subsys *ss);
 struct cgroup_subsys_state *css_tryget_online_from_dir(struct dentry *dentry,
@@ -567,20 +569,11 @@ static inline bool cgroup_is_descendant(struct cgroup *cgrp,
 static inline struct cgroup *cgroup_ancestor(struct cgroup *cgrp,
                                              int ancestor_level)
 {
-        struct cgroup *ptr;
-
         if (cgrp->level < ancestor_level)
                 return NULL;
-
-        for (ptr = cgrp;
-             ptr && ptr->level > ancestor_level;
-             ptr = cgroup_parent(ptr))
-                ;
-
-        if (ptr && ptr->level == ancestor_level)
-                return ptr;
-
-        return NULL;
+        while (cgrp && cgrp->level > ancestor_level)
+                cgrp = cgroup_parent(cgrp);
+        return cgrp;
 }
 
 /**
@@ -657,6 +650,11 @@ static inline void pr_cont_cgroup_path(struct cgroup *cgrp)
         pr_cont_kernfs_path(cgrp->kn);
 }
 
+static inline struct psi_group *cgroup_psi(struct cgroup *cgrp)
+{
+        return &cgrp->psi;
+}
+
 static inline void cgroup_init_kthreadd(void)
 {
         /*
@@ -710,6 +708,16 @@ static inline union kernfs_node_id *cgroup_get_kernfs_id(struct cgroup *cgrp)
         return NULL;
 }
 
+static inline struct cgroup *cgroup_parent(struct cgroup *cgrp)
+{
+        return NULL;
+}
+
+static inline struct psi_group *cgroup_psi(struct cgroup *cgrp)
+{
+        return NULL;
+}
+
 static inline bool task_under_cgroup_hierarchy(struct task_struct *task,
                                                struct cgroup *ancestor)
 {
diff --git a/include/linux/clocksource.h b/include/linux/clocksource.h
index 308918928767..b21db536fd52 100644
--- a/include/linux/clocksource.h
+++ b/include/linux/clocksource.h
@@ -241,6 +241,11 @@ static inline void __clocksource_update_freq_khz(struct clocksource *cs, u32 khz
         __clocksource_update_freq_scale(cs, 1000, khz);
 }
 
+#ifdef CONFIG_ARCH_CLOCKSOURCE_INIT
+extern void clocksource_arch_init(struct clocksource *cs);
+#else
+static inline void clocksource_arch_init(struct clocksource *cs) { }
+#endif
 
 extern int timekeeping_notify(struct clocksource *clock);
 
@@ -257,9 +262,6 @@ extern int clocksource_i8253_init(void);
 #define TIMER_OF_DECLARE(name, compat, fn) \
         OF_DECLARE_1_RET(timer, name, compat, fn)
 
-#define CLOCKSOURCE_OF_DECLARE(name, compat, fn) \
-        TIMER_OF_DECLARE(name, compat, fn)
-
 #ifdef CONFIG_TIMER_PROBE
 extern void timer_probe(void);
 #else
diff --git a/include/linux/compat.h b/include/linux/compat.h
index 1a3c4f37e908..d30e4dbd4be2 100644
--- a/include/linux/compat.h
+++ b/include/linux/compat.h
@@ -7,7 +7,7 @@
  */
 
 #include <linux/types.h>
-#include <linux/compat_time.h>
+#include <linux/time.h>
 
 #include <linux/stat.h>
 #include <linux/param.h>        /* for HZ */
@@ -103,6 +103,9 @@ typedef struct compat_sigaltstack {
         compat_size_t                   ss_size;
 } compat_stack_t;
 #endif
+#ifndef COMPAT_MINSIGSTKSZ
+#define COMPAT_MINSIGSTKSZ      MINSIGSTKSZ
+#endif
 
 #define compat_jiffies_to_clock_t(x)    \
                 (((unsigned long)(x) * COMPAT_USER_HZ) / HZ)
@@ -110,19 +113,12 @@ typedef struct compat_sigaltstack {
 typedef __compat_uid32_t        compat_uid_t;
 typedef __compat_gid32_t        compat_gid_t;
 
-typedef compat_ulong_t          compat_aio_context_t;
-
 struct compat_sel_arg_struct;
 struct rusage;
 
-struct compat_utimbuf {
-        compat_time_t           actime;
-        compat_time_t           modtime;
-};
-
 struct compat_itimerval {
-        struct compat_timeval   it_interval;
-        struct compat_timeval   it_value;
+        struct old_timeval32    it_interval;
+        struct old_timeval32    it_value;
 };
 
 struct itimerval;
@@ -146,7 +142,7 @@ struct compat_timex {
         compat_long_t constant;
         compat_long_t precision;
         compat_long_t tolerance;
-        struct compat_timeval time;
+        struct old_timeval32 time;
         compat_long_t tick;
         compat_long_t ppsfreq;
         compat_long_t jitter;
@@ -307,8 +303,8 @@ struct compat_rlimit {
 };
 
 struct compat_rusage {
-        struct compat_timeval ru_utime;
-        struct compat_timeval ru_stime;
+        struct old_timeval32 ru_utime;
+        struct old_timeval32 ru_stime;
         compat_long_t   ru_maxrss;
         compat_long_t   ru_ixrss;
         compat_long_t   ru_idrss;
@@ -452,13 +448,13 @@ long compat_get_bitmap(unsigned long *mask, const compat_ulong_t __user *umask,
                        unsigned long bitmap_size);
 long compat_put_bitmap(compat_ulong_t __user *umask, unsigned long *mask,
                        unsigned long bitmap_size);
-int copy_siginfo_from_user32(siginfo_t *to, const struct compat_siginfo __user *from);
-int copy_siginfo_to_user32(struct compat_siginfo __user *to, const siginfo_t *from);
+int copy_siginfo_from_user32(kernel_siginfo_t *to, const struct compat_siginfo __user *from);
+int copy_siginfo_to_user32(struct compat_siginfo __user *to, const kernel_siginfo_t *from);
 int get_compat_sigevent(struct sigevent *event,
                 const struct compat_sigevent __user *u_event);
 
-static inline int compat_timeval_compare(struct compat_timeval *lhs,
-                                        struct compat_timeval *rhs)
+static inline int old_timeval32_compare(struct old_timeval32 *lhs,
+                                        struct old_timeval32 *rhs)
 {
         if (lhs->tv_sec < rhs->tv_sec)
                 return -1;
@@ -467,8 +463,8 @@ static inline int compat_timeval_compare(struct compat_timeval *lhs,
         return lhs->tv_usec - rhs->tv_usec;
 }
 
-static inline int compat_timespec_compare(struct compat_timespec *lhs,
-                                        struct compat_timespec *rhs)
+static inline int old_timespec32_compare(struct old_timespec32 *lhs,
+                                        struct old_timespec32 *rhs)
 {
         if (lhs->tv_sec < rhs->tv_sec)
                 return -1;
@@ -552,12 +548,12 @@ asmlinkage long compat_sys_io_getevents(compat_aio_context_t ctx_id,
                                         compat_long_t min_nr,
                                         compat_long_t nr,
                                         struct io_event __user *events,
-                                        struct compat_timespec __user *timeout);
+                                        struct old_timespec32 __user *timeout);
 asmlinkage long compat_sys_io_pgetevents(compat_aio_context_t ctx_id,
                                         compat_long_t min_nr,
                                         compat_long_t nr,
                                         struct io_event __user *events,
-                                        struct compat_timespec __user *timeout,
+                                        struct old_timespec32 __user *timeout,
                                         const struct __compat_aio_sigset __user *usig);
 
 /* fs/cookies.c */
@@ -642,11 +638,11 @@ asmlinkage long compat_sys_sendfile64(int out_fd, int in_fd,
 asmlinkage long compat_sys_pselect6(int n, compat_ulong_t __user *inp,
                                     compat_ulong_t __user *outp,
                                     compat_ulong_t __user *exp,
-                                    struct compat_timespec __user *tsp,
+                                    struct old_timespec32 __user *tsp,
                                     void __user *sig);
 asmlinkage long compat_sys_ppoll(struct pollfd __user *ufds,
                                  unsigned int nfds,
-                                 struct compat_timespec __user *tsp,
+                                 struct old_timespec32 __user *tsp,
                                  const compat_sigset_t __user *sigmask,
                                  compat_size_t sigsetsize);
 
@@ -671,15 +667,15 @@ asmlinkage long compat_sys_newfstat(unsigned int fd,
 
 /* fs/timerfd.c */
 asmlinkage long compat_sys_timerfd_gettime(int ufd,
-                                   struct compat_itimerspec __user *otmr);
+                                   struct old_itimerspec32 __user *otmr);
 asmlinkage long compat_sys_timerfd_settime(int ufd, int flags,
-                                   const struct compat_itimerspec __user *utmr,
-                                   struct compat_itimerspec __user *otmr);
+                                   const struct old_itimerspec32 __user *utmr,
+                                   struct old_itimerspec32 __user *otmr);
 
 /* fs/utimes.c */
 asmlinkage long compat_sys_utimensat(unsigned int dfd,
                                      const char __user *filename,
-                                     struct compat_timespec __user *t,
+                                     struct old_timespec32 __user *t,
                                      int flags);
 
 /* kernel/exit.c */
@@ -691,7 +687,7 @@ asmlinkage long compat_sys_waitid(int, compat_pid_t,
 
 /* kernel/futex.c */
 asmlinkage long compat_sys_futex(u32 __user *uaddr, int op, u32 val,
-                struct compat_timespec __user *utime, u32 __user *uaddr2,
+                struct old_timespec32 __user *utime, u32 __user *uaddr2,
                 u32 val3);
 asmlinkage long
 compat_sys_set_robust_list(struct compat_robust_list_head __user *head,
@@ -701,8 +697,8 @@ compat_sys_get_robust_list(int pid, compat_uptr_t __user *head_ptr,
                            compat_size_t __user *len_ptr);
 
 /* kernel/hrtimer.c */
-asmlinkage long compat_sys_nanosleep(struct compat_timespec __user *rqtp,
-                                     struct compat_timespec __user *rmtp);
+asmlinkage long compat_sys_nanosleep(struct old_timespec32 __user *rqtp,
+                                     struct old_timespec32 __user *rmtp);
 
 /* kernel/itimer.c */
 asmlinkage long compat_sys_getitimer(int which,
@@ -722,19 +718,19 @@ asmlinkage long compat_sys_timer_create(clockid_t which_clock,
                         struct compat_sigevent __user *timer_event_spec,
                         timer_t __user *created_timer_id);
 asmlinkage long compat_sys_timer_gettime(timer_t timer_id,
-                                 struct compat_itimerspec __user *setting);
+                                 struct old_itimerspec32 __user *setting);
 asmlinkage long compat_sys_timer_settime(timer_t timer_id, int flags,
-                                         struct compat_itimerspec __user *new,
-                                         struct compat_itimerspec __user *old);
+                                         struct old_itimerspec32 __user *new,
+                                         struct old_itimerspec32 __user *old);
 asmlinkage long compat_sys_clock_settime(clockid_t which_clock,
-                                         struct compat_timespec __user *tp);
+                                         struct old_timespec32 __user *tp);
 asmlinkage long compat_sys_clock_gettime(clockid_t which_clock,
-                                         struct compat_timespec __user *tp);
+                                         struct old_timespec32 __user *tp);
 asmlinkage long compat_sys_clock_getres(clockid_t which_clock,
-                                        struct compat_timespec __user *tp);
+                                        struct old_timespec32 __user *tp);
 asmlinkage long compat_sys_clock_nanosleep(clockid_t which_clock, int flags,
-                                           struct compat_timespec __user *rqtp,
-                                           struct compat_timespec __user *rmtp);
+                                           struct old_timespec32 __user *rqtp,
+                                           struct old_timespec32 __user *rmtp);
 
 /* kernel/ptrace.c */
 asmlinkage long compat_sys_ptrace(compat_long_t request, compat_long_t pid,
@@ -748,7 +744,7 @@ asmlinkage long compat_sys_sched_getaffinity(compat_pid_t pid,
                                      unsigned int len,
                                      compat_ulong_t __user *user_mask_ptr);
 asmlinkage long compat_sys_sched_rr_get_interval(compat_pid_t pid,
-                                                 struct compat_timespec __user *interval);
+                                                 struct old_timespec32 __user *interval);
 
 /* kernel/signal.c */
 asmlinkage long compat_sys_sigaltstack(const compat_stack_t __user *uss_ptr,
@@ -768,7 +764,7 @@ asmlinkage long compat_sys_rt_sigpending(compat_sigset_t __user *uset,
                                          compat_size_t sigsetsize);
 asmlinkage long compat_sys_rt_sigtimedwait(compat_sigset_t __user *uthese,
                 struct compat_siginfo __user *uinfo,
-                struct compat_timespec __user *uts, compat_size_t sigsetsize);
+                struct old_timespec32 __user *uts, compat_size_t sigsetsize);
 asmlinkage long compat_sys_rt_sigqueueinfo(compat_pid_t pid, int sig,
                                 struct compat_siginfo __user *uinfo);
 /* No generic prototype for rt_sigreturn */
@@ -782,9 +778,9 @@ asmlinkage long compat_sys_setrlimit(unsigned int resource,
 asmlinkage long compat_sys_getrusage(int who, struct compat_rusage __user *ru);
 
 /* kernel/time.c */
-asmlinkage long compat_sys_gettimeofday(struct compat_timeval __user *tv,
+asmlinkage long compat_sys_gettimeofday(struct old_timeval32 __user *tv,
                 struct timezone __user *tz);
-asmlinkage long compat_sys_settimeofday(struct compat_timeval __user *tv,
+asmlinkage long compat_sys_settimeofday(struct old_timeval32 __user *tv,
                 struct timezone __user *tz);
 asmlinkage long compat_sys_adjtimex(struct compat_timex __user *utp);
 
@@ -798,11 +794,11 @@ asmlinkage long compat_sys_mq_open(const char __user *u_name,
 asmlinkage long compat_sys_mq_timedsend(mqd_t mqdes,
                         const char __user *u_msg_ptr,
                         compat_size_t msg_len, unsigned int msg_prio,
-                        const struct compat_timespec __user *u_abs_timeout);
+                        const struct old_timespec32 __user *u_abs_timeout);
 asmlinkage ssize_t compat_sys_mq_timedreceive(mqd_t mqdes,
                         char __user *u_msg_ptr,
                         compat_size_t msg_len, unsigned int __user *u_msg_prio,
-                        const struct compat_timespec __user *u_abs_timeout);
+                        const struct old_timespec32 __user *u_abs_timeout);
 asmlinkage long compat_sys_mq_notify(mqd_t mqdes,
                         const struct compat_sigevent __user *u_notification);
 asmlinkage long compat_sys_mq_getsetattr(mqd_t mqdes,
@@ -819,7 +815,7 @@ asmlinkage long compat_sys_msgsnd(int msqid, compat_uptr_t msgp,
 /* ipc/sem.c */
 asmlinkage long compat_sys_semctl(int semid, int semnum, int cmd, int arg);
 asmlinkage long compat_sys_semtimedop(int semid, struct sembuf __user *tsems,
-                unsigned nsems, const struct compat_timespec __user *timeout);
+                unsigned nsems, const struct old_timespec32 __user *timeout);
 
 /* ipc/shm.c */
 asmlinkage long compat_sys_shmctl(int first, int second, void __user *uptr);
@@ -876,7 +872,7 @@ asmlinkage long compat_sys_rt_tgsigqueueinfo(compat_pid_t tgid,
                                         struct compat_siginfo __user *uinfo);
 asmlinkage long compat_sys_recvmmsg(int fd, struct compat_mmsghdr __user *mmsg,
                                     unsigned vlen, unsigned int flags,
-                                    struct compat_timespec __user *timeout);
+                                    struct old_timespec32 __user *timeout);
 asmlinkage long compat_sys_wait4(compat_pid_t pid,
                                  compat_uint_t __user *stat_addr, int options,
                                  struct compat_rusage __user *ru);
@@ -928,7 +924,7 @@ asmlinkage long compat_sys_pwritev64v2(unsigned long fd,
 asmlinkage long compat_sys_open(const char __user *filename, int flags,
                                 umode_t mode);
 asmlinkage long compat_sys_utimes(const char __user *filename,
-                                  struct compat_timeval __user *t);
+                                  struct old_timeval32 __user *t);
 
 /* __ARCH_WANT_SYSCALL_NO_FLAGS */
 asmlinkage long compat_sys_signalfd(int ufd,
@@ -942,15 +938,15 @@ asmlinkage long compat_sys_newlstat(const char __user *filename,
                                     struct compat_stat __user *statbuf);
 
 /* __ARCH_WANT_SYSCALL_DEPRECATED */
-asmlinkage long compat_sys_time(compat_time_t __user *tloc);
+asmlinkage long compat_sys_time(old_time32_t __user *tloc);
 asmlinkage long compat_sys_utime(const char __user *filename,
-                                 struct compat_utimbuf __user *t);
+                                 struct old_utimbuf32 __user *t);
 asmlinkage long compat_sys_futimesat(unsigned int dfd,
                                      const char __user *filename,
-                                     struct compat_timeval __user *t);
+                                     struct old_timeval32 __user *t);
 asmlinkage long compat_sys_select(int n, compat_ulong_t __user *inp,
                 compat_ulong_t __user *outp, compat_ulong_t __user *exp,
-                struct compat_timeval __user *tvp);
+                struct old_timeval32 __user *tvp);
 asmlinkage long compat_sys_ustat(unsigned dev, struct compat_ustat __user *u32);
 asmlinkage long compat_sys_recv(int fd, void __user *buf, compat_size_t len,
                                 unsigned flags);
@@ -983,7 +979,7 @@ asmlinkage long compat_sys_sigaction(int sig,
 #endif
 
 /* obsolete: kernel/time/time.c */
-asmlinkage long compat_sys_stime(compat_time_t __user *tptr);
+asmlinkage long compat_sys_stime(old_time32_t __user *tptr);
 
 /* obsolete: net/socket.c */
 asmlinkage long compat_sys_socketcall(int call, u32 __user *args);
@@ -1002,15 +998,15 @@ static inline bool in_compat_syscall(void) { return is_compat_task(); }
 #endif
 
 /**
- * ns_to_compat_timeval - Compat version of ns_to_timeval
+ * ns_to_old_timeval32 - Compat version of ns_to_timeval
  * @nsec:       the nanoseconds value to be converted
  *
- * Returns the compat_timeval representation of the nsec parameter.
+ * Returns the old_timeval32 representation of the nsec parameter.
  */
-static inline struct compat_timeval ns_to_compat_timeval(s64 nsec)
+static inline struct old_timeval32 ns_to_old_timeval32(s64 nsec)
 {
         struct timeval tv;
-        struct compat_timeval ctv;
+        struct old_timeval32 ctv;
 
         tv = ns_to_timeval(nsec);
         ctv.tv_sec = tv.tv_sec;
diff --git a/include/linux/compat_time.h b/include/linux/compat_time.h
deleted file mode 100644
index e70bfd1d2c3f..000000000000
--- a/include/linux/compat_time.h
+++ /dev/null
@@ -1,32 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-#ifndef _LINUX_COMPAT_TIME_H
-#define _LINUX_COMPAT_TIME_H
-
-#include <linux/types.h>
-#include <linux/time64.h>
-
-typedef s32             compat_time_t;
-
-struct compat_timespec {
-        compat_time_t   tv_sec;
-        s32             tv_nsec;
-};
-
-struct compat_timeval {
-        compat_time_t   tv_sec;
-        s32             tv_usec;
-};
-
-struct compat_itimerspec {
-        struct compat_timespec it_interval;
-        struct compat_timespec it_value;
-};
-
-extern int compat_get_timespec64(struct timespec64 *, const void __user *);
-extern int compat_put_timespec64(const struct timespec64 *, void __user *);
-extern int get_compat_itimerspec64(struct itimerspec64 *its,
-                        const struct compat_itimerspec __user *uits);
-extern int put_compat_itimerspec64(const struct itimerspec64 *its,
-                        struct compat_itimerspec __user *uits);
-
-#endif /* _LINUX_COMPAT_TIME_H */
diff --git a/include/linux/compiler-gcc.h b/include/linux/compiler-gcc.h
index 763bbad1e258..90ddfefb6c2b 100644
--- a/include/linux/compiler-gcc.h
+++ b/include/linux/compiler-gcc.h
@@ -79,20 +79,6 @@
 #define __noretpoline __attribute__((indirect_branch("keep")))
 #endif
 
-/*
- * it doesn't make sense on ARM (currently the only user of __naked)
- * to trace naked functions because then mcount is called without
- * stack and frame pointer being set up and there is no chance to
- * restore the lr register to the value before mcount was called.
- *
- * The asm() bodies of naked functions often depend on standard calling
- * conventions, therefore they must be noinline and noclone.
- *
- * GCC 4.[56] currently fail to enforce this, so we must do so ourselves.
- * See GCC PR44290.
- */
-#define __naked         __attribute__((naked)) noinline __noclone notrace
-
 #define __UNIQUE_ID(prefix) __PASTE(__PASTE(__UNIQUE_ID_, prefix), __COUNTER__)
 
 #define __optimize(level)       __attribute__((__optimize__(level)))
@@ -208,6 +194,12 @@
  * Conflicts with inlining: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=67368
  */
 #define __no_sanitize_address __attribute__((no_sanitize_address))
+#ifdef CONFIG_KASAN
+#define __no_sanitize_address_or_inline                                 \
+        __no_sanitize_address __maybe_unused notrace
+#else
+#define __no_sanitize_address_or_inline inline
+#endif
 #endif
 
 #if GCC_VERSION >= 50100
@@ -225,6 +217,7 @@
 
 #if !defined(__no_sanitize_address)
 #define __no_sanitize_address
+#define __no_sanitize_address_or_inline inline
 #endif
 
 /*
diff --git a/include/linux/compiler.h b/include/linux/compiler.h
index 681d866efb1e..4170fcee5adb 100644
--- a/include/linux/compiler.h
+++ b/include/linux/compiler.h
@@ -99,22 +99,13 @@ void ftrace_likely_update(struct ftrace_likely_data *f, int val,
  * unique, to convince GCC not to merge duplicate inline asm statements.
  */
 #define annotate_reachable() ({                                         \
-        asm volatile("%c0:\n\t"                                         \
-                     ".pushsection .discard.reachable\n\t"              \
-                     ".long %c0b - .\n\t"                               \
-                     ".popsection\n\t" : : "i" (__COUNTER__));          \
+        asm volatile("ANNOTATE_REACHABLE counter=%c0"                   \
+                     : : "i" (__COUNTER__));                            \
 })
 #define annotate_unreachable() ({                                       \
-        asm volatile("%c0:\n\t"                                         \
-                     ".pushsection .discard.unreachable\n\t"            \
-                     ".long %c0b - .\n\t"                               \
-                     ".popsection\n\t" : : "i" (__COUNTER__));          \
+        asm volatile("ANNOTATE_UNREACHABLE counter=%c0"                 \
+                     : : "i" (__COUNTER__));                            \
 })
-#define ASM_UNREACHABLE                                                 \
-        "999:\n\t"                                                      \
-        ".pushsection .discard.unreachable\n\t"                         \
-        ".long 999b - .\n\t"                                            \
-        ".popsection\n\t"
 #else
 #define annotate_reachable()
 #define annotate_unreachable()
@@ -299,6 +290,45 @@ static inline void *offset_to_ptr(const int *off)
         return (void *)((unsigned long)off + *off);
 }
 
+#else /* __ASSEMBLY__ */
+
+#ifdef __KERNEL__
+#ifndef LINKER_SCRIPT
+
+#ifdef CONFIG_STACK_VALIDATION
+.macro ANNOTATE_UNREACHABLE counter:req
+\counter:
+        .pushsection .discard.unreachable
+        .long \counter\()b -.
+        .popsection
+.endm
+
+.macro ANNOTATE_REACHABLE counter:req
+\counter:
+        .pushsection .discard.reachable
+        .long \counter\()b -.
+        .popsection
+.endm
+
+.macro ASM_UNREACHABLE
+999:
+        .pushsection .discard.unreachable
+        .long 999b - .
+        .popsection
+.endm
+#else /* CONFIG_STACK_VALIDATION */
+.macro ANNOTATE_UNREACHABLE counter:req
+.endm
+
+.macro ANNOTATE_REACHABLE counter:req
+.endm
+
+.macro ASM_UNREACHABLE
+.endm
+#endif /* CONFIG_STACK_VALIDATION */
+
+#endif /* LINKER_SCRIPT */
+#endif /* __KERNEL__ */
 #endif /* __ASSEMBLY__ */
 
 #ifndef __optimize
@@ -314,29 +344,14 @@ static inline void *offset_to_ptr(const int *off)
 #endif
 #ifndef __compiletime_error
 # define __compiletime_error(message)
-/*
- * Sparse complains of variable sized arrays due to the temporary variable in
- * __compiletime_assert. Unfortunately we can't just expand it out to make
- * sparse see a constant array size without breaking compiletime_assert on old
- * versions of GCC (e.g. 4.2.4), so hide the array from sparse altogether.
- */
-# ifndef __CHECKER__
-#  define __compiletime_error_fallback(condition) \
-        do { ((void)sizeof(char[1 - 2 * condition])); } while (0)
-# endif
-#endif
-#ifndef __compiletime_error_fallback
-# define __compiletime_error_fallback(condition) do { } while (0)
 #endif
 
 #ifdef __OPTIMIZE__
 # define __compiletime_assert(condition, msg, prefix, suffix)           \
         do {                                                            \
-                int __cond = !(condition);                              \
                 extern void prefix ## suffix(void) __compiletime_error(msg); \
-                if (__cond)                                             \
+                if (!(condition))                                       \
                         prefix ## suffix();                             \
-                __compiletime_error_fallback(__cond);                   \
         } while (0)
 #else
 # define __compiletime_assert(condition, msg, prefix, suffix) do { } while (0)
diff --git a/include/linux/compiler_types.h b/include/linux/compiler_types.h
index 3525c179698c..97cfe29b3f0a 100644
--- a/include/linux/compiler_types.h
+++ b/include/linux/compiler_types.h
@@ -198,7 +198,6 @@ struct ftrace_likely_data {
  */
 #define __pure                  __attribute__((pure))
 #define __aligned(x)            __attribute__((aligned(x)))
-#define __aligned_largest       __attribute__((aligned))
 #define __printf(a, b)          __attribute__((format(printf, a, b)))
 #define __scanf(a, b)           __attribute__((format(scanf, a, b)))
 #define __maybe_unused          __attribute__((unused))
@@ -226,6 +225,14 @@ struct ftrace_likely_data {
 #define notrace                 __attribute__((no_instrument_function))
 #endif
 
+/*
+ * it doesn't make sense on ARM (currently the only user of __naked)
+ * to trace naked functions because then mcount is called without
+ * stack and frame pointer being set up and there is no chance to
+ * restore the lr register to the value before mcount was called.
+ */
+#define __naked                 __attribute__((naked)) notrace
+
 #define __compiler_offsetof(a, b)       __builtin_offsetof(a, b)
 
 /*
diff --git a/include/linux/console_struct.h b/include/linux/console_struct.h
index fea64f2692a0..ab137f97ecbd 100644
--- a/include/linux/console_struct.h
+++ b/include/linux/console_struct.h
@@ -141,7 +141,6 @@ struct vc_data {
         struct uni_pagedir *vc_uni_pagedir;
         struct uni_pagedir **vc_uni_pagedir_loc; /* [!] Location of uni_pagedir variable for this console */
         struct uni_screen *vc_uni_screen;       /* unicode screen content */
-        bool vc_panic_force_write; /* when oops/panic this VC can accept forced output/blanking */
         /* additional information is in vt_kern.h */
 };
 
diff --git a/include/linux/coredump.h b/include/linux/coredump.h
index 207aed96a5b7..abf4b4e65dbb 100644
--- a/include/linux/coredump.h
+++ b/include/linux/coredump.h
@@ -17,9 +17,9 @@ extern int dump_emit(struct coredump_params *cprm, const void *addr, int nr);
 extern int dump_align(struct coredump_params *cprm, int align);
 extern void dump_truncate(struct coredump_params *cprm);
 #ifdef CONFIG_COREDUMP
-extern void do_coredump(const siginfo_t *siginfo);
+extern void do_coredump(const kernel_siginfo_t *siginfo);
 #else
-static inline void do_coredump(const siginfo_t *siginfo) {}
+static inline void do_coredump(const kernel_siginfo_t *siginfo) {}
 #endif
 
 #endif /* _LINUX_COREDUMP_H */
diff --git a/include/linux/coresight.h b/include/linux/coresight.h
index d828a6efe0b1..46c67a764877 100644
--- a/include/linux/coresight.h
+++ b/include/linux/coresight.h
@@ -94,20 +94,15 @@ union coresight_dev_subtype {
  * @cpu:        the CPU a source belongs to. Only applicable for ETM/PTMs.
  * @name:       name of the component as shown under sysfs.
  * @nr_inport:  number of input ports for this component.
- * @outports:   list of remote endpoint port number.
- * @child_names:name of all child components connected to this device.
- * @child_ports:child component port number the current component is
-                connected  to.
  * @nr_outport: number of output ports for this component.
+ * @conns:      Array of nr_outport connections from this component
  */
 struct coresight_platform_data {
         int cpu;
         const char *name;
         int nr_inport;
-        int *outports;
-        const char **child_names;
-        int *child_ports;
         int nr_outport;
+        struct coresight_connection *conns;
 };
 
 /**
@@ -190,23 +185,15 @@ struct coresight_device {
  * @disable:            disables the sink.
  * @alloc_buffer:       initialises perf's ring buffer for trace collection.
  * @free_buffer:        release memory allocated in @get_config.
- * @set_buffer:         initialises buffer mechanic before a trace session.
- * @reset_buffer:       finalises buffer mechanic after a trace session.
  * @update_buffer:      update buffer pointers after a trace session.
  */
 struct coresight_ops_sink {
-        int (*enable)(struct coresight_device *csdev, u32 mode);
+        int (*enable)(struct coresight_device *csdev, u32 mode, void *data);
         void (*disable)(struct coresight_device *csdev);
         void *(*alloc_buffer)(struct coresight_device *csdev, int cpu,
                               void **pages, int nr_pages, bool overwrite);
         void (*free_buffer)(void *config);
-        int (*set_buffer)(struct coresight_device *csdev,
-                          struct perf_output_handle *handle,
-                          void *sink_config);
-        unsigned long (*reset_buffer)(struct coresight_device *csdev,
-                                      struct perf_output_handle *handle,
-                                      void *sink_config);
-        void (*update_buffer)(struct coresight_device *csdev,
+        unsigned long (*update_buffer)(struct coresight_device *csdev,
                               struct perf_output_handle *handle,
                               void *sink_config);
 };
@@ -270,6 +257,13 @@ extern int coresight_enable(struct coresight_device *csdev);
 extern void coresight_disable(struct coresight_device *csdev);
 extern int coresight_timeout(void __iomem *addr, u32 offset,
                              int position, int value);
+
+extern int coresight_claim_device(void __iomem *base);
+extern int coresight_claim_device_unlocked(void __iomem *base);
+
+extern void coresight_disclaim_device(void __iomem *base);
+extern void coresight_disclaim_device_unlocked(void __iomem *base);
+
 #else
 static inline struct coresight_device *
 coresight_register(struct coresight_desc *desc) { return NULL; }
@@ -279,6 +273,19 @@ coresight_enable(struct coresight_device *csdev) { return -ENOSYS; }
 static inline void coresight_disable(struct coresight_device *csdev) {}
 static inline int coresight_timeout(void __iomem *addr, u32 offset,
                                      int position, int value) { return 1; }
+static inline int coresight_claim_device_unlocked(void __iomem *base)
+{
+        return -EINVAL;
+}
+
+static inline int coresight_claim_device(void __iomem *base)
+{
+        return -EINVAL;
+}
+
+static inline void coresight_disclaim_device(void __iomem *base) {}
+static inline void coresight_disclaim_device_unlocked(void __iomem *base) {}
+
 #endif
 
 #ifdef CONFIG_OF
diff --git a/include/linux/cpufeature.h b/include/linux/cpufeature.h
index 986c06c88d81..84d3c81b5978 100644
--- a/include/linux/cpufeature.h
+++ b/include/linux/cpufeature.h
@@ -45,7 +45,7 @@
  * 'asm/cpufeature.h' of your favorite architecture.
  */
 #define module_cpu_feature_match(x, __initfunc)                 \
-static struct cpu_feature const cpu_feature_match_ ## x[] =     \
+static struct cpu_feature const __maybe_unused cpu_feature_match_ ## x[] = \
         { { .feature = cpu_feature(x) }, { } };                 \
 MODULE_DEVICE_TABLE(cpu, cpu_feature_match_ ## x);              \
                                                                 \
diff --git a/include/linux/cpuidle.h b/include/linux/cpuidle.h
index 4325d6fdde9b..faed7a8977e8 100644
--- a/include/linux/cpuidle.h
+++ b/include/linux/cpuidle.h
@@ -81,6 +81,7 @@ struct cpuidle_device {
         unsigned int            registered:1;
         unsigned int            enabled:1;
         unsigned int            use_deepest_state:1;
+        unsigned int            poll_time_limit:1;
         unsigned int            cpu;
 
         int                     last_residency;
@@ -99,16 +100,6 @@ struct cpuidle_device {
 DECLARE_PER_CPU(struct cpuidle_device *, cpuidle_devices);
 DECLARE_PER_CPU(struct cpuidle_device, cpuidle_dev);
 
-/**
- * cpuidle_get_last_residency - retrieves the last state's residency time
- * @dev: the target CPU
- */
-static inline int cpuidle_get_last_residency(struct cpuidle_device *dev)
-{
-        return dev->last_residency;
-}
-
-
 /****************************
  * CPUIDLE DRIVER INTERFACE *
  ****************************/
diff --git a/include/linux/crash_dump.h b/include/linux/crash_dump.h
index 3e4ba9d753c8..f774c5eb9e3c 100644
--- a/include/linux/crash_dump.h
+++ b/include/linux/crash_dump.h
@@ -26,6 +26,10 @@ extern int remap_oldmem_pfn_range(struct vm_area_struct *vma,
 
 extern ssize_t copy_oldmem_page(unsigned long, char *, size_t,
                                                 unsigned long, int);
+extern ssize_t copy_oldmem_page_encrypted(unsigned long pfn, char *buf,
+                                          size_t csize, unsigned long offset,
+                                          int userbuf);
+
 void vmcore_cleanup(void);
 
 /* Architecture code defines this if there are other possible ELF
diff --git a/include/linux/crc-t10dif.h b/include/linux/crc-t10dif.h
index 1fe0cfcdea30..6bb0c0bf357b 100644
--- a/include/linux/crc-t10dif.h
+++ b/include/linux/crc-t10dif.h
@@ -6,6 +6,7 @@
 
 #define CRC_T10DIF_DIGEST_SIZE 2
 #define CRC_T10DIF_BLOCK_SIZE 1
+#define CRC_T10DIF_STRING "crct10dif"
 
 extern __u16 crc_t10dif_generic(__u16 crc, const unsigned char *buffer,
                                 size_t len);
diff --git a/include/linux/crypto.h b/include/linux/crypto.h
index e8839d3a7559..3634ad6fe202 100644
--- a/include/linux/crypto.h
+++ b/include/linux/crypto.h
@@ -454,6 +454,33 @@ struct compress_alg {
  * @cra_refcnt: internally used
  * @cra_destroy: internally used
  *
+ * All following statistics are for this crypto_alg
+ * @encrypt_cnt:        number of encrypt requests
+ * @decrypt_cnt:        number of decrypt requests
+ * @compress_cnt:       number of compress requests
+ * @decompress_cnt:     number of decompress requests
+ * @generate_cnt:       number of RNG generate requests
+ * @seed_cnt:           number of times the rng was seeded
+ * @hash_cnt:           number of hash requests
+ * @sign_cnt:           number of sign requests
+ * @setsecret_cnt:      number of setsecrey operation
+ * @generate_public_key_cnt:    number of generate_public_key operation
+ * @verify_cnt:                 number of verify operation
+ * @compute_shared_secret_cnt:  number of compute_shared_secret operation
+ * @encrypt_tlen:       total data size handled by encrypt requests
+ * @decrypt_tlen:       total data size handled by decrypt requests
+ * @compress_tlen:      total data size handled by compress requests
+ * @decompress_tlen:    total data size handled by decompress requests
+ * @generate_tlen:      total data size of generated data by the RNG
+ * @hash_tlen:          total data size hashed
+ * @akcipher_err_cnt:   number of error for akcipher requests
+ * @cipher_err_cnt:     number of error for akcipher requests
+ * @compress_err_cnt:   number of error for akcipher requests
+ * @aead_err_cnt:       number of error for akcipher requests
+ * @hash_err_cnt:       number of error for akcipher requests
+ * @rng_err_cnt:        number of error for akcipher requests
+ * @kpp_err_cnt:        number of error for akcipher requests
+ *
  * The struct crypto_alg describes a generic Crypto API algorithm and is common
  * for all of the transformations. Any variable not documented here shall not
  * be used by a cipher implementation as it is internal to the Crypto API.
@@ -487,6 +514,45 @@ struct crypto_alg {
         void (*cra_destroy)(struct crypto_alg *alg);
         
         struct module *cra_module;
+
+        union {
+                atomic_t encrypt_cnt;
+                atomic_t compress_cnt;
+                atomic_t generate_cnt;
+                atomic_t hash_cnt;
+                atomic_t setsecret_cnt;
+        };
+        union {
+                atomic64_t encrypt_tlen;
+                atomic64_t compress_tlen;
+                atomic64_t generate_tlen;
+                atomic64_t hash_tlen;
+        };
+        union {
+                atomic_t akcipher_err_cnt;
+                atomic_t cipher_err_cnt;
+                atomic_t compress_err_cnt;
+                atomic_t aead_err_cnt;
+                atomic_t hash_err_cnt;
+                atomic_t rng_err_cnt;
+                atomic_t kpp_err_cnt;
+        };
+        union {
+                atomic_t decrypt_cnt;
+                atomic_t decompress_cnt;
+                atomic_t seed_cnt;
+                atomic_t generate_public_key_cnt;
+        };
+        union {
+                atomic64_t decrypt_tlen;
+                atomic64_t decompress_tlen;
+        };
+        union {
+                atomic_t verify_cnt;
+                atomic_t compute_shared_secret_cnt;
+        };
+        atomic_t sign_cnt;
+
 } CRYPTO_MINALIGN_ATTR;
 
 /*
@@ -907,6 +973,38 @@ static inline struct crypto_ablkcipher *crypto_ablkcipher_reqtfm(
         return __crypto_ablkcipher_cast(req->base.tfm);
 }
 
+static inline void crypto_stat_ablkcipher_encrypt(struct ablkcipher_request *req,
+                                                  int ret)
+{
+#ifdef CONFIG_CRYPTO_STATS
+        struct ablkcipher_tfm *crt =
+                crypto_ablkcipher_crt(crypto_ablkcipher_reqtfm(req));
+
+        if (ret && ret != -EINPROGRESS && ret != -EBUSY) {
+                atomic_inc(&crt->base->base.__crt_alg->cipher_err_cnt);
+        } else {
+                atomic_inc(&crt->base->base.__crt_alg->encrypt_cnt);
+                atomic64_add(req->nbytes, &crt->base->base.__crt_alg->encrypt_tlen);
+        }
+#endif
+}
+
+static inline void crypto_stat_ablkcipher_decrypt(struct ablkcipher_request *req,
+                                                  int ret)
+{
+#ifdef CONFIG_CRYPTO_STATS
+        struct ablkcipher_tfm *crt =
+                crypto_ablkcipher_crt(crypto_ablkcipher_reqtfm(req));
+
+        if (ret && ret != -EINPROGRESS && ret != -EBUSY) {
+                atomic_inc(&crt->base->base.__crt_alg->cipher_err_cnt);
+        } else {
+                atomic_inc(&crt->base->base.__crt_alg->decrypt_cnt);
+                atomic64_add(req->nbytes, &crt->base->base.__crt_alg->decrypt_tlen);
+        }
+#endif
+}
+
 /**
  * crypto_ablkcipher_encrypt() - encrypt plaintext
  * @req: reference to the ablkcipher_request handle that holds all information
@@ -922,7 +1020,11 @@ static inline int crypto_ablkcipher_encrypt(struct ablkcipher_request *req)
 {
         struct ablkcipher_tfm *crt =
                 crypto_ablkcipher_crt(crypto_ablkcipher_reqtfm(req));
-        return crt->encrypt(req);
+        int ret;
+
+        ret = crt->encrypt(req);
+        crypto_stat_ablkcipher_encrypt(req, ret);
+        return ret;
 }
 
 /**
@@ -940,7 +1042,11 @@ static inline int crypto_ablkcipher_decrypt(struct ablkcipher_request *req)
 {
         struct ablkcipher_tfm *crt =
                 crypto_ablkcipher_crt(crypto_ablkcipher_reqtfm(req));
-        return crt->decrypt(req);
+        int ret;
+
+        ret = crt->decrypt(req);
+        crypto_stat_ablkcipher_decrypt(req, ret);
+        return ret;
 }
 
 /**
diff --git a/include/linux/cuda.h b/include/linux/cuda.h
index 056867f09a01..45bfe9d61271 100644
--- a/include/linux/cuda.h
+++ b/include/linux/cuda.h
@@ -8,6 +8,7 @@
 #ifndef _LINUX_CUDA_H
 #define _LINUX_CUDA_H
 
+#include <linux/rtc.h>
 #include <uapi/linux/cuda.h>
 
 
@@ -16,4 +17,7 @@ extern int cuda_request(struct adb_request *req,
                         void (*done)(struct adb_request *), int nbytes, ...);
 extern void cuda_poll(void);
 
+extern time64_t cuda_get_time(void);
+extern int cuda_set_rtc_time(struct rtc_time *tm);
+
 #endif /* _LINUX_CUDA_H */
diff --git a/include/linux/debug_locks.h b/include/linux/debug_locks.h
index 120225e9a366..257ab3c92cb8 100644
--- a/include/linux/debug_locks.h
+++ b/include/linux/debug_locks.h
@@ -8,8 +8,8 @@
 
 struct task_struct;
 
-extern int debug_locks;
-extern int debug_locks_silent;
+extern int debug_locks __read_mostly;
+extern int debug_locks_silent __read_mostly;
 
 
 static inline int __debug_locks_off(void)
diff --git a/include/linux/delayacct.h b/include/linux/delayacct.h
index 31c865d1842e..577d1b25fccd 100644
--- a/include/linux/delayacct.h
+++ b/include/linux/delayacct.h
@@ -57,7 +57,12 @@ struct task_delay_info {
 
         u64 freepages_start;
         u64 freepages_delay;    /* wait for memory reclaim */
+
+        u64 thrashing_start;
+        u64 thrashing_delay;    /* wait for thrashing page */
+
         u32 freepages_count;    /* total count of memory reclaim */
+        u32 thrashing_count;    /* total count of thrash waits */
 };
 #endif
 
@@ -76,6 +81,8 @@ extern int __delayacct_add_tsk(struct taskstats *, struct task_struct *);
 extern __u64 __delayacct_blkio_ticks(struct task_struct *);
 extern void __delayacct_freepages_start(void);
 extern void __delayacct_freepages_end(void);
+extern void __delayacct_thrashing_start(void);
+extern void __delayacct_thrashing_end(void);
 
 static inline int delayacct_is_task_waiting_on_io(struct task_struct *p)
 {
@@ -156,6 +163,18 @@ static inline void delayacct_freepages_end(void)
                 __delayacct_freepages_end();
 }
 
+static inline void delayacct_thrashing_start(void)
+{
+        if (current->delays)
+                __delayacct_thrashing_start();
+}
+
+static inline void delayacct_thrashing_end(void)
+{
+        if (current->delays)
+                __delayacct_thrashing_end();
+}
+
 #else
 static inline void delayacct_set_flag(int flag)
 {}
@@ -182,6 +201,10 @@ static inline void delayacct_freepages_start(void)
 {}
 static inline void delayacct_freepages_end(void)
 {}
+static inline void delayacct_thrashing_start(void)
+{}
+static inline void delayacct_thrashing_end(void)
+{}
 
 #endif /* CONFIG_TASK_DELAY_ACCT */
 
diff --git a/include/linux/devfreq.h b/include/linux/devfreq.h
index 3aae5b3af87c..e4963b0f45da 100644
--- a/include/linux/devfreq.h
+++ b/include/linux/devfreq.h
@@ -198,6 +198,14 @@ extern void devm_devfreq_remove_device(struct device *dev,
 extern int devfreq_suspend_device(struct devfreq *devfreq);
 extern int devfreq_resume_device(struct devfreq *devfreq);
 
+/**
+ * update_devfreq() - Reevaluate the device and configure frequency
+ * @devfreq:    the devfreq device
+ *
+ * Note: devfreq->lock must be held
+ */
+extern int update_devfreq(struct devfreq *devfreq);
+
 /* Helper functions for devfreq user device driver with OPP. */
 extern struct dev_pm_opp *devfreq_recommended_opp(struct device *dev,
                                            unsigned long *freq, u32 flags);
diff --git a/include/linux/device-mapper.h b/include/linux/device-mapper.h
index 6fb0808e87c8..e528baebad69 100644
--- a/include/linux/device-mapper.h
+++ b/include/linux/device-mapper.h
@@ -26,9 +26,8 @@ enum dm_queue_mode {
         DM_TYPE_NONE             = 0,
         DM_TYPE_BIO_BASED        = 1,
         DM_TYPE_REQUEST_BASED    = 2,
-        DM_TYPE_MQ_REQUEST_BASED = 3,
-        DM_TYPE_DAX_BIO_BASED    = 4,
-        DM_TYPE_NVME_BIO_BASED   = 5,
+        DM_TYPE_DAX_BIO_BASED    = 3,
+        DM_TYPE_NVME_BIO_BASED   = 4,
 };
 
 typedef enum { STATUSTYPE_INFO, STATUSTYPE_TABLE } status_type_t;
@@ -92,6 +91,11 @@ typedef int (*dm_message_fn) (struct dm_target *ti, unsigned argc, char **argv,
 
 typedef int (*dm_prepare_ioctl_fn) (struct dm_target *ti, struct block_device **bdev);
 
+typedef int (*dm_report_zones_fn) (struct dm_target *ti, sector_t sector,
+                                   struct blk_zone *zones,
+                                   unsigned int *nr_zones,
+                                   gfp_t gfp_mask);
+
 /*
  * These iteration functions are typically used to check (and combine)
  * properties of underlying devices.
@@ -180,6 +184,9 @@ struct target_type {
         dm_status_fn status;
         dm_message_fn message;
         dm_prepare_ioctl_fn prepare_ioctl;
+#ifdef CONFIG_BLK_DEV_ZONED
+        dm_report_zones_fn report_zones;
+#endif
         dm_busy_fn busy;
         dm_iterate_devices_fn iterate_devices;
         dm_io_hints_fn io_hints;
@@ -420,8 +427,8 @@ struct gendisk *dm_disk(struct mapped_device *md);
 int dm_suspended(struct dm_target *ti);
 int dm_noflush_suspending(struct dm_target *ti);
 void dm_accept_partial_bio(struct bio *bio, unsigned n_sectors);
-void dm_remap_zone_report(struct dm_target *ti, struct bio *bio,
-                          sector_t start);
+void dm_remap_zone_report(struct dm_target *ti, sector_t start,
+                          struct blk_zone *zones, unsigned int *nr_zones);
 union map_info *dm_get_rq_mapinfo(struct request *rq);
 
 struct queue_limits *dm_get_queue_limits(struct mapped_device *md);
@@ -490,6 +497,7 @@ sector_t dm_table_get_size(struct dm_table *t);
 unsigned int dm_table_get_num_targets(struct dm_table *t);
 fmode_t dm_table_get_mode(struct dm_table *t);
 struct mapped_device *dm_table_get_md(struct dm_table *t);
+const char *dm_table_device_name(struct dm_table *t);
 
 /*
  * Trigger an event.
diff --git a/include/linux/device.h b/include/linux/device.h
index 8f882549edee..1b25c7a43f4c 100644
--- a/include/linux/device.h
+++ b/include/linux/device.h
@@ -55,6 +55,8 @@ struct bus_attribute {
         struct bus_attribute bus_attr_##_name = __ATTR_RW(_name)
 #define BUS_ATTR_RO(_name) \
         struct bus_attribute bus_attr_##_name = __ATTR_RO(_name)
+#define BUS_ATTR_WO(_name) \
+        struct bus_attribute bus_attr_##_name = __ATTR_WO(_name)
 
 extern int __must_check bus_create_file(struct bus_type *,
                                         struct bus_attribute *);
@@ -692,8 +694,10 @@ static inline void *devm_kcalloc(struct device *dev,
 {
         return devm_kmalloc_array(dev, n, size, flags | __GFP_ZERO);
 }
-extern void devm_kfree(struct device *dev, void *p);
+extern void devm_kfree(struct device *dev, const void *p);
 extern char *devm_kstrdup(struct device *dev, const char *s, gfp_t gfp) __malloc;
+extern const char *devm_kstrdup_const(struct device *dev,
+                                      const char *s, gfp_t gfp);
 extern void *devm_kmemdup(struct device *dev, const void *src, size_t len,
                           gfp_t gfp);
 
@@ -774,6 +778,30 @@ void device_connection_add(struct device_connection *con);
 void device_connection_remove(struct device_connection *con);
 
 /**
+ * device_connections_add - Add multiple device connections at once
+ * @cons: Zero terminated array of device connection descriptors
+ */
+static inline void device_connections_add(struct device_connection *cons)
+{
+        struct device_connection *c;
+
+        for (c = cons; c->endpoint[0]; c++)
+                device_connection_add(c);
+}
+
+/**
+ * device_connections_remove - Remove multiple device connections at once
+ * @cons: Zero terminated array of device connection descriptors
+ */
+static inline void device_connections_remove(struct device_connection *cons)
+{
+        struct device_connection *c;
+
+        for (c = cons; c->endpoint[0]; c++)
+                device_connection_remove(c);
+}
+
+/**
  * enum device_link_state - Device link states.
  * @DL_STATE_NONE: The presence of the drivers is not being tracked.
  * @DL_STATE_DORMANT: None of the supplier/consumer drivers is present.
@@ -927,6 +955,8 @@ struct dev_links_info {
  * @offline:    Set after successful invocation of bus type's .offline().
  * @of_node_reused: Set if the device-tree node is shared with an ancestor
  *              device.
+ * @dma_coherent: this particular device is dma coherent, even if the
+ *              architecture supports non-coherent devices.
  *
  * At the lowest level, every device in a Linux system is represented by an
  * instance of struct device. The device structure contains the information
@@ -1016,6 +1046,11 @@ struct device {
         bool                    offline_disabled:1;
         bool                    offline:1;
         bool                    of_node_reused:1;
+#if defined(CONFIG_ARCH_HAS_SYNC_DMA_FOR_DEVICE) || \
+    defined(CONFIG_ARCH_HAS_SYNC_DMA_FOR_CPU) || \
+    defined(CONFIG_ARCH_HAS_SYNC_DMA_FOR_CPU_ALL)
+        bool                    dma_coherent:1;
+#endif
 };
 
 static inline struct device *kobj_to_dev(struct kobject *kobj)
diff --git a/include/linux/dma-debug.h b/include/linux/dma-debug.h
index a785f2507159..30213adbb6b9 100644
--- a/include/linux/dma-debug.h
+++ b/include/linux/dma-debug.h
@@ -32,6 +32,9 @@ extern void dma_debug_add_bus(struct bus_type *bus);
 
 extern int dma_debug_resize_entries(u32 num_entries);
 
+extern void debug_dma_map_single(struct device *dev, const void *addr,
+                                 unsigned long len);
+
 extern void debug_dma_map_page(struct device *dev, struct page *page,
                                size_t offset, size_t size,
                                int direction, dma_addr_t dma_addr,
@@ -103,6 +106,11 @@ static inline int dma_debug_resize_entries(u32 num_entries)
         return 0;
 }
 
+static inline void debug_dma_map_single(struct device *dev, const void *addr,
+                                        unsigned long len)
+{
+}
+
 static inline void debug_dma_map_page(struct device *dev, struct page *page,
                                       size_t offset, size_t size,
                                       int direction, dma_addr_t dma_addr,
diff --git a/include/linux/dma-direct.h b/include/linux/dma-direct.h
index 8d9f33febde5..bd73e7a91410 100644
--- a/include/linux/dma-direct.h
+++ b/include/linux/dma-direct.h
@@ -5,6 +5,8 @@
 #include <linux/dma-mapping.h>
 #include <linux/mem_encrypt.h>
 
+#define DIRECT_MAPPING_ERROR            0
+
 #ifdef CONFIG_ARCH_HAS_PHYS_TO_DMA
 #include <asm/dma-direct.h>
 #else
@@ -27,7 +29,8 @@ static inline bool dma_capable(struct device *dev, dma_addr_t addr, size_t size)
         if (!dev->dma_mask)
                 return false;
 
-        return addr + size - 1 <= *dev->dma_mask;
+        return addr + size - 1 <=
+                min_not_zero(*dev->dma_mask, dev->bus_dma_mask);
 }
 #endif /* !CONFIG_ARCH_HAS_PHYS_TO_DMA */
 
@@ -55,10 +58,15 @@ static inline void dma_mark_clean(void *addr, size_t size)
 }
 #endif /* CONFIG_ARCH_HAS_DMA_MARK_CLEAN */
 
+u64 dma_direct_get_required_mask(struct device *dev);
 void *dma_direct_alloc(struct device *dev, size_t size, dma_addr_t *dma_handle,
                 gfp_t gfp, unsigned long attrs);
 void dma_direct_free(struct device *dev, size_t size, void *cpu_addr,
                 dma_addr_t dma_addr, unsigned long attrs);
+void *dma_direct_alloc_pages(struct device *dev, size_t size,
+                dma_addr_t *dma_handle, gfp_t gfp, unsigned long attrs);
+void dma_direct_free_pages(struct device *dev, size_t size, void *cpu_addr,
+                dma_addr_t dma_addr, unsigned long attrs);
 dma_addr_t dma_direct_map_page(struct device *dev, struct page *page,
                 unsigned long offset, size_t size, enum dma_data_direction dir,
                 unsigned long attrs);
diff --git a/include/linux/dma-mapping.h b/include/linux/dma-mapping.h
index 1db6a6b46d0d..15bd41447025 100644
--- a/include/linux/dma-mapping.h
+++ b/include/linux/dma-mapping.h
@@ -130,13 +130,10 @@ struct dma_map_ops {
                         enum dma_data_direction direction);
         int (*mapping_error)(struct device *dev, dma_addr_t dma_addr);
         int (*dma_supported)(struct device *dev, u64 mask);
-#ifdef ARCH_HAS_DMA_GET_REQUIRED_MASK
         u64 (*get_required_mask)(struct device *dev);
-#endif
 };
 
 extern const struct dma_map_ops dma_direct_ops;
-extern const struct dma_map_ops dma_noncoherent_ops;
 extern const struct dma_map_ops dma_virt_ops;
 
 #define DMA_BIT_MASK(n) (((n) == 64) ? ~0ULL : ((1ULL<<(n))-1))
@@ -232,6 +229,7 @@ static inline dma_addr_t dma_map_single_attrs(struct device *dev, void *ptr,
         dma_addr_t addr;
 
         BUG_ON(!valid_dma_direction(dir));
+        debug_dma_map_single(dev, ptr, size);
         addr = ops->map_page(dev, virt_to_page(ptr),
                              offset_in_page(ptr), size,
                              dir, attrs);
@@ -445,7 +443,8 @@ dma_cache_sync(struct device *dev, void *vaddr, size_t size,
 }
 
 extern int dma_common_mmap(struct device *dev, struct vm_area_struct *vma,
-                           void *cpu_addr, dma_addr_t dma_addr, size_t size);
+                void *cpu_addr, dma_addr_t dma_addr, size_t size,
+                unsigned long attrs);
 
 void *dma_common_contiguous_remap(struct page *page, size_t size,
                         unsigned long vm_flags,
@@ -477,14 +476,14 @@ dma_mmap_attrs(struct device *dev, struct vm_area_struct *vma, void *cpu_addr,
         BUG_ON(!ops);
         if (ops->mmap)
                 return ops->mmap(dev, vma, cpu_addr, dma_addr, size, attrs);
-        return dma_common_mmap(dev, vma, cpu_addr, dma_addr, size);
+        return dma_common_mmap(dev, vma, cpu_addr, dma_addr, size, attrs);
 }
 
 #define dma_mmap_coherent(d, v, c, h, s) dma_mmap_attrs(d, v, c, h, s, 0)
 
 int
-dma_common_get_sgtable(struct device *dev, struct sg_table *sgt,
-                       void *cpu_addr, dma_addr_t dma_addr, size_t size);
+dma_common_get_sgtable(struct device *dev, struct sg_table *sgt, void *cpu_addr,
+                dma_addr_t dma_addr, size_t size, unsigned long attrs);
 
 static inline int
 dma_get_sgtable_attrs(struct device *dev, struct sg_table *sgt, void *cpu_addr,
@@ -496,7 +495,8 @@ dma_get_sgtable_attrs(struct device *dev, struct sg_table *sgt, void *cpu_addr,
         if (ops->get_sgtable)
                 return ops->get_sgtable(dev, sgt, cpu_addr, dma_addr, size,
                                         attrs);
-        return dma_common_get_sgtable(dev, sgt, cpu_addr, dma_addr, size);
+        return dma_common_get_sgtable(dev, sgt, cpu_addr, dma_addr, size,
+                        attrs);
 }
 
 #define dma_get_sgtable(d, t, v, h, s) dma_get_sgtable_attrs(d, t, v, h, s, 0)
@@ -558,9 +558,11 @@ static inline void dma_free_attrs(struct device *dev, size_t size,
 }
 
 static inline void *dma_alloc_coherent(struct device *dev, size_t size,
-                dma_addr_t *dma_handle, gfp_t flag)
+                dma_addr_t *dma_handle, gfp_t gfp)
 {
-        return dma_alloc_attrs(dev, size, dma_handle, flag, 0);
+
+        return dma_alloc_attrs(dev, size, dma_handle, gfp,
+                        (gfp & __GFP_NOWARN) ? DMA_ATTR_NO_WARN : 0);
 }
 
 static inline void dma_free_coherent(struct device *dev, size_t size,
@@ -753,18 +755,6 @@ dma_mark_declared_memory_occupied(struct device *dev,
 }
 #endif /* CONFIG_HAVE_GENERIC_DMA_COHERENT */
 
-#ifdef CONFIG_HAS_DMA
-int dma_configure(struct device *dev);
-void dma_deconfigure(struct device *dev);
-#else
-static inline int dma_configure(struct device *dev)
-{
-        return 0;
-}
-
-static inline void dma_deconfigure(struct device *dev) {}
-#endif
-
 /*
  * Managed DMA API
  */
@@ -806,8 +796,12 @@ static inline void dmam_release_declared_memory(struct device *dev)
 static inline void *dma_alloc_wc(struct device *dev, size_t size,
                                  dma_addr_t *dma_addr, gfp_t gfp)
 {
-        return dma_alloc_attrs(dev, size, dma_addr, gfp,
-                               DMA_ATTR_WRITE_COMBINE);
+        unsigned long attrs = DMA_ATTR_NO_WARN;
+
+        if (gfp & __GFP_NOWARN)
+                attrs |= DMA_ATTR_NO_WARN;
+
+        return dma_alloc_attrs(dev, size, dma_addr, gfp, attrs);
 }
 #ifndef dma_alloc_writecombine
 #define dma_alloc_writecombine dma_alloc_wc
diff --git a/include/linux/dma-noncoherent.h b/include/linux/dma-noncoherent.h
index a0aa00cc909d..9051b055beec 100644
--- a/include/linux/dma-noncoherent.h
+++ b/include/linux/dma-noncoherent.h
@@ -4,18 +4,35 @@
 
 #include <linux/dma-mapping.h>
 
+#ifdef CONFIG_ARCH_HAS_DMA_COHERENCE_H
+#include <asm/dma-coherence.h>
+#elif defined(CONFIG_ARCH_HAS_SYNC_DMA_FOR_DEVICE) || \
+        defined(CONFIG_ARCH_HAS_SYNC_DMA_FOR_CPU) || \
+        defined(CONFIG_ARCH_HAS_SYNC_DMA_FOR_CPU_ALL)
+static inline bool dev_is_dma_coherent(struct device *dev)
+{
+        return dev->dma_coherent;
+}
+#else
+static inline bool dev_is_dma_coherent(struct device *dev)
+{
+        return true;
+}
+#endif /* CONFIG_ARCH_HAS_DMA_COHERENCE_H */
+
 void *arch_dma_alloc(struct device *dev, size_t size, dma_addr_t *dma_handle,
                 gfp_t gfp, unsigned long attrs);
 void arch_dma_free(struct device *dev, size_t size, void *cpu_addr,
                 dma_addr_t dma_addr, unsigned long attrs);
+long arch_dma_coherent_to_pfn(struct device *dev, void *cpu_addr,
+                dma_addr_t dma_addr);
 
-#ifdef CONFIG_DMA_NONCOHERENT_MMAP
-int arch_dma_mmap(struct device *dev, struct vm_area_struct *vma,
-                void *cpu_addr, dma_addr_t dma_addr, size_t size,
+#ifdef CONFIG_ARCH_HAS_DMA_MMAP_PGPROT
+pgprot_t arch_dma_mmap_pgprot(struct device *dev, pgprot_t prot,
                 unsigned long attrs);
 #else
-#define arch_dma_mmap NULL
-#endif /* CONFIG_DMA_NONCOHERENT_MMAP */
+# define arch_dma_mmap_pgprot(dev, prot, attrs) pgprot_noncached(prot)
+#endif
 
 #ifdef CONFIG_DMA_NONCOHERENT_CACHE_SYNC
 void arch_dma_cache_sync(struct device *dev, void *vaddr, size_t size,
diff --git a/include/linux/dma/sprd-dma.h b/include/linux/dma/sprd-dma.h
index b0115e340fbc..b42b80e52cc2 100644
--- a/include/linux/dma/sprd-dma.h
+++ b/include/linux/dma/sprd-dma.h
@@ -58,4 +58,73 @@ enum sprd_dma_int_type {
         SPRD_DMA_CFGERR_INT,
 };
 
+/*
+ * struct sprd_dma_linklist - DMA link-list address structure
+ * @virt_addr: link-list virtual address to configure link-list node
+ * @phy_addr: link-list physical address to link DMA transfer
+ *
+ * The Spreadtrum DMA controller supports the link-list mode, that means slaves
+ * can supply several groups configurations (each configuration represents one
+ * DMA transfer) saved in memory, and DMA controller will link these groups
+ * configurations by writing the physical address of each configuration into the
+ * link-list register.
+ *
+ * Just as shown below, the link-list pointer register will be pointed to the
+ * physical address of 'configuration 1', and the 'configuration 1' link-list
+ * pointer will be pointed to 'configuration 2', and so on.
+ * Once trigger the DMA transfer, the DMA controller will load 'configuration
+ * 1' to its registers automatically, after 'configuration 1' transaction is
+ * done, DMA controller will load 'configuration 2' automatically, until all
+ * DMA transactions are done.
+ *
+ * Note: The last link-list pointer should point to the physical address
+ * of 'configuration 1', which can avoid DMA controller loads incorrect
+ * configuration when the last configuration transaction is done.
+ *
+ *     DMA controller                    linklist memory
+ * ======================             -----------------------
+ *|                      |           |    configuration 1    |<---
+ *|   DMA controller     |   ------->|                       |   |
+ *|                      |   |       |                       |   |
+ *|                      |   |       |                       |   |
+ *|                      |   |       |                       |   |
+ *| linklist pointer reg |----   ----|    linklist pointer   |   |
+ * ======================        |    -----------------------    |
+ *                               |                               |
+ *                               |    -----------------------    |
+ *                               |   |    configuration 2    |   |
+ *                               --->|                       |   |
+ *                                   |                       |   |
+ *                                   |                       |   |
+ *                                   |                       |   |
+ *                               ----|    linklist pointer   |   |
+ *                               |    -----------------------    |
+ *                               |                               |
+ *                               |    -----------------------    |
+ *                               |   |    configuration 3    |   |
+ *                               --->|                       |   |
+ *                                   |                       |   |
+ *                                   |           .           |   |
+ *                                               .               |
+ *                                               .               |
+ *                                               .               |
+ *                               |               .               |
+ *                               |    -----------------------    |
+ *                               |   |    configuration n    |   |
+ *                               --->|                       |   |
+ *                                   |                       |   |
+ *                                   |                       |   |
+ *                                   |                       |   |
+ *                                   |    linklist pointer   |----
+ *                                    -----------------------
+ *
+ * To support the link-list mode, DMA slaves should allocate one segment memory
+ * from always-on IRAM or dma coherent memory to store these groups of DMA
+ * configuration, and pass the virtual and physical address to DMA controller.
+ */
+struct sprd_dma_linklist {
+        unsigned long virt_addr;
+        phys_addr_t phy_addr;
+};
+
 #endif
diff --git a/include/linux/dns_resolver.h b/include/linux/dns_resolver.h
index 6ac3cad9aef1..34a744a1bafc 100644
--- a/include/linux/dns_resolver.h
+++ b/include/linux/dns_resolver.h
@@ -24,11 +24,9 @@
 #ifndef _LINUX_DNS_RESOLVER_H
 #define _LINUX_DNS_RESOLVER_H
 
-#ifdef __KERNEL__
+#include <uapi/linux/dns_resolver.h>
 
 extern int dns_query(const char *type, const char *name, size_t namelen,
                      const char *options, char **_result, time64_t *_expiry);
 
-#endif /* KERNEL */
-
 #endif /* _LINUX_DNS_RESOLVER_H */
diff --git a/include/linux/edac.h b/include/linux/edac.h
index bffb97828ed6..1d0c9ea8825d 100644
--- a/include/linux/edac.h
+++ b/include/linux/edac.h
@@ -17,6 +17,7 @@
 #include <linux/completion.h>
 #include <linux/workqueue.h>
 #include <linux/debugfs.h>
+#include <linux/numa.h>
 
 #define EDAC_DEVICE_NAME_LEN    31
 
@@ -451,6 +452,8 @@ struct dimm_info {
         u32 nr_pages;                   /* number of pages on this dimm */
 
         unsigned csrow, cschannel;      /* Points to the old API data */
+
+        u16 smbios_handle;              /* Handle for SMBIOS type 17 */
 };
 
 /**
@@ -670,6 +673,6 @@ struct mem_ctl_info {
 /*
  * Maximum number of memory controllers in the coherent fabric.
  */
-#define EDAC_MAX_MCS    16
+#define EDAC_MAX_MCS    2 * MAX_NUMNODES
 
 #endif
diff --git a/include/linux/efi.h b/include/linux/efi.h
index 401e4b254e30..845174e113ce 100644
--- a/include/linux/efi.h
+++ b/include/linux/efi.h
@@ -672,6 +672,7 @@ void efi_native_runtime_setup(void);
 #define LINUX_EFI_LOADER_ENTRY_GUID             EFI_GUID(0x4a67b082, 0x0a4c, 0x41cf,  0xb6, 0xc7, 0x44, 0x0b, 0x29, 0xbb, 0x8c, 0x4f)
 #define LINUX_EFI_RANDOM_SEED_TABLE_GUID        EFI_GUID(0x1ce1e5bc, 0x7ceb, 0x42f2,  0x81, 0xe5, 0x8a, 0xad, 0xf1, 0x80, 0xf5, 0x7b)
 #define LINUX_EFI_TPM_EVENT_LOG_GUID            EFI_GUID(0xb7799cb0, 0xeca2, 0x4943,  0x96, 0x67, 0x1f, 0xae, 0x07, 0xb7, 0x47, 0xfa)
+#define LINUX_EFI_MEMRESERVE_TABLE_GUID         EFI_GUID(0x888eb0c6, 0x8ede, 0x4ff5,  0xa8, 0xf0, 0x9a, 0xee, 0x5c, 0xb9, 0x77, 0xc2)
 
 typedef struct {
         efi_guid_t guid;
@@ -957,6 +958,7 @@ extern struct efi {
         unsigned long mem_attr_table;   /* memory attributes table */
         unsigned long rng_seed;         /* UEFI firmware random seed */
         unsigned long tpm_log;          /* TPM2 Event Log table */
+        unsigned long mem_reserve;      /* Linux EFI memreserve table */
         efi_get_time_t *get_time;
         efi_set_time_t *set_time;
         efi_get_wakeup_time_t *get_wakeup_time;
@@ -1041,6 +1043,7 @@ extern int __init efi_uart_console_only (void);
 extern u64 efi_mem_desc_end(efi_memory_desc_t *md);
 extern int efi_mem_desc_lookup(u64 phys_addr, efi_memory_desc_t *out_md);
 extern void efi_mem_reserve(phys_addr_t addr, u64 size);
+extern int efi_mem_reserve_persistent(phys_addr_t addr, u64 size);
 extern void efi_initialize_iomem_resources(struct resource *code_resource,
                 struct resource *data_resource, struct resource *bss_resource);
 extern void efi_reserve_boot_services(void);
@@ -1659,7 +1662,55 @@ struct linux_efi_tpm_eventlog {
 
 extern int efi_tpm_eventlog_init(void);
 
+/*
+ * efi_runtime_service() function identifiers.
+ * "NONE" is used by efi_recover_from_page_fault() to check if the page
+ * fault happened while executing an efi runtime service.
+ */
+enum efi_rts_ids {
+        NONE,
+        GET_TIME,
+        SET_TIME,
+        GET_WAKEUP_TIME,
+        SET_WAKEUP_TIME,
+        GET_VARIABLE,
+        GET_NEXT_VARIABLE,
+        SET_VARIABLE,
+        QUERY_VARIABLE_INFO,
+        GET_NEXT_HIGH_MONO_COUNT,
+        RESET_SYSTEM,
+        UPDATE_CAPSULE,
+        QUERY_CAPSULE_CAPS,
+};
+
+/*
+ * efi_runtime_work:    Details of EFI Runtime Service work
+ * @arg<1-5>:           EFI Runtime Service function arguments
+ * @status:             Status of executing EFI Runtime Service
+ * @efi_rts_id:         EFI Runtime Service function identifier
+ * @efi_rts_comp:       Struct used for handling completions
+ */
+struct efi_runtime_work {
+        void *arg1;
+        void *arg2;
+        void *arg3;
+        void *arg4;
+        void *arg5;
+        efi_status_t status;
+        struct work_struct work;
+        enum efi_rts_ids efi_rts_id;
+        struct completion efi_rts_comp;
+};
+
+extern struct efi_runtime_work efi_rts_work;
+
 /* Workqueue to queue EFI Runtime Services */
 extern struct workqueue_struct *efi_rts_wq;
 
+struct linux_efi_memreserve {
+        phys_addr_t     next;
+        phys_addr_t     base;
+        phys_addr_t     size;
+};
+
 #endif /* _LINUX_EFI_H */
diff --git a/include/linux/elevator.h b/include/linux/elevator.h
index a02deea30185..015bb59c0331 100644
--- a/include/linux/elevator.h
+++ b/include/linux/elevator.h
@@ -111,7 +111,7 @@ struct elevator_mq_ops {
         void (*insert_requests)(struct blk_mq_hw_ctx *, struct list_head *, bool);
         struct request *(*dispatch_request)(struct blk_mq_hw_ctx *);
         bool (*has_work)(struct blk_mq_hw_ctx *);
-        void (*completed_request)(struct request *);
+        void (*completed_request)(struct request *, u64);
         void (*started_request)(struct request *);
         void (*requeue_request)(struct request *);
         struct request *(*former_request)(struct request_queue *, struct request *);
diff --git a/include/linux/elfcore-compat.h b/include/linux/elfcore-compat.h
index b5f2efdd05e0..7a37f4ce9fd2 100644
--- a/include/linux/elfcore-compat.h
+++ b/include/linux/elfcore-compat.h
@@ -27,10 +27,10 @@ struct compat_elf_prstatus
         compat_pid_t                    pr_ppid;
         compat_pid_t                    pr_pgrp;
         compat_pid_t                    pr_sid;
-        struct compat_timeval           pr_utime;
-        struct compat_timeval           pr_stime;
-        struct compat_timeval           pr_cutime;
-        struct compat_timeval           pr_cstime;
+        struct old_timeval32            pr_utime;
+        struct old_timeval32            pr_stime;
+        struct old_timeval32            pr_cutime;
+        struct old_timeval32            pr_cstime;
         compat_elf_gregset_t            pr_reg;
 #ifdef CONFIG_BINFMT_ELF_FDPIC
         compat_ulong_t                  pr_exec_fdpic_loadmap;
diff --git a/include/linux/ethtool.h b/include/linux/ethtool.h
index f8a2245b70ac..afd9596ce636 100644
--- a/include/linux/ethtool.h
+++ b/include/linux/ethtool.h
@@ -183,14 +183,6 @@ bool ethtool_convert_link_mode_to_legacy_u32(u32 *legacy_u32,
 
 /**
  * struct ethtool_ops - optional netdev operations
- * @get_settings: DEPRECATED, use %get_link_ksettings/%set_link_ksettings
- *      API. Get various device settings including Ethernet link
- *      settings. The @cmd parameter is expected to have been cleared
- *      before get_settings is called. Returns a negative error code
- *      or zero.
- * @set_settings: DEPRECATED, use %get_link_ksettings/%set_link_ksettings
- *      API. Set various device settings including Ethernet link
- *      settings.  Returns a negative error code or zero.
  * @get_drvinfo: Report driver/device information.  Should only set the
  *      @driver, @version, @fw_version and @bus_info fields.  If not
  *      implemented, the @driver and @bus_info fields will be filled in
@@ -297,19 +289,16 @@ bool ethtool_convert_link_mode_to_legacy_u32(u32 *legacy_u32,
  *      a TX queue has this number, return -EINVAL. If only a RX queue or a TX
  *      queue has this number, ignore the inapplicable fields.
  *      Returns a negative error code or zero.
- * @get_link_ksettings: When defined, takes precedence over the
- *      %get_settings method. Get various device settings
- *      including Ethernet link settings. The %cmd and
- *      %link_mode_masks_nwords fields should be ignored (use
- *      %__ETHTOOL_LINK_MODE_MASK_NBITS instead of the latter), any
- *      change to them will be overwritten by kernel. Returns a
- *      negative error code or zero.
- * @set_link_ksettings: When defined, takes precedence over the
- *      %set_settings method. Set various device settings including
- *      Ethernet link settings. The %cmd and %link_mode_masks_nwords
- *      fields should be ignored (use %__ETHTOOL_LINK_MODE_MASK_NBITS
- *      instead of the latter), any change to them will be overwritten
- *      by kernel. Returns a negative error code or zero.
+ * @get_link_ksettings: Get various device settings including Ethernet link
+ *      settings. The %cmd and %link_mode_masks_nwords fields should be
+ *      ignored (use %__ETHTOOL_LINK_MODE_MASK_NBITS instead of the latter),
+ *      any change to them will be overwritten by kernel. Returns a negative
+ *      error code or zero.
+ * @set_link_ksettings: Set various device settings including Ethernet link
+ *      settings. The %cmd and %link_mode_masks_nwords fields should be
+ *      ignored (use %__ETHTOOL_LINK_MODE_MASK_NBITS instead of the latter),
+ *      any change to them will be overwritten by kernel. Returns a negative
+ *      error code or zero.
  * @get_fecparam: Get the network device Forward Error Correction parameters.
  * @set_fecparam: Set the network device Forward Error Correction parameters.
  * @get_ethtool_phy_stats: Return extended statistics about the PHY device.
@@ -329,8 +318,6 @@ bool ethtool_convert_link_mode_to_legacy_u32(u32 *legacy_u32,
  * of the generic netdev features interface.
  */
 struct ethtool_ops {
-        int     (*get_settings)(struct net_device *, struct ethtool_cmd *);
-        int     (*set_settings)(struct net_device *, struct ethtool_cmd *);
         void    (*get_drvinfo)(struct net_device *, struct ethtool_drvinfo *);
         int     (*get_regs_len)(struct net_device *);
         void    (*get_regs)(struct net_device *, struct ethtool_regs *, void *);
diff --git a/include/linux/f2fs_fs.h b/include/linux/f2fs_fs.h
index f70f8ac9c4f4..d7711048ef93 100644
--- a/include/linux/f2fs_fs.h
+++ b/include/linux/f2fs_fs.h
@@ -1,12 +1,9 @@
+// SPDX-License-Identifier: GPL-2.0
 /**
  * include/linux/f2fs_fs.h
  *
  * Copyright (c) 2012 Samsung Electronics Co., Ltd.
  *             http://www.samsung.com/
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
  */
 #ifndef _LINUX_F2FS_FS_H
 #define _LINUX_F2FS_FS_H
@@ -112,12 +109,15 @@ struct f2fs_super_block {
         struct f2fs_device devs[MAX_DEVICES];   /* device list */
         __le32 qf_ino[F2FS_MAX_QUOTAS]; /* quota inode numbers */
         __u8 hot_ext_count;             /* # of hot file extension */
-        __u8 reserved[314];             /* valid reserved region */
+        __u8 reserved[310];             /* valid reserved region */
+        __le32 crc;                     /* checksum of superblock */
 } __packed;
 
 /*
  * For checkpoint
  */
+#define CP_DISABLED_FLAG                0x00001000
+#define CP_QUOTA_NEED_FSCK_FLAG         0x00000800
 #define CP_LARGE_NAT_BITMAP_FLAG        0x00000400
 #define CP_NOCRC_RECOVERY_FLAG  0x00000200
 #define CP_TRIMMED_FLAG         0x00000100
diff --git a/include/linux/fanotify.h b/include/linux/fanotify.h
index 096c96f4f16a..a5a60691e48b 100644
--- a/include/linux/fanotify.h
+++ b/include/linux/fanotify.h
@@ -4,6 +4,61 @@
 
 #include <uapi/linux/fanotify.h>
 
-/* not valid from userspace, only kernel internal */
-#define FAN_MARK_ONDIR          0x00000100
+#define FAN_GROUP_FLAG(group, flag) \
+        ((group)->fanotify_data.flags & (flag))
+
+/*
+ * Flags allowed to be passed from/to userspace.
+ *
+ * We intentionally do not add new bits to the old FAN_ALL_* constants, because
+ * they are uapi exposed constants. If there are programs out there using
+ * these constant, the programs may break if re-compiled with new uapi headers
+ * and then run on an old kernel.
+ */
+#define FANOTIFY_CLASS_BITS     (FAN_CLASS_NOTIF | FAN_CLASS_CONTENT | \
+                                 FAN_CLASS_PRE_CONTENT)
+
+#define FANOTIFY_INIT_FLAGS     (FANOTIFY_CLASS_BITS | \
+                                 FAN_REPORT_TID | \
+                                 FAN_CLOEXEC | FAN_NONBLOCK | \
+                                 FAN_UNLIMITED_QUEUE | FAN_UNLIMITED_MARKS)
+
+#define FANOTIFY_MARK_TYPE_BITS (FAN_MARK_INODE | FAN_MARK_MOUNT | \
+                                 FAN_MARK_FILESYSTEM)
+
+#define FANOTIFY_MARK_FLAGS     (FANOTIFY_MARK_TYPE_BITS | \
+                                 FAN_MARK_ADD | \
+                                 FAN_MARK_REMOVE | \
+                                 FAN_MARK_DONT_FOLLOW | \
+                                 FAN_MARK_ONLYDIR | \
+                                 FAN_MARK_IGNORED_MASK | \
+                                 FAN_MARK_IGNORED_SURV_MODIFY | \
+                                 FAN_MARK_FLUSH)
+
+/* Events that user can request to be notified on */
+#define FANOTIFY_EVENTS         (FAN_ACCESS | FAN_MODIFY | \
+                                 FAN_CLOSE | FAN_OPEN)
+
+/* Events that require a permission response from user */
+#define FANOTIFY_PERM_EVENTS    (FAN_OPEN_PERM | FAN_ACCESS_PERM)
+
+/* Extra flags that may be reported with event or control handling of events */
+#define FANOTIFY_EVENT_FLAGS    (FAN_EVENT_ON_CHILD | FAN_ONDIR)
+
+/* Events that may be reported to user */
+#define FANOTIFY_OUTGOING_EVENTS        (FANOTIFY_EVENTS | \
+                                         FANOTIFY_PERM_EVENTS | \
+                                         FAN_Q_OVERFLOW)
+
+#define ALL_FANOTIFY_EVENT_BITS         (FANOTIFY_OUTGOING_EVENTS | \
+                                         FANOTIFY_EVENT_FLAGS)
+
+/* Do not use these old uapi constants internally */
+#undef FAN_ALL_CLASS_BITS
+#undef FAN_ALL_INIT_FLAGS
+#undef FAN_ALL_MARK_FLAGS
+#undef FAN_ALL_EVENTS
+#undef FAN_ALL_PERM_EVENTS
+#undef FAN_ALL_OUTGOING_EVENTS
+
 #endif /* _LINUX_FANOTIFY_H */
diff --git a/include/linux/fb.h b/include/linux/fb.h
index 3e7e75383d32..a3cab6dc9b44 100644
--- a/include/linux/fb.h
+++ b/include/linux/fb.h
@@ -456,10 +456,13 @@ struct fb_tile_ops {
  * and host endianness. Drivers should not use this flag.
  */
 #define FBINFO_BE_MATH  0x100000
+/*
+ * Hide smem_start in the FBIOGET_FSCREENINFO IOCTL. This is used by modern DRM
+ * drivers to stop userspace from trying to share buffers behind the kernel's
+ * back. Instead dma-buf based buffer sharing should be used.
+ */
+#define FBINFO_HIDE_SMEM_START  0x200000
 
-/* report to the VT layer that this fb driver can accept forced console
-   output like oopses */
-#define FBINFO_CAN_FORCE_OUTPUT     0x200000
 
 struct fb_info {
         atomic_t count;
@@ -632,6 +635,8 @@ extern ssize_t fb_sys_write(struct fb_info *info, const char __user *buf,
 extern int register_framebuffer(struct fb_info *fb_info);
 extern int unregister_framebuffer(struct fb_info *fb_info);
 extern int unlink_framebuffer(struct fb_info *fb_info);
+extern int remove_conflicting_pci_framebuffers(struct pci_dev *pdev, int res_id,
+                                               const char *name);
 extern int remove_conflicting_framebuffers(struct apertures_struct *a,
                                            const char *name, bool primary);
 extern int fb_prepare_logo(struct fb_info *fb_info, int rotate);
diff --git a/include/linux/filter.h b/include/linux/filter.h
index 6791a0ac0139..de629b706d1d 100644
--- a/include/linux/filter.h
+++ b/include/linux/filter.h
@@ -520,24 +520,6 @@ struct bpf_skb_data_end {
         void *data_end;
 };
 
-struct sk_msg_buff {
-        void *data;
-        void *data_end;
-        __u32 apply_bytes;
-        __u32 cork_bytes;
-        int sg_copybreak;
-        int sg_start;
-        int sg_curr;
-        int sg_end;
-        struct scatterlist sg_data[MAX_SKB_FRAGS];
-        bool sg_copy[MAX_SKB_FRAGS];
-        __u32 flags;
-        struct sock *sk_redir;
-        struct sock *sk;
-        struct sk_buff *skb;
-        struct list_head list;
-};
-
 struct bpf_redirect_info {
         u32 ifindex;
         u32 flags;
@@ -566,6 +548,27 @@ static inline void bpf_compute_data_pointers(struct sk_buff *skb)
         cb->data_end  = skb->data + skb_headlen(skb);
 }
 
+/* Similar to bpf_compute_data_pointers(), except that save orginal
+ * data in cb->data and cb->meta_data for restore.
+ */
+static inline void bpf_compute_and_save_data_end(
+        struct sk_buff *skb, void **saved_data_end)
+{
+        struct bpf_skb_data_end *cb = (struct bpf_skb_data_end *)skb->cb;
+
+        *saved_data_end = cb->data_end;
+        cb->data_end  = skb->data + skb_headlen(skb);
+}
+
+/* Restore data saved by bpf_compute_data_pointers(). */
+static inline void bpf_restore_data_end(
+        struct sk_buff *skb, void *saved_data_end)
+{
+        struct bpf_skb_data_end *cb = (struct bpf_skb_data_end *)skb->cb;
+
+        cb->data_end = saved_data_end;
+}
+
 static inline u8 *bpf_skb_cb(struct sk_buff *skb)
 {
         /* eBPF programs may read/write skb->cb[] area to transfer meta
@@ -833,9 +836,6 @@ void xdp_do_flush_map(void);
 
 void bpf_warn_invalid_xdp_action(u32 act);
 
-struct sock *do_sk_redirect_map(struct sk_buff *skb);
-struct sock *do_msg_redirect_map(struct sk_msg_buff *md);
-
 #ifdef CONFIG_INET
 struct sock *bpf_run_sk_reuseport(struct sock_reuseport *reuse, struct sock *sk,
                                   struct bpf_prog *prog, struct sk_buff *skb,
@@ -854,6 +854,7 @@ bpf_run_sk_reuseport(struct sock_reuseport *reuse, struct sock *sk,
 extern int bpf_jit_enable;
 extern int bpf_jit_harden;
 extern int bpf_jit_kallsyms;
+extern int bpf_jit_limit;
 
 typedef void (*bpf_jit_fill_hole_t)(void *area, unsigned int size);
 
diff --git a/include/linux/fpga/fpga-bridge.h b/include/linux/fpga/fpga-bridge.h
index ce550fcf6360..817600a32c93 100644
--- a/include/linux/fpga/fpga-bridge.h
+++ b/include/linux/fpga/fpga-bridge.h
@@ -69,4 +69,8 @@ void fpga_bridge_free(struct fpga_bridge *br);
 int fpga_bridge_register(struct fpga_bridge *br);
 void fpga_bridge_unregister(struct fpga_bridge *br);
 
+struct fpga_bridge
+*devm_fpga_bridge_create(struct device *dev, const char *name,
+                         const struct fpga_bridge_ops *br_ops, void *priv);
+
 #endif /* _LINUX_FPGA_BRIDGE_H */
diff --git a/include/linux/fpga/fpga-mgr.h b/include/linux/fpga/fpga-mgr.h
index 8942e61f0028..e8ca62b2cb5b 100644
--- a/include/linux/fpga/fpga-mgr.h
+++ b/include/linux/fpga/fpga-mgr.h
@@ -53,12 +53,20 @@ enum fpga_mgr_states {
         FPGA_MGR_STATE_OPERATING,
 };
 
-/*
- * FPGA Manager flags
- * FPGA_MGR_PARTIAL_RECONFIG: do partial reconfiguration if supported
- * FPGA_MGR_EXTERNAL_CONFIG: FPGA has been configured prior to Linux booting
- * FPGA_MGR_BITSTREAM_LSB_FIRST: SPI bitstream bit order is LSB first
- * FPGA_MGR_COMPRESSED_BITSTREAM: FPGA bitstream is compressed
+/**
+ * DOC: FPGA Manager flags
+ *
+ * Flags used in the &fpga_image_info->flags field
+ *
+ * %FPGA_MGR_PARTIAL_RECONFIG: do partial reconfiguration if supported
+ *
+ * %FPGA_MGR_EXTERNAL_CONFIG: FPGA has been configured prior to Linux booting
+ *
+ * %FPGA_MGR_ENCRYPTED_BITSTREAM: indicates bitstream is encrypted
+ *
+ * %FPGA_MGR_BITSTREAM_LSB_FIRST: SPI bitstream bit order is LSB first
+ *
+ * %FPGA_MGR_COMPRESSED_BITSTREAM: FPGA bitstream is compressed
  */
 #define FPGA_MGR_PARTIAL_RECONFIG       BIT(0)
 #define FPGA_MGR_EXTERNAL_CONFIG        BIT(1)
@@ -190,4 +198,8 @@ void fpga_mgr_free(struct fpga_manager *mgr);
 int fpga_mgr_register(struct fpga_manager *mgr);
 void fpga_mgr_unregister(struct fpga_manager *mgr);
 
+struct fpga_manager *devm_fpga_mgr_create(struct device *dev, const char *name,
+                                          const struct fpga_manager_ops *mops,
+                                          void *priv);
+
 #endif /*_LINUX_FPGA_MGR_H */
diff --git a/include/linux/fpga/fpga-region.h b/include/linux/fpga/fpga-region.h
index 0521b7f577a4..27cb706275db 100644
--- a/include/linux/fpga/fpga-region.h
+++ b/include/linux/fpga/fpga-region.h
@@ -44,4 +44,8 @@ void fpga_region_free(struct fpga_region *region);
 int fpga_region_register(struct fpga_region *region);
 void fpga_region_unregister(struct fpga_region *region);
 
+struct fpga_region
+*devm_fpga_region_create(struct device *dev, struct fpga_manager *mgr,
+                        int (*get_bridges)(struct fpga_region *));
+
 #endif /* _FPGA_REGION_H */
diff --git a/include/linux/fs.h b/include/linux/fs.h
index 33322702c910..8252df30b9a1 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -403,24 +403,40 @@ int pagecache_write_end(struct file *, struct address_space *mapping,
                                 loff_t pos, unsigned len, unsigned copied,
                                 struct page *page, void *fsdata);
 
+/**
+ * struct address_space - Contents of a cacheable, mappable object.
+ * @host: Owner, either the inode or the block_device.
+ * @i_pages: Cached pages.
+ * @gfp_mask: Memory allocation flags to use for allocating pages.
+ * @i_mmap_writable: Number of VM_SHARED mappings.
+ * @i_mmap: Tree of private and shared mappings.
+ * @i_mmap_rwsem: Protects @i_mmap and @i_mmap_writable.
+ * @nrpages: Number of page entries, protected by the i_pages lock.
+ * @nrexceptional: Shadow or DAX entries, protected by the i_pages lock.
+ * @writeback_index: Writeback starts here.
+ * @a_ops: Methods.
+ * @flags: Error bits and flags (AS_*).
+ * @wb_err: The most recent error which has occurred.
+ * @private_lock: For use by the owner of the address_space.
+ * @private_list: For use by the owner of the address_space.
+ * @private_data: For use by the owner of the address_space.
+ */
 struct address_space {
-        struct inode            *host;          /* owner: inode, block_device */
-        struct radix_tree_root  i_pages;        /* cached pages */
-        atomic_t                i_mmap_writable;/* count VM_SHARED mappings */
-        struct rb_root_cached   i_mmap;         /* tree of private and shared mappings */
-        struct rw_semaphore     i_mmap_rwsem;   /* protect tree, count, list */
-        /* Protected by the i_pages lock */
-        unsigned long           nrpages;        /* number of total pages */
-        /* number of shadow or DAX exceptional entries */
+        struct inode            *host;
+        struct xarray           i_pages;
+        gfp_t                   gfp_mask;
+        atomic_t                i_mmap_writable;
+        struct rb_root_cached   i_mmap;
+        struct rw_semaphore     i_mmap_rwsem;
+        unsigned long           nrpages;
         unsigned long           nrexceptional;
-        pgoff_t                 writeback_index;/* writeback starts here */
-        const struct address_space_operations *a_ops;   /* methods */
-        unsigned long           flags;          /* error bits */
-        spinlock_t              private_lock;   /* for use by the address_space */
-        gfp_t                   gfp_mask;       /* implicit gfp mask for allocations */
-        struct list_head        private_list;   /* for use by the address_space */
-        void                    *private_data;  /* ditto */
+        pgoff_t                 writeback_index;
+        const struct address_space_operations *a_ops;
+        unsigned long           flags;
         errseq_t                wb_err;
+        spinlock_t              private_lock;
+        struct list_head        private_list;
+        void                    *private_data;
 } __attribute__((aligned(sizeof(long)))) __randomize_layout;
         /*
          * On most architectures that alignment is already the case; but
@@ -467,15 +483,18 @@ struct block_device {
         struct mutex            bd_fsfreeze_mutex;
 } __randomize_layout;
 
+/* XArray tags, for tagging dirty and writeback pages in the pagecache. */
+#define PAGECACHE_TAG_DIRTY     XA_MARK_0
+#define PAGECACHE_TAG_WRITEBACK XA_MARK_1
+#define PAGECACHE_TAG_TOWRITE   XA_MARK_2
+
 /*
- * Radix-tree tags, for tagging dirty and writeback pages within the pagecache
- * radix trees
+ * Returns true if any of the pages in the mapping are marked with the tag.
  */
-#define PAGECACHE_TAG_DIRTY     0
-#define PAGECACHE_TAG_WRITEBACK 1
-#define PAGECACHE_TAG_TOWRITE   2
-
-int mapping_tagged(struct address_space *mapping, int tag);
+static inline bool mapping_tagged(struct address_space *mapping, xa_mark_t tag)
+{
+        return xa_marked(&mapping->i_pages, tag);
+}
 
 static inline void i_mmap_lock_write(struct address_space *mapping)
 {
@@ -1393,17 +1412,26 @@ struct super_block {
 
         struct sb_writers       s_writers;
 
+        /*
+         * Keep s_fs_info, s_time_gran, s_fsnotify_mask, and
+         * s_fsnotify_marks together for cache efficiency. They are frequently
+         * accessed and rarely modified.
+         */
+        void                    *s_fs_info;     /* Filesystem private info */
+
+        /* Granularity of c/m/atime in ns (cannot be worse than a second) */
+        u32                     s_time_gran;
+#ifdef CONFIG_FSNOTIFY
+        __u32                   s_fsnotify_mask;
+        struct fsnotify_mark_connector __rcu    *s_fsnotify_marks;
+#endif
+
         char                    s_id[32];       /* Informational name */
         uuid_t                  s_uuid;         /* UUID */
 
-        void                    *s_fs_info;     /* Filesystem private info */
         unsigned int            s_max_links;
         fmode_t                 s_mode;
 
-        /* Granularity of c/m/atime in ns.
-           Cannot be worse than a second */
-        u32                s_time_gran;
-
         /*
          * The next field is for VFS *only*. No filesystems have any business
          * even looking at it. You had been warned.
@@ -1428,6 +1456,9 @@ struct super_block {
         /* Number of inodes with nlink == 0 but still referenced */
         atomic_long_t s_remove_count;
 
+        /* Pending fsnotify inode refs */
+        atomic_long_t s_fsnotify_inode_refs;
+
         /* Being remounted read-only */
         int s_readonly_remount;
 
@@ -1763,6 +1794,7 @@ struct file_operations {
                         u64);
         int (*dedupe_file_range)(struct file *, loff_t, struct file *, loff_t,
                         u64);
+        int (*fadvise)(struct file *, loff_t, loff_t, int);
 } __randomize_layout;
 
 struct inode_operations {
@@ -1827,8 +1859,10 @@ extern ssize_t vfs_copy_file_range(struct file *, loff_t , struct file *,
 extern int vfs_clone_file_prep_inodes(struct inode *inode_in, loff_t pos_in,
                                       struct inode *inode_out, loff_t pos_out,
                                       u64 *len, bool is_dedupe);
+extern int do_clone_file_range(struct file *file_in, loff_t pos_in,
+                               struct file *file_out, loff_t pos_out, u64 len);
 extern int vfs_clone_file_range(struct file *file_in, loff_t pos_in,
-                struct file *file_out, loff_t pos_out, u64 len);
+                                struct file *file_out, loff_t pos_out, u64 len);
 extern int vfs_dedupe_file_range_compare(struct inode *src, loff_t srcoff,
                                          struct inode *dest, loff_t destoff,
                                          loff_t len, bool *is_same);
@@ -2772,19 +2806,6 @@ static inline void file_end_write(struct file *file)
         __sb_end_write(file_inode(file)->i_sb, SB_FREEZE_WRITE);
 }
 
-static inline int do_clone_file_range(struct file *file_in, loff_t pos_in,
-                                      struct file *file_out, loff_t pos_out,
-                                      u64 len)
-{
-        int ret;
-
-        file_start_write(file_out);
-        ret = vfs_clone_file_range(file_in, pos_in, file_out, pos_out, len);
-        file_end_write(file_out);
-
-        return ret;
-}
-
 /*
  * get_write_access() gets write permission for a file.
  * put_write_access() releases this write permission.
@@ -3459,4 +3480,8 @@ static inline bool dir_relax_shared(struct inode *inode)
 extern bool path_noexec(const struct path *path);
 extern void inode_nohighmem(struct inode *inode);
 
+/* mm/fadvise.c */
+extern int vfs_fadvise(struct file *file, loff_t offset, loff_t len,
+                       int advice);
+
 #endif /* _LINUX_FS_H */
diff --git a/include/linux/fsl/mc.h b/include/linux/fsl/mc.h
index f27cb14088a4..9d3f668df7df 100644
--- a/include/linux/fsl/mc.h
+++ b/include/linux/fsl/mc.h
@@ -351,6 +351,14 @@ int mc_send_command(struct fsl_mc_io *mc_io, struct fsl_mc_command *cmd);
 #define dev_is_fsl_mc(_dev) (0)
 #endif
 
+/* Macro to check if a device is a container device */
+#define fsl_mc_is_cont_dev(_dev) (to_fsl_mc_device(_dev)->flags & \
+        FSL_MC_IS_DPRC)
+
+/* Macro to get the container device of a MC device */
+#define fsl_mc_cont_dev(_dev) (fsl_mc_is_cont_dev(_dev) ? \
+        (_dev) : (_dev)->parent)
+
 /*
  * module_fsl_mc_driver() - Helper macro for drivers that don't do
  * anything special in module init/exit.  This eliminates a lot of
@@ -405,6 +413,7 @@ extern struct device_type fsl_mc_bus_dpcon_type;
 extern struct device_type fsl_mc_bus_dpmcp_type;
 extern struct device_type fsl_mc_bus_dpmac_type;
 extern struct device_type fsl_mc_bus_dprtc_type;
+extern struct device_type fsl_mc_bus_dpseci_type;
 
 static inline bool is_fsl_mc_bus_dprc(const struct fsl_mc_device *mc_dev)
 {
@@ -451,6 +460,11 @@ static inline bool is_fsl_mc_bus_dprtc(const struct fsl_mc_device *mc_dev)
         return mc_dev->dev.type == &fsl_mc_bus_dprtc_type;
 }
 
+static inline bool is_fsl_mc_bus_dpseci(const struct fsl_mc_device *mc_dev)
+{
+        return mc_dev->dev.type == &fsl_mc_bus_dpseci_type;
+}
+
 /*
  * Data Path Buffer Pool (DPBP) API
  * Contains initialization APIs and runtime control APIs for DPBP
diff --git a/include/linux/fsl_ifc.h b/include/linux/fsl_ifc.h
index 3fdfede2f0f3..5f343b796ad9 100644
--- a/include/linux/fsl_ifc.h
+++ b/include/linux/fsl_ifc.h
@@ -274,6 +274,8 @@
  */
 /* Auto Boot Mode */
 #define IFC_NAND_NCFGR_BOOT             0x80000000
+/* SRAM Initialization */
+#define IFC_NAND_NCFGR_SRAM_INIT_EN     0x20000000
 /* Addressing Mode-ROW0+n/COL0 */
 #define IFC_NAND_NCFGR_ADDR_MODE_RC0    0x00000000
 /* Addressing Mode-ROW0+n/COL0+n */
diff --git a/include/linux/fsnotify_backend.h b/include/linux/fsnotify_backend.h
index b8f4182f42f1..135b973e44d1 100644
--- a/include/linux/fsnotify_backend.h
+++ b/include/linux/fsnotify_backend.h
@@ -68,15 +68,20 @@
 
 #define ALL_FSNOTIFY_PERM_EVENTS (FS_OPEN_PERM | FS_ACCESS_PERM)
 
+/* Events that can be reported to backends */
 #define ALL_FSNOTIFY_EVENTS (FS_ACCESS | FS_MODIFY | FS_ATTRIB | \
                              FS_CLOSE_WRITE | FS_CLOSE_NOWRITE | FS_OPEN | \
                              FS_MOVED_FROM | FS_MOVED_TO | FS_CREATE | \
                              FS_DELETE | FS_DELETE_SELF | FS_MOVE_SELF | \
                              FS_UNMOUNT | FS_Q_OVERFLOW | FS_IN_IGNORED | \
-                             FS_OPEN_PERM | FS_ACCESS_PERM | FS_EXCL_UNLINK | \
-                             FS_ISDIR | FS_IN_ONESHOT | FS_DN_RENAME | \
+                             FS_OPEN_PERM | FS_ACCESS_PERM | FS_DN_RENAME)
+
+/* Extra flags that may be reported with event or control handling of events */
+#define ALL_FSNOTIFY_FLAGS  (FS_EXCL_UNLINK | FS_ISDIR | FS_IN_ONESHOT | \
                              FS_DN_MULTISHOT | FS_EVENT_ON_CHILD)
 
+#define ALL_FSNOTIFY_BITS   (ALL_FSNOTIFY_EVENTS | ALL_FSNOTIFY_FLAGS)
+
 struct fsnotify_group;
 struct fsnotify_event;
 struct fsnotify_mark;
@@ -189,10 +194,10 @@ struct fsnotify_group {
                         /* allows a group to block waiting for a userspace response */
                         struct list_head access_list;
                         wait_queue_head_t access_waitq;
-                        int f_flags;
+                        int flags;           /* flags from fanotify_init() */
+                        int f_flags; /* event_f_flags from fanotify_init() */
                         unsigned int max_marks;
                         struct user_struct *user;
-                        bool audit;
                 } fanotify_data;
 #endif /* CONFIG_FANOTIFY */
         };
@@ -206,12 +211,14 @@ struct fsnotify_group {
 enum fsnotify_obj_type {
         FSNOTIFY_OBJ_TYPE_INODE,
         FSNOTIFY_OBJ_TYPE_VFSMOUNT,
+        FSNOTIFY_OBJ_TYPE_SB,
         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_TYPE_SB_FL         (1U << FSNOTIFY_OBJ_TYPE_SB)
 #define FSNOTIFY_OBJ_ALL_TYPES_MASK     ((1U << FSNOTIFY_OBJ_TYPE_COUNT) - 1)
 
 static inline bool fsnotify_valid_obj_type(unsigned int type)
@@ -255,6 +262,7 @@ static inline struct fsnotify_mark *fsnotify_iter_##name##_mark( \
 
 FSNOTIFY_ITER_FUNCS(inode, INODE)
 FSNOTIFY_ITER_FUNCS(vfsmount, VFSMOUNT)
+FSNOTIFY_ITER_FUNCS(sb, SB)
 
 #define fsnotify_foreach_obj_type(type) \
         for (type = 0; type < FSNOTIFY_OBJ_TYPE_COUNT; type++)
@@ -267,8 +275,8 @@ struct fsnotify_mark_connector;
 typedef struct fsnotify_mark_connector __rcu *fsnotify_connp_t;
 
 /*
- * Inode / vfsmount point to this structure which tracks all marks attached to
- * the inode / vfsmount. The reference to inode / vfsmount is held by this
+ * Inode/vfsmount/sb point to this structure which tracks all marks attached to
+ * the inode/vfsmount/sb. The reference to inode/vfsmount/sb is held by this
  * structure. We destroy this structure when there are no more marks attached
  * to it. The structure is protected by fsnotify_mark_srcu.
  */
@@ -335,6 +343,7 @@ extern int fsnotify(struct inode *to_tell, __u32 mask, const void *data, int dat
 extern int __fsnotify_parent(const struct path *path, struct dentry *dentry, __u32 mask);
 extern void __fsnotify_inode_delete(struct inode *inode);
 extern void __fsnotify_vfsmount_delete(struct vfsmount *mnt);
+extern void fsnotify_sb_delete(struct super_block *sb);
 extern u32 fsnotify_get_cookie(void);
 
 static inline int fsnotify_inode_watches_children(struct inode *inode)
@@ -455,9 +464,13 @@ static inline void fsnotify_clear_inode_marks_by_group(struct fsnotify_group *gr
 {
         fsnotify_clear_marks_by_group(group, FSNOTIFY_OBJ_TYPE_INODE_FL);
 }
+/* run all the marks in a group, and clear all of the sn marks */
+static inline void fsnotify_clear_sb_marks_by_group(struct fsnotify_group *group)
+{
+        fsnotify_clear_marks_by_group(group, FSNOTIFY_OBJ_TYPE_SB_FL);
+}
 extern void fsnotify_get_mark(struct fsnotify_mark *mark);
 extern void fsnotify_put_mark(struct fsnotify_mark *mark);
-extern void fsnotify_unmount_inodes(struct super_block *sb);
 extern void fsnotify_finish_user_wait(struct fsnotify_iter_info *iter_info);
 extern bool fsnotify_prepare_user_wait(struct fsnotify_iter_info *iter_info);
 
@@ -484,6 +497,9 @@ static inline void __fsnotify_inode_delete(struct inode *inode)
 static inline void __fsnotify_vfsmount_delete(struct vfsmount *mnt)
 {}
 
+static inline void fsnotify_sb_delete(struct super_block *sb)
+{}
+
 static inline void fsnotify_update_flags(struct dentry *dentry)
 {}
 
diff --git a/include/linux/genhd.h b/include/linux/genhd.h
index 57864422a2c8..70fc838e6773 100644
--- a/include/linux/genhd.h
+++ b/include/linux/genhd.h
@@ -83,10 +83,10 @@ struct partition {
 } __attribute__((packed));
 
 struct disk_stats {
+        u64 nsecs[NR_STAT_GROUPS];
         unsigned long sectors[NR_STAT_GROUPS];
         unsigned long ios[NR_STAT_GROUPS];
         unsigned long merges[NR_STAT_GROUPS];
-        unsigned long ticks[NR_STAT_GROUPS];
         unsigned long io_ticks;
         unsigned long time_in_queue;
 };
@@ -354,6 +354,9 @@ static inline void free_part_stats(struct hd_struct *part)
 
 #endif /* CONFIG_SMP */
 
+#define part_stat_read_msecs(part, which)                               \
+        div_u64(part_stat_read(part, nsecs[which]), NSEC_PER_MSEC)
+
 #define part_stat_read_accum(part, field)                               \
         (part_stat_read(part, field[STAT_READ]) +                       \
          part_stat_read(part, field[STAT_WRITE]) +                      \
@@ -399,10 +402,11 @@ static inline void free_part_info(struct hd_struct *part)
 extern void part_round_stats(struct request_queue *q, int cpu, struct hd_struct *part);
 
 /* block/genhd.c */
-extern void device_add_disk(struct device *parent, struct gendisk *disk);
+extern void device_add_disk(struct device *parent, struct gendisk *disk,
+                            const struct attribute_group **groups);
 static inline void add_disk(struct gendisk *disk)
 {
-        device_add_disk(NULL, disk);
+        device_add_disk(NULL, disk, NULL);
 }
 extern void device_add_disk_no_queue_reg(struct device *parent, struct gendisk *disk);
 static inline void add_disk_no_queue_reg(struct gendisk *disk)
diff --git a/include/linux/gpio/consumer.h b/include/linux/gpio/consumer.h
index 21ddbe440030..f2f887795d43 100644
--- a/include/linux/gpio/consumer.h
+++ b/include/linux/gpio/consumer.h
@@ -18,10 +18,19 @@ struct device;
 struct gpio_desc;
 
 /**
+ * Opaque descriptor for a structure of GPIO array attributes.  This structure
+ * is attached to struct gpiod_descs obtained from gpiod_get_array() and can be
+ * passed back to get/set array functions in order to activate fast processing
+ * path if applicable.
+ */
+struct gpio_array;
+
+/**
  * Struct containing an array of descriptors that can be obtained using
  * gpiod_get_array().
  */
 struct gpio_descs {
+        struct gpio_array *info;
         unsigned int ndescs;
         struct gpio_desc *desc[];
 };
@@ -30,6 +39,7 @@ struct gpio_descs {
 #define GPIOD_FLAGS_BIT_DIR_OUT         BIT(1)
 #define GPIOD_FLAGS_BIT_DIR_VAL         BIT(2)
 #define GPIOD_FLAGS_BIT_OPEN_DRAIN      BIT(3)
+#define GPIOD_FLAGS_BIT_NONEXCLUSIVE    BIT(4)
 
 /**
  * Optional flags that can be passed to one of gpiod_* to configure direction
@@ -104,36 +114,46 @@ int gpiod_direction_output_raw(struct gpio_desc *desc, int value);
 /* Value get/set from non-sleeping context */
 int gpiod_get_value(const struct gpio_desc *desc);
 int gpiod_get_array_value(unsigned int array_size,
-                          struct gpio_desc **desc_array, int *value_array);
+                          struct gpio_desc **desc_array,
+                          struct gpio_array *array_info,
+                          unsigned long *value_bitmap);
 void gpiod_set_value(struct gpio_desc *desc, int value);
-void gpiod_set_array_value(unsigned int array_size,
-                           struct gpio_desc **desc_array, int *value_array);
+int gpiod_set_array_value(unsigned int array_size,
+                          struct gpio_desc **desc_array,
+                          struct gpio_array *array_info,
+                          unsigned long *value_bitmap);
 int gpiod_get_raw_value(const struct gpio_desc *desc);
 int gpiod_get_raw_array_value(unsigned int array_size,
                               struct gpio_desc **desc_array,
-                              int *value_array);
+                              struct gpio_array *array_info,
+                              unsigned long *value_bitmap);
 void gpiod_set_raw_value(struct gpio_desc *desc, int value);
 int gpiod_set_raw_array_value(unsigned int array_size,
-                               struct gpio_desc **desc_array,
-                               int *value_array);
+                              struct gpio_desc **desc_array,
+                              struct gpio_array *array_info,
+                              unsigned long *value_bitmap);
 
 /* Value get/set from sleeping context */
 int gpiod_get_value_cansleep(const struct gpio_desc *desc);
 int gpiod_get_array_value_cansleep(unsigned int array_size,
                                    struct gpio_desc **desc_array,
-                                   int *value_array);
+                                   struct gpio_array *array_info,
+                                   unsigned long *value_bitmap);
 void gpiod_set_value_cansleep(struct gpio_desc *desc, int value);
-void gpiod_set_array_value_cansleep(unsigned int array_size,
-                                    struct gpio_desc **desc_array,
-                                    int *value_array);
+int gpiod_set_array_value_cansleep(unsigned int array_size,
+                                   struct gpio_desc **desc_array,
+                                   struct gpio_array *array_info,
+                                   unsigned long *value_bitmap);
 int gpiod_get_raw_value_cansleep(const struct gpio_desc *desc);
 int gpiod_get_raw_array_value_cansleep(unsigned int array_size,
                                        struct gpio_desc **desc_array,
-                                       int *value_array);
+                                       struct gpio_array *array_info,
+                                       unsigned long *value_bitmap);
 void gpiod_set_raw_value_cansleep(struct gpio_desc *desc, int value);
 int gpiod_set_raw_array_value_cansleep(unsigned int array_size,
-                                        struct gpio_desc **desc_array,
-                                        int *value_array);
+                                       struct gpio_desc **desc_array,
+                                       struct gpio_array *array_info,
+                                       unsigned long *value_bitmap);
 
 int gpiod_set_debounce(struct gpio_desc *desc, unsigned debounce);
 int gpiod_set_transitory(struct gpio_desc *desc, bool transitory);
@@ -330,7 +350,8 @@ static inline int gpiod_get_value(const struct gpio_desc *desc)
 }
 static inline int gpiod_get_array_value(unsigned int array_size,
                                         struct gpio_desc **desc_array,
-                                        int *value_array)
+                                        struct gpio_array *array_info,
+                                        unsigned long *value_bitmap)
 {
         /* GPIO can never have been requested */
         WARN_ON(1);
@@ -341,12 +362,14 @@ static inline void gpiod_set_value(struct gpio_desc *desc, int value)
         /* GPIO can never have been requested */
         WARN_ON(1);
 }
-static inline void gpiod_set_array_value(unsigned int array_size,
-                                         struct gpio_desc **desc_array,
-                                         int *value_array)
+static inline int gpiod_set_array_value(unsigned int array_size,
+                                        struct gpio_desc **desc_array,
+                                        struct gpio_array *array_info,
+                                        unsigned long *value_bitmap)
 {
         /* GPIO can never have been requested */
         WARN_ON(1);
+        return 0;
 }
 static inline int gpiod_get_raw_value(const struct gpio_desc *desc)
 {
@@ -356,7 +379,8 @@ static inline int gpiod_get_raw_value(const struct gpio_desc *desc)
 }
 static inline int gpiod_get_raw_array_value(unsigned int array_size,
                                             struct gpio_desc **desc_array,
-                                            int *value_array)
+                                            struct gpio_array *array_info,
+                                            unsigned long *value_bitmap)
 {
         /* GPIO can never have been requested */
         WARN_ON(1);
@@ -368,8 +392,9 @@ static inline void gpiod_set_raw_value(struct gpio_desc *desc, int value)
         WARN_ON(1);
 }
 static inline int gpiod_set_raw_array_value(unsigned int array_size,
-                                             struct gpio_desc **desc_array,
-                                             int *value_array)
+                                            struct gpio_desc **desc_array,
+                                            struct gpio_array *array_info,
+                                            unsigned long *value_bitmap)
 {
         /* GPIO can never have been requested */
         WARN_ON(1);
@@ -384,7 +409,8 @@ static inline int gpiod_get_value_cansleep(const struct gpio_desc *desc)
 }
 static inline int gpiod_get_array_value_cansleep(unsigned int array_size,
                                      struct gpio_desc **desc_array,
-                                     int *value_array)
+                                     struct gpio_array *array_info,
+                                     unsigned long *value_bitmap)
 {
         /* GPIO can never have been requested */
         WARN_ON(1);
@@ -395,12 +421,14 @@ static inline void gpiod_set_value_cansleep(struct gpio_desc *desc, int value)
         /* GPIO can never have been requested */
         WARN_ON(1);
 }
-static inline void gpiod_set_array_value_cansleep(unsigned int array_size,
+static inline int gpiod_set_array_value_cansleep(unsigned int array_size,
                                             struct gpio_desc **desc_array,
-                                            int *value_array)
+                                            struct gpio_array *array_info,
+                                            unsigned long *value_bitmap)
 {
         /* GPIO can never have been requested */
         WARN_ON(1);
+        return 0;
 }
 static inline int gpiod_get_raw_value_cansleep(const struct gpio_desc *desc)
 {
@@ -410,7 +438,8 @@ static inline int gpiod_get_raw_value_cansleep(const struct gpio_desc *desc)
 }
 static inline int gpiod_get_raw_array_value_cansleep(unsigned int array_size,
                                                struct gpio_desc **desc_array,
-                                               int *value_array)
+                                               struct gpio_array *array_info,
+                                               unsigned long *value_bitmap)
 {
         /* GPIO can never have been requested */
         WARN_ON(1);
@@ -424,7 +453,8 @@ static inline void gpiod_set_raw_value_cansleep(struct gpio_desc *desc,
 }
 static inline int gpiod_set_raw_array_value_cansleep(unsigned int array_size,
                                                 struct gpio_desc **desc_array,
-                                                int *value_array)
+                                                struct gpio_array *array_info,
+                                                unsigned long *value_bitmap)
 {
         /* GPIO can never have been requested */
         WARN_ON(1);
diff --git a/include/linux/gpio/driver.h b/include/linux/gpio/driver.h
index 0ea328e71ec9..2db62b550b95 100644
--- a/include/linux/gpio/driver.h
+++ b/include/linux/gpio/driver.h
@@ -66,9 +66,15 @@ struct gpio_irq_chip {
         /**
          * @lock_key:
          *
-         * Per GPIO IRQ chip lockdep classes.
+         * Per GPIO IRQ chip lockdep class for IRQ lock.
          */
         struct lock_class_key *lock_key;
+
+        /**
+         * @request_key:
+         *
+         * Per GPIO IRQ chip lockdep class for IRQ request.
+         */
         struct lock_class_key *request_key;
 
         /**
@@ -95,6 +101,13 @@ struct gpio_irq_chip {
         unsigned int num_parents;
 
         /**
+         * @parent_irq:
+         *
+         * For use by gpiochip_set_cascaded_irqchip()
+         */
+        unsigned int parent_irq;
+
+        /**
          * @parents:
          *
          * A list of interrupt parents of a GPIO chip. This is owned by the
@@ -138,6 +151,20 @@ struct gpio_irq_chip {
          * will allocate and map all IRQs during initialization.
          */
         unsigned int first;
+
+        /**
+         * @irq_enable:
+         *
+         * Store old irq_chip irq_enable callback
+         */
+        void            (*irq_enable)(struct irq_data *data);
+
+        /**
+         * @irq_disable:
+         *
+         * Store old irq_chip irq_disable callback
+         */
+        void            (*irq_disable)(struct irq_data *data);
 };
 
 static inline struct gpio_irq_chip *to_gpio_irq_chip(struct irq_chip *chip)
@@ -158,9 +185,13 @@ static inline struct gpio_irq_chip *to_gpio_irq_chip(struct irq_chip *chip)
  * @free: optional hook for chip-specific deactivation, such as
  *      disabling module power and clock; may sleep
  * @get_direction: returns direction for signal "offset", 0=out, 1=in,
- *      (same as GPIOF_DIR_XXX), or negative error
+ *      (same as GPIOF_DIR_XXX), or negative error.
+ *      It is recommended to always implement this function, even on
+ *      input-only or output-only gpio chips.
  * @direction_input: configures signal "offset" as input, or returns error
+ *      This can be omitted on input-only or output-only gpio chips.
  * @direction_output: configures signal "offset" as output, or returns error
+ *      This can be omitted on input-only or output-only gpio chips.
  * @get: returns value for signal "offset", 0=low, 1=high, or negative error
  * @get_multiple: reads values for multiple signals defined by "mask" and
  *      stores them in "bits", returns 0 on success or negative error
@@ -256,6 +287,9 @@ struct gpio_chip {
 
         void                    (*dbg_show)(struct seq_file *s,
                                                 struct gpio_chip *chip);
+
+        int                     (*init_valid_mask)(struct gpio_chip *chip);
+
         int                     base;
         u16                     ngpio;
         const char              *const *names;
@@ -294,7 +328,9 @@ struct gpio_chip {
         /**
          * @need_valid_mask:
          *
-         * If set core allocates @valid_mask with all bits set to one.
+         * If set core allocates @valid_mask with all its values initialized
+         * with init_valid_mask() or set to one if init_valid_mask() is not
+         * defined
          */
         bool need_valid_mask;
 
@@ -395,6 +431,10 @@ extern struct gpio_chip *gpiochip_find(void *data,
 int gpiochip_lock_as_irq(struct gpio_chip *chip, unsigned int offset);
 void gpiochip_unlock_as_irq(struct gpio_chip *chip, unsigned int offset);
 bool gpiochip_line_is_irq(struct gpio_chip *chip, unsigned int offset);
+int gpiochip_reqres_irq(struct gpio_chip *chip, unsigned int offset);
+void gpiochip_relres_irq(struct gpio_chip *chip, unsigned int offset);
+void gpiochip_disable_irq(struct gpio_chip *chip, unsigned int offset);
+void gpiochip_enable_irq(struct gpio_chip *chip, unsigned int offset);
 
 /* Line status inquiry for drivers */
 bool gpiochip_line_is_open_drain(struct gpio_chip *chip, unsigned int offset);
diff --git a/include/linux/hdmi.h b/include/linux/hdmi.h
index d271ff23984f..4f3febc0f971 100644
--- a/include/linux/hdmi.h
+++ b/include/linux/hdmi.h
@@ -101,8 +101,8 @@ enum hdmi_extended_colorimetry {
         HDMI_EXTENDED_COLORIMETRY_XV_YCC_601,
         HDMI_EXTENDED_COLORIMETRY_XV_YCC_709,
         HDMI_EXTENDED_COLORIMETRY_S_YCC_601,
-        HDMI_EXTENDED_COLORIMETRY_ADOBE_YCC_601,
-        HDMI_EXTENDED_COLORIMETRY_ADOBE_RGB,
+        HDMI_EXTENDED_COLORIMETRY_OPYCC_601,
+        HDMI_EXTENDED_COLORIMETRY_OPRGB,
 
         /* The following EC values are only defined in CEA-861-F. */
         HDMI_EXTENDED_COLORIMETRY_BT2020_CONST_LUM,
diff --git a/include/linux/hid.h b/include/linux/hid.h
index 834e6461a690..2827b87590d8 100644
--- a/include/linux/hid.h
+++ b/include/linux/hid.h
@@ -526,6 +526,7 @@ struct hid_input {
         const char *name;
         bool registered;
         struct list_head reports;       /* the list of reports */
+        unsigned int application;       /* application usage for this input */
 };
 
 enum hid_type {
@@ -1138,6 +1139,34 @@ static inline u32 hid_report_len(struct hid_report *report)
 int hid_report_raw_event(struct hid_device *hid, int type, u8 *data, u32 size,
                 int interrupt);
 
+
+/**
+ * struct hid_scroll_counter - Utility class for processing high-resolution
+ *                             scroll events.
+ * @dev: the input device for which events should be reported.
+ * @microns_per_hi_res_unit: the amount moved by the user's finger for each
+ *                           high-resolution unit reported by the mouse, in
+ *                           microns.
+ * @resolution_multiplier: the wheel's resolution in high-resolution mode as a
+ *                         multiple of its lower resolution. For example, if
+ *                         moving the wheel by one "notch" would result in a
+ *                         value of 1 in low-resolution mode but 8 in
+ *                         high-resolution, the multiplier is 8.
+ * @remainder: counts the number of high-resolution units moved since the last
+ *             low-resolution event (REL_WHEEL or REL_HWHEEL) was sent. Should
+ *             only be used by class methods.
+ */
+struct hid_scroll_counter {
+        struct input_dev *dev;
+        int microns_per_hi_res_unit;
+        int resolution_multiplier;
+
+        int remainder;
+};
+
+void hid_scroll_counter_handle_scroll(struct hid_scroll_counter *counter,
+                                      int hi_res_value);
+
 /* HID quirks API */
 unsigned long hid_lookup_quirk(const struct hid_device *hdev);
 int hid_quirks_init(char **quirks_param, __u16 bus, int count);
diff --git a/include/linux/hmm.h b/include/linux/hmm.h
index 4c92e3ba3e16..dde947083d4e 100644
--- a/include/linux/hmm.h
+++ b/include/linux/hmm.h
@@ -107,7 +107,7 @@ enum hmm_pfn_flag_e {
  * HMM_PFN_ERROR: corresponding CPU page table entry points to poisoned memory
  * HMM_PFN_NONE: corresponding CPU page table entry is pte_none()
  * HMM_PFN_SPECIAL: corresponding CPU page table entry is special; i.e., the
- *      result of vm_insert_pfn() or vm_insert_page(). Therefore, it should not
+ *      result of vmf_insert_pfn() or vm_insert_page(). Therefore, it should not
  *      be mirrored by a device, because the entry will never have HMM_PFN_VALID
  *      set and the pfn value is undefined.
  *
diff --git a/include/linux/huge_mm.h b/include/linux/huge_mm.h
index 99c19b06d9a4..4663ee96cf59 100644
--- a/include/linux/huge_mm.h
+++ b/include/linux/huge_mm.h
@@ -43,7 +43,7 @@ extern int mincore_huge_pmd(struct vm_area_struct *vma, pmd_t *pmd,
                         unsigned char *vec);
 extern bool move_huge_pmd(struct vm_area_struct *vma, unsigned long old_addr,
                          unsigned long new_addr, unsigned long old_end,
-                         pmd_t *old_pmd, pmd_t *new_pmd, bool *need_flush);
+                         pmd_t *old_pmd, pmd_t *new_pmd);
 extern int change_huge_pmd(struct vm_area_struct *vma, pmd_t *pmd,
                         unsigned long addr, pgprot_t newprot,
                         int prot_numa);
@@ -213,9 +213,9 @@ static inline int hpage_nr_pages(struct page *page)
 }
 
 struct page *follow_devmap_pmd(struct vm_area_struct *vma, unsigned long addr,
-                pmd_t *pmd, int flags);
+                pmd_t *pmd, int flags, struct dev_pagemap **pgmap);
 struct page *follow_devmap_pud(struct vm_area_struct *vma, unsigned long addr,
-                pud_t *pud, int flags);
+                pud_t *pud, int flags, struct dev_pagemap **pgmap);
 
 extern vm_fault_t do_huge_pmd_numa_page(struct vm_fault *vmf, pmd_t orig_pmd);
 
@@ -344,13 +344,13 @@ static inline void mm_put_huge_zero_page(struct mm_struct *mm)
 }
 
 static inline struct page *follow_devmap_pmd(struct vm_area_struct *vma,
-                unsigned long addr, pmd_t *pmd, int flags)
+        unsigned long addr, pmd_t *pmd, int flags, struct dev_pagemap **pgmap)
 {
         return NULL;
 }
 
 static inline struct page *follow_devmap_pud(struct vm_area_struct *vma,
-                unsigned long addr, pud_t *pud, int flags)
+        unsigned long addr, pud_t *pud, int flags, struct dev_pagemap **pgmap)
 {
         return NULL;
 }
diff --git a/include/linux/hugetlb.h b/include/linux/hugetlb.h
index 6b68e345f0ca..087fd5f48c91 100644
--- a/include/linux/hugetlb.h
+++ b/include/linux/hugetlb.h
@@ -140,6 +140,8 @@ pte_t *huge_pte_alloc(struct mm_struct *mm,
 pte_t *huge_pte_offset(struct mm_struct *mm,
                        unsigned long addr, unsigned long sz);
 int huge_pmd_unshare(struct mm_struct *mm, unsigned long *addr, pte_t *ptep);
+void adjust_range_if_pmd_sharing_possible(struct vm_area_struct *vma,
+                                unsigned long *start, unsigned long *end);
 struct page *follow_huge_addr(struct mm_struct *mm, unsigned long address,
                               int write);
 struct page *follow_huge_pd(struct vm_area_struct *vma,
@@ -170,6 +172,18 @@ static inline unsigned long hugetlb_total_pages(void)
         return 0;
 }
 
+static inline int huge_pmd_unshare(struct mm_struct *mm, unsigned long *addr,
+                                        pte_t *ptep)
+{
+        return 0;
+}
+
+static inline void adjust_range_if_pmd_sharing_possible(
+                                struct vm_area_struct *vma,
+                                unsigned long *start, unsigned long *end)
+{
+}
+
 #define follow_hugetlb_page(m,v,p,vs,a,b,i,w,n) ({ BUG(); 0; })
 #define follow_huge_addr(mm, addr, write)       ERR_PTR(-EINVAL)
 #define copy_hugetlb_page_range(src, dst, vma)  ({ BUG(); 0; })
diff --git a/include/linux/hw_random.h b/include/linux/hw_random.h
index bee0827766a3..c0b93e0ff0c0 100644
--- a/include/linux/hw_random.h
+++ b/include/linux/hw_random.h
@@ -33,7 +33,8 @@
  *                      and max is a multiple of 4 and >= 32 bytes.
  * @priv:               Private data, for use by the RNG driver.
  * @quality:            Estimation of true entropy in RNG's bitstream
- *                      (per mill).
+ *                      (in bits of entropy per 1024 bits of input;
+ *                      valid values: 1 to 1024, or 0 for unknown).
  */
 struct hwrng {
         const char *name;
diff --git a/include/linux/hwmon.h b/include/linux/hwmon.h
index 9493d4a388db..99e0c1b0b5fb 100644
--- a/include/linux/hwmon.h
+++ b/include/linux/hwmon.h
@@ -118,6 +118,7 @@ enum hwmon_in_attributes {
         hwmon_in_max_alarm,
         hwmon_in_lcrit_alarm,
         hwmon_in_crit_alarm,
+        hwmon_in_enable,
 };
 
 #define HWMON_I_INPUT           BIT(hwmon_in_input)
@@ -135,6 +136,7 @@ enum hwmon_in_attributes {
 #define HWMON_I_MAX_ALARM       BIT(hwmon_in_max_alarm)
 #define HWMON_I_LCRIT_ALARM     BIT(hwmon_in_lcrit_alarm)
 #define HWMON_I_CRIT_ALARM      BIT(hwmon_in_crit_alarm)
+#define HWMON_I_ENABLE          BIT(hwmon_in_enable)
 
 enum hwmon_curr_attributes {
         hwmon_curr_input,
diff --git a/include/linux/hyperv.h b/include/linux/hyperv.h
index efda23cf32c7..b3e24368930a 100644
--- a/include/linux/hyperv.h
+++ b/include/linux/hyperv.h
@@ -739,8 +739,9 @@ struct vmbus_channel {
         u32 ringbuffer_gpadlhandle;
 
         /* Allocated memory for ring buffer */
-        void *ringbuffer_pages;
+        struct page *ringbuffer_page;
         u32 ringbuffer_pagecount;
+        u32 ringbuffer_send_offset;
         struct hv_ring_buffer_info outbound;    /* send to parent */
         struct hv_ring_buffer_info inbound;     /* receive from parent */
 
@@ -1021,6 +1022,14 @@ struct vmbus_packet_mpb_array {
         struct hv_mpb_array range;
 } __packed;
 
+int vmbus_alloc_ring(struct vmbus_channel *channel,
+                     u32 send_size, u32 recv_size);
+void vmbus_free_ring(struct vmbus_channel *channel);
+
+int vmbus_connect_ring(struct vmbus_channel *channel,
+                       void (*onchannel_callback)(void *context),
+                       void *context);
+int vmbus_disconnect_ring(struct vmbus_channel *channel);
 
 extern int vmbus_open(struct vmbus_channel *channel,
                             u32 send_ringbuffersize,
@@ -1125,6 +1134,7 @@ struct hv_device {
         u16 device_id;
 
         struct device device;
+        char *driver_override; /* Driver name to force a match */
 
         struct vmbus_channel *channel;
         struct kset          *channels_kset;
@@ -1442,7 +1452,7 @@ extern bool vmbus_prep_negotiate_resp(struct icmsg_hdr *icmsghdrp, u8 *buf,
                                 const int *srv_version, int srv_vercnt,
                                 int *nego_fw_version, int *nego_srv_version);
 
-void hv_process_channel_removal(u32 relid);
+void hv_process_channel_removal(struct vmbus_channel *channel);
 
 void vmbus_setevent(struct vmbus_channel *channel);
 /*
diff --git a/include/linux/idr.h b/include/linux/idr.h
index 3ec8628ce17f..60daf34b625d 100644
--- a/include/linux/idr.h
+++ b/include/linux/idr.h
@@ -214,8 +214,7 @@ static inline void idr_preload_end(void)
              ++id, (entry) = idr_get_next((idr), &(id)))
 
 /*
- * IDA - IDR based id allocator, use when translation from id to
- * pointer isn't necessary.
+ * IDA - ID Allocator, use when translation from id to pointer isn't necessary.
  */
 #define IDA_CHUNK_SIZE          128     /* 128 bytes per chunk */
 #define IDA_BITMAP_LONGS        (IDA_CHUNK_SIZE / sizeof(long))
@@ -225,14 +224,14 @@ struct ida_bitmap {
         unsigned long           bitmap[IDA_BITMAP_LONGS];
 };
 
-DECLARE_PER_CPU(struct ida_bitmap *, ida_bitmap);
-
 struct ida {
-        struct radix_tree_root  ida_rt;
+        struct xarray xa;
 };
 
+#define IDA_INIT_FLAGS  (XA_FLAGS_LOCK_IRQ | XA_FLAGS_ALLOC)
+
 #define IDA_INIT(name)  {                                               \
-        .ida_rt = RADIX_TREE_INIT(name, IDR_RT_MARKER | GFP_NOWAIT),    \
+        .xa = XARRAY_INIT(name, IDA_INIT_FLAGS)                         \
 }
 #define DEFINE_IDA(name)        struct ida name = IDA_INIT(name)
 
@@ -292,7 +291,7 @@ static inline int ida_alloc_max(struct ida *ida, unsigned int max, gfp_t gfp)
 
 static inline void ida_init(struct ida *ida)
 {
-        INIT_RADIX_TREE(&ida->ida_rt, IDR_RT_MARKER | GFP_NOWAIT);
+        xa_init_flags(&ida->xa, IDA_INIT_FLAGS);
 }
 
 #define ida_simple_get(ida, start, end, gfp)    \
@@ -301,9 +300,6 @@ static inline void ida_init(struct ida *ida)
 
 static inline bool ida_is_empty(const struct ida *ida)
 {
-        return radix_tree_empty(&ida->ida_rt);
+        return xa_empty(&ida->xa);
 }
-
-/* in lib/radix-tree.c */
-int ida_pre_get(struct ida *ida, gfp_t gfp_mask);
 #endif /* __IDR_H__ */
diff --git a/include/linux/ieee80211.h b/include/linux/ieee80211.h
index 9c03a7d5e400..0ef67f837ae1 100644
--- a/include/linux/ieee80211.h
+++ b/include/linux/ieee80211.h
@@ -1460,13 +1460,16 @@ struct ieee80211_ht_operation {
  *      STA can receive. Rate expressed in units of 1 Mbps.
  *      If this field is 0 this value should not be used to
  *      consider the highest RX data rate supported.
- *      The top 3 bits of this field are reserved.
+ *      The top 3 bits of this field indicate the Maximum NSTS,total
+ *      (a beamformee capability.)
  * @tx_mcs_map: TX MCS map 2 bits for each stream, total 8 streams
  * @tx_highest: Indicates highest long GI VHT PPDU data rate
  *      STA can transmit. Rate expressed in units of 1 Mbps.
  *      If this field is 0 this value should not be used to
  *      consider the highest TX data rate supported.
- *      The top 3 bits of this field are reserved.
+ *      The top 2 bits of this field are reserved, the
+ *      3rd bit from the top indiciates VHT Extended NSS BW
+ *      Capability.
  */
 struct ieee80211_vht_mcs_info {
         __le16 rx_mcs_map;
@@ -1475,6 +1478,13 @@ struct ieee80211_vht_mcs_info {
         __le16 tx_highest;
 } __packed;
 
+/* for rx_highest */
+#define IEEE80211_VHT_MAX_NSTS_TOTAL_SHIFT      13
+#define IEEE80211_VHT_MAX_NSTS_TOTAL_MASK       (7 << IEEE80211_VHT_MAX_NSTS_TOTAL_SHIFT)
+
+/* for tx_highest */
+#define IEEE80211_VHT_EXT_NSS_BW_CAPABLE        (1 << 13)
+
 /**
  * enum ieee80211_vht_mcs_support - VHT MCS support definitions
  * @IEEE80211_VHT_MCS_SUPPORT_0_7: MCSes 0-7 are supported for the
@@ -1545,11 +1555,11 @@ struct ieee80211_vht_operation {
  * struct ieee80211_he_cap_elem - HE capabilities element
  *
  * This structure is the "HE capabilities element" fixed fields as
- * described in P802.11ax_D2.0 section 9.4.2.237.2 and 9.4.2.237.3
+ * described in P802.11ax_D3.0 section 9.4.2.237.2 and 9.4.2.237.3
  */
 struct ieee80211_he_cap_elem {
-        u8 mac_cap_info[5];
-        u8 phy_cap_info[9];
+        u8 mac_cap_info[6];
+        u8 phy_cap_info[11];
 } __packed;
 
 #define IEEE80211_TX_RX_MCS_NSS_DESC_MAX_LEN    5
@@ -1650,6 +1660,7 @@ struct ieee80211_mu_edca_param_set {
 #define IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ                0x00000004
 #define IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160_80PLUS80MHZ       0x00000008
 #define IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK                  0x0000000C
+#define IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_SHIFT                 2
 #define IEEE80211_VHT_CAP_RXLDPC                                0x00000010
 #define IEEE80211_VHT_CAP_SHORT_GI_80                           0x00000020
 #define IEEE80211_VHT_CAP_SHORT_GI_160                          0x00000040
@@ -1659,6 +1670,7 @@ struct ieee80211_mu_edca_param_set {
 #define IEEE80211_VHT_CAP_RXSTBC_3                              0x00000300
 #define IEEE80211_VHT_CAP_RXSTBC_4                              0x00000400
 #define IEEE80211_VHT_CAP_RXSTBC_MASK                           0x00000700
+#define IEEE80211_VHT_CAP_RXSTBC_SHIFT                          8
 #define IEEE80211_VHT_CAP_SU_BEAMFORMER_CAPABLE                 0x00000800
 #define IEEE80211_VHT_CAP_SU_BEAMFORMEE_CAPABLE                 0x00001000
 #define IEEE80211_VHT_CAP_BEAMFORMEE_STS_SHIFT                  13
@@ -1678,6 +1690,26 @@ struct ieee80211_mu_edca_param_set {
 #define IEEE80211_VHT_CAP_VHT_LINK_ADAPTATION_VHT_MRQ_MFB       0x0c000000
 #define IEEE80211_VHT_CAP_RX_ANTENNA_PATTERN                    0x10000000
 #define IEEE80211_VHT_CAP_TX_ANTENNA_PATTERN                    0x20000000
+#define IEEE80211_VHT_CAP_EXT_NSS_BW_SHIFT                      30
+#define IEEE80211_VHT_CAP_EXT_NSS_BW_MASK                       0xc0000000
+
+/**
+ * ieee80211_get_vht_max_nss - return max NSS for a given bandwidth/MCS
+ * @cap: VHT capabilities of the peer
+ * @bw: bandwidth to use
+ * @mcs: MCS index to use
+ * @ext_nss_bw_capable: indicates whether or not the local transmitter
+ *      (rate scaling algorithm) can deal with the new logic
+ *      (dot11VHTExtendedNSSBWCapable)
+ *
+ * Due to the VHT Extended NSS Bandwidth Support, the maximum NSS can
+ * vary for a given BW/MCS. This function parses the data.
+ *
+ * Note: This function is exported by cfg80211.
+ */
+int ieee80211_get_vht_max_nss(struct ieee80211_vht_cap *cap,
+                              enum ieee80211_vht_chanwidth bw,
+                              int mcs, bool ext_nss_bw_capable);
 
 /* 802.11ax HE MAC capabilities */
 #define IEEE80211_HE_MAC_CAP0_HTC_HE                            0x01
@@ -1707,15 +1739,15 @@ struct ieee80211_mu_edca_param_set {
 #define IEEE80211_HE_MAC_CAP1_TF_MAC_PAD_DUR_8US                0x04
 #define IEEE80211_HE_MAC_CAP1_TF_MAC_PAD_DUR_16US               0x08
 #define IEEE80211_HE_MAC_CAP1_TF_MAC_PAD_DUR_MASK               0x0c
-#define IEEE80211_HE_MAC_CAP1_MULTI_TID_AGG_QOS_1               0x00
-#define IEEE80211_HE_MAC_CAP1_MULTI_TID_AGG_QOS_2               0x10
-#define IEEE80211_HE_MAC_CAP1_MULTI_TID_AGG_QOS_3               0x20
-#define IEEE80211_HE_MAC_CAP1_MULTI_TID_AGG_QOS_4               0x30
-#define IEEE80211_HE_MAC_CAP1_MULTI_TID_AGG_QOS_5               0x40
-#define IEEE80211_HE_MAC_CAP1_MULTI_TID_AGG_QOS_6               0x50
-#define IEEE80211_HE_MAC_CAP1_MULTI_TID_AGG_QOS_7               0x60
-#define IEEE80211_HE_MAC_CAP1_MULTI_TID_AGG_QOS_8               0x70
-#define IEEE80211_HE_MAC_CAP1_MULTI_TID_AGG_QOS_MASK            0x70
+#define IEEE80211_HE_MAC_CAP1_MULTI_TID_AGG_RX_QOS_1            0x00
+#define IEEE80211_HE_MAC_CAP1_MULTI_TID_AGG_RX_QOS_2            0x10
+#define IEEE80211_HE_MAC_CAP1_MULTI_TID_AGG_RX_QOS_3            0x20
+#define IEEE80211_HE_MAC_CAP1_MULTI_TID_AGG_RX_QOS_4            0x30
+#define IEEE80211_HE_MAC_CAP1_MULTI_TID_AGG_RX_QOS_5            0x40
+#define IEEE80211_HE_MAC_CAP1_MULTI_TID_AGG_RX_QOS_6            0x50
+#define IEEE80211_HE_MAC_CAP1_MULTI_TID_AGG_RX_QOS_7            0x60
+#define IEEE80211_HE_MAC_CAP1_MULTI_TID_AGG_RX_QOS_8            0x70
+#define IEEE80211_HE_MAC_CAP1_MULTI_TID_AGG_RX_QOS_MASK         0x70
 
 /* Link adaptation is split between byte HE_MAC_CAP1 and
  * HE_MAC_CAP2. It should be set only if IEEE80211_HE_MAC_CAP0_HTC_HE
@@ -1729,14 +1761,13 @@ struct ieee80211_mu_edca_param_set {
 
 #define IEEE80211_HE_MAC_CAP2_LINK_ADAPTATION                   0x01
 #define IEEE80211_HE_MAC_CAP2_ALL_ACK                           0x02
-#define IEEE80211_HE_MAC_CAP2_UL_MU_RESP_SCHED                  0x04
+#define IEEE80211_HE_MAC_CAP2_TRS                               0x04
 #define IEEE80211_HE_MAC_CAP2_BSR                               0x08
 #define IEEE80211_HE_MAC_CAP2_BCAST_TWT                         0x10
 #define IEEE80211_HE_MAC_CAP2_32BIT_BA_BITMAP                   0x20
 #define IEEE80211_HE_MAC_CAP2_MU_CASCADING                      0x40
 #define IEEE80211_HE_MAC_CAP2_ACK_EN                            0x80
 
-#define IEEE80211_HE_MAC_CAP3_GRP_ADDR_MULTI_STA_BA_DL_MU       0x01
 #define IEEE80211_HE_MAC_CAP3_OMI_CONTROL                       0x02
 #define IEEE80211_HE_MAC_CAP3_OFDMA_RA                          0x04
 
@@ -1744,25 +1775,34 @@ struct ieee80211_mu_edca_param_set {
  * A-MDPU Length Exponent field in the HT capabilities, VHT capabilities and the
  * same field in the HE capabilities.
  */
-#define IEEE80211_HE_MAC_CAP3_MAX_A_AMPDU_LEN_EXP_USE_VHT       0x00
-#define IEEE80211_HE_MAC_CAP3_MAX_A_AMPDU_LEN_EXP_VHT_1         0x08
-#define IEEE80211_HE_MAC_CAP3_MAX_A_AMPDU_LEN_EXP_VHT_2         0x10
-#define IEEE80211_HE_MAC_CAP3_MAX_A_AMPDU_LEN_EXP_RESERVED      0x18
-#define IEEE80211_HE_MAC_CAP3_MAX_A_AMPDU_LEN_EXP_MASK          0x18
-#define IEEE80211_HE_MAC_CAP3_A_AMSDU_FRAG                      0x20
+#define IEEE80211_HE_MAC_CAP3_MAX_AMPDU_LEN_EXP_USE_VHT 0x00
+#define IEEE80211_HE_MAC_CAP3_MAX_AMPDU_LEN_EXP_VHT_1           0x08
+#define IEEE80211_HE_MAC_CAP3_MAX_AMPDU_LEN_EXP_VHT_2           0x10
+#define IEEE80211_HE_MAC_CAP3_MAX_AMPDU_LEN_EXP_RESERVED        0x18
+#define IEEE80211_HE_MAC_CAP3_MAX_AMPDU_LEN_EXP_MASK            0x18
+#define IEEE80211_HE_MAC_CAP3_AMSDU_FRAG                        0x20
 #define IEEE80211_HE_MAC_CAP3_FLEX_TWT_SCHED                    0x40
 #define IEEE80211_HE_MAC_CAP3_RX_CTRL_FRAME_TO_MULTIBSS         0x80
 
 #define IEEE80211_HE_MAC_CAP4_BSRP_BQRP_A_MPDU_AGG              0x01
 #define IEEE80211_HE_MAC_CAP4_QTP                               0x02
 #define IEEE80211_HE_MAC_CAP4_BQR                               0x04
-#define IEEE80211_HE_MAC_CAP4_SR_RESP                           0x08
+#define IEEE80211_HE_MAC_CAP4_SRP_RESP                          0x08
 #define IEEE80211_HE_MAC_CAP4_NDP_FB_REP                        0x10
 #define IEEE80211_HE_MAC_CAP4_OPS                               0x20
 #define IEEE80211_HE_MAC_CAP4_AMDSU_IN_AMPDU                    0x40
+/* Multi TID agg TX is split between byte #4 and #5
+ * The value is a combination of B39,B40,B41
+ */
+#define IEEE80211_HE_MAC_CAP4_MULTI_TID_AGG_TX_QOS_B39          0x80
+
+#define IEEE80211_HE_MAC_CAP5_MULTI_TID_AGG_TX_QOS_B40          0x01
+#define IEEE80211_HE_MAC_CAP5_MULTI_TID_AGG_TX_QOS_B41          0x02
+#define IEEE80211_HE_MAC_CAP5_SUBCHAN_SELECVITE_TRANSMISSION    0x04
+#define IEEE80211_HE_MAC_CAP5_UL_2x996_TONE_RU                  0x08
+#define IEEE80211_HE_MAC_CAP5_OM_CTRL_UL_MU_DATA_DIS_RX         0x10
 
 /* 802.11ax HE PHY capabilities */
-#define IEEE80211_HE_PHY_CAP0_DUAL_BAND                                 0x01
 #define IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_40MHZ_IN_2G             0x02
 #define IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_40MHZ_80MHZ_IN_5G       0x04
 #define IEEE80211_HE_PHY_CAP0_CHANNEL_WIDTH_SET_160MHZ_IN_5G            0x08
@@ -1779,10 +1819,10 @@ struct ieee80211_mu_edca_param_set {
 #define IEEE80211_HE_PHY_CAP1_DEVICE_CLASS_A                            0x10
 #define IEEE80211_HE_PHY_CAP1_LDPC_CODING_IN_PAYLOAD                    0x20
 #define IEEE80211_HE_PHY_CAP1_HE_LTF_AND_GI_FOR_HE_PPDUS_0_8US          0x40
-/* Midamble RX Max NSTS is split between byte #2 and byte #3 */
-#define IEEE80211_HE_PHY_CAP1_MIDAMBLE_RX_MAX_NSTS                      0x80
+/* Midamble RX/TX Max NSTS is split between byte #2 and byte #3 */
+#define IEEE80211_HE_PHY_CAP1_MIDAMBLE_RX_TX_MAX_NSTS                   0x80
 
-#define IEEE80211_HE_PHY_CAP2_MIDAMBLE_RX_MAX_NSTS                      0x01
+#define IEEE80211_HE_PHY_CAP2_MIDAMBLE_RX_TX_MAX_NSTS                   0x01
 #define IEEE80211_HE_PHY_CAP2_NDP_4x_LTF_AND_3_2US                      0x02
 #define IEEE80211_HE_PHY_CAP2_STBC_TX_UNDER_80MHZ                       0x04
 #define IEEE80211_HE_PHY_CAP2_STBC_RX_UNDER_80MHZ                       0x08
@@ -1883,7 +1923,19 @@ struct ieee80211_mu_edca_param_set {
 #define IEEE80211_HE_PHY_CAP8_20MHZ_IN_160MHZ_HE_PPDU                   0x04
 #define IEEE80211_HE_PHY_CAP8_80MHZ_IN_160MHZ_HE_PPDU                   0x08
 #define IEEE80211_HE_PHY_CAP8_HE_ER_SU_1XLTF_AND_08_US_GI               0x10
-#define IEEE80211_HE_PHY_CAP8_MIDAMBLE_RX_2X_AND_1XLTF                  0x20
+#define IEEE80211_HE_PHY_CAP8_MIDAMBLE_RX_TX_2X_AND_1XLTF               0x20
+#define IEEE80211_HE_PHY_CAP8_DCM_MAX_BW_20MHZ                          0x00
+#define IEEE80211_HE_PHY_CAP8_DCM_MAX_BW_40MHZ                          0x40
+#define IEEE80211_HE_PHY_CAP8_DCM_MAX_BW_80MHZ                          0x80
+#define IEEE80211_HE_PHY_CAP8_DCM_MAX_BW_160_OR_80P80_MHZ               0xc0
+#define IEEE80211_HE_PHY_CAP8_DCM_MAX_BW_MASK                           0xc0
+
+#define IEEE80211_HE_PHY_CAP9_LONGER_THAN_16_SIGB_OFDM_SYM              0x01
+#define IEEE80211_HE_PHY_CAP9_NON_TRIGGERED_CQI_FEEDBACK                0x02
+#define IEEE80211_HE_PHY_CAP9_TX_1024_QAM_LESS_THAN_242_TONE_RU         0x04
+#define IEEE80211_HE_PHY_CAP9_RX_1024_QAM_LESS_THAN_242_TONE_RU         0x08
+#define IEEE80211_HE_PHY_CAP9_RX_FULL_BW_SU_USING_MU_WITH_COMP_SIGB     0x10
+#define IEEE80211_HE_PHY_CAP9_RX_FULL_BW_SU_USING_MU_WITH_NON_COMP_SIGB 0x20
 
 /* 802.11ax HE TX/RX MCS NSS Support  */
 #define IEEE80211_TX_RX_MCS_NSS_SUPP_HIGHEST_MCS_POS                    (3)
@@ -1963,8 +2015,8 @@ ieee80211_he_ppe_size(u8 ppe_thres_hdr, const u8 *phy_cap_info)
 #define IEEE80211_HE_OPERATION_TWT_REQUIRED                     0x00000200
 #define IEEE80211_HE_OPERATION_RTS_THRESHOLD_MASK               0x000ffc00
 #define IEEE80211_HE_OPERATION_RTS_THRESHOLD_OFFSET             10
-#define IEEE80211_HE_OPERATION_PARTIAL_BSS_COLOR                0x000100000
-#define IEEE80211_HE_OPERATION_VHT_OPER_INFO                    0x000200000
+#define IEEE80211_HE_OPERATION_PARTIAL_BSS_COLOR                0x00100000
+#define IEEE80211_HE_OPERATION_VHT_OPER_INFO                    0x00200000
 #define IEEE80211_HE_OPERATION_MULTI_BSSID_AP                   0x10000000
 #define IEEE80211_HE_OPERATION_TX_BSSID_INDICATOR               0x20000000
 #define IEEE80211_HE_OPERATION_BSS_COLOR_DISABLED               0x40000000
diff --git a/include/linux/if_tun.h b/include/linux/if_tun.h
index 3d2996dc7d85..12e3eebf0ce6 100644
--- a/include/linux/if_tun.h
+++ b/include/linux/if_tun.h
@@ -16,9 +16,23 @@
 #define __IF_TUN_H
 
 #include <uapi/linux/if_tun.h>
+#include <uapi/linux/virtio_net.h>
 
 #define TUN_XDP_FLAG 0x1UL
 
+#define TUN_MSG_UBUF 1
+#define TUN_MSG_PTR  2
+struct tun_msg_ctl {
+        unsigned short type;
+        unsigned short num;
+        void *ptr;
+};
+
+struct tun_xdp_hdr {
+        int buflen;
+        struct virtio_net_hdr gso;
+};
+
 #if defined(CONFIG_TUN) || defined(CONFIG_TUN_MODULE)
 struct socket *tun_get_socket(struct file *);
 struct ptr_ring *tun_get_tx_ring(struct file *file);
diff --git a/include/linux/init.h b/include/linux/init.h
index 2538d176dd1f..9c2aba1dbabf 100644
--- a/include/linux/init.h
+++ b/include/linux/init.h
@@ -133,7 +133,6 @@ static inline initcall_t initcall_from_entry(initcall_entry_t *entry)
 #endif
 
 extern initcall_entry_t __con_initcall_start[], __con_initcall_end[];
-extern initcall_entry_t __security_initcall_start[], __security_initcall_end[];
 
 /* Used for contructor calls. */
 typedef void (*ctor_fn_t)(void);
@@ -236,7 +235,6 @@ extern bool initcall_debug;
         static exitcall_t __exitcall_##fn __exit_call = fn
 
 #define console_initcall(fn)    ___define_initcall(fn,, .con_initcall)
-#define security_initcall(fn)   ___define_initcall(fn,, .security_initcall)
 
 struct obs_kernel_param {
         const char *str;
diff --git a/include/linux/intel-iommu.h b/include/linux/intel-iommu.h
index 28004d74ae04..b0ae25837361 100644
--- a/include/linux/intel-iommu.h
+++ b/include/linux/intel-iommu.h
@@ -72,6 +72,42 @@
 #define DMAR_PEDATA_REG 0xe4    /* Page request event interrupt data register */
 #define DMAR_PEADDR_REG 0xe8    /* Page request event interrupt addr register */
 #define DMAR_PEUADDR_REG 0xec   /* Page request event Upper address register */
+#define DMAR_MTRRCAP_REG 0x100  /* MTRR capability register */
+#define DMAR_MTRRDEF_REG 0x108  /* MTRR default type register */
+#define DMAR_MTRR_FIX64K_00000_REG 0x120 /* MTRR Fixed range registers */
+#define DMAR_MTRR_FIX16K_80000_REG 0x128
+#define DMAR_MTRR_FIX16K_A0000_REG 0x130
+#define DMAR_MTRR_FIX4K_C0000_REG 0x138
+#define DMAR_MTRR_FIX4K_C8000_REG 0x140
+#define DMAR_MTRR_FIX4K_D0000_REG 0x148
+#define DMAR_MTRR_FIX4K_D8000_REG 0x150
+#define DMAR_MTRR_FIX4K_E0000_REG 0x158
+#define DMAR_MTRR_FIX4K_E8000_REG 0x160
+#define DMAR_MTRR_FIX4K_F0000_REG 0x168
+#define DMAR_MTRR_FIX4K_F8000_REG 0x170
+#define DMAR_MTRR_PHYSBASE0_REG 0x180 /* MTRR Variable range registers */
+#define DMAR_MTRR_PHYSMASK0_REG 0x188
+#define DMAR_MTRR_PHYSBASE1_REG 0x190
+#define DMAR_MTRR_PHYSMASK1_REG 0x198
+#define DMAR_MTRR_PHYSBASE2_REG 0x1a0
+#define DMAR_MTRR_PHYSMASK2_REG 0x1a8
+#define DMAR_MTRR_PHYSBASE3_REG 0x1b0
+#define DMAR_MTRR_PHYSMASK3_REG 0x1b8
+#define DMAR_MTRR_PHYSBASE4_REG 0x1c0
+#define DMAR_MTRR_PHYSMASK4_REG 0x1c8
+#define DMAR_MTRR_PHYSBASE5_REG 0x1d0
+#define DMAR_MTRR_PHYSMASK5_REG 0x1d8
+#define DMAR_MTRR_PHYSBASE6_REG 0x1e0
+#define DMAR_MTRR_PHYSMASK6_REG 0x1e8
+#define DMAR_MTRR_PHYSBASE7_REG 0x1f0
+#define DMAR_MTRR_PHYSMASK7_REG 0x1f8
+#define DMAR_MTRR_PHYSBASE8_REG 0x200
+#define DMAR_MTRR_PHYSMASK8_REG 0x208
+#define DMAR_MTRR_PHYSBASE9_REG 0x210
+#define DMAR_MTRR_PHYSMASK9_REG 0x218
+#define DMAR_VCCAP_REG          0xe00 /* Virtual command capability register */
+#define DMAR_VCMD_REG           0xe10 /* Virtual command register */
+#define DMAR_VCRSP_REG          0xe20 /* Virtual command response register */
 
 #define OFFSET_STRIDE           (9)
 
@@ -389,6 +425,33 @@ struct pasid_entry;
 struct pasid_state_entry;
 struct page_req_dsc;
 
+/*
+ * 0: Present
+ * 1-11: Reserved
+ * 12-63: Context Ptr (12 - (haw-1))
+ * 64-127: Reserved
+ */
+struct root_entry {
+        u64     lo;
+        u64     hi;
+};
+
+/*
+ * low 64 bits:
+ * 0: present
+ * 1: fault processing disable
+ * 2-3: translation type
+ * 12-63: address space root
+ * high 64 bits:
+ * 0-2: address width
+ * 3-6: aval
+ * 8-23: domain id
+ */
+struct context_entry {
+        u64 lo;
+        u64 hi;
+};
+
 struct dmar_domain {
         int     nid;                    /* node id */
 
@@ -558,6 +621,15 @@ extern int intel_iommu_enable_pasid(struct intel_iommu *iommu, struct intel_svm_
 extern struct intel_iommu *intel_svm_device_to_iommu(struct device *dev);
 #endif
 
+#ifdef CONFIG_INTEL_IOMMU_DEBUGFS
+void intel_iommu_debugfs_init(void);
+#else
+static inline void intel_iommu_debugfs_init(void) {}
+#endif /* CONFIG_INTEL_IOMMU_DEBUGFS */
+
 extern const struct attribute_group *intel_iommu_groups[];
+bool context_present(struct context_entry *context);
+struct context_entry *iommu_context_addr(struct intel_iommu *iommu, u8 bus,
+                                         u8 devfn, int alloc);
 
 #endif
diff --git a/include/linux/interrupt.h b/include/linux/interrupt.h
index eeceac3376fc..1d6711c28271 100644
--- a/include/linux/interrupt.h
+++ b/include/linux/interrupt.h
@@ -45,7 +45,7 @@
  * IRQF_PERCPU - Interrupt is per cpu
  * IRQF_NOBALANCING - Flag to exclude this interrupt from irq balancing
  * IRQF_IRQPOLL - Interrupt is used for polling (only the interrupt that is
- *                registered first in an shared interrupt is considered for
+ *                registered first in a shared interrupt is considered for
  *                performance reasons)
  * IRQF_ONESHOT - Interrupt is not reenabled after the hardirq handler finished.
  *                Used by threaded interrupts which need to keep the
diff --git a/include/linux/iomap.h b/include/linux/iomap.h
index 3555d54bf79a..9a4258154b25 100644
--- a/include/linux/iomap.h
+++ b/include/linux/iomap.h
@@ -6,6 +6,7 @@
 #include <linux/bitmap.h>
 #include <linux/mm.h>
 #include <linux/types.h>
+#include <linux/mm_types.h>
 
 struct address_space;
 struct fiemap_extent_info;
@@ -141,7 +142,8 @@ int iomap_zero_range(struct inode *inode, loff_t pos, loff_t len,
                 bool *did_zero, const struct iomap_ops *ops);
 int iomap_truncate_page(struct inode *inode, loff_t pos, bool *did_zero,
                 const struct iomap_ops *ops);
-int iomap_page_mkwrite(struct vm_fault *vmf, const struct iomap_ops *ops);
+vm_fault_t iomap_page_mkwrite(struct vm_fault *vmf,
+                        const struct iomap_ops *ops);
 int iomap_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
                 loff_t start, loff_t len, const struct iomap_ops *ops);
 loff_t iomap_seek_hole(struct inode *inode, loff_t offset,
diff --git a/include/linux/iommu.h b/include/linux/iommu.h
index 87994c265bf5..a1d28f42cb77 100644
--- a/include/linux/iommu.h
+++ b/include/linux/iommu.h
@@ -124,6 +124,7 @@ enum iommu_attr {
         DOMAIN_ATTR_FSL_PAMU_ENABLE,
         DOMAIN_ATTR_FSL_PAMUV1,
         DOMAIN_ATTR_NESTING,    /* two stages of translation */
+        DOMAIN_ATTR_DMA_USE_FLUSH_QUEUE,
         DOMAIN_ATTR_MAX,
 };
 
@@ -181,8 +182,6 @@ struct iommu_resv_region {
  * @apply_resv_region: Temporary helper call-back for iova reserved ranges
  * @domain_window_enable: Configure and enable a particular window for a domain
  * @domain_window_disable: Disable a particular window for a domain
- * @domain_set_windows: Set the number of windows for a domain
- * @domain_get_windows: Return the number of windows for a domain
  * @of_xlate: add OF master IDs to iommu grouping
  * @pgsize_bitmap: bitmap of all possible supported page sizes
  */
@@ -223,10 +222,6 @@ struct iommu_ops {
         int (*domain_window_enable)(struct iommu_domain *domain, u32 wnd_nr,
                                     phys_addr_t paddr, u64 size, int prot);
         void (*domain_window_disable)(struct iommu_domain *domain, u32 wnd_nr);
-        /* Set the number of windows per domain */
-        int (*domain_set_windows)(struct iommu_domain *domain, u32 w_count);
-        /* Get the number of windows per domain */
-        u32 (*domain_get_windows)(struct iommu_domain *domain);
 
         int (*of_xlate)(struct device *dev, struct of_phandle_args *args);
         bool (*is_attach_deferred)(struct iommu_domain *domain, struct device *dev);
@@ -293,6 +288,7 @@ extern int iommu_attach_device(struct iommu_domain *domain,
 extern void iommu_detach_device(struct iommu_domain *domain,
                                 struct device *dev);
 extern struct iommu_domain *iommu_get_domain_for_dev(struct device *dev);
+extern struct iommu_domain *iommu_get_dma_domain(struct device *dev);
 extern int iommu_map(struct iommu_domain *domain, unsigned long iova,
                      phys_addr_t paddr, size_t size, int prot);
 extern size_t iommu_unmap(struct iommu_domain *domain, unsigned long iova,
@@ -377,6 +373,8 @@ static inline void iommu_tlb_sync(struct iommu_domain *domain)
 extern struct iommu_group *pci_device_group(struct device *dev);
 /* Generic device grouping function */
 extern struct iommu_group *generic_device_group(struct device *dev);
+/* FSL-MC device grouping function */
+struct iommu_group *fsl_mc_device_group(struct device *dev);
 
 /**
  * struct iommu_fwspec - per-device IOMMU instance data
diff --git a/include/linux/iova.h b/include/linux/iova.h
index 928442dda565..0b93bf96693e 100644
--- a/include/linux/iova.h
+++ b/include/linux/iova.h
@@ -75,6 +75,7 @@ struct iova_domain {
         unsigned long   granule;        /* pfn granularity for this domain */
         unsigned long   start_pfn;      /* Lower limit for this domain */
         unsigned long   dma_32bit_pfn;
+        unsigned long   max32_alloc_size; /* Size of last failed allocation */
         struct iova     anchor;         /* rbtree lookup anchor */
         struct iova_rcache rcaches[IOVA_RANGE_CACHE_MAX_SIZE];  /* IOVA range caches */
 
diff --git a/include/linux/ipmi.h b/include/linux/ipmi.h
index 41f5c086f670..ef61676cfe05 100644
--- a/include/linux/ipmi.h
+++ b/include/linux/ipmi.h
@@ -27,7 +27,7 @@ struct device;
  * Opaque type for a IPMI message user.  One of these is needed to
  * send and receive messages.
  */
-typedef struct ipmi_user *ipmi_user_t;
+struct ipmi_user;
 
 /*
  * Stuff coming from the receive interface comes as one of these.
diff --git a/include/linux/ipmi_smi.h b/include/linux/ipmi_smi.h
index 7d5fd38d5282..8c4e2ab696c3 100644
--- a/include/linux/ipmi_smi.h
+++ b/include/linux/ipmi_smi.h
@@ -28,7 +28,7 @@ struct device;
  */
 
 /* Structure for the low-level drivers. */
-typedef struct ipmi_smi *ipmi_smi_t;
+struct ipmi_smi;
 
 /*
  * Messages to/from the lower layer.  The smi interface will take one
diff --git a/include/linux/ipv6.h b/include/linux/ipv6.h
index 8415bf1a9776..495e834c1367 100644
--- a/include/linux/ipv6.h
+++ b/include/linux/ipv6.h
@@ -274,7 +274,8 @@ struct ipv6_pinfo {
                                                  */
                                 dontfrag:1,
                                 autoflowlabel:1,
-                                autoflowlabel_set:1;
+                                autoflowlabel_set:1,
+                                mc_all:1;
         __u8                    min_hopcount;
         __u8                    tclass;
         __be32                  rcv_flowinfo;
diff --git a/include/linux/irq.h b/include/linux/irq.h
index 201de12a9957..c9bffda04a45 100644
--- a/include/linux/irq.h
+++ b/include/linux/irq.h
@@ -1151,7 +1151,8 @@ void irq_matrix_offline(struct irq_matrix *m);
 void irq_matrix_assign_system(struct irq_matrix *m, unsigned int bit, bool replace);
 int irq_matrix_reserve_managed(struct irq_matrix *m, const struct cpumask *msk);
 void irq_matrix_remove_managed(struct irq_matrix *m, const struct cpumask *msk);
-int irq_matrix_alloc_managed(struct irq_matrix *m, unsigned int cpu);
+int irq_matrix_alloc_managed(struct irq_matrix *m, const struct cpumask *msk,
+                                unsigned int *mapped_cpu);
 void irq_matrix_reserve(struct irq_matrix *m);
 void irq_matrix_remove_reserved(struct irq_matrix *m);
 int irq_matrix_alloc(struct irq_matrix *m, const struct cpumask *msk,
diff --git a/include/linux/irqchip/arm-gic-common.h b/include/linux/irqchip/arm-gic-common.h
index 0a83b4379f34..9a1a479a2bf4 100644
--- a/include/linux/irqchip/arm-gic-common.h
+++ b/include/linux/irqchip/arm-gic-common.h
@@ -13,6 +13,12 @@
 #include <linux/types.h>
 #include <linux/ioport.h>
 
+#define GICD_INT_DEF_PRI                0xa0
+#define GICD_INT_DEF_PRI_X4             ((GICD_INT_DEF_PRI << 24) |\
+                                        (GICD_INT_DEF_PRI << 16) |\
+                                        (GICD_INT_DEF_PRI << 8) |\
+                                        GICD_INT_DEF_PRI)
+
 enum gic_type {
         GIC_V2,
         GIC_V3,
diff --git a/include/linux/irqchip/arm-gic-v3.h b/include/linux/irqchip/arm-gic-v3.h
index 8bdbb5f29494..071b4cbdf010 100644
--- a/include/linux/irqchip/arm-gic-v3.h
+++ b/include/linux/irqchip/arm-gic-v3.h
@@ -357,6 +357,8 @@
 #define GITS_CBASER_RaWaWt      GIC_BASER_CACHEABILITY(GITS_CBASER, INNER, RaWaWt)
 #define GITS_CBASER_RaWaWb      GIC_BASER_CACHEABILITY(GITS_CBASER, INNER, RaWaWb)
 
+#define GITS_CBASER_ADDRESS(cbaser)     ((cbaser) & GENMASK_ULL(51, 12))
+
 #define GITS_BASER_NR_REGS              8
 
 #define GITS_BASER_VALID                        (1ULL << 63)
@@ -388,6 +390,9 @@
 #define GITS_BASER_ENTRY_SIZE_MASK      GENMASK_ULL(52, 48)
 #define GITS_BASER_PHYS_52_to_48(phys)                                  \
         (((phys) & GENMASK_ULL(47, 16)) | (((phys) >> 48) & 0xf) << 12)
+#define GITS_BASER_ADDR_48_to_52(baser)                                 \
+        (((baser) & GENMASK_ULL(47, 16)) | (((baser) >> 12) & 0xf) << 48)
+
 #define GITS_BASER_SHAREABILITY_SHIFT   (10)
 #define GITS_BASER_InnerShareable                                       \
         GIC_BASER_SHAREABILITY(GITS_BASER, InnerShareable)
@@ -585,8 +590,10 @@ struct rdists {
                 void __iomem    *rd_base;
                 struct page     *pend_page;
                 phys_addr_t     phys_base;
+                bool            lpi_enabled;
         } __percpu              *rdist;
-        struct page             *prop_page;
+        phys_addr_t             prop_table_pa;
+        void                    *prop_table_va;
         u64                     flags;
         u32                     gicd_typer;
         bool                    has_vlpis;
diff --git a/include/linux/irqchip/arm-gic.h b/include/linux/irqchip/arm-gic.h
index 6c4aaf04046c..626179077bb0 100644
--- a/include/linux/irqchip/arm-gic.h
+++ b/include/linux/irqchip/arm-gic.h
@@ -65,11 +65,6 @@
 #define GICD_INT_EN_CLR_X32             0xffffffff
 #define GICD_INT_EN_SET_SGI             0x0000ffff
 #define GICD_INT_EN_CLR_PPI             0xffff0000
-#define GICD_INT_DEF_PRI                0xa0
-#define GICD_INT_DEF_PRI_X4             ((GICD_INT_DEF_PRI << 24) |\
-                                        (GICD_INT_DEF_PRI << 16) |\
-                                        (GICD_INT_DEF_PRI << 8) |\
-                                        GICD_INT_DEF_PRI)
 
 #define GICD_IIDR_IMPLEMENTER_SHIFT     0
 #define GICD_IIDR_IMPLEMENTER_MASK      (0xfff << GICD_IIDR_IMPLEMENTER_SHIFT)
diff --git a/include/linux/irqdomain.h b/include/linux/irqdomain.h
index dccfa65aee96..068aa46f0d55 100644
--- a/include/linux/irqdomain.h
+++ b/include/linux/irqdomain.h
@@ -75,6 +75,7 @@ struct irq_fwspec {
 enum irq_domain_bus_token {
         DOMAIN_BUS_ANY          = 0,
         DOMAIN_BUS_WIRED,
+        DOMAIN_BUS_GENERIC_MSI,
         DOMAIN_BUS_PCI_MSI,
         DOMAIN_BUS_PLATFORM_MSI,
         DOMAIN_BUS_NEXUS,
diff --git a/include/linux/jump_label.h b/include/linux/jump_label.h
index 1a0b6f17a5d6..5df6a621e464 100644
--- a/include/linux/jump_label.h
+++ b/include/linux/jump_label.h
@@ -119,6 +119,68 @@ struct static_key {
 
 #ifdef HAVE_JUMP_LABEL
 #include <asm/jump_label.h>
+
+#ifndef __ASSEMBLY__
+#ifdef CONFIG_HAVE_ARCH_JUMP_LABEL_RELATIVE
+
+struct jump_entry {
+        s32 code;
+        s32 target;
+        long key;       // key may be far away from the core kernel under KASLR
+};
+
+static inline unsigned long jump_entry_code(const struct jump_entry *entry)
+{
+        return (unsigned long)&entry->code + entry->code;
+}
+
+static inline unsigned long jump_entry_target(const struct jump_entry *entry)
+{
+        return (unsigned long)&entry->target + entry->target;
+}
+
+static inline struct static_key *jump_entry_key(const struct jump_entry *entry)
+{
+        long offset = entry->key & ~3L;
+
+        return (struct static_key *)((unsigned long)&entry->key + offset);
+}
+
+#else
+
+static inline unsigned long jump_entry_code(const struct jump_entry *entry)
+{
+        return entry->code;
+}
+
+static inline unsigned long jump_entry_target(const struct jump_entry *entry)
+{
+        return entry->target;
+}
+
+static inline struct static_key *jump_entry_key(const struct jump_entry *entry)
+{
+        return (struct static_key *)((unsigned long)entry->key & ~3UL);
+}
+
+#endif
+
+static inline bool jump_entry_is_branch(const struct jump_entry *entry)
+{
+        return (unsigned long)entry->key & 1UL;
+}
+
+static inline bool jump_entry_is_init(const struct jump_entry *entry)
+{
+        return (unsigned long)entry->key & 2UL;
+}
+
+static inline void jump_entry_set_init(struct jump_entry *entry)
+{
+        entry->key |= 2;
+}
+
+#endif
 #endif
 
 #ifndef __ASSEMBLY__
@@ -151,7 +213,6 @@ extern struct jump_entry __start___jump_table[];
 extern struct jump_entry __stop___jump_table[];
 
 extern void jump_label_init(void);
-extern void jump_label_invalidate_initmem(void);
 extern void jump_label_lock(void);
 extern void jump_label_unlock(void);
 extern void arch_jump_label_transform(struct jump_entry *entry,
@@ -199,8 +260,6 @@ static __always_inline void jump_label_init(void)
         static_key_initialized = true;
 }
 
-static inline void jump_label_invalidate_initmem(void) {}
-
 static __always_inline bool static_key_false(struct static_key *key)
 {
         if (unlikely(static_key_count(key) > 0))
diff --git a/include/linux/kernfs.h b/include/linux/kernfs.h
index 814643f7ee52..5b36b1287a5a 100644
--- a/include/linux/kernfs.h
+++ b/include/linux/kernfs.h
@@ -477,10 +477,11 @@ static inline void kernfs_init(void) { }
  * @buf: buffer to copy @kn's name into
  * @buflen: size of @buf
  *
- * Builds and returns the full path of @kn in @buf of @buflen bytes.  The
- * path is built from the end of @buf so the returned pointer usually
- * doesn't match @buf.  If @buf isn't long enough, @buf is nul terminated
- * and %NULL is returned.
+ * If @kn is NULL result will be "(null)".
+ *
+ * Returns the length of the full path.  If the full length is equal to or
+ * greater than @buflen, @buf contains the truncated path with the trailing
+ * '\0'.  On error, -errno is returned.
  */
 static inline int kernfs_path(struct kernfs_node *kn, char *buf, size_t buflen)
 {
diff --git a/include/linux/kvm_host.h b/include/linux/kvm_host.h
index 0205aee44ded..c926698040e0 100644
--- a/include/linux/kvm_host.h
+++ b/include/linux/kvm_host.h
@@ -733,8 +733,6 @@ bool kvm_vcpu_wake_up(struct kvm_vcpu *vcpu);
 void kvm_vcpu_kick(struct kvm_vcpu *vcpu);
 int kvm_vcpu_yield_to(struct kvm_vcpu *target);
 void kvm_vcpu_on_spin(struct kvm_vcpu *vcpu, bool usermode_vcpu_not_eligible);
-void kvm_load_guest_fpu(struct kvm_vcpu *vcpu);
-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);
diff --git a/include/linux/leds.h b/include/linux/leds.h
index 834683d603f9..7393a316d9fa 100644
--- a/include/linux/leds.h
+++ b/include/linux/leds.h
@@ -22,6 +22,7 @@
 #include <linux/workqueue.h>
 
 struct device;
+struct led_pattern;
 /*
  * LED Core
  */
@@ -88,6 +89,10 @@ struct led_classdev {
                                      unsigned long *delay_on,
                                      unsigned long *delay_off);
 
+        int (*pattern_set)(struct led_classdev *led_cdev,
+                           struct led_pattern *pattern, u32 len, int repeat);
+        int (*pattern_clear)(struct led_classdev *led_cdev);
+
         struct device           *dev;
         const struct attribute_group    **groups;
 
@@ -472,4 +477,14 @@ static inline void led_classdev_notify_brightness_hw_changed(
         struct led_classdev *led_cdev, enum led_brightness brightness) { }
 #endif
 
+/**
+ * struct led_pattern - pattern interval settings
+ * @delta_t: pattern interval delay, in milliseconds
+ * @brightness: pattern interval brightness
+ */
+struct led_pattern {
+        u32 delta_t;
+        int brightness;
+};
+
 #endif          /* __LINUX_LEDS_H_INCLUDED */
diff --git a/include/linux/libfdt_env.h b/include/linux/libfdt_env.h
index c6ac1fe7ec68..edb0f0c30904 100644
--- a/include/linux/libfdt_env.h
+++ b/include/linux/libfdt_env.h
@@ -2,6 +2,7 @@
 #ifndef LIBFDT_ENV_H
 #define LIBFDT_ENV_H
 
+#include <linux/kernel.h>       /* For INT_MAX */
 #include <linux/string.h>
 
 #include <asm/byteorder.h>
diff --git a/include/linux/lightnvm.h b/include/linux/lightnvm.h
index e9e0d1c7eaf5..2fdeac1a420d 100644
--- a/include/linux/lightnvm.h
+++ b/include/linux/lightnvm.h
@@ -86,8 +86,8 @@ struct nvm_chk_meta;
 typedef int (nvm_id_fn)(struct nvm_dev *);
 typedef int (nvm_op_bb_tbl_fn)(struct nvm_dev *, struct ppa_addr, u8 *);
 typedef int (nvm_op_set_bb_fn)(struct nvm_dev *, struct ppa_addr *, int, int);
-typedef int (nvm_get_chk_meta_fn)(struct nvm_dev *, struct nvm_chk_meta *,
-                                                                sector_t, int);
+typedef int (nvm_get_chk_meta_fn)(struct nvm_dev *, sector_t, int,
+                                                        struct nvm_chk_meta *);
 typedef int (nvm_submit_io_fn)(struct nvm_dev *, struct nvm_rq *);
 typedef int (nvm_submit_io_sync_fn)(struct nvm_dev *, struct nvm_rq *);
 typedef void *(nvm_create_dma_pool_fn)(struct nvm_dev *, char *);
@@ -305,6 +305,8 @@ struct nvm_rq {
         u64 ppa_status; /* ppa media status */
         int error;
 
+        int is_seq; /* Sequential hint flag. 1.2 only */
+
         void *private;
 };
 
@@ -318,6 +320,11 @@ static inline void *nvm_rq_to_pdu(struct nvm_rq *rqdata)
         return rqdata + 1;
 }
 
+static inline struct ppa_addr *nvm_rq_to_ppa_list(struct nvm_rq *rqd)
+{
+        return (rqd->nr_ppas > 1) ? rqd->ppa_list : &rqd->ppa_addr;
+}
+
 enum {
         NVM_BLK_ST_FREE =       0x1,    /* Free block */
         NVM_BLK_ST_TGT =        0x2,    /* Block in use by target */
@@ -485,6 +492,144 @@ static inline struct ppa_addr dev_to_generic_addr(struct nvm_dev *dev,
         return l;
 }
 
+static inline u64 dev_to_chunk_addr(struct nvm_dev *dev, void *addrf,
+                                    struct ppa_addr p)
+{
+        struct nvm_geo *geo = &dev->geo;
+        u64 caddr;
+
+        if (geo->version == NVM_OCSSD_SPEC_12) {
+                struct nvm_addrf_12 *ppaf = (struct nvm_addrf_12 *)addrf;
+
+                caddr = (u64)p.g.pg << ppaf->pg_offset;
+                caddr |= (u64)p.g.pl << ppaf->pln_offset;
+                caddr |= (u64)p.g.sec << ppaf->sec_offset;
+        } else {
+                caddr = p.m.sec;
+        }
+
+        return caddr;
+}
+
+static inline struct ppa_addr nvm_ppa32_to_ppa64(struct nvm_dev *dev,
+                                                 void *addrf, u32 ppa32)
+{
+        struct ppa_addr ppa64;
+
+        ppa64.ppa = 0;
+
+        if (ppa32 == -1) {
+                ppa64.ppa = ADDR_EMPTY;
+        } else if (ppa32 & (1U << 31)) {
+                ppa64.c.line = ppa32 & ((~0U) >> 1);
+                ppa64.c.is_cached = 1;
+        } else {
+                struct nvm_geo *geo = &dev->geo;
+
+                if (geo->version == NVM_OCSSD_SPEC_12) {
+                        struct nvm_addrf_12 *ppaf = addrf;
+
+                        ppa64.g.ch = (ppa32 & ppaf->ch_mask) >>
+                                                        ppaf->ch_offset;
+                        ppa64.g.lun = (ppa32 & ppaf->lun_mask) >>
+                                                        ppaf->lun_offset;
+                        ppa64.g.blk = (ppa32 & ppaf->blk_mask) >>
+                                                        ppaf->blk_offset;
+                        ppa64.g.pg = (ppa32 & ppaf->pg_mask) >>
+                                                        ppaf->pg_offset;
+                        ppa64.g.pl = (ppa32 & ppaf->pln_mask) >>
+                                                        ppaf->pln_offset;
+                        ppa64.g.sec = (ppa32 & ppaf->sec_mask) >>
+                                                        ppaf->sec_offset;
+                } else {
+                        struct nvm_addrf *lbaf = addrf;
+
+                        ppa64.m.grp = (ppa32 & lbaf->ch_mask) >>
+                                                        lbaf->ch_offset;
+                        ppa64.m.pu = (ppa32 & lbaf->lun_mask) >>
+                                                        lbaf->lun_offset;
+                        ppa64.m.chk = (ppa32 & lbaf->chk_mask) >>
+                                                        lbaf->chk_offset;
+                        ppa64.m.sec = (ppa32 & lbaf->sec_mask) >>
+                                                        lbaf->sec_offset;
+                }
+        }
+
+        return ppa64;
+}
+
+static inline u32 nvm_ppa64_to_ppa32(struct nvm_dev *dev,
+                                     void *addrf, struct ppa_addr ppa64)
+{
+        u32 ppa32 = 0;
+
+        if (ppa64.ppa == ADDR_EMPTY) {
+                ppa32 = ~0U;
+        } else if (ppa64.c.is_cached) {
+                ppa32 |= ppa64.c.line;
+                ppa32 |= 1U << 31;
+        } else {
+                struct nvm_geo *geo = &dev->geo;
+
+                if (geo->version == NVM_OCSSD_SPEC_12) {
+                        struct nvm_addrf_12 *ppaf = addrf;
+
+                        ppa32 |= ppa64.g.ch << ppaf->ch_offset;
+                        ppa32 |= ppa64.g.lun << ppaf->lun_offset;
+                        ppa32 |= ppa64.g.blk << ppaf->blk_offset;
+                        ppa32 |= ppa64.g.pg << ppaf->pg_offset;
+                        ppa32 |= ppa64.g.pl << ppaf->pln_offset;
+                        ppa32 |= ppa64.g.sec << ppaf->sec_offset;
+                } else {
+                        struct nvm_addrf *lbaf = addrf;
+
+                        ppa32 |= ppa64.m.grp << lbaf->ch_offset;
+                        ppa32 |= ppa64.m.pu << lbaf->lun_offset;
+                        ppa32 |= ppa64.m.chk << lbaf->chk_offset;
+                        ppa32 |= ppa64.m.sec << lbaf->sec_offset;
+                }
+        }
+
+        return ppa32;
+}
+
+static inline int nvm_next_ppa_in_chk(struct nvm_tgt_dev *dev,
+                                      struct ppa_addr *ppa)
+{
+        struct nvm_geo *geo = &dev->geo;
+        int last = 0;
+
+        if (geo->version == NVM_OCSSD_SPEC_12) {
+                int sec = ppa->g.sec;
+
+                sec++;
+                if (sec == geo->ws_min) {
+                        int pg = ppa->g.pg;
+
+                        sec = 0;
+                        pg++;
+                        if (pg == geo->num_pg) {
+                                int pl = ppa->g.pl;
+
+                                pg = 0;
+                                pl++;
+                                if (pl == geo->num_pln)
+                                        last = 1;
+
+                                ppa->g.pl = pl;
+                        }
+                        ppa->g.pg = pg;
+                }
+                ppa->g.sec = sec;
+        } else {
+                ppa->m.sec++;
+                if (ppa->m.sec == geo->clba)
+                        last = 1;
+        }
+
+        return last;
+}
+
 typedef blk_qc_t (nvm_tgt_make_rq_fn)(struct request_queue *, struct bio *);
 typedef sector_t (nvm_tgt_capacity_fn)(void *);
 typedef void *(nvm_tgt_init_fn)(struct nvm_tgt_dev *, struct gendisk *,
@@ -493,9 +638,15 @@ typedef void (nvm_tgt_exit_fn)(void *, bool);
 typedef int (nvm_tgt_sysfs_init_fn)(struct gendisk *);
 typedef void (nvm_tgt_sysfs_exit_fn)(struct gendisk *);
 
+enum {
+        NVM_TGT_F_DEV_L2P = 0,
+        NVM_TGT_F_HOST_L2P = 1 << 0,
+};
+
 struct nvm_tgt_type {
         const char *name;
         unsigned int version[3];
+        int flags;
 
         /* target entry points */
         nvm_tgt_make_rq_fn *make_rq;
@@ -524,18 +675,13 @@ extern struct nvm_dev *nvm_alloc_dev(int);
 extern int nvm_register(struct nvm_dev *);
 extern void nvm_unregister(struct nvm_dev *);
 
-
-extern int nvm_get_chunk_meta(struct nvm_tgt_dev *tgt_dev,
-                              struct nvm_chk_meta *meta, struct ppa_addr ppa,
-                              int nchks);
-
-extern int nvm_set_tgt_bb_tbl(struct nvm_tgt_dev *, struct ppa_addr *,
+extern int nvm_get_chunk_meta(struct nvm_tgt_dev *, struct ppa_addr,
+                              int, struct nvm_chk_meta *);
+extern int nvm_set_chunk_meta(struct nvm_tgt_dev *, struct ppa_addr *,
                               int, int);
 extern int nvm_submit_io(struct nvm_tgt_dev *, struct nvm_rq *);
 extern int nvm_submit_io_sync(struct nvm_tgt_dev *, struct nvm_rq *);
 extern void nvm_end_io(struct nvm_rq *);
-extern int nvm_bb_tbl_fold(struct nvm_dev *, u8 *, int);
-extern int nvm_get_tgt_bb_tbl(struct nvm_tgt_dev *, struct ppa_addr, u8 *);
 
 #else /* CONFIG_NVM */
 struct nvm_dev_ops;
diff --git a/include/linux/linkage.h b/include/linux/linkage.h
index d7618c41f74c..7c47b1a471d4 100644
--- a/include/linux/linkage.h
+++ b/include/linux/linkage.h
@@ -90,6 +90,7 @@
 #ifndef WEAK
 #define WEAK(name)         \
         .weak name ASM_NL   \
+        ALIGN ASM_NL \
         name:
 #endif
 
diff --git a/include/linux/linkmode.h b/include/linux/linkmode.h
new file mode 100644
index 000000000000..22443d7fb5cd
--- /dev/null
+++ b/include/linux/linkmode.h
@@ -0,0 +1,76 @@
+#ifndef __LINKMODE_H
+#define __LINKMODE_H
+
+#include <linux/bitmap.h>
+#include <linux/ethtool.h>
+#include <uapi/linux/ethtool.h>
+
+static inline void linkmode_zero(unsigned long *dst)
+{
+        bitmap_zero(dst, __ETHTOOL_LINK_MODE_MASK_NBITS);
+}
+
+static inline void linkmode_copy(unsigned long *dst, const unsigned long *src)
+{
+        bitmap_copy(dst, src, __ETHTOOL_LINK_MODE_MASK_NBITS);
+}
+
+static inline void linkmode_and(unsigned long *dst, const unsigned long *a,
+                                const unsigned long *b)
+{
+        bitmap_and(dst, a, b, __ETHTOOL_LINK_MODE_MASK_NBITS);
+}
+
+static inline void linkmode_or(unsigned long *dst, const unsigned long *a,
+                                const unsigned long *b)
+{
+        bitmap_or(dst, a, b, __ETHTOOL_LINK_MODE_MASK_NBITS);
+}
+
+static inline bool linkmode_empty(const unsigned long *src)
+{
+        return bitmap_empty(src, __ETHTOOL_LINK_MODE_MASK_NBITS);
+}
+
+static inline int linkmode_andnot(unsigned long *dst, const unsigned long *src1,
+                                  const unsigned long *src2)
+{
+        return bitmap_andnot(dst, src1, src2,  __ETHTOOL_LINK_MODE_MASK_NBITS);
+}
+
+static inline void linkmode_set_bit(int nr, volatile unsigned long *addr)
+{
+        __set_bit(nr, addr);
+}
+
+static inline void linkmode_set_bit_array(const int *array, int array_size,
+                                          unsigned long *addr)
+{
+        int i;
+
+        for (i = 0; i < array_size; i++)
+                linkmode_set_bit(array[i], addr);
+}
+
+static inline void linkmode_clear_bit(int nr, volatile unsigned long *addr)
+{
+        __clear_bit(nr, addr);
+}
+
+static inline void linkmode_change_bit(int nr, volatile unsigned long *addr)
+{
+        __change_bit(nr, addr);
+}
+
+static inline int linkmode_test_bit(int nr, volatile unsigned long *addr)
+{
+        return test_bit(nr, addr);
+}
+
+static inline int linkmode_equal(const unsigned long *src1,
+                                 const unsigned long *src2)
+{
+        return bitmap_equal(src1, src2, __ETHTOOL_LINK_MODE_MASK_NBITS);
+}
+
+#endif /* __LINKMODE_H */
diff --git a/include/linux/list.h b/include/linux/list.h
index de04cc5ed536..edb7628e46ed 100644
--- a/include/linux/list.h
+++ b/include/linux/list.h
@@ -184,6 +184,29 @@ static inline void list_move_tail(struct list_head *list,
 }
 
 /**
+ * list_bulk_move_tail - move a subsection of a list to its tail
+ * @head: the head that will follow our entry
+ * @first: first entry to move
+ * @last: last entry to move, can be the same as first
+ *
+ * Move all entries between @first and including @last before @head.
+ * All three entries must belong to the same linked list.
+ */
+static inline void list_bulk_move_tail(struct list_head *head,
+                                       struct list_head *first,
+                                       struct list_head *last)
+{
+        first->prev->next = last->next;
+        last->next->prev = first->prev;
+
+        head->prev->next = first;
+        first->prev = head->prev;
+
+        last->next = head;
+        head->prev = last;
+}
+
+/**
  * list_is_last - tests whether @list is the last entry in list @head
  * @list: the entry to test
  * @head: the head of the list
diff --git a/include/linux/lockdep.h b/include/linux/lockdep.h
index b0d0b51c4d85..1fd82ff99c65 100644
--- a/include/linux/lockdep.h
+++ b/include/linux/lockdep.h
@@ -99,13 +99,8 @@ struct lock_class {
          */
         unsigned int                    version;
 
-        /*
-         * Statistics counter:
-         */
-        unsigned long                   ops;
-
-        const char                      *name;
         int                             name_version;
+        const char                      *name;
 
 #ifdef CONFIG_LOCK_STAT
         unsigned long                   contention_point[LOCKSTAT_POINTS];
diff --git a/include/linux/lsm_hooks.h b/include/linux/lsm_hooks.h
index 97a020c616ad..aaeb7fa24dc4 100644
--- a/include/linux/lsm_hooks.h
+++ b/include/linux/lsm_hooks.h
@@ -672,7 +672,7 @@
  *      Return 0 if permission is granted.
  * @task_kill:
  *      Check permission before sending signal @sig to @p.  @info can be NULL,
- *      the constant 1, or a pointer to a siginfo structure.  If @info is 1 or
+ *      the constant 1, or a pointer to a kernel_siginfo structure.  If @info is 1 or
  *      SI_FROMKERNEL(info) is true, then the signal should be viewed as coming
  *      from the kernel and should typically be permitted.
  *      SIGIO signals are handled separately by the send_sigiotask hook in
@@ -1606,7 +1606,7 @@ union security_list_options {
         int (*task_setscheduler)(struct task_struct *p);
         int (*task_getscheduler)(struct task_struct *p);
         int (*task_movememory)(struct task_struct *p);
-        int (*task_kill)(struct task_struct *p, struct siginfo *info,
+        int (*task_kill)(struct task_struct *p, struct kernel_siginfo *info,
                                 int sig, const struct cred *cred);
         int (*task_prctl)(int option, unsigned long arg2, unsigned long arg3,
                                 unsigned long arg4, unsigned long arg5);
@@ -2039,6 +2039,18 @@ extern char *lsm_names;
 extern void security_add_hooks(struct security_hook_list *hooks, int count,
                                 char *lsm);
 
+struct lsm_info {
+        const char *name;       /* Required. */
+        int (*init)(void);      /* Required. */
+};
+
+extern struct lsm_info __start_lsm_info[], __end_lsm_info[];
+
+#define DEFINE_LSM(lsm)                                                 \
+        static struct lsm_info __lsm_##lsm                              \
+                __used __section(.lsm_info.init)                        \
+                __aligned(sizeof(unsigned long))
+
 #ifdef CONFIG_SECURITY_SELINUX_DISABLE
 /*
  * Assuring the safety of deleting a security module is up to
diff --git a/include/linux/math64.h b/include/linux/math64.h
index 837f2f2d1d34..bb2c84afb80c 100644
--- a/include/linux/math64.h
+++ b/include/linux/math64.h
@@ -281,4 +281,7 @@ static inline u64 mul_u64_u32_div(u64 a, u32 mul, u32 divisor)
 }
 #endif /* mul_u64_u32_div */
 
+#define DIV64_U64_ROUND_UP(ll, d)       \
+        ({ u64 _tmp = (d); div64_u64((ll) + _tmp - 1, _tmp); })
+
 #endif /* _LINUX_MATH64_H */
diff --git a/include/linux/memblock.h b/include/linux/memblock.h
index 516920549378..2acdd046df2d 100644
--- a/include/linux/memblock.h
+++ b/include/linux/memblock.h
@@ -265,21 +265,6 @@ void __next_mem_pfn_range(int *idx, int nid, unsigned long *out_start_pfn,
         for_each_mem_range_rev(i, &memblock.memory, &memblock.reserved, \
                                nid, flags, p_start, p_end, p_nid)
 
-/**
- * for_each_resv_unavail_range - iterate through reserved and unavailable memory
- * @i: u64 used as loop variable
- * @p_start: ptr to phys_addr_t for start address of the range, can be %NULL
- * @p_end: ptr to phys_addr_t for end address of the range, can be %NULL
- *
- * Walks over unavailable but reserved (reserved && !memory) areas of memblock.
- * Available as soon as memblock is initialized.
- * Note: because this memory does not belong to any physical node, flags and
- * nid arguments do not make sense and thus not exported as arguments.
- */
-#define for_each_resv_unavail_range(i, p_start, p_end)                  \
-        for_each_mem_range(i, &memblock.reserved, &memblock.memory,     \
-                           NUMA_NO_NODE, MEMBLOCK_NONE, p_start, p_end, NULL)
-
 static inline void memblock_set_region_flags(struct memblock_region *r,
                                              enum memblock_flags flags)
 {
diff --git a/include/linux/memcontrol.h b/include/linux/memcontrol.h
index 652f602167df..7ab2120155a4 100644
--- a/include/linux/memcontrol.h
+++ b/include/linux/memcontrol.h
@@ -78,7 +78,7 @@ struct mem_cgroup_reclaim_cookie {
 
 struct mem_cgroup_id {
         int id;
-        atomic_t ref;
+        refcount_t ref;
 };
 
 /*
@@ -1268,10 +1268,11 @@ struct kmem_cache *memcg_kmem_get_cache(struct kmem_cache *cachep);
 void memcg_kmem_put_cache(struct kmem_cache *cachep);
 int memcg_kmem_charge_memcg(struct page *page, gfp_t gfp, int order,
                             struct mem_cgroup *memcg);
+
+#ifdef CONFIG_MEMCG_KMEM
 int memcg_kmem_charge(struct page *page, gfp_t gfp, int order);
 void memcg_kmem_uncharge(struct page *page, int order);
 
-#ifdef CONFIG_MEMCG_KMEM
 extern struct static_key_false memcg_kmem_enabled_key;
 extern struct workqueue_struct *memcg_kmem_cache_wq;
 
@@ -1307,6 +1308,16 @@ extern int memcg_expand_shrinker_maps(int new_id);
 extern void memcg_set_shrinker_bit(struct mem_cgroup *memcg,
                                    int nid, int shrinker_id);
 #else
+
+static inline int memcg_kmem_charge(struct page *page, gfp_t gfp, int order)
+{
+        return 0;
+}
+
+static inline void memcg_kmem_uncharge(struct page *page, int order)
+{
+}
+
 #define for_each_memcg_cache_index(_idx)        \
         for (; NULL; )
 
diff --git a/include/linux/memremap.h b/include/linux/memremap.h
index f91f9e763557..0ac69ddf5fc4 100644
--- a/include/linux/memremap.h
+++ b/include/linux/memremap.h
@@ -53,11 +53,16 @@ struct vmem_altmap {
  * 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).
+ *
+ * MEMORY_DEVICE_PCI_P2PDMA:
+ * Device memory residing in a PCI BAR intended for use with Peer-to-Peer
+ * transactions.
  */
 enum memory_type {
         MEMORY_DEVICE_PRIVATE = 1,
         MEMORY_DEVICE_PUBLIC,
         MEMORY_DEVICE_FS_DAX,
+        MEMORY_DEVICE_PCI_P2PDMA,
 };
 
 /*
@@ -120,6 +125,7 @@ struct dev_pagemap {
         struct device *dev;
         void *data;
         enum memory_type type;
+        u64 pci_p2pdma_bus_offset;
 };
 
 #ifdef CONFIG_ZONE_DEVICE
diff --git a/include/linux/mfd/cros_ec_commands.h b/include/linux/mfd/cros_ec_commands.h
index 6e1ab9bead28..5fd0e429f472 100644
--- a/include/linux/mfd/cros_ec_commands.h
+++ b/include/linux/mfd/cros_ec_commands.h
@@ -2132,6 +2132,7 @@ struct ec_response_get_next_event_v1 {
 /* Switches */
 #define EC_MKBP_LID_OPEN        0
 #define EC_MKBP_TABLET_MODE     1
+#define EC_MKBP_BASE_ATTACHED   2
 
 /*****************************************************************************/
 /* Temperature sensor commands */
@@ -3102,6 +3103,16 @@ struct ec_params_usb_pd_info_request {
         uint8_t port;
 } __packed;
 
+/*
+ * This command will return the number of USB PD charge port + the number
+ * of dedicated port present.
+ * EC_CMD_USB_PD_PORTS does NOT include the dedicated ports
+ */
+#define EC_CMD_CHARGE_PORT_COUNT 0x0105
+struct ec_response_charge_port_count {
+        uint8_t port_count;
+} __packed;
+
 /* Read USB-PD Device discovery info */
 #define EC_CMD_USB_PD_DISCOVERY 0x0113
 struct ec_params_usb_pd_discovery_entry {
diff --git a/include/linux/mfd/da9063/pdata.h b/include/linux/mfd/da9063/pdata.h
index 8a125701ef7b..50bed4f89c1a 100644
--- a/include/linux/mfd/da9063/pdata.h
+++ b/include/linux/mfd/da9063/pdata.h
@@ -21,7 +21,7 @@
 /*
  * Regulator configuration
  */
-/* DA9063 regulator IDs */
+/* DA9063 and DA9063L regulator IDs */
 enum {
         /* BUCKs */
         DA9063_ID_BCORE1,
@@ -37,18 +37,20 @@ enum {
         DA9063_ID_BMEM_BIO_MERGED,
         /* When two BUCKs are merged, they cannot be reused separately */
 
-        /* LDOs */
+        /* LDOs on both DA9063 and DA9063L */
+        DA9063_ID_LDO3,
+        DA9063_ID_LDO7,
+        DA9063_ID_LDO8,
+        DA9063_ID_LDO9,
+        DA9063_ID_LDO11,
+
+        /* DA9063-only LDOs */
         DA9063_ID_LDO1,
         DA9063_ID_LDO2,
-        DA9063_ID_LDO3,
         DA9063_ID_LDO4,
         DA9063_ID_LDO5,
         DA9063_ID_LDO6,
-        DA9063_ID_LDO7,
-        DA9063_ID_LDO8,
-        DA9063_ID_LDO9,
         DA9063_ID_LDO10,
-        DA9063_ID_LDO11,
 };
 
 /* Regulators platform data */
diff --git a/include/linux/mfd/ingenic-tcu.h b/include/linux/mfd/ingenic-tcu.h
new file mode 100644
index 000000000000..ab16ad283def
--- /dev/null
+++ b/include/linux/mfd/ingenic-tcu.h
@@ -0,0 +1,56 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Header file for the Ingenic JZ47xx TCU driver
+ */
+#ifndef __LINUX_MFD_INGENIC_TCU_H_
+#define __LINUX_MFD_INGENIC_TCU_H_
+
+#include <linux/bitops.h>
+
+#define TCU_REG_WDT_TDR         0x00
+#define TCU_REG_WDT_TCER        0x04
+#define TCU_REG_WDT_TCNT        0x08
+#define TCU_REG_WDT_TCSR        0x0c
+#define TCU_REG_TER             0x10
+#define TCU_REG_TESR            0x14
+#define TCU_REG_TECR            0x18
+#define TCU_REG_TSR             0x1c
+#define TCU_REG_TFR             0x20
+#define TCU_REG_TFSR            0x24
+#define TCU_REG_TFCR            0x28
+#define TCU_REG_TSSR            0x2c
+#define TCU_REG_TMR             0x30
+#define TCU_REG_TMSR            0x34
+#define TCU_REG_TMCR            0x38
+#define TCU_REG_TSCR            0x3c
+#define TCU_REG_TDFR0           0x40
+#define TCU_REG_TDHR0           0x44
+#define TCU_REG_TCNT0           0x48
+#define TCU_REG_TCSR0           0x4c
+#define TCU_REG_OST_DR          0xe0
+#define TCU_REG_OST_CNTL        0xe4
+#define TCU_REG_OST_CNTH        0xe8
+#define TCU_REG_OST_TCSR        0xec
+#define TCU_REG_TSTR            0xf0
+#define TCU_REG_TSTSR           0xf4
+#define TCU_REG_TSTCR           0xf8
+#define TCU_REG_OST_CNTHBUF     0xfc
+
+#define TCU_TCSR_RESERVED_BITS          0x3f
+#define TCU_TCSR_PARENT_CLOCK_MASK      0x07
+#define TCU_TCSR_PRESCALE_LSB           3
+#define TCU_TCSR_PRESCALE_MASK          0x38
+
+#define TCU_TCSR_PWM_SD         BIT(9)  /* 0: Shutdown abruptly 1: gracefully */
+#define TCU_TCSR_PWM_INITL_HIGH BIT(8)  /* Sets the initial output level */
+#define TCU_TCSR_PWM_EN         BIT(7)  /* PWM pin output enable */
+
+#define TCU_WDT_TCER_TCEN       BIT(0)  /* Watchdog timer enable */
+
+#define TCU_CHANNEL_STRIDE      0x10
+#define TCU_REG_TDFRc(c)        (TCU_REG_TDFR0 + ((c) * TCU_CHANNEL_STRIDE))
+#define TCU_REG_TDHRc(c)        (TCU_REG_TDHR0 + ((c) * TCU_CHANNEL_STRIDE))
+#define TCU_REG_TCNTc(c)        (TCU_REG_TCNT0 + ((c) * TCU_CHANNEL_STRIDE))
+#define TCU_REG_TCSRc(c)        (TCU_REG_TCSR0 + ((c) * TCU_CHANNEL_STRIDE))
+
+#endif /* __LINUX_MFD_INGENIC_TCU_H_ */
diff --git a/include/linux/mfd/intel_msic.h b/include/linux/mfd/intel_msic.h
index 439a7a617bc9..317e8608cf41 100644
--- a/include/linux/mfd/intel_msic.h
+++ b/include/linux/mfd/intel_msic.h
@@ -1,12 +1,9 @@
+/* SPDX-License-Identifier: GPL-2.0 */
 /*
- * include/linux/mfd/intel_msic.h - Core interface for Intel MSIC
+ * Core interface for Intel MSIC
  *
  * Copyright (C) 2011, Intel Corporation
  * Author: Mika Westerberg <mika.westerberg@linux.intel.com>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
  */
 
 #ifndef __LINUX_MFD_INTEL_MSIC_H__
diff --git a/include/linux/mfd/intel_soc_pmic.h b/include/linux/mfd/intel_soc_pmic.h
index 5aacdb017a9f..ed1dfba5e5f9 100644
--- a/include/linux/mfd/intel_soc_pmic.h
+++ b/include/linux/mfd/intel_soc_pmic.h
@@ -1,17 +1,9 @@
+/* SPDX-License-Identifier: GPL-2.0 */
 /*
- * intel_soc_pmic.h - Intel SoC PMIC Driver
+ * Intel SoC PMIC Driver
  *
  * Copyright (C) 2012-2014 Intel Corporation. All rights reserved.
  *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License 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.
- *
  * Author: Yang, Bin <bin.yang@intel.com>
  * Author: Zhu, Lejun <lejun.zhu@linux.intel.com>
  */
@@ -25,6 +17,7 @@ struct intel_soc_pmic {
         int irq;
         struct regmap *regmap;
         struct regmap_irq_chip_data *irq_chip_data;
+        struct regmap_irq_chip_data *irq_chip_data_pwrbtn;
         struct regmap_irq_chip_data *irq_chip_data_tmu;
         struct regmap_irq_chip_data *irq_chip_data_bcu;
         struct regmap_irq_chip_data *irq_chip_data_adc;
diff --git a/include/linux/mfd/intel_soc_pmic_bxtwc.h b/include/linux/mfd/intel_soc_pmic_bxtwc.h
index 0c351bc85d2d..9be566cc58c6 100644
--- a/include/linux/mfd/intel_soc_pmic_bxtwc.h
+++ b/include/linux/mfd/intel_soc_pmic_bxtwc.h
@@ -1,16 +1,8 @@
+/* SPDX-License-Identifier: GPL-2.0 */
 /*
  * Header file for Intel Broxton Whiskey Cove PMIC
  *
  * Copyright (C) 2015 Intel Corporation. All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify it
- * under the terms and conditions of the GNU General Public License,
- * version 2, as published by the Free Software Foundation.
- *
- * This program is distributed in the hope 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 __INTEL_BXTWC_H__
diff --git a/include/linux/mfd/madera/core.h b/include/linux/mfd/madera/core.h
index c332681848ef..fe69c0f4398f 100644
--- a/include/linux/mfd/madera/core.h
+++ b/include/linux/mfd/madera/core.h
@@ -148,6 +148,7 @@ struct snd_soc_dapm_context;
  * @internal_dcvdd:     true if DCVDD is supplied from the internal LDO1
  * @pdata:              our pdata
  * @irq_dev:            the irqchip child driver device
+ * @irq_data:           pointer to irqchip data for the child irqchip driver
  * @irq:                host irq number from SPI or I2C configuration
  * @out_clamp:          indicates output clamp state for each analogue output
  * @out_shorted:        indicates short circuit state for each analogue output
@@ -175,6 +176,7 @@ struct madera {
         struct madera_pdata pdata;
 
         struct device *irq_dev;
+        struct regmap_irq_chip_data *irq_data;
         int irq;
 
         unsigned int num_micbias;
diff --git a/include/linux/mfd/madera/pdata.h b/include/linux/mfd/madera/pdata.h
index 0b311f39c8f4..8dc852402dbb 100644
--- a/include/linux/mfd/madera/pdata.h
+++ b/include/linux/mfd/madera/pdata.h
@@ -24,7 +24,6 @@
 
 struct gpio_desc;
 struct pinctrl_map;
-struct madera_irqchip_pdata;
 struct madera_codec_pdata;
 
 /**
diff --git a/include/linux/mfd/max14577-private.h b/include/linux/mfd/max14577-private.h
index df75234f979d..a21374f8ad26 100644
--- a/include/linux/mfd/max14577-private.h
+++ b/include/linux/mfd/max14577-private.h
@@ -1,19 +1,10 @@
+/* SPDX-License-Identifier: GPL-2.0+ */
 /*
  * max14577-private.h - Common API for the Maxim 14577/77836 internal sub chip
  *
  * Copyright (C) 2014 Samsung Electrnoics
  * Chanwoo Choi <cw00.choi@samsung.com>
  * Krzysztof Kozlowski <krzk@kernel.org>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * 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 __MAX14577_PRIVATE_H__
diff --git a/include/linux/mfd/max14577.h b/include/linux/mfd/max14577.h
index d81b52bb8bee..8b3ef891ba42 100644
--- a/include/linux/mfd/max14577.h
+++ b/include/linux/mfd/max14577.h
@@ -1,3 +1,4 @@
+/* SPDX-License-Identifier: GPL-2.0+ */
 /*
  * max14577.h - Driver for the Maxim 14577/77836
  *
@@ -5,16 +6,6 @@
  * Chanwoo Choi <cw00.choi@samsung.com>
  * Krzysztof Kozlowski <krzk@kernel.org>
  *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * 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.
- *
  * This driver is based on max8997.h
  *
  * MAX14577 has MUIC, Charger devices.
diff --git a/include/linux/mfd/max77686-private.h b/include/linux/mfd/max77686-private.h
index 643dae777b43..833e578e051e 100644
--- a/include/linux/mfd/max77686-private.h
+++ b/include/linux/mfd/max77686-private.h
@@ -1,22 +1,9 @@
+/* SPDX-License-Identifier: GPL-2.0+ */
 /*
  * max77686-private.h - Voltage regulator driver for the Maxim 77686/802
  *
  *  Copyright (C) 2012 Samsung Electrnoics
  *  Chiwoong Byun <woong.byun@samsung.com>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * 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 __LINUX_MFD_MAX77686_PRIV_H
diff --git a/include/linux/mfd/max77686.h b/include/linux/mfd/max77686.h
index d4b72d519115..d0fb510875e6 100644
--- a/include/linux/mfd/max77686.h
+++ b/include/linux/mfd/max77686.h
@@ -1,23 +1,10 @@
+/* SPDX-License-Identifier: GPL-2.0+ */
 /*
  * max77686.h - Driver for the Maxim 77686/802
  *
  *  Copyright (C) 2012 Samsung Electrnoics
  *  Chiwoong Byun <woong.byun@samsung.com>
  *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * 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
- *
  * This driver is based on max8997.h
  *
  * MAX77686 has PMIC, RTC devices.
diff --git a/include/linux/mfd/max77693-common.h b/include/linux/mfd/max77693-common.h
index 095b121aa725..a5bce099f1ed 100644
--- a/include/linux/mfd/max77693-common.h
+++ b/include/linux/mfd/max77693-common.h
@@ -1,12 +1,8 @@
+/* SPDX-License-Identifier: GPL-2.0+ */
 /*
  * Common data shared between Maxim 77693 and 77843 drivers
  *
  * Copyright (C) 2015 Samsung Electronics
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
  */
 
 #ifndef __LINUX_MFD_MAX77693_COMMON_H
diff --git a/include/linux/mfd/max77693-private.h b/include/linux/mfd/max77693-private.h
index 3c7a63b98ad6..e798c81aec31 100644
--- a/include/linux/mfd/max77693-private.h
+++ b/include/linux/mfd/max77693-private.h
@@ -1,3 +1,4 @@
+/* SPDX-License-Identifier: GPL-2.0+ */
 /*
  * max77693-private.h - Voltage regulator driver for the Maxim 77693
  *
@@ -5,20 +6,6 @@
  *  SangYoung Son <hello.son@samsung.com>
  *
  * This program is not provided / owned by Maxim Integrated Products.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  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 __LINUX_MFD_MAX77693_PRIV_H
diff --git a/include/linux/mfd/max77693.h b/include/linux/mfd/max77693.h
index d450f687301b..c67c16ba8649 100644
--- a/include/linux/mfd/max77693.h
+++ b/include/linux/mfd/max77693.h
@@ -1,3 +1,4 @@
+/* SPDX-License-Identifier: GPL-2.0+ */
 /*
  * max77693.h - Driver for the Maxim 77693
  *
@@ -6,20 +7,6 @@
  *
  * This program is not provided / owned by Maxim Integrated Products.
  *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  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
- *
  * This driver is based on max8997.h
  *
  * MAX77693 has PMIC, Charger, Flash LED, Haptic, MUIC devices.
diff --git a/include/linux/mfd/max77843-private.h b/include/linux/mfd/max77843-private.h
index b8908bf8d315..0bc7454c4dbe 100644
--- a/include/linux/mfd/max77843-private.h
+++ b/include/linux/mfd/max77843-private.h
@@ -1,14 +1,10 @@
+/* SPDX-License-Identifier: GPL-2.0+ */
 /*
  * Common variables for the Maxim MAX77843 driver
  *
  * Copyright (C) 2015 Samsung Electronics
  * Author: Jaewon Kim <jaewon02.kim@samsung.com>
  * Author: Beomho Seo <beomho.seo@samsung.com>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
  */
 
 #ifndef __MAX77843_PRIVATE_H_
diff --git a/include/linux/mfd/max8997-private.h b/include/linux/mfd/max8997-private.h
index 78c76cd4d37b..a10cd6945232 100644
--- a/include/linux/mfd/max8997-private.h
+++ b/include/linux/mfd/max8997-private.h
@@ -1,22 +1,9 @@
+/* SPDX-License-Identifier: GPL-2.0+ */
 /*
  * max8997-private.h - Voltage regulator driver for the Maxim 8997
  *
  *  Copyright (C) 2010 Samsung Electrnoics
  *  MyungJoo Ham <myungjoo.ham@samsung.com>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * 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 __LINUX_MFD_MAX8997_PRIV_H
diff --git a/include/linux/mfd/max8997.h b/include/linux/mfd/max8997.h
index cf815577bd68..e955e2f0a2cc 100644
--- a/include/linux/mfd/max8997.h
+++ b/include/linux/mfd/max8997.h
@@ -1,23 +1,10 @@
+/* SPDX-License-Identifier: GPL-2.0+ */
 /*
  * max8997.h - Driver for the Maxim 8997/8966
  *
  *  Copyright (C) 2009-2010 Samsung Electrnoics
  *  MyungJoo Ham <myungjoo.ham@samsung.com>
  *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * 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
- *
  * This driver is based on max8998.h
  *
  * MAX8997 has PMIC, MUIC, HAPTIC, RTC, FLASH, and Fuel Gauge devices.
@@ -178,7 +165,6 @@ struct max8997_led_platform_data {
 struct max8997_platform_data {
         /* IRQ */
         int ono;
-        int wakeup;
 
         /* ---- PMIC ---- */
         struct max8997_regulator_data *regulators;
diff --git a/include/linux/mfd/max8998-private.h b/include/linux/mfd/max8998-private.h
index d68ada502ff3..6deb5f577602 100644
--- a/include/linux/mfd/max8998-private.h
+++ b/include/linux/mfd/max8998-private.h
@@ -1,23 +1,10 @@
+/* SPDX-License-Identifier: GPL-2.0+ */
 /*
  * max8998-private.h - Voltage regulator driver for the Maxim 8998
  *
  *  Copyright (C) 2009-2010 Samsung Electrnoics
  *  Kyungmin Park <kyungmin.park@samsung.com>
  *  Marek Szyprowski <m.szyprowski@samsung.com>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * 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 __LINUX_MFD_MAX8998_PRIV_H
diff --git a/include/linux/mfd/max8998.h b/include/linux/mfd/max8998.h
index e3956a654cbc..061af220dcd3 100644
--- a/include/linux/mfd/max8998.h
+++ b/include/linux/mfd/max8998.h
@@ -1,23 +1,10 @@
+/* SPDX-License-Identifier: GPL-2.0+ */
 /*
  * max8998.h - Voltage regulator driver for the Maxim 8998
  *
  *  Copyright (C) 2009-2010 Samsung Electrnoics
  *  Kyungmin Park <kyungmin.park@samsung.com>
  *  Marek Szyprowski <m.szyprowski@samsung.com>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * 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 __LINUX_MFD_MAX8998_H
diff --git a/include/linux/mfd/mc13xxx.h b/include/linux/mfd/mc13xxx.h
index 54a3cd808f9e..2ad9bdc0a5ec 100644
--- a/include/linux/mfd/mc13xxx.h
+++ b/include/linux/mfd/mc13xxx.h
@@ -249,6 +249,7 @@ struct mc13xxx_platform_data {
 #define MC13XXX_ADC0_TSMOD0             (1 << 12)
 #define MC13XXX_ADC0_TSMOD1             (1 << 13)
 #define MC13XXX_ADC0_TSMOD2             (1 << 14)
+#define MC13XXX_ADC0_CHRGRAWDIV         (1 << 15)
 #define MC13XXX_ADC0_ADINC1             (1 << 16)
 #define MC13XXX_ADC0_ADINC2             (1 << 17)
 
diff --git a/include/linux/mfd/rohm-bd718x7.h b/include/linux/mfd/rohm-bd718x7.h
index a528747f8aed..fd194bfc836f 100644
--- a/include/linux/mfd/rohm-bd718x7.h
+++ b/include/linux/mfd/rohm-bd718x7.h
@@ -1,112 +1,127 @@
 /* SPDX-License-Identifier: GPL-2.0-or-later */
 /* Copyright (C) 2018 ROHM Semiconductors */
 
-#ifndef __LINUX_MFD_BD71837_H__
-#define __LINUX_MFD_BD71837_H__
+#ifndef __LINUX_MFD_BD718XX_H__
+#define __LINUX_MFD_BD718XX_H__
 
 #include <linux/regmap.h>
 
 enum {
-        BD71837_BUCK1   =       0,
-        BD71837_BUCK2,
-        BD71837_BUCK3,
-        BD71837_BUCK4,
-        BD71837_BUCK5,
-        BD71837_BUCK6,
-        BD71837_BUCK7,
-        BD71837_BUCK8,
-        BD71837_LDO1,
-        BD71837_LDO2,
-        BD71837_LDO3,
-        BD71837_LDO4,
-        BD71837_LDO5,
-        BD71837_LDO6,
-        BD71837_LDO7,
-        BD71837_REGULATOR_CNT,
+        BD718XX_TYPE_BD71837 = 0,
+        BD718XX_TYPE_BD71847,
+        BD718XX_TYPE_AMOUNT
 };
 
-#define BD71837_BUCK1_VOLTAGE_NUM       0x40
-#define BD71837_BUCK2_VOLTAGE_NUM       0x40
-#define BD71837_BUCK3_VOLTAGE_NUM       0x40
-#define BD71837_BUCK4_VOLTAGE_NUM       0x40
+enum {
+        BD718XX_BUCK1 = 0,
+        BD718XX_BUCK2,
+        BD718XX_BUCK3,
+        BD718XX_BUCK4,
+        BD718XX_BUCK5,
+        BD718XX_BUCK6,
+        BD718XX_BUCK7,
+        BD718XX_BUCK8,
+        BD718XX_LDO1,
+        BD718XX_LDO2,
+        BD718XX_LDO3,
+        BD718XX_LDO4,
+        BD718XX_LDO5,
+        BD718XX_LDO6,
+        BD718XX_LDO7,
+        BD718XX_REGULATOR_AMOUNT,
+};
+
+/* Common voltage configurations */
+#define BD718XX_DVS_BUCK_VOLTAGE_NUM            0x3D
+#define BD718XX_4TH_NODVS_BUCK_VOLTAGE_NUM      0x3D
+
+#define BD718XX_LDO1_VOLTAGE_NUM        0x08
+#define BD718XX_LDO2_VOLTAGE_NUM        0x02
+#define BD718XX_LDO3_VOLTAGE_NUM        0x10
+#define BD718XX_LDO4_VOLTAGE_NUM        0x0A
+#define BD718XX_LDO6_VOLTAGE_NUM        0x0A
 
-#define BD71837_BUCK5_VOLTAGE_NUM       0x08
+/* BD71837 specific voltage configurations */
+#define BD71837_BUCK5_VOLTAGE_NUM       0x10
 #define BD71837_BUCK6_VOLTAGE_NUM       0x04
 #define BD71837_BUCK7_VOLTAGE_NUM       0x08
-#define BD71837_BUCK8_VOLTAGE_NUM       0x40
-
-#define BD71837_LDO1_VOLTAGE_NUM        0x04
-#define BD71837_LDO2_VOLTAGE_NUM        0x02
-#define BD71837_LDO3_VOLTAGE_NUM        0x10
-#define BD71837_LDO4_VOLTAGE_NUM        0x10
 #define BD71837_LDO5_VOLTAGE_NUM        0x10
-#define BD71837_LDO6_VOLTAGE_NUM        0x10
 #define BD71837_LDO7_VOLTAGE_NUM        0x10
 
+/* BD71847 specific voltage configurations */
+#define BD71847_BUCK3_VOLTAGE_NUM       0x18
+#define BD71847_BUCK4_VOLTAGE_NUM       0x08
+#define BD71847_LDO5_VOLTAGE_NUM        0x20
+
+/* Registers specific to BD71837 */
+enum {
+        BD71837_REG_BUCK3_CTRL =        0x07,
+        BD71837_REG_BUCK4_CTRL =        0x08,
+        BD71837_REG_BUCK3_VOLT_RUN =    0x12,
+        BD71837_REG_BUCK4_VOLT_RUN =    0x13,
+        BD71837_REG_LDO7_VOLT =         0x1E,
+};
+
+/* Registers common for BD71837 and BD71847 */
 enum {
-        BD71837_REG_REV                = 0x00,
-        BD71837_REG_SWRESET            = 0x01,
-        BD71837_REG_I2C_DEV            = 0x02,
-        BD71837_REG_PWRCTRL0           = 0x03,
-        BD71837_REG_PWRCTRL1           = 0x04,
-        BD71837_REG_BUCK1_CTRL         = 0x05,
-        BD71837_REG_BUCK2_CTRL         = 0x06,
-        BD71837_REG_BUCK3_CTRL         = 0x07,
-        BD71837_REG_BUCK4_CTRL         = 0x08,
-        BD71837_REG_BUCK5_CTRL         = 0x09,
-        BD71837_REG_BUCK6_CTRL         = 0x0A,
-        BD71837_REG_BUCK7_CTRL         = 0x0B,
-        BD71837_REG_BUCK8_CTRL         = 0x0C,
-        BD71837_REG_BUCK1_VOLT_RUN     = 0x0D,
-        BD71837_REG_BUCK1_VOLT_IDLE    = 0x0E,
-        BD71837_REG_BUCK1_VOLT_SUSP    = 0x0F,
-        BD71837_REG_BUCK2_VOLT_RUN     = 0x10,
-        BD71837_REG_BUCK2_VOLT_IDLE    = 0x11,
-        BD71837_REG_BUCK3_VOLT_RUN     = 0x12,
-        BD71837_REG_BUCK4_VOLT_RUN     = 0x13,
-        BD71837_REG_BUCK5_VOLT         = 0x14,
-        BD71837_REG_BUCK6_VOLT         = 0x15,
-        BD71837_REG_BUCK7_VOLT         = 0x16,
-        BD71837_REG_BUCK8_VOLT         = 0x17,
-        BD71837_REG_LDO1_VOLT          = 0x18,
-        BD71837_REG_LDO2_VOLT          = 0x19,
-        BD71837_REG_LDO3_VOLT          = 0x1A,
-        BD71837_REG_LDO4_VOLT          = 0x1B,
-        BD71837_REG_LDO5_VOLT          = 0x1C,
-        BD71837_REG_LDO6_VOLT          = 0x1D,
-        BD71837_REG_LDO7_VOLT          = 0x1E,
-        BD71837_REG_TRANS_COND0        = 0x1F,
-        BD71837_REG_TRANS_COND1        = 0x20,
-        BD71837_REG_VRFAULTEN          = 0x21,
-        BD71837_REG_MVRFLTMASK0        = 0x22,
-        BD71837_REG_MVRFLTMASK1        = 0x23,
-        BD71837_REG_MVRFLTMASK2        = 0x24,
-        BD71837_REG_RCVCFG             = 0x25,
-        BD71837_REG_RCVNUM             = 0x26,
-        BD71837_REG_PWRONCONFIG0       = 0x27,
-        BD71837_REG_PWRONCONFIG1       = 0x28,
-        BD71837_REG_RESETSRC           = 0x29,
-        BD71837_REG_MIRQ               = 0x2A,
-        BD71837_REG_IRQ                = 0x2B,
-        BD71837_REG_IN_MON             = 0x2C,
-        BD71837_REG_POW_STATE          = 0x2D,
-        BD71837_REG_OUT32K             = 0x2E,
-        BD71837_REG_REGLOCK            = 0x2F,
-        BD71837_REG_OTPVER             = 0xFF,
-        BD71837_MAX_REGISTER           = 0x100,
+        BD718XX_REG_REV =                       0x00,
+        BD718XX_REG_SWRESET =                   0x01,
+        BD718XX_REG_I2C_DEV =                   0x02,
+        BD718XX_REG_PWRCTRL0 =                  0x03,
+        BD718XX_REG_PWRCTRL1 =                  0x04,
+        BD718XX_REG_BUCK1_CTRL =                0x05,
+        BD718XX_REG_BUCK2_CTRL =                0x06,
+        BD718XX_REG_1ST_NODVS_BUCK_CTRL =       0x09,
+        BD718XX_REG_2ND_NODVS_BUCK_CTRL =       0x0A,
+        BD718XX_REG_3RD_NODVS_BUCK_CTRL =       0x0B,
+        BD718XX_REG_4TH_NODVS_BUCK_CTRL =       0x0C,
+        BD718XX_REG_BUCK1_VOLT_RUN =            0x0D,
+        BD718XX_REG_BUCK1_VOLT_IDLE =           0x0E,
+        BD718XX_REG_BUCK1_VOLT_SUSP =           0x0F,
+        BD718XX_REG_BUCK2_VOLT_RUN =            0x10,
+        BD718XX_REG_BUCK2_VOLT_IDLE =           0x11,
+        BD718XX_REG_1ST_NODVS_BUCK_VOLT =       0x14,
+        BD718XX_REG_2ND_NODVS_BUCK_VOLT =       0x15,
+        BD718XX_REG_3RD_NODVS_BUCK_VOLT =       0x16,
+        BD718XX_REG_4TH_NODVS_BUCK_VOLT =       0x17,
+        BD718XX_REG_LDO1_VOLT =                 0x18,
+        BD718XX_REG_LDO2_VOLT =                 0x19,
+        BD718XX_REG_LDO3_VOLT =                 0x1A,
+        BD718XX_REG_LDO4_VOLT =                 0x1B,
+        BD718XX_REG_LDO5_VOLT =                 0x1C,
+        BD718XX_REG_LDO6_VOLT =                 0x1D,
+        BD718XX_REG_TRANS_COND0 =               0x1F,
+        BD718XX_REG_TRANS_COND1 =               0x20,
+        BD718XX_REG_VRFAULTEN =                 0x21,
+        BD718XX_REG_MVRFLTMASK0 =               0x22,
+        BD718XX_REG_MVRFLTMASK1 =               0x23,
+        BD718XX_REG_MVRFLTMASK2 =               0x24,
+        BD718XX_REG_RCVCFG =                    0x25,
+        BD718XX_REG_RCVNUM =                    0x26,
+        BD718XX_REG_PWRONCONFIG0 =              0x27,
+        BD718XX_REG_PWRONCONFIG1 =              0x28,
+        BD718XX_REG_RESETSRC =                  0x29,
+        BD718XX_REG_MIRQ =                      0x2A,
+        BD718XX_REG_IRQ =                       0x2B,
+        BD718XX_REG_IN_MON =                    0x2C,
+        BD718XX_REG_POW_STATE =                 0x2D,
+        BD718XX_REG_OUT32K =                    0x2E,
+        BD718XX_REG_REGLOCK =                   0x2F,
+        BD718XX_REG_OTPVER =                    0xFF,
+        BD718XX_MAX_REGISTER =                  0x100,
 };
 
 #define REGLOCK_PWRSEQ  0x1
 #define REGLOCK_VREG    0x10
 
 /* Generic BUCK control masks */
-#define BD71837_BUCK_SEL        0x02
-#define BD71837_BUCK_EN         0x01
-#define BD71837_BUCK_RUN_ON     0x04
+#define BD718XX_BUCK_SEL        0x02
+#define BD718XX_BUCK_EN         0x01
+#define BD718XX_BUCK_RUN_ON     0x04
 
 /* Generic LDO masks */
-#define BD71837_LDO_SEL         0x80
-#define BD71837_LDO_EN          0x40
+#define BD718XX_LDO_SEL         0x80
+#define BD718XX_LDO_EN          0x40
 
 /* BD71837 BUCK ramp rate CTRL reg bits */
 #define BUCK_RAMPRATE_MASK      0xC0
@@ -115,51 +130,64 @@ enum {
 #define BUCK_RAMPRATE_2P50MV    0x2
 #define BUCK_RAMPRATE_1P25MV    0x3
 
-/* BD71837_REG_BUCK1_VOLT_RUN bits */
-#define BUCK1_RUN_MASK          0x3F
-#define BUCK1_RUN_DEFAULT       0x14
-
-/* BD71837_REG_BUCK1_VOLT_SUSP bits */
-#define BUCK1_SUSP_MASK         0x3F
-#define BUCK1_SUSP_DEFAULT      0x14
-
-/* BD71837_REG_BUCK1_VOLT_IDLE bits */
-#define BUCK1_IDLE_MASK         0x3F
-#define BUCK1_IDLE_DEFAULT      0x14
-
-/* BD71837_REG_BUCK2_VOLT_RUN bits */
-#define BUCK2_RUN_MASK          0x3F
-#define BUCK2_RUN_DEFAULT       0x1E
-
-/* BD71837_REG_BUCK2_VOLT_IDLE bits */
-#define BUCK2_IDLE_MASK         0x3F
-#define BUCK2_IDLE_DEFAULT      0x14
-
-/* BD71837_REG_BUCK3_VOLT_RUN bits */
-#define BUCK3_RUN_MASK          0x3F
-#define BUCK3_RUN_DEFAULT       0x1E
-
-/* BD71837_REG_BUCK4_VOLT_RUN bits */
-#define BUCK4_RUN_MASK          0x3F
-#define BUCK4_RUN_DEFAULT       0x1E
-
-/* BD71837_REG_BUCK5_VOLT bits */
-#define BUCK5_MASK              0x07
-#define BUCK5_DEFAULT           0x02
-
-/* BD71837_REG_BUCK6_VOLT bits */
-#define BUCK6_MASK              0x03
-#define BUCK6_DEFAULT           0x03
-
-/* BD71837_REG_BUCK7_VOLT bits */
-#define BUCK7_MASK              0x07
-#define BUCK7_DEFAULT           0x03
-
-/* BD71837_REG_BUCK8_VOLT bits */
-#define BUCK8_MASK              0x3F
-#define BUCK8_DEFAULT           0x1E
-
-/* BD71837_REG_IRQ bits */
+#define DVS_BUCK_RUN_MASK       0x3F
+#define DVS_BUCK_SUSP_MASK      0x3F
+#define DVS_BUCK_IDLE_MASK      0x3F
+
+#define BD718XX_1ST_NODVS_BUCK_MASK     0x07
+#define BD718XX_3RD_NODVS_BUCK_MASK     0x07
+#define BD718XX_4TH_NODVS_BUCK_MASK     0x3F
+
+#define BD71847_BUCK3_MASK              0x07
+#define BD71847_BUCK3_RANGE_MASK        0xC0
+#define BD71847_BUCK4_MASK              0x03
+#define BD71847_BUCK4_RANGE_MASK        0x40
+
+#define BD71837_BUCK5_MASK              0x07
+#define BD71837_BUCK5_RANGE_MASK        0x80
+#define BD71837_BUCK6_MASK              0x03
+
+#define BD718XX_LDO1_MASK               0x03
+#define BD718XX_LDO1_RANGE_MASK         0x20
+#define BD718XX_LDO2_MASK               0x20
+#define BD718XX_LDO3_MASK               0x0F
+#define BD718XX_LDO4_MASK               0x0F
+#define BD718XX_LDO6_MASK               0x0F
+
+#define BD71837_LDO5_MASK               0x0F
+#define BD71847_LDO5_MASK               0x0F
+#define BD71847_LDO5_RANGE_MASK         0x20
+
+#define BD71837_LDO7_MASK               0x0F
+
+/* BD718XX Voltage monitoring masks */
+#define BD718XX_BUCK1_VRMON80           0x1
+#define BD718XX_BUCK1_VRMON130          0x2
+#define BD718XX_BUCK2_VRMON80           0x4
+#define BD718XX_BUCK2_VRMON130          0x8
+#define BD718XX_1ST_NODVS_BUCK_VRMON80  0x1
+#define BD718XX_1ST_NODVS_BUCK_VRMON130 0x2
+#define BD718XX_2ND_NODVS_BUCK_VRMON80  0x4
+#define BD718XX_2ND_NODVS_BUCK_VRMON130 0x8
+#define BD718XX_3RD_NODVS_BUCK_VRMON80  0x10
+#define BD718XX_3RD_NODVS_BUCK_VRMON130 0x20
+#define BD718XX_4TH_NODVS_BUCK_VRMON80  0x40
+#define BD718XX_4TH_NODVS_BUCK_VRMON130 0x80
+#define BD718XX_LDO1_VRMON80            0x1
+#define BD718XX_LDO2_VRMON80            0x2
+#define BD718XX_LDO3_VRMON80            0x4
+#define BD718XX_LDO4_VRMON80            0x8
+#define BD718XX_LDO5_VRMON80            0x10
+#define BD718XX_LDO6_VRMON80            0x20
+
+/* BD71837 specific voltage monitoring masks */
+#define BD71837_BUCK3_VRMON80           0x10
+#define BD71837_BUCK3_VRMON130          0x20
+#define BD71837_BUCK4_VRMON80           0x40
+#define BD71837_BUCK4_VRMON130          0x80
+#define BD71837_LDO7_VRMON80            0x40
+
+/* BD718XX_REG_IRQ bits */
 #define IRQ_SWRST               0x40
 #define IRQ_PWRON_S             0x20
 #define IRQ_PWRON_L             0x10
@@ -168,52 +196,31 @@ enum {
 #define IRQ_ON_REQ              0x02
 #define IRQ_STBY_REQ            0x01
 
-/* BD71837_REG_OUT32K bits */
-#define BD71837_OUT32K_EN       0x01
+/* BD718XX_REG_OUT32K bits */
+#define BD718XX_OUT32K_EN       0x01
 
-/* BD71837 gated clock rate */
-#define BD71837_CLK_RATE 32768
+/* BD7183XX gated clock rate */
+#define BD718XX_CLK_RATE 32768
 
-/* ROHM BD71837 irqs */
+/* ROHM BD718XX irqs */
 enum {
-        BD71837_INT_STBY_REQ,
-        BD71837_INT_ON_REQ,
-        BD71837_INT_WDOG,
-        BD71837_INT_PWRBTN,
-        BD71837_INT_PWRBTN_L,
-        BD71837_INT_PWRBTN_S,
-        BD71837_INT_SWRST
+        BD718XX_INT_STBY_REQ,
+        BD718XX_INT_ON_REQ,
+        BD718XX_INT_WDOG,
+        BD718XX_INT_PWRBTN,
+        BD718XX_INT_PWRBTN_L,
+        BD718XX_INT_PWRBTN_S,
+        BD718XX_INT_SWRST
 };
 
-/* ROHM BD71837 interrupt masks */
-#define BD71837_INT_SWRST_MASK          0x40
-#define BD71837_INT_PWRBTN_S_MASK       0x20
-#define BD71837_INT_PWRBTN_L_MASK       0x10
-#define BD71837_INT_PWRBTN_MASK         0x8
-#define BD71837_INT_WDOG_MASK           0x4
-#define BD71837_INT_ON_REQ_MASK         0x2
-#define BD71837_INT_STBY_REQ_MASK       0x1
-
-/* BD71837_REG_LDO1_VOLT bits */
-#define LDO1_MASK               0x03
-
-/* BD71837_REG_LDO1_VOLT bits */
-#define LDO2_MASK               0x20
-
-/* BD71837_REG_LDO3_VOLT bits */
-#define LDO3_MASK               0x0F
-
-/* BD71837_REG_LDO4_VOLT bits */
-#define LDO4_MASK               0x0F
-
-/* BD71837_REG_LDO5_VOLT bits */
-#define LDO5_MASK               0x0F
-
-/* BD71837_REG_LDO6_VOLT bits */
-#define LDO6_MASK               0x0F
-
-/* BD71837_REG_LDO7_VOLT bits */
-#define LDO7_MASK               0x0F
+/* ROHM BD718XX interrupt masks */
+#define BD718XX_INT_SWRST_MASK          0x40
+#define BD718XX_INT_PWRBTN_S_MASK       0x20
+#define BD718XX_INT_PWRBTN_L_MASK       0x10
+#define BD718XX_INT_PWRBTN_MASK         0x8
+#define BD718XX_INT_WDOG_MASK           0x4
+#define BD718XX_INT_ON_REQ_MASK         0x2
+#define BD718XX_INT_STBY_REQ_MASK       0x1
 
 /* Register write induced reset settings */
 
@@ -223,13 +230,13 @@ enum {
  * write 1 to it we will trigger the action. So always write 0 to it when
  * changning SWRESET action - no matter what we read from it.
  */
-#define BD71837_SWRESET_TYPE_MASK       7
-#define BD71837_SWRESET_TYPE_DISABLED   0
-#define BD71837_SWRESET_TYPE_COLD       4
-#define BD71837_SWRESET_TYPE_WARM       6
+#define BD718XX_SWRESET_TYPE_MASK       7
+#define BD718XX_SWRESET_TYPE_DISABLED   0
+#define BD718XX_SWRESET_TYPE_COLD       4
+#define BD718XX_SWRESET_TYPE_WARM       6
 
-#define BD71837_SWRESET_RESET_MASK      1
-#define BD71837_SWRESET_RESET           1
+#define BD718XX_SWRESET_RESET_MASK      1
+#define BD718XX_SWRESET_RESET           1
 
 /* Poweroff state transition conditions */
 
@@ -314,10 +321,10 @@ enum {
         BD718XX_PWRBTN_LONG_PRESS_15S
 };
 
-struct bd71837_pmic;
-struct bd71837_clk;
+struct bd718xx_clk;
 
-struct bd71837 {
+struct bd718xx {
+        unsigned int chip_type;
         struct device *dev;
         struct regmap *regmap;
         unsigned long int id;
@@ -325,8 +332,7 @@ struct bd71837 {
         int chip_irq;
         struct regmap_irq_chip_data *irq_data;
 
-        struct bd71837_pmic *pmic;
-        struct bd71837_clk *clk;
+        struct bd718xx_clk *clk;
 };
 
-#endif /* __LINUX_MFD_BD71837_H__ */
+#endif /* __LINUX_MFD_BD718XX_H__ */
diff --git a/include/linux/mfd/samsung/core.h b/include/linux/mfd/samsung/core.h
index 28f4ae76271d..3ca17eb89aa2 100644
--- a/include/linux/mfd/samsung/core.h
+++ b/include/linux/mfd/samsung/core.h
@@ -1,14 +1,7 @@
+/* SPDX-License-Identifier: GPL-2.0+ */
 /*
- * core.h
- *
- * copyright (c) 2011 Samsung Electronics Co., Ltd
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd
  *              http://www.samsung.com
- *
- *  This program is free software; you can redistribute  it and/or modify it
- *  under  the terms of  the GNU General  Public License as published by the
- *  Free Software Foundation;  either version 2 of the  License, or (at your
- *  option) any later version.
- *
  */
 
 #ifndef __LINUX_MFD_SEC_CORE_H
diff --git a/include/linux/mfd/samsung/irq.h b/include/linux/mfd/samsung/irq.h
index 667aa40486dd..6cfe4201a106 100644
--- a/include/linux/mfd/samsung/irq.h
+++ b/include/linux/mfd/samsung/irq.h
@@ -1,13 +1,7 @@
-/* irq.h
- *
+/* SPDX-License-Identifier: GPL-2.0+ */
+/*
  * Copyright (c) 2012 Samsung Electronics Co., Ltd
  *              http://www.samsung.com
- *
- *  This program is free software; you can redistribute  it and/or modify it
- *  under  the terms of  the GNU General  Public License as published by the
- *  Free Software Foundation;  either version 2 of the  License, or (at your
- *  option) any later version.
- *
  */
 
 #ifndef __LINUX_MFD_SEC_IRQ_H
diff --git a/include/linux/mfd/samsung/rtc.h b/include/linux/mfd/samsung/rtc.h
index 9ed2871ea335..0204decfc9aa 100644
--- a/include/linux/mfd/samsung/rtc.h
+++ b/include/linux/mfd/samsung/rtc.h
@@ -1,18 +1,7 @@
-/* rtc.h
- *
+/* SPDX-License-Identifier: GPL-2.0+ */
+/*
  * Copyright (c) 2011-2014 Samsung Electronics Co., Ltd
  *              http://www.samsung.com
- *
- * This program is free software; you can redistribute  it and/or modify it
- * under  the terms of  the GNU General  Public License as published by the
- * Free Software Foundation;  either version 2 of the  License, or (at your
- * option) any later version.
- *
- * 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_MFD_SEC_RTC_H
diff --git a/include/linux/mfd/samsung/s2mpa01.h b/include/linux/mfd/samsung/s2mpa01.h
index 2766108bca2f..0762e9de6f2f 100644
--- a/include/linux/mfd/samsung/s2mpa01.h
+++ b/include/linux/mfd/samsung/s2mpa01.h
@@ -1,12 +1,7 @@
+/* SPDX-License-Identifier: GPL-2.0+ */
 /*
  * Copyright (c) 2013 Samsung Electronics Co., Ltd
  *              http://www.samsung.com
- *
- *  This program is free software; you can redistribute  it and/or modify it
- *  under  the terms of  the GNU General  Public License as published by the
- *  Free Software Foundation;  either version 2 of the  License, or (at your
- *  option) any later version.
- *
  */
 
 #ifndef __LINUX_MFD_S2MPA01_H
diff --git a/include/linux/mfd/samsung/s2mps11.h b/include/linux/mfd/samsung/s2mps11.h
index 2c14eeca46f0..6e7668a389a1 100644
--- a/include/linux/mfd/samsung/s2mps11.h
+++ b/include/linux/mfd/samsung/s2mps11.h
@@ -1,14 +1,7 @@
+/* SPDX-License-Identifier: GPL-2.0+ */
 /*
- * s2mps11.h
- *
  * Copyright (c) 2012 Samsung Electronics Co., Ltd
  *              http://www.samsung.com
- *
- *  This program is free software; you can redistribute  it and/or modify it
- *  under  the terms of  the GNU General  Public License as published by the
- *  Free Software Foundation;  either version 2 of the  License, or (at your
- *  option) any later version.
- *
  */
 
 #ifndef __LINUX_MFD_S2MPS11_H
diff --git a/include/linux/mfd/samsung/s2mps13.h b/include/linux/mfd/samsung/s2mps13.h
index 239e977ba45d..b96d8a11dcd3 100644
--- a/include/linux/mfd/samsung/s2mps13.h
+++ b/include/linux/mfd/samsung/s2mps13.h
@@ -1,19 +1,7 @@
+/* SPDX-License-Identifier: GPL-2.0+ */
 /*
- * s2mps13.h
- *
  * Copyright (c) 2014 Samsung Electronics Co., Ltd
  *              http://www.samsung.com
- *
- * This program is free software; you can redistribute  it and/or modify it
- * under  the terms of  the GNU General  Public License as published by the
- * Free Software Foundation;  either version 2 of the  License, or (at your
- * option) any later version.
- *
- * 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_MFD_S2MPS13_H
diff --git a/include/linux/mfd/samsung/s2mps14.h b/include/linux/mfd/samsung/s2mps14.h
index c92f4782afb5..f4afa0cfc24f 100644
--- a/include/linux/mfd/samsung/s2mps14.h
+++ b/include/linux/mfd/samsung/s2mps14.h
@@ -1,19 +1,7 @@
+/* SPDX-License-Identifier: GPL-2.0+ */
 /*
- * s2mps14.h
- *
  * Copyright (c) 2014 Samsung Electronics Co., Ltd
  *              http://www.samsung.com
- *
- * This program is free software; you can redistribute  it and/or modify it
- * under  the terms of  the GNU General  Public License as published by the
- * Free Software Foundation;  either version 2 of the  License, or (at your
- * option) any later version.
- *
- * 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_MFD_S2MPS14_H
diff --git a/include/linux/mfd/samsung/s2mps15.h b/include/linux/mfd/samsung/s2mps15.h
index 36d35287c3c0..eac6bf74b72e 100644
--- a/include/linux/mfd/samsung/s2mps15.h
+++ b/include/linux/mfd/samsung/s2mps15.h
@@ -1,16 +1,7 @@
+/* SPDX-License-Identifier: GPL-2.0+ */
 /*
  * Copyright (c) 2015 Samsung Electronics Co., Ltd
  *              http://www.samsung.com
- *
- * This program is free software; you can redistribute  it and/or modify it
- * under  the terms of  the GNU General  Public License as published by the
- * Free Software Foundation;  either version 2 of the  License, or (at your
- * option) any later version.
- *
- * 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_MFD_S2MPS15_H
diff --git a/include/linux/mfd/samsung/s2mpu02.h b/include/linux/mfd/samsung/s2mpu02.h
index 47ae9bc583a7..76cd5380cf0f 100644
--- a/include/linux/mfd/samsung/s2mpu02.h
+++ b/include/linux/mfd/samsung/s2mpu02.h
@@ -1,19 +1,7 @@
+/* SPDX-License-Identifier: GPL-2.0+ */
 /*
- * s2mpu02.h
- *
  * Copyright (c) 2014 Samsung Electronics Co., Ltd
  *              http://www.samsung.com
- *
- * This program is free software; you can redistribute  it and/or modify it
- * under  the terms of  the GNU General  Public License as published by the
- * Free Software Foundation;  either version 2 of the  License, or (at your
- * option) any later version.
- *
- * 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_MFD_S2MPU02_H
diff --git a/include/linux/mfd/samsung/s5m8763.h b/include/linux/mfd/samsung/s5m8763.h
index e025418e5589..c534f086ca16 100644
--- a/include/linux/mfd/samsung/s5m8763.h
+++ b/include/linux/mfd/samsung/s5m8763.h
@@ -1,13 +1,7 @@
-/*  s5m8763.h
- *
+/* SPDX-License-Identifier: GPL-2.0+ */
+/*
  * Copyright (c) 2011 Samsung Electronics Co., Ltd
  *              http://www.samsung.com
- *
- *  This program is free software; you can redistribute  it and/or modify it
- *  under  the terms of  the GNU General  Public License as published by the
- *  Free Software Foundation;  either version 2 of the  License, or (at your
- *  option) any later version.
- *
  */
 
 #ifndef __LINUX_MFD_S5M8763_H
diff --git a/include/linux/mfd/samsung/s5m8767.h b/include/linux/mfd/samsung/s5m8767.h
index 243b58fec33d..704f8d80e96e 100644
--- a/include/linux/mfd/samsung/s5m8767.h
+++ b/include/linux/mfd/samsung/s5m8767.h
@@ -1,13 +1,7 @@
-/*  s5m8767.h
- *
+/* SPDX-License-Identifier: GPL-2.0+ */
+/*
  * Copyright (c) 2011 Samsung Electronics Co., Ltd
  *              http://www.samsung.com
- *
- *  This program is free software; you can redistribute  it and/or modify it
- *  under  the terms of  the GNU General  Public License as published by the
- *  Free Software Foundation;  either version 2 of the  License, or (at your
- *  option) any later version.
- *
  */
 
 #ifndef __LINUX_MFD_S5M8767_H
diff --git a/include/linux/mfd/ti-lmu.h b/include/linux/mfd/ti-lmu.h
index 09d5f30384e5..1ef51ed36be5 100644
--- a/include/linux/mfd/ti-lmu.h
+++ b/include/linux/mfd/ti-lmu.h
@@ -16,6 +16,7 @@
 #include <linux/gpio.h>
 #include <linux/notifier.h>
 #include <linux/regmap.h>
+#include <linux/gpio/consumer.h>
 
 /* Notifier event */
 #define LMU_EVENT_MONITOR_DONE          0x01
@@ -81,7 +82,7 @@ enum lm363x_regulator_id {
 struct ti_lmu {
         struct device *dev;
         struct regmap *regmap;
-        int en_gpio;
+        struct gpio_desc *en_gpio;
         struct blocking_notifier_head notifier;
 };
 #endif
diff --git a/include/linux/mfd/tmio.h b/include/linux/mfd/tmio.h
index 77866214ab51..1e70060c92ce 100644
--- a/include/linux/mfd/tmio.h
+++ b/include/linux/mfd/tmio.h
@@ -62,13 +62,6 @@
 #define TMIO_MMC_USE_GPIO_CD            BIT(5)
 
 /*
- * Some controllers doesn't have over 0x100 register.
- * it is used to checking accessibility of
- * CTL_SD_CARD_CLK_CTL / CTL_CLK_AND_WAIT_CTL
- */
-#define TMIO_MMC_HAVE_HIGH_REG          BIT(6)
-
-/*
  * Some controllers have CMD12 automatically
  * issue/non-issue register
  */
diff --git a/include/linux/micrel_phy.h b/include/linux/micrel_phy.h
index 472fa4d4ea62..7361cd3fddc1 100644
--- a/include/linux/micrel_phy.h
+++ b/include/linux/micrel_phy.h
@@ -31,6 +31,7 @@
 #define PHY_ID_KSZ8081          0x00221560
 #define PHY_ID_KSZ8061          0x00221570
 #define PHY_ID_KSZ9031          0x00221620
+#define PHY_ID_KSZ9131          0x00221640
 
 #define PHY_ID_KSZ886X          0x00221430
 #define PHY_ID_KSZ8863          0x00221435
diff --git a/include/linux/mii.h b/include/linux/mii.h
index 55000ee5c6ad..2da85b02e1c0 100644
--- a/include/linux/mii.h
+++ b/include/linux/mii.h
@@ -10,6 +10,7 @@
 
 
 #include <linux/if.h>
+#include <linux/linkmode.h>
 #include <uapi/linux/mii.h>
 
 struct ethtool_cmd;
@@ -132,6 +133,34 @@ static inline u32 ethtool_adv_to_mii_adv_t(u32 ethadv)
 }
 
 /**
+ * linkmode_adv_to_mii_adv_t
+ * @advertising: the linkmode advertisement settings
+ *
+ * A small helper function that translates linkmode advertisement
+ * settings to phy autonegotiation advertisements for the
+ * MII_ADVERTISE register.
+ */
+static inline u32 linkmode_adv_to_mii_adv_t(unsigned long *advertising)
+{
+        u32 result = 0;
+
+        if (linkmode_test_bit(ETHTOOL_LINK_MODE_10baseT_Half_BIT, advertising))
+                result |= ADVERTISE_10HALF;
+        if (linkmode_test_bit(ETHTOOL_LINK_MODE_10baseT_Full_BIT, advertising))
+                result |= ADVERTISE_10FULL;
+        if (linkmode_test_bit(ETHTOOL_LINK_MODE_100baseT_Half_BIT, advertising))
+                result |= ADVERTISE_100HALF;
+        if (linkmode_test_bit(ETHTOOL_LINK_MODE_100baseT_Full_BIT, advertising))
+                result |= ADVERTISE_100FULL;
+        if (linkmode_test_bit(ETHTOOL_LINK_MODE_Pause_BIT, advertising))
+                result |= ADVERTISE_PAUSE_CAP;
+        if (linkmode_test_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, advertising))
+                result |= ADVERTISE_PAUSE_ASYM;
+
+        return result;
+}
+
+/**
  * mii_adv_to_ethtool_adv_t
  * @adv: value of the MII_ADVERTISE register
  *
@@ -179,6 +208,28 @@ static inline u32 ethtool_adv_to_mii_ctrl1000_t(u32 ethadv)
 }
 
 /**
+ * linkmode_adv_to_mii_ctrl1000_t
+ * advertising: the linkmode advertisement settings
+ *
+ * A small helper function that translates linkmode advertisement
+ * settings to phy autonegotiation advertisements for the
+ * MII_CTRL1000 register when in 1000T mode.
+ */
+static inline u32 linkmode_adv_to_mii_ctrl1000_t(unsigned long *advertising)
+{
+        u32 result = 0;
+
+        if (linkmode_test_bit(ETHTOOL_LINK_MODE_1000baseT_Half_BIT,
+                              advertising))
+                result |= ADVERTISE_1000HALF;
+        if (linkmode_test_bit(ETHTOOL_LINK_MODE_1000baseT_Full_BIT,
+                              advertising))
+                result |= ADVERTISE_1000FULL;
+
+        return result;
+}
+
+/**
  * mii_ctrl1000_to_ethtool_adv_t
  * @adv: value of the MII_CTRL1000 register
  *
@@ -303,6 +354,56 @@ static inline u32 mii_lpa_to_ethtool_lpa_x(u32 lpa)
 }
 
 /**
+ * mii_adv_to_linkmode_adv_t
+ * @advertising:pointer to destination link mode.
+ * @adv: value of the MII_ADVERTISE register
+ *
+ * A small helper function that translates MII_ADVERTISE bits
+ * to linkmode advertisement settings.
+ */
+static inline void mii_adv_to_linkmode_adv_t(unsigned long *advertising,
+                                             u32 adv)
+{
+        linkmode_zero(advertising);
+
+        if (adv & ADVERTISE_10HALF)
+                linkmode_set_bit(ETHTOOL_LINK_MODE_10baseT_Half_BIT,
+                                 advertising);
+        if (adv & ADVERTISE_10FULL)
+                linkmode_set_bit(ETHTOOL_LINK_MODE_10baseT_Full_BIT,
+                                 advertising);
+        if (adv & ADVERTISE_100HALF)
+                linkmode_set_bit(ETHTOOL_LINK_MODE_100baseT_Half_BIT,
+                                 advertising);
+        if (adv & ADVERTISE_100FULL)
+                linkmode_set_bit(ETHTOOL_LINK_MODE_100baseT_Full_BIT,
+                                 advertising);
+        if (adv & ADVERTISE_PAUSE_CAP)
+                linkmode_set_bit(ETHTOOL_LINK_MODE_Pause_BIT, advertising);
+        if (adv & ADVERTISE_PAUSE_ASYM)
+                linkmode_set_bit(ETHTOOL_LINK_MODE_Asym_Pause_BIT, advertising);
+}
+
+/**
+ * ethtool_adv_to_lcl_adv_t
+ * @advertising:pointer to ethtool advertising
+ *
+ * A small helper function that translates ethtool advertising to LVL
+ * pause capabilities.
+ */
+static inline u32 ethtool_adv_to_lcl_adv_t(u32 advertising)
+{
+        u32 lcl_adv = 0;
+
+        if (advertising & ADVERTISED_Pause)
+                lcl_adv |= ADVERTISE_PAUSE_CAP;
+        if (advertising & ADVERTISED_Asym_Pause)
+                lcl_adv |= ADVERTISE_PAUSE_ASYM;
+
+        return lcl_adv;
+}
+
+/**
  * mii_advertise_flowctrl - get flow control advertisement flags
  * @cap: Flow control capabilities (FLOW_CTRL_RX, FLOW_CTRL_TX or both)
  */
diff --git a/include/linux/mlx5/cq.h b/include/linux/mlx5/cq.h
index 0ef6138eca49..31a750570c38 100644
--- a/include/linux/mlx5/cq.h
+++ b/include/linux/mlx5/cq.h
@@ -61,6 +61,7 @@ struct mlx5_core_cq {
         int                     reset_notify_added;
         struct list_head        reset_notify;
         struct mlx5_eq          *eq;
+        u16 uid;
 };
 
 
diff --git a/include/linux/mlx5/device.h b/include/linux/mlx5/device.h
index 11fa4e66afc5..b4c0457fbebd 100644
--- a/include/linux/mlx5/device.h
+++ b/include/linux/mlx5/device.h
@@ -504,6 +504,10 @@ struct health_buffer {
         __be16          ext_synd;
 };
 
+enum mlx5_cmd_addr_l_sz_offset {
+        MLX5_NIC_IFC_OFFSET = 8,
+};
+
 struct mlx5_init_seg {
         __be32                  fw_rev;
         __be32                  cmdif_rev_fw_sub;
@@ -1120,6 +1124,12 @@ enum mlx5_qcam_feature_groups {
 #define MLX5_CAP_FLOWTABLE_NIC_RX_MAX(mdev, cap) \
         MLX5_CAP_FLOWTABLE_MAX(mdev, flow_table_properties_nic_receive.cap)
 
+#define MLX5_CAP_FLOWTABLE_NIC_TX(mdev, cap) \
+                MLX5_CAP_FLOWTABLE(mdev, flow_table_properties_nic_transmit.cap)
+
+#define MLX5_CAP_FLOWTABLE_NIC_TX_MAX(mdev, cap) \
+        MLX5_CAP_FLOWTABLE_MAX(mdev, flow_table_properties_nic_transmit.cap)
+
 #define MLX5_CAP_FLOWTABLE_SNIFFER_RX(mdev, cap) \
         MLX5_CAP_FLOWTABLE(mdev, flow_table_properties_nic_receive_sniffer.cap)
 
diff --git a/include/linux/mlx5/driver.h b/include/linux/mlx5/driver.h
index 7a452716de4b..aa5963b5d38e 100644
--- a/include/linux/mlx5/driver.h
+++ b/include/linux/mlx5/driver.h
@@ -97,14 +97,15 @@ enum {
 };
 
 enum {
-        MLX5_ATOMIC_MODE_IB_COMP        = 1 << 16,
-        MLX5_ATOMIC_MODE_CX             = 2 << 16,
-        MLX5_ATOMIC_MODE_8B             = 3 << 16,
-        MLX5_ATOMIC_MODE_16B            = 4 << 16,
-        MLX5_ATOMIC_MODE_32B            = 5 << 16,
-        MLX5_ATOMIC_MODE_64B            = 6 << 16,
-        MLX5_ATOMIC_MODE_128B           = 7 << 16,
-        MLX5_ATOMIC_MODE_256B           = 8 << 16,
+        MLX5_ATOMIC_MODE_OFFSET = 16,
+        MLX5_ATOMIC_MODE_IB_COMP = 1,
+        MLX5_ATOMIC_MODE_CX = 2,
+        MLX5_ATOMIC_MODE_8B = 3,
+        MLX5_ATOMIC_MODE_16B = 4,
+        MLX5_ATOMIC_MODE_32B = 5,
+        MLX5_ATOMIC_MODE_64B = 6,
+        MLX5_ATOMIC_MODE_128B = 7,
+        MLX5_ATOMIC_MODE_256B = 8,
 };
 
 enum {
@@ -133,6 +134,7 @@ enum {
         MLX5_REG_PVLC            = 0x500f,
         MLX5_REG_PCMR            = 0x5041,
         MLX5_REG_PMLP            = 0x5002,
+        MLX5_REG_PPLM            = 0x5023,
         MLX5_REG_PCAM            = 0x507f,
         MLX5_REG_NODE_DESC       = 0x6001,
         MLX5_REG_HOST_ENDIANNESS = 0x7004,
@@ -162,16 +164,11 @@ enum mlx5_dcbx_oper_mode {
         MLX5E_DCBX_PARAM_VER_OPER_AUTO  = 0x3,
 };
 
-enum mlx5_dct_atomic_mode {
-        MLX5_ATOMIC_MODE_DCT_OFF        = 20,
-        MLX5_ATOMIC_MODE_DCT_NONE       = 0 << MLX5_ATOMIC_MODE_DCT_OFF,
-        MLX5_ATOMIC_MODE_DCT_IB_COMP    = 1 << MLX5_ATOMIC_MODE_DCT_OFF,
-        MLX5_ATOMIC_MODE_DCT_CX         = 2 << MLX5_ATOMIC_MODE_DCT_OFF,
-};
-
 enum {
         MLX5_ATOMIC_OPS_CMP_SWAP        = 1 << 0,
         MLX5_ATOMIC_OPS_FETCH_ADD       = 1 << 1,
+        MLX5_ATOMIC_OPS_EXTENDED_CMP_SWAP = 1 << 2,
+        MLX5_ATOMIC_OPS_EXTENDED_FETCH_ADD = 1 << 3,
 };
 
 enum mlx5_page_fault_resume_flags {
@@ -360,10 +357,10 @@ struct mlx5_frag_buf {
 };
 
 struct mlx5_frag_buf_ctrl {
-        struct mlx5_frag_buf    frag_buf;
+        struct mlx5_buf_list   *frags;
         u32                     sz_m1;
-        u32                     frag_sz_m1;
-        u32                     strides_offset;
+        u16                     frag_sz_m1;
+        u16                     strides_offset;
         u8                      log_sz;
         u8                      log_stride;
         u8                      log_frag_strides;
@@ -477,6 +474,7 @@ struct mlx5_core_srq {
 
         atomic_t                refcount;
         struct completion       free;
+        u16             uid;
 };
 
 struct mlx5_eq_table {
@@ -583,10 +581,11 @@ struct mlx5_irq_info {
 };
 
 struct mlx5_fc_stats {
-        struct rb_root counters;
-        struct list_head addlist;
-        /* protect addlist add/splice operations */
-        spinlock_t addlist_lock;
+        spinlock_t counters_idr_lock; /* protects counters_idr */
+        struct idr counters_idr;
+        struct list_head counters;
+        struct llist_head addlist;
+        struct llist_head dellist;
 
         struct workqueue_struct *wq;
         struct delayed_work work;
@@ -804,7 +803,7 @@ struct mlx5_pps {
 };
 
 struct mlx5_clock {
-        rwlock_t                   lock;
+        seqlock_t                  lock;
         struct cyclecounter        cycles;
         struct timecounter         tc;
         struct hwtstamp_config     hwtstamp_config;
@@ -837,6 +836,7 @@ struct mlx5_core_dev {
                 u32 fpga[MLX5_ST_SZ_DW(fpga_cap)];
                 u32 qcam[MLX5_ST_SZ_DW(qcam_reg)];
         } caps;
+        u64                     sys_image_guid;
         phys_addr_t             iseg_base;
         struct mlx5_init_seg __iomem *iseg;
         enum mlx5_device_state  state;
@@ -994,10 +994,12 @@ static inline u32 mlx5_base_mkey(const u32 key)
         return key & 0xffffff00u;
 }
 
-static inline void mlx5_fill_fbc_offset(u8 log_stride, u8 log_sz,
-                                        u32 strides_offset,
+static inline void mlx5_init_fbc_offset(struct mlx5_buf_list *frags,
+                                        u8 log_stride, u8 log_sz,
+                                        u16 strides_offset,
                                         struct mlx5_frag_buf_ctrl *fbc)
 {
+        fbc->frags      = frags;
         fbc->log_stride = log_stride;
         fbc->log_sz     = log_sz;
         fbc->sz_m1      = (1 << fbc->log_sz) - 1;
@@ -1006,18 +1008,11 @@ static inline void mlx5_fill_fbc_offset(u8 log_stride, u8 log_sz,
         fbc->strides_offset = strides_offset;
 }
 
-static inline void mlx5_fill_fbc(u8 log_stride, u8 log_sz,
+static inline void mlx5_init_fbc(struct mlx5_buf_list *frags,
+                                 u8 log_stride, u8 log_sz,
                                  struct mlx5_frag_buf_ctrl *fbc)
 {
-        mlx5_fill_fbc_offset(log_stride, log_sz, 0, fbc);
-}
-
-static inline void mlx5_core_init_cq_frag_buf(struct mlx5_frag_buf_ctrl *fbc,
-                                              void *cqc)
-{
-        mlx5_fill_fbc(6 + MLX5_GET(cqc, cqc, cqe_sz),
-                      MLX5_GET(cqc, cqc, log_cq_size),
-                      fbc);
+        mlx5_init_fbc_offset(frags, log_stride, log_sz, 0, fbc);
 }
 
 static inline void *mlx5_frag_buf_get_wqe(struct mlx5_frag_buf_ctrl *fbc,
@@ -1028,8 +1023,15 @@ static inline void *mlx5_frag_buf_get_wqe(struct mlx5_frag_buf_ctrl *fbc,
         ix  += fbc->strides_offset;
         frag = ix >> fbc->log_frag_strides;
 
-        return fbc->frag_buf.frags[frag].buf +
-                ((fbc->frag_sz_m1 & ix) << fbc->log_stride);
+        return fbc->frags[frag].buf + ((fbc->frag_sz_m1 & ix) << fbc->log_stride);
+}
+
+static inline u32
+mlx5_frag_buf_get_idx_last_contig_stride(struct mlx5_frag_buf_ctrl *fbc, u32 ix)
+{
+        u32 last_frag_stride_idx = (ix + fbc->strides_offset) | fbc->frag_sz_m1;
+
+        return min_t(u32, last_frag_stride_idx - fbc->strides_offset, fbc->sz_m1);
 }
 
 int mlx5_cmd_init(struct mlx5_core_dev *dev);
@@ -1052,7 +1054,7 @@ int mlx5_cmd_free_uar(struct mlx5_core_dev *dev, u32 uarn);
 void mlx5_health_cleanup(struct mlx5_core_dev *dev);
 int mlx5_health_init(struct mlx5_core_dev *dev);
 void mlx5_start_health_poll(struct mlx5_core_dev *dev);
-void mlx5_stop_health_poll(struct mlx5_core_dev *dev);
+void mlx5_stop_health_poll(struct mlx5_core_dev *dev, bool disable_health);
 void mlx5_drain_health_wq(struct mlx5_core_dev *dev);
 void mlx5_trigger_health_work(struct mlx5_core_dev *dev);
 void mlx5_drain_health_recovery(struct mlx5_core_dev *dev);
@@ -1226,21 +1228,15 @@ int mlx5_lag_query_cong_counters(struct mlx5_core_dev *dev,
 struct mlx5_uars_page *mlx5_get_uars_page(struct mlx5_core_dev *mdev);
 void mlx5_put_uars_page(struct mlx5_core_dev *mdev, struct mlx5_uars_page *up);
 
-#ifndef CONFIG_MLX5_CORE_IPOIB
-static inline
-struct net_device *mlx5_rdma_netdev_alloc(struct mlx5_core_dev *mdev,
-                                          struct ib_device *ibdev,
-                                          const char *name,
-                                          void (*setup)(struct net_device *))
-{
-        return ERR_PTR(-EOPNOTSUPP);
-}
-#else
+#ifdef CONFIG_MLX5_CORE_IPOIB
 struct net_device *mlx5_rdma_netdev_alloc(struct mlx5_core_dev *mdev,
                                           struct ib_device *ibdev,
                                           const char *name,
                                           void (*setup)(struct net_device *));
 #endif /* CONFIG_MLX5_CORE_IPOIB */
+int mlx5_rdma_rn_get_params(struct mlx5_core_dev *mdev,
+                            struct ib_device *device,
+                            struct rdma_netdev_alloc_params *params);
 
 struct mlx5_profile {
         u64     mask;
diff --git a/include/linux/mlx5/fs.h b/include/linux/mlx5/fs.h
index 804516e4f483..5660f07d3be0 100644
--- a/include/linux/mlx5/fs.h
+++ b/include/linux/mlx5/fs.h
@@ -45,7 +45,8 @@ enum {
 };
 
 enum {
-        MLX5_FLOW_TABLE_TUNNEL_EN = BIT(0),
+        MLX5_FLOW_TABLE_TUNNEL_EN_REFORMAT = BIT(0),
+        MLX5_FLOW_TABLE_TUNNEL_EN_DECAP = BIT(1),
 };
 
 #define LEFTOVERS_RULE_NUM       2
@@ -91,7 +92,7 @@ struct mlx5_flow_destination {
                 u32                     tir_num;
                 u32                     ft_num;
                 struct mlx5_flow_table  *ft;
-                struct mlx5_fc          *counter;
+                u32                     counter_id;
                 struct {
                         u16             num;
                         u16             vhca_id;
@@ -101,6 +102,8 @@ struct mlx5_flow_destination {
 };
 
 struct mlx5_flow_namespace *
+mlx5_get_fdb_sub_ns(struct mlx5_core_dev *dev, int n);
+struct mlx5_flow_namespace *
 mlx5_get_flow_namespace(struct mlx5_core_dev *dev,
                         enum mlx5_flow_namespace_type type);
 struct mlx5_flow_namespace *
@@ -155,20 +158,28 @@ struct mlx5_fs_vlan {
 
 #define MLX5_FS_VLAN_DEPTH      2
 
+enum {
+        FLOW_ACT_HAS_TAG   = BIT(0),
+        FLOW_ACT_NO_APPEND = BIT(1),
+};
+
 struct mlx5_flow_act {
         u32 action;
-        bool has_flow_tag;
         u32 flow_tag;
-        u32 encap_id;
+        u32 reformat_id;
         u32 modify_id;
         uintptr_t esp_id;
+        u32 flags;
         struct mlx5_fs_vlan vlan[MLX5_FS_VLAN_DEPTH];
         struct ib_counters *counters;
 };
 
 #define MLX5_DECLARE_FLOW_ACT(name) \
-        struct mlx5_flow_act name = {MLX5_FLOW_CONTEXT_ACTION_FWD_DEST,\
-                                     MLX5_FS_DEFAULT_FLOW_TAG, 0, 0}
+        struct mlx5_flow_act name = { .action = MLX5_FLOW_CONTEXT_ACTION_FWD_DEST,\
+                                      .flow_tag = MLX5_FS_DEFAULT_FLOW_TAG, \
+                                      .reformat_id = 0, \
+                                      .modify_id = 0, \
+                                      .flags =  0, }
 
 /* Single destination per rule.
  * Group ID is implied by the match criteria.
@@ -185,15 +196,30 @@ int mlx5_modify_rule_destination(struct mlx5_flow_handle *handler,
                                  struct mlx5_flow_destination *new_dest,
                                  struct mlx5_flow_destination *old_dest);
 
-struct mlx5_fc *mlx5_flow_rule_counter(struct mlx5_flow_handle *handler);
 struct mlx5_fc *mlx5_fc_create(struct mlx5_core_dev *dev, bool aging);
 void mlx5_fc_destroy(struct mlx5_core_dev *dev, struct mlx5_fc *counter);
 void mlx5_fc_query_cached(struct mlx5_fc *counter,
                           u64 *bytes, u64 *packets, u64 *lastuse);
 int mlx5_fc_query(struct mlx5_core_dev *dev, struct mlx5_fc *counter,
                   u64 *packets, u64 *bytes);
+u32 mlx5_fc_id(struct mlx5_fc *counter);
 
 int mlx5_fs_add_rx_underlay_qpn(struct mlx5_core_dev *dev, u32 underlay_qpn);
 int mlx5_fs_remove_rx_underlay_qpn(struct mlx5_core_dev *dev, u32 underlay_qpn);
 
+int mlx5_modify_header_alloc(struct mlx5_core_dev *dev,
+                             u8 namespace, u8 num_actions,
+                             void *modify_actions, u32 *modify_header_id);
+void mlx5_modify_header_dealloc(struct mlx5_core_dev *dev,
+                                u32 modify_header_id);
+
+int mlx5_packet_reformat_alloc(struct mlx5_core_dev *dev,
+                               int reformat_type,
+                               size_t size,
+                               void *reformat_data,
+                               enum mlx5_flow_namespace_type namespace,
+                               u32 *packet_reformat_id);
+void mlx5_packet_reformat_dealloc(struct mlx5_core_dev *dev,
+                                  u32 packet_reformat_id);
+
 #endif
diff --git a/include/linux/mlx5/mlx5_ifc.h b/include/linux/mlx5/mlx5_ifc.h
index f043d65b9bac..dbff9ff28f2c 100644
--- a/include/linux/mlx5/mlx5_ifc.h
+++ b/include/linux/mlx5/mlx5_ifc.h
@@ -243,8 +243,8 @@ enum {
         MLX5_CMD_OP_DEALLOC_FLOW_COUNTER          = 0x93a,
         MLX5_CMD_OP_QUERY_FLOW_COUNTER            = 0x93b,
         MLX5_CMD_OP_MODIFY_FLOW_TABLE             = 0x93c,
-        MLX5_CMD_OP_ALLOC_ENCAP_HEADER            = 0x93d,
-        MLX5_CMD_OP_DEALLOC_ENCAP_HEADER          = 0x93e,
+        MLX5_CMD_OP_ALLOC_PACKET_REFORMAT_CONTEXT = 0x93d,
+        MLX5_CMD_OP_DEALLOC_PACKET_REFORMAT_CONTEXT = 0x93e,
         MLX5_CMD_OP_ALLOC_MODIFY_HEADER_CONTEXT   = 0x940,
         MLX5_CMD_OP_DEALLOC_MODIFY_HEADER_CONTEXT = 0x941,
         MLX5_CMD_OP_QUERY_MODIFY_HEADER_CONTEXT   = 0x942,
@@ -336,7 +336,7 @@ struct mlx5_ifc_flow_table_prop_layout_bits {
         u8         modify_root[0x1];
         u8         identified_miss_table_mode[0x1];
         u8         flow_table_modify[0x1];
-        u8         encap[0x1];
+        u8         reformat[0x1];
         u8         decap[0x1];
         u8         reserved_at_9[0x1];
         u8         pop_vlan[0x1];
@@ -344,8 +344,12 @@ struct mlx5_ifc_flow_table_prop_layout_bits {
         u8         reserved_at_c[0x1];
         u8         pop_vlan_2[0x1];
         u8         push_vlan_2[0x1];
-        u8         reserved_at_f[0x11];
-
+        u8         reformat_and_vlan_action[0x1];
+        u8         reserved_at_10[0x2];
+        u8         reformat_l3_tunnel_to_l2[0x1];
+        u8         reformat_l2_to_l3_tunnel[0x1];
+        u8         reformat_and_modify_action[0x1];
+        u8         reserved_at_14[0xb];
         u8         reserved_at_20[0x2];
         u8         log_max_ft_size[0x6];
         u8         log_max_modify_header_context[0x8];
@@ -554,7 +558,13 @@ struct mlx5_ifc_flow_table_nic_cap_bits {
         u8         nic_rx_multi_path_tirs[0x1];
         u8         nic_rx_multi_path_tirs_fts[0x1];
         u8         allow_sniffer_and_nic_rx_shared_tir[0x1];
-        u8         reserved_at_3[0x1fd];
+        u8         reserved_at_3[0x1d];
+        u8         encap_general_header[0x1];
+        u8         reserved_at_21[0xa];
+        u8         log_max_packet_reformat_context[0x5];
+        u8         reserved_at_30[0x6];
+        u8         max_encap_header_size[0xa];
+        u8         reserved_at_40[0x1c0];
 
         struct mlx5_ifc_flow_table_prop_layout_bits flow_table_properties_nic_receive;
 
@@ -574,7 +584,9 @@ struct mlx5_ifc_flow_table_nic_cap_bits {
 struct mlx5_ifc_flow_table_eswitch_cap_bits {
         u8      reserved_at_0[0x1c];
         u8      fdb_multi_path_to_table[0x1];
-        u8      reserved_at_1d[0x1e3];
+        u8      reserved_at_1d[0x1];
+        u8      multi_fdb_encap[0x1];
+        u8      reserved_at_1e[0x1e1];
 
         struct mlx5_ifc_flow_table_prop_layout_bits flow_table_properties_nic_esw_fdb;
 
@@ -599,7 +611,7 @@ struct mlx5_ifc_e_switch_cap_bits {
         u8         vxlan_encap_decap[0x1];
         u8         nvgre_encap_decap[0x1];
         u8         reserved_at_22[0x9];
-        u8         log_max_encap_headers[0x5];
+        u8         log_max_packet_reformat_context[0x5];
         u8         reserved_2b[0x6];
         u8         max_encap_header_size[0xa];
 
@@ -896,7 +908,8 @@ struct mlx5_ifc_cmd_hca_cap_bits {
         u8         log_max_mkey[0x6];
         u8         reserved_at_f0[0x8];
         u8         dump_fill_mkey[0x1];
-        u8         reserved_at_f9[0x3];
+        u8         reserved_at_f9[0x2];
+        u8         fast_teardown[0x1];
         u8         log_max_eq[0x4];
 
         u8         max_indirection[0x8];
@@ -995,7 +1008,8 @@ struct mlx5_ifc_cmd_hca_cap_bits {
         u8         umr_modify_atomic_disabled[0x1];
         u8         umr_indirect_mkey_disabled[0x1];
         u8         umr_fence[0x2];
-        u8         reserved_at_20c[0x3];
+        u8         dc_req_scat_data_cqe[0x1];
+        u8         reserved_at_20d[0x2];
         u8         drain_sigerr[0x1];
         u8         cmdif_checksum[0x2];
         u8         sigerr_cqe[0x1];
@@ -1280,7 +1294,9 @@ struct mlx5_ifc_wq_bits {
         u8         reserved_at_118[0x3];
         u8         log_wq_sz[0x5];
 
-        u8         reserved_at_120[0x3];
+        u8         dbr_umem_valid[0x1];
+        u8         wq_umem_valid[0x1];
+        u8         reserved_at_122[0x1];
         u8         log_hairpin_num_packets[0x5];
         u8         reserved_at_128[0x3];
         u8         log_hairpin_data_sz[0x5];
@@ -2354,7 +2370,10 @@ struct mlx5_ifc_qpc_bits {
 
         u8         dc_access_key[0x40];
 
-        u8         reserved_at_680[0xc0];
+        u8         reserved_at_680[0x3];
+        u8         dbr_umem_valid[0x1];
+
+        u8         reserved_at_684[0xbc];
 };
 
 struct mlx5_ifc_roce_addr_layout_bits {
@@ -2394,7 +2413,7 @@ enum {
         MLX5_FLOW_CONTEXT_ACTION_DROP      = 0x2,
         MLX5_FLOW_CONTEXT_ACTION_FWD_DEST  = 0x4,
         MLX5_FLOW_CONTEXT_ACTION_COUNT     = 0x8,
-        MLX5_FLOW_CONTEXT_ACTION_ENCAP     = 0x10,
+        MLX5_FLOW_CONTEXT_ACTION_PACKET_REFORMAT = 0x10,
         MLX5_FLOW_CONTEXT_ACTION_DECAP     = 0x20,
         MLX5_FLOW_CONTEXT_ACTION_MOD_HDR   = 0x40,
         MLX5_FLOW_CONTEXT_ACTION_VLAN_POP  = 0x80,
@@ -2427,7 +2446,7 @@ struct mlx5_ifc_flow_context_bits {
         u8         reserved_at_a0[0x8];
         u8         flow_counter_list_size[0x18];
 
-        u8         encap_id[0x20];
+        u8         packet_reformat_id[0x20];
 
         u8         modify_header_id[0x20];
 
@@ -2454,7 +2473,7 @@ struct mlx5_ifc_xrc_srqc_bits {
 
         u8         wq_signature[0x1];
         u8         cont_srq[0x1];
-        u8         reserved_at_22[0x1];
+        u8         dbr_umem_valid[0x1];
         u8         rlky[0x1];
         u8         basic_cyclic_rcv_wqe[0x1];
         u8         log_rq_stride[0x3];
@@ -2549,8 +2568,8 @@ enum {
 };
 
 enum {
-        MLX5_TIRC_SELF_LB_BLOCK_BLOCK_UNICAST_    = 0x1,
-        MLX5_TIRC_SELF_LB_BLOCK_BLOCK_MULTICAST_  = 0x2,
+        MLX5_TIRC_SELF_LB_BLOCK_BLOCK_UNICAST    = 0x1,
+        MLX5_TIRC_SELF_LB_BLOCK_BLOCK_MULTICAST  = 0x2,
 };
 
 struct mlx5_ifc_tirc_bits {
@@ -3118,7 +3137,9 @@ enum {
 
 struct mlx5_ifc_cqc_bits {
         u8         status[0x4];
-        u8         reserved_at_4[0x4];
+        u8         reserved_at_4[0x2];
+        u8         dbr_umem_valid[0x1];
+        u8         reserved_at_7[0x1];
         u8         cqe_sz[0x3];
         u8         cc[0x1];
         u8         reserved_at_c[0x1];
@@ -3352,12 +3373,13 @@ struct mlx5_ifc_teardown_hca_out_bits {
 
         u8         reserved_at_40[0x3f];
 
-        u8         force_state[0x1];
+        u8         state[0x1];
 };
 
 enum {
         MLX5_TEARDOWN_HCA_IN_PROFILE_GRACEFUL_CLOSE  = 0x0,
         MLX5_TEARDOWN_HCA_IN_PROFILE_FORCE_CLOSE     = 0x1,
+        MLX5_TEARDOWN_HCA_IN_PROFILE_PREPARE_FAST_TEARDOWN = 0x2,
 };
 
 struct mlx5_ifc_teardown_hca_in_bits {
@@ -3384,7 +3406,7 @@ struct mlx5_ifc_sqerr2rts_qp_out_bits {
 
 struct mlx5_ifc_sqerr2rts_qp_in_bits {
         u8         opcode[0x10];
-        u8         reserved_at_10[0x10];
+        u8         uid[0x10];
 
         u8         reserved_at_20[0x10];
         u8         op_mod[0x10];
@@ -3414,7 +3436,7 @@ struct mlx5_ifc_sqd2rts_qp_out_bits {
 
 struct mlx5_ifc_sqd2rts_qp_in_bits {
         u8         opcode[0x10];
-        u8         reserved_at_10[0x10];
+        u8         uid[0x10];
 
         u8         reserved_at_20[0x10];
         u8         op_mod[0x10];
@@ -3619,7 +3641,7 @@ struct mlx5_ifc_rts2rts_qp_out_bits {
 
 struct mlx5_ifc_rts2rts_qp_in_bits {
         u8         opcode[0x10];
-        u8         reserved_at_10[0x10];
+        u8         uid[0x10];
 
         u8         reserved_at_20[0x10];
         u8         op_mod[0x10];
@@ -3649,7 +3671,7 @@ struct mlx5_ifc_rtr2rts_qp_out_bits {
 
 struct mlx5_ifc_rtr2rts_qp_in_bits {
         u8         opcode[0x10];
-        u8         reserved_at_10[0x10];
+        u8         uid[0x10];
 
         u8         reserved_at_20[0x10];
         u8         op_mod[0x10];
@@ -3679,7 +3701,7 @@ struct mlx5_ifc_rst2init_qp_out_bits {
 
 struct mlx5_ifc_rst2init_qp_in_bits {
         u8         opcode[0x10];
-        u8         reserved_at_10[0x10];
+        u8         uid[0x10];
 
         u8         reserved_at_20[0x10];
         u8         op_mod[0x10];
@@ -4802,19 +4824,19 @@ struct mlx5_ifc_query_eq_in_bits {
         u8         reserved_at_60[0x20];
 };
 
-struct mlx5_ifc_encap_header_in_bits {
+struct mlx5_ifc_packet_reformat_context_in_bits {
         u8         reserved_at_0[0x5];
-        u8         header_type[0x3];
+        u8         reformat_type[0x3];
         u8         reserved_at_8[0xe];
-        u8         encap_header_size[0xa];
+        u8         reformat_data_size[0xa];
 
         u8         reserved_at_20[0x10];
-        u8         encap_header[2][0x8];
+        u8         reformat_data[2][0x8];
 
-        u8         more_encap_header[0][0x8];
+        u8         more_reformat_data[0][0x8];
 };
 
-struct mlx5_ifc_query_encap_header_out_bits {
+struct mlx5_ifc_query_packet_reformat_context_out_bits {
         u8         status[0x8];
         u8         reserved_at_8[0x18];
 
@@ -4822,33 +4844,41 @@ struct mlx5_ifc_query_encap_header_out_bits {
 
         u8         reserved_at_40[0xa0];
 
-        struct mlx5_ifc_encap_header_in_bits encap_header[0];
+        struct mlx5_ifc_packet_reformat_context_in_bits packet_reformat_context[0];
 };
 
-struct mlx5_ifc_query_encap_header_in_bits {
+struct mlx5_ifc_query_packet_reformat_context_in_bits {
         u8         opcode[0x10];
         u8         reserved_at_10[0x10];
 
         u8         reserved_at_20[0x10];
         u8         op_mod[0x10];
 
-        u8         encap_id[0x20];
+        u8         packet_reformat_id[0x20];
 
         u8         reserved_at_60[0xa0];
 };
 
-struct mlx5_ifc_alloc_encap_header_out_bits {
+struct mlx5_ifc_alloc_packet_reformat_context_out_bits {
         u8         status[0x8];
         u8         reserved_at_8[0x18];
 
         u8         syndrome[0x20];
 
-        u8         encap_id[0x20];
+        u8         packet_reformat_id[0x20];
 
         u8         reserved_at_60[0x20];
 };
 
-struct mlx5_ifc_alloc_encap_header_in_bits {
+enum {
+        MLX5_REFORMAT_TYPE_L2_TO_VXLAN = 0x0,
+        MLX5_REFORMAT_TYPE_L2_TO_NVGRE = 0x1,
+        MLX5_REFORMAT_TYPE_L2_TO_L2_TUNNEL = 0x2,
+        MLX5_REFORMAT_TYPE_L3_TUNNEL_TO_L2 = 0x3,
+        MLX5_REFORMAT_TYPE_L2_TO_L3_TUNNEL = 0x4,
+};
+
+struct mlx5_ifc_alloc_packet_reformat_context_in_bits {
         u8         opcode[0x10];
         u8         reserved_at_10[0x10];
 
@@ -4857,10 +4887,10 @@ struct mlx5_ifc_alloc_encap_header_in_bits {
 
         u8         reserved_at_40[0xa0];
 
-        struct mlx5_ifc_encap_header_in_bits encap_header;
+        struct mlx5_ifc_packet_reformat_context_in_bits packet_reformat_context;
 };
 
-struct mlx5_ifc_dealloc_encap_header_out_bits {
+struct mlx5_ifc_dealloc_packet_reformat_context_out_bits {
         u8         status[0x8];
         u8         reserved_at_8[0x18];
 
@@ -4869,14 +4899,14 @@ struct mlx5_ifc_dealloc_encap_header_out_bits {
         u8         reserved_at_40[0x40];
 };
 
-struct mlx5_ifc_dealloc_encap_header_in_bits {
+struct mlx5_ifc_dealloc_packet_reformat_context_in_bits {
         u8         opcode[0x10];
         u8         reserved_at_10[0x10];
 
         u8         reserved_20[0x10];
         u8         op_mod[0x10];
 
-        u8         encap_id[0x20];
+        u8         packet_reformat_id[0x20];
 
         u8         reserved_60[0x20];
 };
@@ -5174,7 +5204,7 @@ struct mlx5_ifc_qp_2rst_out_bits {
 
 struct mlx5_ifc_qp_2rst_in_bits {
         u8         opcode[0x10];
-        u8         reserved_at_10[0x10];
+        u8         uid[0x10];
 
         u8         reserved_at_20[0x10];
         u8         op_mod[0x10];
@@ -5196,7 +5226,7 @@ struct mlx5_ifc_qp_2err_out_bits {
 
 struct mlx5_ifc_qp_2err_in_bits {
         u8         opcode[0x10];
-        u8         reserved_at_10[0x10];
+        u8         uid[0x10];
 
         u8         reserved_at_20[0x10];
         u8         op_mod[0x10];
@@ -5296,7 +5326,7 @@ struct mlx5_ifc_modify_tis_bitmask_bits {
 
 struct mlx5_ifc_modify_tis_in_bits {
         u8         opcode[0x10];
-        u8         reserved_at_10[0x10];
+        u8         uid[0x10];
 
         u8         reserved_at_20[0x10];
         u8         op_mod[0x10];
@@ -5335,7 +5365,7 @@ struct mlx5_ifc_modify_tir_out_bits {
 
 struct mlx5_ifc_modify_tir_in_bits {
         u8         opcode[0x10];
-        u8         reserved_at_10[0x10];
+        u8         uid[0x10];
 
         u8         reserved_at_20[0x10];
         u8         op_mod[0x10];
@@ -5363,7 +5393,7 @@ struct mlx5_ifc_modify_sq_out_bits {
 
 struct mlx5_ifc_modify_sq_in_bits {
         u8         opcode[0x10];
-        u8         reserved_at_10[0x10];
+        u8         uid[0x10];
 
         u8         reserved_at_20[0x10];
         u8         op_mod[0x10];
@@ -5436,7 +5466,7 @@ struct mlx5_ifc_rqt_bitmask_bits {
 
 struct mlx5_ifc_modify_rqt_in_bits {
         u8         opcode[0x10];
-        u8         reserved_at_10[0x10];
+        u8         uid[0x10];
 
         u8         reserved_at_20[0x10];
         u8         op_mod[0x10];
@@ -5470,7 +5500,7 @@ enum {
 
 struct mlx5_ifc_modify_rq_in_bits {
         u8         opcode[0x10];
-        u8         reserved_at_10[0x10];
+        u8         uid[0x10];
 
         u8         reserved_at_20[0x10];
         u8         op_mod[0x10];
@@ -5506,7 +5536,7 @@ struct mlx5_ifc_rmp_bitmask_bits {
 
 struct mlx5_ifc_modify_rmp_in_bits {
         u8         opcode[0x10];
-        u8         reserved_at_10[0x10];
+        u8         uid[0x10];
 
         u8         reserved_at_20[0x10];
         u8         op_mod[0x10];
@@ -5611,7 +5641,7 @@ enum {
 
 struct mlx5_ifc_modify_cq_in_bits {
         u8         opcode[0x10];
-        u8         reserved_at_10[0x10];
+        u8         uid[0x10];
 
         u8         reserved_at_20[0x10];
         u8         op_mod[0x10];
@@ -5623,7 +5653,10 @@ struct mlx5_ifc_modify_cq_in_bits {
 
         struct mlx5_ifc_cqc_bits cq_context;
 
-        u8         reserved_at_280[0x600];
+        u8         reserved_at_280[0x40];
+
+        u8         cq_umem_valid[0x1];
+        u8         reserved_at_2c1[0x5bf];
 
         u8         pas[0][0x40];
 };
@@ -5771,7 +5804,7 @@ struct mlx5_ifc_init2rtr_qp_out_bits {
 
 struct mlx5_ifc_init2rtr_qp_in_bits {
         u8         opcode[0x10];
-        u8         reserved_at_10[0x10];
+        u8         uid[0x10];
 
         u8         reserved_at_20[0x10];
         u8         op_mod[0x10];
@@ -5801,7 +5834,7 @@ struct mlx5_ifc_init2init_qp_out_bits {
 
 struct mlx5_ifc_init2init_qp_in_bits {
         u8         opcode[0x10];
-        u8         reserved_at_10[0x10];
+        u8         uid[0x10];
 
         u8         reserved_at_20[0x10];
         u8         op_mod[0x10];
@@ -5900,7 +5933,7 @@ struct mlx5_ifc_drain_dct_out_bits {
 
 struct mlx5_ifc_drain_dct_in_bits {
         u8         opcode[0x10];
-        u8         reserved_at_10[0x10];
+        u8         uid[0x10];
 
         u8         reserved_at_20[0x10];
         u8         op_mod[0x10];
@@ -5944,7 +5977,7 @@ struct mlx5_ifc_detach_from_mcg_out_bits {
 
 struct mlx5_ifc_detach_from_mcg_in_bits {
         u8         opcode[0x10];
-        u8         reserved_at_10[0x10];
+        u8         uid[0x10];
 
         u8         reserved_at_20[0x10];
         u8         op_mod[0x10];
@@ -5968,7 +6001,7 @@ struct mlx5_ifc_destroy_xrq_out_bits {
 
 struct mlx5_ifc_destroy_xrq_in_bits {
         u8         opcode[0x10];
-        u8         reserved_at_10[0x10];
+        u8         uid[0x10];
 
         u8         reserved_at_20[0x10];
         u8         op_mod[0x10];
@@ -5990,7 +6023,7 @@ struct mlx5_ifc_destroy_xrc_srq_out_bits {
 
 struct mlx5_ifc_destroy_xrc_srq_in_bits {
         u8         opcode[0x10];
-        u8         reserved_at_10[0x10];
+        u8         uid[0x10];
 
         u8         reserved_at_20[0x10];
         u8         op_mod[0x10];
@@ -6012,7 +6045,7 @@ struct mlx5_ifc_destroy_tis_out_bits {
 
 struct mlx5_ifc_destroy_tis_in_bits {
         u8         opcode[0x10];
-        u8         reserved_at_10[0x10];
+        u8         uid[0x10];
 
         u8         reserved_at_20[0x10];
         u8         op_mod[0x10];
@@ -6034,7 +6067,7 @@ struct mlx5_ifc_destroy_tir_out_bits {
 
 struct mlx5_ifc_destroy_tir_in_bits {
         u8         opcode[0x10];
-        u8         reserved_at_10[0x10];
+        u8         uid[0x10];
 
         u8         reserved_at_20[0x10];
         u8         op_mod[0x10];
@@ -6056,7 +6089,7 @@ struct mlx5_ifc_destroy_srq_out_bits {
 
 struct mlx5_ifc_destroy_srq_in_bits {
         u8         opcode[0x10];
-        u8         reserved_at_10[0x10];
+        u8         uid[0x10];
 
         u8         reserved_at_20[0x10];
         u8         op_mod[0x10];
@@ -6078,7 +6111,7 @@ struct mlx5_ifc_destroy_sq_out_bits {
 
 struct mlx5_ifc_destroy_sq_in_bits {
         u8         opcode[0x10];
-        u8         reserved_at_10[0x10];
+        u8         uid[0x10];
 
         u8         reserved_at_20[0x10];
         u8         op_mod[0x10];
@@ -6124,7 +6157,7 @@ struct mlx5_ifc_destroy_rqt_out_bits {
 
 struct mlx5_ifc_destroy_rqt_in_bits {
         u8         opcode[0x10];
-        u8         reserved_at_10[0x10];
+        u8         uid[0x10];
 
         u8         reserved_at_20[0x10];
         u8         op_mod[0x10];
@@ -6146,7 +6179,7 @@ struct mlx5_ifc_destroy_rq_out_bits {
 
 struct mlx5_ifc_destroy_rq_in_bits {
         u8         opcode[0x10];
-        u8         reserved_at_10[0x10];
+        u8         uid[0x10];
 
         u8         reserved_at_20[0x10];
         u8         op_mod[0x10];
@@ -6190,7 +6223,7 @@ struct mlx5_ifc_destroy_rmp_out_bits {
 
 struct mlx5_ifc_destroy_rmp_in_bits {
         u8         opcode[0x10];
-        u8         reserved_at_10[0x10];
+        u8         uid[0x10];
 
         u8         reserved_at_20[0x10];
         u8         op_mod[0x10];
@@ -6212,7 +6245,7 @@ struct mlx5_ifc_destroy_qp_out_bits {
 
 struct mlx5_ifc_destroy_qp_in_bits {
         u8         opcode[0x10];
-        u8         reserved_at_10[0x10];
+        u8         uid[0x10];
 
         u8         reserved_at_20[0x10];
         u8         op_mod[0x10];
@@ -6364,7 +6397,7 @@ struct mlx5_ifc_destroy_dct_out_bits {
 
 struct mlx5_ifc_destroy_dct_in_bits {
         u8         opcode[0x10];
-        u8         reserved_at_10[0x10];
+        u8         uid[0x10];
 
         u8         reserved_at_20[0x10];
         u8         op_mod[0x10];
@@ -6386,7 +6419,7 @@ struct mlx5_ifc_destroy_cq_out_bits {
 
 struct mlx5_ifc_destroy_cq_in_bits {
         u8         opcode[0x10];
-        u8         reserved_at_10[0x10];
+        u8         uid[0x10];
 
         u8         reserved_at_20[0x10];
         u8         op_mod[0x10];
@@ -6489,7 +6522,7 @@ struct mlx5_ifc_dealloc_xrcd_out_bits {
 
 struct mlx5_ifc_dealloc_xrcd_in_bits {
         u8         opcode[0x10];
-        u8         reserved_at_10[0x10];
+        u8         uid[0x10];
 
         u8         reserved_at_20[0x10];
         u8         op_mod[0x10];
@@ -6577,7 +6610,7 @@ struct mlx5_ifc_dealloc_pd_out_bits {
 
 struct mlx5_ifc_dealloc_pd_in_bits {
         u8         opcode[0x10];
-        u8         reserved_at_10[0x10];
+        u8         uid[0x10];
 
         u8         reserved_at_20[0x10];
         u8         op_mod[0x10];
@@ -6623,7 +6656,7 @@ struct mlx5_ifc_create_xrq_out_bits {
 
 struct mlx5_ifc_create_xrq_in_bits {
         u8         opcode[0x10];
-        u8         reserved_at_10[0x10];
+        u8         uid[0x10];
 
         u8         reserved_at_20[0x10];
         u8         op_mod[0x10];
@@ -6647,7 +6680,7 @@ struct mlx5_ifc_create_xrc_srq_out_bits {
 
 struct mlx5_ifc_create_xrc_srq_in_bits {
         u8         opcode[0x10];
-        u8         reserved_at_10[0x10];
+        u8         uid[0x10];
 
         u8         reserved_at_20[0x10];
         u8         op_mod[0x10];
@@ -6656,7 +6689,9 @@ struct mlx5_ifc_create_xrc_srq_in_bits {
 
         struct mlx5_ifc_xrc_srqc_bits xrc_srq_context_entry;
 
-        u8         reserved_at_280[0x600];
+        u8         reserved_at_280[0x40];
+        u8         xrc_srq_umem_valid[0x1];
+        u8         reserved_at_2c1[0x5bf];
 
         u8         pas[0][0x40];
 };
@@ -6675,7 +6710,7 @@ struct mlx5_ifc_create_tis_out_bits {
 
 struct mlx5_ifc_create_tis_in_bits {
         u8         opcode[0x10];
-        u8         reserved_at_10[0x10];
+        u8         uid[0x10];
 
         u8         reserved_at_20[0x10];
         u8         op_mod[0x10];
@@ -6699,7 +6734,7 @@ struct mlx5_ifc_create_tir_out_bits {
 
 struct mlx5_ifc_create_tir_in_bits {
         u8         opcode[0x10];
-        u8         reserved_at_10[0x10];
+        u8         uid[0x10];
 
         u8         reserved_at_20[0x10];
         u8         op_mod[0x10];
@@ -6723,7 +6758,7 @@ struct mlx5_ifc_create_srq_out_bits {
 
 struct mlx5_ifc_create_srq_in_bits {
         u8         opcode[0x10];
-        u8         reserved_at_10[0x10];
+        u8         uid[0x10];
 
         u8         reserved_at_20[0x10];
         u8         op_mod[0x10];
@@ -6751,7 +6786,7 @@ struct mlx5_ifc_create_sq_out_bits {
 
 struct mlx5_ifc_create_sq_in_bits {
         u8         opcode[0x10];
-        u8         reserved_at_10[0x10];
+        u8         uid[0x10];
 
         u8         reserved_at_20[0x10];
         u8         op_mod[0x10];
@@ -6805,7 +6840,7 @@ struct mlx5_ifc_create_rqt_out_bits {
 
 struct mlx5_ifc_create_rqt_in_bits {
         u8         opcode[0x10];
-        u8         reserved_at_10[0x10];
+        u8         uid[0x10];
 
         u8         reserved_at_20[0x10];
         u8         op_mod[0x10];
@@ -6829,7 +6864,7 @@ struct mlx5_ifc_create_rq_out_bits {
 
 struct mlx5_ifc_create_rq_in_bits {
         u8         opcode[0x10];
-        u8         reserved_at_10[0x10];
+        u8         uid[0x10];
 
         u8         reserved_at_20[0x10];
         u8         op_mod[0x10];
@@ -6853,7 +6888,7 @@ struct mlx5_ifc_create_rmp_out_bits {
 
 struct mlx5_ifc_create_rmp_in_bits {
         u8         opcode[0x10];
-        u8         reserved_at_10[0x10];
+        u8         uid[0x10];
 
         u8         reserved_at_20[0x10];
         u8         op_mod[0x10];
@@ -6877,7 +6912,7 @@ struct mlx5_ifc_create_qp_out_bits {
 
 struct mlx5_ifc_create_qp_in_bits {
         u8         opcode[0x10];
-        u8         reserved_at_10[0x10];
+        u8         uid[0x10];
 
         u8         reserved_at_20[0x10];
         u8         op_mod[0x10];
@@ -6890,7 +6925,10 @@ struct mlx5_ifc_create_qp_in_bits {
 
         struct mlx5_ifc_qpc_bits qpc;
 
-        u8         reserved_at_800[0x80];
+        u8         reserved_at_800[0x60];
+
+        u8         wq_umem_valid[0x1];
+        u8         reserved_at_861[0x1f];
 
         u8         pas[0][0x40];
 };
@@ -6952,7 +6990,8 @@ struct mlx5_ifc_create_mkey_in_bits {
         u8         reserved_at_40[0x20];
 
         u8         pg_access[0x1];
-        u8         reserved_at_61[0x1f];
+        u8         mkey_umem_valid[0x1];
+        u8         reserved_at_62[0x1e];
 
         struct mlx5_ifc_mkc_bits memory_key_mkey_entry;
 
@@ -6978,7 +7017,7 @@ struct mlx5_ifc_create_flow_table_out_bits {
 };
 
 struct mlx5_ifc_flow_table_context_bits {
-        u8         encap_en[0x1];
+        u8         reformat_en[0x1];
         u8         decap_en[0x1];
         u8         reserved_at_2[0x2];
         u8         table_miss_action[0x4];
@@ -7120,7 +7159,7 @@ struct mlx5_ifc_create_dct_out_bits {
 
 struct mlx5_ifc_create_dct_in_bits {
         u8         opcode[0x10];
-        u8         reserved_at_10[0x10];
+        u8         uid[0x10];
 
         u8         reserved_at_20[0x10];
         u8         op_mod[0x10];
@@ -7146,7 +7185,7 @@ struct mlx5_ifc_create_cq_out_bits {
 
 struct mlx5_ifc_create_cq_in_bits {
         u8         opcode[0x10];
-        u8         reserved_at_10[0x10];
+        u8         uid[0x10];
 
         u8         reserved_at_20[0x10];
         u8         op_mod[0x10];
@@ -7155,7 +7194,10 @@ struct mlx5_ifc_create_cq_in_bits {
 
         struct mlx5_ifc_cqc_bits cq_context;
 
-        u8         reserved_at_280[0x600];
+        u8         reserved_at_280[0x60];
+
+        u8         cq_umem_valid[0x1];
+        u8         reserved_at_2e1[0x59f];
 
         u8         pas[0][0x40];
 };
@@ -7203,7 +7245,7 @@ struct mlx5_ifc_attach_to_mcg_out_bits {
 
 struct mlx5_ifc_attach_to_mcg_in_bits {
         u8         opcode[0x10];
-        u8         reserved_at_10[0x10];
+        u8         uid[0x10];
 
         u8         reserved_at_20[0x10];
         u8         op_mod[0x10];
@@ -7254,7 +7296,7 @@ enum {
 
 struct mlx5_ifc_arm_xrc_srq_in_bits {
         u8         opcode[0x10];
-        u8         reserved_at_10[0x10];
+        u8         uid[0x10];
 
         u8         reserved_at_20[0x10];
         u8         op_mod[0x10];
@@ -7282,7 +7324,7 @@ enum {
 
 struct mlx5_ifc_arm_rq_in_bits {
         u8         opcode[0x10];
-        u8         reserved_at_10[0x10];
+        u8         uid[0x10];
 
         u8         reserved_at_20[0x10];
         u8         op_mod[0x10];
@@ -7330,7 +7372,7 @@ struct mlx5_ifc_alloc_xrcd_out_bits {
 
 struct mlx5_ifc_alloc_xrcd_in_bits {
         u8         opcode[0x10];
-        u8         reserved_at_10[0x10];
+        u8         uid[0x10];
 
         u8         reserved_at_20[0x10];
         u8         op_mod[0x10];
@@ -7418,7 +7460,7 @@ struct mlx5_ifc_alloc_pd_out_bits {
 
 struct mlx5_ifc_alloc_pd_in_bits {
         u8         opcode[0x10];
-        u8         reserved_at_10[0x10];
+        u8         uid[0x10];
 
         u8         reserved_at_20[0x10];
         u8         op_mod[0x10];
@@ -7786,20 +7828,34 @@ struct mlx5_ifc_pplr_reg_bits {
 
 struct mlx5_ifc_pplm_reg_bits {
         u8         reserved_at_0[0x8];
-        u8         local_port[0x8];
-        u8         reserved_at_10[0x10];
+        u8         local_port[0x8];
+        u8         reserved_at_10[0x10];
 
-        u8         reserved_at_20[0x20];
+        u8         reserved_at_20[0x20];
 
-        u8         port_profile_mode[0x8];
-        u8         static_port_profile[0x8];
-        u8         active_port_profile[0x8];
-        u8         reserved_at_58[0x8];
+        u8         port_profile_mode[0x8];
+        u8         static_port_profile[0x8];
+        u8         active_port_profile[0x8];
+        u8         reserved_at_58[0x8];
 
-        u8         retransmission_active[0x8];
-        u8         fec_mode_active[0x18];
+        u8         retransmission_active[0x8];
+        u8         fec_mode_active[0x18];
 
-        u8         reserved_at_80[0x20];
+        u8         rs_fec_correction_bypass_cap[0x4];
+        u8         reserved_at_84[0x8];
+        u8         fec_override_cap_56g[0x4];
+        u8         fec_override_cap_100g[0x4];
+        u8         fec_override_cap_50g[0x4];
+        u8         fec_override_cap_25g[0x4];
+        u8         fec_override_cap_10g_40g[0x4];
+
+        u8         rs_fec_correction_bypass_admin[0x4];
+        u8         reserved_at_a4[0x8];
+        u8         fec_override_admin_56g[0x4];
+        u8         fec_override_admin_100g[0x4];
+        u8         fec_override_admin_50g[0x4];
+        u8         fec_override_admin_25g[0x4];
+        u8         fec_override_admin_10g_40g[0x4];
 };
 
 struct mlx5_ifc_ppcnt_reg_bits {
@@ -8084,7 +8140,8 @@ struct mlx5_ifc_pcam_enhanced_features_bits {
         u8         rx_icrc_encapsulated_counter[0x1];
         u8         reserved_at_6e[0x8];
         u8         pfcc_mask[0x1];
-        u8         reserved_at_77[0x4];
+        u8         reserved_at_77[0x3];
+        u8         per_lane_error_counters[0x1];
         u8         rx_buffer_fullness_counters[0x1];
         u8         ptys_connector_type[0x1];
         u8         reserved_at_7d[0x1];
@@ -8095,7 +8152,10 @@ struct mlx5_ifc_pcam_enhanced_features_bits {
 struct mlx5_ifc_pcam_regs_5000_to_507f_bits {
         u8         port_access_reg_cap_mask_127_to_96[0x20];
         u8         port_access_reg_cap_mask_95_to_64[0x20];
-        u8         port_access_reg_cap_mask_63_to_32[0x20];
+
+        u8         port_access_reg_cap_mask_63_to_36[0x1c];
+        u8         pplm[0x1];
+        u8         port_access_reg_cap_mask_34_to_32[0x3];
 
         u8         port_access_reg_cap_mask_31_to_13[0x13];
         u8         pbmc[0x1];
diff --git a/include/linux/mlx5/qp.h b/include/linux/mlx5/qp.h
index 4778d41085d4..fbe322c966bc 100644
--- a/include/linux/mlx5/qp.h
+++ b/include/linux/mlx5/qp.h
@@ -471,6 +471,7 @@ struct mlx5_core_qp {
         int                     qpn;
         struct mlx5_rsc_debug   *dbg;
         int                     pid;
+        u16                     uid;
 };
 
 struct mlx5_core_dct {
diff --git a/include/linux/mlx5/srq.h b/include/linux/mlx5/srq.h
index 24ff23e27c8a..1b1f3c20c6a3 100644
--- a/include/linux/mlx5/srq.h
+++ b/include/linux/mlx5/srq.h
@@ -61,6 +61,7 @@ struct mlx5_srq_attr {
         u32 tm_next_tag;
         u32 tm_hw_phase_cnt;
         u32 tm_sw_phase_cnt;
+        u16 uid;
 };
 
 struct mlx5_core_dev;
diff --git a/include/linux/mlx5/transobj.h b/include/linux/mlx5/transobj.h
index 83a33a1873a6..7f5ca2cd3a32 100644
--- a/include/linux/mlx5/transobj.h
+++ b/include/linux/mlx5/transobj.h
@@ -90,6 +90,8 @@ struct mlx5_hairpin {
 
         u32 *rqn;
         u32 *sqn;
+
+        bool peer_gone;
 };
 
 struct mlx5_hairpin *
diff --git a/include/linux/mlx5/vport.h b/include/linux/mlx5/vport.h
index 7e7c6dfcfb09..9c694808c212 100644
--- a/include/linux/mlx5/vport.h
+++ b/include/linux/mlx5/vport.h
@@ -121,4 +121,6 @@ int mlx5_nic_vport_query_local_lb(struct mlx5_core_dev *mdev, bool *status);
 int mlx5_nic_vport_affiliate_multiport(struct mlx5_core_dev *master_mdev,
                                        struct mlx5_core_dev *port_mdev);
 int mlx5_nic_vport_unaffiliate_multiport(struct mlx5_core_dev *port_mdev);
+
+u64 mlx5_query_nic_system_image_guid(struct mlx5_core_dev *mdev);
 #endif /* __MLX5_VPORT_H__ */
diff --git a/include/linux/mm.h b/include/linux/mm.h
index a61ebe8ad4ca..1e52b8fd1685 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -848,6 +848,8 @@ static inline bool is_zone_device_page(const struct page *page)
 {
         return page_zonenum(page) == ZONE_DEVICE;
 }
+extern void memmap_init_zone_device(struct zone *, unsigned long,
+                                    unsigned long, struct dev_pagemap *);
 #else
 static inline bool is_zone_device_page(const struct page *page)
 {
@@ -890,6 +892,19 @@ static inline bool is_device_public_page(const struct page *page)
                 page->pgmap->type == MEMORY_DEVICE_PUBLIC;
 }
 
+#ifdef CONFIG_PCI_P2PDMA
+static inline bool is_pci_p2pdma_page(const struct page *page)
+{
+        return is_zone_device_page(page) &&
+                page->pgmap->type == MEMORY_DEVICE_PCI_P2PDMA;
+}
+#else /* CONFIG_PCI_P2PDMA */
+static inline bool is_pci_p2pdma_page(const struct page *page)
+{
+        return false;
+}
+#endif /* CONFIG_PCI_P2PDMA */
+
 #else /* CONFIG_DEV_PAGEMAP_OPS */
 static inline void dev_pagemap_get_ops(void)
 {
@@ -913,6 +928,11 @@ static inline bool is_device_public_page(const struct page *page)
 {
         return false;
 }
+
+static inline bool is_pci_p2pdma_page(const struct page *page)
+{
+        return false;
+}
 #endif /* CONFIG_DEV_PAGEMAP_OPS */
 
 static inline void get_page(struct page *page)
@@ -2286,6 +2306,8 @@ extern unsigned long do_mmap(struct file *file, unsigned long addr,
         unsigned long len, unsigned long prot, unsigned long flags,
         vm_flags_t vm_flags, unsigned long pgoff, unsigned long *populate,
         struct list_head *uf);
+extern int __do_munmap(struct mm_struct *, unsigned long, size_t,
+                       struct list_head *uf, bool downgrade);
 extern int do_munmap(struct mm_struct *, unsigned long, size_t,
                      struct list_head *uf);
 
@@ -2455,6 +2477,12 @@ static inline struct vm_area_struct *find_exact_vma(struct mm_struct *mm,
         return vma;
 }
 
+static inline bool range_in_vma(struct vm_area_struct *vma,
+                                unsigned long start, unsigned long end)
+{
+        return (vma && vma->vm_start <= start && end <= vma->vm_end);
+}
+
 #ifdef CONFIG_MMU
 pgprot_t vm_get_page_prot(unsigned long vm_flags);
 void vma_set_page_prot(struct vm_area_struct *vma);
@@ -2478,11 +2506,11 @@ struct vm_area_struct *find_extend_vma(struct mm_struct *, unsigned long addr);
 int remap_pfn_range(struct vm_area_struct *, unsigned long addr,
                         unsigned long pfn, unsigned long size, pgprot_t);
 int vm_insert_page(struct vm_area_struct *, unsigned long addr, struct page *);
-int vm_insert_pfn(struct vm_area_struct *vma, unsigned long addr,
+vm_fault_t vmf_insert_pfn(struct vm_area_struct *vma, unsigned long addr,
                         unsigned long pfn);
-int vm_insert_pfn_prot(struct vm_area_struct *vma, unsigned long addr,
+vm_fault_t vmf_insert_pfn_prot(struct vm_area_struct *vma, unsigned long addr,
                         unsigned long pfn, pgprot_t pgprot);
-int vm_insert_mixed(struct vm_area_struct *vma, unsigned long addr,
+vm_fault_t vmf_insert_mixed(struct vm_area_struct *vma, unsigned long addr,
                         pfn_t pfn);
 vm_fault_t vmf_insert_mixed_mkwrite(struct vm_area_struct *vma,
                 unsigned long addr, pfn_t pfn);
@@ -2501,32 +2529,6 @@ static inline vm_fault_t vmf_insert_page(struct vm_area_struct *vma,
         return VM_FAULT_NOPAGE;
 }
 
-static inline vm_fault_t vmf_insert_mixed(struct vm_area_struct *vma,
-                                unsigned long addr, pfn_t pfn)
-{
-        int err = vm_insert_mixed(vma, addr, pfn);
-
-        if (err == -ENOMEM)
-                return VM_FAULT_OOM;
-        if (err < 0 && err != -EBUSY)
-                return VM_FAULT_SIGBUS;
-
-        return VM_FAULT_NOPAGE;
-}
-
-static inline vm_fault_t vmf_insert_pfn(struct vm_area_struct *vma,
-                        unsigned long addr, unsigned long pfn)
-{
-        int err = vm_insert_pfn(vma, addr, pfn);
-
-        if (err == -ENOMEM)
-                return VM_FAULT_OOM;
-        if (err < 0 && err != -EBUSY)
-                return VM_FAULT_SIGBUS;
-
-        return VM_FAULT_NOPAGE;
-}
-
 static inline vm_fault_t vmf_error(int err)
 {
         if (err == -ENOMEM)
@@ -2534,16 +2536,8 @@ static inline vm_fault_t vmf_error(int err)
         return VM_FAULT_SIGBUS;
 }
 
-struct page *follow_page_mask(struct vm_area_struct *vma,
-                              unsigned long address, unsigned int foll_flags,
-                              unsigned int *page_mask);
-
-static inline struct page *follow_page(struct vm_area_struct *vma,
-                unsigned long address, unsigned int foll_flags)
-{
-        unsigned int unused_page_mask;
-        return follow_page_mask(vma, address, foll_flags, &unused_page_mask);
-}
+struct page *follow_page(struct vm_area_struct *vma, unsigned long address,
+                         unsigned int foll_flags);
 
 #define FOLL_WRITE      0x01    /* check pte is writable */
 #define FOLL_TOUCH      0x02    /* mark page accessed */
diff --git a/include/linux/mm_types.h b/include/linux/mm_types.h
index cd2bc939efd0..5ed8f6292a53 100644
--- a/include/linux/mm_types.h
+++ b/include/linux/mm_types.h
@@ -341,7 +341,7 @@ struct mm_struct {
         struct {
                 struct vm_area_struct *mmap;            /* list of VMAs */
                 struct rb_root mm_rb;
-                u32 vmacache_seqnum;                   /* per-thread vmacache */
+                u64 vmacache_seqnum;                   /* per-thread vmacache */
 #ifdef CONFIG_MMU
                 unsigned long (*get_unmapped_area) (struct file *filp,
                                 unsigned long addr, unsigned long len,
diff --git a/include/linux/mm_types_task.h b/include/linux/mm_types_task.h
index 5fe87687664c..d7016dcb245e 100644
--- a/include/linux/mm_types_task.h
+++ b/include/linux/mm_types_task.h
@@ -32,7 +32,7 @@
 #define VMACACHE_MASK (VMACACHE_SIZE - 1)
 
 struct vmacache {
-        u32 seqnum;
+        u64 seqnum;
         struct vm_area_struct *vmas[VMACACHE_SIZE];
 };
 
diff --git a/include/linux/mmc/host.h b/include/linux/mmc/host.h
index beed7121c781..2a5fe75dd082 100644
--- a/include/linux/mmc/host.h
+++ b/include/linux/mmc/host.h
@@ -569,6 +569,11 @@ static inline bool mmc_can_retune(struct mmc_host *host)
         return host->can_retune == 1;
 }
 
+static inline bool mmc_doing_retune(struct mmc_host *host)
+{
+        return host->doing_retune == 1;
+}
+
 static inline enum dma_data_direction mmc_get_dma_dir(struct mmc_data *data)
 {
         return data->flags & MMC_DATA_WRITE ? DMA_TO_DEVICE : DMA_FROM_DEVICE;
diff --git a/include/linux/mmu_notifier.h b/include/linux/mmu_notifier.h
index 133ba78820ee..9893a6432adf 100644
--- a/include/linux/mmu_notifier.h
+++ b/include/linux/mmu_notifier.h
@@ -2,7 +2,6 @@
 #ifndef _LINUX_MMU_NOTIFIER_H
 #define _LINUX_MMU_NOTIFIER_H
 
-#include <linux/types.h>
 #include <linux/list.h>
 #include <linux/spinlock.h>
 #include <linux/mm_types.h>
@@ -11,9 +10,6 @@
 struct mmu_notifier;
 struct mmu_notifier_ops;
 
-/* mmu_notifier_ops flags */
-#define MMU_INVALIDATE_DOES_NOT_BLOCK   (0x01)
-
 #ifdef CONFIG_MMU_NOTIFIER
 
 /*
@@ -31,15 +27,6 @@ struct mmu_notifier_mm {
 
 struct mmu_notifier_ops {
         /*
-         * Flags to specify behavior of callbacks for this MMU notifier.
-         * Used to determine which context an operation may be called.
-         *
-         * MMU_INVALIDATE_DOES_NOT_BLOCK: invalidate_range_* callbacks do not
-         *      block
-         */
-        int flags;
-
-        /*
          * Called either by mmu_notifier_unregister or when the mm is
          * being destroyed by exit_mmap, always before all pages are
          * freed. This can run concurrently with other mmu notifier
@@ -153,7 +140,9 @@ struct mmu_notifier_ops {
          *
          * If blockable argument is set to false then the callback cannot
          * sleep and has to return with -EAGAIN. 0 should be returned
-         * otherwise.
+         * otherwise. Please note that if invalidate_range_start approves
+         * a non-blocking behavior then the same applies to
+         * invalidate_range_end.
          *
          */
         int (*invalidate_range_start)(struct mmu_notifier *mn,
@@ -181,10 +170,6 @@ struct mmu_notifier_ops {
          * Note that this function might be called with just a sub-range
          * of what was passed to invalidate_range_start()/end(), if
          * called between those functions.
-         *
-         * If this callback cannot block, and invalidate_range_{start,end}
-         * cannot block, mmu_notifier_ops.flags should have
-         * MMU_INVALIDATE_DOES_NOT_BLOCK set.
          */
         void (*invalidate_range)(struct mmu_notifier *mn, struct mm_struct *mm,
                                  unsigned long start, unsigned long end);
@@ -239,7 +224,6 @@ extern void __mmu_notifier_invalidate_range_end(struct mm_struct *mm,
                                   bool only_end);
 extern void __mmu_notifier_invalidate_range(struct mm_struct *mm,
                                   unsigned long start, unsigned long end);
-extern bool mm_has_blockable_invalidate_notifiers(struct mm_struct *mm);
 
 static inline void mmu_notifier_release(struct mm_struct *mm)
 {
@@ -493,11 +477,6 @@ static inline void mmu_notifier_invalidate_range(struct mm_struct *mm,
 {
 }
 
-static inline bool mm_has_blockable_invalidate_notifiers(struct mm_struct *mm)
-{
-        return false;
-}
-
 static inline void mmu_notifier_mm_init(struct mm_struct *mm)
 {
 }
diff --git a/include/linux/mmzone.h b/include/linux/mmzone.h
index 1e22d96734e0..9f0caccd5833 100644
--- a/include/linux/mmzone.h
+++ b/include/linux/mmzone.h
@@ -161,8 +161,10 @@ enum node_stat_item {
         NR_SLAB_UNRECLAIMABLE,
         NR_ISOLATED_ANON,       /* Temporary isolated pages from anon lru */
         NR_ISOLATED_FILE,       /* Temporary isolated pages from file lru */
+        WORKINGSET_NODES,
         WORKINGSET_REFAULT,
         WORKINGSET_ACTIVATE,
+        WORKINGSET_RESTORE,
         WORKINGSET_NODERECLAIM,
         NR_ANON_MAPPED, /* Mapped anonymous pages */
         NR_FILE_MAPPED, /* pagecache pages mapped into pagetables.
@@ -180,7 +182,7 @@ enum node_stat_item {
         NR_VMSCAN_IMMEDIATE,    /* Prioritise for reclaim when writeback ends */
         NR_DIRTIED,             /* page dirtyings since bootup */
         NR_WRITTEN,             /* page writings since bootup */
-        NR_INDIRECTLY_RECLAIMABLE_BYTES, /* measured in bytes */
+        NR_KERNEL_MISC_RECLAIMABLE,     /* reclaimable non-slab kernel pages */
         NR_VM_NODE_STAT_ITEMS
 };
 
@@ -668,16 +670,6 @@ typedef struct pglist_data {
         wait_queue_head_t kcompactd_wait;
         struct task_struct *kcompactd;
 #endif
-#ifdef CONFIG_NUMA_BALANCING
-        /* Lock serializing the migrate rate limiting window */
-        spinlock_t numabalancing_migrate_lock;
-
-        /* Rate limiting time interval */
-        unsigned long numabalancing_migrate_next_window;
-
-        /* Number of pages migrated during the rate limiting time interval */
-        unsigned long numabalancing_migrate_nr_pages;
-#endif
         /*
          * This is a per-node reserve of pages that are not available
          * to userspace allocations.
diff --git a/include/linux/mod_devicetable.h b/include/linux/mod_devicetable.h
index 1298a7daa57d..01797cb4587e 100644
--- a/include/linux/mod_devicetable.h
+++ b/include/linux/mod_devicetable.h
@@ -754,6 +754,7 @@ struct tb_service_id {
  * struct typec_device_id - USB Type-C alternate mode identifiers
  * @svid: Standard or Vendor ID
  * @mode: Mode index
+ * @driver_data: Driver specific data
  */
 struct typec_device_id {
         __u16 svid;
diff --git a/include/linux/module.h b/include/linux/module.h
index f807f15bebbe..fce6b4335e36 100644
--- a/include/linux/module.h
+++ b/include/linux/module.h
@@ -20,6 +20,7 @@
 #include <linux/export.h>
 #include <linux/rbtree_latch.h>
 #include <linux/error-injection.h>
+#include <linux/tracepoint-defs.h>
 
 #include <linux/percpu.h>
 #include <asm/module.h>
@@ -123,7 +124,6 @@ extern void cleanup_module(void);
 #define late_initcall_sync(fn)          module_init(fn)
 
 #define console_initcall(fn)            module_init(fn)
-#define security_initcall(fn)           module_init(fn)
 
 /* Each module must use one module_init(). */
 #define module_init(initfn)                                     \
@@ -430,7 +430,7 @@ struct module {
 
 #ifdef CONFIG_TRACEPOINTS
         unsigned int num_tracepoints;
-        struct tracepoint * const *tracepoints_ptrs;
+        tracepoint_ptr_t *tracepoints_ptrs;
 #endif
 #ifdef HAVE_JUMP_LABEL
         struct jump_entry *jump_entries;
diff --git a/include/linux/mroute_base.h b/include/linux/mroute_base.h
index 6675b9f81979..34de06b426ef 100644
--- a/include/linux/mroute_base.h
+++ b/include/linux/mroute_base.h
@@ -7,6 +7,7 @@
 #include <net/net_namespace.h>
 #include <net/sock.h>
 #include <net/fib_notifier.h>
+#include <net/ip_fib.h>
 
 /**
  * struct vif_device - interface representor for multicast routing
@@ -283,6 +284,12 @@ void *mr_mfc_find_any(struct mr_table *mrt, int vifi, void *hasharg);
 
 int mr_fill_mroute(struct mr_table *mrt, struct sk_buff *skb,
                    struct mr_mfc *c, struct rtmsg *rtm);
+int mr_table_dump(struct mr_table *mrt, struct sk_buff *skb,
+                  struct netlink_callback *cb,
+                  int (*fill)(struct mr_table *mrt, struct sk_buff *skb,
+                              u32 portid, u32 seq, struct mr_mfc *c,
+                              int cmd, int flags),
+                  spinlock_t *lock, struct fib_dump_filter *filter);
 int mr_rtm_dumproute(struct sk_buff *skb, struct netlink_callback *cb,
                      struct mr_table *(*iter)(struct net *net,
                                               struct mr_table *mrt),
@@ -290,7 +297,7 @@ int mr_rtm_dumproute(struct sk_buff *skb, struct netlink_callback *cb,
                                  struct sk_buff *skb,
                                  u32 portid, u32 seq, struct mr_mfc *c,
                                  int cmd, int flags),
-                     spinlock_t *lock);
+                     spinlock_t *lock, struct fib_dump_filter *filter);
 
 int mr_dump(struct net *net, struct notifier_block *nb, unsigned short family,
             int (*rules_dump)(struct net *net,
@@ -340,7 +347,7 @@ mr_rtm_dumproute(struct sk_buff *skb, struct netlink_callback *cb,
                              struct sk_buff *skb,
                              u32 portid, u32 seq, struct mr_mfc *c,
                              int cmd, int flags),
-                 spinlock_t *lock)
+                 spinlock_t *lock, struct fib_dump_filter *filter)
 {
         return -EINVAL;
 }
diff --git a/include/linux/msi.h b/include/linux/msi.h
index 5839d8062dfc..0e9c50052ff3 100644
--- a/include/linux/msi.h
+++ b/include/linux/msi.h
@@ -317,11 +317,18 @@ int msi_domain_prepare_irqs(struct irq_domain *domain, struct device *dev,
 int msi_domain_populate_irqs(struct irq_domain *domain, struct device *dev,
                              int virq, int nvec, msi_alloc_info_t *args);
 struct irq_domain *
-platform_msi_create_device_domain(struct device *dev,
-                                  unsigned int nvec,
-                                  irq_write_msi_msg_t write_msi_msg,
-                                  const struct irq_domain_ops *ops,
-                                  void *host_data);
+__platform_msi_create_device_domain(struct device *dev,
+                                    unsigned int nvec,
+                                    bool is_tree,
+                                    irq_write_msi_msg_t write_msi_msg,
+                                    const struct irq_domain_ops *ops,
+                                    void *host_data);
+
+#define platform_msi_create_device_domain(dev, nvec, write, ops, data)  \
+        __platform_msi_create_device_domain(dev, nvec, false, write, ops, data)
+#define platform_msi_create_device_tree_domain(dev, nvec, write, ops, data) \
+        __platform_msi_create_device_domain(dev, nvec, true, write, ops, data)
+
 int platform_msi_domain_alloc(struct irq_domain *domain, unsigned int virq,
                               unsigned int nr_irqs);
 void platform_msi_domain_free(struct irq_domain *domain, unsigned int virq,
diff --git a/include/linux/mtd/blktrans.h b/include/linux/mtd/blktrans.h
index e93837f647de..1d3ade69d39a 100644
--- a/include/linux/mtd/blktrans.h
+++ b/include/linux/mtd/blktrans.h
@@ -23,7 +23,6 @@
 #include <linux/mutex.h>
 #include <linux/kref.h>
 #include <linux/sysfs.h>
-#include <linux/workqueue.h>
 
 struct hd_geometry;
 struct mtd_info;
@@ -44,9 +43,9 @@ struct mtd_blktrans_dev {
         struct kref ref;
         struct gendisk *disk;
         struct attribute_group *disk_attributes;
-        struct workqueue_struct *wq;
-        struct work_struct work;
         struct request_queue *rq;
+        struct list_head rq_list;
+        struct blk_mq_tag_set *tag_set;
         spinlock_t queue_lock;
         void *priv;
         fmode_t file_mode;
diff --git a/include/linux/mtd/jedec.h b/include/linux/mtd/jedec.h
new file mode 100644
index 000000000000..0b6b59f7cfbd
--- /dev/null
+++ b/include/linux/mtd/jedec.h
@@ -0,0 +1,91 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Copyright © 2000-2010 David Woodhouse <dwmw2@infradead.org>
+ *                       Steven J. Hill <sjhill@realitydiluted.com>
+ *                       Thomas Gleixner <tglx@linutronix.de>
+ *
+ * Contains all JEDEC related definitions
+ */
+
+#ifndef __LINUX_MTD_JEDEC_H
+#define __LINUX_MTD_JEDEC_H
+
+struct jedec_ecc_info {
+        u8 ecc_bits;
+        u8 codeword_size;
+        __le16 bb_per_lun;
+        __le16 block_endurance;
+        u8 reserved[2];
+} __packed;
+
+/* JEDEC features */
+#define JEDEC_FEATURE_16_BIT_BUS        (1 << 0)
+
+struct nand_jedec_params {
+        /* rev info and features block */
+        /* 'J' 'E' 'S' 'D'  */
+        u8 sig[4];
+        __le16 revision;
+        __le16 features;
+        u8 opt_cmd[3];
+        __le16 sec_cmd;
+        u8 num_of_param_pages;
+        u8 reserved0[18];
+
+        /* manufacturer information block */
+        char manufacturer[12];
+        char model[20];
+        u8 jedec_id[6];
+        u8 reserved1[10];
+
+        /* memory organization block */
+        __le32 byte_per_page;
+        __le16 spare_bytes_per_page;
+        u8 reserved2[6];
+        __le32 pages_per_block;
+        __le32 blocks_per_lun;
+        u8 lun_count;
+        u8 addr_cycles;
+        u8 bits_per_cell;
+        u8 programs_per_page;
+        u8 multi_plane_addr;
+        u8 multi_plane_op_attr;
+        u8 reserved3[38];
+
+        /* electrical parameter block */
+        __le16 async_sdr_speed_grade;
+        __le16 toggle_ddr_speed_grade;
+        __le16 sync_ddr_speed_grade;
+        u8 async_sdr_features;
+        u8 toggle_ddr_features;
+        u8 sync_ddr_features;
+        __le16 t_prog;
+        __le16 t_bers;
+        __le16 t_r;
+        __le16 t_r_multi_plane;
+        __le16 t_ccs;
+        __le16 io_pin_capacitance_typ;
+        __le16 input_pin_capacitance_typ;
+        __le16 clk_pin_capacitance_typ;
+        u8 driver_strength_support;
+        __le16 t_adl;
+        u8 reserved4[36];
+
+        /* ECC and endurance block */
+        u8 guaranteed_good_blocks;
+        __le16 guaranteed_block_endurance;
+        struct jedec_ecc_info ecc_info[4];
+        u8 reserved5[29];
+
+        /* reserved */
+        u8 reserved6[148];
+
+        /* vendor */
+        __le16 vendor_rev_num;
+        u8 reserved7[88];
+
+        /* CRC for Parameter Page */
+        __le16 crc;
+} __packed;
+
+#endif /* __LINUX_MTD_JEDEC_H */
diff --git a/include/linux/mtd/nand_bch.h b/include/linux/mtd/nand_bch.h
index 98f20ef05d60..b8106651f807 100644
--- a/include/linux/mtd/nand_bch.h
+++ b/include/linux/mtd/nand_bch.h
@@ -12,6 +12,7 @@
 #define __MTD_NAND_BCH_H__
 
 struct mtd_info;
+struct nand_chip;
 struct nand_bch_control;
 
 #if defined(CONFIG_MTD_NAND_ECC_BCH)
@@ -21,14 +22,14 @@ static inline int mtd_nand_has_bch(void) { return 1; }
 /*
  * Calculate BCH ecc code
  */
-int nand_bch_calculate_ecc(struct mtd_info *mtd, const u_char *dat,
+int nand_bch_calculate_ecc(struct nand_chip *chip, const u_char *dat,
                            u_char *ecc_code);
 
 /*
  * Detect and correct bit errors
  */
-int nand_bch_correct_data(struct mtd_info *mtd, u_char *dat, u_char *read_ecc,
-                          u_char *calc_ecc);
+int nand_bch_correct_data(struct nand_chip *chip, u_char *dat,
+                          u_char *read_ecc, u_char *calc_ecc);
 /*
  * Initialize BCH encoder/decoder
  */
@@ -43,14 +44,14 @@ void nand_bch_free(struct nand_bch_control *nbc);
 static inline int mtd_nand_has_bch(void) { return 0; }
 
 static inline int
-nand_bch_calculate_ecc(struct mtd_info *mtd, const u_char *dat,
+nand_bch_calculate_ecc(struct nand_chip *chip, const u_char *dat,
                        u_char *ecc_code)
 {
         return -1;
 }
 
 static inline int
-nand_bch_correct_data(struct mtd_info *mtd, unsigned char *buf,
+nand_bch_correct_data(struct nand_chip *chip, unsigned char *buf,
                       unsigned char *read_ecc, unsigned char *calc_ecc)
 {
         return -ENOTSUPP;
diff --git a/include/linux/mtd/nand_ecc.h b/include/linux/mtd/nand_ecc.h
index 8a2decf7462c..0b3bb156c344 100644
--- a/include/linux/mtd/nand_ecc.h
+++ b/include/linux/mtd/nand_ecc.h
@@ -13,28 +13,30 @@
 #ifndef __MTD_NAND_ECC_H__
 #define __MTD_NAND_ECC_H__
 
-struct mtd_info;
+struct nand_chip;
 
 /*
  * Calculate 3 byte ECC code for eccsize byte block
  */
 void __nand_calculate_ecc(const u_char *dat, unsigned int eccsize,
-                                u_char *ecc_code);
+                          u_char *ecc_code, bool sm_order);
 
 /*
  * Calculate 3 byte ECC code for 256/512 byte block
  */
-int nand_calculate_ecc(struct mtd_info *mtd, const u_char *dat, u_char *ecc_code);
+int nand_calculate_ecc(struct nand_chip *chip, const u_char *dat,
+                       u_char *ecc_code);
 
 /*
  * Detect and correct a 1 bit error for eccsize byte block
  */
 int __nand_correct_data(u_char *dat, u_char *read_ecc, u_char *calc_ecc,
-                        unsigned int eccsize);
+                        unsigned int eccsize, bool sm_order);
 
 /*
  * Detect and correct a 1 bit error for 256/512 byte block
  */
-int nand_correct_data(struct mtd_info *mtd, u_char *dat, u_char *read_ecc, u_char *calc_ecc);
+int nand_correct_data(struct nand_chip *chip, u_char *dat, u_char *read_ecc,
+                      u_char *calc_ecc);
 
 #endif /* __MTD_NAND_ECC_H__ */
diff --git a/include/linux/mtd/onfi.h b/include/linux/mtd/onfi.h
new file mode 100644
index 000000000000..339ac798568e
--- /dev/null
+++ b/include/linux/mtd/onfi.h
@@ -0,0 +1,178 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Copyright © 2000-2010 David Woodhouse <dwmw2@infradead.org>
+ *                       Steven J. Hill <sjhill@realitydiluted.com>
+ *                       Thomas Gleixner <tglx@linutronix.de>
+ *
+ * Contains all ONFI related definitions
+ */
+
+#ifndef __LINUX_MTD_ONFI_H
+#define __LINUX_MTD_ONFI_H
+
+#include <linux/types.h>
+
+/* ONFI version bits */
+#define ONFI_VERSION_1_0                BIT(1)
+#define ONFI_VERSION_2_0                BIT(2)
+#define ONFI_VERSION_2_1                BIT(3)
+#define ONFI_VERSION_2_2                BIT(4)
+#define ONFI_VERSION_2_3                BIT(5)
+#define ONFI_VERSION_3_0                BIT(6)
+#define ONFI_VERSION_3_1                BIT(7)
+#define ONFI_VERSION_3_2                BIT(8)
+#define ONFI_VERSION_4_0                BIT(9)
+
+/* ONFI features */
+#define ONFI_FEATURE_16_BIT_BUS         (1 << 0)
+#define ONFI_FEATURE_EXT_PARAM_PAGE     (1 << 7)
+
+/* ONFI timing mode, used in both asynchronous and synchronous mode */
+#define ONFI_TIMING_MODE_0              (1 << 0)
+#define ONFI_TIMING_MODE_1              (1 << 1)
+#define ONFI_TIMING_MODE_2              (1 << 2)
+#define ONFI_TIMING_MODE_3              (1 << 3)
+#define ONFI_TIMING_MODE_4              (1 << 4)
+#define ONFI_TIMING_MODE_5              (1 << 5)
+#define ONFI_TIMING_MODE_UNKNOWN        (1 << 6)
+
+/* ONFI feature number/address */
+#define ONFI_FEATURE_NUMBER             256
+#define ONFI_FEATURE_ADDR_TIMING_MODE   0x1
+
+/* Vendor-specific feature address (Micron) */
+#define ONFI_FEATURE_ADDR_READ_RETRY    0x89
+#define ONFI_FEATURE_ON_DIE_ECC         0x90
+#define   ONFI_FEATURE_ON_DIE_ECC_EN    BIT(3)
+
+/* ONFI subfeature parameters length */
+#define ONFI_SUBFEATURE_PARAM_LEN       4
+
+/* ONFI optional commands SET/GET FEATURES supported? */
+#define ONFI_OPT_CMD_SET_GET_FEATURES   (1 << 2)
+
+struct nand_onfi_params {
+        /* rev info and features block */
+        /* 'O' 'N' 'F' 'I'  */
+        u8 sig[4];
+        __le16 revision;
+        __le16 features;
+        __le16 opt_cmd;
+        u8 reserved0[2];
+        __le16 ext_param_page_length; /* since ONFI 2.1 */
+        u8 num_of_param_pages;        /* since ONFI 2.1 */
+        u8 reserved1[17];
+
+        /* manufacturer information block */
+        char manufacturer[12];
+        char model[20];
+        u8 jedec_id;
+        __le16 date_code;
+        u8 reserved2[13];
+
+        /* memory organization block */
+        __le32 byte_per_page;
+        __le16 spare_bytes_per_page;
+        __le32 data_bytes_per_ppage;
+        __le16 spare_bytes_per_ppage;
+        __le32 pages_per_block;
+        __le32 blocks_per_lun;
+        u8 lun_count;
+        u8 addr_cycles;
+        u8 bits_per_cell;
+        __le16 bb_per_lun;
+        __le16 block_endurance;
+        u8 guaranteed_good_blocks;
+        __le16 guaranteed_block_endurance;
+        u8 programs_per_page;
+        u8 ppage_attr;
+        u8 ecc_bits;
+        u8 interleaved_bits;
+        u8 interleaved_ops;
+        u8 reserved3[13];
+
+        /* electrical parameter block */
+        u8 io_pin_capacitance_max;
+        __le16 async_timing_mode;
+        __le16 program_cache_timing_mode;
+        __le16 t_prog;
+        __le16 t_bers;
+        __le16 t_r;
+        __le16 t_ccs;
+        __le16 src_sync_timing_mode;
+        u8 src_ssync_features;
+        __le16 clk_pin_capacitance_typ;
+        __le16 io_pin_capacitance_typ;
+        __le16 input_pin_capacitance_typ;
+        u8 input_pin_capacitance_max;
+        u8 driver_strength_support;
+        __le16 t_int_r;
+        __le16 t_adl;
+        u8 reserved4[8];
+
+        /* vendor */
+        __le16 vendor_revision;
+        u8 vendor[88];
+
+        __le16 crc;
+} __packed;
+
+#define ONFI_CRC_BASE   0x4F4E
+
+/* Extended ECC information Block Definition (since ONFI 2.1) */
+struct onfi_ext_ecc_info {
+        u8 ecc_bits;
+        u8 codeword_size;
+        __le16 bb_per_lun;
+        __le16 block_endurance;
+        u8 reserved[2];
+} __packed;
+
+#define ONFI_SECTION_TYPE_0     0       /* Unused section. */
+#define ONFI_SECTION_TYPE_1     1       /* for additional sections. */
+#define ONFI_SECTION_TYPE_2     2       /* for ECC information. */
+struct onfi_ext_section {
+        u8 type;
+        u8 length;
+} __packed;
+
+#define ONFI_EXT_SECTION_MAX 8
+
+/* Extended Parameter Page Definition (since ONFI 2.1) */
+struct onfi_ext_param_page {
+        __le16 crc;
+        u8 sig[4];             /* 'E' 'P' 'P' 'S' */
+        u8 reserved0[10];
+        struct onfi_ext_section sections[ONFI_EXT_SECTION_MAX];
+
+        /*
+         * The actual size of the Extended Parameter Page is in
+         * @ext_param_page_length of nand_onfi_params{}.
+         * The following are the variable length sections.
+         * So we do not add any fields below. Please see the ONFI spec.
+         */
+} __packed;
+
+/**
+ * struct onfi_params - ONFI specific parameters that will be reused
+ * @version: ONFI version (BCD encoded), 0 if ONFI is not supported
+ * @tPROG: Page program time
+ * @tBERS: Block erase time
+ * @tR: Page read time
+ * @tCCS: Change column setup time
+ * @async_timing_mode: Supported asynchronous timing mode
+ * @vendor_revision: Vendor specific revision number
+ * @vendor: Vendor specific data
+ */
+struct onfi_params {
+        int version;
+        u16 tPROG;
+        u16 tBERS;
+        u16 tR;
+        u16 tCCS;
+        u16 async_timing_mode;
+        u16 vendor_revision;
+        u8 vendor[88];
+};
+
+#endif /* __LINUX_MTD_ONFI_H */
diff --git a/include/linux/mtd/platnand.h b/include/linux/mtd/platnand.h
new file mode 100644
index 000000000000..bc11eb6b593b
--- /dev/null
+++ b/include/linux/mtd/platnand.h
@@ -0,0 +1,74 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ *  Copyright © 2000-2010 David Woodhouse <dwmw2@infradead.org>
+ *                        Steven J. Hill <sjhill@realitydiluted.com>
+ *                        Thomas Gleixner <tglx@linutronix.de>
+ *
+ * Contains all platform NAND related definitions.
+ */
+
+#ifndef __LINUX_MTD_PLATNAND_H
+#define __LINUX_MTD_PLATNAND_H
+
+#include <linux/mtd/partitions.h>
+#include <linux/mtd/rawnand.h>
+#include <linux/platform_device.h>
+
+/**
+ * struct platform_nand_chip - chip level device structure
+ * @nr_chips: max. number of chips to scan for
+ * @chip_offset: chip number offset
+ * @nr_partitions: number of partitions pointed to by partitions (or zero)
+ * @partitions: mtd partition list
+ * @chip_delay: R/B delay value in us
+ * @options: Option flags, e.g. 16bit buswidth
+ * @bbt_options: BBT option flags, e.g. NAND_BBT_USE_FLASH
+ * @part_probe_types: NULL-terminated array of probe types
+ */
+struct platform_nand_chip {
+        int nr_chips;
+        int chip_offset;
+        int nr_partitions;
+        struct mtd_partition *partitions;
+        int chip_delay;
+        unsigned int options;
+        unsigned int bbt_options;
+        const char **part_probe_types;
+};
+
+/**
+ * struct platform_nand_ctrl - controller level device structure
+ * @probe: platform specific function to probe/setup hardware
+ * @remove: platform specific function to remove/teardown hardware
+ * @dev_ready: platform specific function to read ready/busy pin
+ * @select_chip: platform specific chip select function
+ * @cmd_ctrl: platform specific function for controlling
+ *            ALE/CLE/nCE. Also used to write command and address
+ * @write_buf: platform specific function for write buffer
+ * @read_buf: platform specific function for read buffer
+ * @priv: private data to transport driver specific settings
+ *
+ * All fields are optional and depend on the hardware driver requirements
+ */
+struct platform_nand_ctrl {
+        int (*probe)(struct platform_device *pdev);
+        void (*remove)(struct platform_device *pdev);
+        int (*dev_ready)(struct nand_chip *chip);
+        void (*select_chip)(struct nand_chip *chip, int cs);
+        void (*cmd_ctrl)(struct nand_chip *chip, int dat, unsigned int ctrl);
+        void (*write_buf)(struct nand_chip *chip, const uint8_t *buf, int len);
+        void (*read_buf)(struct nand_chip *chip, uint8_t *buf, int len);
+        void *priv;
+};
+
+/**
+ * struct platform_nand_data - container structure for platform-specific data
+ * @chip: chip level chip structure
+ * @ctrl: controller level device structure
+ */
+struct platform_nand_data {
+        struct platform_nand_chip chip;
+        struct platform_nand_ctrl ctrl;
+};
+
+#endif /* __LINUX_MTD_PLATNAND_H */
diff --git a/include/linux/mtd/rawnand.h b/include/linux/mtd/rawnand.h
index efb2345359bb..e10b126e148f 100644
--- a/include/linux/mtd/rawnand.h
+++ b/include/linux/mtd/rawnand.h
@@ -21,22 +21,12 @@
 #include <linux/mtd/mtd.h>
 #include <linux/mtd/flashchip.h>
 #include <linux/mtd/bbm.h>
+#include <linux/mtd/jedec.h>
+#include <linux/mtd/onfi.h>
 #include <linux/of.h>
 #include <linux/types.h>
 
-struct nand_flash_dev;
-
-/* Scan and identify a NAND device */
-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);
-}
-
-/* Internal helper for board drivers which need to override command function */
-void nand_wait_ready(struct mtd_info *mtd);
+struct nand_chip;
 
 /* The maximum number of NAND chips in an array */
 #define NAND_MAX_CHIPS          8
@@ -131,9 +121,11 @@ enum nand_ecc_algo {
 #define NAND_ECC_GENERIC_ERASED_CHECK   BIT(0)
 #define NAND_ECC_MAXIMIZE               BIT(1)
 
-/* Bit mask for flags passed to do_nand_read_ecc */
-#define NAND_GET_DEVICE         0x80
-
+/*
+ * When using software implementation of Hamming, we can specify which byte
+ * ordering should be used.
+ */
+#define NAND_ECC_SOFT_HAMMING_SM_ORDER  BIT(2)
 
 /*
  * Option constants for bizarre disfunctionality and real
@@ -175,9 +167,7 @@ enum nand_ecc_algo {
 #define NAND_SAMSUNG_LP_OPTIONS NAND_CACHEPRG
 
 /* Macros to identify the above */
-#define NAND_HAS_CACHEPROG(chip) ((chip->options & NAND_CACHEPRG))
 #define NAND_HAS_SUBPAGE_READ(chip) ((chip->options & NAND_SUBPAGE_READ))
-#define NAND_HAS_SUBPAGE_WRITE(chip) !((chip)->options & NAND_NO_SUBPAGE_WRITE)
 
 /* Non chip related options */
 /* This option skips the bbt scan during initialization. */
@@ -198,10 +188,10 @@ enum nand_ecc_algo {
 #define NAND_USE_BOUNCE_BUFFER  0x00100000
 
 /*
- * In case your controller is implementing ->cmd_ctrl() and is relying on the
- * default ->cmdfunc() implementation, you may want to let the core handle the
- * tCCS delay which is required when a column change (RNDIN or RNDOUT) is
- * requested.
+ * In case your controller is implementing ->legacy.cmd_ctrl() and is relying
+ * on the default ->cmdfunc() implementation, you may want to let the core
+ * handle the tCCS delay which is required when a column change (RNDIN or
+ * RNDOUT) is requested.
  * If your controller already takes care of this delay, you don't need to set
  * this flag.
  */
@@ -222,250 +212,6 @@ enum nand_ecc_algo {
 #define NAND_CI_CELLTYPE_MSK    0x0C
 #define NAND_CI_CELLTYPE_SHIFT  2
 
-/* Keep gcc happy */
-struct nand_chip;
-
-/* ONFI version bits */
-#define ONFI_VERSION_1_0                BIT(1)
-#define ONFI_VERSION_2_0                BIT(2)
-#define ONFI_VERSION_2_1                BIT(3)
-#define ONFI_VERSION_2_2                BIT(4)
-#define ONFI_VERSION_2_3                BIT(5)
-#define ONFI_VERSION_3_0                BIT(6)
-#define ONFI_VERSION_3_1                BIT(7)
-#define ONFI_VERSION_3_2                BIT(8)
-#define ONFI_VERSION_4_0                BIT(9)
-
-/* ONFI features */
-#define ONFI_FEATURE_16_BIT_BUS         (1 << 0)
-#define ONFI_FEATURE_EXT_PARAM_PAGE     (1 << 7)
-
-/* ONFI timing mode, used in both asynchronous and synchronous mode */
-#define ONFI_TIMING_MODE_0              (1 << 0)
-#define ONFI_TIMING_MODE_1              (1 << 1)
-#define ONFI_TIMING_MODE_2              (1 << 2)
-#define ONFI_TIMING_MODE_3              (1 << 3)
-#define ONFI_TIMING_MODE_4              (1 << 4)
-#define ONFI_TIMING_MODE_5              (1 << 5)
-#define ONFI_TIMING_MODE_UNKNOWN        (1 << 6)
-
-/* ONFI feature number/address */
-#define ONFI_FEATURE_NUMBER             256
-#define ONFI_FEATURE_ADDR_TIMING_MODE   0x1
-
-/* Vendor-specific feature address (Micron) */
-#define ONFI_FEATURE_ADDR_READ_RETRY    0x89
-#define ONFI_FEATURE_ON_DIE_ECC         0x90
-#define   ONFI_FEATURE_ON_DIE_ECC_EN    BIT(3)
-
-/* ONFI subfeature parameters length */
-#define ONFI_SUBFEATURE_PARAM_LEN       4
-
-/* ONFI optional commands SET/GET FEATURES supported? */
-#define ONFI_OPT_CMD_SET_GET_FEATURES   (1 << 2)
-
-struct nand_onfi_params {
-        /* rev info and features block */
-        /* 'O' 'N' 'F' 'I'  */
-        u8 sig[4];
-        __le16 revision;
-        __le16 features;
-        __le16 opt_cmd;
-        u8 reserved0[2];
-        __le16 ext_param_page_length; /* since ONFI 2.1 */
-        u8 num_of_param_pages;        /* since ONFI 2.1 */
-        u8 reserved1[17];
-
-        /* manufacturer information block */
-        char manufacturer[12];
-        char model[20];
-        u8 jedec_id;
-        __le16 date_code;
-        u8 reserved2[13];
-
-        /* memory organization block */
-        __le32 byte_per_page;
-        __le16 spare_bytes_per_page;
-        __le32 data_bytes_per_ppage;
-        __le16 spare_bytes_per_ppage;
-        __le32 pages_per_block;
-        __le32 blocks_per_lun;
-        u8 lun_count;
-        u8 addr_cycles;
-        u8 bits_per_cell;
-        __le16 bb_per_lun;
-        __le16 block_endurance;
-        u8 guaranteed_good_blocks;
-        __le16 guaranteed_block_endurance;
-        u8 programs_per_page;
-        u8 ppage_attr;
-        u8 ecc_bits;
-        u8 interleaved_bits;
-        u8 interleaved_ops;
-        u8 reserved3[13];
-
-        /* electrical parameter block */
-        u8 io_pin_capacitance_max;
-        __le16 async_timing_mode;
-        __le16 program_cache_timing_mode;
-        __le16 t_prog;
-        __le16 t_bers;
-        __le16 t_r;
-        __le16 t_ccs;
-        __le16 src_sync_timing_mode;
-        u8 src_ssync_features;
-        __le16 clk_pin_capacitance_typ;
-        __le16 io_pin_capacitance_typ;
-        __le16 input_pin_capacitance_typ;
-        u8 input_pin_capacitance_max;
-        u8 driver_strength_support;
-        __le16 t_int_r;
-        __le16 t_adl;
-        u8 reserved4[8];
-
-        /* vendor */
-        __le16 vendor_revision;
-        u8 vendor[88];
-
-        __le16 crc;
-} __packed;
-
-#define ONFI_CRC_BASE   0x4F4E
-
-/* Extended ECC information Block Definition (since ONFI 2.1) */
-struct onfi_ext_ecc_info {
-        u8 ecc_bits;
-        u8 codeword_size;
-        __le16 bb_per_lun;
-        __le16 block_endurance;
-        u8 reserved[2];
-} __packed;
-
-#define ONFI_SECTION_TYPE_0     0       /* Unused section. */
-#define ONFI_SECTION_TYPE_1     1       /* for additional sections. */
-#define ONFI_SECTION_TYPE_2     2       /* for ECC information. */
-struct onfi_ext_section {
-        u8 type;
-        u8 length;
-} __packed;
-
-#define ONFI_EXT_SECTION_MAX 8
-
-/* Extended Parameter Page Definition (since ONFI 2.1) */
-struct onfi_ext_param_page {
-        __le16 crc;
-        u8 sig[4];             /* 'E' 'P' 'P' 'S' */
-        u8 reserved0[10];
-        struct onfi_ext_section sections[ONFI_EXT_SECTION_MAX];
-
-        /*
-         * The actual size of the Extended Parameter Page is in
-         * @ext_param_page_length of nand_onfi_params{}.
-         * The following are the variable length sections.
-         * So we do not add any fields below. Please see the ONFI spec.
-         */
-} __packed;
-
-struct jedec_ecc_info {
-        u8 ecc_bits;
-        u8 codeword_size;
-        __le16 bb_per_lun;
-        __le16 block_endurance;
-        u8 reserved[2];
-} __packed;
-
-/* JEDEC features */
-#define JEDEC_FEATURE_16_BIT_BUS        (1 << 0)
-
-struct nand_jedec_params {
-        /* rev info and features block */
-        /* 'J' 'E' 'S' 'D'  */
-        u8 sig[4];
-        __le16 revision;
-        __le16 features;
-        u8 opt_cmd[3];
-        __le16 sec_cmd;
-        u8 num_of_param_pages;
-        u8 reserved0[18];
-
-        /* manufacturer information block */
-        char manufacturer[12];
-        char model[20];
-        u8 jedec_id[6];
-        u8 reserved1[10];
-
-        /* memory organization block */
-        __le32 byte_per_page;
-        __le16 spare_bytes_per_page;
-        u8 reserved2[6];
-        __le32 pages_per_block;
-        __le32 blocks_per_lun;
-        u8 lun_count;
-        u8 addr_cycles;
-        u8 bits_per_cell;
-        u8 programs_per_page;
-        u8 multi_plane_addr;
-        u8 multi_plane_op_attr;
-        u8 reserved3[38];
-
-        /* electrical parameter block */
-        __le16 async_sdr_speed_grade;
-        __le16 toggle_ddr_speed_grade;
-        __le16 sync_ddr_speed_grade;
-        u8 async_sdr_features;
-        u8 toggle_ddr_features;
-        u8 sync_ddr_features;
-        __le16 t_prog;
-        __le16 t_bers;
-        __le16 t_r;
-        __le16 t_r_multi_plane;
-        __le16 t_ccs;
-        __le16 io_pin_capacitance_typ;
-        __le16 input_pin_capacitance_typ;
-        __le16 clk_pin_capacitance_typ;
-        u8 driver_strength_support;
-        __le16 t_adl;
-        u8 reserved4[36];
-
-        /* ECC and endurance block */
-        u8 guaranteed_good_blocks;
-        __le16 guaranteed_block_endurance;
-        struct jedec_ecc_info ecc_info[4];
-        u8 reserved5[29];
-
-        /* reserved */
-        u8 reserved6[148];
-
-        /* vendor */
-        __le16 vendor_rev_num;
-        u8 reserved7[88];
-
-        /* CRC for Parameter Page */
-        __le16 crc;
-} __packed;
-
-/**
- * struct onfi_params - ONFI specific parameters that will be reused
- * @version: ONFI version (BCD encoded), 0 if ONFI is not supported
- * @tPROG: Page program time
- * @tBERS: Block erase time
- * @tR: Page read time
- * @tCCS: Change column setup time
- * @async_timing_mode: Supported asynchronous timing mode
- * @vendor_revision: Vendor specific revision number
- * @vendor: Vendor specific data
- */
-struct onfi_params {
-        int version;
-        u16 tPROG;
-        u16 tBERS;
-        u16 tR;
-        u16 tCCS;
-        u16 async_timing_mode;
-        u16 vendor_revision;
-        u8 vendor[88];
-};
-
 /**
  * struct nand_parameters - NAND generic parameters from the parameter page
  * @model: Model name
@@ -646,31 +392,28 @@ struct nand_ecc_ctrl {
         void *priv;
         u8 *calc_buf;
         u8 *code_buf;
-        void (*hwctl)(struct mtd_info *mtd, int mode);
-        int (*calculate)(struct mtd_info *mtd, const uint8_t *dat,
-                        uint8_t *ecc_code);
-        int (*correct)(struct mtd_info *mtd, uint8_t *dat, uint8_t *read_ecc,
-                        uint8_t *calc_ecc);
-        int (*read_page_raw)(struct mtd_info *mtd, struct nand_chip *chip,
-                        uint8_t *buf, int oob_required, int page);
-        int (*write_page_raw)(struct mtd_info *mtd, struct nand_chip *chip,
-                        const uint8_t *buf, int oob_required, int page);
-        int (*read_page)(struct mtd_info *mtd, struct nand_chip *chip,
-                        uint8_t *buf, int oob_required, int page);
-        int (*read_subpage)(struct mtd_info *mtd, struct nand_chip *chip,
-                        uint32_t offs, uint32_t len, uint8_t *buf, int page);
-        int (*write_subpage)(struct mtd_info *mtd, struct nand_chip *chip,
-                        uint32_t offset, uint32_t data_len,
-                        const uint8_t *data_buf, int oob_required, int page);
-        int (*write_page)(struct mtd_info *mtd, struct nand_chip *chip,
-                        const uint8_t *buf, int oob_required, int page);
-        int (*write_oob_raw)(struct mtd_info *mtd, struct nand_chip *chip,
-                        int page);
-        int (*read_oob_raw)(struct mtd_info *mtd, struct nand_chip *chip,
-                        int page);
-        int (*read_oob)(struct mtd_info *mtd, struct nand_chip *chip, int page);
-        int (*write_oob)(struct mtd_info *mtd, struct nand_chip *chip,
-                        int page);
+        void (*hwctl)(struct nand_chip *chip, int mode);
+        int (*calculate)(struct nand_chip *chip, const uint8_t *dat,
+                         uint8_t *ecc_code);
+        int (*correct)(struct nand_chip *chip, uint8_t *dat, uint8_t *read_ecc,
+                       uint8_t *calc_ecc);
+        int (*read_page_raw)(struct nand_chip *chip, uint8_t *buf,
+                             int oob_required, int page);
+        int (*write_page_raw)(struct nand_chip *chip, const uint8_t *buf,
+                              int oob_required, int page);
+        int (*read_page)(struct nand_chip *chip, uint8_t *buf,
+                         int oob_required, int page);
+        int (*read_subpage)(struct nand_chip *chip, uint32_t offs,
+                            uint32_t len, uint8_t *buf, int page);
+        int (*write_subpage)(struct nand_chip *chip, uint32_t offset,
+                             uint32_t data_len, const uint8_t *data_buf,
+                             int oob_required, int page);
+        int (*write_page)(struct nand_chip *chip, const uint8_t *buf,
+                          int oob_required, int page);
+        int (*write_oob_raw)(struct nand_chip *chip, int page);
+        int (*read_oob_raw)(struct nand_chip *chip, int page);
+        int (*read_oob)(struct nand_chip *chip, int page);
+        int (*write_oob)(struct nand_chip *chip, int page);
 };
 
 /**
@@ -800,24 +543,6 @@ nand_get_sdr_timings(const struct nand_data_interface *conf)
 }
 
 /**
- * struct nand_manufacturer_ops - NAND Manufacturer operations
- * @detect: detect the NAND memory organization and capabilities
- * @init: initialize all vendor specific fields (like the ->read_retry()
- *        implementation) if any.
- * @cleanup: the ->init() function may have allocated resources, ->cleanup()
- *           is here to let vendor specific code release those resources.
- * @fixup_onfi_param_page: apply vendor specific fixups to the ONFI parameter
- *                         page. This is called after the checksum is verified.
- */
-struct nand_manufacturer_ops {
-        void (*detect)(struct nand_chip *chip);
-        int (*init)(struct nand_chip *chip);
-        void (*cleanup)(struct nand_chip *chip);
-        void (*fixup_onfi_param_page)(struct nand_chip *chip,
-                                      struct nand_onfi_params *p);
-};
-
-/**
  * struct nand_op_cmd_instr - Definition of a command instruction
  * @opcode: the command to issue in one cycle
  */
@@ -1175,44 +900,72 @@ int nand_op_parser_exec_op(struct nand_chip *chip,
                            const struct nand_operation *op, bool check_only);
 
 /**
+ * struct nand_legacy - NAND chip legacy fields/hooks
+ * @IO_ADDR_R: address to read the 8 I/O lines of the flash device
+ * @IO_ADDR_W: address to write the 8 I/O lines of the flash device
+ * @read_byte: read one byte from the chip
+ * @write_byte: write a single byte to the chip on the low 8 I/O lines
+ * @write_buf: write data from the buffer to the chip
+ * @read_buf: read data from the chip into the buffer
+ * @cmd_ctrl: hardware specific function for controlling ALE/CLE/nCE. Also used
+ *            to write command and address
+ * @cmdfunc: hardware specific function for writing commands to the chip.
+ * @dev_ready: hardware specific function for accessing device ready/busy line.
+ *             If set to NULL no access to ready/busy is available and the
+ *             ready/busy information is read from the chip status register.
+ * @waitfunc: hardware specific function for wait on ready.
+ * @block_bad: check if a block is bad, using OOB markers
+ * @block_markbad: mark a block bad
+ * @erase: erase function
+ * @set_features: set the NAND chip features
+ * @get_features: get the NAND chip features
+ * @chip_delay: chip dependent delay for transferring data from array to read
+ *              regs (tR).
+ *
+ * If you look at this structure you're already wrong. These fields/hooks are
+ * all deprecated.
+ */
+struct nand_legacy {
+        void __iomem *IO_ADDR_R;
+        void __iomem *IO_ADDR_W;
+        u8 (*read_byte)(struct nand_chip *chip);
+        void (*write_byte)(struct nand_chip *chip, u8 byte);
+        void (*write_buf)(struct nand_chip *chip, const u8 *buf, int len);
+        void (*read_buf)(struct nand_chip *chip, u8 *buf, int len);
+        void (*cmd_ctrl)(struct nand_chip *chip, int dat, unsigned int ctrl);
+        void (*cmdfunc)(struct nand_chip *chip, unsigned command, int column,
+                        int page_addr);
+        int (*dev_ready)(struct nand_chip *chip);
+        int (*waitfunc)(struct nand_chip *chip);
+        int (*block_bad)(struct nand_chip *chip, loff_t ofs);
+        int (*block_markbad)(struct nand_chip *chip, loff_t ofs);
+        int (*erase)(struct nand_chip *chip, int page);
+        int (*set_features)(struct nand_chip *chip, int feature_addr,
+                            u8 *subfeature_para);
+        int (*get_features)(struct nand_chip *chip, int feature_addr,
+                            u8 *subfeature_para);
+        int chip_delay;
+};
+
+/**
  * struct nand_chip - NAND Private Flash Chip Data
  * @mtd:                MTD device registered to the MTD framework
- * @IO_ADDR_R:          [BOARDSPECIFIC] address to read the 8 I/O lines of the
- *                      flash device
- * @IO_ADDR_W:          [BOARDSPECIFIC] address to write the 8 I/O lines of the
- *                      flash device.
- * @read_byte:          [REPLACEABLE] read one byte from the chip
- * @read_word:          [REPLACEABLE] read one word from the chip
- * @write_byte:         [REPLACEABLE] write a single byte to the chip on the
- *                      low 8 I/O lines
- * @write_buf:          [REPLACEABLE] write data from the buffer to the chip
- * @read_buf:           [REPLACEABLE] read data from the chip into the buffer
+ * @legacy:             All legacy fields/hooks. If you develop a new driver,
+ *                      don't even try to use any of these fields/hooks, and if
+ *                      you're modifying an existing driver that is using those
+ *                      fields/hooks, you should consider reworking the driver
+ *                      avoid using them.
  * @select_chip:        [REPLACEABLE] select chip nr
- * @block_bad:          [REPLACEABLE] check if a block is bad, using OOB markers
- * @block_markbad:      [REPLACEABLE] mark a block bad
- * @cmd_ctrl:           [BOARDSPECIFIC] hardwarespecific function for controlling
- *                      ALE/CLE/nCE. Also used to write command and address
- * @dev_ready:          [BOARDSPECIFIC] hardwarespecific function for accessing
- *                      device ready/busy line. If set to NULL no access to
- *                      ready/busy is available and the ready/busy information
- *                      is read from the chip status register.
- * @cmdfunc:            [REPLACEABLE] hardwarespecific function for writing
- *                      commands to the chip.
- * @waitfunc:           [REPLACEABLE] hardwarespecific function for wait on
- *                      ready.
  * @exec_op:            controller specific method to execute NAND operations.
  *                      This method replaces ->cmdfunc(),
- *                      ->{read,write}_{buf,byte,word}(), ->dev_ready() and
- *                      ->waifunc().
+ *                      ->legacy.{read,write}_{buf,byte,word}(),
+ *                      ->legacy.dev_ready() and ->waifunc().
  * @setup_read_retry:   [FLASHSPECIFIC] flash (vendor) specific function for
  *                      setting the read-retry mode. Mostly needed for MLC NAND.
  * @ecc:                [BOARDSPECIFIC] ECC control structure
  * @buf_align:          minimum buffer alignment required by a platform
  * @dummy_controller:   dummy controller implementation for drivers that can
  *                      only control a single chip
- * @erase:              [REPLACEABLE] erase function
- * @chip_delay:         [BOARDSPECIFIC] chip dependent delay for transferring
- *                      data from array to read regs (tR).
  * @state:              [INTERN] the current state of the NAND device
  * @oob_poi:            "poison value buffer," used for laying out OOB data
  *                      before writing
@@ -1260,8 +1013,6 @@ int nand_op_parser_exec_op(struct nand_chip *chip,
  * @blocks_per_die:     [INTERN] The number of PEBs in a die
  * @data_interface:     [INTERN] NAND interface timing information
  * @read_retries:       [INTERN] the number of read retry modes supported
- * @set_features:       [REPLACEABLE] set the NAND chip features
- * @get_features:       [REPLACEABLE] get the NAND chip features
  * @setup_data_interface: [OPTIONAL] setup the data interface and timing. If
  *                        chipnr is set to %NAND_DATA_IFACE_CHECK_ONLY this
  *                        means the configuration should not be applied but
@@ -1283,35 +1034,17 @@ int nand_op_parser_exec_op(struct nand_chip *chip,
 
 struct nand_chip {
         struct mtd_info mtd;
-        void __iomem *IO_ADDR_R;
-        void __iomem *IO_ADDR_W;
 
-        uint8_t (*read_byte)(struct mtd_info *mtd);
-        u16 (*read_word)(struct mtd_info *mtd);
-        void (*write_byte)(struct mtd_info *mtd, uint8_t byte);
-        void (*write_buf)(struct mtd_info *mtd, const uint8_t *buf, int len);
-        void (*read_buf)(struct mtd_info *mtd, uint8_t *buf, int len);
-        void (*select_chip)(struct mtd_info *mtd, int chip);
-        int (*block_bad)(struct mtd_info *mtd, loff_t ofs);
-        int (*block_markbad)(struct mtd_info *mtd, loff_t ofs);
-        void (*cmd_ctrl)(struct mtd_info *mtd, int dat, unsigned int ctrl);
-        int (*dev_ready)(struct mtd_info *mtd);
-        void (*cmdfunc)(struct mtd_info *mtd, unsigned command, int column,
-                        int page_addr);
-        int(*waitfunc)(struct mtd_info *mtd, struct nand_chip *this);
+        struct nand_legacy legacy;
+
+        void (*select_chip)(struct nand_chip *chip, int cs);
         int (*exec_op)(struct nand_chip *chip,
                        const struct nand_operation *op,
                        bool check_only);
-        int (*erase)(struct mtd_info *mtd, int page);
-        int (*set_features)(struct mtd_info *mtd, struct nand_chip *chip,
-                            int feature_addr, uint8_t *subfeature_para);
-        int (*get_features)(struct mtd_info *mtd, struct nand_chip *chip,
-                            int feature_addr, uint8_t *subfeature_para);
-        int (*setup_read_retry)(struct mtd_info *mtd, int retry_mode);
-        int (*setup_data_interface)(struct mtd_info *mtd, int chipnr,
+        int (*setup_read_retry)(struct nand_chip *chip, int retry_mode);
+        int (*setup_data_interface)(struct nand_chip *chip, int chipnr,
                                     const struct nand_data_interface *conf);
 
-        int chip_delay;
         unsigned int options;
         unsigned int bbt_options;
 
@@ -1420,27 +1153,6 @@ static inline void *nand_get_manufacturer_data(struct nand_chip *chip)
 }
 
 /*
- * NAND Flash Manufacturer ID Codes
- */
-#define NAND_MFR_TOSHIBA        0x98
-#define NAND_MFR_ESMT           0xc8
-#define NAND_MFR_SAMSUNG        0xec
-#define NAND_MFR_FUJITSU        0x04
-#define NAND_MFR_NATIONAL       0x8f
-#define NAND_MFR_RENESAS        0x07
-#define NAND_MFR_STMICRO        0x20
-#define NAND_MFR_HYNIX          0xad
-#define NAND_MFR_MICRON         0x2c
-#define NAND_MFR_AMD            0x01
-#define NAND_MFR_MACRONIX       0xc2
-#define NAND_MFR_EON            0x92
-#define NAND_MFR_SANDISK        0x45
-#define NAND_MFR_INTEL          0x89
-#define NAND_MFR_ATO            0x9b
-#define NAND_MFR_WINBOND        0xef
-
-
-/*
  * A helper for defining older NAND chips where the second ID byte fully
  * defined the chip, including the geometry (chip size, eraseblock size, page
  * size). All these chips have 512 bytes NAND page size.
@@ -1519,114 +1231,7 @@ struct nand_flash_dev {
         int onfi_timing_mode_default;
 };
 
-/**
- * struct nand_manufacturer - NAND Flash Manufacturer structure
- * @name:       Manufacturer name
- * @id:         manufacturer ID code of device.
- * @ops:        manufacturer operations
-*/
-struct nand_manufacturer {
-        int id;
-        char *name;
-        const struct nand_manufacturer_ops *ops;
-};
-
-const struct nand_manufacturer *nand_get_manufacturer(u8 id);
-
-static inline const char *
-nand_manufacturer_name(const struct nand_manufacturer *manufacturer)
-{
-        return manufacturer ? manufacturer->name : "Unknown";
-}
-
-extern struct nand_flash_dev nand_flash_ids[];
-
-extern const struct nand_manufacturer_ops toshiba_nand_manuf_ops;
-extern const struct nand_manufacturer_ops samsung_nand_manuf_ops;
-extern const struct nand_manufacturer_ops hynix_nand_manuf_ops;
-extern const struct nand_manufacturer_ops micron_nand_manuf_ops;
-extern const struct nand_manufacturer_ops amd_nand_manuf_ops;
-extern const struct nand_manufacturer_ops macronix_nand_manuf_ops;
-
 int nand_create_bbt(struct nand_chip *chip);
-int nand_markbad_bbt(struct mtd_info *mtd, loff_t offs);
-int nand_isreserved_bbt(struct mtd_info *mtd, loff_t offs);
-int nand_isbad_bbt(struct mtd_info *mtd, loff_t offs, int allowbbt);
-int nand_erase_nand(struct mtd_info *mtd, struct erase_info *instr,
-                    int allowbbt);
-
-/**
- * struct platform_nand_chip - chip level device structure
- * @nr_chips:           max. number of chips to scan for
- * @chip_offset:        chip number offset
- * @nr_partitions:      number of partitions pointed to by partitions (or zero)
- * @partitions:         mtd partition list
- * @chip_delay:         R/B delay value in us
- * @options:            Option flags, e.g. 16bit buswidth
- * @bbt_options:        BBT option flags, e.g. NAND_BBT_USE_FLASH
- * @part_probe_types:   NULL-terminated array of probe types
- */
-struct platform_nand_chip {
-        int nr_chips;
-        int chip_offset;
-        int nr_partitions;
-        struct mtd_partition *partitions;
-        int chip_delay;
-        unsigned int options;
-        unsigned int bbt_options;
-        const char **part_probe_types;
-};
-
-/* Keep gcc happy */
-struct platform_device;
-
-/**
- * struct platform_nand_ctrl - controller level device structure
- * @probe:              platform specific function to probe/setup hardware
- * @remove:             platform specific function to remove/teardown hardware
- * @dev_ready:          platform specific function to read ready/busy pin
- * @select_chip:        platform specific chip select function
- * @cmd_ctrl:           platform specific function for controlling
- *                      ALE/CLE/nCE. Also used to write command and address
- * @write_buf:          platform specific function for write buffer
- * @read_buf:           platform specific function for read buffer
- * @priv:               private data to transport driver specific settings
- *
- * All fields are optional and depend on the hardware driver requirements
- */
-struct platform_nand_ctrl {
-        int (*probe)(struct platform_device *pdev);
-        void (*remove)(struct platform_device *pdev);
-        int (*dev_ready)(struct mtd_info *mtd);
-        void (*select_chip)(struct mtd_info *mtd, int chip);
-        void (*cmd_ctrl)(struct mtd_info *mtd, int dat, unsigned int ctrl);
-        void (*write_buf)(struct mtd_info *mtd, const uint8_t *buf, int len);
-        void (*read_buf)(struct mtd_info *mtd, uint8_t *buf, int len);
-        void *priv;
-};
-
-/**
- * struct platform_nand_data - container structure for platform-specific data
- * @chip:               chip level chip structure
- * @ctrl:               controller level device structure
- */
-struct platform_nand_data {
-        struct platform_nand_chip chip;
-        struct platform_nand_ctrl ctrl;
-};
-
-/* return the supported asynchronous timing mode. */
-static inline int onfi_get_async_timing_mode(struct nand_chip *chip)
-{
-        if (!chip->parameters.onfi)
-                return ONFI_TIMING_MODE_UNKNOWN;
-
-        return chip->parameters.onfi->async_timing_mode;
-}
-
-int onfi_fill_data_interface(struct nand_chip *chip,
-                             enum nand_data_interface_type type,
-                             int timing_mode);
 
 /*
  * Check if it is a SLC nand.
@@ -1658,9 +1263,6 @@ static inline int nand_opcode_8bits(unsigned int command)
         return 0;
 }
 
-/* get timing characteristics from ONFI timing mode. */
-const struct nand_sdr_timings *onfi_async_timing_mode_to_sdr_timings(int mode);
-
 int nand_check_erased_ecc_chunk(void *data, int datalen,
                                 void *ecc, int ecclen,
                                 void *extraoob, int extraooblen,
@@ -1670,37 +1272,22 @@ int nand_ecc_choose_conf(struct nand_chip *chip,
                          const struct nand_ecc_caps *caps, int oobavail);
 
 /* Default write_oob implementation */
-int nand_write_oob_std(struct mtd_info *mtd, struct nand_chip *chip, int page);
-
-/* Default write_oob syndrome implementation */
-int nand_write_oob_syndrome(struct mtd_info *mtd, struct nand_chip *chip,
-                            int page);
+int nand_write_oob_std(struct nand_chip *chip, int page);
 
 /* Default read_oob implementation */
-int nand_read_oob_std(struct mtd_info *mtd, struct nand_chip *chip, int page);
+int nand_read_oob_std(struct nand_chip *chip, int page);
 
-/* Default read_oob syndrome implementation */
-int nand_read_oob_syndrome(struct mtd_info *mtd, struct nand_chip *chip,
-                           int page);
-
-/* Wrapper to use in order for controllers/vendors to GET/SET FEATURES */
-int nand_get_features(struct nand_chip *chip, int addr, u8 *subfeature_param);
-int nand_set_features(struct nand_chip *chip, int addr, u8 *subfeature_param);
 /* Stub used by drivers that do not support GET/SET FEATURES operations */
-int nand_get_set_features_notsupp(struct mtd_info *mtd, struct nand_chip *chip,
-                                  int addr, u8 *subfeature_param);
+int nand_get_set_features_notsupp(struct nand_chip *chip, int addr,
+                                  u8 *subfeature_param);
 
 /* Default read_page_raw implementation */
-int nand_read_page_raw(struct mtd_info *mtd, struct nand_chip *chip,
-                       uint8_t *buf, int oob_required, int page);
-int nand_read_page_raw_notsupp(struct mtd_info *mtd, struct nand_chip *chip,
-                               u8 *buf, int oob_required, int page);
+int nand_read_page_raw(struct nand_chip *chip, uint8_t *buf, int oob_required,
+                       int page);
 
 /* Default write_page_raw implementation */
-int nand_write_page_raw(struct mtd_info *mtd, struct nand_chip *chip,
-                        const uint8_t *buf, int oob_required, int page);
-int nand_write_page_raw_notsupp(struct mtd_info *mtd, struct nand_chip *chip,
-                                const u8 *buf, int oob_required, int page);
+int nand_write_page_raw(struct nand_chip *chip, const uint8_t *buf,
+                        int oob_required, int page);
 
 /* Reset and initialize a NAND device */
 int nand_reset(struct nand_chip *chip, int chipnr);
@@ -1710,7 +1297,6 @@ int nand_reset_op(struct nand_chip *chip);
 int nand_readid_op(struct nand_chip *chip, u8 addr, void *buf,
                    unsigned int len);
 int nand_status_op(struct nand_chip *chip, u8 *status);
-int nand_exit_status_op(struct nand_chip *chip);
 int nand_erase_op(struct nand_chip *chip, unsigned int eraseblock);
 int nand_read_page_op(struct nand_chip *chip, unsigned int page,
                       unsigned int offset_in_page, void *buf, unsigned int len);
@@ -1734,16 +1320,25 @@ int nand_read_data_op(struct nand_chip *chip, void *buf, unsigned int len,
 int nand_write_data_op(struct nand_chip *chip, const void *buf,
                        unsigned int len, bool force_8bit);
 
+/* Scan and identify a NAND device */
+int nand_scan_with_ids(struct nand_chip *chip, unsigned int max_chips,
+                       struct nand_flash_dev *ids);
+
+static inline int nand_scan(struct nand_chip *chip, unsigned int max_chips)
+{
+        return nand_scan_with_ids(chip, max_chips, NULL);
+}
+
+/* Internal helper for board drivers which need to override command function */
+void nand_wait_ready(struct nand_chip *chip);
+
 /*
  * Free resources held by the NAND device, must be called on error after a
  * sucessful nand_scan().
  */
 void nand_cleanup(struct nand_chip *chip);
 /* Unregister the MTD device and calls nand_cleanup() */
-void nand_release(struct mtd_info *mtd);
-
-/* Default extended ID decoding function */
-void nand_decode_ext_id(struct nand_chip *chip);
+void nand_release(struct nand_chip *chip);
 
 /*
  * External helper for controller drivers that have to implement the WAITRDY
diff --git a/include/linux/mtd/spi-nor.h b/include/linux/mtd/spi-nor.h
index c922e97f205a..7f0c7303575e 100644
--- a/include/linux/mtd/spi-nor.h
+++ b/include/linux/mtd/spi-nor.h
@@ -239,6 +239,94 @@ enum spi_nor_option_flags {
 };
 
 /**
+ * struct spi_nor_erase_type - Structure to describe a SPI NOR erase type
+ * @size:               the size of the sector/block erased by the erase type.
+ *                      JEDEC JESD216B imposes erase sizes to be a power of 2.
+ * @size_shift:         @size is a power of 2, the shift is stored in
+ *                      @size_shift.
+ * @size_mask:          the size mask based on @size_shift.
+ * @opcode:             the SPI command op code to erase the sector/block.
+ * @idx:                Erase Type index as sorted in the Basic Flash Parameter
+ *                      Table. It will be used to synchronize the supported
+ *                      Erase Types with the ones identified in the SFDP
+ *                      optional tables.
+ */
+struct spi_nor_erase_type {
+        u32     size;
+        u32     size_shift;
+        u32     size_mask;
+        u8      opcode;
+        u8      idx;
+};
+
+/**
+ * struct spi_nor_erase_command - Used for non-uniform erases
+ * The structure is used to describe a list of erase commands to be executed
+ * once we validate that the erase can be performed. The elements in the list
+ * are run-length encoded.
+ * @list:               for inclusion into the list of erase commands.
+ * @count:              how many times the same erase command should be
+ *                      consecutively used.
+ * @size:               the size of the sector/block erased by the command.
+ * @opcode:             the SPI command op code to erase the sector/block.
+ */
+struct spi_nor_erase_command {
+        struct list_head        list;
+        u32                     count;
+        u32                     size;
+        u8                      opcode;
+};
+
+/**
+ * struct spi_nor_erase_region - Structure to describe a SPI NOR erase region
+ * @offset:             the offset in the data array of erase region start.
+ *                      LSB bits are used as a bitmask encoding flags to
+ *                      determine if this region is overlaid, if this region is
+ *                      the last in the SPI NOR flash memory and to indicate
+ *                      all the supported erase commands inside this region.
+ *                      The erase types are sorted in ascending order with the
+ *                      smallest Erase Type size being at BIT(0).
+ * @size:               the size of the region in bytes.
+ */
+struct spi_nor_erase_region {
+        u64             offset;
+        u64             size;
+};
+
+#define SNOR_ERASE_TYPE_MAX     4
+#define SNOR_ERASE_TYPE_MASK    GENMASK_ULL(SNOR_ERASE_TYPE_MAX - 1, 0)
+
+#define SNOR_LAST_REGION        BIT(4)
+#define SNOR_OVERLAID_REGION    BIT(5)
+
+#define SNOR_ERASE_FLAGS_MAX    6
+#define SNOR_ERASE_FLAGS_MASK   GENMASK_ULL(SNOR_ERASE_FLAGS_MAX - 1, 0)
+
+/**
+ * struct spi_nor_erase_map - Structure to describe the SPI NOR erase map
+ * @regions:            array of erase regions. The regions are consecutive in
+ *                      address space. Walking through the regions is done
+ *                      incrementally.
+ * @uniform_region:     a pre-allocated erase region for SPI NOR with a uniform
+ *                      sector size (legacy implementation).
+ * @erase_type:         an array of erase types shared by all the regions.
+ *                      The erase types are sorted in ascending order, with the
+ *                      smallest Erase Type size being the first member in the
+ *                      erase_type array.
+ * @uniform_erase_type: bitmask encoding erase types that can erase the
+ *                      entire memory. This member is completed at init by
+ *                      uniform and non-uniform SPI NOR flash memories if they
+ *                      support at least one erase type that can erase the
+ *                      entire memory.
+ */
+struct spi_nor_erase_map {
+        struct spi_nor_erase_region     *regions;
+        struct spi_nor_erase_region     uniform_region;
+        struct spi_nor_erase_type       erase_type[SNOR_ERASE_TYPE_MAX];
+        u8                              uniform_erase_type;
+};
+
+/**
  * struct flash_info - Forward declaration of a structure used internally by
  *                     spi_nor_scan()
  */
@@ -262,6 +350,7 @@ struct flash_info;
  * @write_proto:        the SPI protocol for write operations
  * @reg_proto           the SPI protocol for read_reg/write_reg/erase operations
  * @cmd_buf:            used by the write_reg
+ * @erase_map:          the erase map of the SPI NOR
  * @prepare:            [OPTIONAL] do some preparations for the
  *                      read/write/erase/lock/unlock operations
  * @unprepare:          [OPTIONAL] do some post work after the
@@ -297,6 +386,7 @@ struct spi_nor {
         bool                    sst_write_second;
         u32                     flags;
         u8                      cmd_buf[SPI_NOR_MAX_CMD_SIZE];
+        struct spi_nor_erase_map        erase_map;
 
         int (*prepare)(struct spi_nor *nor, enum spi_nor_ops ops);
         void (*unprepare)(struct spi_nor *nor, enum spi_nor_ops ops);
@@ -317,6 +407,35 @@ struct spi_nor {
         void *priv;
 };
 
+static u64 __maybe_unused
+spi_nor_region_is_last(const struct spi_nor_erase_region *region)
+{
+        return region->offset & SNOR_LAST_REGION;
+}
+
+static u64 __maybe_unused
+spi_nor_region_end(const struct spi_nor_erase_region *region)
+{
+        return (region->offset & ~SNOR_ERASE_FLAGS_MASK) + region->size;
+}
+
+static void __maybe_unused
+spi_nor_region_mark_end(struct spi_nor_erase_region *region)
+{
+        region->offset |= SNOR_LAST_REGION;
+}
+
+static void __maybe_unused
+spi_nor_region_mark_overlay(struct spi_nor_erase_region *region)
+{
+        region->offset |= SNOR_OVERLAID_REGION;
+}
+
+static bool __maybe_unused spi_nor_has_uniform_erase(const struct spi_nor *nor)
+{
+        return !!nor->erase_map.uniform_erase_type;
+}
+
 static inline void spi_nor_set_flash_node(struct spi_nor *nor,
                                           struct device_node *np)
 {
diff --git a/include/linux/ndctl.h b/include/linux/ndctl.h
new file mode 100644
index 000000000000..cd5a293ce3ae
--- /dev/null
+++ b/include/linux/ndctl.h
@@ -0,0 +1,22 @@
+/*
+ * Copyright (c) 2014-2016, Intel Corporation.
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU Lesser General Public License,
+ * version 2.1, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope it will be useful, but WITHOUT ANY
+ * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for
+ * more details.
+ */
+#ifndef _LINUX_NDCTL_H
+#define _LINUX_NDCTL_H
+
+#include <uapi/linux/ndctl.h>
+
+enum {
+        ND_MIN_NAMESPACE_SIZE = PAGE_SIZE,
+};
+
+#endif /* _LINUX_NDCTL_H */
diff --git a/include/linux/netdevice.h b/include/linux/netdevice.h
index ca5ab98053c8..dc1d9ed33b31 100644
--- a/include/linux/netdevice.h
+++ b/include/linux/netdevice.h
@@ -535,6 +535,32 @@ static inline void napi_synchronize(const struct napi_struct *n)
                 barrier();
 }
 
+/**
+ *      napi_if_scheduled_mark_missed - if napi is running, set the
+ *      NAPIF_STATE_MISSED
+ *      @n: NAPI context
+ *
+ * If napi is running, set the NAPIF_STATE_MISSED, and return true if
+ * NAPI is scheduled.
+ **/
+static inline bool napi_if_scheduled_mark_missed(struct napi_struct *n)
+{
+        unsigned long val, new;
+
+        do {
+                val = READ_ONCE(n->state);
+                if (val & NAPIF_STATE_DISABLE)
+                        return true;
+
+                if (!(val & NAPIF_STATE_SCHED))
+                        return false;
+
+                new = val | NAPIF_STATE_MISSED;
+        } while (cmpxchg(&n->state, val, new) != val);
+
+        return true;
+}
+
 enum netdev_queue_state_t {
         __QUEUE_STATE_DRV_XOFF,
         __QUEUE_STATE_STACK_XOFF,
@@ -583,6 +609,9 @@ struct netdev_queue {
 
         /* Subordinate device that the queue has been assigned to */
         struct net_device       *sb_dev;
+#ifdef CONFIG_XDP_SOCKETS
+        struct xdp_umem         *umem;
+#endif
 /*
  * write-mostly part
  */
@@ -712,6 +741,9 @@ struct netdev_rx_queue {
         struct kobject                  kobj;
         struct net_device               *dev;
         struct xdp_rxq_info             xdp_rxq;
+#ifdef CONFIG_XDP_SOCKETS
+        struct xdp_umem                 *umem;
+#endif
 } ____cacheline_aligned_in_smp;
 
 /*
@@ -1730,6 +1762,8 @@ enum netdev_priv_flags {
  *                      switch driver and used to set the phys state of the
  *                      switch port.
  *
+ *      @wol_enabled:   Wake-on-LAN is enabled
+ *
  *      FIXME: cleanup struct net_device such that network protocol info
  *      moves out.
  */
@@ -1974,7 +2008,6 @@ struct net_device {
                 struct pcpu_lstats __percpu             *lstats;
                 struct pcpu_sw_netstats __percpu        *tstats;
                 struct pcpu_dstats __percpu             *dstats;
-                struct pcpu_vstats __percpu             *vstats;
         };
 
 #if IS_ENABLED(CONFIG_GARP)
@@ -2014,6 +2047,7 @@ struct net_device {
         struct lock_class_key   *qdisc_tx_busylock;
         struct lock_class_key   *qdisc_running_key;
         bool                    proto_down;
+        unsigned                wol_enabled:1;
 };
 #define to_net_dev(d) container_of(d, struct net_device, dev)
 
@@ -2317,6 +2351,7 @@ static inline struct sk_buff *call_gro_receive_sk(gro_receive_sk_t cb,
 
 struct packet_type {
         __be16                  type;   /* This is really htons(ether_type). */
+        bool                    ignore_outgoing;
         struct net_device       *dev;   /* NULL is wildcarded here           */
         int                     (*func) (struct sk_buff *,
                                          struct net_device *,
@@ -2355,6 +2390,12 @@ struct pcpu_sw_netstats {
         struct u64_stats_sync   syncp;
 };
 
+struct pcpu_lstats {
+        u64 packets;
+        u64 bytes;
+        struct u64_stats_sync syncp;
+};
+
 #define __netdev_alloc_pcpu_stats(type, gfp)                            \
 ({                                                                      \
         typeof(type) __percpu *pcpu_stats = alloc_percpu_gfp(type, gfp);\
@@ -2455,6 +2496,13 @@ struct netdev_notifier_info {
         struct netlink_ext_ack  *extack;
 };
 
+struct netdev_notifier_info_ext {
+        struct netdev_notifier_info info; /* must be first */
+        union {
+                u32 mtu;
+        } ext;
+};
+
 struct netdev_notifier_change_info {
         struct netdev_notifier_info info; /* must be first */
         unsigned int flags_changed;
@@ -3597,6 +3645,7 @@ static __always_inline int ____dev_forward_skb(struct net_device *dev,
         return 0;
 }
 
+bool dev_nit_active(struct net_device *dev);
 void dev_queue_xmit_nit(struct sk_buff *skb, struct net_device *dev);
 
 extern int              netdev_budget;
diff --git a/include/linux/netfilter.h b/include/linux/netfilter.h
index 07efffd0c759..bbe99d2b28b4 100644
--- a/include/linux/netfilter.h
+++ b/include/linux/netfilter.h
@@ -215,6 +215,8 @@ static inline int nf_hook(u_int8_t pf, unsigned int hook, struct net *net,
                 break;
         case NFPROTO_ARP:
 #ifdef CONFIG_NETFILTER_FAMILY_ARP
+                if (WARN_ON_ONCE(hook >= ARRAY_SIZE(net->nf.hooks_arp)))
+                        break;
                 hook_head = rcu_dereference(net->nf.hooks_arp[hook]);
 #endif
                 break;
diff --git a/include/linux/netfilter/nf_conntrack_common.h b/include/linux/netfilter/nf_conntrack_common.h
index 03097fa70975..e142b2b5f1ea 100644
--- a/include/linux/netfilter/nf_conntrack_common.h
+++ b/include/linux/netfilter/nf_conntrack_common.h
@@ -19,7 +19,4 @@ struct ip_conntrack_stat {
         unsigned int search_restart;
 };
 
-/* call to create an explicit dependency on nf_conntrack. */
-void need_conntrack(void);
-
 #endif /* _NF_CONNTRACK_COMMON_H */
diff --git a/include/linux/netfilter/nfnetlink_osf.h b/include/linux/netfilter/nfnetlink_osf.h
index ecf7dab81e9e..c6000046c966 100644
--- a/include/linux/netfilter/nfnetlink_osf.h
+++ b/include/linux/netfilter/nfnetlink_osf.h
@@ -27,6 +27,7 @@ bool nf_osf_match(const struct sk_buff *skb, u_int8_t family,
                   const struct list_head *nf_osf_fingers);
 
 const char *nf_osf_find(const struct sk_buff *skb,
-                        const struct list_head *nf_osf_fingers);
+                        const struct list_head *nf_osf_fingers,
+                        const int ttl_check);
 
 #endif /* _NFOSF_H */
diff --git a/include/linux/netlink.h b/include/linux/netlink.h
index 71f121b66ca8..4da90a6ab536 100644
--- a/include/linux/netlink.h
+++ b/include/linux/netlink.h
@@ -176,8 +176,11 @@ struct netlink_callback {
         void                    *data;
         /* the module that dump function belong to */
         struct module           *module;
+        struct netlink_ext_ack  *extack;
         u16                     family;
         u16                     min_dump_alloc;
+        bool                    strict_check;
+        u16                     answer_flags;
         unsigned int            prev_seq, seq;
         long                    args[6];
 };
diff --git a/include/linux/netpoll.h b/include/linux/netpoll.h
index 67662d01130a..676f1ff161a9 100644
--- a/include/linux/netpoll.h
+++ b/include/linux/netpoll.h
@@ -31,8 +31,6 @@ struct netpoll {
         bool ipv6;
         u16 local_port, remote_port;
         u8 remote_mac[ETH_ALEN];
-
-        struct work_struct cleanup_work;
 };
 
 struct netpoll_info {
@@ -49,8 +47,9 @@ struct netpoll_info {
 };
 
 #ifdef CONFIG_NETPOLL
-extern void netpoll_poll_disable(struct net_device *dev);
-extern void netpoll_poll_enable(struct net_device *dev);
+void netpoll_poll_dev(struct net_device *dev);
+void netpoll_poll_disable(struct net_device *dev);
+void netpoll_poll_enable(struct net_device *dev);
 #else
 static inline void netpoll_poll_disable(struct net_device *dev) { return; }
 static inline void netpoll_poll_enable(struct net_device *dev) { return; }
@@ -62,7 +61,7 @@ int netpoll_parse_options(struct netpoll *np, char *opt);
 int __netpoll_setup(struct netpoll *np, struct net_device *ndev);
 int netpoll_setup(struct netpoll *np);
 void __netpoll_cleanup(struct netpoll *np);
-void __netpoll_free_async(struct netpoll *np);
+void __netpoll_free(struct netpoll *np);
 void netpoll_cleanup(struct netpoll *np);
 void netpoll_send_skb_on_dev(struct netpoll *np, struct sk_buff *skb,
                              struct net_device *dev);
diff --git a/include/linux/nfs_fs.h b/include/linux/nfs_fs.h
index a0831e9d19c9..6e0417c02279 100644
--- a/include/linux/nfs_fs.h
+++ b/include/linux/nfs_fs.h
@@ -62,6 +62,7 @@ struct nfs_lock_context {
         struct nfs_open_context *open_context;
         fl_owner_t lockowner;
         atomic_t io_count;
+        struct rcu_head rcu_head;
 };
 
 struct nfs4_state;
@@ -82,6 +83,7 @@ struct nfs_open_context {
 
         struct list_head list;
         struct nfs4_threshold   *mdsthreshold;
+        struct rcu_head rcu_head;
 };
 
 struct nfs_open_dir_context {
diff --git a/include/linux/nfs_fs_sb.h b/include/linux/nfs_fs_sb.h
index bf39d9c92201..0fc0b9135d46 100644
--- a/include/linux/nfs_fs_sb.h
+++ b/include/linux/nfs_fs_sb.h
@@ -228,6 +228,9 @@ struct nfs_server {
         unsigned short          mountd_port;
         unsigned short          mountd_protocol;
         struct rpc_wait_queue   uoc_rpcwaitq;
+
+        /* XDR related information */
+        unsigned int            read_hdrsize;
 };
 
 /* Server capabilities */
diff --git a/include/linux/nfs_xdr.h b/include/linux/nfs_xdr.h
index bd1c889a9ed9..0e016252cfc6 100644
--- a/include/linux/nfs_xdr.h
+++ b/include/linux/nfs_xdr.h
@@ -608,8 +608,13 @@ struct nfs_pgio_args {
         __u32                   count;
         unsigned int            pgbase;
         struct page **          pages;
-        const u32 *             bitmask;        /* used by write */
-        enum nfs3_stable_how    stable;         /* used by write */
+        union {
+                unsigned int            replen;                 /* used by read */
+                struct {
+                        const u32 *             bitmask;        /* used by write */
+                        enum nfs3_stable_how    stable;         /* used by write */
+                };
+        };
 };
 
 struct nfs_pgio_res {
@@ -617,10 +622,16 @@ struct nfs_pgio_res {
         struct nfs_fattr *      fattr;
         __u32                   count;
         __u32                   op_status;
-        int                     eof;            /* used by read */
-        struct nfs_writeverf *  verf;           /* used by write */
-        const struct nfs_server *server;        /* used by write */
-
+        union {
+                struct {
+                        unsigned int            replen;         /* used by read */
+                        int                     eof;            /* used by read */
+                };
+                struct {
+                        struct nfs_writeverf *  verf;           /* used by write */
+                        const struct nfs_server *server;        /* used by write */
+                };
+        };
 };
 
 /*
@@ -1471,11 +1482,10 @@ struct nfs_pgio_header {
         const struct nfs_rw_ops *rw_ops;
         struct nfs_io_completion *io_completion;
         struct nfs_direct_req   *dreq;
-        spinlock_t              lock;
-        /* fields protected by lock */
+
         int                     pnfs_error;
         int                     error;          /* merge with pnfs_error */
-        unsigned long           good_bytes;     /* boundary of good data */
+        unsigned int            good_bytes;     /* boundary of good data */
         unsigned long           flags;
 
         /*
diff --git a/include/linux/nvme.h b/include/linux/nvme.h
index 68e91ef5494c..818dbe9331be 100644
--- a/include/linux/nvme.h
+++ b/include/linux/nvme.h
@@ -1241,6 +1241,7 @@ enum {
         NVME_SC_ANA_PERSISTENT_LOSS     = 0x301,
         NVME_SC_ANA_INACCESSIBLE        = 0x302,
         NVME_SC_ANA_TRANSITION          = 0x303,
+        NVME_SC_HOST_PATH_ERROR         = 0x370,
 
         NVME_SC_DNR                     = 0x4000,
 };
diff --git a/include/linux/nvmem-consumer.h b/include/linux/nvmem-consumer.h
index 4e85447f7860..312bfa5efd80 100644
--- a/include/linux/nvmem-consumer.h
+++ b/include/linux/nvmem-consumer.h
@@ -1,12 +1,9 @@
+/* SPDX-License-Identifier: GPL-2.0 */
 /*
  * nvmem framework consumer.
  *
  * Copyright (C) 2015 Srinivas Kandagatla <srinivas.kandagatla@linaro.org>
  * Copyright (C) 2013 Maxime Ripard <maxime.ripard@free-electrons.com>
- *
- * This file is licensed under the terms of the GNU General Public
- * License version 2.  This program is licensed "as is" without any
- * warranty of any kind, whether express or implied.
  */
 
 #ifndef _LINUX_NVMEM_CONSUMER_H
@@ -14,6 +11,7 @@
 
 #include <linux/err.h>
 #include <linux/errno.h>
+#include <linux/notifier.h>
 
 struct device;
 struct device_node;
@@ -29,11 +27,36 @@ struct nvmem_cell_info {
         unsigned int            nbits;
 };
 
+/**
+ * struct nvmem_cell_lookup - cell lookup entry
+ *
+ * @nvmem_name: Name of the provider.
+ * @cell_name:  Name of the nvmem cell as defined in the name field of
+ *              struct nvmem_cell_info.
+ * @dev_id:     Name of the consumer device that will be associated with
+ *              this cell.
+ * @con_id:     Connector id for this cell lookup.
+ */
+struct nvmem_cell_lookup {
+        const char              *nvmem_name;
+        const char              *cell_name;
+        const char              *dev_id;
+        const char              *con_id;
+        struct list_head        node;
+};
+
+enum {
+        NVMEM_ADD = 1,
+        NVMEM_REMOVE,
+        NVMEM_CELL_ADD,
+        NVMEM_CELL_REMOVE,
+};
+
 #if IS_ENABLED(CONFIG_NVMEM)
 
 /* Cell based interface */
-struct nvmem_cell *nvmem_cell_get(struct device *dev, const char *name);
-struct nvmem_cell *devm_nvmem_cell_get(struct device *dev, const char *name);
+struct nvmem_cell *nvmem_cell_get(struct device *dev, const char *id);
+struct nvmem_cell *devm_nvmem_cell_get(struct device *dev, const char *id);
 void nvmem_cell_put(struct nvmem_cell *cell);
 void devm_nvmem_cell_put(struct device *dev, struct nvmem_cell *cell);
 void *nvmem_cell_read(struct nvmem_cell *cell, size_t *len);
@@ -55,18 +78,28 @@ ssize_t nvmem_device_cell_read(struct nvmem_device *nvmem,
 int nvmem_device_cell_write(struct nvmem_device *nvmem,
                             struct nvmem_cell_info *info, void *buf);
 
+const char *nvmem_dev_name(struct nvmem_device *nvmem);
+
+void nvmem_add_cell_lookups(struct nvmem_cell_lookup *entries,
+                            size_t nentries);
+void nvmem_del_cell_lookups(struct nvmem_cell_lookup *entries,
+                            size_t nentries);
+
+int nvmem_register_notifier(struct notifier_block *nb);
+int nvmem_unregister_notifier(struct notifier_block *nb);
+
 #else
 
 static inline struct nvmem_cell *nvmem_cell_get(struct device *dev,
-                                                const char *name)
+                                                const char *id)
 {
-        return ERR_PTR(-ENOSYS);
+        return ERR_PTR(-EOPNOTSUPP);
 }
 
 static inline struct nvmem_cell *devm_nvmem_cell_get(struct device *dev,
-                                       const char *name)
+                                                     const char *id)
 {
-        return ERR_PTR(-ENOSYS);
+        return ERR_PTR(-EOPNOTSUPP);
 }
 
 static inline void devm_nvmem_cell_put(struct device *dev,
@@ -80,31 +113,31 @@ static inline void nvmem_cell_put(struct nvmem_cell *cell)
 
 static inline void *nvmem_cell_read(struct nvmem_cell *cell, size_t *len)
 {
-        return ERR_PTR(-ENOSYS);
+        return ERR_PTR(-EOPNOTSUPP);
 }
 
 static inline int nvmem_cell_write(struct nvmem_cell *cell,
                                     const char *buf, size_t len)
 {
-        return -ENOSYS;
+        return -EOPNOTSUPP;
 }
 
 static inline int nvmem_cell_read_u32(struct device *dev,
                                       const char *cell_id, u32 *val)
 {
-        return -ENOSYS;
+        return -EOPNOTSUPP;
 }
 
 static inline struct nvmem_device *nvmem_device_get(struct device *dev,
                                                     const char *name)
 {
-        return ERR_PTR(-ENOSYS);
+        return ERR_PTR(-EOPNOTSUPP);
 }
 
 static inline struct nvmem_device *devm_nvmem_device_get(struct device *dev,
                                                          const char *name)
 {
-        return ERR_PTR(-ENOSYS);
+        return ERR_PTR(-EOPNOTSUPP);
 }
 
 static inline void nvmem_device_put(struct nvmem_device *nvmem)
@@ -120,47 +153,68 @@ static inline ssize_t nvmem_device_cell_read(struct nvmem_device *nvmem,
                                          struct nvmem_cell_info *info,
                                          void *buf)
 {
-        return -ENOSYS;
+        return -EOPNOTSUPP;
 }
 
 static inline int nvmem_device_cell_write(struct nvmem_device *nvmem,
                                           struct nvmem_cell_info *info,
                                           void *buf)
 {
-        return -ENOSYS;
+        return -EOPNOTSUPP;
 }
 
 static inline int nvmem_device_read(struct nvmem_device *nvmem,
                                     unsigned int offset, size_t bytes,
                                     void *buf)
 {
-        return -ENOSYS;
+        return -EOPNOTSUPP;
 }
 
 static inline int nvmem_device_write(struct nvmem_device *nvmem,
                                      unsigned int offset, size_t bytes,
                                      void *buf)
 {
-        return -ENOSYS;
+        return -EOPNOTSUPP;
 }
+
+static inline const char *nvmem_dev_name(struct nvmem_device *nvmem)
+{
+        return NULL;
+}
+
+static inline void
+nvmem_add_cell_lookups(struct nvmem_cell_lookup *entries, size_t nentries) {}
+static inline void
+nvmem_del_cell_lookups(struct nvmem_cell_lookup *entries, size_t nentries) {}
+
+static inline int nvmem_register_notifier(struct notifier_block *nb)
+{
+        return -EOPNOTSUPP;
+}
+
+static inline int nvmem_unregister_notifier(struct notifier_block *nb)
+{
+        return -EOPNOTSUPP;
+}
+
 #endif /* CONFIG_NVMEM */
 
 #if IS_ENABLED(CONFIG_NVMEM) && IS_ENABLED(CONFIG_OF)
 struct nvmem_cell *of_nvmem_cell_get(struct device_node *np,
-                                     const char *name);
+                                     const char *id);
 struct nvmem_device *of_nvmem_device_get(struct device_node *np,
                                          const char *name);
 #else
 static inline struct nvmem_cell *of_nvmem_cell_get(struct device_node *np,
-                                     const char *name)
+                                                   const char *id)
 {
-        return ERR_PTR(-ENOSYS);
+        return ERR_PTR(-EOPNOTSUPP);
 }
 
 static inline struct nvmem_device *of_nvmem_device_get(struct device_node *np,
                                                        const char *name)
 {
-        return ERR_PTR(-ENOSYS);
+        return ERR_PTR(-EOPNOTSUPP);
 }
 #endif /* CONFIG_NVMEM && CONFIG_OF */
 
diff --git a/include/linux/nvmem-provider.h b/include/linux/nvmem-provider.h
index 24def6ad09bb..1e3283c2af77 100644
--- a/include/linux/nvmem-provider.h
+++ b/include/linux/nvmem-provider.h
@@ -1,12 +1,9 @@
+/* SPDX-License-Identifier: GPL-2.0 */
 /*
  * nvmem framework provider.
  *
  * Copyright (C) 2015 Srinivas Kandagatla <srinivas.kandagatla@linaro.org>
  * Copyright (C) 2013 Maxime Ripard <maxime.ripard@free-electrons.com>
- *
- * This file is licensed under the terms of the GNU General Public
- * License version 2.  This program is licensed "as is" without any
- * warranty of any kind, whether express or implied.
  */
 
 #ifndef _LINUX_NVMEM_PROVIDER_H
@@ -67,30 +64,46 @@ struct nvmem_config {
         struct device           *base_dev;
 };
 
+/**
+ * struct nvmem_cell_table - NVMEM cell definitions for given provider
+ *
+ * @nvmem_name:         Provider name.
+ * @cells:              Array of cell definitions.
+ * @ncells:             Number of cell definitions in the array.
+ * @node:               List node.
+ *
+ * This structure together with related helper functions is provided for users
+ * that don't can't access the nvmem provided structure but wish to register
+ * cell definitions for it e.g. board files registering an EEPROM device.
+ */
+struct nvmem_cell_table {
+        const char              *nvmem_name;
+        const struct nvmem_cell_info    *cells;
+        size_t                  ncells;
+        struct list_head        node;
+};
+
 #if IS_ENABLED(CONFIG_NVMEM)
 
 struct nvmem_device *nvmem_register(const struct nvmem_config *cfg);
-int nvmem_unregister(struct nvmem_device *nvmem);
+void nvmem_unregister(struct nvmem_device *nvmem);
 
 struct nvmem_device *devm_nvmem_register(struct device *dev,
                                          const struct nvmem_config *cfg);
 
 int devm_nvmem_unregister(struct device *dev, struct nvmem_device *nvmem);
 
-int nvmem_add_cells(struct nvmem_device *nvmem,
-                    const struct nvmem_cell_info *info,
-                    int ncells);
+void nvmem_add_cell_table(struct nvmem_cell_table *table);
+void nvmem_del_cell_table(struct nvmem_cell_table *table);
+
 #else
 
 static inline struct nvmem_device *nvmem_register(const struct nvmem_config *c)
 {
-        return ERR_PTR(-ENOSYS);
+        return ERR_PTR(-EOPNOTSUPP);
 }
 
-static inline int nvmem_unregister(struct nvmem_device *nvmem)
-{
-        return -ENOSYS;
-}
+static inline void nvmem_unregister(struct nvmem_device *nvmem) {}
 
 static inline struct nvmem_device *
 devm_nvmem_register(struct device *dev, const struct nvmem_config *c)
@@ -101,16 +114,11 @@ devm_nvmem_register(struct device *dev, const struct nvmem_config *c)
 static inline int
 devm_nvmem_unregister(struct device *dev, struct nvmem_device *nvmem)
 {
-        return nvmem_unregister(nvmem);
-
+        return -EOPNOTSUPP;
 }
 
-static inline int nvmem_add_cells(struct nvmem_device *nvmem,
-                                  const struct nvmem_cell_info *info,
-                                  int ncells)
-{
-        return -ENOSYS;
-}
+static inline void nvmem_add_cell_table(struct nvmem_cell_table *table) {}
+static inline void nvmem_del_cell_table(struct nvmem_cell_table *table) {}
 
 #endif /* CONFIG_NVMEM */
 #endif  /* ifndef _LINUX_NVMEM_PROVIDER_H */
diff --git a/include/linux/of.h b/include/linux/of.h
index 99b0ebf49632..a5aee3c438ad 100644
--- a/include/linux/of.h
+++ b/include/linux/of.h
@@ -247,12 +247,6 @@ static inline unsigned long of_read_ulong(const __be32 *cell, int size)
 #include <asm/prom.h>
 #endif
 
-/* Default #address and #size cells.  Allow arch asm/prom.h to override */
-#if !defined(OF_ROOT_NODE_ADDR_CELLS_DEFAULT)
-#define OF_ROOT_NODE_ADDR_CELLS_DEFAULT 1
-#define OF_ROOT_NODE_SIZE_CELLS_DEFAULT 1
-#endif
-
 #define OF_IS_DYNAMIC(x) test_bit(OF_DYNAMIC, &x->_flags)
 #define OF_MARK_DYNAMIC(x) set_bit(OF_DYNAMIC, &x->_flags)
 
@@ -353,6 +347,8 @@ extern const void *of_get_property(const struct device_node *node,
                                 const char *name,
                                 int *lenp);
 extern struct device_node *of_get_cpu_node(int cpu, unsigned int *thread);
+extern struct device_node *of_get_next_cpu_node(struct device_node *prev);
+
 #define for_each_property_of_node(dn, pp) \
         for (pp = dn->properties; pp != NULL; pp = pp->next)
 
@@ -392,6 +388,9 @@ extern int of_phandle_iterator_args(struct of_phandle_iterator *it,
 extern void of_alias_scan(void * (*dt_alloc)(u64 size, u64 align));
 extern int of_alias_get_id(struct device_node *np, const char *stem);
 extern int of_alias_get_highest_id(const char *stem);
+extern int of_alias_get_alias_list(const struct of_device_id *matches,
+                                   const char *stem, unsigned long *bitmap,
+                                   unsigned int nbits);
 
 extern int of_machine_is_compatible(const char *compat);
 
@@ -550,6 +549,10 @@ bool of_console_check(struct device_node *dn, char *name, int index);
 
 extern int of_cpu_node_to_id(struct device_node *np);
 
+int of_map_rid(struct device_node *np, u32 rid,
+               const char *map_name, const char *map_mask_name,
+               struct device_node **target, u32 *id_out);
+
 #else /* CONFIG_OF */
 
 static inline void of_core_init(void)
@@ -754,6 +757,11 @@ static inline struct device_node *of_get_cpu_node(int cpu,
         return NULL;
 }
 
+static inline struct device_node *of_get_next_cpu_node(struct device_node *prev)
+{
+        return NULL;
+}
+
 static inline int of_n_addr_cells(struct device_node *np)
 {
         return 0;
@@ -893,6 +901,13 @@ static inline int of_alias_get_highest_id(const char *stem)
         return -ENOSYS;
 }
 
+static inline int of_alias_get_alias_list(const struct of_device_id *matches,
+                                          const char *stem, unsigned long *bitmap,
+                                          unsigned int nbits)
+{
+        return -ENOSYS;
+}
+
 static inline int of_machine_is_compatible(const char *compat)
 {
         return 0;
@@ -952,6 +967,13 @@ static inline int of_cpu_node_to_id(struct device_node *np)
         return -ENODEV;
 }
 
+static inline int of_map_rid(struct device_node *np, u32 rid,
+                             const char *map_name, const char *map_mask_name,
+                             struct device_node **target, u32 *id_out)
+{
+        return -EINVAL;
+}
+
 #define of_match_ptr(_ptr)      NULL
 #define of_match_node(_matches, _node)  NULL
 #endif /* CONFIG_OF */
@@ -990,7 +1012,7 @@ static inline struct device_node *of_find_matching_node(
 
 static inline const char *of_node_get_device_type(const struct device_node *np)
 {
-        return of_get_property(np, "type", NULL);
+        return of_get_property(np, "device_type", NULL);
 }
 
 static inline bool of_node_is_type(const struct device_node *np, const char *type)
@@ -1217,6 +1239,10 @@ static inline int of_property_read_s32(const struct device_node *np,
         for (child = of_get_next_available_child(parent, NULL); child != NULL; \
              child = of_get_next_available_child(parent, child))
 
+#define for_each_of_cpu_node(cpu) \
+        for (cpu = of_get_next_cpu_node(NULL); cpu != NULL; \
+             cpu = of_get_next_cpu_node(cpu))
+
 #define for_each_node_with_property(dn, prop_name) \
         for (dn = of_find_node_with_property(NULL, prop_name); dn; \
              dn = of_find_node_with_property(dn, prop_name))
diff --git a/include/linux/of_device.h b/include/linux/of_device.h
index 165fd302b442..8d31e39dd564 100644
--- a/include/linux/of_device.h
+++ b/include/linux/of_device.h
@@ -58,7 +58,6 @@ static inline struct device_node *of_cpu_device_node_get(int cpu)
 int of_dma_configure(struct device *dev,
                      struct device_node *np,
                      bool force_dma);
-void of_dma_deconfigure(struct device *dev);
 #else /* CONFIG_OF */
 
 static inline int of_driver_match_device(struct device *dev,
@@ -113,8 +112,6 @@ static inline int of_dma_configure(struct device *dev,
 {
         return 0;
 }
-static inline void of_dma_deconfigure(struct device *dev)
-{}
 #endif /* CONFIG_OF */
 
 #endif /* _LINUX_OF_DEVICE_H */
diff --git a/include/linux/of_pci.h b/include/linux/of_pci.h
index e83d87fc5673..21a89c4880fa 100644
--- a/include/linux/of_pci.h
+++ b/include/linux/of_pci.h
@@ -14,9 +14,6 @@ struct device_node *of_pci_find_child_device(struct device_node *parent,
                                              unsigned int devfn);
 int of_pci_get_devfn(struct device_node *np);
 void of_pci_check_probe_only(void);
-int of_pci_map_rid(struct device_node *np, u32 rid,
-                   const char *map_name, const char *map_mask_name,
-                   struct device_node **target, u32 *id_out);
 #else
 static inline struct device_node *of_pci_find_child_device(struct device_node *parent,
                                              unsigned int devfn)
@@ -29,13 +26,6 @@ static inline int of_pci_get_devfn(struct device_node *np)
         return -EINVAL;
 }
 
-static inline int of_pci_map_rid(struct device_node *np, u32 rid,
-                        const char *map_name, const char *map_mask_name,
-                        struct device_node **target, u32 *id_out)
-{
-        return -EINVAL;
-}
-
 static inline void of_pci_check_probe_only(void) { }
 #endif
 
diff --git a/include/linux/page-flags.h b/include/linux/page-flags.h
index 74bee8cecf4c..50ce1bddaf56 100644
--- a/include/linux/page-flags.h
+++ b/include/linux/page-flags.h
@@ -69,13 +69,14 @@
  */
 enum pageflags {
         PG_locked,              /* Page is locked. Don't touch. */
-        PG_error,
         PG_referenced,
         PG_uptodate,
         PG_dirty,
         PG_lru,
         PG_active,
+        PG_workingset,
         PG_waiters,             /* Page has waiters, check its waitqueue. Must be bit #7 and in the same byte as "PG_locked" */
+        PG_error,
         PG_slab,
         PG_owner_priv_1,        /* Owner use. If pagecache, fs may use*/
         PG_arch_1,
@@ -162,6 +163,14 @@ static inline int PagePoisoned(const struct page *page)
         return page->flags == PAGE_POISON_PATTERN;
 }
 
+#ifdef CONFIG_DEBUG_VM
+void page_init_poison(struct page *page, size_t size);
+#else
+static inline void page_init_poison(struct page *page, size_t size)
+{
+}
+#endif
+
 /*
  * Page flags policies wrt compound pages
  *
@@ -280,6 +289,8 @@ PAGEFLAG(Dirty, dirty, PF_HEAD) TESTSCFLAG(Dirty, dirty, PF_HEAD)
 PAGEFLAG(LRU, lru, PF_HEAD) __CLEARPAGEFLAG(LRU, lru, PF_HEAD)
 PAGEFLAG(Active, active, PF_HEAD) __CLEARPAGEFLAG(Active, active, PF_HEAD)
         TESTCLEARFLAG(Active, active, PF_HEAD)
+PAGEFLAG(Workingset, workingset, PF_HEAD)
+        TESTCLEARFLAG(Workingset, workingset, PF_HEAD)
 __PAGEFLAG(Slab, slab, PF_NO_TAIL)
 __PAGEFLAG(SlobFree, slob_free, PF_NO_TAIL)
 PAGEFLAG(Checked, checked, PF_NO_COMPOUND)         /* Used by some filesystems */
@@ -292,6 +303,7 @@ PAGEFLAG(Foreign, foreign, PF_NO_COMPOUND);
 
 PAGEFLAG(Reserved, reserved, PF_NO_COMPOUND)
         __CLEARPAGEFLAG(Reserved, reserved, PF_NO_COMPOUND)
+        __SETPAGEFLAG(Reserved, reserved, PF_NO_COMPOUND)
 PAGEFLAG(SwapBacked, swapbacked, PF_NO_TAIL)
         __CLEARPAGEFLAG(SwapBacked, swapbacked, PF_NO_TAIL)
         __SETPAGEFLAG(SwapBacked, swapbacked, PF_NO_TAIL)
diff --git a/include/linux/pagemap.h b/include/linux/pagemap.h
index b1bd2186e6d2..226f96f0dee0 100644
--- a/include/linux/pagemap.h
+++ b/include/linux/pagemap.h
@@ -241,9 +241,9 @@ static inline gfp_t readahead_gfp_mask(struct address_space *x)
 
 typedef int filler_t(void *, struct page *);
 
-pgoff_t page_cache_next_hole(struct address_space *mapping,
+pgoff_t page_cache_next_miss(struct address_space *mapping,
                              pgoff_t index, unsigned long max_scan);
-pgoff_t page_cache_prev_hole(struct address_space *mapping,
+pgoff_t page_cache_prev_miss(struct address_space *mapping,
                              pgoff_t index, unsigned long max_scan);
 
 #define FGP_ACCESSED            0x00000001
@@ -363,17 +363,17 @@ static inline unsigned find_get_pages(struct address_space *mapping,
 unsigned find_get_pages_contig(struct address_space *mapping, pgoff_t start,
                                unsigned int nr_pages, struct page **pages);
 unsigned find_get_pages_range_tag(struct address_space *mapping, pgoff_t *index,
-                        pgoff_t end, int tag, unsigned int nr_pages,
+                        pgoff_t end, xa_mark_t tag, unsigned int nr_pages,
                         struct page **pages);
 static inline unsigned find_get_pages_tag(struct address_space *mapping,
-                        pgoff_t *index, int tag, unsigned int nr_pages,
+                        pgoff_t *index, xa_mark_t tag, unsigned int nr_pages,
                         struct page **pages)
 {
         return find_get_pages_range_tag(mapping, index, (pgoff_t)-1, tag,
                                         nr_pages, pages);
 }
 unsigned find_get_entries_tag(struct address_space *mapping, pgoff_t start,
-                        int tag, unsigned int nr_entries,
+                        xa_mark_t tag, unsigned int nr_entries,
                         struct page **entries, pgoff_t *indices);
 
 struct page *grab_cache_page_write_begin(struct address_space *mapping,
diff --git a/include/linux/pagevec.h b/include/linux/pagevec.h
index 6dc456ac6136..081d934eda64 100644
--- a/include/linux/pagevec.h
+++ b/include/linux/pagevec.h
@@ -9,6 +9,8 @@
 #ifndef _LINUX_PAGEVEC_H
 #define _LINUX_PAGEVEC_H
 
+#include <linux/xarray.h>
+
 /* 15 pointers + header align the pagevec structure to a power of two */
 #define PAGEVEC_SIZE    15
 
@@ -40,12 +42,12 @@ static inline unsigned pagevec_lookup(struct pagevec *pvec,
 
 unsigned pagevec_lookup_range_tag(struct pagevec *pvec,
                 struct address_space *mapping, pgoff_t *index, pgoff_t end,
-                int tag);
+                xa_mark_t tag);
 unsigned pagevec_lookup_range_nr_tag(struct pagevec *pvec,
                 struct address_space *mapping, pgoff_t *index, pgoff_t end,
-                int tag, unsigned max_pages);
+                xa_mark_t tag, unsigned max_pages);
 static inline unsigned pagevec_lookup_tag(struct pagevec *pvec,
-                struct address_space *mapping, pgoff_t *index, int tag)
+                struct address_space *mapping, pgoff_t *index, xa_mark_t tag)
 {
         return pagevec_lookup_range_tag(pvec, mapping, index, (pgoff_t)-1, tag);
 }
diff --git a/include/linux/pci-dma-compat.h b/include/linux/pci-dma-compat.h
index c3f1b44ade29..cb1adf0b78a9 100644
--- a/include/linux/pci-dma-compat.h
+++ b/include/linux/pci-dma-compat.h
@@ -119,29 +119,11 @@ static inline int pci_set_consistent_dma_mask(struct pci_dev *dev, u64 mask)
 {
         return dma_set_coherent_mask(&dev->dev, mask);
 }
-
-static inline int pci_set_dma_max_seg_size(struct pci_dev *dev,
-                                           unsigned int size)
-{
-        return dma_set_max_seg_size(&dev->dev, size);
-}
-
-static inline int pci_set_dma_seg_boundary(struct pci_dev *dev,
-                                           unsigned long mask)
-{
-        return dma_set_seg_boundary(&dev->dev, mask);
-}
 #else
 static inline int pci_set_dma_mask(struct pci_dev *dev, u64 mask)
 { return -EIO; }
 static inline int pci_set_consistent_dma_mask(struct pci_dev *dev, u64 mask)
 { return -EIO; }
-static inline int pci_set_dma_max_seg_size(struct pci_dev *dev,
-                                           unsigned int size)
-{ return -EIO; }
-static inline int pci_set_dma_seg_boundary(struct pci_dev *dev,
-                                           unsigned long mask)
-{ return -EIO; }
 #endif
 
 #endif
diff --git a/include/linux/pci-dma.h b/include/linux/pci-dma.h
deleted file mode 100644
index 0f7aa7353ca3..000000000000
--- a/include/linux/pci-dma.h
+++ /dev/null
@@ -1,12 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0 */
-#ifndef _LINUX_PCI_DMA_H
-#define _LINUX_PCI_DMA_H
-
-#define DECLARE_PCI_UNMAP_ADDR(ADDR_NAME) DEFINE_DMA_UNMAP_ADDR(ADDR_NAME);
-#define DECLARE_PCI_UNMAP_LEN(LEN_NAME)   DEFINE_DMA_UNMAP_LEN(LEN_NAME);
-#define pci_unmap_addr             dma_unmap_addr
-#define pci_unmap_addr_set         dma_unmap_addr_set
-#define pci_unmap_len              dma_unmap_len
-#define pci_unmap_len_set          dma_unmap_len_set
-
-#endif
diff --git a/include/linux/pci-p2pdma.h b/include/linux/pci-p2pdma.h
new file mode 100644
index 000000000000..bca9bc3e5be7
--- /dev/null
+++ b/include/linux/pci-p2pdma.h
@@ -0,0 +1,114 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * PCI Peer 2 Peer DMA support.
+ *
+ * Copyright (c) 2016-2018, Logan Gunthorpe
+ * Copyright (c) 2016-2017, Microsemi Corporation
+ * Copyright (c) 2017, Christoph Hellwig
+ * Copyright (c) 2018, Eideticom Inc.
+ */
+
+#ifndef _LINUX_PCI_P2PDMA_H
+#define _LINUX_PCI_P2PDMA_H
+
+#include <linux/pci.h>
+
+struct block_device;
+struct scatterlist;
+
+#ifdef CONFIG_PCI_P2PDMA
+int pci_p2pdma_add_resource(struct pci_dev *pdev, int bar, size_t size,
+                u64 offset);
+int pci_p2pdma_distance_many(struct pci_dev *provider, struct device **clients,
+                             int num_clients, bool verbose);
+bool pci_has_p2pmem(struct pci_dev *pdev);
+struct pci_dev *pci_p2pmem_find_many(struct device **clients, int num_clients);
+void *pci_alloc_p2pmem(struct pci_dev *pdev, size_t size);
+void pci_free_p2pmem(struct pci_dev *pdev, void *addr, size_t size);
+pci_bus_addr_t pci_p2pmem_virt_to_bus(struct pci_dev *pdev, void *addr);
+struct scatterlist *pci_p2pmem_alloc_sgl(struct pci_dev *pdev,
+                                         unsigned int *nents, u32 length);
+void pci_p2pmem_free_sgl(struct pci_dev *pdev, struct scatterlist *sgl);
+void pci_p2pmem_publish(struct pci_dev *pdev, bool publish);
+int pci_p2pdma_map_sg(struct device *dev, struct scatterlist *sg, int nents,
+                      enum dma_data_direction dir);
+int pci_p2pdma_enable_store(const char *page, struct pci_dev **p2p_dev,
+                            bool *use_p2pdma);
+ssize_t pci_p2pdma_enable_show(char *page, struct pci_dev *p2p_dev,
+                               bool use_p2pdma);
+#else /* CONFIG_PCI_P2PDMA */
+static inline int pci_p2pdma_add_resource(struct pci_dev *pdev, int bar,
+                size_t size, u64 offset)
+{
+        return -EOPNOTSUPP;
+}
+static inline int pci_p2pdma_distance_many(struct pci_dev *provider,
+        struct device **clients, int num_clients, bool verbose)
+{
+        return -1;
+}
+static inline bool pci_has_p2pmem(struct pci_dev *pdev)
+{
+        return false;
+}
+static inline struct pci_dev *pci_p2pmem_find_many(struct device **clients,
+                                                   int num_clients)
+{
+        return NULL;
+}
+static inline void *pci_alloc_p2pmem(struct pci_dev *pdev, size_t size)
+{
+        return NULL;
+}
+static inline void pci_free_p2pmem(struct pci_dev *pdev, void *addr,
+                size_t size)
+{
+}
+static inline pci_bus_addr_t pci_p2pmem_virt_to_bus(struct pci_dev *pdev,
+                                                    void *addr)
+{
+        return 0;
+}
+static inline struct scatterlist *pci_p2pmem_alloc_sgl(struct pci_dev *pdev,
+                unsigned int *nents, u32 length)
+{
+        return NULL;
+}
+static inline void pci_p2pmem_free_sgl(struct pci_dev *pdev,
+                struct scatterlist *sgl)
+{
+}
+static inline void pci_p2pmem_publish(struct pci_dev *pdev, bool publish)
+{
+}
+static inline int pci_p2pdma_map_sg(struct device *dev,
+                struct scatterlist *sg, int nents, enum dma_data_direction dir)
+{
+        return 0;
+}
+static inline int pci_p2pdma_enable_store(const char *page,
+                struct pci_dev **p2p_dev, bool *use_p2pdma)
+{
+        *use_p2pdma = false;
+        return 0;
+}
+static inline ssize_t pci_p2pdma_enable_show(char *page,
+                struct pci_dev *p2p_dev, bool use_p2pdma)
+{
+        return sprintf(page, "none\n");
+}
+#endif /* CONFIG_PCI_P2PDMA */
+
+
+static inline int pci_p2pdma_distance(struct pci_dev *provider,
+        struct device *client, bool verbose)
+{
+        return pci_p2pdma_distance_many(provider, &client, 1, verbose);
+}
+
+static inline struct pci_dev *pci_p2pmem_find(struct device *client)
+{
+        return pci_p2pmem_find_many(&client, 1);
+}
+
+#endif /* _LINUX_PCI_P2P_H */
diff --git a/include/linux/pci.h b/include/linux/pci.h
index e72ca8dd6241..11c71c4ecf75 100644
--- a/include/linux/pci.h
+++ b/include/linux/pci.h
@@ -281,6 +281,7 @@ struct pcie_link_state;
 struct pci_vpd;
 struct pci_sriov;
 struct pci_ats;
+struct pci_p2pdma;
 
 /* The pci_dev structure describes PCI devices */
 struct pci_dev {
@@ -325,6 +326,7 @@ struct pci_dev {
         pci_power_t     current_state;  /* Current operating state. In ACPI,
                                            this is D0-D3, D0 being fully
                                            functional, and D3 being off. */
+        unsigned int    imm_ready:1;    /* Supports Immediate Readiness */
         u8              pm_cap;         /* PM capability offset */
         unsigned int    pme_support:5;  /* Bitmask of states from which PME#
                                            can be generated */
@@ -402,6 +404,7 @@ struct pci_dev {
         unsigned int    has_secondary_link:1;
         unsigned int    non_compliant_bars:1;   /* Broken BARs; ignore them */
         unsigned int    is_probed:1;            /* Device probing in progress */
+        unsigned int    link_active_reporting:1;/* Device capable of reporting link active */
         pci_dev_flags_t dev_flags;
         atomic_t        enable_cnt;     /* pci_enable_device has been called */
 
@@ -439,6 +442,9 @@ struct pci_dev {
 #ifdef CONFIG_PCI_PASID
         u16             pasid_features;
 #endif
+#ifdef CONFIG_PCI_P2PDMA
+        struct pci_p2pdma *p2pdma;
+#endif
         phys_addr_t     rom;            /* Physical address if not from BAR */
         size_t          romlen;         /* Length if not from BAR */
         char            *driver_override; /* Driver name to force a match */
@@ -1235,6 +1241,9 @@ void pci_bus_remove_resources(struct pci_bus *bus);
 int devm_request_pci_bus_resources(struct device *dev,
                                    struct list_head *resources);
 
+/* Temporary until new and working PCI SBR API in place */
+int pci_bridge_secondary_bus_reset(struct pci_dev *dev);
+
 #define pci_bus_for_each_resource(bus, res, i)                          \
         for (i = 0;                                                     \
             (res = pci_bus_resource_n(bus, i)) || i < PCI_BRIDGE_RESOURCE_NUM; \
@@ -1339,7 +1348,6 @@ int pci_set_vga_state(struct pci_dev *pdev, bool decode,
 
 /* kmem_cache style wrapper around pci_alloc_consistent() */
 
-#include <linux/pci-dma.h>
 #include <linux/dmapool.h>
 
 #define pci_pool dma_pool
@@ -1702,6 +1710,10 @@ static inline int pci_irqd_intx_xlate(struct irq_domain *d,
                                       unsigned long *out_hwirq,
                                       unsigned int *out_type)
 { return -EINVAL; }
+
+static inline const struct pci_device_id *pci_match_id(const struct pci_device_id *ids,
+                                                         struct pci_dev *dev)
+{ return NULL; }
 #endif /* CONFIG_PCI */
 
 /* Include architecture-dependent settings and functions */
diff --git a/include/linux/pci_hotplug.h b/include/linux/pci_hotplug.h
index a6d6650a0490..7acc9f91e72b 100644
--- a/include/linux/pci_hotplug.h
+++ b/include/linux/pci_hotplug.h
@@ -16,8 +16,6 @@
 
 /**
  * struct hotplug_slot_ops -the callbacks that the hotplug pci core can use
- * @owner: The module owner of this structure
- * @mod_name: The module name (KBUILD_MODNAME) of this structure
  * @enable_slot: Called when the user wants to enable a specific pci slot
  * @disable_slot: Called when the user wants to disable a specific pci slot
  * @set_attention_status: Called to set the specific slot's attention LED to
@@ -25,17 +23,9 @@
  * @hardware_test: Called to run a specified hardware test on the specified
  * slot.
  * @get_power_status: Called to get the current power status of a slot.
- *      If this field is NULL, the value passed in the struct hotplug_slot_info
- *      will be used when this value is requested by a user.
  * @get_attention_status: Called to get the current attention status of a slot.
- *      If this field is NULL, the value passed in the struct hotplug_slot_info
- *      will be used when this value is requested by a user.
  * @get_latch_status: Called to get the current latch status of a slot.
- *      If this field is NULL, the value passed in the struct hotplug_slot_info
- *      will be used when this value is requested by a user.
  * @get_adapter_status: Called to get see if an adapter is present in the slot or not.
- *      If this field is NULL, the value passed in the struct hotplug_slot_info
- *      will be used when this value is requested by a user.
  * @reset_slot: Optional interface to allow override of a bus reset for the
  *      slot for cases where a secondary bus reset can result in spurious
  *      hotplug events or where a slot can be reset independent of the bus.
@@ -46,8 +36,6 @@
  * set an LED, enable / disable power, etc.)
  */
 struct hotplug_slot_ops {
-        struct module *owner;
-        const char *mod_name;
         int (*enable_slot)              (struct hotplug_slot *slot);
         int (*disable_slot)             (struct hotplug_slot *slot);
         int (*set_attention_status)     (struct hotplug_slot *slot, u8 value);
@@ -60,37 +48,19 @@ struct hotplug_slot_ops {
 };
 
 /**
- * struct hotplug_slot_info - used to notify the hotplug pci core of the state of the slot
- * @power_status: if power is enabled or not (1/0)
- * @attention_status: if the attention light is enabled or not (1/0)
- * @latch_status: if the latch (if any) is open or closed (1/0)
- * @adapter_status: if there is a pci board present in the slot or not (1/0)
- *
- * Used to notify the hotplug pci core of the status of a specific slot.
- */
-struct hotplug_slot_info {
-        u8      power_status;
-        u8      attention_status;
-        u8      latch_status;
-        u8      adapter_status;
-};
-
-/**
  * struct hotplug_slot - used to register a physical slot with the hotplug pci core
  * @ops: pointer to the &struct hotplug_slot_ops to be used for this slot
- * @info: pointer to the &struct hotplug_slot_info for the initial values for
- * this slot.
- * @private: used by the hotplug pci controller driver to store whatever it
- * needs.
+ * @owner: The module owner of this structure
+ * @mod_name: The module name (KBUILD_MODNAME) of this structure
  */
 struct hotplug_slot {
-        struct hotplug_slot_ops         *ops;
-        struct hotplug_slot_info        *info;
-        void                            *private;
+        const struct hotplug_slot_ops   *ops;
 
         /* Variables below this are for use only by the hotplug pci core. */
         struct list_head                slot_list;
         struct pci_slot                 *pci_slot;
+        struct module                   *owner;
+        const char                      *mod_name;
 };
 
 static inline const char *hotplug_slot_name(const struct hotplug_slot *slot)
@@ -110,9 +80,6 @@ void pci_hp_del(struct hotplug_slot *slot);
 void pci_hp_destroy(struct hotplug_slot *slot);
 void pci_hp_deregister(struct hotplug_slot *slot);
 
-int __must_check pci_hp_change_slot_info(struct hotplug_slot *slot,
-                                         struct hotplug_slot_info *info);
-
 /* use a define to avoid include chaining to get THIS_MODULE & friends */
 #define pci_hp_register(slot, pbus, devnr, name) \
         __pci_hp_register(slot, pbus, devnr, name, THIS_MODULE, KBUILD_MODNAME)
diff --git a/include/linux/pci_ids.h b/include/linux/pci_ids.h
index d157983b84cf..69f0abe1ba1a 100644
--- a/include/linux/pci_ids.h
+++ b/include/linux/pci_ids.h
@@ -117,6 +117,10 @@
 #define PCI_CLASS_SERIAL_USB_DEVICE     0x0c03fe
 #define PCI_CLASS_SERIAL_FIBER          0x0c04
 #define PCI_CLASS_SERIAL_SMBUS          0x0c05
+#define PCI_CLASS_SERIAL_IPMI           0x0c07
+#define PCI_CLASS_SERIAL_IPMI_SMIC      0x0c0700
+#define PCI_CLASS_SERIAL_IPMI_KCS       0x0c0701
+#define PCI_CLASS_SERIAL_IPMI_BT        0x0c0702
 
 #define PCI_BASE_CLASS_WIRELESS                 0x0d
 #define PCI_CLASS_WIRELESS_RF_CONTROLLER        0x0d10
@@ -2539,8 +2543,6 @@
 #define PCI_VENDOR_ID_HUAWEI            0x19e5
 
 #define PCI_VENDOR_ID_NETRONOME         0x19ee
-#define PCI_DEVICE_ID_NETRONOME_NFP3200 0x3200
-#define PCI_DEVICE_ID_NETRONOME_NFP3240 0x3240
 #define PCI_DEVICE_ID_NETRONOME_NFP4000 0x4000
 #define PCI_DEVICE_ID_NETRONOME_NFP5000 0x5000
 #define PCI_DEVICE_ID_NETRONOME_NFP6000 0x6000
@@ -2561,6 +2563,8 @@
 
 #define PCI_VENDOR_ID_AMAZON            0x1d0f
 
+#define PCI_VENDOR_ID_HYGON             0x1d94
+
 #define PCI_VENDOR_ID_TEKRAM            0x1de1
 #define PCI_DEVICE_ID_TEKRAM_DC290      0xdc29
 
diff --git a/include/linux/percpu-refcount.h b/include/linux/percpu-refcount.h
index 009cdf3d65b6..b297cd1cd4f1 100644
--- a/include/linux/percpu-refcount.h
+++ b/include/linux/percpu-refcount.h
@@ -108,6 +108,7 @@ void percpu_ref_switch_to_atomic_sync(struct percpu_ref *ref);
 void percpu_ref_switch_to_percpu(struct percpu_ref *ref);
 void percpu_ref_kill_and_confirm(struct percpu_ref *ref,
                                  percpu_ref_func_t *confirm_kill);
+void percpu_ref_resurrect(struct percpu_ref *ref);
 void percpu_ref_reinit(struct percpu_ref *ref);
 
 /**
diff --git a/include/linux/perf/arm_pmu.h b/include/linux/perf/arm_pmu.h
index 10f92e1d8e7b..bf309ff6f244 100644
--- a/include/linux/perf/arm_pmu.h
+++ b/include/linux/perf/arm_pmu.h
@@ -99,6 +99,7 @@ struct arm_pmu {
         void            (*stop)(struct arm_pmu *);
         void            (*reset)(void *);
         int             (*map_event)(struct perf_event *event);
+        int             (*filter_match)(struct perf_event *event);
         int             num_events;
         bool            secure_access; /* 32-bit ARM only */
 #define ARMV8_PMUV3_MAX_COMMON_EVENTS 0x40
diff --git a/include/linux/pfn_t.h b/include/linux/pfn_t.h
index 21713dc14ce2..7bb77850c65a 100644
--- a/include/linux/pfn_t.h
+++ b/include/linux/pfn_t.h
@@ -9,8 +9,10 @@
  * PFN_SG_LAST - pfn references a page and is the last scatterlist entry
  * PFN_DEV - pfn is not covered by system memmap by default
  * PFN_MAP - pfn has a dynamic page mapping established by a device driver
+ * PFN_SPECIAL - for CONFIG_FS_DAX_LIMITED builds to allow XIP, but not
+ *               get_user_pages
  */
-#define PFN_FLAGS_MASK (((u64) ~PAGE_MASK) << (BITS_PER_LONG_LONG - PAGE_SHIFT))
+#define PFN_FLAGS_MASK (((u64) (~PAGE_MASK)) << (BITS_PER_LONG_LONG - PAGE_SHIFT))
 #define PFN_SG_CHAIN (1ULL << (BITS_PER_LONG_LONG - 1))
 #define PFN_SG_LAST (1ULL << (BITS_PER_LONG_LONG - 2))
 #define PFN_DEV (1ULL << (BITS_PER_LONG_LONG - 3))
diff --git a/include/linux/phy.h b/include/linux/phy.h
index cd6f637cbbfb..3ea87f774a76 100644
--- a/include/linux/phy.h
+++ b/include/linux/phy.h
@@ -19,6 +19,7 @@
 #include <linux/compiler.h>
 #include <linux/spinlock.h>
 #include <linux/ethtool.h>
+#include <linux/linkmode.h>
 #include <linux/mdio.h>
 #include <linux/mii.h>
 #include <linux/module.h>
@@ -41,13 +42,21 @@
 #define PHY_1000BT_FEATURES     (SUPPORTED_1000baseT_Half | \
                                  SUPPORTED_1000baseT_Full)
 
-#define PHY_BASIC_FEATURES      (PHY_10BT_FEATURES | \
-                                 PHY_100BT_FEATURES | \
-                                 PHY_DEFAULT_FEATURES)
-
-#define PHY_GBIT_FEATURES       (PHY_BASIC_FEATURES | \
-                                 PHY_1000BT_FEATURES)
-
+extern __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_basic_features) __ro_after_init;
+extern __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_basic_t1_features) __ro_after_init;
+extern __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_gbit_features) __ro_after_init;
+extern __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_gbit_fibre_features) __ro_after_init;
+extern __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_gbit_all_ports_features) __ro_after_init;
+extern __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_10gbit_features) __ro_after_init;
+extern __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_10gbit_full_features) __ro_after_init;
+
+#define PHY_BASIC_FEATURES ((unsigned long *)&phy_basic_features)
+#define PHY_BASIC_T1_FEATURES ((unsigned long *)&phy_basic_t1_features)
+#define PHY_GBIT_FEATURES ((unsigned long *)&phy_gbit_features)
+#define PHY_GBIT_FIBRE_FEATURES ((unsigned long *)&phy_gbit_fibre_features)
+#define PHY_GBIT_ALL_PORTS_FEATURES ((unsigned long *)&phy_gbit_all_ports_features)
+#define PHY_10GBIT_FEATURES ((unsigned long *)&phy_10gbit_features)
+#define PHY_10GBIT_FULL_FEATURES ((unsigned long *)&phy_10gbit_full_features)
 
 /*
  * Set phydev->irq to PHY_POLL if interrupts are not supported,
@@ -509,7 +518,7 @@ struct phy_driver {
         u32 phy_id;
         char *name;
         u32 phy_id_mask;
-        u32 features;
+        const unsigned long * const features;
         u32 flags;
         const void *driver_data;
 
@@ -967,6 +976,12 @@ static inline void phy_device_reset(struct phy_device *phydev, int value)
 #define phydev_err(_phydev, format, args...)    \
         dev_err(&_phydev->mdio.dev, format, ##args)
 
+#define phydev_info(_phydev, format, args...)   \
+        dev_info(&_phydev->mdio.dev, format, ##args)
+
+#define phydev_warn(_phydev, format, args...)   \
+        dev_warn(&_phydev->mdio.dev, format, ##args)
+
 #define phydev_dbg(_phydev, format, args...)    \
         dev_dbg(&_phydev->mdio.dev, format, ##args)
 
@@ -1039,7 +1054,7 @@ void phy_change_work(struct work_struct *work);
 void phy_mac_interrupt(struct phy_device *phydev);
 void phy_start_machine(struct phy_device *phydev);
 void phy_stop_machine(struct phy_device *phydev);
-void phy_trigger_machine(struct phy_device *phydev, bool sync);
+void phy_trigger_machine(struct phy_device *phydev);
 int phy_ethtool_sset(struct phy_device *phydev, struct ethtool_cmd *cmd);
 void phy_ethtool_ksettings_get(struct phy_device *phydev,
                                struct ethtool_link_ksettings *cmd);
@@ -1049,6 +1064,14 @@ int phy_mii_ioctl(struct phy_device *phydev, struct ifreq *ifr, int cmd);
 int phy_start_interrupts(struct phy_device *phydev);
 void phy_print_status(struct phy_device *phydev);
 int phy_set_max_speed(struct phy_device *phydev, u32 max_speed);
+void phy_remove_link_mode(struct phy_device *phydev, u32 link_mode);
+void phy_support_sym_pause(struct phy_device *phydev);
+void phy_support_asym_pause(struct phy_device *phydev);
+void phy_set_sym_pause(struct phy_device *phydev, bool rx, bool tx,
+                       bool autoneg);
+void phy_set_asym_pause(struct phy_device *phydev, bool rx, bool tx);
+bool phy_validate_pause(struct phy_device *phydev,
+                        struct ethtool_pauseparam *pp);
 
 int phy_register_fixup(const char *bus_id, u32 phy_uid, u32 phy_uid_mask,
                        int (*run)(struct phy_device *));
diff --git a/include/linux/phy/phy-qcom-ufs.h b/include/linux/phy/phy-qcom-ufs.h
deleted file mode 100644
index 0a2c18a9771d..000000000000
--- a/include/linux/phy/phy-qcom-ufs.h
+++ /dev/null
@@ -1,38 +0,0 @@
-/*
- * Copyright (c) 2013-2015, Linux Foundation. All rights reserved.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 and
- * only version 2 as published by the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- */
-
-#ifndef PHY_QCOM_UFS_H_
-#define PHY_QCOM_UFS_H_
-
-#include "phy.h"
-
-/**
- * ufs_qcom_phy_enable_dev_ref_clk() - Enable the device
- * ref clock.
- * @phy: reference to a generic phy.
- */
-void ufs_qcom_phy_enable_dev_ref_clk(struct phy *phy);
-
-/**
- * ufs_qcom_phy_disable_dev_ref_clk() - Disable the device
- * ref clock.
- * @phy: reference to a generic phy.
- */
-void ufs_qcom_phy_disable_dev_ref_clk(struct phy *phy);
-
-int ufs_qcom_phy_set_tx_lane_enable(struct phy *phy, u32 tx_lanes);
-void ufs_qcom_phy_save_controller_version(struct phy *phy,
-                        u8 major, u16 minor, u16 step);
-
-#endif /* PHY_QCOM_UFS_H_ */
diff --git a/include/linux/phy/phy.h b/include/linux/phy/phy.h
index 9713aebdd348..03b319f89a34 100644
--- a/include/linux/phy/phy.h
+++ b/include/linux/phy/phy.h
@@ -37,9 +37,11 @@ enum phy_mode {
         PHY_MODE_USB_OTG,
         PHY_MODE_SGMII,
         PHY_MODE_2500SGMII,
+        PHY_MODE_QSGMII,
         PHY_MODE_10GKR,
         PHY_MODE_UFS_HS_A,
         PHY_MODE_UFS_HS_B,
+        PHY_MODE_PCIE,
 };
 
 /**
diff --git a/include/linux/platform_data/dma-ep93xx.h b/include/linux/platform_data/dma-ep93xx.h
index f8f1f6b952a6..eb9805bb3fe8 100644
--- a/include/linux/platform_data/dma-ep93xx.h
+++ b/include/linux/platform_data/dma-ep93xx.h
@@ -85,7 +85,7 @@ static inline enum dma_transfer_direction
 ep93xx_dma_chan_direction(struct dma_chan *chan)
 {
         if (!ep93xx_dma_chan_is_m2p(chan))
-                return DMA_NONE;
+                return DMA_TRANS_NONE;
 
         /* even channels are for TX, odd for RX */
         return (chan->chan_id % 2 == 0) ? DMA_MEM_TO_DEV : DMA_DEV_TO_MEM;
diff --git a/include/linux/platform_data/dma-mcf-edma.h b/include/linux/platform_data/dma-mcf-edma.h
new file mode 100644
index 000000000000..d718ccfa3421
--- /dev/null
+++ b/include/linux/platform_data/dma-mcf-edma.h
@@ -0,0 +1,38 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/*
+ * Freescale eDMA platform data, ColdFire SoC's family.
+ *
+ * Copyright (c) 2017 Angelo Dureghello <angelo@sysam.it>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ */
+
+#ifndef __LINUX_PLATFORM_DATA_MCF_EDMA_H__
+#define __LINUX_PLATFORM_DATA_MCF_EDMA_H__
+
+struct dma_slave_map;
+
+bool mcf_edma_filter_fn(struct dma_chan *chan, void *param);
+
+#define MCF_EDMA_FILTER_PARAM(ch)       ((void *)ch)
+
+/**
+ * struct mcf_edma_platform_data - platform specific data for eDMA engine
+ *
+ * @ver                 The eDMA module version.
+ * @dma_channels        The number of eDMA channels.
+ */
+struct mcf_edma_platform_data {
+        int dma_channels;
+        const struct dma_slave_map *slave_map;
+        int slavecnt;
+};
+
+#endif /* __LINUX_PLATFORM_DATA_MCF_EDMA_H__ */
diff --git a/include/linux/platform_data/ehci-sh.h b/include/linux/platform_data/ehci-sh.h
index 5c15a738e116..219bd79dabfc 100644
--- a/include/linux/platform_data/ehci-sh.h
+++ b/include/linux/platform_data/ehci-sh.h
@@ -1,21 +1,9 @@
-/*
+/* SPDX-License-Identifier: GPL-2.0
+ *
  * EHCI SuperH driver platform data
  *
  * Copyright (C) 2012  Nobuhiro Iwamatsu <nobuhiro.iwamatsu.yj@renesas.com>
  * Copyright (C) 2012  Renesas Solutions Corp.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; 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., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  */
 
 #ifndef __USB_EHCI_SH_H
diff --git a/include/linux/platform_data/gpio-davinci.h b/include/linux/platform_data/gpio-davinci.h
index 57a5a35e0073..f92a47e18034 100644
--- a/include/linux/platform_data/gpio-davinci.h
+++ b/include/linux/platform_data/gpio-davinci.h
@@ -16,46 +16,12 @@
 #ifndef __DAVINCI_GPIO_PLATFORM_H
 #define __DAVINCI_GPIO_PLATFORM_H
 
-#include <linux/io.h>
-#include <linux/spinlock.h>
-
-#include <asm-generic/gpio.h>
-
-#define MAX_REGS_BANKS          5
-#define MAX_INT_PER_BANK 32
-
 struct davinci_gpio_platform_data {
         u32     ngpio;
         u32     gpio_unbanked;
 };
 
-struct davinci_gpio_irq_data {
-        void __iomem                    *regs;
-        struct davinci_gpio_controller  *chip;
-        int                             bank_num;
-};
-
-struct davinci_gpio_controller {
-        struct gpio_chip        chip;
-        struct irq_domain       *irq_domain;
-        /* Serialize access to GPIO registers */
-        spinlock_t              lock;
-        void __iomem            *regs[MAX_REGS_BANKS];
-        int                     gpio_unbanked;
-        int                     irqs[MAX_INT_PER_BANK];
-        unsigned int            base;
-};
-
-/*
- * basic gpio routines
- */
-#define GPIO(X)         (X)     /* 0 <= X <= (DAVINCI_N_GPIO - 1) */
-
 /* Convert GPIO signal to GPIO pin number */
 #define GPIO_TO_PIN(bank, gpio) (16 * (bank) + (gpio))
 
-static inline u32 __gpio_mask(unsigned gpio)
-{
-        return 1 << (gpio % 32);
-}
 #endif
diff --git a/include/linux/platform_data/gpio-omap.h b/include/linux/platform_data/gpio-omap.h
index 8612855691b2..8485c6a9a383 100644
--- a/include/linux/platform_data/gpio-omap.h
+++ b/include/linux/platform_data/gpio-omap.h
@@ -197,23 +197,12 @@ struct omap_gpio_platform_data {
         bool is_mpuio;          /* whether the bank is of type MPUIO */
         u32 non_wakeup_gpios;
 
+        u32 quirks;             /* Version specific quirks mask */
+
         struct omap_gpio_reg_offs *regs;
 
         /* Return context loss count due to PM states changing */
         int (*get_context_loss_count)(struct device *dev);
 };
 
-#if IS_BUILTIN(CONFIG_GPIO_OMAP)
-extern void omap2_gpio_prepare_for_idle(int off_mode);
-extern void omap2_gpio_resume_after_idle(void);
-#else
-static inline void omap2_gpio_prepare_for_idle(int off_mode)
-{
-}
-
-static inline void omap2_gpio_resume_after_idle(void)
-{
-}
-#endif
-
 #endif
diff --git a/include/linux/platform_data/gpio-ts5500.h b/include/linux/platform_data/gpio-ts5500.h
deleted file mode 100644
index b10d11c9bb49..000000000000
--- a/include/linux/platform_data/gpio-ts5500.h
+++ /dev/null
@@ -1,27 +0,0 @@
-/*
- * GPIO (DIO) header for Technologic Systems TS-5500
- *
- * Copyright (c) 2012 Savoir-faire Linux Inc.
- *      Vivien Didelot <vivien.didelot@savoirfairelinux.com>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
- */
-
-#ifndef _PDATA_GPIO_TS5500_H
-#define _PDATA_GPIO_TS5500_H
-
-/**
- * struct ts5500_dio_platform_data - TS-5500 pin block configuration
- * @base:       The GPIO base number to use.
- * @strap:      The only pin connected to an interrupt in a block is input-only.
- *              If you need a bidirectional line which can trigger an IRQ, you
- *              may strap it with an in/out pin. This flag indicates this case.
- */
-struct ts5500_dio_platform_data {
-        int base;
-        bool strap;
-};
-
-#endif /* _PDATA_GPIO_TS5500_H */
diff --git a/include/linux/platform_data/hsmmc-omap.h b/include/linux/platform_data/hsmmc-omap.h
index 73d9098ada2d..85da11916bd5 100644
--- a/include/linux/platform_data/hsmmc-omap.h
+++ b/include/linux/platform_data/hsmmc-omap.h
@@ -70,9 +70,6 @@ struct omap_hsmmc_platform_data {
         /* string specifying a particular variant of hardware */
         char *version;
 
-        int gpio_cd;                    /* gpio (card detect) */
-        int gpio_cod;                   /* gpio (cover detect) */
-        int gpio_wp;                    /* gpio (write protect) */
         /* if we have special card, init it using this callback */
         void (*init_card)(struct mmc_card *card);
 
diff --git a/include/linux/platform_data/mv_usb.h b/include/linux/platform_data/mv_usb.h
index 98b7925f1a2d..c0f624aca81c 100644
--- a/include/linux/platform_data/mv_usb.h
+++ b/include/linux/platform_data/mv_usb.h
@@ -48,6 +48,5 @@ struct mv_usb_platform_data {
         int     (*phy_init)(void __iomem *regbase);
         void    (*phy_deinit)(void __iomem *regbase);
         int     (*set_vbus)(unsigned int vbus);
-        int     (*private_init)(void __iomem *opregs, void __iomem *phyregs);
 };
 #endif
diff --git a/include/linux/platform_data/pxa_sdhci.h b/include/linux/platform_data/pxa_sdhci.h
index 9e20c2fb4ffd..4977c06d8a86 100644
--- a/include/linux/platform_data/pxa_sdhci.h
+++ b/include/linux/platform_data/pxa_sdhci.h
@@ -33,8 +33,6 @@
  *      1: choose feedback clk + delay value
  *      2: choose internal clk
  * @clk_delay_enable: enable clk_delay or not, used on pxa910
- * @ext_cd_gpio: gpio pin used for external CD line
- * @ext_cd_gpio_invert: invert values for external CD gpio line
  * @max_speed: the maximum speed supported
  * @host_caps: Standard MMC host capabilities bit field.
  * @quirks: quirks of platfrom
@@ -46,8 +44,6 @@ struct sdhci_pxa_platdata {
         unsigned int    clk_delay_cycles;
         unsigned int    clk_delay_sel;
         bool            clk_delay_enable;
-        unsigned int    ext_cd_gpio;
-        bool            ext_cd_gpio_invert;
         unsigned int    max_speed;
         u32             host_caps;
         u32             host_caps2;
diff --git a/include/linux/platform_data/shmob_drm.h b/include/linux/platform_data/shmob_drm.h
index ee495d707f17..fe815d7d9f58 100644
--- a/include/linux/platform_data/shmob_drm.h
+++ b/include/linux/platform_data/shmob_drm.h
@@ -1,14 +1,10 @@
+/* SPDX-License-Identifier: GPL-2.0+ */
 /*
  * shmob_drm.h  --  SH Mobile DRM driver
  *
  * Copyright (C) 2012 Renesas Corporation
  *
  * Laurent Pinchart (laurent.pinchart@ideasonboard.com)
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
  */
 
 #ifndef __SHMOB_DRM_H__
diff --git a/include/linux/platform_data/spi-davinci.h b/include/linux/platform_data/spi-davinci.h
index f4edcb03c40c..0638fb6353bc 100644
--- a/include/linux/platform_data/spi-davinci.h
+++ b/include/linux/platform_data/spi-davinci.h
@@ -36,9 +36,6 @@ enum {
  * @num_chipselect: number of chipselects supported by this SPI master
  * @intr_line:  interrupt line used to connect the SPI IP to the ARM interrupt
  *              controller withn the SoC. Possible values are 0 and 1.
- * @chip_sel:   list of GPIOs which can act as chip-selects for the SPI.
- *              SPI_INTERN_CS denotes internal SPI chip-select. Not necessary
- *              to populate if all chip-selects are internal.
  * @cshold_bug: set this to true if the SPI controller on your chip requires
  *              a write to CSHOLD bit in between transfers (like in DM355).
  * @dma_event_q: DMA event queue to use if SPI_IO_TYPE_DMA is used for any
@@ -48,7 +45,6 @@ struct davinci_spi_platform_data {
         u8                      version;
         u8                      num_chipselect;
         u8                      intr_line;
-        u8                      *chip_sel;
         u8                      prescaler_limit;
         bool                    cshold_bug;
         enum dma_event_q        dma_event_q;
diff --git a/include/linux/platform_device.h b/include/linux/platform_device.h
index 1a9f38f27f65..c7c081dc6034 100644
--- a/include/linux/platform_device.h
+++ b/include/linux/platform_device.h
@@ -40,6 +40,7 @@ struct platform_device {
 
 #define platform_get_device_id(pdev)    ((pdev)->id_entry)
 
+#define dev_is_platform(dev) ((dev)->bus == &platform_bus_type)
 #define to_platform_device(x) container_of((x), struct platform_device, dev)
 
 extern int platform_device_register(struct platform_device *);
diff --git a/include/linux/pm_domain.h b/include/linux/pm_domain.h
index 776c546d581a..3b5d7280e52e 100644
--- a/include/linux/pm_domain.h
+++ b/include/linux/pm_domain.h
@@ -17,11 +17,36 @@
 #include <linux/notifier.h>
 #include <linux/spinlock.h>
 
-/* Defines used for the flags field in the struct generic_pm_domain */
-#define GENPD_FLAG_PM_CLK        (1U << 0) /* PM domain uses PM clk */
-#define GENPD_FLAG_IRQ_SAFE      (1U << 1) /* PM domain operates in atomic */
-#define GENPD_FLAG_ALWAYS_ON     (1U << 2) /* PM domain is always powered on */
-#define GENPD_FLAG_ACTIVE_WAKEUP (1U << 3) /* Keep devices active if wakeup */
+/*
+ * Flags to control the behaviour of a genpd.
+ *
+ * These flags may be set in the struct generic_pm_domain's flags field by a
+ * genpd backend driver. The flags must be set before it calls pm_genpd_init(),
+ * which initializes a genpd.
+ *
+ * GENPD_FLAG_PM_CLK:           Instructs genpd to use the PM clk framework,
+ *                              while powering on/off attached devices.
+ *
+ * GENPD_FLAG_IRQ_SAFE:         This informs genpd that its backend callbacks,
+ *                              ->power_on|off(), doesn't sleep. Hence, these
+ *                              can be invoked from within atomic context, which
+ *                              enables genpd to power on/off the PM domain,
+ *                              even when pm_runtime_is_irq_safe() returns true,
+ *                              for any of its attached devices. Note that, a
+ *                              genpd having this flag set, requires its
+ *                              masterdomains to also have it set.
+ *
+ * GENPD_FLAG_ALWAYS_ON:        Instructs genpd to always keep the PM domain
+ *                              powered on.
+ *
+ * GENPD_FLAG_ACTIVE_WAKEUP:    Instructs genpd to keep the PM domain powered
+ *                              on, in case any of its attached devices is used
+ *                              in the wakeup path to serve system wakeups.
+ */
+#define GENPD_FLAG_PM_CLK        (1U << 0)
+#define GENPD_FLAG_IRQ_SAFE      (1U << 1)
+#define GENPD_FLAG_ALWAYS_ON     (1U << 2)
+#define GENPD_FLAG_ACTIVE_WAKEUP (1U << 3)
 
 enum gpd_status {
         GPD_STATE_ACTIVE = 0,   /* PM domain is active */
diff --git a/include/linux/pm_opp.h b/include/linux/pm_opp.h
index 099b31960dec..5d399eeef172 100644
--- a/include/linux/pm_opp.h
+++ b/include/linux/pm_opp.h
@@ -79,6 +79,7 @@ struct dev_pm_set_opp_data {
 #if defined(CONFIG_PM_OPP)
 
 struct opp_table *dev_pm_opp_get_opp_table(struct device *dev);
+struct opp_table *dev_pm_opp_get_opp_table_indexed(struct device *dev, int index);
 void dev_pm_opp_put_opp_table(struct opp_table *opp_table);
 
 unsigned long dev_pm_opp_get_voltage(struct dev_pm_opp *opp);
@@ -136,6 +137,11 @@ static inline struct opp_table *dev_pm_opp_get_opp_table(struct device *dev)
         return ERR_PTR(-ENOTSUPP);
 }
 
+static inline struct opp_table *dev_pm_opp_get_opp_table_indexed(struct device *dev, int index)
+{
+        return ERR_PTR(-ENOTSUPP);
+}
+
 static inline void dev_pm_opp_put_opp_table(struct opp_table *opp_table) {}
 
 static inline unsigned long dev_pm_opp_get_voltage(struct dev_pm_opp *opp)
diff --git a/include/linux/pmu.h b/include/linux/pmu.h
index 9ac8fc60ad49..52453a24a24f 100644
--- a/include/linux/pmu.h
+++ b/include/linux/pmu.h
@@ -9,6 +9,7 @@
 #ifndef _LINUX_PMU_H
 #define _LINUX_PMU_H
 
+#include <linux/rtc.h>
 #include <uapi/linux/pmu.h>
 
 
@@ -36,6 +37,9 @@ static inline void pmu_resume(void)
 
 extern void pmu_enable_irled(int on);
 
+extern time64_t pmu_get_time(void);
+extern int pmu_set_rtc_time(struct rtc_time *tm);
+
 extern void pmu_restart(void);
 extern void pmu_shutdown(void);
 extern void pmu_unlock(void);
diff --git a/include/linux/posix-timers.h b/include/linux/posix-timers.h
index ee7e987ea1b4..e96581ca7c9d 100644
--- a/include/linux/posix-timers.h
+++ b/include/linux/posix-timers.h
@@ -126,5 +126,5 @@ void set_process_cpu_timer(struct task_struct *task, unsigned int clock_idx,
 
 void update_rlimit_cpu(struct task_struct *task, unsigned long rlim_new);
 
-void posixtimer_rearm(struct siginfo *info);
+void posixtimer_rearm(struct kernel_siginfo *info);
 #endif
diff --git a/include/linux/power/bq27xxx_battery.h b/include/linux/power/bq27xxx_battery.h
index d6355f49fbae..507c5e214c42 100644
--- a/include/linux/power/bq27xxx_battery.h
+++ b/include/linux/power/bq27xxx_battery.h
@@ -24,6 +24,7 @@ enum bq27xxx_chip {
         BQ27546,
         BQ27742,
         BQ27545, /* bq27545 */
+        BQ27411,
         BQ27421, /* bq27421, bq27441, bq27621 */
         BQ27425,
         BQ27426,
diff --git a/include/linux/psi.h b/include/linux/psi.h
new file mode 100644
index 000000000000..8e0725aac0aa
--- /dev/null
+++ b/include/linux/psi.h
@@ -0,0 +1,53 @@
+#ifndef _LINUX_PSI_H
+#define _LINUX_PSI_H
+
+#include <linux/psi_types.h>
+#include <linux/sched.h>
+
+struct seq_file;
+struct css_set;
+
+#ifdef CONFIG_PSI
+
+extern bool psi_disabled;
+
+void psi_init(void);
+
+void psi_task_change(struct task_struct *task, int clear, int set);
+
+void psi_memstall_tick(struct task_struct *task, int cpu);
+void psi_memstall_enter(unsigned long *flags);
+void psi_memstall_leave(unsigned long *flags);
+
+int psi_show(struct seq_file *s, struct psi_group *group, enum psi_res res);
+
+#ifdef CONFIG_CGROUPS
+int psi_cgroup_alloc(struct cgroup *cgrp);
+void psi_cgroup_free(struct cgroup *cgrp);
+void cgroup_move_task(struct task_struct *p, struct css_set *to);
+#endif
+
+#else /* CONFIG_PSI */
+
+static inline void psi_init(void) {}
+
+static inline void psi_memstall_enter(unsigned long *flags) {}
+static inline void psi_memstall_leave(unsigned long *flags) {}
+
+#ifdef CONFIG_CGROUPS
+static inline int psi_cgroup_alloc(struct cgroup *cgrp)
+{
+        return 0;
+}
+static inline void psi_cgroup_free(struct cgroup *cgrp)
+{
+}
+static inline void cgroup_move_task(struct task_struct *p, struct css_set *to)
+{
+        rcu_assign_pointer(p->cgroups, to);
+}
+#endif
+
+#endif /* CONFIG_PSI */
+
+#endif /* _LINUX_PSI_H */
diff --git a/include/linux/psi_types.h b/include/linux/psi_types.h
new file mode 100644
index 000000000000..2cf422db5d18
--- /dev/null
+++ b/include/linux/psi_types.h
@@ -0,0 +1,92 @@
+#ifndef _LINUX_PSI_TYPES_H
+#define _LINUX_PSI_TYPES_H
+
+#include <linux/seqlock.h>
+#include <linux/types.h>
+
+#ifdef CONFIG_PSI
+
+/* Tracked task states */
+enum psi_task_count {
+        NR_IOWAIT,
+        NR_MEMSTALL,
+        NR_RUNNING,
+        NR_PSI_TASK_COUNTS,
+};
+
+/* Task state bitmasks */
+#define TSK_IOWAIT      (1 << NR_IOWAIT)
+#define TSK_MEMSTALL    (1 << NR_MEMSTALL)
+#define TSK_RUNNING     (1 << NR_RUNNING)
+
+/* Resources that workloads could be stalled on */
+enum psi_res {
+        PSI_IO,
+        PSI_MEM,
+        PSI_CPU,
+        NR_PSI_RESOURCES,
+};
+
+/*
+ * Pressure states for each resource:
+ *
+ * SOME: Stalled tasks & working tasks
+ * FULL: Stalled tasks & no working tasks
+ */
+enum psi_states {
+        PSI_IO_SOME,
+        PSI_IO_FULL,
+        PSI_MEM_SOME,
+        PSI_MEM_FULL,
+        PSI_CPU_SOME,
+        /* Only per-CPU, to weigh the CPU in the global average: */
+        PSI_NONIDLE,
+        NR_PSI_STATES,
+};
+
+struct psi_group_cpu {
+        /* 1st cacheline updated by the scheduler */
+
+        /* Aggregator needs to know of concurrent changes */
+        seqcount_t seq ____cacheline_aligned_in_smp;
+
+        /* States of the tasks belonging to this group */
+        unsigned int tasks[NR_PSI_TASK_COUNTS];
+
+        /* Period time sampling buckets for each state of interest (ns) */
+        u32 times[NR_PSI_STATES];
+
+        /* Time of last task change in this group (rq_clock) */
+        u64 state_start;
+
+        /* 2nd cacheline updated by the aggregator */
+
+        /* Delta detection against the sampling buckets */
+        u32 times_prev[NR_PSI_STATES] ____cacheline_aligned_in_smp;
+};
+
+struct psi_group {
+        /* Protects data updated during an aggregation */
+        struct mutex stat_lock;
+
+        /* Per-cpu task state & time tracking */
+        struct psi_group_cpu __percpu *pcpu;
+
+        /* Periodic aggregation state */
+        u64 total_prev[NR_PSI_STATES - 1];
+        u64 last_update;
+        u64 next_update;
+        struct delayed_work clock_work;
+
+        /* Total stall times and sampled pressure averages */
+        u64 total[NR_PSI_STATES - 1];
+        unsigned long avg[NR_PSI_STATES - 1][3];
+};
+
+#else /* CONFIG_PSI */
+
+struct psi_group { };
+
+#endif /* CONFIG_PSI */
+
+#endif /* _LINUX_PSI_TYPES_H */
diff --git a/include/linux/pstore_ram.h b/include/linux/pstore_ram.h
index e6d226464838..602d64725222 100644
--- a/include/linux/pstore_ram.h
+++ b/include/linux/pstore_ram.h
@@ -46,6 +46,7 @@ struct persistent_ram_zone {
         phys_addr_t paddr;
         size_t size;
         void *vaddr;
+        char *label;
         struct persistent_ram_buffer *buffer;
         size_t buffer_size;
         u32 flags;
@@ -65,7 +66,7 @@ struct persistent_ram_zone {
 
 struct persistent_ram_zone *persistent_ram_new(phys_addr_t start, size_t size,
                         u32 sig, struct persistent_ram_ecc_info *ecc_info,
-                        unsigned int memtype, u32 flags);
+                        unsigned int memtype, u32 flags, char *label);
 void persistent_ram_free(struct persistent_ram_zone *prz);
 void persistent_ram_zap(struct persistent_ram_zone *prz);
 
diff --git a/include/linux/ptrace.h b/include/linux/ptrace.h
index 4f36431c380b..6c2ffed907f5 100644
--- a/include/linux/ptrace.h
+++ b/include/linux/ptrace.h
@@ -62,14 +62,17 @@ extern void exit_ptrace(struct task_struct *tracer, struct list_head *dead);
 #define PTRACE_MODE_READ        0x01
 #define PTRACE_MODE_ATTACH      0x02
 #define PTRACE_MODE_NOAUDIT     0x04
-#define PTRACE_MODE_FSCREDS 0x08
-#define PTRACE_MODE_REALCREDS 0x10
+#define PTRACE_MODE_FSCREDS     0x08
+#define PTRACE_MODE_REALCREDS   0x10
+#define PTRACE_MODE_SCHED       0x20
+#define PTRACE_MODE_IBPB        0x40
 
 /* shorthands for READ/ATTACH and FSCREDS/REALCREDS combinations */
 #define PTRACE_MODE_READ_FSCREDS (PTRACE_MODE_READ | PTRACE_MODE_FSCREDS)
 #define PTRACE_MODE_READ_REALCREDS (PTRACE_MODE_READ | PTRACE_MODE_REALCREDS)
 #define PTRACE_MODE_ATTACH_FSCREDS (PTRACE_MODE_ATTACH | PTRACE_MODE_FSCREDS)
 #define PTRACE_MODE_ATTACH_REALCREDS (PTRACE_MODE_ATTACH | PTRACE_MODE_REALCREDS)
+#define PTRACE_MODE_SPEC_IBPB (PTRACE_MODE_ATTACH_REALCREDS | PTRACE_MODE_IBPB)
 
 /**
  * ptrace_may_access - check whether the caller is permitted to access
@@ -87,6 +90,20 @@ extern void exit_ptrace(struct task_struct *tracer, struct list_head *dead);
  */
 extern bool ptrace_may_access(struct task_struct *task, unsigned int mode);
 
+/**
+ * ptrace_may_access - check whether the caller is permitted to access
+ * a target task.
+ * @task: target task
+ * @mode: selects type of access and caller credentials
+ *
+ * Returns true on success, false on denial.
+ *
+ * Similar to ptrace_may_access(). Only to be called from context switch
+ * code. Does not call into audit and the regular LSM hooks due to locking
+ * constraints.
+ */
+extern bool ptrace_may_access_sched(struct task_struct *task, unsigned int mode);
+
 static inline int ptrace_reparented(struct task_struct *child)
 {
         return !same_thread_group(child->real_parent, child->parent);
@@ -336,14 +353,19 @@ static inline void user_enable_block_step(struct task_struct *task)
 extern void user_enable_block_step(struct task_struct *);
 #endif  /* arch_has_block_step */
 
-#ifdef ARCH_HAS_USER_SINGLE_STEP_INFO
-extern void user_single_step_siginfo(struct task_struct *tsk,
-                                struct pt_regs *regs, siginfo_t *info);
+#ifdef ARCH_HAS_USER_SINGLE_STEP_REPORT
+extern void user_single_step_report(struct pt_regs *regs);
 #else
-static inline void user_single_step_siginfo(struct task_struct *tsk,
-                                struct pt_regs *regs, siginfo_t *info)
+static inline void user_single_step_report(struct pt_regs *regs)
 {
-        info->si_signo = SIGTRAP;
+        kernel_siginfo_t info;
+        clear_siginfo(&info);
+        info.si_signo = SIGTRAP;
+        info.si_errno = 0;
+        info.si_code = SI_USER;
+        info.si_pid = 0;
+        info.si_uid = 0;
+        force_sig_info(info.si_signo, &info, current);
 }
 #endif
 
diff --git a/include/linux/pxa2xx_ssp.h b/include/linux/pxa2xx_ssp.h
index 13b4244d44c1..979087e021f3 100644
--- a/include/linux/pxa2xx_ssp.h
+++ b/include/linux/pxa2xx_ssp.h
@@ -196,6 +196,7 @@ enum pxa_ssp_type {
         PXA27x_SSP,
         PXA3xx_SSP,
         PXA168_SSP,
+        MMP2_SSP,
         PXA910_SSP,
         CE4100_SSP,
         QUARK_X1000_SSP,
@@ -217,7 +218,7 @@ struct ssp_device {
 
         const char      *label;
         int             port_id;
-        int             type;
+        enum pxa_ssp_type type;
         int             use_count;
         int             irq;
 
diff --git a/include/linux/qcom-geni-se.h b/include/linux/qcom-geni-se.h
index 5d6144977828..3bcd67fd5548 100644
--- a/include/linux/qcom-geni-se.h
+++ b/include/linux/qcom-geni-se.h
@@ -225,19 +225,14 @@ struct geni_se {
 #define HW_VER_MINOR_SHFT               16
 #define HW_VER_STEP_MASK                GENMASK(15, 0)
 
+#define GENI_SE_VERSION_MAJOR(ver) ((ver & HW_VER_MAJOR_MASK) >> HW_VER_MAJOR_SHFT)
+#define GENI_SE_VERSION_MINOR(ver) ((ver & HW_VER_MINOR_MASK) >> HW_VER_MINOR_SHFT)
+#define GENI_SE_VERSION_STEP(ver) (ver & HW_VER_STEP_MASK)
+
 #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.
diff --git a/include/linux/qcom_scm.h b/include/linux/qcom_scm.h
index 5d65521260b3..06996ad4f2bc 100644
--- a/include/linux/qcom_scm.h
+++ b/include/linux/qcom_scm.h
@@ -1,4 +1,4 @@
-/* Copyright (c) 2010-2015, The Linux Foundation. All rights reserved.
+/* Copyright (c) 2010-2015, 2018, The Linux Foundation. All rights reserved.
  * Copyright (C) 2015 Linaro Ltd.
  *
  * This program is free software; you can redistribute it and/or modify
@@ -33,6 +33,8 @@ struct qcom_scm_vmperm {
 
 #define QCOM_SCM_VMID_HLOS       0x3
 #define QCOM_SCM_VMID_MSS_MSA    0xF
+#define QCOM_SCM_VMID_WLAN       0x18
+#define QCOM_SCM_VMID_WLAN_CE    0x19
 #define QCOM_SCM_PERM_READ       0x4
 #define QCOM_SCM_PERM_WRITE      0x2
 #define QCOM_SCM_PERM_EXEC       0x1
diff --git a/include/linux/qed/common_hsi.h b/include/linux/qed/common_hsi.h
index 0081fa6d1268..03f59a28fefd 100644
--- a/include/linux/qed/common_hsi.h
+++ b/include/linux/qed/common_hsi.h
@@ -110,7 +110,7 @@
 
 #define FW_MAJOR_VERSION        8
 #define FW_MINOR_VERSION        37
-#define FW_REVISION_VERSION     2
+#define FW_REVISION_VERSION     7
 #define FW_ENGINEERING_VERSION  0
 
 /***********************/
@@ -931,12 +931,12 @@ struct db_rdma_dpm_params {
 #define DB_RDMA_DPM_PARAMS_WQE_SIZE_SHIFT               16
 #define DB_RDMA_DPM_PARAMS_RESERVED0_MASK               0x1
 #define DB_RDMA_DPM_PARAMS_RESERVED0_SHIFT              27
-#define DB_RDMA_DPM_PARAMS_COMPLETION_FLG_MASK          0x1
-#define DB_RDMA_DPM_PARAMS_COMPLETION_FLG_SHIFT         28
+#define DB_RDMA_DPM_PARAMS_ACK_REQUEST_MASK             0x1
+#define DB_RDMA_DPM_PARAMS_ACK_REQUEST_SHIFT            28
 #define DB_RDMA_DPM_PARAMS_S_FLG_MASK                   0x1
 #define DB_RDMA_DPM_PARAMS_S_FLG_SHIFT                  29
-#define DB_RDMA_DPM_PARAMS_RESERVED1_MASK               0x1
-#define DB_RDMA_DPM_PARAMS_RESERVED1_SHIFT              30
+#define DB_RDMA_DPM_PARAMS_COMPLETION_FLG_MASK          0x1
+#define DB_RDMA_DPM_PARAMS_COMPLETION_FLG_SHIFT         30
 #define DB_RDMA_DPM_PARAMS_CONN_TYPE_IS_IWARP_MASK      0x1
 #define DB_RDMA_DPM_PARAMS_CONN_TYPE_IS_IWARP_SHIFT     31
 };
diff --git a/include/linux/qed/iscsi_common.h b/include/linux/qed/iscsi_common.h
index b34c573f2b30..66aba505ec56 100644
--- a/include/linux/qed/iscsi_common.h
+++ b/include/linux/qed/iscsi_common.h
@@ -896,7 +896,7 @@ struct e4_ustorm_iscsi_task_ag_ctx {
         __le32 exp_cont_len;
         __le32 total_data_acked;
         __le32 exp_data_acked;
-        u8 next_tid_valid;
+        u8 byte2;
         u8 byte3;
         __le16 word1;
         __le16 next_tid;
diff --git a/include/linux/qed/qed_if.h b/include/linux/qed/qed_if.h
index 8cd34645e892..a47321a0d572 100644
--- a/include/linux/qed/qed_if.h
+++ b/include/linux/qed/qed_if.h
@@ -667,14 +667,35 @@ enum qed_link_mode_bits {
         QED_LM_Autoneg_BIT = BIT(1),
         QED_LM_Asym_Pause_BIT = BIT(2),
         QED_LM_Pause_BIT = BIT(3),
-        QED_LM_1000baseT_Half_BIT = BIT(4),
-        QED_LM_1000baseT_Full_BIT = BIT(5),
+        QED_LM_1000baseT_Full_BIT = BIT(4),
+        QED_LM_10000baseT_Full_BIT = BIT(5),
         QED_LM_10000baseKR_Full_BIT = BIT(6),
-        QED_LM_25000baseKR_Full_BIT = BIT(7),
-        QED_LM_40000baseLR4_Full_BIT = BIT(8),
-        QED_LM_50000baseKR2_Full_BIT = BIT(9),
-        QED_LM_100000baseKR4_Full_BIT = BIT(10),
-        QED_LM_COUNT = 11
+        QED_LM_20000baseKR2_Full_BIT = BIT(7),
+        QED_LM_25000baseKR_Full_BIT = BIT(8),
+        QED_LM_40000baseLR4_Full_BIT = BIT(9),
+        QED_LM_50000baseKR2_Full_BIT = BIT(10),
+        QED_LM_100000baseKR4_Full_BIT = BIT(11),
+        QED_LM_2500baseX_Full_BIT = BIT(12),
+        QED_LM_Backplane_BIT = BIT(13),
+        QED_LM_1000baseKX_Full_BIT = BIT(14),
+        QED_LM_10000baseKX4_Full_BIT = BIT(15),
+        QED_LM_10000baseR_FEC_BIT = BIT(16),
+        QED_LM_40000baseKR4_Full_BIT = BIT(17),
+        QED_LM_40000baseCR4_Full_BIT = BIT(18),
+        QED_LM_40000baseSR4_Full_BIT = BIT(19),
+        QED_LM_25000baseCR_Full_BIT = BIT(20),
+        QED_LM_25000baseSR_Full_BIT = BIT(21),
+        QED_LM_50000baseCR2_Full_BIT = BIT(22),
+        QED_LM_100000baseSR4_Full_BIT = BIT(23),
+        QED_LM_100000baseCR4_Full_BIT = BIT(24),
+        QED_LM_100000baseLR4_ER4_Full_BIT = BIT(25),
+        QED_LM_50000baseSR2_Full_BIT = BIT(26),
+        QED_LM_1000baseX_Full_BIT = BIT(27),
+        QED_LM_10000baseCR_Full_BIT = BIT(28),
+        QED_LM_10000baseSR_Full_BIT = BIT(29),
+        QED_LM_10000baseLR_Full_BIT = BIT(30),
+        QED_LM_10000baseLRM_Full_BIT = BIT(31),
+        QED_LM_COUNT = 32
 };
 
 struct qed_link_params {
diff --git a/include/linux/qed/qed_rdma_if.h b/include/linux/qed/qed_rdma_if.h
index df4d13f7e191..d15f8e4815e3 100644
--- a/include/linux/qed/qed_rdma_if.h
+++ b/include/linux/qed/qed_rdma_if.h
@@ -39,15 +39,6 @@
 #include <linux/qed/qed_ll2_if.h>
 #include <linux/qed/rdma_common.h>
 
-enum qed_roce_ll2_tx_dest {
-        /* Light L2 TX Destination to the Network */
-        QED_ROCE_LL2_TX_DEST_NW,
-
-        /* Light L2 TX Destination to the Loopback */
-        QED_ROCE_LL2_TX_DEST_LB,
-        QED_ROCE_LL2_TX_DEST_MAX
-};
-
 #define QED_RDMA_MAX_CNQ_SIZE               (0xFFFF)
 
 /* rdma interface */
@@ -581,7 +572,7 @@ struct qed_roce_ll2_packet {
         int n_seg;
         struct qed_roce_ll2_buffer payload[RDMA_MAX_SGE_PER_SQ_WQE];
         int roce_mode;
-        enum qed_roce_ll2_tx_dest tx_dest;
+        enum qed_ll2_tx_dest tx_dest;
 };
 
 enum qed_rdma_type {
diff --git a/include/linux/radix-tree.h b/include/linux/radix-tree.h
index 34149e8b5f73..06c4c7a6c09c 100644
--- a/include/linux/radix-tree.h
+++ b/include/linux/radix-tree.h
@@ -28,34 +28,30 @@
 #include <linux/rcupdate.h>
 #include <linux/spinlock.h>
 #include <linux/types.h>
+#include <linux/xarray.h>
+
+/* Keep unconverted code working */
+#define radix_tree_root         xarray
+#define radix_tree_node         xa_node
 
 /*
  * The bottom two bits of the slot determine how the remaining bits in the
  * slot are interpreted:
  *
  * 00 - data pointer
- * 01 - internal entry
- * 10 - exceptional entry
- * 11 - this bit combination is currently unused/reserved
+ * 10 - internal entry
+ * x1 - value entry
  *
  * The internal entry may be a pointer to the next level in the tree, a
  * sibling entry, or an indicator that the entry in this slot has been moved
  * to another location in the tree and the lookup should be restarted.  While
  * NULL fits the 'data pointer' pattern, it means that there is no entry in
  * the tree for this index (no matter what level of the tree it is found at).
- * This means that you cannot store NULL in the tree as a value for the index.
+ * This means that storing a NULL entry in the tree is the same as deleting
+ * the entry from the tree.
  */
 #define RADIX_TREE_ENTRY_MASK           3UL
-#define RADIX_TREE_INTERNAL_NODE        1UL
-
-/*
- * Most users of the radix tree store pointers but shmem/tmpfs stores swap
- * entries in the same tree.  They are marked as exceptional entries to
- * distinguish them from pointers to struct page.
- * EXCEPTIONAL_ENTRY tests the bit, EXCEPTIONAL_SHIFT shifts content past it.
- */
-#define RADIX_TREE_EXCEPTIONAL_ENTRY    2
-#define RADIX_TREE_EXCEPTIONAL_SHIFT    2
+#define RADIX_TREE_INTERNAL_NODE        2UL
 
 static inline bool radix_tree_is_internal_node(void *ptr)
 {
@@ -65,75 +61,32 @@ static inline bool radix_tree_is_internal_node(void *ptr)
 
 /*** radix-tree API starts here ***/
 
-#define RADIX_TREE_MAX_TAGS 3
-
-#ifndef RADIX_TREE_MAP_SHIFT
-#define RADIX_TREE_MAP_SHIFT    (CONFIG_BASE_SMALL ? 4 : 6)
-#endif
-
+#define RADIX_TREE_MAP_SHIFT    XA_CHUNK_SHIFT
 #define RADIX_TREE_MAP_SIZE     (1UL << RADIX_TREE_MAP_SHIFT)
 #define RADIX_TREE_MAP_MASK     (RADIX_TREE_MAP_SIZE-1)
 
-#define RADIX_TREE_TAG_LONGS    \
-        ((RADIX_TREE_MAP_SIZE + BITS_PER_LONG - 1) / BITS_PER_LONG)
+#define RADIX_TREE_MAX_TAGS     XA_MAX_MARKS
+#define RADIX_TREE_TAG_LONGS    XA_MARK_LONGS
 
 #define RADIX_TREE_INDEX_BITS  (8 /* CHAR_BIT */ * sizeof(unsigned long))
 #define RADIX_TREE_MAX_PATH (DIV_ROUND_UP(RADIX_TREE_INDEX_BITS, \
                                           RADIX_TREE_MAP_SHIFT))
 
-/*
- * @count is the count of every non-NULL element in the ->slots array
- * whether that is an exceptional entry, a retry entry, a user pointer,
- * a sibling entry or a pointer to the next level of the tree.
- * @exceptional is the count of every element in ->slots which is
- * either radix_tree_exceptional_entry() or is a sibling entry for an
- * exceptional entry.
- */
-struct radix_tree_node {
-        unsigned char   shift;          /* Bits remaining in each slot */
-        unsigned char   offset;         /* Slot offset in parent */
-        unsigned char   count;          /* Total entry count */
-        unsigned char   exceptional;    /* Exceptional entry count */
-        struct radix_tree_node *parent;         /* Used when ascending tree */
-        struct radix_tree_root *root;           /* The tree we belong to */
-        union {
-                struct list_head private_list;  /* For tree user */
-                struct rcu_head rcu_head;       /* Used when freeing node */
-        };
-        void __rcu      *slots[RADIX_TREE_MAP_SIZE];
-        unsigned long   tags[RADIX_TREE_MAX_TAGS][RADIX_TREE_TAG_LONGS];
-};
-
-/* The IDR tag is stored in the low bits of the GFP flags */
+/* The IDR tag is stored in the low bits of xa_flags */
 #define ROOT_IS_IDR     ((__force gfp_t)4)
-/* The top bits of gfp_mask are used to store the root tags */
+/* The top bits of xa_flags are used to store the root tags */
 #define ROOT_TAG_SHIFT  (__GFP_BITS_SHIFT)
 
-struct radix_tree_root {
-        spinlock_t              xa_lock;
-        gfp_t                   gfp_mask;
-        struct radix_tree_node  __rcu *rnode;
-};
-
-#define RADIX_TREE_INIT(name, mask)     {                               \
-        .xa_lock = __SPIN_LOCK_UNLOCKED(name.xa_lock),                  \
-        .gfp_mask = (mask),                                             \
-        .rnode = NULL,                                                  \
-}
+#define RADIX_TREE_INIT(name, mask)     XARRAY_INIT(name, mask)
 
 #define RADIX_TREE(name, mask) \
         struct radix_tree_root name = RADIX_TREE_INIT(name, mask)
 
-#define INIT_RADIX_TREE(root, mask)                                     \
-do {                                                                    \
-        spin_lock_init(&(root)->xa_lock);                               \
-        (root)->gfp_mask = (mask);                                      \
-        (root)->rnode = NULL;                                           \
-} while (0)
+#define INIT_RADIX_TREE(root, mask) xa_init_flags(root, mask)
 
 static inline bool radix_tree_empty(const struct radix_tree_root *root)
 {
-        return root->rnode == NULL;
+        return root->xa_head == NULL;
 }
 
 /**
@@ -143,7 +96,6 @@ static inline bool radix_tree_empty(const struct radix_tree_root *root)
  * @next_index: one beyond the last index for this chunk
  * @tags:       bit-mask for tag-iterating
  * @node:       node that contains current slot
- * @shift:      shift for the node that holds our slots
  *
  * This radix tree iterator works in terms of "chunks" of slots.  A chunk is a
  * subinterval of slots contained within one radix tree leaf node.  It is
@@ -157,20 +109,8 @@ struct radix_tree_iter {
         unsigned long   next_index;
         unsigned long   tags;
         struct radix_tree_node *node;
-#ifdef CONFIG_RADIX_TREE_MULTIORDER
-        unsigned int    shift;
-#endif
 };
 
-static inline unsigned int iter_shift(const struct radix_tree_iter *iter)
-{
-#ifdef CONFIG_RADIX_TREE_MULTIORDER
-        return iter->shift;
-#else
-        return 0;
-#endif
-}
-
 /**
  * Radix-tree synchronization
  *
@@ -194,12 +134,11 @@ static inline unsigned int iter_shift(const struct radix_tree_iter *iter)
  * radix_tree_lookup_slot
  * radix_tree_tag_get
  * radix_tree_gang_lookup
- * radix_tree_gang_lookup_slot
  * radix_tree_gang_lookup_tag
  * radix_tree_gang_lookup_tag_slot
  * radix_tree_tagged
  *
- * The first 8 functions are able to be called locklessly, using RCU. The
+ * The first 7 functions are able to be called locklessly, using RCU. The
  * caller must ensure calls to these functions are made within rcu_read_lock()
  * regions. Other readers (lock-free or otherwise) and modifications may be
  * running concurrently.
@@ -269,17 +208,6 @@ static inline int radix_tree_deref_retry(void *arg)
 }
 
 /**
- * radix_tree_exceptional_entry - radix_tree_deref_slot gave exceptional entry?
- * @arg:        value returned by radix_tree_deref_slot
- * Returns:     0 if well-aligned pointer, non-0 if exceptional entry.
- */
-static inline int radix_tree_exceptional_entry(void *arg)
-{
-        /* Not unlikely because radix_tree_exception often tested first */
-        return (unsigned long)arg & RADIX_TREE_EXCEPTIONAL_ENTRY;
-}
-
-/**
  * radix_tree_exception - radix_tree_deref_slot returned either exception?
  * @arg:        value returned by radix_tree_deref_slot
  * Returns:     0 if well-aligned pointer, non-0 if either kind of exception.
@@ -289,47 +217,28 @@ static inline int radix_tree_exception(void *arg)
         return unlikely((unsigned long)arg & RADIX_TREE_ENTRY_MASK);
 }
 
-int __radix_tree_create(struct radix_tree_root *, unsigned long index,
-                        unsigned order, struct radix_tree_node **nodep,
-                        void __rcu ***slotp);
-int __radix_tree_insert(struct radix_tree_root *, unsigned long index,
-                        unsigned order, void *);
-static inline int radix_tree_insert(struct radix_tree_root *root,
-                        unsigned long index, void *entry)
-{
-        return __radix_tree_insert(root, index, 0, entry);
-}
+int radix_tree_insert(struct radix_tree_root *, unsigned long index,
+                        void *);
 void *__radix_tree_lookup(const struct radix_tree_root *, unsigned long index,
                           struct radix_tree_node **nodep, void __rcu ***slotp);
 void *radix_tree_lookup(const struct radix_tree_root *, unsigned long);
 void __rcu **radix_tree_lookup_slot(const struct radix_tree_root *,
                                         unsigned long index);
-typedef void (*radix_tree_update_node_t)(struct radix_tree_node *);
 void __radix_tree_replace(struct radix_tree_root *, struct radix_tree_node *,
-                          void __rcu **slot, void *entry,
-                          radix_tree_update_node_t update_node);
+                          void __rcu **slot, void *entry);
 void radix_tree_iter_replace(struct radix_tree_root *,
                 const struct radix_tree_iter *, void __rcu **slot, void *entry);
 void radix_tree_replace_slot(struct radix_tree_root *,
                              void __rcu **slot, void *entry);
-void __radix_tree_delete_node(struct radix_tree_root *,
-                              struct radix_tree_node *,
-                              radix_tree_update_node_t update_node);
 void radix_tree_iter_delete(struct radix_tree_root *,
                         struct radix_tree_iter *iter, void __rcu **slot);
 void *radix_tree_delete_item(struct radix_tree_root *, unsigned long, void *);
 void *radix_tree_delete(struct radix_tree_root *, unsigned long);
-void radix_tree_clear_tags(struct radix_tree_root *, struct radix_tree_node *,
-                           void __rcu **slot);
 unsigned int radix_tree_gang_lookup(const struct radix_tree_root *,
                         void **results, unsigned long first_index,
                         unsigned int max_items);
-unsigned int radix_tree_gang_lookup_slot(const struct radix_tree_root *,
-                        void __rcu ***results, unsigned long *indices,
-                        unsigned long first_index, unsigned int max_items);
 int radix_tree_preload(gfp_t gfp_mask);
 int radix_tree_maybe_preload(gfp_t gfp_mask);
-int radix_tree_maybe_preload_order(gfp_t gfp_mask, int order);
 void radix_tree_init(void);
 void *radix_tree_tag_set(struct radix_tree_root *,
                         unsigned long index, unsigned int tag);
@@ -337,8 +246,6 @@ void *radix_tree_tag_clear(struct radix_tree_root *,
                         unsigned long index, unsigned int tag);
 int radix_tree_tag_get(const struct radix_tree_root *,
                         unsigned long index, unsigned int tag);
-void radix_tree_iter_tag_set(struct radix_tree_root *,
-                const struct radix_tree_iter *iter, unsigned int tag);
 void radix_tree_iter_tag_clear(struct radix_tree_root *,
                 const struct radix_tree_iter *iter, unsigned int tag);
 unsigned int radix_tree_gang_lookup_tag(const struct radix_tree_root *,
@@ -354,12 +261,6 @@ static inline void radix_tree_preload_end(void)
         preempt_enable();
 }
 
-int radix_tree_split_preload(unsigned old_order, unsigned new_order, gfp_t);
-int radix_tree_split(struct radix_tree_root *, unsigned long index,
-                        unsigned new_order);
-int radix_tree_join(struct radix_tree_root *, unsigned long index,
-                        unsigned new_order, void *);
-
 void __rcu **idr_get_free(struct radix_tree_root *root,
                               struct radix_tree_iter *iter, gfp_t gfp,
                               unsigned long max);
@@ -465,7 +366,7 @@ void __rcu **radix_tree_iter_retry(struct radix_tree_iter *iter)
 static inline unsigned long
 __radix_tree_iter_add(struct radix_tree_iter *iter, unsigned long slots)
 {
-        return iter->index + (slots << iter_shift(iter));
+        return iter->index + slots;
 }
 
 /**
@@ -490,21 +391,9 @@ void __rcu **__must_check radix_tree_iter_resume(void __rcu **slot,
 static __always_inline long
 radix_tree_chunk_size(struct radix_tree_iter *iter)
 {
-        return (iter->next_index - iter->index) >> iter_shift(iter);
+        return iter->next_index - iter->index;
 }
 
-#ifdef CONFIG_RADIX_TREE_MULTIORDER
-void __rcu **__radix_tree_next_slot(void __rcu **slot,
-                                struct radix_tree_iter *iter, unsigned flags);
-#else
-/* Can't happen without sibling entries, but the compiler can't tell that */
-static inline void __rcu **__radix_tree_next_slot(void __rcu **slot,
-                                struct radix_tree_iter *iter, unsigned flags)
-{
-        return slot;
-}
-#endif
-
 /**
  * radix_tree_next_slot - find next slot in chunk
  *
@@ -563,8 +452,6 @@ static __always_inline void __rcu **radix_tree_next_slot(void __rcu **slot,
         return NULL;
 
  found:
-        if (unlikely(radix_tree_is_internal_node(rcu_dereference_raw(*slot))))
-                return __radix_tree_next_slot(slot, iter, flags);
         return slot;
 }
 
@@ -584,23 +471,6 @@ static __always_inline void __rcu **radix_tree_next_slot(void __rcu **slot,
              slot = radix_tree_next_slot(slot, iter, 0))
 
 /**
- * radix_tree_for_each_contig - iterate over contiguous slots
- *
- * @slot:       the void** variable for pointer to slot
- * @root:       the struct radix_tree_root pointer
- * @iter:       the struct radix_tree_iter pointer
- * @start:      iteration starting index
- *
- * @slot points to radix tree slot, @iter->index contains its index.
- */
-#define radix_tree_for_each_contig(slot, root, iter, start)             \
-        for (slot = radix_tree_iter_init(iter, start) ;                 \
-             slot || (slot = radix_tree_next_chunk(root, iter,          \
-                                RADIX_TREE_ITER_CONTIG)) ;              \
-             slot = radix_tree_next_slot(slot, iter,                    \
-                                RADIX_TREE_ITER_CONTIG))
-
-/**
  * radix_tree_for_each_tagged - iterate over tagged slots
  *
  * @slot:       the void** variable for pointer to slot
diff --git a/include/linux/rculist.h b/include/linux/rculist.h
index 4786c2235b98..e91ec9ddcd30 100644
--- a/include/linux/rculist.h
+++ b/include/linux/rculist.h
@@ -182,7 +182,7 @@ static inline void list_replace_rcu(struct list_head *old,
  * @list:       the RCU-protected list to splice
  * @prev:       points to the last element of the existing list
  * @next:       points to the first element of the existing list
- * @sync:       function to sync: synchronize_rcu(), synchronize_sched(), ...
+ * @sync:       synchronize_rcu, synchronize_rcu_expedited, ...
  *
  * The list pointed to by @prev and @next can be RCU-read traversed
  * concurrently with this function.
@@ -240,7 +240,7 @@ static inline void __list_splice_init_rcu(struct list_head *list,
  *                        designed for stacks.
  * @list:       the RCU-protected list to splice
  * @head:       the place in the existing list to splice the first list into
- * @sync:       function to sync: synchronize_rcu(), synchronize_sched(), ...
+ * @sync:       synchronize_rcu, synchronize_rcu_expedited, ...
  */
 static inline void list_splice_init_rcu(struct list_head *list,
                                         struct list_head *head,
@@ -255,7 +255,7 @@ static inline void list_splice_init_rcu(struct list_head *list,
  *                             list, designed for queues.
  * @list:       the RCU-protected list to splice
  * @head:       the place in the existing list to splice the first list into
- * @sync:       function to sync: synchronize_rcu(), synchronize_sched(), ...
+ * @sync:       synchronize_rcu, synchronize_rcu_expedited, ...
  */
 static inline void list_splice_tail_init_rcu(struct list_head *list,
                                              struct list_head *head,
@@ -359,13 +359,12 @@ static inline void list_splice_tail_init_rcu(struct list_head *list,
  * @type:       the type of the struct this is embedded in.
  * @member:     the name of the list_head within the struct.
  *
- * This primitive may safely run concurrently with the _rcu list-mutation
- * primitives such as list_add_rcu(), but requires some implicit RCU
- * read-side guarding.  One example is running within a special
- * exception-time environment where preemption is disabled and where
- * lockdep cannot be invoked (in which case updaters must use RCU-sched,
- * as in synchronize_sched(), call_rcu_sched(), and friends).  Another
- * example is when items are added to the list, but never deleted.
+ * This primitive may safely run concurrently with the _rcu
+ * list-mutation primitives such as list_add_rcu(), but requires some
+ * implicit RCU read-side guarding.  One example is running within a special
+ * exception-time environment where preemption is disabled and where lockdep
+ * cannot be invoked.  Another example is when items are added to the list,
+ * but never deleted.
  */
 #define list_entry_lockless(ptr, type, member) \
         container_of((typeof(ptr))READ_ONCE(ptr), type, member)
@@ -376,13 +375,12 @@ static inline void list_splice_tail_init_rcu(struct list_head *list,
  * @head:       the head for your list.
  * @member:     the name of the list_struct within the struct.
  *
- * This primitive may safely run concurrently with the _rcu list-mutation
- * primitives such as list_add_rcu(), but requires some implicit RCU
- * read-side guarding.  One example is running within a special
- * exception-time environment where preemption is disabled and where
- * lockdep cannot be invoked (in which case updaters must use RCU-sched,
- * as in synchronize_sched(), call_rcu_sched(), and friends).  Another
- * example is when items are added to the list, but never deleted.
+ * This primitive may safely run concurrently with the _rcu
+ * list-mutation primitives such as list_add_rcu(), but requires some
+ * implicit RCU read-side guarding.  One example is running within a special
+ * exception-time environment where preemption is disabled and where lockdep
+ * cannot be invoked.  Another example is when items are added to the list,
+ * but never deleted.
  */
 #define list_for_each_entry_lockless(pos, head, member) \
         for (pos = list_entry_lockless((head)->next, typeof(*pos), member); \
diff --git a/include/linux/rcupdate.h b/include/linux/rcupdate.h
index 75e5b393cf44..4db8bcacc51a 100644
--- a/include/linux/rcupdate.h
+++ b/include/linux/rcupdate.h
@@ -48,23 +48,14 @@
 #define ulong2long(a)           (*(long *)(&(a)))
 
 /* Exported common interfaces */
-
-#ifdef CONFIG_PREEMPT_RCU
 void call_rcu(struct rcu_head *head, rcu_callback_t func);
-#else /* #ifdef CONFIG_PREEMPT_RCU */
-#define call_rcu        call_rcu_sched
-#endif /* #else #ifdef CONFIG_PREEMPT_RCU */
-
-void call_rcu_bh(struct rcu_head *head, rcu_callback_t func);
-void call_rcu_sched(struct rcu_head *head, rcu_callback_t func);
-void synchronize_sched(void);
 void rcu_barrier_tasks(void);
+void synchronize_rcu(void);
 
 #ifdef CONFIG_PREEMPT_RCU
 
 void __rcu_read_lock(void);
 void __rcu_read_unlock(void);
-void synchronize_rcu(void);
 
 /*
  * Defined as a macro as it is a very low level header included from
@@ -88,11 +79,6 @@ static inline void __rcu_read_unlock(void)
                 preempt_enable();
 }
 
-static inline void synchronize_rcu(void)
-{
-        synchronize_sched();
-}
-
 static inline int rcu_preempt_depth(void)
 {
         return 0;
@@ -103,8 +89,6 @@ static inline int rcu_preempt_depth(void)
 /* Internal to kernel */
 void rcu_init(void);
 extern int rcu_scheduler_active __read_mostly;
-void rcu_sched_qs(void);
-void rcu_bh_qs(void);
 void rcu_check_callbacks(int user);
 void rcu_report_dead(unsigned int cpu);
 void rcutree_migrate_callbacks(int cpu);
@@ -135,11 +119,10 @@ static inline void rcu_init_nohz(void) { }
  * RCU_NONIDLE - Indicate idle-loop code that needs RCU readers
  * @a: Code that RCU needs to pay attention to.
  *
- * RCU, RCU-bh, and RCU-sched read-side critical sections are forbidden
- * in the inner idle loop, that is, between the rcu_idle_enter() and
- * the rcu_idle_exit() -- RCU will happily ignore any such read-side
- * critical sections.  However, things like powertop need tracepoints
- * in the inner idle loop.
+ * RCU read-side critical sections are forbidden in the inner idle loop,
+ * that is, between the rcu_idle_enter() and the rcu_idle_exit() -- RCU
+ * will happily ignore any such read-side critical sections.  However,
+ * things like powertop need tracepoints in the inner idle loop.
  *
  * This macro provides the way out:  RCU_NONIDLE(do_something_with_RCU())
  * will tell RCU that it needs to pay attention, invoke its argument
@@ -167,20 +150,16 @@ static inline void rcu_init_nohz(void) { }
                 if (READ_ONCE((t)->rcu_tasks_holdout)) \
                         WRITE_ONCE((t)->rcu_tasks_holdout, false); \
         } while (0)
-#define rcu_note_voluntary_context_switch(t) \
-        do { \
-                rcu_all_qs(); \
-                rcu_tasks_qs(t); \
-        } while (0)
+#define rcu_note_voluntary_context_switch(t) rcu_tasks_qs(t)
 void call_rcu_tasks(struct rcu_head *head, rcu_callback_t func);
 void synchronize_rcu_tasks(void);
 void exit_tasks_rcu_start(void);
 void exit_tasks_rcu_finish(void);
 #else /* #ifdef CONFIG_TASKS_RCU */
 #define rcu_tasks_qs(t) do { } while (0)
-#define rcu_note_voluntary_context_switch(t)            rcu_all_qs()
-#define call_rcu_tasks call_rcu_sched
-#define synchronize_rcu_tasks synchronize_sched
+#define rcu_note_voluntary_context_switch(t) do { } while (0)
+#define call_rcu_tasks call_rcu
+#define synchronize_rcu_tasks synchronize_rcu
 static inline void exit_tasks_rcu_start(void) { }
 static inline void exit_tasks_rcu_finish(void) { }
 #endif /* #else #ifdef CONFIG_TASKS_RCU */
@@ -325,9 +304,8 @@ static inline void rcu_preempt_sleep_check(void) { }
  * Helper functions for rcu_dereference_check(), rcu_dereference_protected()
  * and rcu_assign_pointer().  Some of these could be folded into their
  * callers, but they are left separate in order to ease introduction of
- * multiple flavors of pointers to match the multiple flavors of RCU
- * (e.g., __rcu_bh, * __rcu_sched, and __srcu), should this make sense in
- * the future.
+ * multiple pointers markings to match different RCU implementations
+ * (e.g., __srcu), should this make sense in the future.
  */
 
 #ifdef __CHECKER__
@@ -686,14 +664,9 @@ static inline void rcu_read_unlock(void)
 /**
  * rcu_read_lock_bh() - mark the beginning of an RCU-bh critical section
  *
- * This is equivalent of rcu_read_lock(), but to be used when updates
- * are being done using call_rcu_bh() or synchronize_rcu_bh(). Since
- * both call_rcu_bh() and synchronize_rcu_bh() consider completion of a
- * softirq handler to be a quiescent state, a process in RCU read-side
- * critical section must be protected by disabling softirqs. Read-side
- * critical sections in interrupt context can use just rcu_read_lock(),
- * though this should at least be commented to avoid confusing people
- * reading the code.
+ * This is equivalent of rcu_read_lock(), but also disables softirqs.
+ * Note that anything else that disables softirqs can also serve as
+ * an RCU read-side critical section.
  *
  * Note that rcu_read_lock_bh() and the matching rcu_read_unlock_bh()
  * must occur in the same context, for example, it is illegal to invoke
@@ -726,10 +699,9 @@ static inline void rcu_read_unlock_bh(void)
 /**
  * rcu_read_lock_sched() - mark the beginning of a RCU-sched critical section
  *
- * This is equivalent of rcu_read_lock(), but to be used when updates
- * are being done using call_rcu_sched() or synchronize_rcu_sched().
- * Read-side critical sections can also be introduced by anything that
- * disables preemption, including local_irq_disable() and friends.
+ * This is equivalent of rcu_read_lock(), but disables preemption.
+ * Read-side critical sections can also be introduced by anything else
+ * that disables preemption, including local_irq_disable() and friends.
  *
  * Note that rcu_read_lock_sched() and the matching rcu_read_unlock_sched()
  * must occur in the same context, for example, it is illegal to invoke
@@ -885,4 +857,96 @@ static inline notrace void rcu_read_unlock_sched_notrace(void)
 #endif /* #else #ifdef CONFIG_ARCH_WEAK_RELEASE_ACQUIRE */
 
 
+/* Has the specified rcu_head structure been handed to call_rcu()? */
+
+/*
+ * rcu_head_init - Initialize rcu_head for rcu_head_after_call_rcu()
+ * @rhp: The rcu_head structure to initialize.
+ *
+ * If you intend to invoke rcu_head_after_call_rcu() to test whether a
+ * given rcu_head structure has already been passed to call_rcu(), then
+ * you must also invoke this rcu_head_init() function on it just after
+ * allocating that structure.  Calls to this function must not race with
+ * calls to call_rcu(), rcu_head_after_call_rcu(), or callback invocation.
+ */
+static inline void rcu_head_init(struct rcu_head *rhp)
+{
+        rhp->func = (rcu_callback_t)~0L;
+}
+
+/*
+ * rcu_head_after_call_rcu - Has this rcu_head been passed to call_rcu()?
+ * @rhp: The rcu_head structure to test.
+ * @func: The function passed to call_rcu() along with @rhp.
+ *
+ * Returns @true if the @rhp has been passed to call_rcu() with @func,
+ * and @false otherwise.  Emits a warning in any other case, including
+ * the case where @rhp has already been invoked after a grace period.
+ * Calls to this function must not race with callback invocation.  One way
+ * to avoid such races is to enclose the call to rcu_head_after_call_rcu()
+ * in an RCU read-side critical section that includes a read-side fetch
+ * of the pointer to the structure containing @rhp.
+ */
+static inline bool
+rcu_head_after_call_rcu(struct rcu_head *rhp, rcu_callback_t f)
+{
+        if (READ_ONCE(rhp->func) == f)
+                return true;
+        WARN_ON_ONCE(READ_ONCE(rhp->func) != (rcu_callback_t)~0L);
+        return false;
+}
+
+
+/* Transitional pre-consolidation compatibility definitions. */
+
+static inline void synchronize_rcu_bh(void)
+{
+        synchronize_rcu();
+}
+
+static inline void synchronize_rcu_bh_expedited(void)
+{
+        synchronize_rcu_expedited();
+}
+
+static inline void call_rcu_bh(struct rcu_head *head, rcu_callback_t func)
+{
+        call_rcu(head, func);
+}
+
+static inline void rcu_barrier_bh(void)
+{
+        rcu_barrier();
+}
+
+static inline void synchronize_sched(void)
+{
+        synchronize_rcu();
+}
+
+static inline void synchronize_sched_expedited(void)
+{
+        synchronize_rcu_expedited();
+}
+
+static inline void call_rcu_sched(struct rcu_head *head, rcu_callback_t func)
+{
+        call_rcu(head, func);
+}
+
+static inline void rcu_barrier_sched(void)
+{
+        rcu_barrier();
+}
+
+static inline unsigned long get_state_synchronize_sched(void)
+{
+        return get_state_synchronize_rcu();
+}
+
+static inline void cond_synchronize_sched(unsigned long oldstate)
+{
+        cond_synchronize_rcu(oldstate);
+}
+
 #endif /* __LINUX_RCUPDATE_H */
diff --git a/include/linux/rcupdate_wait.h b/include/linux/rcupdate_wait.h
index 57f371344152..8a16c3eb3dd0 100644
--- a/include/linux/rcupdate_wait.h
+++ b/include/linux/rcupdate_wait.h
@@ -33,17 +33,17 @@ do {									\
 
 /**
  * synchronize_rcu_mult - Wait concurrently for multiple grace periods
- * @...: List of call_rcu() functions for the flavors to wait on.
+ * @...: List of call_rcu() functions for different grace periods to wait on
  *
- * This macro waits concurrently for multiple flavors of RCU grace periods.
- * For example, synchronize_rcu_mult(call_rcu, call_rcu_bh) would wait
- * on concurrent RCU and RCU-bh grace periods.  Waiting on a give SRCU
+ * This macro waits concurrently for multiple types of RCU grace periods.
+ * For example, synchronize_rcu_mult(call_rcu, call_rcu_tasks) would wait
+ * on concurrent RCU and RCU-tasks grace periods.  Waiting on a give SRCU
  * domain requires you to write a wrapper function for that SRCU domain's
  * call_srcu() function, supplying the corresponding srcu_struct.
  *
- * If Tiny RCU, tell _wait_rcu_gp() not to bother waiting for RCU
- * or RCU-bh, given that anywhere synchronize_rcu_mult() can be called
- * is automatically a grace period.
+ * If Tiny RCU, tell _wait_rcu_gp() does not bother waiting for RCU,
+ * given that anywhere synchronize_rcu_mult() can be called is automatically
+ * a grace period.
  */
 #define synchronize_rcu_mult(...) \
         _wait_rcu_gp(IS_ENABLED(CONFIG_TINY_RCU), __VA_ARGS__)
diff --git a/include/linux/rcutiny.h b/include/linux/rcutiny.h
index 8d9a0ea8f0b5..af65d1f36ddb 100644
--- a/include/linux/rcutiny.h
+++ b/include/linux/rcutiny.h
@@ -27,12 +27,6 @@
 
 #include <linux/ktime.h>
 
-struct rcu_dynticks;
-static inline int rcu_dynticks_snap(struct rcu_dynticks *rdtp)
-{
-        return 0;
-}
-
 /* Never flag non-existent other CPUs! */
 static inline bool rcu_eqs_special_set(int cpu) { return false; }
 
@@ -46,53 +40,28 @@ static inline void cond_synchronize_rcu(unsigned long oldstate)
         might_sleep();
 }
 
-static inline unsigned long get_state_synchronize_sched(void)
-{
-        return 0;
-}
-
-static inline void cond_synchronize_sched(unsigned long oldstate)
-{
-        might_sleep();
-}
-
-extern void rcu_barrier_bh(void);
-extern void rcu_barrier_sched(void);
+extern void rcu_barrier(void);
 
 static inline void synchronize_rcu_expedited(void)
 {
-        synchronize_sched();    /* Only one CPU, so pretty fast anyway!!! */
+        synchronize_rcu();
 }
 
-static inline void rcu_barrier(void)
+static inline void kfree_call_rcu(struct rcu_head *head, rcu_callback_t func)
 {
-        rcu_barrier_sched();  /* Only one CPU, so only one list of callbacks! */
-}
-
-static inline void synchronize_rcu_bh(void)
-{
-        synchronize_sched();
-}
-
-static inline void synchronize_rcu_bh_expedited(void)
-{
-        synchronize_sched();
+        call_rcu(head, func);
 }
 
-static inline void synchronize_sched_expedited(void)
-{
-        synchronize_sched();
-}
+void rcu_qs(void);
 
-static inline void kfree_call_rcu(struct rcu_head *head,
-                                  rcu_callback_t func)
+static inline void rcu_softirq_qs(void)
 {
-        call_rcu(head, func);
+        rcu_qs();
 }
 
 #define rcu_note_context_switch(preempt) \
         do { \
-                rcu_sched_qs(); \
+                rcu_qs(); \
                 rcu_tasks_qs(current); \
         } while (0)
 
@@ -108,6 +77,7 @@ static inline int rcu_needs_cpu(u64 basemono, u64 *nextevt)
  */
 static inline void rcu_virt_note_context_switch(int cpu) { }
 static inline void rcu_cpu_stall_reset(void) { }
+static inline int rcu_jiffies_till_stall_check(void) { return 21 * HZ; }
 static inline void rcu_idle_enter(void) { }
 static inline void rcu_idle_exit(void) { }
 static inline void rcu_irq_enter(void) { }
@@ -115,6 +85,11 @@ static inline void rcu_irq_exit_irqson(void) { }
 static inline void rcu_irq_enter_irqson(void) { }
 static inline void rcu_irq_exit(void) { }
 static inline void exit_rcu(void) { }
+static inline bool rcu_preempt_need_deferred_qs(struct task_struct *t)
+{
+        return false;
+}
+static inline void rcu_preempt_deferred_qs(struct task_struct *t) { }
 #ifdef CONFIG_SRCU
 void rcu_scheduler_starting(void);
 #else /* #ifndef CONFIG_SRCU */
diff --git a/include/linux/rcutree.h b/include/linux/rcutree.h
index 914655848ef6..7f83179177d1 100644
--- a/include/linux/rcutree.h
+++ b/include/linux/rcutree.h
@@ -30,6 +30,7 @@
 #ifndef __LINUX_RCUTREE_H
 #define __LINUX_RCUTREE_H
 
+void rcu_softirq_qs(void);
 void rcu_note_context_switch(bool preempt);
 int rcu_needs_cpu(u64 basem, u64 *nextevt);
 void rcu_cpu_stall_reset(void);
@@ -44,41 +45,13 @@ static inline void rcu_virt_note_context_switch(int cpu)
         rcu_note_context_switch(false);
 }
 
-void synchronize_rcu_bh(void);
-void synchronize_sched_expedited(void);
 void synchronize_rcu_expedited(void);
-
 void kfree_call_rcu(struct rcu_head *head, rcu_callback_t func);
 
-/**
- * synchronize_rcu_bh_expedited - Brute-force RCU-bh grace period
- *
- * Wait for an RCU-bh grace period to elapse, but use a "big hammer"
- * approach to force the grace period to end quickly.  This consumes
- * significant time on all CPUs and is unfriendly to real-time workloads,
- * so is thus not recommended for any sort of common-case code.  In fact,
- * if you are using synchronize_rcu_bh_expedited() in a loop, please
- * restructure your code to batch your updates, and then use a single
- * synchronize_rcu_bh() instead.
- *
- * Note that it is illegal to call this function while holding any lock
- * that is acquired by a CPU-hotplug notifier.  And yes, it is also illegal
- * to call this function from a CPU-hotplug notifier.  Failing to observe
- * these restriction will result in deadlock.
- */
-static inline void synchronize_rcu_bh_expedited(void)
-{
-        synchronize_sched_expedited();
-}
-
 void rcu_barrier(void);
-void rcu_barrier_bh(void);
-void rcu_barrier_sched(void);
 bool rcu_eqs_special_set(int cpu);
 unsigned long get_state_synchronize_rcu(void);
 void cond_synchronize_rcu(unsigned long oldstate);
-unsigned long get_state_synchronize_sched(void);
-void cond_synchronize_sched(unsigned long oldstate);
 
 void rcu_idle_enter(void);
 void rcu_idle_exit(void);
@@ -93,7 +66,9 @@ void rcu_scheduler_starting(void);
 extern int rcu_scheduler_active __read_mostly;
 void rcu_end_inkernel_boot(void);
 bool rcu_is_watching(void);
+#ifndef CONFIG_PREEMPT
 void rcu_all_qs(void);
+#endif
 
 /* RCUtree hotplug events */
 int rcutree_prepare_cpu(unsigned int cpu);
diff --git a/include/linux/regmap.h b/include/linux/regmap.h
index 379505a53722..a367d59c301d 100644
--- a/include/linux/regmap.h
+++ b/include/linux/regmap.h
@@ -268,6 +268,13 @@ typedef void (*regmap_unlock)(void *);
  *                field is NULL but precious_table (see below) is not, the
  *                check is performed on such table (a register is precious if
  *                it belongs to one of the ranges specified by precious_table).
+ * @writeable_noinc_reg: Optional callback returning true if the register
+ *                      supports multiple write operations without incrementing
+ *                      the register number. If this field is NULL but
+ *                      wr_noinc_table (see below) is not, the check is
+ *                      performed on such table (a register is no increment
+ *                      writeable if it belongs to one of the ranges specified
+ *                      by wr_noinc_table).
  * @readable_noinc_reg: Optional callback returning true if the register
  *                      supports multiple read operations without incrementing
  *                      the register number. If this field is NULL but
@@ -302,6 +309,7 @@ typedef void (*regmap_unlock)(void *);
  * @rd_table:     As above, for read access.
  * @volatile_table: As above, for volatile registers.
  * @precious_table: As above, for precious registers.
+ * @wr_noinc_table: As above, for no increment writeable registers.
  * @rd_noinc_table: As above, for no increment readable registers.
  * @reg_defaults: Power on reset values for registers (for use with
  *                register cache support).
@@ -315,9 +323,12 @@ typedef void (*regmap_unlock)(void *);
  *                   masks are used.
  * @zero_flag_mask: If set, read_flag_mask and write_flag_mask are used even
  *                   if they are both empty.
- * @use_single_rw: If set, converts the bulk read and write operations into
- *                  a series of single read and write operations. This is useful
- *                  for device that does not support bulk read and write.
+ * @use_single_read: If set, converts the bulk read operation into a series of
+ *                   single read operations. This is useful for a device that
+ *                   does not support  bulk read.
+ * @use_single_write: If set, converts the bulk write operation into a series of
+ *                    single write operations. This is useful for a device that
+ *                    does not support bulk write.
  * @can_multi_write: If set, the device supports the multi write mode of bulk
  *                   write operations, if clear multi write requests will be
  *                   split into individual write operations
@@ -352,6 +363,7 @@ struct regmap_config {
         bool (*readable_reg)(struct device *dev, unsigned int reg);
         bool (*volatile_reg)(struct device *dev, unsigned int reg);
         bool (*precious_reg)(struct device *dev, unsigned int reg);
+        bool (*writeable_noinc_reg)(struct device *dev, unsigned int reg);
         bool (*readable_noinc_reg)(struct device *dev, unsigned int reg);
 
         bool disable_locking;
@@ -369,6 +381,7 @@ struct regmap_config {
         const struct regmap_access_table *rd_table;
         const struct regmap_access_table *volatile_table;
         const struct regmap_access_table *precious_table;
+        const struct regmap_access_table *wr_noinc_table;
         const struct regmap_access_table *rd_noinc_table;
         const struct reg_default *reg_defaults;
         unsigned int num_reg_defaults;
@@ -380,7 +393,8 @@ struct regmap_config {
         unsigned long write_flag_mask;
         bool zero_flag_mask;
 
-        bool use_single_rw;
+        bool use_single_read;
+        bool use_single_write;
         bool can_multi_write;
 
         enum regmap_endian reg_format_endian;
@@ -979,6 +993,8 @@ int regmap_write(struct regmap *map, unsigned int reg, unsigned int val);
 int regmap_write_async(struct regmap *map, unsigned int reg, unsigned int val);
 int regmap_raw_write(struct regmap *map, unsigned int reg,
                      const void *val, size_t val_len);
+int regmap_noinc_write(struct regmap *map, unsigned int reg,
+                     const void *val, size_t val_len);
 int regmap_bulk_write(struct regmap *map, unsigned int reg, const void *val,
                         size_t val_count);
 int regmap_multi_reg_write(struct regmap *map, const struct reg_sequence *regs,
@@ -1222,6 +1238,13 @@ static inline int regmap_raw_write_async(struct regmap *map, unsigned int reg,
         return -EINVAL;
 }
 
+static inline int regmap_noinc_write(struct regmap *map, unsigned int reg,
+                                    const void *val, size_t val_len)
+{
+        WARN_ONCE(1, "regmap API is disabled");
+        return -EINVAL;
+}
+
 static inline int regmap_bulk_write(struct regmap *map, unsigned int reg,
                                     const void *val, size_t val_count)
 {
diff --git a/include/linux/regulator/driver.h b/include/linux/regulator/driver.h
index 0fd8fbb74763..a9c030192147 100644
--- a/include/linux/regulator/driver.h
+++ b/include/linux/regulator/driver.h
@@ -271,9 +271,16 @@ enum regulator_type {
  * @ramp_delay: Time to settle down after voltage change (unit: uV/us)
  * @min_dropout_uV: The minimum dropout voltage this regulator can handle
  * @linear_ranges: A constant table of possible voltage ranges.
- * @n_linear_ranges: Number of entries in the @linear_ranges table.
+ * @linear_range_selectors: A constant table of voltage range selectors.
+ *                          If pickable ranges are used each range must
+ *                          have corresponding selector here.
+ * @n_linear_ranges: Number of entries in the @linear_ranges (and in
+ *                   linear_range_selectors if used) table(s).
  * @volt_table: Voltage mapping table (if table based mapping)
  *
+ * @vsel_range_reg: Register for range selector when using pickable ranges
+ *                  and regulator_regmap_X_voltage_X_pickable functions.
+ * @vsel_range_mask: Mask for register bitfield used for range selector
  * @vsel_reg: Register for selector when using regulator_regmap_X_voltage_
  * @vsel_mask: Mask for register bitfield used for selector
  * @csel_reg: Register for TPS65218 LS3 current regulator
@@ -338,10 +345,14 @@ struct regulator_desc {
         int min_dropout_uV;
 
         const struct regulator_linear_range *linear_ranges;
+        const unsigned int *linear_range_selectors;
+
         int n_linear_ranges;
 
         const unsigned int *volt_table;
 
+        unsigned int vsel_range_reg;
+        unsigned int vsel_range_mask;
         unsigned int vsel_reg;
         unsigned int vsel_mask;
         unsigned int csel_reg;
@@ -498,18 +509,25 @@ int regulator_mode_to_status(unsigned int);
 
 int regulator_list_voltage_linear(struct regulator_dev *rdev,
                                   unsigned int selector);
+int regulator_list_voltage_pickable_linear_range(struct regulator_dev *rdev,
+                                                   unsigned int selector);
 int regulator_list_voltage_linear_range(struct regulator_dev *rdev,
                                         unsigned int selector);
 int regulator_list_voltage_table(struct regulator_dev *rdev,
                                   unsigned int selector);
 int regulator_map_voltage_linear(struct regulator_dev *rdev,
                                   int min_uV, int max_uV);
+int regulator_map_voltage_pickable_linear_range(struct regulator_dev *rdev,
+                                                  int min_uV, int max_uV);
 int regulator_map_voltage_linear_range(struct regulator_dev *rdev,
                                        int min_uV, int max_uV);
 int regulator_map_voltage_iterate(struct regulator_dev *rdev,
                                   int min_uV, int max_uV);
 int regulator_map_voltage_ascend(struct regulator_dev *rdev,
                                   int min_uV, int max_uV);
+int regulator_get_voltage_sel_pickable_regmap(struct regulator_dev *rdev);
+int regulator_set_voltage_sel_pickable_regmap(struct regulator_dev *rdev,
+                                                unsigned int sel);
 int regulator_get_voltage_sel_regmap(struct regulator_dev *rdev);
 int regulator_set_voltage_sel_regmap(struct regulator_dev *rdev, unsigned sel);
 int regulator_is_enabled_regmap(struct regulator_dev *rdev);
diff --git a/include/linux/regulator/fixed.h b/include/linux/regulator/fixed.h
index 48918be649d4..1a4340ed8e2b 100644
--- a/include/linux/regulator/fixed.h
+++ b/include/linux/regulator/fixed.h
@@ -24,8 +24,6 @@ struct regulator_init_data;
  * @supply_name:        Name of the regulator supply
  * @input_supply:       Name of the input regulator supply
  * @microvolts:         Output voltage of regulator
- * @gpio:               GPIO to use for enable control
- *                      set to -EINVAL if not used
  * @startup_delay:      Start-up time in microseconds
  * @gpio_is_open_drain: Gpio pin is open drain or normal type.
  *                      If it is open drain type then HIGH will be set
@@ -49,7 +47,6 @@ struct fixed_voltage_config {
         const char *supply_name;
         const char *input_supply;
         int microvolts;
-        int gpio;
         unsigned startup_delay;
         unsigned gpio_is_open_drain:1;
         unsigned enable_high:1;
diff --git a/include/linux/regulator/machine.h b/include/linux/regulator/machine.h
index 3468703d663a..a459a5e973a7 100644
--- a/include/linux/regulator/machine.h
+++ b/include/linux/regulator/machine.h
@@ -48,9 +48,9 @@ struct regulator;
  * DISABLE_IN_SUSPEND   - turn off regulator in suspend states
  * ENABLE_IN_SUSPEND    - keep regulator on in suspend states
  */
-#define DO_NOTHING_IN_SUSPEND   (-1)
-#define DISABLE_IN_SUSPEND      0
-#define ENABLE_IN_SUSPEND       1
+#define DO_NOTHING_IN_SUSPEND   0
+#define DISABLE_IN_SUSPEND      1
+#define ENABLE_IN_SUSPEND       2
 
 /* Regulator active discharge flags */
 enum regulator_active_discharge {
diff --git a/include/linux/restart_block.h b/include/linux/restart_block.h
index 5d83d0c1d06c..bba2920e9c05 100644
--- a/include/linux/restart_block.h
+++ b/include/linux/restart_block.h
@@ -10,7 +10,7 @@
 #include <linux/time64.h>
 
 struct timespec;
-struct compat_timespec;
+struct old_timespec32;
 struct pollfd;
 
 enum timespec_type {
@@ -40,7 +40,7 @@ struct restart_block {
                         enum timespec_type type;
                         union {
                                 struct __kernel_timespec __user *rmtp;
-                                struct compat_timespec __user *compat_rmtp;
+                                struct old_timespec32 __user *compat_rmtp;
                         };
                         u64 expires;
                 } nanosleep;
diff --git a/include/linux/rtc.h b/include/linux/rtc.h
index 6aedc30003e7..c8bb4a2b48c3 100644
--- a/include/linux/rtc.h
+++ b/include/linux/rtc.h
@@ -167,17 +167,12 @@ struct rtc_device {
 #define RTC_TIMESTAMP_BEGIN_2000        946684800LL /* 2000-01-01 00:00:00 */
 #define RTC_TIMESTAMP_END_2099          4102444799LL /* 2099-12-31 23:59:59 */
 
-extern struct rtc_device *rtc_device_register(const char *name,
-                                        struct device *dev,
-                                        const struct rtc_class_ops *ops,
-                                        struct module *owner);
 extern struct rtc_device *devm_rtc_device_register(struct device *dev,
                                         const char *name,
                                         const struct rtc_class_ops *ops,
                                         struct module *owner);
 struct rtc_device *devm_rtc_allocate_device(struct device *dev);
 int __rtc_register_device(struct module *owner, struct rtc_device *rtc);
-extern void rtc_device_unregister(struct rtc_device *rtc);
 extern void devm_rtc_device_unregister(struct device *dev,
                                         struct rtc_device *rtc);
 
@@ -277,4 +272,20 @@ static inline int rtc_nvmem_register(struct rtc_device *rtc,
 static inline void rtc_nvmem_unregister(struct rtc_device *rtc) {}
 #endif
 
+#ifdef CONFIG_RTC_INTF_SYSFS
+int rtc_add_group(struct rtc_device *rtc, const struct attribute_group *grp);
+int rtc_add_groups(struct rtc_device *rtc, const struct attribute_group **grps);
+#else
+static inline
+int rtc_add_group(struct rtc_device *rtc, const struct attribute_group *grp)
+{
+        return 0;
+}
+
+static inline
+int rtc_add_groups(struct rtc_device *rtc, const struct attribute_group **grps)
+{
+        return 0;
+}
+#endif
 #endif /* _LINUX_RTC_H_ */
diff --git a/include/linux/rtnetlink.h b/include/linux/rtnetlink.h
index 5225832bd6ff..bb9cb84114c1 100644
--- a/include/linux/rtnetlink.h
+++ b/include/linux/rtnetlink.h
@@ -6,6 +6,7 @@
 #include <linux/mutex.h>
 #include <linux/netdevice.h>
 #include <linux/wait.h>
+#include <linux/refcount.h>
 #include <uapi/linux/rtnetlink.h>
 
 extern int rtnetlink_send(struct sk_buff *skb, struct net *net, u32 pid, u32 group, int echo);
@@ -34,6 +35,7 @@ extern void rtnl_unlock(void);
 extern int rtnl_trylock(void);
 extern int rtnl_is_locked(void);
 extern int rtnl_lock_killable(void);
+extern bool refcount_dec_and_rtnl_lock(refcount_t *r);
 
 extern wait_queue_head_t netdev_unregistering_wq;
 extern struct rw_semaphore pernet_ops_rwsem;
@@ -83,6 +85,11 @@ static inline struct netdev_queue *dev_ingress_queue(struct net_device *dev)
         return rtnl_dereference(dev->ingress_queue);
 }
 
+static inline struct netdev_queue *dev_ingress_queue_rcu(struct net_device *dev)
+{
+        return rcu_dereference(dev->ingress_queue);
+}
+
 struct netdev_queue *dev_ingress_queue_create(struct net_device *dev);
 
 #ifdef CONFIG_NET_INGRESS
diff --git a/include/linux/rwsem.h b/include/linux/rwsem.h
index ab93b6eae696..67dbb57508b1 100644
--- a/include/linux/rwsem.h
+++ b/include/linux/rwsem.h
@@ -45,10 +45,10 @@ struct rw_semaphore {
 };
 
 /*
- * Setting bit 0 of the owner field with other non-zero bits will indicate
+ * Setting bit 1 of the owner field but not bit 0 will indicate
  * that the rwsem is writer-owned with an unknown owner.
  */
-#define RWSEM_OWNER_UNKNOWN     ((struct task_struct *)-1L)
+#define RWSEM_OWNER_UNKNOWN     ((struct task_struct *)-2L)
 
 extern struct rw_semaphore *rwsem_down_read_failed(struct rw_semaphore *sem);
 extern struct rw_semaphore *rwsem_down_read_failed_killable(struct rw_semaphore *sem);
diff --git a/include/linux/sched.h b/include/linux/sched.h
index 977cb57d7bc9..8f8a5418b627 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -25,6 +25,7 @@
 #include <linux/latencytop.h>
 #include <linux/sched/prio.h>
 #include <linux/signal_types.h>
+#include <linux/psi_types.h>
 #include <linux/mm_types_task.h>
 #include <linux/task_io_accounting.h>
 #include <linux/rseq.h>
@@ -571,12 +572,8 @@ union rcu_special {
         struct {
                 u8                      blocked;
                 u8                      need_qs;
-                u8                      exp_need_qs;
-
-                /* Otherwise the compiler can store garbage here: */
-                u8                      pad;
         } b; /* Bits. */
-        u32 s; /* Set of bits. */
+        u16 s; /* Set of bits. */
 };
 
 enum perf_event_task_context {
@@ -710,6 +707,10 @@ struct task_struct {
         unsigned                        sched_contributes_to_load:1;
         unsigned                        sched_migrated:1;
         unsigned                        sched_remote_wakeup:1;
+#ifdef CONFIG_PSI
+        unsigned                        sched_psi_wake_requeue:1;
+#endif
+
         /* Force alignment to the next boundary: */
         unsigned                        :0;
 
@@ -723,9 +724,6 @@ struct task_struct {
 #endif
 #ifdef CONFIG_MEMCG
         unsigned                        in_user_fault:1;
-#ifdef CONFIG_MEMCG_KMEM
-        unsigned                        memcg_kmem_skip_account:1;
-#endif
 #endif
 #ifdef CONFIG_COMPAT_BRK
         unsigned                        brk_randomized:1;
@@ -739,6 +737,12 @@ struct task_struct {
         unsigned                        use_memdelay:1;
 #endif
 
+        /*
+         * May usercopy functions fault on kernel addresses?
+         * This is not just a single bit because this can potentially nest.
+         */
+        unsigned int                    kernel_uaccess_faults_ok;
+
         unsigned long                   atomic_flags; /* Flags requiring atomic access. */
 
         struct restart_block            restart_block;
@@ -960,9 +964,13 @@ struct task_struct {
 
         /* Ptrace state: */
         unsigned long                   ptrace_message;
-        siginfo_t                       *last_siginfo;
+        kernel_siginfo_t                *last_siginfo;
 
         struct task_io_accounting       ioac;
+#ifdef CONFIG_PSI
+        /* Pressure stall state */
+        unsigned int                    psi_flags;
+#endif
 #ifdef CONFIG_TASK_XACCT
         /* Accumulated RSS usage: */
         u64                             acct_rss_mem1;
@@ -1389,6 +1397,7 @@ extern struct pid *cad_pid;
 #define PF_KTHREAD              0x00200000      /* I am a kernel thread */
 #define PF_RANDOMIZE            0x00400000      /* Randomize virtual address space */
 #define PF_SWAPWRITE            0x00800000      /* Allowed to write to swap */
+#define PF_MEMSTALL             0x01000000      /* Stalled due to lack of memory */
 #define PF_NO_SETAFFINITY       0x04000000      /* Userland is not allowed to meddle with cpus_allowed */
 #define PF_MCE_EARLY            0x08000000      /* Early kill for mce process policy */
 #define PF_MUTEX_TESTER         0x20000000      /* Thread belongs to the rt mutex tester */
diff --git a/include/linux/sched/loadavg.h b/include/linux/sched/loadavg.h
index 80bc84ba5d2a..4859bea47a7b 100644
--- a/include/linux/sched/loadavg.h
+++ b/include/linux/sched/loadavg.h
@@ -22,10 +22,26 @@ extern void get_avenrun(unsigned long *loads, unsigned long offset, int shift);
 #define EXP_5           2014            /* 1/exp(5sec/5min) */
 #define EXP_15          2037            /* 1/exp(5sec/15min) */
 
-#define CALC_LOAD(load,exp,n) \
-        load *= exp; \
-        load += n*(FIXED_1-exp); \
-        load >>= FSHIFT;
+/*
+ * a1 = a0 * e + a * (1 - e)
+ */
+static inline unsigned long
+calc_load(unsigned long load, unsigned long exp, unsigned long active)
+{
+        unsigned long newload;
+
+        newload = load * exp + active * (FIXED_1 - exp);
+        if (active >= load)
+                newload += FIXED_1-1;
+
+        return newload / FIXED_1;
+}
+
+extern unsigned long calc_load_n(unsigned long load, unsigned long exp,
+                                 unsigned long active, unsigned int n);
+
+#define LOAD_INT(x) ((x) >> FSHIFT)
+#define LOAD_FRAC(x) LOAD_INT(((x) & (FIXED_1-1)) * 100)
 
 extern void calc_global_load(unsigned long ticks);
 
diff --git a/include/linux/sched/signal.h b/include/linux/sched/signal.h
index 1be35729c2c5..13789d10a50e 100644
--- a/include/linux/sched/signal.h
+++ b/include/linux/sched/signal.h
@@ -270,16 +270,16 @@ static inline int signal_group_exit(const struct signal_struct *sig)
 extern void flush_signals(struct task_struct *);
 extern void ignore_signals(struct task_struct *);
 extern void flush_signal_handlers(struct task_struct *, int force_default);
-extern int dequeue_signal(struct task_struct *tsk, sigset_t *mask, siginfo_t *info);
+extern int dequeue_signal(struct task_struct *tsk, sigset_t *mask, kernel_siginfo_t *info);
 
-static inline int kernel_dequeue_signal(siginfo_t *info)
+static inline int kernel_dequeue_signal(void)
 {
         struct task_struct *tsk = current;
-        siginfo_t __info;
+        kernel_siginfo_t __info;
         int ret;
 
         spin_lock_irq(&tsk->sighand->siglock);
-        ret = dequeue_signal(tsk, &tsk->blocked, info ?: &__info);
+        ret = dequeue_signal(tsk, &tsk->blocked, &__info);
         spin_unlock_irq(&tsk->sighand->siglock);
 
         return ret;
@@ -322,12 +322,12 @@ int force_sig_pkuerr(void __user *addr, u32 pkey);
 
 int force_sig_ptrace_errno_trap(int errno, void __user *addr);
 
-extern int send_sig_info(int, struct siginfo *, struct task_struct *);
+extern int send_sig_info(int, struct kernel_siginfo *, struct task_struct *);
 extern void force_sigsegv(int sig, struct task_struct *p);
-extern int force_sig_info(int, struct siginfo *, struct task_struct *);
-extern int __kill_pgrp_info(int sig, struct siginfo *info, struct pid *pgrp);
-extern int kill_pid_info(int sig, struct siginfo *info, struct pid *pid);
-extern int kill_pid_info_as_cred(int, struct siginfo *, struct pid *,
+extern int force_sig_info(int, struct kernel_siginfo *, struct task_struct *);
+extern int __kill_pgrp_info(int sig, struct kernel_siginfo *info, struct pid *pgrp);
+extern int kill_pid_info(int sig, struct kernel_siginfo *info, struct pid *pid);
+extern int kill_pid_info_as_cred(int, struct kernel_siginfo *, struct pid *,
                                 const struct cred *);
 extern int kill_pgrp(struct pid *pid, int sig, int priv);
 extern int kill_pid(struct pid *pid, int sig, int priv);
@@ -475,9 +475,8 @@ static inline int kill_cad_pid(int sig, int priv)
 }
 
 /* These can be the second arg to send_sig_info/send_group_sig_info.  */
-#define SEND_SIG_NOINFO ((struct siginfo *) 0)
-#define SEND_SIG_PRIV   ((struct siginfo *) 1)
-#define SEND_SIG_FORCED ((struct siginfo *) 2)
+#define SEND_SIG_NOINFO ((struct kernel_siginfo *) 0)
+#define SEND_SIG_PRIV   ((struct kernel_siginfo *) 1)
 
 /*
  * True if we are on the alternate signal stack.
diff --git a/include/linux/sched/topology.h b/include/linux/sched/topology.h
index 26347741ba50..6b9976180c1e 100644
--- a/include/linux/sched/topology.h
+++ b/include/linux/sched/topology.h
@@ -23,10 +23,10 @@
 #define SD_BALANCE_FORK         0x0008  /* Balance on fork, clone */
 #define SD_BALANCE_WAKE         0x0010  /* Balance on wakeup */
 #define SD_WAKE_AFFINE          0x0020  /* Wake task to waking CPU */
-#define SD_ASYM_CPUCAPACITY     0x0040  /* Groups have different max cpu capacities */
-#define SD_SHARE_CPUCAPACITY    0x0080  /* Domain members share cpu capacity */
+#define SD_ASYM_CPUCAPACITY     0x0040  /* Domain members have different CPU capacities */
+#define SD_SHARE_CPUCAPACITY    0x0080  /* Domain members share CPU capacity */
 #define SD_SHARE_POWERDOMAIN    0x0100  /* Domain members share power domain */
-#define SD_SHARE_PKG_RESOURCES  0x0200  /* Domain members share cpu pkg resources */
+#define SD_SHARE_PKG_RESOURCES  0x0200  /* Domain members share CPU pkg resources */
 #define SD_SERIALIZE            0x0400  /* Only a single load balancing instance */
 #define SD_ASYM_PACKING         0x0800  /* Place busy groups earlier in the domain */
 #define SD_PREFER_SIBLING       0x1000  /* Prefer to place tasks in a sibling domain */
diff --git a/include/linux/security.h b/include/linux/security.h
index 75f4156c84d7..d170a5b031f3 100644
--- a/include/linux/security.h
+++ b/include/linux/security.h
@@ -35,7 +35,7 @@
 struct linux_binprm;
 struct cred;
 struct rlimit;
-struct siginfo;
+struct kernel_siginfo;
 struct sembuf;
 struct kern_ipc_perm;
 struct audit_context;
@@ -361,7 +361,7 @@ int security_task_setrlimit(struct task_struct *p, unsigned int resource,
 int security_task_setscheduler(struct task_struct *p);
 int security_task_getscheduler(struct task_struct *p);
 int security_task_movememory(struct task_struct *p);
-int security_task_kill(struct task_struct *p, struct siginfo *info,
+int security_task_kill(struct task_struct *p, struct kernel_siginfo *info,
                         int sig, const struct cred *cred);
 int security_task_prctl(int option, unsigned long arg2, unsigned long arg3,
                         unsigned long arg4, unsigned long arg5);
@@ -1020,7 +1020,7 @@ static inline int security_task_movememory(struct task_struct *p)
 }
 
 static inline int security_task_kill(struct task_struct *p,
-                                     struct siginfo *info, int sig,
+                                     struct kernel_siginfo *info, int sig,
                                      const struct cred *cred)
 {
         return 0;
diff --git a/include/linux/serial_core.h b/include/linux/serial_core.h
index 406edae44ca3..047fa67d039b 100644
--- a/include/linux/serial_core.h
+++ b/include/linux/serial_core.h
@@ -144,6 +144,8 @@ struct uart_port {
         void                    (*handle_break)(struct uart_port *);
         int                     (*rs485_config)(struct uart_port *,
                                                 struct serial_rs485 *rs485);
+        int                     (*iso7816_config)(struct uart_port *,
+                                                  struct serial_iso7816 *iso7816);
         unsigned int            irq;                    /* irq number */
         unsigned long           irqflags;               /* irq flags  */
         unsigned int            uartclk;                /* base uart clock */
@@ -260,6 +262,7 @@ struct uart_port {
         struct attribute_group  *attr_group;            /* port specific attributes */
         const struct attribute_group **tty_groups;      /* all attributes (serial core use only) */
         struct serial_rs485     rs485;
+        struct serial_iso7816   iso7816;
         void                    *private_data;          /* generic platform data pointer */
 };
 
diff --git a/include/linux/serial_sci.h b/include/linux/serial_sci.h
index c0e795d95477..1c89611e0e06 100644
--- a/include/linux/serial_sci.h
+++ b/include/linux/serial_sci.h
@@ -36,6 +36,7 @@ enum {
         SCIx_SH4_SCIF_FIFODATA_REGTYPE,
         SCIx_SH7705_SCIF_REGTYPE,
         SCIx_HSCIF_REGTYPE,
+        SCIx_RZ_SCIFA_REGTYPE,
 
         SCIx_NR_REGTYPES,
 };
diff --git a/include/linux/signal.h b/include/linux/signal.h
index 3d4cd5db30a9..200ed96a05af 100644
--- a/include/linux/signal.h
+++ b/include/linux/signal.h
@@ -11,17 +11,21 @@ struct task_struct;
 /* for sysctl */
 extern int print_fatal_signals;
 
-static inline void copy_siginfo(struct siginfo *to, const struct siginfo *from)
+static inline void copy_siginfo(kernel_siginfo_t *to,
+                                const kernel_siginfo_t *from)
 {
         memcpy(to, from, sizeof(*to));
 }
 
-static inline void clear_siginfo(struct siginfo *info)
+static inline void clear_siginfo(kernel_siginfo_t *info)
 {
         memset(info, 0, sizeof(*info));
 }
 
-int copy_siginfo_to_user(struct siginfo __user *to, const struct siginfo *from);
+#define SI_EXPANSION_SIZE (sizeof(struct siginfo) - sizeof(struct kernel_siginfo))
+
+int copy_siginfo_to_user(siginfo_t __user *to, const kernel_siginfo_t *from);
+int copy_siginfo_from_user(kernel_siginfo_t *to, const siginfo_t __user *from);
 
 enum siginfo_layout {
         SIL_KILL,
@@ -36,7 +40,7 @@ enum siginfo_layout {
         SIL_SYS,
 };
 
-enum siginfo_layout siginfo_layout(int sig, int si_code);
+enum siginfo_layout siginfo_layout(unsigned sig, int si_code);
 
 /*
  * Define some primitives to manipulate sigset_t.
@@ -257,11 +261,11 @@ struct pt_regs;
 enum pid_type;
 
 extern int next_signal(struct sigpending *pending, sigset_t *mask);
-extern int do_send_sig_info(int sig, struct siginfo *info,
+extern int do_send_sig_info(int sig, struct kernel_siginfo *info,
                                 struct task_struct *p, enum pid_type type);
-extern int group_send_sig_info(int sig, struct siginfo *info,
+extern int group_send_sig_info(int sig, struct kernel_siginfo *info,
                                struct task_struct *p, enum pid_type type);
-extern int __group_send_sig_info(int, struct siginfo *, struct task_struct *);
+extern int __group_send_sig_info(int, struct kernel_siginfo *, struct task_struct *);
 extern int sigprocmask(int, sigset_t *, sigset_t *);
 extern void set_current_blocked(sigset_t *);
 extern void __set_current_blocked(const sigset_t *);
diff --git a/include/linux/signal_types.h b/include/linux/signal_types.h
index 222ae696000b..f8a90ae9c6ec 100644
--- a/include/linux/signal_types.h
+++ b/include/linux/signal_types.h
@@ -9,6 +9,10 @@
 #include <linux/list.h>
 #include <uapi/linux/signal.h>
 
+typedef struct kernel_siginfo {
+        __SIGINFO;
+} kernel_siginfo_t;
+
 /*
  * Real Time signals may be queued.
  */
@@ -16,7 +20,7 @@
 struct sigqueue {
         struct list_head list;
         int flags;
-        siginfo_t info;
+        kernel_siginfo_t info;
         struct user_struct *user;
 };
 
@@ -60,7 +64,7 @@ struct old_sigaction {
 
 struct ksignal {
         struct k_sigaction ka;
-        siginfo_t info;
+        kernel_siginfo_t info;
         int sig;
 };
 
diff --git a/include/linux/skbuff.h b/include/linux/skbuff.h
index 17a13e4785fc..0ba687454267 100644
--- a/include/linux/skbuff.h
+++ b/include/linux/skbuff.h
@@ -243,6 +243,8 @@ struct scatterlist;
 struct pipe_inode_info;
 struct iov_iter;
 struct napi_struct;
+struct bpf_prog;
+union bpf_attr;
 
 #if defined(CONFIG_NF_CONNTRACK) || defined(CONFIG_NF_CONNTRACK_MODULE)
 struct nf_conntrack {
@@ -689,7 +691,7 @@ struct sk_buff {
 
         union {
                 ktime_t         tstamp;
-                u64             skb_mstamp;
+                u64             skb_mstamp_ns; /* earliest departure time */
         };
         /*
          * This is the control buffer. It is free to use for every
@@ -1080,11 +1082,6 @@ static inline int skb_pad(struct sk_buff *skb, int pad)
 }
 #define dev_kfree_skb(a)        consume_skb(a)
 
-int skb_append_datato_frags(struct sock *sk, struct sk_buff *skb,
-                            int getfrag(void *from, char *to, int offset,
-                                        int len, int odd, struct sk_buff *skb),
-                            void *from, int length);
-
 int skb_append_pagefrags(struct sk_buff *skb, struct page *page,
                          int offset, size_t size);
 
@@ -1192,6 +1189,24 @@ void skb_flow_dissector_init(struct flow_dissector *flow_dissector,
                              const struct flow_dissector_key *key,
                              unsigned int key_count);
 
+#ifdef CONFIG_NET
+int skb_flow_dissector_bpf_prog_attach(const union bpf_attr *attr,
+                                       struct bpf_prog *prog);
+
+int skb_flow_dissector_bpf_prog_detach(const union bpf_attr *attr);
+#else
+static inline int skb_flow_dissector_bpf_prog_attach(const union bpf_attr *attr,
+                                                     struct bpf_prog *prog)
+{
+        return -EOPNOTSUPP;
+}
+
+static inline int skb_flow_dissector_bpf_prog_detach(const union bpf_attr *attr)
+{
+        return -EOPNOTSUPP;
+}
+#endif
+
 bool __skb_flow_dissect(const struct sk_buff *skb,
                         struct flow_dissector *flow_dissector,
                         void *target_container,
@@ -1339,6 +1354,17 @@ static inline void skb_zcopy_abort(struct sk_buff *skb)
         }
 }
 
+static inline void skb_mark_not_on_list(struct sk_buff *skb)
+{
+        skb->next = NULL;
+}
+
+static inline void skb_list_del_init(struct sk_buff *skb)
+{
+        __list_del_entry(&skb->list);
+        skb_mark_not_on_list(skb);
+}
+
 /**
  *      skb_queue_empty - check if a queue is empty
  *      @list: queue head
@@ -1593,6 +1619,17 @@ static inline struct sk_buff *skb_peek(const struct sk_buff_head *list_)
 }
 
 /**
+ *      __skb_peek - peek at the head of a non-empty &sk_buff_head
+ *      @list_: list to peek at
+ *
+ *      Like skb_peek(), but the caller knows that the list is not empty.
+ */
+static inline struct sk_buff *__skb_peek(const struct sk_buff_head *list_)
+{
+        return list_->next;
+}
+
+/**
  *      skb_peek_next - peek skb following the given one from a queue
  *      @skb: skb to start from
  *      @list_: list to peek at
@@ -3468,13 +3505,19 @@ static inline bool __skb_metadata_differs(const struct sk_buff *skb_a,
 #define __it(x, op) (x -= sizeof(u##op))
 #define __it_diff(a, b, op) (*(u##op *)__it(a, op)) ^ (*(u##op *)__it(b, op))
         case 32: diffs |= __it_diff(a, b, 64);
+                 /* fall through */
         case 24: diffs |= __it_diff(a, b, 64);
+                 /* fall through */
         case 16: diffs |= __it_diff(a, b, 64);
+                 /* fall through */
         case  8: diffs |= __it_diff(a, b, 64);
                 break;
         case 28: diffs |= __it_diff(a, b, 64);
+                 /* fall through */
         case 20: diffs |= __it_diff(a, b, 64);
+                 /* fall through */
         case 12: diffs |= __it_diff(a, b, 64);
+                 /* fall through */
         case  4: diffs |= __it_diff(a, b, 32);
                 break;
         }
diff --git a/include/linux/skmsg.h b/include/linux/skmsg.h
new file mode 100644
index 000000000000..2a11e9d91dfa
--- /dev/null
+++ b/include/linux/skmsg.h
@@ -0,0 +1,434 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/* Copyright (c) 2017 - 2018 Covalent IO, Inc. http://covalent.io */
+
+#ifndef _LINUX_SKMSG_H
+#define _LINUX_SKMSG_H
+
+#include <linux/bpf.h>
+#include <linux/filter.h>
+#include <linux/scatterlist.h>
+#include <linux/skbuff.h>
+
+#include <net/sock.h>
+#include <net/tcp.h>
+#include <net/strparser.h>
+
+#define MAX_MSG_FRAGS                   MAX_SKB_FRAGS
+
+enum __sk_action {
+        __SK_DROP = 0,
+        __SK_PASS,
+        __SK_REDIRECT,
+        __SK_NONE,
+};
+
+struct sk_msg_sg {
+        u32                             start;
+        u32                             curr;
+        u32                             end;
+        u32                             size;
+        u32                             copybreak;
+        bool                            copy[MAX_MSG_FRAGS];
+        /* The extra element is used for chaining the front and sections when
+         * the list becomes partitioned (e.g. end < start). The crypto APIs
+         * require the chaining.
+         */
+        struct scatterlist              data[MAX_MSG_FRAGS + 1];
+};
+
+struct sk_msg {
+        struct sk_msg_sg                sg;
+        void                            *data;
+        void                            *data_end;
+        u32                             apply_bytes;
+        u32                             cork_bytes;
+        u32                             flags;
+        struct sk_buff                  *skb;
+        struct sock                     *sk_redir;
+        struct sock                     *sk;
+        struct list_head                list;
+};
+
+struct sk_psock_progs {
+        struct bpf_prog                 *msg_parser;
+        struct bpf_prog                 *skb_parser;
+        struct bpf_prog                 *skb_verdict;
+};
+
+enum sk_psock_state_bits {
+        SK_PSOCK_TX_ENABLED,
+};
+
+struct sk_psock_link {
+        struct list_head                list;
+        struct bpf_map                  *map;
+        void                            *link_raw;
+};
+
+struct sk_psock_parser {
+        struct strparser                strp;
+        bool                            enabled;
+        void (*saved_data_ready)(struct sock *sk);
+};
+
+struct sk_psock_work_state {
+        struct sk_buff                  *skb;
+        u32                             len;
+        u32                             off;
+};
+
+struct sk_psock {
+        struct sock                     *sk;
+        struct sock                     *sk_redir;
+        u32                             apply_bytes;
+        u32                             cork_bytes;
+        u32                             eval;
+        struct sk_msg                   *cork;
+        struct sk_psock_progs           progs;
+        struct sk_psock_parser          parser;
+        struct sk_buff_head             ingress_skb;
+        struct list_head                ingress_msg;
+        unsigned long                   state;
+        struct list_head                link;
+        spinlock_t                      link_lock;
+        refcount_t                      refcnt;
+        void (*saved_unhash)(struct sock *sk);
+        void (*saved_close)(struct sock *sk, long timeout);
+        void (*saved_write_space)(struct sock *sk);
+        struct proto                    *sk_proto;
+        struct sk_psock_work_state      work_state;
+        struct work_struct              work;
+        union {
+                struct rcu_head         rcu;
+                struct work_struct      gc;
+        };
+};
+
+int sk_msg_alloc(struct sock *sk, struct sk_msg *msg, int len,
+                 int elem_first_coalesce);
+int sk_msg_clone(struct sock *sk, struct sk_msg *dst, struct sk_msg *src,
+                 u32 off, u32 len);
+void sk_msg_trim(struct sock *sk, struct sk_msg *msg, int len);
+int sk_msg_free(struct sock *sk, struct sk_msg *msg);
+int sk_msg_free_nocharge(struct sock *sk, struct sk_msg *msg);
+void sk_msg_free_partial(struct sock *sk, struct sk_msg *msg, u32 bytes);
+void sk_msg_free_partial_nocharge(struct sock *sk, struct sk_msg *msg,
+                                  u32 bytes);
+
+void sk_msg_return(struct sock *sk, struct sk_msg *msg, int bytes);
+void sk_msg_return_zero(struct sock *sk, struct sk_msg *msg, int bytes);
+
+int sk_msg_zerocopy_from_iter(struct sock *sk, struct iov_iter *from,
+                              struct sk_msg *msg, u32 bytes);
+int sk_msg_memcopy_from_iter(struct sock *sk, struct iov_iter *from,
+                             struct sk_msg *msg, u32 bytes);
+
+static inline void sk_msg_check_to_free(struct sk_msg *msg, u32 i, u32 bytes)
+{
+        WARN_ON(i == msg->sg.end && bytes);
+}
+
+static inline void sk_msg_apply_bytes(struct sk_psock *psock, u32 bytes)
+{
+        if (psock->apply_bytes) {
+                if (psock->apply_bytes < bytes)
+                        psock->apply_bytes = 0;
+                else
+                        psock->apply_bytes -= bytes;
+        }
+}
+
+#define sk_msg_iter_var_prev(var)                       \
+        do {                                            \
+                if (var == 0)                           \
+                        var = MAX_MSG_FRAGS - 1;        \
+                else                                    \
+                        var--;                          \
+        } while (0)
+
+#define sk_msg_iter_var_next(var)                       \
+        do {                                            \
+                var++;                                  \
+                if (var == MAX_MSG_FRAGS)               \
+                        var = 0;                        \
+        } while (0)
+
+#define sk_msg_iter_prev(msg, which)                    \
+        sk_msg_iter_var_prev(msg->sg.which)
+
+#define sk_msg_iter_next(msg, which)                    \
+        sk_msg_iter_var_next(msg->sg.which)
+
+static inline void sk_msg_clear_meta(struct sk_msg *msg)
+{
+        memset(&msg->sg, 0, offsetofend(struct sk_msg_sg, copy));
+}
+
+static inline void sk_msg_init(struct sk_msg *msg)
+{
+        BUILD_BUG_ON(ARRAY_SIZE(msg->sg.data) - 1 != MAX_MSG_FRAGS);
+        memset(msg, 0, sizeof(*msg));
+        sg_init_marker(msg->sg.data, MAX_MSG_FRAGS);
+}
+
+static inline void sk_msg_xfer(struct sk_msg *dst, struct sk_msg *src,
+                               int which, u32 size)
+{
+        dst->sg.data[which] = src->sg.data[which];
+        dst->sg.data[which].length  = size;
+        dst->sg.size               += size;
+        src->sg.data[which].length -= size;
+        src->sg.data[which].offset += size;
+}
+
+static inline void sk_msg_xfer_full(struct sk_msg *dst, struct sk_msg *src)
+{
+        memcpy(dst, src, sizeof(*src));
+        sk_msg_init(src);
+}
+
+static inline bool sk_msg_full(const struct sk_msg *msg)
+{
+        return (msg->sg.end == msg->sg.start) && msg->sg.size;
+}
+
+static inline u32 sk_msg_elem_used(const struct sk_msg *msg)
+{
+        if (sk_msg_full(msg))
+                return MAX_MSG_FRAGS;
+
+        return msg->sg.end >= msg->sg.start ?
+                msg->sg.end - msg->sg.start :
+                msg->sg.end + (MAX_MSG_FRAGS - msg->sg.start);
+}
+
+static inline struct scatterlist *sk_msg_elem(struct sk_msg *msg, int which)
+{
+        return &msg->sg.data[which];
+}
+
+static inline struct scatterlist sk_msg_elem_cpy(struct sk_msg *msg, int which)
+{
+        return msg->sg.data[which];
+}
+
+static inline struct page *sk_msg_page(struct sk_msg *msg, int which)
+{
+        return sg_page(sk_msg_elem(msg, which));
+}
+
+static inline bool sk_msg_to_ingress(const struct sk_msg *msg)
+{
+        return msg->flags & BPF_F_INGRESS;
+}
+
+static inline void sk_msg_compute_data_pointers(struct sk_msg *msg)
+{
+        struct scatterlist *sge = sk_msg_elem(msg, msg->sg.start);
+
+        if (msg->sg.copy[msg->sg.start]) {
+                msg->data = NULL;
+                msg->data_end = NULL;
+        } else {
+                msg->data = sg_virt(sge);
+                msg->data_end = msg->data + sge->length;
+        }
+}
+
+static inline void sk_msg_page_add(struct sk_msg *msg, struct page *page,
+                                   u32 len, u32 offset)
+{
+        struct scatterlist *sge;
+
+        get_page(page);
+        sge = sk_msg_elem(msg, msg->sg.end);
+        sg_set_page(sge, page, len, offset);
+        sg_unmark_end(sge);
+
+        msg->sg.copy[msg->sg.end] = true;
+        msg->sg.size += len;
+        sk_msg_iter_next(msg, end);
+}
+
+static inline void sk_msg_sg_copy(struct sk_msg *msg, u32 i, bool copy_state)
+{
+        do {
+                msg->sg.copy[i] = copy_state;
+                sk_msg_iter_var_next(i);
+                if (i == msg->sg.end)
+                        break;
+        } while (1);
+}
+
+static inline void sk_msg_sg_copy_set(struct sk_msg *msg, u32 start)
+{
+        sk_msg_sg_copy(msg, start, true);
+}
+
+static inline void sk_msg_sg_copy_clear(struct sk_msg *msg, u32 start)
+{
+        sk_msg_sg_copy(msg, start, false);
+}
+
+static inline struct sk_psock *sk_psock(const struct sock *sk)
+{
+        return rcu_dereference_sk_user_data(sk);
+}
+
+static inline void sk_psock_queue_msg(struct sk_psock *psock,
+                                      struct sk_msg *msg)
+{
+        list_add_tail(&msg->list, &psock->ingress_msg);
+}
+
+static inline bool sk_psock_queue_empty(const struct sk_psock *psock)
+{
+        return psock ? list_empty(&psock->ingress_msg) : true;
+}
+
+static inline void sk_psock_report_error(struct sk_psock *psock, int err)
+{
+        struct sock *sk = psock->sk;
+
+        sk->sk_err = err;
+        sk->sk_error_report(sk);
+}
+
+struct sk_psock *sk_psock_init(struct sock *sk, int node);
+
+int sk_psock_init_strp(struct sock *sk, struct sk_psock *psock);
+void sk_psock_start_strp(struct sock *sk, struct sk_psock *psock);
+void sk_psock_stop_strp(struct sock *sk, struct sk_psock *psock);
+
+int sk_psock_msg_verdict(struct sock *sk, struct sk_psock *psock,
+                         struct sk_msg *msg);
+
+static inline struct sk_psock_link *sk_psock_init_link(void)
+{
+        return kzalloc(sizeof(struct sk_psock_link),
+                       GFP_ATOMIC | __GFP_NOWARN);
+}
+
+static inline void sk_psock_free_link(struct sk_psock_link *link)
+{
+        kfree(link);
+}
+
+struct sk_psock_link *sk_psock_link_pop(struct sk_psock *psock);
+#if defined(CONFIG_BPF_STREAM_PARSER)
+void sk_psock_unlink(struct sock *sk, struct sk_psock_link *link);
+#else
+static inline void sk_psock_unlink(struct sock *sk,
+                                   struct sk_psock_link *link)
+{
+}
+#endif
+
+void __sk_psock_purge_ingress_msg(struct sk_psock *psock);
+
+static inline void sk_psock_cork_free(struct sk_psock *psock)
+{
+        if (psock->cork) {
+                sk_msg_free(psock->sk, psock->cork);
+                kfree(psock->cork);
+                psock->cork = NULL;
+        }
+}
+
+static inline void sk_psock_update_proto(struct sock *sk,
+                                         struct sk_psock *psock,
+                                         struct proto *ops)
+{
+        psock->saved_unhash = sk->sk_prot->unhash;
+        psock->saved_close = sk->sk_prot->close;
+        psock->saved_write_space = sk->sk_write_space;
+
+        psock->sk_proto = sk->sk_prot;
+        sk->sk_prot = ops;
+}
+
+static inline void sk_psock_restore_proto(struct sock *sk,
+                                          struct sk_psock *psock)
+{
+        if (psock->sk_proto) {
+                sk->sk_prot = psock->sk_proto;
+                psock->sk_proto = NULL;
+        }
+}
+
+static inline void sk_psock_set_state(struct sk_psock *psock,
+                                      enum sk_psock_state_bits bit)
+{
+        set_bit(bit, &psock->state);
+}
+
+static inline void sk_psock_clear_state(struct sk_psock *psock,
+                                        enum sk_psock_state_bits bit)
+{
+        clear_bit(bit, &psock->state);
+}
+
+static inline bool sk_psock_test_state(const struct sk_psock *psock,
+                                       enum sk_psock_state_bits bit)
+{
+        return test_bit(bit, &psock->state);
+}
+
+static inline struct sk_psock *sk_psock_get_checked(struct sock *sk)
+{
+        struct sk_psock *psock;
+
+        rcu_read_lock();
+        psock = sk_psock(sk);
+        if (psock) {
+                if (sk->sk_prot->recvmsg != tcp_bpf_recvmsg) {
+                        psock = ERR_PTR(-EBUSY);
+                        goto out;
+                }
+
+                if (!refcount_inc_not_zero(&psock->refcnt))
+                        psock = ERR_PTR(-EBUSY);
+        }
+out:
+        rcu_read_unlock();
+        return psock;
+}
+
+static inline struct sk_psock *sk_psock_get(struct sock *sk)
+{
+        struct sk_psock *psock;
+
+        rcu_read_lock();
+        psock = sk_psock(sk);
+        if (psock && !refcount_inc_not_zero(&psock->refcnt))
+                psock = NULL;
+        rcu_read_unlock();
+        return psock;
+}
+
+void sk_psock_stop(struct sock *sk, struct sk_psock *psock);
+void sk_psock_destroy(struct rcu_head *rcu);
+void sk_psock_drop(struct sock *sk, struct sk_psock *psock);
+
+static inline void sk_psock_put(struct sock *sk, struct sk_psock *psock)
+{
+        if (refcount_dec_and_test(&psock->refcnt))
+                sk_psock_drop(sk, psock);
+}
+
+static inline void psock_set_prog(struct bpf_prog **pprog,
+                                  struct bpf_prog *prog)
+{
+        prog = xchg(pprog, prog);
+        if (prog)
+                bpf_prog_put(prog);
+}
+
+static inline void psock_progs_drop(struct sk_psock_progs *progs)
+{
+        psock_set_prog(&progs->msg_parser, NULL);
+        psock_set_prog(&progs->skb_parser, NULL);
+        psock_set_prog(&progs->skb_verdict, NULL);
+}
+
+#endif /* _LINUX_SKMSG_H */
diff --git a/include/linux/slab.h b/include/linux/slab.h
index ed9cbddeb4a6..918f374e7156 100644
--- a/include/linux/slab.h
+++ b/include/linux/slab.h
@@ -295,12 +295,43 @@ static inline void __check_heap_object(const void *ptr, unsigned long n,
 #define SLAB_OBJ_MIN_SIZE      (KMALLOC_MIN_SIZE < 16 ? \
                                (KMALLOC_MIN_SIZE) : 16)
 
+/*
+ * Whenever changing this, take care of that kmalloc_type() and
+ * create_kmalloc_caches() still work as intended.
+ */
+enum kmalloc_cache_type {
+        KMALLOC_NORMAL = 0,
+        KMALLOC_RECLAIM,
+#ifdef CONFIG_ZONE_DMA
+        KMALLOC_DMA,
+#endif
+        NR_KMALLOC_TYPES
+};
+
 #ifndef CONFIG_SLOB
-extern struct kmem_cache *kmalloc_caches[KMALLOC_SHIFT_HIGH + 1];
+extern struct kmem_cache *
+kmalloc_caches[NR_KMALLOC_TYPES][KMALLOC_SHIFT_HIGH + 1];
+
+static __always_inline enum kmalloc_cache_type kmalloc_type(gfp_t flags)
+{
+        int is_dma = 0;
+        int type_dma = 0;
+        int is_reclaimable;
+
 #ifdef CONFIG_ZONE_DMA
-extern struct kmem_cache *kmalloc_dma_caches[KMALLOC_SHIFT_HIGH + 1];
+        is_dma = !!(flags & __GFP_DMA);
+        type_dma = is_dma * KMALLOC_DMA;
 #endif
 
+        is_reclaimable = !!(flags & __GFP_RECLAIMABLE);
+
+        /*
+         * If an allocation is both __GFP_DMA and __GFP_RECLAIMABLE, return
+         * KMALLOC_DMA and effectively ignore __GFP_RECLAIMABLE
+         */
+        return type_dma + (is_reclaimable & !is_dma) * KMALLOC_RECLAIM;
+}
+
 /*
  * Figure out which kmalloc slab an allocation of a certain size
  * belongs to.
@@ -501,18 +532,20 @@ static __always_inline void *kmalloc_large(size_t size, gfp_t flags)
 static __always_inline void *kmalloc(size_t size, gfp_t flags)
 {
         if (__builtin_constant_p(size)) {
+#ifndef CONFIG_SLOB
+                unsigned int index;
+#endif
                 if (size > KMALLOC_MAX_CACHE_SIZE)
                         return kmalloc_large(size, flags);
 #ifndef CONFIG_SLOB
-                if (!(flags & GFP_DMA)) {
-                        unsigned int index = kmalloc_index(size);
+                index = kmalloc_index(size);
 
-                        if (!index)
-                                return ZERO_SIZE_PTR;
+                if (!index)
+                        return ZERO_SIZE_PTR;
 
-                        return kmem_cache_alloc_trace(kmalloc_caches[index],
-                                        flags, size);
-                }
+                return kmem_cache_alloc_trace(
+                                kmalloc_caches[kmalloc_type(flags)][index],
+                                flags, size);
 #endif
         }
         return __kmalloc(size, flags);
@@ -542,13 +575,14 @@ static __always_inline void *kmalloc_node(size_t size, gfp_t flags, int node)
 {
 #ifndef CONFIG_SLOB
         if (__builtin_constant_p(size) &&
-                size <= KMALLOC_MAX_CACHE_SIZE && !(flags & GFP_DMA)) {
+                size <= KMALLOC_MAX_CACHE_SIZE) {
                 unsigned int i = kmalloc_index(size);
 
                 if (!i)
                         return ZERO_SIZE_PTR;
 
-                return kmem_cache_alloc_node_trace(kmalloc_caches[i],
+                return kmem_cache_alloc_node_trace(
+                                kmalloc_caches[kmalloc_type(flags)][i],
                                                 flags, node, size);
         }
 #endif
diff --git a/include/linux/smp.h b/include/linux/smp.h
index 9fb239e12b82..a56f08ff3097 100644
--- a/include/linux/smp.h
+++ b/include/linux/smp.h
@@ -53,6 +53,10 @@ void on_each_cpu_cond(bool (*cond_func)(int cpu, void *info),
                 smp_call_func_t func, void *info, bool wait,
                 gfp_t gfp_flags);
 
+void on_each_cpu_cond_mask(bool (*cond_func)(int cpu, void *info),
+                smp_call_func_t func, void *info, bool wait,
+                gfp_t gfp_flags, const struct cpumask *mask);
+
 int smp_call_function_single_async(int cpu, call_single_data_t *csd);
 
 #ifdef CONFIG_SMP
diff --git a/include/linux/socket.h b/include/linux/socket.h
index 7ed4713d5337..8b571e9b9f76 100644
--- a/include/linux/socket.h
+++ b/include/linux/socket.h
@@ -348,7 +348,7 @@ struct ucred {
 extern int move_addr_to_kernel(void __user *uaddr, int ulen, struct sockaddr_storage *kaddr);
 extern int put_cmsg(struct msghdr*, int level, int type, int len, void *data);
 
-struct timespec;
+struct timespec64;
 
 /* The __sys_...msg variants allow MSG_CMSG_COMPAT iff
  * forbid_cmsg_compat==false
@@ -358,7 +358,7 @@ extern long __sys_recvmsg(int fd, struct user_msghdr __user *msg,
 extern long __sys_sendmsg(int fd, struct user_msghdr __user *msg,
                           unsigned int flags, bool forbid_cmsg_compat);
 extern int __sys_recvmmsg(int fd, struct mmsghdr __user *mmsg, unsigned int vlen,
-                          unsigned int flags, struct timespec *timeout);
+                          unsigned int flags, struct timespec64 *timeout);
 extern int __sys_sendmmsg(int fd, struct mmsghdr __user *mmsg,
                           unsigned int vlen, unsigned int flags,
                           bool forbid_cmsg_compat);
diff --git a/include/linux/soundwire/sdw.h b/include/linux/soundwire/sdw.h
index 962971e6a9c7..df313913e856 100644
--- a/include/linux/soundwire/sdw.h
+++ b/include/linux/soundwire/sdw.h
@@ -678,6 +678,9 @@ struct sdw_master_ops {
  * @defer_msg: Defer message
  * @clk_stop_timeout: Clock stop timeout computed
  * @bank_switch_timeout: Bank switch timeout computed
+ * @multi_link: Store bus property that indicates if multi links
+ * are supported. This flag is populated by drivers after reading
+ * appropriate firmware (ACPI/DT).
  */
 struct sdw_bus {
         struct device *dev;
@@ -694,6 +697,7 @@ struct sdw_bus {
         struct sdw_defer defer_msg;
         unsigned int clk_stop_timeout;
         u32 bank_switch_timeout;
+        bool multi_link;
 };
 
 int sdw_add_bus_master(struct sdw_bus *bus);
@@ -768,14 +772,18 @@ struct sdw_stream_params {
  * @params: Stream parameters
  * @state: Current state of the stream
  * @type: Stream type PCM or PDM
- * @m_rt: Master runtime
+ * @master_list: List of Master runtime(s) in this stream.
+ * master_list can contain only one m_rt per Master instance
+ * for a stream
+ * @m_rt_count: Count of Master runtime(s) in this stream
  */
 struct sdw_stream_runtime {
         char *name;
         struct sdw_stream_params params;
         enum sdw_stream_state state;
         enum sdw_stream_type type;
-        struct sdw_master_runtime *m_rt;
+        struct list_head master_list;
+        int m_rt_count;
 };
 
 struct sdw_stream_runtime *sdw_alloc_stream(char *stream_name);
diff --git a/include/linux/spi/spi-mem.h b/include/linux/spi/spi-mem.h
index b2bd4b4127c4..69ee30456864 100644
--- a/include/linux/spi/spi-mem.h
+++ b/include/linux/spi/spi-mem.h
@@ -81,8 +81,10 @@ enum spi_mem_data_dir {
  * @dummy.buswidth: number of IO lanes used to transmit the dummy bytes
  * @data.buswidth: number of IO lanes used to send/receive the data
  * @data.dir: direction of the transfer
- * @data.buf.in: input buffer
- * @data.buf.out: output buffer
+ * @data.nbytes: number of data bytes to send/receive. Can be zero if the
+ *               operation does not involve transferring data
+ * @data.buf.in: input buffer (must be DMA-able)
+ * @data.buf.out: output buffer (must be DMA-able)
  */
 struct spi_mem_op {
         struct {
@@ -105,7 +107,6 @@ struct spi_mem_op {
                 u8 buswidth;
                 enum spi_mem_data_dir dir;
                 unsigned int nbytes;
-                /* buf.{in,out} must be DMA-able. */
                 union {
                         void *in;
                         const void *out;
diff --git a/include/linux/spi/spi.h b/include/linux/spi/spi.h
index a64235e05321..6be77fa5ab90 100644
--- a/include/linux/spi/spi.h
+++ b/include/linux/spi/spi.h
@@ -1,15 +1,6 @@
-/*
- * Copyright (C) 2005 David Brownell
+/* SPDX-License-Identifier: GPL-2.0-or-later
  *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
+ * Copyright (C) 2005 David Brownell
  */
 
 #ifndef __LINUX_SPI_H
@@ -163,10 +154,12 @@ struct spi_device {
 #define SPI_TX_QUAD     0x200                   /* transmit with 4 wires */
 #define SPI_RX_DUAL     0x400                   /* receive with 2 wires */
 #define SPI_RX_QUAD     0x800                   /* receive with 4 wires */
+#define SPI_CS_WORD     0x1000                  /* toggle cs after each word */
         int                     irq;
         void                    *controller_state;
         void                    *controller_data;
         char                    modalias[SPI_NAME_SIZE];
+        const char              *driver_override;
         int                     cs_gpio;        /* chip select gpio */
 
         /* the statistics */
@@ -177,7 +170,6 @@ struct spi_device {
          * the controller talks to each chip, like:
          *  - memory packing (12 bit samples into low bits, others zeroed)
          *  - priority
-         *  - drop chipselect after each word
          *  - chipselect delays
          *  - ...
          */
@@ -711,6 +703,8 @@ extern void spi_res_release(struct spi_controller *ctlr,
  * @delay_usecs: microseconds to delay after this transfer before
  *      (optionally) changing the chipselect status, then starting
  *      the next transfer or completing this @spi_message.
+ * @word_delay: clock cycles to inter word delay after each word size
+ *      (set by bits_per_word) transmission.
  * @transfer_list: transfers are sequenced through @spi_message.transfers
  * @tx_sg: Scatterlist for transmit, currently not for client use
  * @rx_sg: Scatterlist for receive, currently not for client use
@@ -793,6 +787,7 @@ struct spi_transfer {
         u8              bits_per_word;
         u16             delay_usecs;
         u32             speed_hz;
+        u16             word_delay;
 
         struct list_head transfer_list;
 };
@@ -1277,7 +1272,6 @@ spi_register_board_info(struct spi_board_info const *info, unsigned n)
         { return 0; }
 #endif
 
-
 /* If you're hotplugging an adapter with devices (parport, usb, etc)
  * use spi_new_device() to describe each device.  You can also call
  * spi_unregister_device() to start making that device vanish, but
@@ -1309,6 +1303,22 @@ spi_transfer_is_last(struct spi_controller *ctlr, struct spi_transfer *xfer)
         return list_is_last(&xfer->transfer_list, &ctlr->cur_msg->transfers);
 }
 
+/* OF support code */
+#if IS_ENABLED(CONFIG_OF)
+
+/* must call put_device() when done with returned spi_device device */
+extern struct spi_device *
+of_find_spi_device_by_node(struct device_node *node);
+
+#else
+
+static inline struct spi_device *
+of_find_spi_device_by_node(struct device_node *node)
+{
+        return NULL;
+}
+
+#endif /* IS_ENABLED(CONFIG_OF) */
 
 /* Compatibility layer */
 #define spi_master                      spi_controller
diff --git a/include/linux/srcutree.h b/include/linux/srcutree.h
index 745d4ca4dd50..0ae91b3a7406 100644
--- a/include/linux/srcutree.h
+++ b/include/linux/srcutree.h
@@ -105,12 +105,13 @@ struct srcu_struct {
 #define SRCU_STATE_SCAN2        2
 
 #define __SRCU_STRUCT_INIT(name, pcpu_name)                             \
-        {                                                               \
-                .sda = &pcpu_name,                                      \
-                .lock = __SPIN_LOCK_UNLOCKED(name.lock),                \
-                .srcu_gp_seq_needed = 0 - 1,                            \
-                __SRCU_DEP_MAP_INIT(name)                               \
-        }
+{                                                                       \
+        .sda = &pcpu_name,                                              \
+        .lock = __SPIN_LOCK_UNLOCKED(name.lock),                        \
+        .srcu_gp_seq_needed = -1UL,                                     \
+        .work = __DELAYED_WORK_INITIALIZER(name.work, NULL, 0),         \
+        __SRCU_DEP_MAP_INIT(name)                                       \
+}
 
 /*
  * Define and initialize a srcu struct at build time.
diff --git a/include/linux/start_kernel.h b/include/linux/start_kernel.h
index 4b268d86a784..8b369a41c03c 100644
--- a/include/linux/start_kernel.h
+++ b/include/linux/start_kernel.h
@@ -9,5 +9,7 @@
    up something else. */
 
 extern asmlinkage void __init start_kernel(void);
+extern void __init arch_call_rest_init(void);
+extern void __ref rest_init(void);
 
 #endif /* _LINUX_START_KERNEL_H */
diff --git a/include/linux/stmmac.h b/include/linux/stmmac.h
index c43e9a01b892..7ddfc65586b0 100644
--- a/include/linux/stmmac.h
+++ b/include/linux/stmmac.h
@@ -30,6 +30,7 @@
 
 #define MTL_MAX_RX_QUEUES       8
 #define MTL_MAX_TX_QUEUES       8
+#define STMMAC_CH_MAX           8
 
 #define STMMAC_RX_COE_NONE      0
 #define STMMAC_RX_COE_TYPE1     1
diff --git a/include/linux/string.h b/include/linux/string.h
index 4a5a0eb7df51..27d0482e5e05 100644
--- a/include/linux/string.h
+++ b/include/linux/string.h
@@ -131,6 +131,13 @@ static inline void *memset_p(void **p, void *v, __kernel_size_t n)
                 return memset64((uint64_t *)p, (uintptr_t)v, n);
 }
 
+extern void **__memcat_p(void **a, void **b);
+#define memcat_p(a, b) ({                                       \
+        BUILD_BUG_ON_MSG(!__same_type(*(a), *(b)),              \
+                         "type mismatch in memcat_p()");        \
+        (typeof(*a) *)__memcat_p((void **)(a), (void **)(b));   \
+})
+
 #ifndef __HAVE_ARCH_MEMCPY
 extern void * memcpy(void *,const void *,__kernel_size_t);
 #endif
diff --git a/include/linux/sunrpc/auth.h b/include/linux/sunrpc/auth.h
index 58a6765c1c5e..c4db9424b63b 100644
--- a/include/linux/sunrpc/auth.h
+++ b/include/linux/sunrpc/auth.h
@@ -67,7 +67,7 @@ struct rpc_cred {
         const struct rpc_credops *cr_ops;
         unsigned long           cr_expire;      /* when to gc */
         unsigned long           cr_flags;       /* various flags */
-        atomic_t                cr_count;       /* ref count */
+        refcount_t              cr_count;       /* ref count */
 
         kuid_t                  cr_uid;
 
@@ -100,7 +100,7 @@ struct rpc_auth {
                                                  * differ from the flavor in
                                                  * au_ops->au_flavor in gss
                                                  * case) */
-        atomic_t                au_count;       /* Reference counter */
+        refcount_t              au_count;       /* Reference counter */
 
         struct rpc_cred_cache * au_credcache;
         /* per-flavor data */
@@ -157,6 +157,7 @@ struct rpc_credops {
         int                     (*crkey_timeout)(struct rpc_cred *);
         bool                    (*crkey_to_expire)(struct rpc_cred *);
         char *                  (*crstringify_acceptor)(struct rpc_cred *);
+        bool                    (*crneed_reencode)(struct rpc_task *);
 };
 
 extern const struct rpc_authops authunix_ops;
@@ -192,6 +193,7 @@ __be32 *		rpcauth_marshcred(struct rpc_task *, __be32 *);
 __be32 *                rpcauth_checkverf(struct rpc_task *, __be32 *);
 int                     rpcauth_wrap_req(struct rpc_task *task, kxdreproc_t encode, void *rqstp, __be32 *data, void *obj);
 int                     rpcauth_unwrap_resp(struct rpc_task *task, kxdrdproc_t decode, void *rqstp, __be32 *data, void *obj);
+bool                    rpcauth_xmit_need_reencode(struct rpc_task *task);
 int                     rpcauth_refreshcred(struct rpc_task *);
 void                    rpcauth_invalcred(struct rpc_task *);
 int                     rpcauth_uptodatecred(struct rpc_task *);
@@ -204,11 +206,11 @@ bool			rpcauth_cred_key_to_expire(struct rpc_auth *, struct rpc_cred *);
 char *                  rpcauth_stringify_acceptor(struct rpc_cred *);
 
 static inline
-struct rpc_cred *       get_rpccred(struct rpc_cred *cred)
+struct rpc_cred *get_rpccred(struct rpc_cred *cred)
 {
-        if (cred != NULL)
-                atomic_inc(&cred->cr_count);
-        return cred;
+        if (cred != NULL && refcount_inc_not_zero(&cred->cr_count))
+                return cred;
+        return NULL;
 }
 
 /**
@@ -224,9 +226,7 @@ struct rpc_cred *	get_rpccred(struct rpc_cred *cred)
 static inline struct rpc_cred *
 get_rpccred_rcu(struct rpc_cred *cred)
 {
-        if (atomic_inc_not_zero(&cred->cr_count))
-                return cred;
-        return NULL;
+        return get_rpccred(cred);
 }
 
 #endif /* __KERNEL__ */
diff --git a/include/linux/sunrpc/auth_gss.h b/include/linux/sunrpc/auth_gss.h
index 0c9eac351aab..30427b729070 100644
--- a/include/linux/sunrpc/auth_gss.h
+++ b/include/linux/sunrpc/auth_gss.h
@@ -70,6 +70,7 @@ struct gss_cl_ctx {
         refcount_t              count;
         enum rpc_gss_proc       gc_proc;
         u32                     gc_seq;
+        u32                     gc_seq_xmit;
         spinlock_t              gc_seq_lock;
         struct gss_ctx          *gc_gss_ctx;
         struct xdr_netobj       gc_wire_ctx;
diff --git a/include/linux/sunrpc/bc_xprt.h b/include/linux/sunrpc/bc_xprt.h
index 4397a4824c81..28721cf73ec3 100644
--- a/include/linux/sunrpc/bc_xprt.h
+++ b/include/linux/sunrpc/bc_xprt.h
@@ -34,6 +34,7 @@ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #ifdef CONFIG_SUNRPC_BACKCHANNEL
 struct rpc_rqst *xprt_lookup_bc_request(struct rpc_xprt *xprt, __be32 xid);
 void xprt_complete_bc_request(struct rpc_rqst *req, uint32_t copied);
+void xprt_init_bc_request(struct rpc_rqst *req, struct rpc_task *task);
 void xprt_free_bc_request(struct rpc_rqst *req);
 int xprt_setup_backchannel(struct rpc_xprt *, unsigned int min_reqs);
 void xprt_destroy_backchannel(struct rpc_xprt *, unsigned int max_reqs);
diff --git a/include/linux/sunrpc/gss_krb5.h b/include/linux/sunrpc/gss_krb5.h
index 7df625d41e35..131424cefc6a 100644
--- a/include/linux/sunrpc/gss_krb5.h
+++ b/include/linux/sunrpc/gss_krb5.h
@@ -71,10 +71,10 @@ struct gss_krb5_enctype {
         const u32               keyed_cksum;    /* is it a keyed cksum? */
         const u32               keybytes;       /* raw key len, in bytes */
         const u32               keylength;      /* final key len, in bytes */
-        u32 (*encrypt) (struct crypto_skcipher *tfm,
+        u32 (*encrypt) (struct crypto_sync_skcipher *tfm,
                         void *iv, void *in, void *out,
                         int length);            /* encryption function */
-        u32 (*decrypt) (struct crypto_skcipher *tfm,
+        u32 (*decrypt) (struct crypto_sync_skcipher *tfm,
                         void *iv, void *in, void *out,
                         int length);            /* decryption function */
         u32 (*mk_key) (const struct gss_krb5_enctype *gk5e,
@@ -98,12 +98,12 @@ struct krb5_ctx {
         u32                     enctype;
         u32                     flags;
         const struct gss_krb5_enctype *gk5e; /* enctype-specific info */
-        struct crypto_skcipher  *enc;
-        struct crypto_skcipher  *seq;
-        struct crypto_skcipher *acceptor_enc;
-        struct crypto_skcipher *initiator_enc;
-        struct crypto_skcipher *acceptor_enc_aux;
-        struct crypto_skcipher *initiator_enc_aux;
+        struct crypto_sync_skcipher *enc;
+        struct crypto_sync_skcipher *seq;
+        struct crypto_sync_skcipher *acceptor_enc;
+        struct crypto_sync_skcipher *initiator_enc;
+        struct crypto_sync_skcipher *acceptor_enc_aux;
+        struct crypto_sync_skcipher *initiator_enc_aux;
         u8                      Ksess[GSS_KRB5_MAX_KEYLEN]; /* session key */
         u8                      cksum[GSS_KRB5_MAX_KEYLEN];
         s32                     endtime;
@@ -118,7 +118,8 @@ struct krb5_ctx {
         u8                      acceptor_integ[GSS_KRB5_MAX_KEYLEN];
 };
 
-extern spinlock_t krb5_seq_lock;
+extern u32 gss_seq_send_fetch_and_inc(struct krb5_ctx *ctx);
+extern u64 gss_seq_send64_fetch_and_inc(struct krb5_ctx *ctx);
 
 /* The length of the Kerberos GSS token header */
 #define GSS_KRB5_TOK_HDR_LEN    (16)
@@ -262,24 +263,24 @@ gss_unwrap_kerberos(struct gss_ctx *ctx_id, int offset,
 
 
 u32
-krb5_encrypt(struct crypto_skcipher *key,
+krb5_encrypt(struct crypto_sync_skcipher *key,
              void *iv, void *in, void *out, int length);
 
 u32
-krb5_decrypt(struct crypto_skcipher *key,
+krb5_decrypt(struct crypto_sync_skcipher *key,
              void *iv, void *in, void *out, int length); 
 
 int
-gss_encrypt_xdr_buf(struct crypto_skcipher *tfm, struct xdr_buf *outbuf,
+gss_encrypt_xdr_buf(struct crypto_sync_skcipher *tfm, struct xdr_buf *outbuf,
                     int offset, struct page **pages);
 
 int
-gss_decrypt_xdr_buf(struct crypto_skcipher *tfm, struct xdr_buf *inbuf,
+gss_decrypt_xdr_buf(struct crypto_sync_skcipher *tfm, struct xdr_buf *inbuf,
                     int offset);
 
 s32
 krb5_make_seq_num(struct krb5_ctx *kctx,
-                struct crypto_skcipher *key,
+                struct crypto_sync_skcipher *key,
                 int direction,
                 u32 seqnum, unsigned char *cksum, unsigned char *buf);
 
@@ -320,12 +321,12 @@ gss_krb5_aes_decrypt(struct krb5_ctx *kctx, u32 offset,
 
 int
 krb5_rc4_setup_seq_key(struct krb5_ctx *kctx,
-                       struct crypto_skcipher *cipher,
+                       struct crypto_sync_skcipher *cipher,
                        unsigned char *cksum);
 
 int
 krb5_rc4_setup_enc_key(struct krb5_ctx *kctx,
-                       struct crypto_skcipher *cipher,
+                       struct crypto_sync_skcipher *cipher,
                        s32 seqnum);
 void
 gss_krb5_make_confounder(char *p, u32 conflen);
diff --git a/include/linux/sunrpc/sched.h b/include/linux/sunrpc/sched.h
index 592653becd91..7b540c066594 100644
--- a/include/linux/sunrpc/sched.h
+++ b/include/linux/sunrpc/sched.h
@@ -140,8 +140,9 @@ struct rpc_task_setup {
 #define RPC_TASK_RUNNING        0
 #define RPC_TASK_QUEUED         1
 #define RPC_TASK_ACTIVE         2
-#define RPC_TASK_MSG_RECV       3
-#define RPC_TASK_MSG_RECV_WAIT  4
+#define RPC_TASK_NEED_XMIT      3
+#define RPC_TASK_NEED_RECV      4
+#define RPC_TASK_MSG_PIN_WAIT   5
 
 #define RPC_IS_RUNNING(t)       test_bit(RPC_TASK_RUNNING, &(t)->tk_runstate)
 #define rpc_set_running(t)      set_bit(RPC_TASK_RUNNING, &(t)->tk_runstate)
@@ -188,7 +189,6 @@ struct rpc_timer {
 struct rpc_wait_queue {
         spinlock_t              lock;
         struct list_head        tasks[RPC_NR_PRIORITY]; /* task queue for each priority level */
-        pid_t                   owner;                  /* process id of last task serviced */
         unsigned char           maxpriority;            /* maximum priority (0 if queue is not a priority queue) */
         unsigned char           priority;               /* current priority */
         unsigned char           nr;                     /* # tasks remaining for cookie */
@@ -204,7 +204,6 @@ struct rpc_wait_queue {
  * from a single cookie.  The aim is to improve
  * performance of NFS operations such as read/write.
  */
-#define RPC_BATCH_COUNT                 16
 #define RPC_IS_PRIORITY(q)              ((q)->maxpriority > 0)
 
 /*
@@ -234,6 +233,9 @@ void rpc_wake_up_queued_task_on_wq(struct workqueue_struct *wq,
                 struct rpc_task *task);
 void            rpc_wake_up_queued_task(struct rpc_wait_queue *,
                                         struct rpc_task *);
+void            rpc_wake_up_queued_task_set_status(struct rpc_wait_queue *,
+                                                   struct rpc_task *,
+                                                   int);
 void            rpc_wake_up(struct rpc_wait_queue *);
 struct rpc_task *rpc_wake_up_next(struct rpc_wait_queue *);
 struct rpc_task *rpc_wake_up_first_on_wq(struct workqueue_struct *wq,
diff --git a/include/linux/sunrpc/svc_xprt.h b/include/linux/sunrpc/svc_xprt.h
index c3d72066d4b1..6b7a86c4d6e6 100644
--- a/include/linux/sunrpc/svc_xprt.h
+++ b/include/linux/sunrpc/svc_xprt.h
@@ -84,7 +84,6 @@ struct svc_xprt {
         struct sockaddr_storage xpt_remote;     /* remote peer's address */
         size_t                  xpt_remotelen;  /* length of address */
         char                    xpt_remotebuf[INET6_ADDRSTRLEN + 10];
-        struct rpc_wait_queue   xpt_bc_pending; /* backchannel wait queue */
         struct list_head        xpt_users;      /* callbacks on free */
 
         struct net              *xpt_net;
diff --git a/include/linux/sunrpc/xdr.h b/include/linux/sunrpc/xdr.h
index 2bd68177a442..43106ffa6788 100644
--- a/include/linux/sunrpc/xdr.h
+++ b/include/linux/sunrpc/xdr.h
@@ -18,6 +18,7 @@
 #include <asm/unaligned.h>
 #include <linux/scatterlist.h>
 
+struct bio_vec;
 struct rpc_rqst;
 
 /*
@@ -52,12 +53,14 @@ struct xdr_buf {
         struct kvec     head[1],        /* RPC header + non-page data */
                         tail[1];        /* Appended after page data */
 
+        struct bio_vec  *bvec;
         struct page **  pages;          /* Array of pages */
         unsigned int    page_base,      /* Start of page data */
                         page_len,       /* Length of page data */
                         flags;          /* Flags for data disposition */
 #define XDRBUF_READ             0x01            /* target of file read */
 #define XDRBUF_WRITE            0x02            /* source of file write */
+#define XDRBUF_SPARSE_PAGES     0x04            /* Page array is sparse */
 
         unsigned int    buflen,         /* Total length of storage buffer */
                         len;            /* Length of XDR encoded message */
@@ -69,6 +72,8 @@ xdr_buf_init(struct xdr_buf *buf, void *start, size_t len)
         buf->head[0].iov_base = start;
         buf->head[0].iov_len = len;
         buf->tail[0].iov_len = 0;
+        buf->bvec = NULL;
+        buf->pages = NULL;
         buf->page_len = 0;
         buf->flags = 0;
         buf->len = 0;
@@ -115,6 +120,9 @@ __be32 *xdr_decode_netobj(__be32 *p, struct xdr_netobj *);
 void    xdr_inline_pages(struct xdr_buf *, unsigned int,
                          struct page **, unsigned int, unsigned int);
 void    xdr_terminate_string(struct xdr_buf *, const u32);
+size_t  xdr_buf_pagecount(struct xdr_buf *buf);
+int     xdr_alloc_bvec(struct xdr_buf *buf, gfp_t gfp);
+void    xdr_free_bvec(struct xdr_buf *buf);
 
 static inline __be32 *xdr_encode_array(__be32 *p, const void *s, unsigned int len)
 {
@@ -177,10 +185,7 @@ struct xdr_skb_reader {
 
 typedef size_t (*xdr_skb_read_actor)(struct xdr_skb_reader *desc, void *to, size_t len);
 
-size_t xdr_skb_read_bits(struct xdr_skb_reader *desc, void *to, size_t len);
 extern int csum_partial_copy_to_xdr(struct xdr_buf *, struct sk_buff *);
-extern ssize_t xdr_partial_copy_from_skb(struct xdr_buf *, unsigned int,
-                struct xdr_skb_reader *, xdr_skb_read_actor);
 
 extern int xdr_encode_word(struct xdr_buf *, unsigned int, u32);
 extern int xdr_decode_word(struct xdr_buf *, unsigned int, u32 *);
diff --git a/include/linux/sunrpc/xprt.h b/include/linux/sunrpc/xprt.h
index 336fd1a19cca..a4ab4f8d9140 100644
--- a/include/linux/sunrpc/xprt.h
+++ b/include/linux/sunrpc/xprt.h
@@ -82,7 +82,14 @@ struct rpc_rqst {
         struct page             **rq_enc_pages; /* scratch pages for use by
                                                    gss privacy code */
         void (*rq_release_snd_buf)(struct rpc_rqst *); /* release rq_enc_pages */
-        struct list_head        rq_list;
+
+        union {
+                struct list_head        rq_list;        /* Slot allocation list */
+                struct rb_node          rq_recv;        /* Receive queue */
+        };
+
+        struct list_head        rq_xmit;        /* Send queue */
+        struct list_head        rq_xmit2;       /* Send queue */
 
         void                    *rq_buffer;     /* Call XDR encode buffer */
         size_t                  rq_callsize;
@@ -103,6 +110,7 @@ struct rpc_rqst {
                                                 /* A cookie used to track the
                                                    state of the transport
                                                    connection */
+        atomic_t                rq_pin;
         
         /*
          * Partial send handling
@@ -133,7 +141,8 @@ struct rpc_xprt_ops {
         void            (*connect)(struct rpc_xprt *xprt, struct rpc_task *task);
         int             (*buf_alloc)(struct rpc_task *task);
         void            (*buf_free)(struct rpc_task *task);
-        int             (*send_request)(struct rpc_task *task);
+        void            (*prepare_request)(struct rpc_rqst *req);
+        int             (*send_request)(struct rpc_rqst *req);
         void            (*set_retrans_timeout)(struct rpc_task *task);
         void            (*timer)(struct rpc_xprt *xprt, struct rpc_task *task);
         void            (*release_request)(struct rpc_task *task);
@@ -234,9 +243,12 @@ struct rpc_xprt {
          */
         spinlock_t              transport_lock; /* lock transport info */
         spinlock_t              reserve_lock;   /* lock slot table */
-        spinlock_t              recv_lock;      /* lock receive list */
+        spinlock_t              queue_lock;     /* send/receive queue lock */
         u32                     xid;            /* Next XID value to use */
         struct rpc_task *       snd_task;       /* Task blocked in send */
+
+        struct list_head        xmit_queue;     /* Send queue */
+
         struct svc_xprt         *bc_xprt;       /* NFSv4.1 backchannel */
 #if defined(CONFIG_SUNRPC_BACKCHANNEL)
         struct svc_serv         *bc_serv;       /* The RPC service which will */
@@ -248,7 +260,8 @@ struct rpc_xprt {
         struct list_head        bc_pa_list;     /* List of preallocated
                                                  * backchannel rpc_rqst's */
 #endif /* CONFIG_SUNRPC_BACKCHANNEL */
-        struct list_head        recv;
+
+        struct rb_root          recv_queue;     /* Receive queue */
 
         struct {
                 unsigned long           bind_count,     /* total number of binds */
@@ -325,15 +338,18 @@ 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);
+void                    xprt_request_prepare(struct rpc_rqst *req);
 bool                    xprt_prepare_transmit(struct rpc_task *task);
+void                    xprt_request_enqueue_transmit(struct rpc_task *task);
+void                    xprt_request_enqueue_receive(struct rpc_task *task);
+void                    xprt_request_wait_receive(struct rpc_task *task);
+bool                    xprt_request_need_retransmit(struct rpc_task *task);
 void                    xprt_transmit(struct rpc_task *task);
 void                    xprt_end_transmit(struct rpc_task *task);
 int                     xprt_adjust_timeout(struct rpc_rqst *req);
@@ -373,8 +389,8 @@ int			xprt_load_transport(const char *);
 void                    xprt_set_retrans_timeout_def(struct rpc_task *task);
 void                    xprt_set_retrans_timeout_rtt(struct rpc_task *task);
 void                    xprt_wake_pending_tasks(struct rpc_xprt *xprt, int status);
-void                    xprt_wait_for_buffer_space(struct rpc_task *task, rpc_action action);
-void                    xprt_write_space(struct rpc_xprt *xprt);
+void                    xprt_wait_for_buffer_space(struct rpc_xprt *xprt);
+bool                    xprt_write_space(struct rpc_xprt *xprt);
 void                    xprt_adjust_cwnd(struct rpc_xprt *xprt, struct rpc_task *task, int result);
 struct rpc_rqst *       xprt_lookup_rqst(struct rpc_xprt *xprt, __be32 xid);
 void                    xprt_update_rtt(struct rpc_task *task);
@@ -382,6 +398,7 @@ void			xprt_complete_rqst(struct rpc_task *task, int copied);
 void                    xprt_pin_rqst(struct rpc_rqst *req);
 void                    xprt_unpin_rqst(struct rpc_rqst *req);
 void                    xprt_release_rqst_cong(struct rpc_task *task);
+bool                    xprt_request_get_cong(struct rpc_xprt *xprt, struct rpc_rqst *req);
 void                    xprt_disconnect_done(struct rpc_xprt *xprt);
 void                    xprt_force_disconnect(struct rpc_xprt *xprt);
 void                    xprt_conditional_disconnect(struct rpc_xprt *xprt, unsigned int cookie);
@@ -400,6 +417,8 @@ void			xprt_unlock_connect(struct rpc_xprt *, void *);
 #define XPRT_BINDING            (5)
 #define XPRT_CLOSING            (6)
 #define XPRT_CONGESTED          (9)
+#define XPRT_CWND_WAIT          (10)
+#define XPRT_WRITE_SPACE        (11)
 
 static inline void xprt_set_connected(struct rpc_xprt *xprt)
 {
diff --git a/include/linux/sunrpc/xprtsock.h b/include/linux/sunrpc/xprtsock.h
index ae0f99b9b965..458bfe0137f5 100644
--- a/include/linux/sunrpc/xprtsock.h
+++ b/include/linux/sunrpc/xprtsock.h
@@ -30,15 +30,25 @@ struct sock_xprt {
         /*
          * State of TCP reply receive
          */
-        __be32                  tcp_fraghdr,
-                                tcp_xid,
-                                tcp_calldir;
+        struct {
+                struct {
+                        __be32  fraghdr,
+                                xid,
+                                calldir;
+                } __attribute__((packed));
 
-        u32                     tcp_offset,
-                                tcp_reclen;
+                u32             offset,
+                                len;
 
-        unsigned long           tcp_copied,
-                                tcp_flags;
+                unsigned long   copied;
+        } recv;
+
+        /*
+         * State of TCP transmit queue
+         */
+        struct {
+                u32             offset;
+        } xmit;
 
         /*
          * Connection of transports
@@ -68,20 +78,8 @@ struct sock_xprt {
 };
 
 /*
- * TCP receive state flags
- */
-#define TCP_RCV_LAST_FRAG       (1UL << 0)
-#define TCP_RCV_COPY_FRAGHDR    (1UL << 1)
-#define TCP_RCV_COPY_XID        (1UL << 2)
-#define TCP_RCV_COPY_DATA       (1UL << 3)
-#define TCP_RCV_READ_CALLDIR    (1UL << 4)
-#define TCP_RCV_COPY_CALLDIR    (1UL << 5)
-
-/*
  * TCP RPC flags
  */
-#define TCP_RPC_REPLY           (1UL << 6)
-
 #define XPRT_SOCK_CONNECTING    1U
 #define XPRT_SOCK_DATA_READY    (2)
 #define XPRT_SOCK_UPD_TIMEOUT   (3)
diff --git a/include/linux/suspend.h b/include/linux/suspend.h
index 5a28ac9284f0..3f529ad9a9d2 100644
--- a/include/linux/suspend.h
+++ b/include/linux/suspend.h
@@ -251,6 +251,7 @@ static inline bool idle_should_enter_s2idle(void)
         return unlikely(s2idle_state == S2IDLE_STATE_ENTER);
 }
 
+extern bool pm_suspend_via_s2idle(void);
 extern void __init pm_states_init(void);
 extern void s2idle_set_ops(const struct platform_s2idle_ops *ops);
 extern void s2idle_wake(void);
@@ -282,6 +283,7 @@ static inline void pm_set_suspend_via_firmware(void) {}
 static inline void pm_set_resume_via_firmware(void) {}
 static inline bool pm_suspend_via_firmware(void) { return false; }
 static inline bool pm_resume_via_firmware(void) { return false; }
+static inline bool pm_suspend_via_s2idle(void) { return false; }
 
 static inline void suspend_set_ops(const struct platform_suspend_ops *ops) {}
 static inline int pm_suspend(suspend_state_t state) { return -ENOSYS; }
diff --git a/include/linux/swap.h b/include/linux/swap.h
index 8e2c11e692ba..d8a07a4f171d 100644
--- a/include/linux/swap.h
+++ b/include/linux/swap.h
@@ -167,13 +167,14 @@ enum {
         SWP_SOLIDSTATE  = (1 << 4),     /* blkdev seeks are cheap */
         SWP_CONTINUED   = (1 << 5),     /* swap_map has count continuation */
         SWP_BLKDEV      = (1 << 6),     /* its a block device */
-        SWP_FILE        = (1 << 7),     /* set after swap_activate success */
-        SWP_AREA_DISCARD = (1 << 8),    /* single-time swap area discards */
-        SWP_PAGE_DISCARD = (1 << 9),    /* freed swap page-cluster discards */
-        SWP_STABLE_WRITES = (1 << 10),  /* no overwrite PG_writeback pages */
-        SWP_SYNCHRONOUS_IO = (1 << 11), /* synchronous IO is efficient */
+        SWP_ACTIVATED   = (1 << 7),     /* set after swap_activate success */
+        SWP_FS          = (1 << 8),     /* swap file goes through fs */
+        SWP_AREA_DISCARD = (1 << 9),    /* single-time swap area discards */
+        SWP_PAGE_DISCARD = (1 << 10),   /* freed swap page-cluster discards */
+        SWP_STABLE_WRITES = (1 << 11),  /* no overwrite PG_writeback pages */
+        SWP_SYNCHRONOUS_IO = (1 << 12), /* synchronous IO is efficient */
                                         /* add others here before... */
-        SWP_SCANNING    = (1 << 12),    /* refcount in scan_swap_map */
+        SWP_SCANNING    = (1 << 13),    /* refcount in scan_swap_map */
 };
 
 #define SWAP_CLUSTER_MAX 32UL
@@ -296,20 +297,15 @@ struct vma_swap_readahead {
 
 /* linux/mm/workingset.c */
 void *workingset_eviction(struct address_space *mapping, struct page *page);
-bool workingset_refault(void *shadow);
+void workingset_refault(struct page *page, void *shadow);
 void workingset_activation(struct page *page);
 
-/* Do not use directly, use workingset_lookup_update */
-void workingset_update_node(struct radix_tree_node *node);
-
-/* Returns workingset_update_node() if the mapping has shadow entries. */
-#define workingset_lookup_update(mapping)                               \
-({                                                                      \
-        radix_tree_update_node_t __helper = workingset_update_node;     \
-        if (dax_mapping(mapping) || shmem_mapping(mapping))             \
-                __helper = NULL;                                        \
-        __helper;                                                       \
-})
+/* Only track the nodes of mappings with shadow entries */
+void workingset_update_node(struct xa_node *node);
+#define mapping_set_update(xas, mapping) do {                           \
+        if (!dax_mapping(mapping) && !shmem_mapping(mapping))           \
+                xas_set_update(xas, workingset_update_node);            \
+} while (0)
 
 /* linux/mm/page_alloc.c */
 extern unsigned long totalram_pages;
@@ -408,7 +404,7 @@ extern void show_swap_cache_info(void);
 extern int add_to_swap(struct page *page);
 extern int add_to_swap_cache(struct page *, swp_entry_t, gfp_t);
 extern int __add_to_swap_cache(struct page *page, swp_entry_t entry);
-extern void __delete_from_swap_cache(struct page *);
+extern void __delete_from_swap_cache(struct page *, swp_entry_t entry);
 extern void delete_from_swap_cache(struct page *);
 extern void free_page_and_swap_cache(struct page *);
 extern void free_pages_and_swap_cache(struct page **, int);
@@ -562,7 +558,8 @@ static inline int add_to_swap_cache(struct page *page, swp_entry_t entry,
         return -1;
 }
 
-static inline void __delete_from_swap_cache(struct page *page)
+static inline void __delete_from_swap_cache(struct page *page,
+                                                        swp_entry_t entry)
 {
 }
 
diff --git a/include/linux/swapops.h b/include/linux/swapops.h
index 22af9d8a84ae..4d961668e5fc 100644
--- a/include/linux/swapops.h
+++ b/include/linux/swapops.h
@@ -18,9 +18,8 @@
  *
  * swp_entry_t's are *never* stored anywhere in their arch-dependent format.
  */
-#define SWP_TYPE_SHIFT(e)       ((sizeof(e.val) * 8) - \
-                        (MAX_SWAPFILES_SHIFT + RADIX_TREE_EXCEPTIONAL_SHIFT))
-#define SWP_OFFSET_MASK(e)      ((1UL << SWP_TYPE_SHIFT(e)) - 1)
+#define SWP_TYPE_SHIFT  (BITS_PER_XA_VALUE - MAX_SWAPFILES_SHIFT)
+#define SWP_OFFSET_MASK ((1UL << SWP_TYPE_SHIFT) - 1)
 
 /*
  * Store a type+offset into a swp_entry_t in an arch-independent format
@@ -29,8 +28,7 @@ static inline swp_entry_t swp_entry(unsigned long type, pgoff_t offset)
 {
         swp_entry_t ret;
 
-        ret.val = (type << SWP_TYPE_SHIFT(ret)) |
-                        (offset & SWP_OFFSET_MASK(ret));
+        ret.val = (type << SWP_TYPE_SHIFT) | (offset & SWP_OFFSET_MASK);
         return ret;
 }
 
@@ -40,7 +38,7 @@ static inline swp_entry_t swp_entry(unsigned long type, pgoff_t offset)
  */
 static inline unsigned swp_type(swp_entry_t entry)
 {
-        return (entry.val >> SWP_TYPE_SHIFT(entry));
+        return (entry.val >> SWP_TYPE_SHIFT);
 }
 
 /*
@@ -49,7 +47,7 @@ static inline unsigned swp_type(swp_entry_t entry)
  */
 static inline pgoff_t swp_offset(swp_entry_t entry)
 {
-        return entry.val & SWP_OFFSET_MASK(entry);
+        return entry.val & SWP_OFFSET_MASK;
 }
 
 #ifdef CONFIG_MMU
@@ -90,16 +88,13 @@ static inline swp_entry_t radix_to_swp_entry(void *arg)
 {
         swp_entry_t entry;
 
-        entry.val = (unsigned long)arg >> RADIX_TREE_EXCEPTIONAL_SHIFT;
+        entry.val = xa_to_value(arg);
         return entry;
 }
 
 static inline void *swp_to_radix_entry(swp_entry_t entry)
 {
-        unsigned long value;
-
-        value = entry.val << RADIX_TREE_EXCEPTIONAL_SHIFT;
-        return (void *)(value | RADIX_TREE_EXCEPTIONAL_ENTRY);
+        return xa_mk_value(entry.val);
 }
 
 #if IS_ENABLED(CONFIG_DEVICE_PRIVATE)
diff --git a/include/linux/swiotlb.h b/include/linux/swiotlb.h
index 965be92c33b5..a387b59640a4 100644
--- a/include/linux/swiotlb.h
+++ b/include/linux/swiotlb.h
@@ -67,11 +67,6 @@ extern void swiotlb_tbl_sync_single(struct device *hwdev,
 
 /* Accessory functions. */
 
-void *swiotlb_alloc(struct device *hwdev, size_t size, dma_addr_t *dma_handle,
-                gfp_t flags, unsigned long attrs);
-void swiotlb_free(struct device *dev, size_t size, void *vaddr,
-                dma_addr_t dma_addr, unsigned long attrs);
-
 extern dma_addr_t swiotlb_map_page(struct device *dev, struct page *page,
                                    unsigned long offset, size_t size,
                                    enum dma_data_direction dir,
@@ -107,9 +102,6 @@ swiotlb_sync_sg_for_device(struct device *hwdev, struct scatterlist *sg,
                            int nelems, enum dma_data_direction dir);
 
 extern int
-swiotlb_dma_mapping_error(struct device *hwdev, dma_addr_t dma_addr);
-
-extern int
 swiotlb_dma_supported(struct device *hwdev, u64 mask);
 
 #ifdef CONFIG_SWIOTLB
@@ -121,7 +113,6 @@ static inline unsigned int swiotlb_max_segment(void) { return 0; }
 #endif
 
 extern void swiotlb_print_info(void);
-extern int is_swiotlb_buffer(phys_addr_t paddr);
 extern void swiotlb_set_max_segment(unsigned int);
 
 extern const struct dma_map_ops swiotlb_dma_ops;
diff --git a/include/linux/syscalls.h b/include/linux/syscalls.h
index 2ff814c92f7f..2ac3d13a915b 100644
--- a/include/linux/syscalls.h
+++ b/include/linux/syscalls.h
@@ -60,7 +60,7 @@ struct tms;
 struct utimbuf;
 struct mq_attr;
 struct compat_stat;
-struct compat_timeval;
+struct old_timeval32;
 struct robust_list_head;
 struct getcpu_cache;
 struct old_linux_dirent;
@@ -513,7 +513,8 @@ asmlinkage long sys_timerfd_gettime(int ufd, struct __kernel_itimerspec __user *
 
 /* fs/utimes.c */
 asmlinkage long sys_utimensat(int dfd, const char __user *filename,
-                                struct timespec __user *utimes, int flags);
+                                struct __kernel_timespec __user *utimes,
+                                int flags);
 
 /* kernel/acct.c */
 asmlinkage long sys_acct(const char __user *name);
@@ -613,7 +614,7 @@ asmlinkage long sys_sched_yield(void);
 asmlinkage long sys_sched_get_priority_max(int policy);
 asmlinkage long sys_sched_get_priority_min(int policy);
 asmlinkage long sys_sched_rr_get_interval(pid_t pid,
-                                        struct timespec __user *interval);
+                                struct __kernel_timespec __user *interval);
 
 /* kernel/signal.c */
 asmlinkage long sys_restart_syscall(void);
@@ -634,7 +635,7 @@ asmlinkage long sys_rt_sigprocmask(int how, sigset_t __user *set,
 asmlinkage long sys_rt_sigpending(sigset_t __user *set, size_t sigsetsize);
 asmlinkage long sys_rt_sigtimedwait(const sigset_t __user *uthese,
                                 siginfo_t __user *uinfo,
-                                const struct timespec __user *uts,
+                                const struct __kernel_timespec __user *uts,
                                 size_t sigsetsize);
 asmlinkage long sys_rt_sigqueueinfo(pid_t pid, int sig, siginfo_t __user *uinfo);
 
@@ -829,7 +830,7 @@ asmlinkage long sys_perf_event_open(
 asmlinkage long sys_accept4(int, struct sockaddr __user *, int __user *, int);
 asmlinkage long sys_recvmmsg(int fd, struct mmsghdr __user *msg,
                              unsigned int vlen, unsigned flags,
-                             struct timespec __user *timeout);
+                             struct __kernel_timespec __user *timeout);
 
 asmlinkage long sys_wait4(pid_t pid, int __user *stat_addr,
                                 int options, struct rusage __user *ru);
@@ -954,8 +955,6 @@ asmlinkage long sys_access(const char __user *filename, int mode);
 asmlinkage long sys_rename(const char __user *oldname,
                                 const char __user *newname);
 asmlinkage long sys_symlink(const char __user *old, const char __user *new);
-asmlinkage long sys_utimes(char __user *filename,
-                                struct timeval __user *utimes);
 #if defined(__ARCH_WANT_STAT64) || defined(__ARCH_WANT_COMPAT_STAT64)
 asmlinkage long sys_stat64(const char __user *filename,
                                 struct stat64 __user *statbuf);
@@ -985,14 +984,18 @@ asmlinkage long sys_alarm(unsigned int seconds);
 asmlinkage long sys_getpgrp(void);
 asmlinkage long sys_pause(void);
 asmlinkage long sys_time(time_t __user *tloc);
+#ifdef __ARCH_WANT_SYS_UTIME
 asmlinkage long sys_utime(char __user *filename,
                                 struct utimbuf __user *times);
+asmlinkage long sys_utimes(char __user *filename,
+                                struct timeval __user *utimes);
+asmlinkage long sys_futimesat(int dfd, const char __user *filename,
+                              struct timeval __user *utimes);
+#endif
 asmlinkage long sys_creat(const char __user *pathname, umode_t mode);
 asmlinkage long sys_getdents(unsigned int fd,
                                 struct linux_dirent __user *dirent,
                                 unsigned int count);
-asmlinkage long sys_futimesat(int dfd, const char __user *filename,
-                              struct timeval __user *utimes);
 asmlinkage long sys_select(int n, fd_set __user *inp, fd_set __user *outp,
                         fd_set __user *exp, struct timeval __user *tvp);
 asmlinkage long sys_poll(struct pollfd __user *ufds, unsigned int nfds,
diff --git a/include/linux/tc.h b/include/linux/tc.h
index f92511e57cdb..a60639f37963 100644
--- a/include/linux/tc.h
+++ b/include/linux/tc.h
@@ -84,6 +84,7 @@ struct tc_dev {
                                            device. */
         struct device   dev;            /* Generic device interface. */
         struct resource resource;       /* Address space of this device. */
+        u64             dma_mask;       /* DMA addressable range. */
         char            vendor[9];
         char            name[9];
         char            firmware[9];
diff --git a/include/linux/tcp.h b/include/linux/tcp.h
index 263e37271afd..8ed77bb4ed86 100644
--- a/include/linux/tcp.h
+++ b/include/linux/tcp.h
@@ -248,6 +248,9 @@ struct tcp_sock {
                 syn_smc:1;      /* SYN includes SMC */
         u32     tlp_high_seq;   /* snd_nxt at the time of TLP retransmit. */
 
+        u64     tcp_wstamp_ns;  /* departure time for next sent data packet */
+        u64     tcp_clock_cache; /* cache last tcp_clock_ns() (see tcp_mstamp_refresh()) */
+
 /* RTT measurement */
         u64     tcp_mstamp;     /* most recent packet received/sent */
         u32     srtt_us;        /* smoothed round trip time << 3 in usecs */
diff --git a/include/linux/thunderbolt.h b/include/linux/thunderbolt.h
index a3ed26082bc1..bf6ec83e60ee 100644
--- a/include/linux/thunderbolt.h
+++ b/include/linux/thunderbolt.h
@@ -1,3 +1,4 @@
+/* SPDX-License-Identifier: GPL-2.0 */
 /*
  * Thunderbolt service API
  *
@@ -5,10 +6,6 @@
  * Copyright (C) 2017, Intel Corporation
  * Authors: Michael Jamet <michael.jamet@intel.com>
  *          Mika Westerberg <mika.westerberg@linux.intel.com>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License version 2 as
- * published by the Free Software Foundation.
  */
 
 #ifndef THUNDERBOLT_H_
diff --git a/include/linux/time32.h b/include/linux/time32.h
index d1ae43c13e25..61904a6c098f 100644
--- a/include/linux/time32.h
+++ b/include/linux/time32.h
@@ -13,6 +13,36 @@
 
 #define TIME_T_MAX      (time_t)((1UL << ((sizeof(time_t) << 3) - 1)) - 1)
 
+typedef s32             old_time32_t;
+
+struct old_timespec32 {
+        old_time32_t    tv_sec;
+        s32             tv_nsec;
+};
+
+struct old_timeval32 {
+        old_time32_t    tv_sec;
+        s32             tv_usec;
+};
+
+struct old_itimerspec32 {
+        struct old_timespec32 it_interval;
+        struct old_timespec32 it_value;
+};
+
+struct old_utimbuf32 {
+        old_time32_t    actime;
+        old_time32_t    modtime;
+};
+
+extern int get_old_timespec32(struct timespec64 *, const void __user *);
+extern int put_old_timespec32(const struct timespec64 *, void __user *);
+extern int get_old_itimerspec32(struct itimerspec64 *its,
+                        const struct old_itimerspec32 __user *uits);
+extern int put_old_itimerspec32(const struct itimerspec64 *its,
+                        struct old_itimerspec32 __user *uits);
+
+
 #if __BITS_PER_LONG == 64
 
 /* timespec64 is defined as timespec here */
@@ -105,16 +135,6 @@ static inline bool timespec_valid(const struct timespec *ts)
         return true;
 }
 
-static inline bool timespec_valid_strict(const struct timespec *ts)
-{
-        if (!timespec_valid(ts))
-                return false;
-        /* Disallow values that could overflow ktime_t */
-        if ((unsigned long long)ts->tv_sec >= KTIME_SEC_MAX)
-                return false;
-        return true;
-}
-
 /**
  * timespec_to_ns - Convert timespec to nanoseconds
  * @ts:         pointer to the timespec variable to be converted
@@ -149,19 +169,6 @@ static __always_inline void timespec_add_ns(struct timespec *a, u64 ns)
         a->tv_nsec = ns;
 }
 
-/**
- * time_to_tm - converts the calendar time to local broken-down time
- *
- * @totalsecs   the number of seconds elapsed since 00:00:00 on January 1, 1970,
- *              Coordinated Universal Time (UTC).
- * @offset      offset seconds adding to totalsecs.
- * @result      pointer to struct tm variable to receive broken-down time
- */
-static inline void time_to_tm(time_t totalsecs, int offset, struct tm *result)
-{
-        time64_to_tm(totalsecs, offset, result);
-}
-
 static inline unsigned long mktime(const unsigned int year,
                         const unsigned int mon, const unsigned int day,
                         const unsigned int hour, const unsigned int min,
@@ -183,8 +190,6 @@ static inline bool timeval_valid(const struct timeval *tv)
         return true;
 }
 
-extern struct timespec timespec_trunc(struct timespec t, unsigned int gran);
-
 /**
  * timeval_to_ns - Convert timeval to nanoseconds
  * @ts:         pointer to the timeval variable to be converted
@@ -208,18 +213,17 @@ extern struct timeval ns_to_timeval(const s64 nsec);
 extern struct __kernel_old_timeval ns_to_kernel_old_timeval(s64 nsec);
 
 /*
- * New aliases for compat time functions. These will be used to replace
- * the compat code so it can be shared between 32-bit and 64-bit builds
- * both of which provide compatibility with old 32-bit tasks.
+ * Old names for the 32-bit time_t interfaces, these will be removed
+ * when everything uses the new names.
  */
-#define old_time32_t            compat_time_t
-#define old_timeval32           compat_timeval
-#define old_timespec32          compat_timespec
-#define old_itimerspec32        compat_itimerspec
-#define ns_to_old_timeval32     ns_to_compat_timeval
-#define get_old_itimerspec32    get_compat_itimerspec64
-#define put_old_itimerspec32    put_compat_itimerspec64
-#define get_old_timespec32      compat_get_timespec64
-#define put_old_timespec32      compat_put_timespec64
+#define compat_time_t           old_time32_t
+#define compat_timeval          old_timeval32
+#define compat_timespec         old_timespec32
+#define compat_itimerspec       old_itimerspec32
+#define ns_to_compat_timeval    ns_to_old_timeval32
+#define get_compat_itimerspec64 get_old_itimerspec32
+#define put_compat_itimerspec64 put_old_itimerspec32
+#define compat_get_timespec64   get_old_timespec32
+#define compat_put_timespec64   put_old_timespec32
 
 #endif
diff --git a/include/linux/timekeeping.h b/include/linux/timekeeping.h
index a5a3cfc3c2fa..29975e93fcb8 100644
--- a/include/linux/timekeeping.h
+++ b/include/linux/timekeeping.h
@@ -266,9 +266,6 @@ extern int update_persistent_clock64(struct timespec64 now);
  * deprecated aliases, don't use in new code
  */
 #define getnstimeofday64(ts)            ktime_get_real_ts64(ts)
-#define get_monotonic_boottime64(ts)    ktime_get_boottime_ts64(ts)
-#define getrawmonotonic64(ts)           ktime_get_raw_ts64(ts)
-#define timekeeping_clocktai64(ts)      ktime_get_clocktai_ts64(ts)
 
 static inline struct timespec64 current_kernel_time64(void)
 {
@@ -279,13 +276,4 @@ static inline struct timespec64 current_kernel_time64(void)
         return ts;
 }
 
-static inline struct timespec64 get_monotonic_coarse64(void)
-{
-        struct timespec64 ts;
-
-        ktime_get_coarse_ts64(&ts);
-
-        return ts;
-}
-
 #endif
diff --git a/include/linux/timekeeping32.h b/include/linux/timekeeping32.h
index 8762c2f45f8b..a502616f7e1c 100644
--- a/include/linux/timekeeping32.h
+++ b/include/linux/timekeeping32.h
@@ -6,27 +6,18 @@
  * over time so we can remove the file here.
  */
 
-extern void do_gettimeofday(struct timeval *tv);
-unsigned long get_seconds(void);
-
-static inline struct timespec current_kernel_time(void)
+static inline void do_gettimeofday(struct timeval *tv)
 {
-        struct timespec64 ts64;
+        struct timespec64 now;
 
-        ktime_get_coarse_real_ts64(&ts64);
-
-        return timespec64_to_timespec(ts64);
+        ktime_get_real_ts64(&now);
+        tv->tv_sec = now.tv_sec;
+        tv->tv_usec = now.tv_nsec/1000;
 }
 
-/**
- * Deprecated. Use do_settimeofday64().
- */
-static inline int do_settimeofday(const struct timespec *ts)
+static inline unsigned long get_seconds(void)
 {
-        struct timespec64 ts64;
-
-        ts64 = timespec_to_timespec64(*ts);
-        return do_settimeofday64(&ts64);
+        return ktime_get_real_seconds();
 }
 
 static inline void getnstimeofday(struct timespec *ts)
@@ -45,14 +36,6 @@ static inline void ktime_get_ts(struct timespec *ts)
         *ts = timespec64_to_timespec(ts64);
 }
 
-static inline void ktime_get_real_ts(struct timespec *ts)
-{
-        struct timespec64 ts64;
-
-        ktime_get_real_ts64(&ts64);
-        *ts = timespec64_to_timespec(ts64);
-}
-
 static inline void getrawmonotonic(struct timespec *ts)
 {
         struct timespec64 ts64;
@@ -61,15 +44,6 @@ static inline void getrawmonotonic(struct timespec *ts)
         *ts = timespec64_to_timespec(ts64);
 }
 
-static inline struct timespec get_monotonic_coarse(void)
-{
-        struct timespec64 ts64;
-
-        ktime_get_coarse_ts64(&ts64);
-
-        return timespec64_to_timespec(ts64);
-}
-
 static inline void getboottime(struct timespec *ts)
 {
         struct timespec64 ts64;
@@ -79,19 +53,6 @@ static inline void getboottime(struct timespec *ts)
 }
 
 /*
- * Timespec interfaces utilizing the ktime based ones
- */
-static inline void get_monotonic_boottime(struct timespec *ts)
-{
-        *ts = ktime_to_timespec(ktime_get_boottime());
-}
-
-static inline void timekeeping_clocktai(struct timespec *ts)
-{
-        *ts = ktime_to_timespec(ktime_get_clocktai());
-}
-
-/*
  * Persistent clock related interfaces
  */
 extern void read_persistent_clock(struct timespec *ts);
diff --git a/include/linux/torture.h b/include/linux/torture.h
index 61dfd93b6ee4..48fad21109fc 100644
--- a/include/linux/torture.h
+++ b/include/linux/torture.h
@@ -77,7 +77,7 @@ void torture_shutdown_absorb(const char *title);
 int torture_shutdown_init(int ssecs, void (*cleanup)(void));
 
 /* Task stuttering, which forces load/no-load transitions. */
-void stutter_wait(const char *title);
+bool stutter_wait(const char *title);
 int torture_stutter_init(int s);
 
 /* Initialization and cleanup. */
diff --git a/include/linux/tracehook.h b/include/linux/tracehook.h
index 05589a3e37f4..40b0b4c1bf7b 100644
--- a/include/linux/tracehook.h
+++ b/include/linux/tracehook.h
@@ -123,15 +123,10 @@ static inline __must_check int tracehook_report_syscall_entry(
  */
 static inline void tracehook_report_syscall_exit(struct pt_regs *regs, int step)
 {
-        if (step) {
-                siginfo_t info;
-                clear_siginfo(&info);
-                user_single_step_siginfo(current, regs, &info);
-                force_sig_info(SIGTRAP, &info, current);
-                return;
-        }
-
-        ptrace_report_syscall(regs);
+        if (step)
+                user_single_step_report(regs);
+        else
+                ptrace_report_syscall(regs);
 }
 
 /**
diff --git a/include/linux/tracepoint-defs.h b/include/linux/tracepoint-defs.h
index 22c5a46e9693..49ba9cde7e4b 100644
--- a/include/linux/tracepoint-defs.h
+++ b/include/linux/tracepoint-defs.h
@@ -35,6 +35,12 @@ struct tracepoint {
         struct tracepoint_func __rcu *funcs;
 };
 
+#ifdef CONFIG_HAVE_ARCH_PREL32_RELOCATIONS
+typedef const int tracepoint_ptr_t;
+#else
+typedef struct tracepoint * const tracepoint_ptr_t;
+#endif
+
 struct bpf_raw_event_map {
         struct tracepoint       *tp;
         void                    *bpf_func;
diff --git a/include/linux/tracepoint.h b/include/linux/tracepoint.h
index 041f7e56a289..538ba1a58f5b 100644
--- a/include/linux/tracepoint.h
+++ b/include/linux/tracepoint.h
@@ -99,6 +99,29 @@ extern void syscall_unregfunc(void);
 #define TRACE_DEFINE_ENUM(x)
 #define TRACE_DEFINE_SIZEOF(x)
 
+#ifdef CONFIG_HAVE_ARCH_PREL32_RELOCATIONS
+static inline struct tracepoint *tracepoint_ptr_deref(tracepoint_ptr_t *p)
+{
+        return offset_to_ptr(p);
+}
+
+#define __TRACEPOINT_ENTRY(name)                                        \
+        asm("   .section \"__tracepoints_ptrs\", \"a\"          \n"     \
+            "   .balign 4                                       \n"     \
+            "   .long   __tracepoint_" #name " - .              \n"     \
+            "   .previous                                       \n")
+#else
+static inline struct tracepoint *tracepoint_ptr_deref(tracepoint_ptr_t *p)
+{
+        return *p;
+}
+
+#define __TRACEPOINT_ENTRY(name)                                         \
+        static tracepoint_ptr_t __tracepoint_ptr_##name __used           \
+        __attribute__((section("__tracepoints_ptrs"))) =                 \
+                &__tracepoint_##name
+#endif
+
 #endif /* _LINUX_TRACEPOINT_H */
 
 /*
@@ -253,19 +276,6 @@ extern void syscall_unregfunc(void);
                 return static_key_false(&__tracepoint_##name.key);      \
         }
 
-#ifdef CONFIG_HAVE_ARCH_PREL32_RELOCATIONS
-#define __TRACEPOINT_ENTRY(name)                                        \
-        asm("   .section \"__tracepoints_ptrs\", \"a\"          \n"     \
-            "   .balign 4                                       \n"     \
-            "   .long   __tracepoint_" #name " - .              \n"     \
-            "   .previous                                       \n")
-#else
-#define __TRACEPOINT_ENTRY(name)                                         \
-        static struct tracepoint * const __tracepoint_ptr_##name __used  \
-        __attribute__((section("__tracepoints_ptrs"))) =                 \
-                &__tracepoint_##name
-#endif
-
 /*
  * We have no guarantee that gcc and the linker won't up-align the tracepoint
  * structures, so we create an array of pointers that will be used for iteration
diff --git a/include/linux/tty.h b/include/linux/tty.h
index c56e3978b00f..414db2bce715 100644
--- a/include/linux/tty.h
+++ b/include/linux/tty.h
@@ -746,8 +746,6 @@ static inline int tty_audit_push(void)
 /* tty_ioctl.c */
 extern int n_tty_ioctl_helper(struct tty_struct *tty, struct file *file,
                        unsigned int cmd, unsigned long arg);
-extern long n_tty_compat_ioctl_helper(struct tty_struct *tty, struct file *file,
-                       unsigned int cmd, unsigned long arg);
 
 /* vt.c */
 
diff --git a/include/linux/tty_driver.h b/include/linux/tty_driver.h
index 71dbc891851a..358446247ccd 100644
--- a/include/linux/tty_driver.h
+++ b/include/linux/tty_driver.h
@@ -249,6 +249,7 @@
 struct tty_struct;
 struct tty_driver;
 struct serial_icounter_struct;
+struct serial_struct;
 
 struct tty_operations {
         struct tty_struct * (*lookup)(struct tty_driver *driver,
@@ -287,6 +288,8 @@ struct tty_operations {
         int (*set_termiox)(struct tty_struct *tty, struct termiox *tnew);
         int (*get_icount)(struct tty_struct *tty,
                                 struct serial_icounter_struct *icount);
+        int  (*get_serial)(struct tty_struct *tty, struct serial_struct *p);
+        int  (*set_serial)(struct tty_struct *tty, struct serial_struct *p);
         void (*show_fdinfo)(struct tty_struct *tty, struct seq_file *m);
 #ifdef CONFIG_CONSOLE_POLL
         int (*poll_init)(struct tty_driver *driver, int line, char *options);
diff --git a/include/linux/tty_ldisc.h b/include/linux/tty_ldisc.h
index 840894ca3fc0..b1e6043e9917 100644
--- a/include/linux/tty_ldisc.h
+++ b/include/linux/tty_ldisc.h
@@ -54,11 +54,17 @@
  *      low-level driver can "grab" an ioctl request before the line
  *      discpline has a chance to see it.
  *
- * long (*compat_ioctl)(struct tty_struct * tty, struct file * file,
+ * int  (*compat_ioctl)(struct tty_struct * tty, struct file * file,
  *                      unsigned int cmd, unsigned long arg);
  *
  *      Process ioctl calls from 32-bit process on 64-bit system
  *
+ *      NOTE: only ioctls that are neither "pointer to compatible
+ *      structure" nor tty-generic.  Something private that takes
+ *      an integer or a pointer to wordsize-sensitive structure
+ *      belongs here, but most of ldiscs will happily leave
+ *      it NULL.
+ *
  * void (*set_termios)(struct tty_struct *tty, struct ktermios * old);
  *
  *      This function notifies the line discpline that a change has
@@ -184,7 +190,7 @@ struct tty_ldisc_ops {
                          const unsigned char *buf, size_t nr);
         int     (*ioctl)(struct tty_struct *tty, struct file *file,
                          unsigned int cmd, unsigned long arg);
-        long    (*compat_ioctl)(struct tty_struct *tty, struct file *file,
+        int     (*compat_ioctl)(struct tty_struct *tty, struct file *file,
                                 unsigned int cmd, unsigned long arg);
         void    (*set_termios)(struct tty_struct *tty, struct ktermios *old);
         __poll_t (*poll)(struct tty_struct *, struct file *,
diff --git a/include/linux/uio.h b/include/linux/uio.h
index 409c845d4cd3..422b1c01ee0d 100644
--- a/include/linux/uio.h
+++ b/include/linux/uio.h
@@ -172,7 +172,7 @@ size_t copy_from_iter_flushcache(void *addr, size_t bytes, struct iov_iter *i)
 static __always_inline __must_check
 size_t copy_to_iter_mcsafe(void *addr, size_t bytes, struct iov_iter *i)
 {
-        if (unlikely(!check_copy_size(addr, bytes, false)))
+        if (unlikely(!check_copy_size(addr, bytes, true)))
                 return 0;
         else
                 return _copy_to_iter_mcsafe(addr, bytes, i);
diff --git a/include/linux/uio_driver.h b/include/linux/uio_driver.h
index 6f8b68cd460f..a3cd7cb67a69 100644
--- a/include/linux/uio_driver.h
+++ b/include/linux/uio_driver.h
@@ -133,6 +133,7 @@ extern void uio_event_notify(struct uio_info *info);
 #define UIO_MEM_PHYS    1
 #define UIO_MEM_LOGICAL 2
 #define UIO_MEM_VIRTUAL 3
+#define UIO_MEM_IOVA    4
 
 /* defines for uio_port->porttype */
 #define UIO_PORT_NONE   0
diff --git a/include/linux/umh.h b/include/linux/umh.h
index 5c812acbb80a..235f51b62c71 100644
--- a/include/linux/umh.h
+++ b/include/linux/umh.h
@@ -44,6 +44,7 @@ struct subprocess_info *call_usermodehelper_setup_file(struct file *file,
                           int (*init)(struct subprocess_info *info, struct cred *new),
                           void (*cleanup)(struct subprocess_info *), void *data);
 struct umh_info {
+        const char *cmdline;
         struct file *pipe_to_umh;
         struct file *pipe_from_umh;
         pid_t pid;
diff --git a/include/linux/usb/chipidea.h b/include/linux/usb/chipidea.h
index 07f99362bc90..63758c399e4e 100644
--- a/include/linux/usb/chipidea.h
+++ b/include/linux/usb/chipidea.h
@@ -77,6 +77,12 @@ struct ci_hdrc_platform_data {
         struct ci_hdrc_cable            vbus_extcon;
         struct ci_hdrc_cable            id_extcon;
         u32                     phy_clkgate_delay_us;
+
+        /* pins */
+        struct pinctrl *pctl;
+        struct pinctrl_state *pins_default;
+        struct pinctrl_state *pins_host;
+        struct pinctrl_state *pins_device;
 };
 
 /* Default offset of capability registers */
diff --git a/include/linux/usb/serial.h b/include/linux/usb/serial.h
index 106551a5616e..1c19f77ed541 100644
--- a/include/linux/usb/serial.h
+++ b/include/linux/usb/serial.h
@@ -285,6 +285,8 @@ struct usb_serial_driver {
         int  (*write_room)(struct tty_struct *tty);
         int  (*ioctl)(struct tty_struct *tty,
                       unsigned int cmd, unsigned long arg);
+        int  (*get_serial)(struct tty_struct *tty, struct serial_struct *ss);
+        int  (*set_serial)(struct tty_struct *tty, struct serial_struct *ss);
         void (*set_termios)(struct tty_struct *tty,
                         struct usb_serial_port *port, struct ktermios *old);
         void (*break_ctl)(struct tty_struct *tty, int break_state);
diff --git a/include/linux/usb/usbnet.h b/include/linux/usb/usbnet.h
index e2ec3582e549..d8860f2d0976 100644
--- a/include/linux/usb/usbnet.h
+++ b/include/linux/usb/usbnet.h
@@ -28,7 +28,7 @@ struct usbnet {
         /* housekeeping */
         struct usb_device       *udev;
         struct usb_interface    *intf;
-        struct driver_info      *driver_info;
+        const struct driver_info *driver_info;
         const char              *driver_name;
         void                    *driver_priv;
         wait_queue_head_t       wait;
diff --git a/include/linux/vga_switcheroo.h b/include/linux/vga_switcheroo.h
index a34539b7f750..7e6ac0114d55 100644
--- a/include/linux/vga_switcheroo.h
+++ b/include/linux/vga_switcheroo.h
@@ -133,15 +133,18 @@ struct vga_switcheroo_handler {
  * @can_switch: check if the device is in a position to switch now.
  *      Mandatory. The client should return false if a user space process
  *      has one of its device files open
+ * @gpu_bound: notify the client id to audio client when the GPU is bound.
  *
  * Client callbacks. A client can be either a GPU or an audio device on a GPU.
  * The @set_gpu_state and @can_switch methods are mandatory, @reprobe may be
  * set to NULL. For audio clients, the @reprobe member is bogus.
+ * OTOH, @gpu_bound is only for audio clients, and not used for GPU clients.
  */
 struct vga_switcheroo_client_ops {
         void (*set_gpu_state)(struct pci_dev *dev, enum vga_switcheroo_state);
         void (*reprobe)(struct pci_dev *dev);
         bool (*can_switch)(struct pci_dev *dev);
+        void (*gpu_bound)(struct pci_dev *dev, enum vga_switcheroo_client_id);
 };
 
 #if defined(CONFIG_VGA_SWITCHEROO)
diff --git a/include/linux/virtio_net.h b/include/linux/virtio_net.h
index 9397628a1967..cb462f9ab7dd 100644
--- a/include/linux/virtio_net.h
+++ b/include/linux/virtio_net.h
@@ -5,6 +5,24 @@
 #include <linux/if_vlan.h>
 #include <uapi/linux/virtio_net.h>
 
+static inline int virtio_net_hdr_set_proto(struct sk_buff *skb,
+                                           const struct virtio_net_hdr *hdr)
+{
+        switch (hdr->gso_type & ~VIRTIO_NET_HDR_GSO_ECN) {
+        case VIRTIO_NET_HDR_GSO_TCPV4:
+        case VIRTIO_NET_HDR_GSO_UDP:
+                skb->protocol = cpu_to_be16(ETH_P_IP);
+                break;
+        case VIRTIO_NET_HDR_GSO_TCPV6:
+                skb->protocol = cpu_to_be16(ETH_P_IPV6);
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        return 0;
+}
+
 static inline int virtio_net_hdr_to_skb(struct sk_buff *skb,
                                         const struct virtio_net_hdr *hdr,
                                         bool little_endian)
diff --git a/include/linux/vm_event_item.h b/include/linux/vm_event_item.h
index 5c7f010676a7..47a3441cf4c4 100644
--- a/include/linux/vm_event_item.h
+++ b/include/linux/vm_event_item.h
@@ -105,7 +105,6 @@ enum vm_event_item { PGPGIN, PGPGOUT, PSWPIN, PSWPOUT,
 #ifdef CONFIG_DEBUG_VM_VMACACHE
                 VMACACHE_FIND_CALLS,
                 VMACACHE_FIND_HITS,
-                VMACACHE_FULL_FLUSHES,
 #endif
 #ifdef CONFIG_SWAP
                 SWAP_RA,
diff --git a/include/linux/vmacache.h b/include/linux/vmacache.h
index 3e9a963edd6a..6fce268a4588 100644
--- a/include/linux/vmacache.h
+++ b/include/linux/vmacache.h
@@ -10,7 +10,6 @@ static inline void vmacache_flush(struct task_struct *tsk)
         memset(tsk->vmacache.vmas, 0, sizeof(tsk->vmacache.vmas));
 }
 
-extern void vmacache_flush_all(struct mm_struct *mm);
 extern void vmacache_update(unsigned long addr, struct vm_area_struct *newvma);
 extern struct vm_area_struct *vmacache_find(struct mm_struct *mm,
                                                     unsigned long addr);
@@ -24,10 +23,6 @@ extern struct vm_area_struct *vmacache_find_exact(struct mm_struct *mm,
 static inline void vmacache_invalidate(struct mm_struct *mm)
 {
         mm->vmacache_seqnum++;
-
-        /* deal with overflows */
-        if (unlikely(mm->vmacache_seqnum == 0))
-                vmacache_flush_all(mm);
 }
 
 #endif /* __LINUX_VMACACHE_H */
diff --git a/include/linux/vt_kern.h b/include/linux/vt_kern.h
index 3fd07912909c..8dc77e40bc03 100644
--- a/include/linux/vt_kern.h
+++ b/include/linux/vt_kern.h
@@ -135,13 +135,6 @@ extern int do_unbind_con_driver(const struct consw *csw, int first, int last,
                              int deflt);
 int vty_init(const struct file_operations *console_fops);
 
-static inline bool vt_force_oops_output(struct vc_data *vc)
-{
-        if (oops_in_progress && vc->vc_panic_force_write  && panic_timeout >= 0)
-                return true;
-        return false;
-}
-
 extern char vt_dont_switch;
 extern int default_utf8;
 extern int global_cursor_default;
diff --git a/include/linux/wait.h b/include/linux/wait.h
index d9f131ecf708..ed7c122cb31f 100644
--- a/include/linux/wait.h
+++ b/include/linux/wait.h
@@ -1052,10 +1052,9 @@ do {										\
         __ret;                                                                  \
 })
 
-#define __wait_event_interruptible_lock_irq_timeout(wq_head, condition,         \
-                                                    lock, timeout)              \
+#define __wait_event_lock_irq_timeout(wq_head, condition, lock, timeout, state) \
         ___wait_event(wq_head, ___wait_cond_timeout(condition),                 \
-                      TASK_INTERRUPTIBLE, 0, timeout,                           \
+                      state, 0, timeout,                                        \
                       spin_unlock_irq(&lock);                                   \
                       __ret = schedule_timeout(__ret);                          \
                       spin_lock_irq(&lock));
@@ -1089,8 +1088,19 @@ do {										\
 ({                                                                              \
         long __ret = timeout;                                                   \
         if (!___wait_cond_timeout(condition))                                   \
-                __ret = __wait_event_interruptible_lock_irq_timeout(            \
-                                        wq_head, condition, lock, timeout);     \
+                __ret = __wait_event_lock_irq_timeout(                          \
+                                        wq_head, condition, lock, timeout,      \
+                                        TASK_INTERRUPTIBLE);                    \
+        __ret;                                                                  \
+})
+
+#define wait_event_lock_irq_timeout(wq_head, condition, lock, timeout)          \
+({                                                                              \
+        long __ret = timeout;                                                   \
+        if (!___wait_cond_timeout(condition))                                   \
+                __ret = __wait_event_lock_irq_timeout(                          \
+                                        wq_head, condition, lock, timeout,      \
+                                        TASK_UNINTERRUPTIBLE);                  \
         __ret;                                                                  \
 })
 
diff --git a/include/linux/writeback.h b/include/linux/writeback.h
index fdfd04e348f6..738a0c24874f 100644
--- a/include/linux/writeback.h
+++ b/include/linux/writeback.h
@@ -246,7 +246,8 @@ static inline void wbc_attach_fdatawrite_inode(struct writeback_control *wbc,
  *
  * @bio is a part of the writeback in progress controlled by @wbc.  Perform
  * writeback specific initialization.  This is used to apply the cgroup
- * writeback context.
+ * writeback context.  Must be called after the bio has been associated with
+ * a device.
  */
 static inline void wbc_init_bio(struct writeback_control *wbc, struct bio *bio)
 {
@@ -257,7 +258,7 @@ static inline void wbc_init_bio(struct writeback_control *wbc, struct bio *bio)
          * regular writeback instead of writing things out itself.
          */
         if (wbc->wb)
-                bio_associate_blkcg(bio, wbc->wb->blkcg_css);
+                bio_associate_blkg_from_css(bio, wbc->wb->blkcg_css);
 }
 
 #else   /* CONFIG_CGROUP_WRITEBACK */
diff --git a/include/linux/xarray.h b/include/linux/xarray.h
index 2dfc8006fe64..d9514928ddac 100644
--- a/include/linux/xarray.h
+++ b/include/linux/xarray.h
@@ -4,10 +4,432 @@
 /*
  * eXtensible Arrays
  * Copyright (c) 2017 Microsoft Corporation
- * Author: Matthew Wilcox <mawilcox@microsoft.com>
+ * Author: Matthew Wilcox <willy@infradead.org>
+ *
+ * See Documentation/core-api/xarray.rst for how to use the XArray.
  */
 
+#include <linux/bug.h>
+#include <linux/compiler.h>
+#include <linux/gfp.h>
+#include <linux/kconfig.h>
+#include <linux/kernel.h>
+#include <linux/rcupdate.h>
 #include <linux/spinlock.h>
+#include <linux/types.h>
+
+/*
+ * The bottom two bits of the entry determine how the XArray interprets
+ * the contents:
+ *
+ * 00: Pointer entry
+ * 10: Internal entry
+ * x1: Value entry or tagged pointer
+ *
+ * Attempting to store internal entries in the XArray is a bug.
+ *
+ * Most internal entries are pointers to the next node in the tree.
+ * The following internal entries have a special meaning:
+ *
+ * 0-62: Sibling entries
+ * 256: Zero entry
+ * 257: Retry entry
+ *
+ * Errors are also represented as internal entries, but use the negative
+ * space (-4094 to -2).  They're never stored in the slots array; only
+ * returned by the normal API.
+ */
+
+#define BITS_PER_XA_VALUE       (BITS_PER_LONG - 1)
+
+/**
+ * xa_mk_value() - Create an XArray entry from an integer.
+ * @v: Value to store in XArray.
+ *
+ * Context: Any context.
+ * Return: An entry suitable for storing in the XArray.
+ */
+static inline void *xa_mk_value(unsigned long v)
+{
+        WARN_ON((long)v < 0);
+        return (void *)((v << 1) | 1);
+}
+
+/**
+ * xa_to_value() - Get value stored in an XArray entry.
+ * @entry: XArray entry.
+ *
+ * Context: Any context.
+ * Return: The value stored in the XArray entry.
+ */
+static inline unsigned long xa_to_value(const void *entry)
+{
+        return (unsigned long)entry >> 1;
+}
+
+/**
+ * xa_is_value() - Determine if an entry is a value.
+ * @entry: XArray entry.
+ *
+ * Context: Any context.
+ * Return: True if the entry is a value, false if it is a pointer.
+ */
+static inline bool xa_is_value(const void *entry)
+{
+        return (unsigned long)entry & 1;
+}
+
+/**
+ * xa_tag_pointer() - Create an XArray entry for a tagged pointer.
+ * @p: Plain pointer.
+ * @tag: Tag value (0, 1 or 3).
+ *
+ * If the user of the XArray prefers, they can tag their pointers instead
+ * of storing value entries.  Three tags are available (0, 1 and 3).
+ * These are distinct from the xa_mark_t as they are not replicated up
+ * through the array and cannot be searched for.
+ *
+ * Context: Any context.
+ * Return: An XArray entry.
+ */
+static inline void *xa_tag_pointer(void *p, unsigned long tag)
+{
+        return (void *)((unsigned long)p | tag);
+}
+
+/**
+ * xa_untag_pointer() - Turn an XArray entry into a plain pointer.
+ * @entry: XArray entry.
+ *
+ * If you have stored a tagged pointer in the XArray, call this function
+ * to get the untagged version of the pointer.
+ *
+ * Context: Any context.
+ * Return: A pointer.
+ */
+static inline void *xa_untag_pointer(void *entry)
+{
+        return (void *)((unsigned long)entry & ~3UL);
+}
+
+/**
+ * xa_pointer_tag() - Get the tag stored in an XArray entry.
+ * @entry: XArray entry.
+ *
+ * If you have stored a tagged pointer in the XArray, call this function
+ * to get the tag of that pointer.
+ *
+ * Context: Any context.
+ * Return: A tag.
+ */
+static inline unsigned int xa_pointer_tag(void *entry)
+{
+        return (unsigned long)entry & 3UL;
+}
+
+/*
+ * xa_mk_internal() - Create an internal entry.
+ * @v: Value to turn into an internal entry.
+ *
+ * Context: Any context.
+ * Return: An XArray internal entry corresponding to this value.
+ */
+static inline void *xa_mk_internal(unsigned long v)
+{
+        return (void *)((v << 2) | 2);
+}
+
+/*
+ * xa_to_internal() - Extract the value from an internal entry.
+ * @entry: XArray entry.
+ *
+ * Context: Any context.
+ * Return: The value which was stored in the internal entry.
+ */
+static inline unsigned long xa_to_internal(const void *entry)
+{
+        return (unsigned long)entry >> 2;
+}
+
+/*
+ * xa_is_internal() - Is the entry an internal entry?
+ * @entry: XArray entry.
+ *
+ * Context: Any context.
+ * Return: %true if the entry is an internal entry.
+ */
+static inline bool xa_is_internal(const void *entry)
+{
+        return ((unsigned long)entry & 3) == 2;
+}
+
+/**
+ * xa_is_err() - Report whether an XArray operation returned an error
+ * @entry: Result from calling an XArray function
+ *
+ * If an XArray operation cannot complete an operation, it will return
+ * a special value indicating an error.  This function tells you
+ * whether an error occurred; xa_err() tells you which error occurred.
+ *
+ * Context: Any context.
+ * Return: %true if the entry indicates an error.
+ */
+static inline bool xa_is_err(const void *entry)
+{
+        return unlikely(xa_is_internal(entry));
+}
+
+/**
+ * xa_err() - Turn an XArray result into an errno.
+ * @entry: Result from calling an XArray function.
+ *
+ * If an XArray operation cannot complete an operation, it will return
+ * a special pointer value which encodes an errno.  This function extracts
+ * the errno from the pointer value, or returns 0 if the pointer does not
+ * represent an errno.
+ *
+ * Context: Any context.
+ * Return: A negative errno or 0.
+ */
+static inline int xa_err(void *entry)
+{
+        /* xa_to_internal() would not do sign extension. */
+        if (xa_is_err(entry))
+                return (long)entry >> 2;
+        return 0;
+}
+
+typedef unsigned __bitwise xa_mark_t;
+#define XA_MARK_0               ((__force xa_mark_t)0U)
+#define XA_MARK_1               ((__force xa_mark_t)1U)
+#define XA_MARK_2               ((__force xa_mark_t)2U)
+#define XA_PRESENT              ((__force xa_mark_t)8U)
+#define XA_MARK_MAX             XA_MARK_2
+#define XA_FREE_MARK            XA_MARK_0
+
+enum xa_lock_type {
+        XA_LOCK_IRQ = 1,
+        XA_LOCK_BH = 2,
+};
+
+/*
+ * Values for xa_flags.  The radix tree stores its GFP flags in the xa_flags,
+ * and we remain compatible with that.
+ */
+#define XA_FLAGS_LOCK_IRQ       ((__force gfp_t)XA_LOCK_IRQ)
+#define XA_FLAGS_LOCK_BH        ((__force gfp_t)XA_LOCK_BH)
+#define XA_FLAGS_TRACK_FREE     ((__force gfp_t)4U)
+#define XA_FLAGS_MARK(mark)     ((__force gfp_t)((1U << __GFP_BITS_SHIFT) << \
+                                                (__force unsigned)(mark)))
+
+#define XA_FLAGS_ALLOC  (XA_FLAGS_TRACK_FREE | XA_FLAGS_MARK(XA_FREE_MARK))
+
+/**
+ * struct xarray - The anchor of the XArray.
+ * @xa_lock: Lock that protects the contents of the XArray.
+ *
+ * To use the xarray, define it statically or embed it in your data structure.
+ * It is a very small data structure, so it does not usually make sense to
+ * allocate it separately and keep a pointer to it in your data structure.
+ *
+ * You may use the xa_lock to protect your own data structures as well.
+ */
+/*
+ * If all of the entries in the array are NULL, @xa_head is a NULL pointer.
+ * If the only non-NULL entry in the array is at index 0, @xa_head is that
+ * entry.  If any other entry in the array is non-NULL, @xa_head points
+ * to an @xa_node.
+ */
+struct xarray {
+        spinlock_t      xa_lock;
+/* private: The rest of the data structure is not to be used directly. */
+        gfp_t           xa_flags;
+        void __rcu *    xa_head;
+};
+
+#define XARRAY_INIT(name, flags) {                              \
+        .xa_lock = __SPIN_LOCK_UNLOCKED(name.xa_lock),          \
+        .xa_flags = flags,                                      \
+        .xa_head = NULL,                                        \
+}
+
+/**
+ * DEFINE_XARRAY_FLAGS() - Define an XArray with custom flags.
+ * @name: A string that names your XArray.
+ * @flags: XA_FLAG values.
+ *
+ * This is intended for file scope definitions of XArrays.  It declares
+ * and initialises an empty XArray with the chosen name and flags.  It is
+ * equivalent to calling xa_init_flags() on the array, but it does the
+ * initialisation at compiletime instead of runtime.
+ */
+#define DEFINE_XARRAY_FLAGS(name, flags)                                \
+        struct xarray name = XARRAY_INIT(name, flags)
+
+/**
+ * DEFINE_XARRAY() - Define an XArray.
+ * @name: A string that names your XArray.
+ *
+ * This is intended for file scope definitions of XArrays.  It declares
+ * and initialises an empty XArray with the chosen name.  It is equivalent
+ * to calling xa_init() on the array, but it does the initialisation at
+ * compiletime instead of runtime.
+ */
+#define DEFINE_XARRAY(name) DEFINE_XARRAY_FLAGS(name, 0)
+
+/**
+ * DEFINE_XARRAY_ALLOC() - Define an XArray which can allocate IDs.
+ * @name: A string that names your XArray.
+ *
+ * This is intended for file scope definitions of allocating XArrays.
+ * See also DEFINE_XARRAY().
+ */
+#define DEFINE_XARRAY_ALLOC(name) DEFINE_XARRAY_FLAGS(name, XA_FLAGS_ALLOC)
+
+void xa_init_flags(struct xarray *, gfp_t flags);
+void *xa_load(struct xarray *, unsigned long index);
+void *xa_store(struct xarray *, unsigned long index, void *entry, gfp_t);
+void *xa_cmpxchg(struct xarray *, unsigned long index,
+                        void *old, void *entry, gfp_t);
+int xa_reserve(struct xarray *, unsigned long index, gfp_t);
+void *xa_store_range(struct xarray *, unsigned long first, unsigned long last,
+                        void *entry, gfp_t);
+bool xa_get_mark(struct xarray *, unsigned long index, xa_mark_t);
+void xa_set_mark(struct xarray *, unsigned long index, xa_mark_t);
+void xa_clear_mark(struct xarray *, unsigned long index, xa_mark_t);
+void *xa_find(struct xarray *xa, unsigned long *index,
+                unsigned long max, xa_mark_t) __attribute__((nonnull(2)));
+void *xa_find_after(struct xarray *xa, unsigned long *index,
+                unsigned long max, xa_mark_t) __attribute__((nonnull(2)));
+unsigned int xa_extract(struct xarray *, void **dst, unsigned long start,
+                unsigned long max, unsigned int n, xa_mark_t);
+void xa_destroy(struct xarray *);
+
+/**
+ * xa_init() - Initialise an empty XArray.
+ * @xa: XArray.
+ *
+ * An empty XArray is full of NULL entries.
+ *
+ * Context: Any context.
+ */
+static inline void xa_init(struct xarray *xa)
+{
+        xa_init_flags(xa, 0);
+}
+
+/**
+ * xa_empty() - Determine if an array has any present entries.
+ * @xa: XArray.
+ *
+ * Context: Any context.
+ * Return: %true if the array contains only NULL pointers.
+ */
+static inline bool xa_empty(const struct xarray *xa)
+{
+        return xa->xa_head == NULL;
+}
+
+/**
+ * xa_marked() - Inquire whether any entry in this array has a mark set
+ * @xa: Array
+ * @mark: Mark value
+ *
+ * Context: Any context.
+ * Return: %true if any entry has this mark set.
+ */
+static inline bool xa_marked(const struct xarray *xa, xa_mark_t mark)
+{
+        return xa->xa_flags & XA_FLAGS_MARK(mark);
+}
+
+/**
+ * xa_erase() - Erase this entry from the XArray.
+ * @xa: XArray.
+ * @index: Index of entry.
+ *
+ * This function is the equivalent of calling xa_store() with %NULL as
+ * the third argument.  The XArray does not need to allocate memory, so
+ * the user does not need to provide GFP flags.
+ *
+ * Context: Process context.  Takes and releases the xa_lock.
+ * Return: The entry which used to be at this index.
+ */
+static inline void *xa_erase(struct xarray *xa, unsigned long index)
+{
+        return xa_store(xa, index, NULL, 0);
+}
+
+/**
+ * xa_insert() - Store this entry in the XArray unless another entry is
+ *                      already present.
+ * @xa: XArray.
+ * @index: Index into array.
+ * @entry: New entry.
+ * @gfp: Memory allocation flags.
+ *
+ * If you would rather see the existing entry in the array, use xa_cmpxchg().
+ * This function is for users who don't care what the entry is, only that
+ * one is present.
+ *
+ * Context: Process context.  Takes and releases the xa_lock.
+ *          May sleep if the @gfp flags permit.
+ * Return: 0 if the store succeeded.  -EEXIST if another entry was present.
+ * -ENOMEM if memory could not be allocated.
+ */
+static inline int xa_insert(struct xarray *xa, unsigned long index,
+                void *entry, gfp_t gfp)
+{
+        void *curr = xa_cmpxchg(xa, index, NULL, entry, gfp);
+        if (!curr)
+                return 0;
+        if (xa_is_err(curr))
+                return xa_err(curr);
+        return -EEXIST;
+}
+
+/**
+ * xa_release() - Release a reserved entry.
+ * @xa: XArray.
+ * @index: Index of entry.
+ *
+ * After calling xa_reserve(), you can call this function to release the
+ * reservation.  If the entry at @index has been stored to, this function
+ * will do nothing.
+ */
+static inline void xa_release(struct xarray *xa, unsigned long index)
+{
+        xa_cmpxchg(xa, index, NULL, NULL, 0);
+}
+
+/**
+ * xa_for_each() - Iterate over a portion of an XArray.
+ * @xa: XArray.
+ * @entry: Entry retrieved from array.
+ * @index: Index of @entry.
+ * @max: Maximum index to retrieve from array.
+ * @filter: Selection criterion.
+ *
+ * Initialise @index to the lowest index you want to retrieve from the
+ * array.  During the iteration, @entry will have the value of the entry
+ * stored in @xa at @index.  The iteration will skip all entries in the
+ * array which do not match @filter.  You may modify @index during the
+ * iteration if you want to skip or reprocess indices.  It is safe to modify
+ * the array during the iteration.  At the end of the iteration, @entry will
+ * be set to NULL and @index will have a value less than or equal to max.
+ *
+ * xa_for_each() is O(n.log(n)) while xas_for_each() is O(n).  You have
+ * to handle your own locking with xas_for_each(), and if you have to unlock
+ * after each iteration, it will also end up being O(n.log(n)).  xa_for_each()
+ * will spin if it hits a retry entry; if you intend to see retry entries,
+ * you should use the xas_for_each() iterator instead.  The xas_for_each()
+ * iterator will expand into more inline code than xa_for_each().
+ *
+ * Context: Any context.  Takes and releases the RCU lock.
+ */
+#define xa_for_each(xa, entry, index, max, filter) \
+        for (entry = xa_find(xa, &index, max, filter); entry; \
+             entry = xa_find_after(xa, &index, max, filter))
 
 #define xa_trylock(xa)          spin_trylock(&(xa)->xa_lock)
 #define xa_lock(xa)             spin_lock(&(xa)->xa_lock)
@@ -21,4 +443,873 @@
 #define xa_unlock_irqrestore(xa, flags) \
                                 spin_unlock_irqrestore(&(xa)->xa_lock, flags)
 
+/*
+ * Versions of the normal API which require the caller to hold the
+ * xa_lock.  If the GFP flags allow it, they will drop the lock to
+ * allocate memory, then reacquire it afterwards.  These functions
+ * may also re-enable interrupts if the XArray flags indicate the
+ * locking should be interrupt safe.
+ */
+void *__xa_erase(struct xarray *, unsigned long index);
+void *__xa_store(struct xarray *, unsigned long index, void *entry, gfp_t);
+void *__xa_cmpxchg(struct xarray *, unsigned long index, void *old,
+                void *entry, gfp_t);
+int __xa_alloc(struct xarray *, u32 *id, u32 max, void *entry, gfp_t);
+void __xa_set_mark(struct xarray *, unsigned long index, xa_mark_t);
+void __xa_clear_mark(struct xarray *, unsigned long index, xa_mark_t);
+
+/**
+ * __xa_insert() - Store this entry in the XArray unless another entry is
+ *                      already present.
+ * @xa: XArray.
+ * @index: Index into array.
+ * @entry: New entry.
+ * @gfp: Memory allocation flags.
+ *
+ * If you would rather see the existing entry in the array, use __xa_cmpxchg().
+ * This function is for users who don't care what the entry is, only that
+ * one is present.
+ *
+ * Context: Any context.  Expects xa_lock to be held on entry.  May
+ *          release and reacquire xa_lock if the @gfp flags permit.
+ * Return: 0 if the store succeeded.  -EEXIST if another entry was present.
+ * -ENOMEM if memory could not be allocated.
+ */
+static inline int __xa_insert(struct xarray *xa, unsigned long index,
+                void *entry, gfp_t gfp)
+{
+        void *curr = __xa_cmpxchg(xa, index, NULL, entry, gfp);
+        if (!curr)
+                return 0;
+        if (xa_is_err(curr))
+                return xa_err(curr);
+        return -EEXIST;
+}
+
+/**
+ * xa_erase_bh() - Erase this entry from the XArray.
+ * @xa: XArray.
+ * @index: Index of entry.
+ *
+ * This function is the equivalent of calling xa_store() with %NULL as
+ * the third argument.  The XArray does not need to allocate memory, so
+ * the user does not need to provide GFP flags.
+ *
+ * Context: Process context.  Takes and releases the xa_lock while
+ * disabling softirqs.
+ * Return: The entry which used to be at this index.
+ */
+static inline void *xa_erase_bh(struct xarray *xa, unsigned long index)
+{
+        void *entry;
+
+        xa_lock_bh(xa);
+        entry = __xa_erase(xa, index);
+        xa_unlock_bh(xa);
+
+        return entry;
+}
+
+/**
+ * xa_erase_irq() - Erase this entry from the XArray.
+ * @xa: XArray.
+ * @index: Index of entry.
+ *
+ * This function is the equivalent of calling xa_store() with %NULL as
+ * the third argument.  The XArray does not need to allocate memory, so
+ * the user does not need to provide GFP flags.
+ *
+ * Context: Process context.  Takes and releases the xa_lock while
+ * disabling interrupts.
+ * Return: The entry which used to be at this index.
+ */
+static inline void *xa_erase_irq(struct xarray *xa, unsigned long index)
+{
+        void *entry;
+
+        xa_lock_irq(xa);
+        entry = __xa_erase(xa, index);
+        xa_unlock_irq(xa);
+
+        return entry;
+}
+
+/**
+ * xa_alloc() - Find somewhere to store this entry in the XArray.
+ * @xa: XArray.
+ * @id: Pointer to ID.
+ * @max: Maximum ID to allocate (inclusive).
+ * @entry: New entry.
+ * @gfp: Memory allocation flags.
+ *
+ * Allocates an unused ID in the range specified by @id and @max.
+ * Updates the @id pointer with the index, then stores the entry at that
+ * index.  A concurrent lookup will not see an uninitialised @id.
+ *
+ * Context: Process context.  Takes and releases the xa_lock.  May sleep if
+ * the @gfp flags permit.
+ * Return: 0 on success, -ENOMEM if memory allocation fails or -ENOSPC if
+ * there is no more space in the XArray.
+ */
+static inline int xa_alloc(struct xarray *xa, u32 *id, u32 max, void *entry,
+                gfp_t gfp)
+{
+        int err;
+
+        xa_lock(xa);
+        err = __xa_alloc(xa, id, max, entry, gfp);
+        xa_unlock(xa);
+
+        return err;
+}
+
+/**
+ * xa_alloc_bh() - Find somewhere to store this entry in the XArray.
+ * @xa: XArray.
+ * @id: Pointer to ID.
+ * @max: Maximum ID to allocate (inclusive).
+ * @entry: New entry.
+ * @gfp: Memory allocation flags.
+ *
+ * Allocates an unused ID in the range specified by @id and @max.
+ * Updates the @id pointer with the index, then stores the entry at that
+ * index.  A concurrent lookup will not see an uninitialised @id.
+ *
+ * Context: Process context.  Takes and releases the xa_lock while
+ * disabling softirqs.  May sleep if the @gfp flags permit.
+ * Return: 0 on success, -ENOMEM if memory allocation fails or -ENOSPC if
+ * there is no more space in the XArray.
+ */
+static inline int xa_alloc_bh(struct xarray *xa, u32 *id, u32 max, void *entry,
+                gfp_t gfp)
+{
+        int err;
+
+        xa_lock_bh(xa);
+        err = __xa_alloc(xa, id, max, entry, gfp);
+        xa_unlock_bh(xa);
+
+        return err;
+}
+
+/**
+ * xa_alloc_irq() - Find somewhere to store this entry in the XArray.
+ * @xa: XArray.
+ * @id: Pointer to ID.
+ * @max: Maximum ID to allocate (inclusive).
+ * @entry: New entry.
+ * @gfp: Memory allocation flags.
+ *
+ * Allocates an unused ID in the range specified by @id and @max.
+ * Updates the @id pointer with the index, then stores the entry at that
+ * index.  A concurrent lookup will not see an uninitialised @id.
+ *
+ * Context: Process context.  Takes and releases the xa_lock while
+ * disabling interrupts.  May sleep if the @gfp flags permit.
+ * Return: 0 on success, -ENOMEM if memory allocation fails or -ENOSPC if
+ * there is no more space in the XArray.
+ */
+static inline int xa_alloc_irq(struct xarray *xa, u32 *id, u32 max, void *entry,
+                gfp_t gfp)
+{
+        int err;
+
+        xa_lock_irq(xa);
+        err = __xa_alloc(xa, id, max, entry, gfp);
+        xa_unlock_irq(xa);
+
+        return err;
+}
+
+/* Everything below here is the Advanced API.  Proceed with caution. */
+
+/*
+ * The xarray is constructed out of a set of 'chunks' of pointers.  Choosing
+ * the best chunk size requires some tradeoffs.  A power of two recommends
+ * itself so that we can walk the tree based purely on shifts and masks.
+ * Generally, the larger the better; as the number of slots per level of the
+ * tree increases, the less tall the tree needs to be.  But that needs to be
+ * balanced against the memory consumption of each node.  On a 64-bit system,
+ * xa_node is currently 576 bytes, and we get 7 of them per 4kB page.  If we
+ * doubled the number of slots per node, we'd get only 3 nodes per 4kB page.
+ */
+#ifndef XA_CHUNK_SHIFT
+#define XA_CHUNK_SHIFT          (CONFIG_BASE_SMALL ? 4 : 6)
+#endif
+#define XA_CHUNK_SIZE           (1UL << XA_CHUNK_SHIFT)
+#define XA_CHUNK_MASK           (XA_CHUNK_SIZE - 1)
+#define XA_MAX_MARKS            3
+#define XA_MARK_LONGS           DIV_ROUND_UP(XA_CHUNK_SIZE, BITS_PER_LONG)
+
+/*
+ * @count is the count of every non-NULL element in the ->slots array
+ * whether that is a value entry, a retry entry, a user pointer,
+ * a sibling entry or a pointer to the next level of the tree.
+ * @nr_values is the count of every element in ->slots which is
+ * either a value entry or a sibling of a value entry.
+ */
+struct xa_node {
+        unsigned char   shift;          /* Bits remaining in each slot */
+        unsigned char   offset;         /* Slot offset in parent */
+        unsigned char   count;          /* Total entry count */
+        unsigned char   nr_values;      /* Value entry count */
+        struct xa_node __rcu *parent;   /* NULL at top of tree */
+        struct xarray   *array;         /* The array we belong to */
+        union {
+                struct list_head private_list;  /* For tree user */
+                struct rcu_head rcu_head;       /* Used when freeing node */
+        };
+        void __rcu      *slots[XA_CHUNK_SIZE];
+        union {
+                unsigned long   tags[XA_MAX_MARKS][XA_MARK_LONGS];
+                unsigned long   marks[XA_MAX_MARKS][XA_MARK_LONGS];
+        };
+};
+
+void xa_dump(const struct xarray *);
+void xa_dump_node(const struct xa_node *);
+
+#ifdef XA_DEBUG
+#define XA_BUG_ON(xa, x) do {                                   \
+                if (x) {                                        \
+                        xa_dump(xa);                            \
+                        BUG();                                  \
+                }                                               \
+        } while (0)
+#define XA_NODE_BUG_ON(node, x) do {                            \
+                if (x) {                                        \
+                        if (node) xa_dump_node(node);           \
+                        BUG();                                  \
+                }                                               \
+        } while (0)
+#else
+#define XA_BUG_ON(xa, x)        do { } while (0)
+#define XA_NODE_BUG_ON(node, x) do { } while (0)
+#endif
+
+/* Private */
+static inline void *xa_head(const struct xarray *xa)
+{
+        return rcu_dereference_check(xa->xa_head,
+                                                lockdep_is_held(&xa->xa_lock));
+}
+
+/* Private */
+static inline void *xa_head_locked(const struct xarray *xa)
+{
+        return rcu_dereference_protected(xa->xa_head,
+                                                lockdep_is_held(&xa->xa_lock));
+}
+
+/* Private */
+static inline void *xa_entry(const struct xarray *xa,
+                                const struct xa_node *node, unsigned int offset)
+{
+        XA_NODE_BUG_ON(node, offset >= XA_CHUNK_SIZE);
+        return rcu_dereference_check(node->slots[offset],
+                                                lockdep_is_held(&xa->xa_lock));
+}
+
+/* Private */
+static inline void *xa_entry_locked(const struct xarray *xa,
+                                const struct xa_node *node, unsigned int offset)
+{
+        XA_NODE_BUG_ON(node, offset >= XA_CHUNK_SIZE);
+        return rcu_dereference_protected(node->slots[offset],
+                                                lockdep_is_held(&xa->xa_lock));
+}
+
+/* Private */
+static inline struct xa_node *xa_parent(const struct xarray *xa,
+                                        const struct xa_node *node)
+{
+        return rcu_dereference_check(node->parent,
+                                                lockdep_is_held(&xa->xa_lock));
+}
+
+/* Private */
+static inline struct xa_node *xa_parent_locked(const struct xarray *xa,
+                                        const struct xa_node *node)
+{
+        return rcu_dereference_protected(node->parent,
+                                                lockdep_is_held(&xa->xa_lock));
+}
+
+/* Private */
+static inline void *xa_mk_node(const struct xa_node *node)
+{
+        return (void *)((unsigned long)node | 2);
+}
+
+/* Private */
+static inline struct xa_node *xa_to_node(const void *entry)
+{
+        return (struct xa_node *)((unsigned long)entry - 2);
+}
+
+/* Private */
+static inline bool xa_is_node(const void *entry)
+{
+        return xa_is_internal(entry) && (unsigned long)entry > 4096;
+}
+
+/* Private */
+static inline void *xa_mk_sibling(unsigned int offset)
+{
+        return xa_mk_internal(offset);
+}
+
+/* Private */
+static inline unsigned long xa_to_sibling(const void *entry)
+{
+        return xa_to_internal(entry);
+}
+
+/**
+ * xa_is_sibling() - Is the entry a sibling entry?
+ * @entry: Entry retrieved from the XArray
+ *
+ * Return: %true if the entry is a sibling entry.
+ */
+static inline bool xa_is_sibling(const void *entry)
+{
+        return IS_ENABLED(CONFIG_XARRAY_MULTI) && xa_is_internal(entry) &&
+                (entry < xa_mk_sibling(XA_CHUNK_SIZE - 1));
+}
+
+#define XA_ZERO_ENTRY           xa_mk_internal(256)
+#define XA_RETRY_ENTRY          xa_mk_internal(257)
+
+/**
+ * xa_is_zero() - Is the entry a zero entry?
+ * @entry: Entry retrieved from the XArray
+ *
+ * Return: %true if the entry is a zero entry.
+ */
+static inline bool xa_is_zero(const void *entry)
+{
+        return unlikely(entry == XA_ZERO_ENTRY);
+}
+
+/**
+ * xa_is_retry() - Is the entry a retry entry?
+ * @entry: Entry retrieved from the XArray
+ *
+ * Return: %true if the entry is a retry entry.
+ */
+static inline bool xa_is_retry(const void *entry)
+{
+        return unlikely(entry == XA_RETRY_ENTRY);
+}
+
+/**
+ * typedef xa_update_node_t - A callback function from the XArray.
+ * @node: The node which is being processed
+ *
+ * This function is called every time the XArray updates the count of
+ * present and value entries in a node.  It allows advanced users to
+ * maintain the private_list in the node.
+ *
+ * Context: The xa_lock is held and interrupts may be disabled.
+ *          Implementations should not drop the xa_lock, nor re-enable
+ *          interrupts.
+ */
+typedef void (*xa_update_node_t)(struct xa_node *node);
+
+/*
+ * The xa_state is opaque to its users.  It contains various different pieces
+ * of state involved in the current operation on the XArray.  It should be
+ * declared on the stack and passed between the various internal routines.
+ * The various elements in it should not be accessed directly, but only
+ * through the provided accessor functions.  The below documentation is for
+ * the benefit of those working on the code, not for users of the XArray.
+ *
+ * @xa_node usually points to the xa_node containing the slot we're operating
+ * on (and @xa_offset is the offset in the slots array).  If there is a
+ * single entry in the array at index 0, there are no allocated xa_nodes to
+ * point to, and so we store %NULL in @xa_node.  @xa_node is set to
+ * the value %XAS_RESTART if the xa_state is not walked to the correct
+ * position in the tree of nodes for this operation.  If an error occurs
+ * during an operation, it is set to an %XAS_ERROR value.  If we run off the
+ * end of the allocated nodes, it is set to %XAS_BOUNDS.
+ */
+struct xa_state {
+        struct xarray *xa;
+        unsigned long xa_index;
+        unsigned char xa_shift;
+        unsigned char xa_sibs;
+        unsigned char xa_offset;
+        unsigned char xa_pad;           /* Helps gcc generate better code */
+        struct xa_node *xa_node;
+        struct xa_node *xa_alloc;
+        xa_update_node_t xa_update;
+};
+
+/*
+ * We encode errnos in the xas->xa_node.  If an error has happened, we need to
+ * drop the lock to fix it, and once we've done so the xa_state is invalid.
+ */
+#define XA_ERROR(errno) ((struct xa_node *)(((unsigned long)errno << 2) | 2UL))
+#define XAS_BOUNDS      ((struct xa_node *)1UL)
+#define XAS_RESTART     ((struct xa_node *)3UL)
+
+#define __XA_STATE(array, index, shift, sibs)  {        \
+        .xa = array,                                    \
+        .xa_index = index,                              \
+        .xa_shift = shift,                              \
+        .xa_sibs = sibs,                                \
+        .xa_offset = 0,                                 \
+        .xa_pad = 0,                                    \
+        .xa_node = XAS_RESTART,                         \
+        .xa_alloc = NULL,                               \
+        .xa_update = NULL                               \
+}
+
+/**
+ * XA_STATE() - Declare an XArray operation state.
+ * @name: Name of this operation state (usually xas).
+ * @array: Array to operate on.
+ * @index: Initial index of interest.
+ *
+ * Declare and initialise an xa_state on the stack.
+ */
+#define XA_STATE(name, array, index)                            \
+        struct xa_state name = __XA_STATE(array, index, 0, 0)
+
+/**
+ * XA_STATE_ORDER() - Declare an XArray operation state.
+ * @name: Name of this operation state (usually xas).
+ * @array: Array to operate on.
+ * @index: Initial index of interest.
+ * @order: Order of entry.
+ *
+ * Declare and initialise an xa_state on the stack.  This variant of
+ * XA_STATE() allows you to specify the 'order' of the element you
+ * want to operate on.`
+ */
+#define XA_STATE_ORDER(name, array, index, order)               \
+        struct xa_state name = __XA_STATE(array,                \
+                        (index >> order) << order,              \
+                        order - (order % XA_CHUNK_SHIFT),       \
+                        (1U << (order % XA_CHUNK_SHIFT)) - 1)
+
+#define xas_marked(xas, mark)   xa_marked((xas)->xa, (mark))
+#define xas_trylock(xas)        xa_trylock((xas)->xa)
+#define xas_lock(xas)           xa_lock((xas)->xa)
+#define xas_unlock(xas)         xa_unlock((xas)->xa)
+#define xas_lock_bh(xas)        xa_lock_bh((xas)->xa)
+#define xas_unlock_bh(xas)      xa_unlock_bh((xas)->xa)
+#define xas_lock_irq(xas)       xa_lock_irq((xas)->xa)
+#define xas_unlock_irq(xas)     xa_unlock_irq((xas)->xa)
+#define xas_lock_irqsave(xas, flags) \
+                                xa_lock_irqsave((xas)->xa, flags)
+#define xas_unlock_irqrestore(xas, flags) \
+                                xa_unlock_irqrestore((xas)->xa, flags)
+
+/**
+ * xas_error() - Return an errno stored in the xa_state.
+ * @xas: XArray operation state.
+ *
+ * Return: 0 if no error has been noted.  A negative errno if one has.
+ */
+static inline int xas_error(const struct xa_state *xas)
+{
+        return xa_err(xas->xa_node);
+}
+
+/**
+ * xas_set_err() - Note an error in the xa_state.
+ * @xas: XArray operation state.
+ * @err: Negative error number.
+ *
+ * Only call this function with a negative @err; zero or positive errors
+ * will probably not behave the way you think they should.  If you want
+ * to clear the error from an xa_state, use xas_reset().
+ */
+static inline void xas_set_err(struct xa_state *xas, long err)
+{
+        xas->xa_node = XA_ERROR(err);
+}
+
+/**
+ * xas_invalid() - Is the xas in a retry or error state?
+ * @xas: XArray operation state.
+ *
+ * Return: %true if the xas cannot be used for operations.
+ */
+static inline bool xas_invalid(const struct xa_state *xas)
+{
+        return (unsigned long)xas->xa_node & 3;
+}
+
+/**
+ * xas_valid() - Is the xas a valid cursor into the array?
+ * @xas: XArray operation state.
+ *
+ * Return: %true if the xas can be used for operations.
+ */
+static inline bool xas_valid(const struct xa_state *xas)
+{
+        return !xas_invalid(xas);
+}
+
+/**
+ * xas_is_node() - Does the xas point to a node?
+ * @xas: XArray operation state.
+ *
+ * Return: %true if the xas currently references a node.
+ */
+static inline bool xas_is_node(const struct xa_state *xas)
+{
+        return xas_valid(xas) && xas->xa_node;
+}
+
+/* True if the pointer is something other than a node */
+static inline bool xas_not_node(struct xa_node *node)
+{
+        return ((unsigned long)node & 3) || !node;
+}
+
+/* True if the node represents RESTART or an error */
+static inline bool xas_frozen(struct xa_node *node)
+{
+        return (unsigned long)node & 2;
+}
+
+/* True if the node represents head-of-tree, RESTART or BOUNDS */
+static inline bool xas_top(struct xa_node *node)
+{
+        return node <= XAS_RESTART;
+}
+
+/**
+ * xas_reset() - Reset an XArray operation state.
+ * @xas: XArray operation state.
+ *
+ * Resets the error or walk state of the @xas so future walks of the
+ * array will start from the root.  Use this if you have dropped the
+ * xarray lock and want to reuse the xa_state.
+ *
+ * Context: Any context.
+ */
+static inline void xas_reset(struct xa_state *xas)
+{
+        xas->xa_node = XAS_RESTART;
+}
+
+/**
+ * xas_retry() - Retry the operation if appropriate.
+ * @xas: XArray operation state.
+ * @entry: Entry from xarray.
+ *
+ * The advanced functions may sometimes return an internal entry, such as
+ * a retry entry or a zero entry.  This function sets up the @xas to restart
+ * the walk from the head of the array if needed.
+ *
+ * Context: Any context.
+ * Return: true if the operation needs to be retried.
+ */
+static inline bool xas_retry(struct xa_state *xas, const void *entry)
+{
+        if (xa_is_zero(entry))
+                return true;
+        if (!xa_is_retry(entry))
+                return false;
+        xas_reset(xas);
+        return true;
+}
+
+void *xas_load(struct xa_state *);
+void *xas_store(struct xa_state *, void *entry);
+void *xas_find(struct xa_state *, unsigned long max);
+void *xas_find_conflict(struct xa_state *);
+
+bool xas_get_mark(const struct xa_state *, xa_mark_t);
+void xas_set_mark(const struct xa_state *, xa_mark_t);
+void xas_clear_mark(const struct xa_state *, xa_mark_t);
+void *xas_find_marked(struct xa_state *, unsigned long max, xa_mark_t);
+void xas_init_marks(const struct xa_state *);
+
+bool xas_nomem(struct xa_state *, gfp_t);
+void xas_pause(struct xa_state *);
+
+void xas_create_range(struct xa_state *);
+
+/**
+ * xas_reload() - Refetch an entry from the xarray.
+ * @xas: XArray operation state.
+ *
+ * Use this function to check that a previously loaded entry still has
+ * the same value.  This is useful for the lockless pagecache lookup where
+ * we walk the array with only the RCU lock to protect us, lock the page,
+ * then check that the page hasn't moved since we looked it up.
+ *
+ * The caller guarantees that @xas is still valid.  If it may be in an
+ * error or restart state, call xas_load() instead.
+ *
+ * Return: The entry at this location in the xarray.
+ */
+static inline void *xas_reload(struct xa_state *xas)
+{
+        struct xa_node *node = xas->xa_node;
+
+        if (node)
+                return xa_entry(xas->xa, node, xas->xa_offset);
+        return xa_head(xas->xa);
+}
+
+/**
+ * xas_set() - Set up XArray operation state for a different index.
+ * @xas: XArray operation state.
+ * @index: New index into the XArray.
+ *
+ * Move the operation state to refer to a different index.  This will
+ * have the effect of starting a walk from the top; see xas_next()
+ * to move to an adjacent index.
+ */
+static inline void xas_set(struct xa_state *xas, unsigned long index)
+{
+        xas->xa_index = index;
+        xas->xa_node = XAS_RESTART;
+}
+
+/**
+ * xas_set_order() - Set up XArray operation state for a multislot entry.
+ * @xas: XArray operation state.
+ * @index: Target of the operation.
+ * @order: Entry occupies 2^@order indices.
+ */
+static inline void xas_set_order(struct xa_state *xas, unsigned long index,
+                                        unsigned int order)
+{
+#ifdef CONFIG_XARRAY_MULTI
+        xas->xa_index = order < BITS_PER_LONG ? (index >> order) << order : 0;
+        xas->xa_shift = order - (order % XA_CHUNK_SHIFT);
+        xas->xa_sibs = (1 << (order % XA_CHUNK_SHIFT)) - 1;
+        xas->xa_node = XAS_RESTART;
+#else
+        BUG_ON(order > 0);
+        xas_set(xas, index);
+#endif
+}
+
+/**
+ * xas_set_update() - Set up XArray operation state for a callback.
+ * @xas: XArray operation state.
+ * @update: Function to call when updating a node.
+ *
+ * The XArray can notify a caller after it has updated an xa_node.
+ * This is advanced functionality and is only needed by the page cache.
+ */
+static inline void xas_set_update(struct xa_state *xas, xa_update_node_t update)
+{
+        xas->xa_update = update;
+}
+
+/**
+ * xas_next_entry() - Advance iterator to next present entry.
+ * @xas: XArray operation state.
+ * @max: Highest index to return.
+ *
+ * xas_next_entry() is an inline function to optimise xarray traversal for
+ * speed.  It is equivalent to calling xas_find(), and will call xas_find()
+ * for all the hard cases.
+ *
+ * Return: The next present entry after the one currently referred to by @xas.
+ */
+static inline void *xas_next_entry(struct xa_state *xas, unsigned long max)
+{
+        struct xa_node *node = xas->xa_node;
+        void *entry;
+
+        if (unlikely(xas_not_node(node) || node->shift ||
+                        xas->xa_offset != (xas->xa_index & XA_CHUNK_MASK)))
+                return xas_find(xas, max);
+
+        do {
+                if (unlikely(xas->xa_index >= max))
+                        return xas_find(xas, max);
+                if (unlikely(xas->xa_offset == XA_CHUNK_MASK))
+                        return xas_find(xas, max);
+                entry = xa_entry(xas->xa, node, xas->xa_offset + 1);
+                if (unlikely(xa_is_internal(entry)))
+                        return xas_find(xas, max);
+                xas->xa_offset++;
+                xas->xa_index++;
+        } while (!entry);
+
+        return entry;
+}
+
+/* Private */
+static inline unsigned int xas_find_chunk(struct xa_state *xas, bool advance,
+                xa_mark_t mark)
+{
+        unsigned long *addr = xas->xa_node->marks[(__force unsigned)mark];
+        unsigned int offset = xas->xa_offset;
+
+        if (advance)
+                offset++;
+        if (XA_CHUNK_SIZE == BITS_PER_LONG) {
+                if (offset < XA_CHUNK_SIZE) {
+                        unsigned long data = *addr & (~0UL << offset);
+                        if (data)
+                                return __ffs(data);
+                }
+                return XA_CHUNK_SIZE;
+        }
+
+        return find_next_bit(addr, XA_CHUNK_SIZE, offset);
+}
+
+/**
+ * xas_next_marked() - Advance iterator to next marked entry.
+ * @xas: XArray operation state.
+ * @max: Highest index to return.
+ * @mark: Mark to search for.
+ *
+ * xas_next_marked() is an inline function to optimise xarray traversal for
+ * speed.  It is equivalent to calling xas_find_marked(), and will call
+ * xas_find_marked() for all the hard cases.
+ *
+ * Return: The next marked entry after the one currently referred to by @xas.
+ */
+static inline void *xas_next_marked(struct xa_state *xas, unsigned long max,
+                                                                xa_mark_t mark)
+{
+        struct xa_node *node = xas->xa_node;
+        unsigned int offset;
+
+        if (unlikely(xas_not_node(node) || node->shift))
+                return xas_find_marked(xas, max, mark);
+        offset = xas_find_chunk(xas, true, mark);
+        xas->xa_offset = offset;
+        xas->xa_index = (xas->xa_index & ~XA_CHUNK_MASK) + offset;
+        if (xas->xa_index > max)
+                return NULL;
+        if (offset == XA_CHUNK_SIZE)
+                return xas_find_marked(xas, max, mark);
+        return xa_entry(xas->xa, node, offset);
+}
+
+/*
+ * If iterating while holding a lock, drop the lock and reschedule
+ * every %XA_CHECK_SCHED loops.
+ */
+enum {
+        XA_CHECK_SCHED = 4096,
+};
+
+/**
+ * xas_for_each() - Iterate over a range of an XArray.
+ * @xas: XArray operation state.
+ * @entry: Entry retrieved from the array.
+ * @max: Maximum index to retrieve from array.
+ *
+ * The loop body will be executed for each entry present in the xarray
+ * between the current xas position and @max.  @entry will be set to
+ * the entry retrieved from the xarray.  It is safe to delete entries
+ * from the array in the loop body.  You should hold either the RCU lock
+ * or the xa_lock while iterating.  If you need to drop the lock, call
+ * xas_pause() first.
+ */
+#define xas_for_each(xas, entry, max) \
+        for (entry = xas_find(xas, max); entry; \
+             entry = xas_next_entry(xas, max))
+
+/**
+ * xas_for_each_marked() - Iterate over a range of an XArray.
+ * @xas: XArray operation state.
+ * @entry: Entry retrieved from the array.
+ * @max: Maximum index to retrieve from array.
+ * @mark: Mark to search for.
+ *
+ * The loop body will be executed for each marked entry in the xarray
+ * between the current xas position and @max.  @entry will be set to
+ * the entry retrieved from the xarray.  It is safe to delete entries
+ * from the array in the loop body.  You should hold either the RCU lock
+ * or the xa_lock while iterating.  If you need to drop the lock, call
+ * xas_pause() first.
+ */
+#define xas_for_each_marked(xas, entry, max, mark) \
+        for (entry = xas_find_marked(xas, max, mark); entry; \
+             entry = xas_next_marked(xas, max, mark))
+
+/**
+ * xas_for_each_conflict() - Iterate over a range of an XArray.
+ * @xas: XArray operation state.
+ * @entry: Entry retrieved from the array.
+ *
+ * The loop body will be executed for each entry in the XArray that lies
+ * within the range specified by @xas.  If the loop completes successfully,
+ * any entries that lie in this range will be replaced by @entry.  The caller
+ * may break out of the loop; if they do so, the contents of the XArray will
+ * be unchanged.  The operation may fail due to an out of memory condition.
+ * The caller may also call xa_set_err() to exit the loop while setting an
+ * error to record the reason.
+ */
+#define xas_for_each_conflict(xas, entry) \
+        while ((entry = xas_find_conflict(xas)))
+
+void *__xas_next(struct xa_state *);
+void *__xas_prev(struct xa_state *);
+
+/**
+ * xas_prev() - Move iterator to previous index.
+ * @xas: XArray operation state.
+ *
+ * If the @xas was in an error state, it will remain in an error state
+ * and this function will return %NULL.  If the @xas has never been walked,
+ * it will have the effect of calling xas_load().  Otherwise one will be
+ * subtracted from the index and the state will be walked to the correct
+ * location in the array for the next operation.
+ *
+ * If the iterator was referencing index 0, this function wraps
+ * around to %ULONG_MAX.
+ *
+ * Return: The entry at the new index.  This may be %NULL or an internal
+ * entry.
+ */
+static inline void *xas_prev(struct xa_state *xas)
+{
+        struct xa_node *node = xas->xa_node;
+
+        if (unlikely(xas_not_node(node) || node->shift ||
+                                xas->xa_offset == 0))
+                return __xas_prev(xas);
+
+        xas->xa_index--;
+        xas->xa_offset--;
+        return xa_entry(xas->xa, node, xas->xa_offset);
+}
+
+/**
+ * xas_next() - Move state to next index.
+ * @xas: XArray operation state.
+ *
+ * If the @xas was in an error state, it will remain in an error state
+ * and this function will return %NULL.  If the @xas has never been walked,
+ * it will have the effect of calling xas_load().  Otherwise one will be
+ * added to the index and the state will be walked to the correct
+ * location in the array for the next operation.
+ *
+ * If the iterator was referencing index %ULONG_MAX, this function wraps
+ * around to 0.
+ *
+ * Return: The entry at the new index.  This may be %NULL or an internal
+ * entry.
+ */
+static inline void *xas_next(struct xa_state *xas)
+{
+        struct xa_node *node = xas->xa_node;
+
+        if (unlikely(xas_not_node(node) || node->shift ||
+                                xas->xa_offset == XA_CHUNK_MASK))
+                return __xas_next(xas);
+
+        xas->xa_index++;
+        xas->xa_offset++;
+        return xa_entry(xas->xa, node, xas->xa_offset);
+}
+
 #endif /* _LINUX_XARRAY_H */