598 files changed, 5003 insertions, 3287 deletions

diff --git a/drivers/acpi/Kconfig b/drivers/acpi/Kconfig
index 7b65a807b3dd..90ff0a47c12e 100644
--- a/drivers/acpi/Kconfig
+++ b/drivers/acpi/Kconfig
@@ -10,6 +10,7 @@ menuconfig ACPI
         bool "ACPI (Advanced Configuration and Power Interface) Support"
         depends on ARCH_SUPPORTS_ACPI
         select PNP
+        select NLS
         default y if X86
         help
           Advanced Configuration and Power Interface (ACPI) support for 
diff --git a/drivers/acpi/Makefile b/drivers/acpi/Makefile
index 7c6afc111d76..bb857421c2e8 100644
--- a/drivers/acpi/Makefile
+++ b/drivers/acpi/Makefile
@@ -41,7 +41,8 @@ acpi-y				+= ec.o
 acpi-$(CONFIG_ACPI_DOCK)        += dock.o
 acpi-$(CONFIG_PCI)              += pci_root.o pci_link.o pci_irq.o
 obj-$(CONFIG_ACPI_MCFG)         += pci_mcfg.o
-acpi-y                          += acpi_lpss.o acpi_apd.o
+acpi-$(CONFIG_PCI)              += acpi_lpss.o
+acpi-y                          += acpi_apd.o
 acpi-y                          += acpi_platform.o
 acpi-y                          += acpi_pnp.o
 acpi-$(CONFIG_ARM_AMBA) += acpi_amba.o
diff --git a/drivers/acpi/arm64/iort.c b/drivers/acpi/arm64/iort.c
index fdd90ffceb85..e48894e002ba 100644
--- a/drivers/acpi/arm64/iort.c
+++ b/drivers/acpi/arm64/iort.c
@@ -876,7 +876,7 @@ int iort_iommu_msi_get_resv_regions(struct device *dev, struct list_head *head)
         return (resv == its->its_count) ? resv : -ENODEV;
 }
 #else
-static inline const struct iommu_ops *iort_fwspec_iommu_ops(struct device *dev);
+static inline const struct iommu_ops *iort_fwspec_iommu_ops(struct device *dev)
 { return NULL; }
 static inline int iort_add_device_replay(const struct iommu_ops *ops,
                                          struct device *dev)
@@ -952,9 +952,10 @@ static int rc_dma_get_range(struct device *dev, u64 *size)
 {
         struct acpi_iort_node *node;
         struct acpi_iort_root_complex *rc;
+        struct pci_bus *pbus = to_pci_dev(dev)->bus;
 
         node = iort_scan_node(ACPI_IORT_NODE_PCI_ROOT_COMPLEX,
-                              iort_match_node_callback, dev);
+                              iort_match_node_callback, &pbus->dev);
         if (!node || node->revision < 1)
                 return -ENODEV;
 
diff --git a/drivers/acpi/bus.c b/drivers/acpi/bus.c
index 99d820a693a8..5c093ce01bcd 100644
--- a/drivers/acpi/bus.c
+++ b/drivers/acpi/bus.c
@@ -1054,18 +1054,6 @@ void __init acpi_early_init(void)
                 goto error0;
         }
 
-        /*
-         * ACPI 2.0 requires the EC driver to be loaded and work before
-         * the EC device is found in the namespace (i.e. before
-         * acpi_load_tables() is called).
-         *
-         * This is accomplished by looking for the ECDT table, and getting
-         * the EC parameters out of that.
-         *
-         * Ignore the result. Not having an ECDT is not fatal.
-         */
-        status = acpi_ec_ecdt_probe();
-
 #ifdef CONFIG_X86
         if (!acpi_ioapic) {
                 /* compatible (0) means level (3) */
@@ -1142,6 +1130,18 @@ static int __init acpi_bus_init(void)
                 goto error1;
         }
 
+        /*
+         * ACPI 2.0 requires the EC driver to be loaded and work before the EC
+         * device is found in the namespace.
+         *
+         * This is accomplished by looking for the ECDT table and getting the EC
+         * parameters out of that.
+         *
+         * Do that before calling acpi_initialize_objects() which may trigger EC
+         * address space accesses.
+         */
+        acpi_ec_ecdt_probe();
+
         status = acpi_enable_subsystem(ACPI_NO_ACPI_ENABLE);
         if (ACPI_FAILURE(status)) {
                 printk(KERN_ERR PREFIX
diff --git a/drivers/acpi/internal.h b/drivers/acpi/internal.h
index 7e6952edb5b0..6a9e1fb8913a 100644
--- a/drivers/acpi/internal.h
+++ b/drivers/acpi/internal.h
@@ -81,7 +81,11 @@ void acpi_debugfs_init(void);
 #else
 static inline void acpi_debugfs_init(void) { return; }
 #endif
+#ifdef CONFIG_PCI
 void acpi_lpss_init(void);
+#else
+static inline void acpi_lpss_init(void) {}
+#endif
 
 void acpi_apd_init(void);
 
diff --git a/drivers/acpi/nfit/core.c b/drivers/acpi/nfit/core.c
index 011d3db19c80..e18ade5d74e9 100644
--- a/drivers/acpi/nfit/core.c
+++ b/drivers/acpi/nfit/core.c
@@ -26,7 +26,6 @@
 #include <acpi/nfit.h>
 #include "intel.h"
 #include "nfit.h"
-#include "intel.h"
 
 /*
  * For readq() and writeq() on 32-bit builds, the hi-lo, lo-hi order is
@@ -78,12 +77,6 @@ const guid_t *to_nfit_uuid(enum nfit_uuids id)
 }
 EXPORT_SYMBOL(to_nfit_uuid);
 
-static struct acpi_nfit_desc *to_acpi_nfit_desc(
-                struct nvdimm_bus_descriptor *nd_desc)
-{
-        return container_of(nd_desc, struct acpi_nfit_desc, nd_desc);
-}
-
 static struct acpi_device *to_acpi_dev(struct acpi_nfit_desc *acpi_desc)
 {
         struct nvdimm_bus_descriptor *nd_desc = &acpi_desc->nd_desc;
@@ -416,10 +409,36 @@ static bool payload_dumpable(struct nvdimm *nvdimm, unsigned int func)
         return true;
 }
 
+static int cmd_to_func(struct nfit_mem *nfit_mem, unsigned int cmd,
+                struct nd_cmd_pkg *call_pkg)
+{
+        if (call_pkg) {
+                int i;
+
+                if (nfit_mem->family != call_pkg->nd_family)
+                        return -ENOTTY;
+
+                for (i = 0; i < ARRAY_SIZE(call_pkg->nd_reserved2); i++)
+                        if (call_pkg->nd_reserved2[i])
+                                return -EINVAL;
+                return call_pkg->nd_command;
+        }
+
+        /* Linux ND commands == NVDIMM_FAMILY_INTEL function numbers */
+        if (nfit_mem->family == NVDIMM_FAMILY_INTEL)
+                return cmd;
+
+        /*
+         * Force function number validation to fail since 0 is never
+         * published as a valid function in dsm_mask.
+         */
+        return 0;
+}
+
 int acpi_nfit_ctl(struct nvdimm_bus_descriptor *nd_desc, struct nvdimm *nvdimm,
                 unsigned int cmd, void *buf, unsigned int buf_len, int *cmd_rc)
 {
-        struct acpi_nfit_desc *acpi_desc = to_acpi_nfit_desc(nd_desc);
+        struct acpi_nfit_desc *acpi_desc = to_acpi_desc(nd_desc);
         struct nfit_mem *nfit_mem = nvdimm_provider_data(nvdimm);
         union acpi_object in_obj, in_buf, *out_obj;
         const struct nd_cmd_desc *desc = NULL;
@@ -429,30 +448,23 @@ int acpi_nfit_ctl(struct nvdimm_bus_descriptor *nd_desc, struct nvdimm *nvdimm,
         unsigned long cmd_mask, dsm_mask;
         u32 offset, fw_status = 0;
         acpi_handle handle;
-        unsigned int func;
         const guid_t *guid;
-        int rc, i;
+        int func, rc, i;
 
         if (cmd_rc)
                 *cmd_rc = -EINVAL;
-        func = cmd;
-        if (cmd == ND_CMD_CALL) {
-                call_pkg = buf;
-                func = call_pkg->nd_command;
-
-                for (i = 0; i < ARRAY_SIZE(call_pkg->nd_reserved2); i++)
-                        if (call_pkg->nd_reserved2[i])
-                                return -EINVAL;
-        }
 
         if (nvdimm) {
                 struct acpi_device *adev = nfit_mem->adev;
 
                 if (!adev)
                         return -ENOTTY;
-                if (call_pkg && nfit_mem->family != call_pkg->nd_family)
-                        return -ENOTTY;
 
+                if (cmd == ND_CMD_CALL)
+                        call_pkg = buf;
+                func = cmd_to_func(nfit_mem, cmd, call_pkg);
+                if (func < 0)
+                        return func;
                 dimm_name = nvdimm_name(nvdimm);
                 cmd_name = nvdimm_cmd_name(cmd);
                 cmd_mask = nvdimm_cmd_mask(nvdimm);
@@ -463,6 +475,7 @@ int acpi_nfit_ctl(struct nvdimm_bus_descriptor *nd_desc, struct nvdimm *nvdimm,
         } else {
                 struct acpi_device *adev = to_acpi_dev(acpi_desc);
 
+                func = cmd;
                 cmd_name = nvdimm_bus_cmd_name(cmd);
                 cmd_mask = nd_desc->cmd_mask;
                 dsm_mask = cmd_mask;
@@ -477,7 +490,13 @@ int acpi_nfit_ctl(struct nvdimm_bus_descriptor *nd_desc, struct nvdimm *nvdimm,
         if (!desc || (cmd && (desc->out_num + desc->in_num == 0)))
                 return -ENOTTY;
 
-        if (!test_bit(cmd, &cmd_mask) || !test_bit(func, &dsm_mask))
+        /*
+         * Check for a valid command.  For ND_CMD_CALL, we also have to
+         * make sure that the DSM function is supported.
+         */
+        if (cmd == ND_CMD_CALL && !test_bit(func, &dsm_mask))
+                return -ENOTTY;
+        else if (!test_bit(cmd, &cmd_mask))
                 return -ENOTTY;
 
         in_obj.type = ACPI_TYPE_PACKAGE;
@@ -721,6 +740,7 @@ int nfit_get_smbios_id(u32 device_handle, u16 *flags)
         struct acpi_nfit_memory_map *memdev;
         struct acpi_nfit_desc *acpi_desc;
         struct nfit_mem *nfit_mem;
+        u16 physical_id;
 
         mutex_lock(&acpi_desc_lock);
         list_for_each_entry(acpi_desc, &acpi_descs, list) {
@@ -728,10 +748,11 @@ int nfit_get_smbios_id(u32 device_handle, u16 *flags)
                 list_for_each_entry(nfit_mem, &acpi_desc->dimms, list) {
                         memdev = __to_nfit_memdev(nfit_mem);
                         if (memdev->device_handle == device_handle) {
+                                *flags = memdev->flags;
+                                physical_id = memdev->physical_id;
                                 mutex_unlock(&acpi_desc->init_mutex);
                                 mutex_unlock(&acpi_desc_lock);
-                                *flags = memdev->flags;
-                                return memdev->physical_id;
+                                return physical_id;
                         }
                 }
                 mutex_unlock(&acpi_desc->init_mutex);
@@ -1872,6 +1893,13 @@ static int acpi_nfit_add_dimm(struct acpi_nfit_desc *acpi_desc,
                 return 0;
         }
 
+        /*
+         * Function 0 is the command interrogation function, don't
+         * export it to potential userspace use, and enable it to be
+         * used as an error value in acpi_nfit_ctl().
+         */
+        dsm_mask &= ~1UL;
+
         guid = to_nfit_uuid(nfit_mem->family);
         for_each_set_bit(i, &dsm_mask, BITS_PER_LONG)
                 if (acpi_check_dsm(adev_dimm->handle, guid,
@@ -2047,11 +2075,6 @@ static int acpi_nfit_register_dimms(struct acpi_nfit_desc *acpi_desc)
                 if (!nvdimm)
                         continue;
 
-                rc = nvdimm_security_setup_events(nvdimm);
-                if (rc < 0)
-                        dev_warn(acpi_desc->dev,
-                                "security event setup failed: %d\n", rc);
-
                 nfit_kernfs = sysfs_get_dirent(nvdimm_kobj(nvdimm)->sd, "nfit");
                 if (nfit_kernfs)
                         nfit_mem->flags_attr = sysfs_get_dirent(nfit_kernfs,
@@ -2231,7 +2254,6 @@ static int acpi_nfit_init_interleave_set(struct acpi_nfit_desc *acpi_desc,
         nd_set = devm_kzalloc(dev, sizeof(*nd_set), GFP_KERNEL);
         if (!nd_set)
                 return -ENOMEM;
-        ndr_desc->nd_set = nd_set;
         guid_copy(&nd_set->type_guid, (guid_t *) spa->range_guid);
 
         info = devm_kzalloc(dev, sizeof_nfit_set_info(nr), GFP_KERNEL);
@@ -3367,7 +3389,7 @@ EXPORT_SYMBOL_GPL(acpi_nfit_init);
 
 static int acpi_nfit_flush_probe(struct nvdimm_bus_descriptor *nd_desc)
 {
-        struct acpi_nfit_desc *acpi_desc = to_acpi_nfit_desc(nd_desc);
+        struct acpi_nfit_desc *acpi_desc = to_acpi_desc(nd_desc);
         struct device *dev = acpi_desc->dev;
 
         /* Bounce the device lock to flush acpi_nfit_add / acpi_nfit_notify */
@@ -3384,7 +3406,7 @@ static int acpi_nfit_flush_probe(struct nvdimm_bus_descriptor *nd_desc)
 static int __acpi_nfit_clear_to_send(struct nvdimm_bus_descriptor *nd_desc,
                 struct nvdimm *nvdimm, unsigned int cmd)
 {
-        struct acpi_nfit_desc *acpi_desc = to_acpi_nfit_desc(nd_desc);
+        struct acpi_nfit_desc *acpi_desc = to_acpi_desc(nd_desc);
 
         if (nvdimm)
                 return 0;
diff --git a/drivers/acpi/nfit/intel.c b/drivers/acpi/nfit/intel.c
index 850b2927b4e7..f70de71f79d6 100644
--- a/drivers/acpi/nfit/intel.c
+++ b/drivers/acpi/nfit/intel.c
@@ -146,7 +146,7 @@ static int intel_security_change_key(struct nvdimm *nvdimm,
 
 static void nvdimm_invalidate_cache(void);
 
-static int intel_security_unlock(struct nvdimm *nvdimm,
+static int __maybe_unused intel_security_unlock(struct nvdimm *nvdimm,
                 const struct nvdimm_key_data *key_data)
 {
         struct nfit_mem *nfit_mem = nvdimm_provider_data(nvdimm);
@@ -227,7 +227,7 @@ static int intel_security_disable(struct nvdimm *nvdimm,
         return 0;
 }
 
-static int intel_security_erase(struct nvdimm *nvdimm,
+static int __maybe_unused intel_security_erase(struct nvdimm *nvdimm,
                 const struct nvdimm_key_data *key,
                 enum nvdimm_passphrase_type ptype)
 {
@@ -276,7 +276,7 @@ static int intel_security_erase(struct nvdimm *nvdimm,
         return 0;
 }
 
-static int intel_security_query_overwrite(struct nvdimm *nvdimm)
+static int __maybe_unused intel_security_query_overwrite(struct nvdimm *nvdimm)
 {
         int rc;
         struct nfit_mem *nfit_mem = nvdimm_provider_data(nvdimm);
@@ -313,7 +313,7 @@ static int intel_security_query_overwrite(struct nvdimm *nvdimm)
         return 0;
 }
 
-static int intel_security_overwrite(struct nvdimm *nvdimm,
+static int __maybe_unused intel_security_overwrite(struct nvdimm *nvdimm,
                 const struct nvdimm_key_data *nkey)
 {
         int rc;
diff --git a/drivers/acpi/numa.c b/drivers/acpi/numa.c
index 274699463b4f..7bbbf8256a41 100644
--- a/drivers/acpi/numa.c
+++ b/drivers/acpi/numa.c
@@ -146,9 +146,9 @@ acpi_table_print_srat_entry(struct acpi_subtable_header *header)
                 {
                         struct acpi_srat_mem_affinity *p =
                             (struct acpi_srat_mem_affinity *)header;
-                        pr_debug("SRAT Memory (0x%lx length 0x%lx) in proximity domain %d %s%s%s\n",
-                                 (unsigned long)p->base_address,
-                                 (unsigned long)p->length,
+                        pr_debug("SRAT Memory (0x%llx length 0x%llx) in proximity domain %d %s%s%s\n",
+                                 (unsigned long long)p->base_address,
+                                 (unsigned long long)p->length,
                                  p->proximity_domain,
                                  (p->flags & ACPI_SRAT_MEM_ENABLED) ?
                                  "enabled" : "disabled",
diff --git a/drivers/acpi/pmic/intel_pmic_xpower.c b/drivers/acpi/pmic/intel_pmic_xpower.c
index 2579675b7082..e7c0006e6602 100644
--- a/drivers/acpi/pmic/intel_pmic_xpower.c
+++ b/drivers/acpi/pmic/intel_pmic_xpower.c
@@ -20,8 +20,11 @@
 #define GPI1_LDO_ON             (3 << 0)
 #define GPI1_LDO_OFF            (4 << 0)
 
-#define AXP288_ADC_TS_PIN_GPADC 0xf2
-#define AXP288_ADC_TS_PIN_ON    0xf3
+#define AXP288_ADC_TS_CURRENT_ON_OFF_MASK               GENMASK(1, 0)
+#define AXP288_ADC_TS_CURRENT_OFF                       (0 << 0)
+#define AXP288_ADC_TS_CURRENT_ON_WHEN_CHARGING          (1 << 0)
+#define AXP288_ADC_TS_CURRENT_ON_ONDEMAND               (2 << 0)
+#define AXP288_ADC_TS_CURRENT_ON                        (3 << 0)
 
 static struct pmic_table power_table[] = {
         {
@@ -212,22 +215,44 @@ out:
  */
 static int intel_xpower_pmic_get_raw_temp(struct regmap *regmap, int reg)
 {
+        int ret, adc_ts_pin_ctrl;
         u8 buf[2];
-        int ret;
 
-        ret = regmap_write(regmap, AXP288_ADC_TS_PIN_CTRL,
-                           AXP288_ADC_TS_PIN_GPADC);
+        /*
+         * The current-source used for the battery temp-sensor (TS) is shared
+         * with the GPADC. For proper fuel-gauge and charger operation the TS
+         * current-source needs to be permanently on. But to read the GPADC we
+         * need to temporary switch the TS current-source to ondemand, so that
+         * the GPADC can use it, otherwise we will always read an all 0 value.
+         *
+         * Note that the switching from on to on-ondemand is not necessary
+         * when the TS current-source is off (this happens on devices which
+         * do not use the TS-pin).
+         */
+        ret = regmap_read(regmap, AXP288_ADC_TS_PIN_CTRL, &adc_ts_pin_ctrl);
         if (ret)
                 return ret;
 
-        /* After switching to the GPADC pin give things some time to settle */
-        usleep_range(6000, 10000);
+        if (adc_ts_pin_ctrl & AXP288_ADC_TS_CURRENT_ON_OFF_MASK) {
+                ret = regmap_update_bits(regmap, AXP288_ADC_TS_PIN_CTRL,
+                                         AXP288_ADC_TS_CURRENT_ON_OFF_MASK,
+                                         AXP288_ADC_TS_CURRENT_ON_ONDEMAND);
+                if (ret)
+                        return ret;
+
+                /* Wait a bit after switching the current-source */
+                usleep_range(6000, 10000);
+        }
 
         ret = regmap_bulk_read(regmap, AXP288_GP_ADC_H, buf, 2);
         if (ret == 0)
                 ret = (buf[0] << 4) + ((buf[1] >> 4) & 0x0f);
 
-        regmap_write(regmap, AXP288_ADC_TS_PIN_CTRL, AXP288_ADC_TS_PIN_ON);
+        if (adc_ts_pin_ctrl & AXP288_ADC_TS_CURRENT_ON_OFF_MASK) {
+                regmap_update_bits(regmap, AXP288_ADC_TS_PIN_CTRL,
+                                   AXP288_ADC_TS_CURRENT_ON_OFF_MASK,
+                                   AXP288_ADC_TS_CURRENT_ON);
+        }
 
         return ret;
 }
diff --git a/drivers/acpi/power.c b/drivers/acpi/power.c
index 1b475bc1ae16..665e93ca0b40 100644
--- a/drivers/acpi/power.c
+++ b/drivers/acpi/power.c
@@ -131,6 +131,23 @@ void acpi_power_resources_list_free(struct list_head *list)
         }
 }
 
+static bool acpi_power_resource_is_dup(union acpi_object *package,
+                                       unsigned int start, unsigned int i)
+{
+        acpi_handle rhandle, dup;
+        unsigned int j;
+
+        /* The caller is expected to check the package element types */
+        rhandle = package->package.elements[i].reference.handle;
+        for (j = start; j < i; j++) {
+                dup = package->package.elements[j].reference.handle;
+                if (dup == rhandle)
+                        return true;
+        }
+
+        return false;
+}
+
 int acpi_extract_power_resources(union acpi_object *package, unsigned int start,
                                  struct list_head *list)
 {
@@ -150,6 +167,11 @@ int acpi_extract_power_resources(union acpi_object *package, unsigned int start,
                         err = -ENODEV;
                         break;
                 }
+
+                /* Some ACPI tables contain duplicate power resource references */
+                if (acpi_power_resource_is_dup(package, start, i))
+                        continue;
+
                 err = acpi_add_power_resource(rhandle);
                 if (err)
                         break;
diff --git a/drivers/android/binderfs.c b/drivers/android/binderfs.c
index 7496b10532aa..6a2185eb66c5 100644
--- a/drivers/android/binderfs.c
+++ b/drivers/android/binderfs.c
@@ -11,6 +11,7 @@
 #include <linux/kdev_t.h>
 #include <linux/kernel.h>
 #include <linux/list.h>
+#include <linux/namei.h>
 #include <linux/magic.h>
 #include <linux/major.h>
 #include <linux/miscdevice.h>
@@ -20,6 +21,7 @@
 #include <linux/parser.h>
 #include <linux/radix-tree.h>
 #include <linux/sched.h>
+#include <linux/seq_file.h>
 #include <linux/slab.h>
 #include <linux/spinlock_types.h>
 #include <linux/stddef.h>
@@ -30,7 +32,7 @@
 #include <linux/xarray.h>
 #include <uapi/asm-generic/errno-base.h>
 #include <uapi/linux/android/binder.h>
-#include <uapi/linux/android/binder_ctl.h>
+#include <uapi/linux/android/binderfs.h>
 
 #include "binder_internal.h"
 
@@ -39,14 +41,32 @@
 #define INODE_OFFSET 3
 #define INTSTRLEN 21
 #define BINDERFS_MAX_MINOR (1U << MINORBITS)
-
-static struct vfsmount *binderfs_mnt;
+/* Ensure that the initial ipc namespace always has devices available. */
+#define BINDERFS_MAX_MINOR_CAPPED (BINDERFS_MAX_MINOR - 4)
 
 static dev_t binderfs_dev;
 static DEFINE_MUTEX(binderfs_minors_mutex);
 static DEFINE_IDA(binderfs_minors);
 
 /**
+ * binderfs_mount_opts - mount options for binderfs
+ * @max: maximum number of allocatable binderfs binder devices
+ */
+struct binderfs_mount_opts {
+        int max;
+};
+
+enum {
+        Opt_max,
+        Opt_err
+};
+
+static const match_table_t tokens = {
+        { Opt_max, "max=%d" },
+        { Opt_err, NULL     }
+};
+
+/**
  * binderfs_info - information about a binderfs mount
  * @ipc_ns:         The ipc namespace the binderfs mount belongs to.
  * @control_dentry: This records the dentry of this binderfs mount
@@ -55,13 +75,16 @@ static DEFINE_IDA(binderfs_minors);
  *                  created.
  * @root_gid:       gid that needs to be used when a new binder device is
  *                  created.
+ * @mount_opts:     The mount options in use.
+ * @device_count:   The current number of allocated binder devices.
  */
 struct binderfs_info {
         struct ipc_namespace *ipc_ns;
         struct dentry *control_dentry;
         kuid_t root_uid;
         kgid_t root_gid;
-
+        struct binderfs_mount_opts mount_opts;
+        int device_count;
 };
 
 static inline struct binderfs_info *BINDERFS_I(const struct inode *inode)
@@ -84,7 +107,7 @@ bool is_binderfs_device(const struct inode *inode)
  * @userp:     buffer to copy information about new device for userspace to
  * @req:       struct binderfs_device as copied from userspace
  *
- * This function allocated a new binder_device and reserves a new minor
+ * This function allocates a new binder_device and reserves a new minor
  * number for it.
  * Minor numbers are limited and tracked globally in binderfs_minors. The
  * function will stash a struct binder_device for the specific binder
@@ -100,20 +123,34 @@ static int binderfs_binder_device_create(struct inode *ref_inode,
                                          struct binderfs_device *req)
 {
         int minor, ret;
-        struct dentry *dentry, *dup, *root;
+        struct dentry *dentry, *root;
         struct binder_device *device;
-        size_t name_len = BINDERFS_MAX_NAME + 1;
         char *name = NULL;
+        size_t name_len;
         struct inode *inode = NULL;
         struct super_block *sb = ref_inode->i_sb;
         struct binderfs_info *info = sb->s_fs_info;
+#if defined(CONFIG_IPC_NS)
+        bool use_reserve = (info->ipc_ns == &init_ipc_ns);
+#else
+        bool use_reserve = true;
+#endif
 
         /* Reserve new minor number for the new device. */
         mutex_lock(&binderfs_minors_mutex);
-        minor = ida_alloc_max(&binderfs_minors, BINDERFS_MAX_MINOR, GFP_KERNEL);
-        mutex_unlock(&binderfs_minors_mutex);
-        if (minor < 0)
+        if (++info->device_count <= info->mount_opts.max)
+                minor = ida_alloc_max(&binderfs_minors,
+                                      use_reserve ? BINDERFS_MAX_MINOR :
+                                                    BINDERFS_MAX_MINOR_CAPPED,
+                                      GFP_KERNEL);
+        else
+                minor = -ENOSPC;
+        if (minor < 0) {
+                --info->device_count;
+                mutex_unlock(&binderfs_minors_mutex);
                 return minor;
+        }
+        mutex_unlock(&binderfs_minors_mutex);
 
         ret = -ENOMEM;
         device = kzalloc(sizeof(*device), GFP_KERNEL);
@@ -132,12 +169,13 @@ static int binderfs_binder_device_create(struct inode *ref_inode,
         inode->i_uid = info->root_uid;
         inode->i_gid = info->root_gid;
 
-        name = kmalloc(name_len, GFP_KERNEL);
+        req->name[BINDERFS_MAX_NAME] = '\0'; /* NUL-terminate */
+        name_len = strlen(req->name);
+        /* Make sure to include terminating NUL byte */
+        name = kmemdup(req->name, name_len + 1, GFP_KERNEL);
         if (!name)
                 goto err;
 
-        strscpy(name, req->name, name_len);
-
         device->binderfs_inode = inode;
         device->context.binder_context_mgr_uid = INVALID_UID;
         device->context.name = name;
@@ -156,28 +194,25 @@ static int binderfs_binder_device_create(struct inode *ref_inode,
 
         root = sb->s_root;
         inode_lock(d_inode(root));
-        dentry = d_alloc_name(root, name);
-        if (!dentry) {
+
+        /* look it up */
+        dentry = lookup_one_len(name, root, name_len);
+        if (IS_ERR(dentry)) {
                 inode_unlock(d_inode(root));
-                ret = -ENOMEM;
+                ret = PTR_ERR(dentry);
                 goto err;
         }
 
-        /* Verify that the name userspace gave us is not already in use. */
-        dup = d_lookup(root, &dentry->d_name);
-        if (dup) {
-                if (d_really_is_positive(dup)) {
-                        dput(dup);
-                        dput(dentry);
-                        inode_unlock(d_inode(root));
-                        ret = -EEXIST;
-                        goto err;
-                }
-                dput(dup);
+        if (d_really_is_positive(dentry)) {
+                /* already exists */
+                dput(dentry);
+                inode_unlock(d_inode(root));
+                ret = -EEXIST;
+                goto err;
         }
 
         inode->i_private = device;
-        d_add(dentry, inode);
+        d_instantiate(dentry, inode);
         fsnotify_create(root->d_inode, dentry);
         inode_unlock(d_inode(root));
 
@@ -187,6 +222,7 @@ err:
         kfree(name);
         kfree(device);
         mutex_lock(&binderfs_minors_mutex);
+        --info->device_count;
         ida_free(&binderfs_minors, minor);
         mutex_unlock(&binderfs_minors_mutex);
         iput(inode);
@@ -232,6 +268,7 @@ static long binder_ctl_ioctl(struct file *file, unsigned int cmd,
 static void binderfs_evict_inode(struct inode *inode)
 {
         struct binder_device *device = inode->i_private;
+        struct binderfs_info *info = BINDERFS_I(inode);
 
         clear_inode(inode);
 
@@ -239,6 +276,7 @@ static void binderfs_evict_inode(struct inode *inode)
                 return;
 
         mutex_lock(&binderfs_minors_mutex);
+        --info->device_count;
         ida_free(&binderfs_minors, device->miscdev.minor);
         mutex_unlock(&binderfs_minors_mutex);
 
@@ -246,43 +284,87 @@ static void binderfs_evict_inode(struct inode *inode)
         kfree(device);
 }
 
+/**
+ * binderfs_parse_mount_opts - parse binderfs mount options
+ * @data: options to set (can be NULL in which case defaults are used)
+ */
+static int binderfs_parse_mount_opts(char *data,
+                                     struct binderfs_mount_opts *opts)
+{
+        char *p;
+        opts->max = BINDERFS_MAX_MINOR;
+
+        while ((p = strsep(&data, ",")) != NULL) {
+                substring_t args[MAX_OPT_ARGS];
+                int token;
+                int max_devices;
+
+                if (!*p)
+                        continue;
+
+                token = match_token(p, tokens, args);
+                switch (token) {
+                case Opt_max:
+                        if (match_int(&args[0], &max_devices) ||
+                            (max_devices < 0 ||
+                             (max_devices > BINDERFS_MAX_MINOR)))
+                                return -EINVAL;
+
+                        opts->max = max_devices;
+                        break;
+                default:
+                        pr_err("Invalid mount options\n");
+                        return -EINVAL;
+                }
+        }
+
+        return 0;
+}
+
+static int binderfs_remount(struct super_block *sb, int *flags, char *data)
+{
+        struct binderfs_info *info = sb->s_fs_info;
+        return binderfs_parse_mount_opts(data, &info->mount_opts);
+}
+
+static int binderfs_show_mount_opts(struct seq_file *seq, struct dentry *root)
+{
+        struct binderfs_info *info;
+
+        info = root->d_sb->s_fs_info;
+        if (info->mount_opts.max <= BINDERFS_MAX_MINOR)
+                seq_printf(seq, ",max=%d", info->mount_opts.max);
+
+        return 0;
+}
+
 static const struct super_operations binderfs_super_ops = {
-        .statfs = simple_statfs,
-        .evict_inode = binderfs_evict_inode,
+        .evict_inode    = binderfs_evict_inode,
+        .remount_fs     = binderfs_remount,
+        .show_options   = binderfs_show_mount_opts,
+        .statfs         = simple_statfs,
 };
 
+static inline bool is_binderfs_control_device(const struct dentry *dentry)
+{
+        struct binderfs_info *info = dentry->d_sb->s_fs_info;
+        return info->control_dentry == dentry;
+}
+
 static int binderfs_rename(struct inode *old_dir, struct dentry *old_dentry,
                            struct inode *new_dir, struct dentry *new_dentry,
                            unsigned int flags)
 {
-        struct inode *inode = d_inode(old_dentry);
-
-        /* binderfs doesn't support directories. */
-        if (d_is_dir(old_dentry))
+        if (is_binderfs_control_device(old_dentry) ||
+            is_binderfs_control_device(new_dentry))
                 return -EPERM;
 
-        if (flags & ~RENAME_NOREPLACE)
-                return -EINVAL;
-
-        if (!simple_empty(new_dentry))
-                return -ENOTEMPTY;
-
-        if (d_really_is_positive(new_dentry))
-                simple_unlink(new_dir, new_dentry);
-
-        old_dir->i_ctime = old_dir->i_mtime = new_dir->i_ctime =
-                new_dir->i_mtime = inode->i_ctime = current_time(old_dir);
-
-        return 0;
+        return simple_rename(old_dir, old_dentry, new_dir, new_dentry, flags);
 }
 
 static int binderfs_unlink(struct inode *dir, struct dentry *dentry)
 {
-        /*
-         * The control dentry is only ever touched during mount so checking it
-         * here should not require us to take lock.
-         */
-        if (BINDERFS_I(dir)->control_dentry == dentry)
+        if (is_binderfs_control_device(dentry))
                 return -EPERM;
 
         return simple_unlink(dir, dentry);
@@ -318,8 +400,6 @@ static int binderfs_binder_ctl_create(struct super_block *sb)
         if (!device)
                 return -ENOMEM;
 
-        inode_lock(d_inode(root));
-
         /* If we have already created a binder-control node, return. */
         if (info->control_dentry) {
                 ret = 0;
@@ -358,12 +438,10 @@ static int binderfs_binder_ctl_create(struct super_block *sb)
         inode->i_private = device;
         info->control_dentry = dentry;
         d_add(dentry, inode);
-        inode_unlock(d_inode(root));
 
         return 0;
 
 out:
-        inode_unlock(d_inode(root));
         kfree(device);
         iput(inode);
 
@@ -378,12 +456,9 @@ static const struct inode_operations binderfs_dir_inode_operations = {
 
 static int binderfs_fill_super(struct super_block *sb, void *data, int silent)
 {
+        int ret;
         struct binderfs_info *info;
-        int ret = -ENOMEM;
         struct inode *inode = NULL;
-        struct ipc_namespace *ipc_ns = sb->s_fs_info;
-
-        get_ipc_ns(ipc_ns);
 
         sb->s_blocksize = PAGE_SIZE;
         sb->s_blocksize_bits = PAGE_SHIFT;
@@ -405,11 +480,17 @@ static int binderfs_fill_super(struct super_block *sb, void *data, int silent)
         sb->s_op = &binderfs_super_ops;
         sb->s_time_gran = 1;
 
-        info = kzalloc(sizeof(struct binderfs_info), GFP_KERNEL);
-        if (!info)
-                goto err_without_dentry;
+        sb->s_fs_info = kzalloc(sizeof(struct binderfs_info), GFP_KERNEL);
+        if (!sb->s_fs_info)
+                return -ENOMEM;
+        info = sb->s_fs_info;
+
+        info->ipc_ns = get_ipc_ns(current->nsproxy->ipc_ns);
+
+        ret = binderfs_parse_mount_opts(data, &info->mount_opts);
+        if (ret)
+                return ret;
 
-        info->ipc_ns = ipc_ns;
         info->root_gid = make_kgid(sb->s_user_ns, 0);
         if (!gid_valid(info->root_gid))
                 info->root_gid = GLOBAL_ROOT_GID;
@@ -417,11 +498,9 @@ static int binderfs_fill_super(struct super_block *sb, void *data, int silent)
         if (!uid_valid(info->root_uid))
                 info->root_uid = GLOBAL_ROOT_UID;
 
-        sb->s_fs_info = info;
-
         inode = new_inode(sb);
         if (!inode)
-                goto err_without_dentry;
+                return -ENOMEM;
 
         inode->i_ino = FIRST_INODE;
         inode->i_fop = &simple_dir_operations;
@@ -432,79 +511,28 @@ static int binderfs_fill_super(struct super_block *sb, void *data, int silent)
 
         sb->s_root = d_make_root(inode);
         if (!sb->s_root)
-                goto err_without_dentry;
-
-        ret = binderfs_binder_ctl_create(sb);
-        if (ret)
-                goto err_with_dentry;
-
-        return 0;
-
-err_with_dentry:
-        dput(sb->s_root);
-        sb->s_root = NULL;
-
-err_without_dentry:
-        put_ipc_ns(ipc_ns);
-        iput(inode);
-        kfree(info);
-
-        return ret;
-}
-
-static int binderfs_test_super(struct super_block *sb, void *data)
-{
-        struct binderfs_info *info = sb->s_fs_info;
-
-        if (info)
-                return info->ipc_ns == data;
-
-        return 0;
-}
+                return -ENOMEM;
 
-static int binderfs_set_super(struct super_block *sb, void *data)
-{
-        sb->s_fs_info = data;
-        return set_anon_super(sb, NULL);
+        return binderfs_binder_ctl_create(sb);
 }
 
 static struct dentry *binderfs_mount(struct file_system_type *fs_type,
                                      int flags, const char *dev_name,
                                      void *data)
 {
-        struct super_block *sb;
-        struct ipc_namespace *ipc_ns = current->nsproxy->ipc_ns;
-
-        if (!ns_capable(ipc_ns->user_ns, CAP_SYS_ADMIN))
-                return ERR_PTR(-EPERM);
-
-        sb = sget_userns(fs_type, binderfs_test_super, binderfs_set_super,
-                         flags, ipc_ns->user_ns, ipc_ns);
-        if (IS_ERR(sb))
-                return ERR_CAST(sb);
-
-        if (!sb->s_root) {
-                int ret = binderfs_fill_super(sb, data, flags & SB_SILENT ? 1 : 0);
-                if (ret) {
-                        deactivate_locked_super(sb);
-                        return ERR_PTR(ret);
-                }
-
-                sb->s_flags |= SB_ACTIVE;
-        }
-
-        return dget(sb->s_root);
+        return mount_nodev(fs_type, flags, data, binderfs_fill_super);
 }
 
 static void binderfs_kill_super(struct super_block *sb)
 {
         struct binderfs_info *info = sb->s_fs_info;
 
+        kill_litter_super(sb);
+
         if (info && info->ipc_ns)
                 put_ipc_ns(info->ipc_ns);
 
         kfree(info);
-        kill_litter_super(sb);
 }
 
 static struct file_system_type binder_fs_type = {
@@ -530,14 +558,6 @@ static int __init init_binderfs(void)
                 return ret;
         }
 
-        binderfs_mnt = kern_mount(&binder_fs_type);
-        if (IS_ERR(binderfs_mnt)) {
-                ret = PTR_ERR(binderfs_mnt);
-                binderfs_mnt = NULL;
-                unregister_filesystem(&binder_fs_type);
-                unregister_chrdev_region(binderfs_dev, BINDERFS_MAX_MINOR);
-        }
-
         return ret;
 }
 
diff --git a/drivers/ata/Kconfig b/drivers/ata/Kconfig
index 4ca7a6b4eaae..8218db17ebdb 100644
--- a/drivers/ata/Kconfig
+++ b/drivers/ata/Kconfig
@@ -1091,7 +1091,7 @@ comment "Generic fallback / legacy drivers"
 
 config PATA_ACPI
         tristate "ACPI firmware driver for PATA"
-        depends on ATA_ACPI && ATA_BMDMA
+        depends on ATA_ACPI && ATA_BMDMA && PCI
         help
           This option enables an ACPI method driver which drives
           motherboard PATA controller interfaces through the ACPI
diff --git a/drivers/ata/ahci.h b/drivers/ata/ahci.h
index ef356e70e6de..8810475f307a 100644
--- a/drivers/ata/ahci.h
+++ b/drivers/ata/ahci.h
@@ -254,6 +254,8 @@ enum {
         AHCI_HFLAG_IS_MOBILE            = (1 << 25), /* mobile chipset, use
                                                         SATA_MOBILE_LPM_POLICY
                                                         as default lpm_policy */
+        AHCI_HFLAG_SUSPEND_PHYS         = (1 << 26), /* handle PHYs during
+                                                        suspend/resume */
 
         /* ap->flags bits */
 
diff --git a/drivers/ata/ahci_mvebu.c b/drivers/ata/ahci_mvebu.c
index f9cb51be38eb..d4bba3ace45d 100644
--- a/drivers/ata/ahci_mvebu.c
+++ b/drivers/ata/ahci_mvebu.c
@@ -28,6 +28,11 @@
 #define AHCI_WINDOW_BASE(win)   (0x64 + ((win) << 4))
 #define AHCI_WINDOW_SIZE(win)   (0x68 + ((win) << 4))
 
+struct ahci_mvebu_plat_data {
+        int (*plat_config)(struct ahci_host_priv *hpriv);
+        unsigned int flags;
+};
+
 static void ahci_mvebu_mbus_config(struct ahci_host_priv *hpriv,
                                    const struct mbus_dram_target_info *dram)
 {
@@ -62,6 +67,35 @@ static void ahci_mvebu_regret_option(struct ahci_host_priv *hpriv)
         writel(0x80, hpriv->mmio + AHCI_VENDOR_SPECIFIC_0_DATA);
 }
 
+static int ahci_mvebu_armada_380_config(struct ahci_host_priv *hpriv)
+{
+        const struct mbus_dram_target_info *dram;
+        int rc = 0;
+
+        dram = mv_mbus_dram_info();
+        if (dram)
+                ahci_mvebu_mbus_config(hpriv, dram);
+        else
+                rc = -ENODEV;
+
+        ahci_mvebu_regret_option(hpriv);
+
+        return rc;
+}
+
+static int ahci_mvebu_armada_3700_config(struct ahci_host_priv *hpriv)
+{
+        u32 reg;
+
+        writel(0, hpriv->mmio + AHCI_VENDOR_SPECIFIC_0_ADDR);
+
+        reg = readl(hpriv->mmio + AHCI_VENDOR_SPECIFIC_0_DATA);
+        reg |= BIT(6);
+        writel(reg, hpriv->mmio + AHCI_VENDOR_SPECIFIC_0_DATA);
+
+        return 0;
+}
+
 /**
  * ahci_mvebu_stop_engine
  *
@@ -126,13 +160,9 @@ static int ahci_mvebu_resume(struct platform_device *pdev)
 {
         struct ata_host *host = platform_get_drvdata(pdev);
         struct ahci_host_priv *hpriv = host->private_data;
-        const struct mbus_dram_target_info *dram;
+        const struct ahci_mvebu_plat_data *pdata = hpriv->plat_data;
 
-        dram = mv_mbus_dram_info();
-        if (dram)
-                ahci_mvebu_mbus_config(hpriv, dram);
-
-        ahci_mvebu_regret_option(hpriv);
+        pdata->plat_config(hpriv);
 
         return ahci_platform_resume_host(&pdev->dev);
 }
@@ -154,29 +184,30 @@ static struct scsi_host_template ahci_platform_sht = {
 
 static int ahci_mvebu_probe(struct platform_device *pdev)
 {
+        const struct ahci_mvebu_plat_data *pdata;
         struct ahci_host_priv *hpriv;
-        const struct mbus_dram_target_info *dram;
         int rc;
 
+        pdata = of_device_get_match_data(&pdev->dev);
+        if (!pdata)
+                return -EINVAL;
+
         hpriv = ahci_platform_get_resources(pdev, 0);
         if (IS_ERR(hpriv))
                 return PTR_ERR(hpriv);
 
+        hpriv->flags |= pdata->flags;
+        hpriv->plat_data = (void *)pdata;
+
         rc = ahci_platform_enable_resources(hpriv);
         if (rc)
                 return rc;
 
         hpriv->stop_engine = ahci_mvebu_stop_engine;
 
-        if (of_device_is_compatible(pdev->dev.of_node,
-                                    "marvell,armada-380-ahci")) {
-                dram = mv_mbus_dram_info();
-                if (!dram)
-                        return -ENODEV;
-
-                ahci_mvebu_mbus_config(hpriv, dram);
-                ahci_mvebu_regret_option(hpriv);
-        }
+        rc = pdata->plat_config(hpriv);
+        if (rc)
+                goto disable_resources;
 
         rc = ahci_platform_init_host(pdev, hpriv, &ahci_mvebu_port_info,
                                      &ahci_platform_sht);
@@ -190,18 +221,28 @@ disable_resources:
         return rc;
 }
 
+static const struct ahci_mvebu_plat_data ahci_mvebu_armada_380_plat_data = {
+        .plat_config = ahci_mvebu_armada_380_config,
+};
+
+static const struct ahci_mvebu_plat_data ahci_mvebu_armada_3700_plat_data = {
+        .plat_config = ahci_mvebu_armada_3700_config,
+        .flags = AHCI_HFLAG_SUSPEND_PHYS,
+};
+
 static const struct of_device_id ahci_mvebu_of_match[] = {
-        { .compatible = "marvell,armada-380-ahci", },
-        { .compatible = "marvell,armada-3700-ahci", },
+        {
+                .compatible = "marvell,armada-380-ahci",
+                .data = &ahci_mvebu_armada_380_plat_data,
+        },
+        {
+                .compatible = "marvell,armada-3700-ahci",
+                .data = &ahci_mvebu_armada_3700_plat_data,
+        },
         { },
 };
 MODULE_DEVICE_TABLE(of, ahci_mvebu_of_match);
 
-/*
- * We currently don't provide power management related operations,
- * since there is no suspend/resume support at the platform level for
- * Armada 38x for the moment.
- */
 static struct platform_driver ahci_mvebu_driver = {
         .probe = ahci_mvebu_probe,
         .remove = ata_platform_remove_one,
diff --git a/drivers/ata/libahci_platform.c b/drivers/ata/libahci_platform.c
index 4b900fc659f7..81b1a3332ed6 100644
--- a/drivers/ata/libahci_platform.c
+++ b/drivers/ata/libahci_platform.c
@@ -56,6 +56,12 @@ static int ahci_platform_enable_phys(struct ahci_host_priv *hpriv)
                 if (rc)
                         goto disable_phys;
 
+                rc = phy_set_mode(hpriv->phys[i], PHY_MODE_SATA);
+                if (rc) {
+                        phy_exit(hpriv->phys[i]);
+                        goto disable_phys;
+                }
+
                 rc = phy_power_on(hpriv->phys[i]);
                 if (rc) {
                         phy_exit(hpriv->phys[i]);
@@ -738,6 +744,9 @@ int ahci_platform_suspend_host(struct device *dev)
         writel(ctl, mmio + HOST_CTL);
         readl(mmio + HOST_CTL); /* flush */
 
+        if (hpriv->flags & AHCI_HFLAG_SUSPEND_PHYS)
+                ahci_platform_disable_phys(hpriv);
+
         return ata_host_suspend(host, PMSG_SUSPEND);
 }
 EXPORT_SYMBOL_GPL(ahci_platform_suspend_host);
@@ -756,6 +765,7 @@ EXPORT_SYMBOL_GPL(ahci_platform_suspend_host);
 int ahci_platform_resume_host(struct device *dev)
 {
         struct ata_host *host = dev_get_drvdata(dev);
+        struct ahci_host_priv *hpriv = host->private_data;
         int rc;
 
         if (dev->power.power_state.event == PM_EVENT_SUSPEND) {
@@ -766,6 +776,9 @@ int ahci_platform_resume_host(struct device *dev)
                 ahci_init_controller(host);
         }
 
+        if (hpriv->flags & AHCI_HFLAG_SUSPEND_PHYS)
+                ahci_platform_enable_phys(hpriv);
+
         ata_host_resume(host);
 
         return 0;
diff --git a/drivers/ata/pata_macio.c b/drivers/ata/pata_macio.c
index 8cc9c429ad95..9e7fc302430f 100644
--- a/drivers/ata/pata_macio.c
+++ b/drivers/ata/pata_macio.c
@@ -915,6 +915,10 @@ static struct scsi_host_template pata_macio_sht = {
         .sg_tablesize           = MAX_DCMDS,
         /* We may not need that strict one */
         .dma_boundary           = ATA_DMA_BOUNDARY,
+        /* Not sure what the real max is but we know it's less than 64K, let's
+         * use 64K minus 256
+         */
+        .max_segment_size       = MAX_DBDMA_SEG,
         .slave_configure        = pata_macio_slave_config,
 };
 
@@ -1044,11 +1048,6 @@ static int pata_macio_common_init(struct pata_macio_priv *priv,
         /* Make sure we have sane initial timings in the cache */
         pata_macio_default_timings(priv);
 
-        /* Not sure what the real max is but we know it's less than 64K, let's
-         * use 64K minus 256
-         */
-        dma_set_max_seg_size(priv->dev, MAX_DBDMA_SEG);
-
         /* Allocate libata host for 1 port */
         memset(&pinfo, 0, sizeof(struct ata_port_info));
         pmac_macio_calc_timing_masks(priv, &pinfo);
diff --git a/drivers/ata/sata_fsl.c b/drivers/ata/sata_fsl.c
index 4dc528bf8e85..9c1247d42897 100644
--- a/drivers/ata/sata_fsl.c
+++ b/drivers/ata/sata_fsl.c
@@ -729,8 +729,8 @@ static int sata_fsl_port_start(struct ata_port *ap)
         if (!pp)
                 return -ENOMEM;
 
-        mem = dma_zalloc_coherent(dev, SATA_FSL_PORT_PRIV_DMA_SZ, &mem_dma,
-                                  GFP_KERNEL);
+        mem = dma_alloc_coherent(dev, SATA_FSL_PORT_PRIV_DMA_SZ, &mem_dma,
+                                 GFP_KERNEL);
         if (!mem) {
                 kfree(pp);
                 return -ENOMEM;
diff --git a/drivers/ata/sata_inic162x.c b/drivers/ata/sata_inic162x.c
index e0bcf9b2dab0..174e84ce4379 100644
--- a/drivers/ata/sata_inic162x.c
+++ b/drivers/ata/sata_inic162x.c
@@ -245,8 +245,15 @@ struct inic_port_priv {
 
 static struct scsi_host_template inic_sht = {
         ATA_BASE_SHT(DRV_NAME),
-        .sg_tablesize   = LIBATA_MAX_PRD,       /* maybe it can be larger? */
-        .dma_boundary   = INIC_DMA_BOUNDARY,
+        .sg_tablesize           = LIBATA_MAX_PRD, /* maybe it can be larger? */
+
+        /*
+         * This controller is braindamaged.  dma_boundary is 0xffff like others
+         * but it will lock up the whole machine HARD if 65536 byte PRD entry
+         * is fed.  Reduce maximum segment size.
+         */
+        .dma_boundary           = INIC_DMA_BOUNDARY,
+        .max_segment_size       = 65536 - 512,
 };
 
 static const int scr_map[] = {
@@ -868,17 +875,6 @@ static int inic_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
                 return rc;
         }
 
-        /*
-         * This controller is braindamaged.  dma_boundary is 0xffff
-         * like others but it will lock up the whole machine HARD if
-         * 65536 byte PRD entry is fed. Reduce maximum segment size.
-         */
-        rc = dma_set_max_seg_size(&pdev->dev, 65536 - 512);
-        if (rc) {
-                dev_err(&pdev->dev, "failed to set the maximum segment size\n");
-                return rc;
-        }
-
         rc = init_controller(hpriv->mmio_base, hpriv->cached_hctl);
         if (rc) {
                 dev_err(&pdev->dev, "failed to initialize controller\n");
diff --git a/drivers/atm/he.c b/drivers/atm/he.c
index 29f102dcfec4..211607986134 100644
--- a/drivers/atm/he.c
+++ b/drivers/atm/he.c
@@ -533,9 +533,10 @@ static void he_init_tx_lbfp(struct he_dev *he_dev)
 
 static int he_init_tpdrq(struct he_dev *he_dev)
 {
-        he_dev->tpdrq_base = dma_zalloc_coherent(&he_dev->pci_dev->dev,
-                                                 CONFIG_TPDRQ_SIZE * sizeof(struct he_tpdrq),
-                                                 &he_dev->tpdrq_phys, GFP_KERNEL);
+        he_dev->tpdrq_base = dma_alloc_coherent(&he_dev->pci_dev->dev,
+                                                CONFIG_TPDRQ_SIZE * sizeof(struct he_tpdrq),
+                                                &he_dev->tpdrq_phys,
+                                                GFP_KERNEL);
         if (he_dev->tpdrq_base == NULL) {
                 hprintk("failed to alloc tpdrq\n");
                 return -ENOMEM;
@@ -717,7 +718,7 @@ static int he_init_cs_block_rcm(struct he_dev *he_dev)
                         instead of '/ 512', use '>> 9' to prevent a call
                         to divdu3 on x86 platforms
                 */
-                rate_cps = (unsigned long long) (1 << exp) * (man + 512) >> 9;
+                rate_cps = (unsigned long long) (1UL << exp) * (man + 512) >> 9;
 
                 if (rate_cps < 10)
                         rate_cps = 10;  /* 2.2.1 minimum payload rate is 10 cps */
@@ -805,9 +806,9 @@ static int he_init_group(struct he_dev *he_dev, int group)
                 goto out_free_rbpl_virt;
         }
 
-        he_dev->rbpl_base = dma_zalloc_coherent(&he_dev->pci_dev->dev,
-                                                CONFIG_RBPL_SIZE * sizeof(struct he_rbp),
-                                                &he_dev->rbpl_phys, GFP_KERNEL);
+        he_dev->rbpl_base = dma_alloc_coherent(&he_dev->pci_dev->dev,
+                                               CONFIG_RBPL_SIZE * sizeof(struct he_rbp),
+                                               &he_dev->rbpl_phys, GFP_KERNEL);
         if (he_dev->rbpl_base == NULL) {
                 hprintk("failed to alloc rbpl_base\n");
                 goto out_destroy_rbpl_pool;
@@ -844,9 +845,9 @@ static int he_init_group(struct he_dev *he_dev, int group)
 
         /* rx buffer ready queue */
 
-        he_dev->rbrq_base = dma_zalloc_coherent(&he_dev->pci_dev->dev,
-                                                CONFIG_RBRQ_SIZE * sizeof(struct he_rbrq),
-                                                &he_dev->rbrq_phys, GFP_KERNEL);
+        he_dev->rbrq_base = dma_alloc_coherent(&he_dev->pci_dev->dev,
+                                               CONFIG_RBRQ_SIZE * sizeof(struct he_rbrq),
+                                               &he_dev->rbrq_phys, GFP_KERNEL);
         if (he_dev->rbrq_base == NULL) {
                 hprintk("failed to allocate rbrq\n");
                 goto out_free_rbpl;
@@ -868,9 +869,9 @@ static int he_init_group(struct he_dev *he_dev, int group)
 
         /* tx buffer ready queue */
 
-        he_dev->tbrq_base = dma_zalloc_coherent(&he_dev->pci_dev->dev,
-                                                CONFIG_TBRQ_SIZE * sizeof(struct he_tbrq),
-                                                &he_dev->tbrq_phys, GFP_KERNEL);
+        he_dev->tbrq_base = dma_alloc_coherent(&he_dev->pci_dev->dev,
+                                               CONFIG_TBRQ_SIZE * sizeof(struct he_tbrq),
+                                               &he_dev->tbrq_phys, GFP_KERNEL);
         if (he_dev->tbrq_base == NULL) {
                 hprintk("failed to allocate tbrq\n");
                 goto out_free_rbpq_base;
@@ -913,11 +914,9 @@ static int he_init_irq(struct he_dev *he_dev)
         /* 2.9.3.5  tail offset for each interrupt queue is located after the
                     end of the interrupt queue */
 
-        he_dev->irq_base = dma_zalloc_coherent(&he_dev->pci_dev->dev,
-                                               (CONFIG_IRQ_SIZE + 1)
-                                               * sizeof(struct he_irq),
-                                               &he_dev->irq_phys,
-                                               GFP_KERNEL);
+        he_dev->irq_base = dma_alloc_coherent(&he_dev->pci_dev->dev,
+                                              (CONFIG_IRQ_SIZE + 1) * sizeof(struct he_irq),
+                                              &he_dev->irq_phys, GFP_KERNEL);
         if (he_dev->irq_base == NULL) {
                 hprintk("failed to allocate irq\n");
                 return -ENOMEM;
@@ -1464,9 +1463,9 @@ static int he_start(struct atm_dev *dev)
 
         /* host status page */
 
-        he_dev->hsp = dma_zalloc_coherent(&he_dev->pci_dev->dev,
-                                          sizeof(struct he_hsp),
-                                          &he_dev->hsp_phys, GFP_KERNEL);
+        he_dev->hsp = dma_alloc_coherent(&he_dev->pci_dev->dev,
+                                         sizeof(struct he_hsp),
+                                         &he_dev->hsp_phys, GFP_KERNEL);
         if (he_dev->hsp == NULL) {
                 hprintk("failed to allocate host status page\n");
                 return -ENOMEM;
diff --git a/drivers/atm/idt77252.c b/drivers/atm/idt77252.c
index 6e737142ceaa..43a14579e80e 100644
--- a/drivers/atm/idt77252.c
+++ b/drivers/atm/idt77252.c
@@ -641,8 +641,8 @@ alloc_scq(struct idt77252_dev *card, int class)
         scq = kzalloc(sizeof(struct scq_info), GFP_KERNEL);
         if (!scq)
                 return NULL;
-        scq->base = dma_zalloc_coherent(&card->pcidev->dev, SCQ_SIZE,
-                                        &scq->paddr, GFP_KERNEL);
+        scq->base = dma_alloc_coherent(&card->pcidev->dev, SCQ_SIZE,
+                                       &scq->paddr, GFP_KERNEL);
         if (scq->base == NULL) {
                 kfree(scq);
                 return NULL;
@@ -971,8 +971,8 @@ init_rsq(struct idt77252_dev *card)
 {
         struct rsq_entry *rsqe;
 
-        card->rsq.base = dma_zalloc_coherent(&card->pcidev->dev, RSQSIZE,
-                                             &card->rsq.paddr, GFP_KERNEL);
+        card->rsq.base = dma_alloc_coherent(&card->pcidev->dev, RSQSIZE,
+                                            &card->rsq.paddr, GFP_KERNEL);
         if (card->rsq.base == NULL) {
                 printk("%s: can't allocate RSQ.\n", card->name);
                 return -1;
@@ -3390,10 +3390,10 @@ static int init_card(struct atm_dev *dev)
         writel(0, SAR_REG_GP);
 
         /* Initialize RAW Cell Handle Register  */
-        card->raw_cell_hnd = dma_zalloc_coherent(&card->pcidev->dev,
-                                                 2 * sizeof(u32),
-                                                 &card->raw_cell_paddr,
-                                                 GFP_KERNEL);
+        card->raw_cell_hnd = dma_alloc_coherent(&card->pcidev->dev,
+                                                2 * sizeof(u32),
+                                                &card->raw_cell_paddr,
+                                                GFP_KERNEL);
         if (!card->raw_cell_hnd) {
                 printk("%s: memory allocation failure.\n", card->name);
                 deinit_card(card);
diff --git a/drivers/base/power/main.c b/drivers/base/power/main.c
index a690fd400260..0992e67e862b 100644
--- a/drivers/base/power/main.c
+++ b/drivers/base/power/main.c
@@ -32,6 +32,7 @@
 #include <trace/events/power.h>
 #include <linux/cpufreq.h>
 #include <linux/cpuidle.h>
+#include <linux/devfreq.h>
 #include <linux/timer.h>
 
 #include "../base.h"
@@ -1078,6 +1079,7 @@ void dpm_resume(pm_message_t state)
         dpm_show_time(starttime, state, 0, NULL);
 
         cpufreq_resume();
+        devfreq_resume();
         trace_suspend_resume(TPS("dpm_resume"), state.event, false);
 }
 
@@ -1852,6 +1854,7 @@ int dpm_suspend(pm_message_t state)
         trace_suspend_resume(TPS("dpm_suspend"), state.event, true);
         might_sleep();
 
+        devfreq_suspend();
         cpufreq_suspend();
 
         mutex_lock(&dpm_list_mtx);
diff --git a/drivers/base/power/runtime.c b/drivers/base/power/runtime.c
index 70624695b6d5..457be03b744d 100644
--- a/drivers/base/power/runtime.c
+++ b/drivers/base/power/runtime.c
@@ -121,7 +121,7 @@ static void pm_runtime_cancel_pending(struct device *dev)
  * Compute the autosuspend-delay expiration time based on the device's
  * power.last_busy time.  If the delay has already expired or is disabled
  * (negative) or the power.use_autosuspend flag isn't set, return 0.
- * Otherwise return the expiration time in jiffies (adjusted to be nonzero).
+ * Otherwise return the expiration time in nanoseconds (adjusted to be nonzero).
  *
  * This function may be called either with or without dev->power.lock held.
  * Either way it can be racy, since power.last_busy may be updated at any time.
@@ -141,7 +141,7 @@ u64 pm_runtime_autosuspend_expiration(struct device *dev)
 
         last_busy = READ_ONCE(dev->power.last_busy);
 
-        expires = last_busy + autosuspend_delay * NSEC_PER_MSEC;
+        expires = last_busy + (u64)autosuspend_delay * NSEC_PER_MSEC;
         if (expires <= now)
                 expires = 0;    /* Already expired. */
 
@@ -525,7 +525,7 @@ static int rpm_suspend(struct device *dev, int rpmflags)
                                  * We add a slack of 25% to gather wakeups
                                  * without sacrificing the granularity.
                                  */
-                                u64 slack = READ_ONCE(dev->power.autosuspend_delay) *
+                                u64 slack = (u64)READ_ONCE(dev->power.autosuspend_delay) *
                                                     (NSEC_PER_MSEC >> 2);
 
                                 dev->power.timer_expires = expires;
@@ -905,7 +905,10 @@ static enum hrtimer_restart  pm_suspend_timer_fn(struct hrtimer *timer)
         spin_lock_irqsave(&dev->power.lock, flags);
 
         expires = dev->power.timer_expires;
-        /* If 'expire' is after 'jiffies' we've been called too early. */
+        /*
+         * If 'expires' is after the current time, we've been called
+         * too early.
+         */
         if (expires > 0 && expires < ktime_to_ns(ktime_get())) {
                 dev->power.timer_expires = 0;
                 rpm_suspend(dev, dev->power.timer_autosuspends ?
diff --git a/drivers/base/regmap/regmap-irq.c b/drivers/base/regmap/regmap-irq.c
index 1bd1145ad8b5..330c1f7e9665 100644
--- a/drivers/base/regmap/regmap-irq.c
+++ b/drivers/base/regmap/regmap-irq.c
@@ -108,6 +108,9 @@ static void regmap_irq_sync_unlock(struct irq_data *data)
          * suppress pointless writes.
          */
         for (i = 0; i < d->chip->num_regs; i++) {
+                if (!d->chip->mask_base)
+                        continue;
+
                 reg = d->chip->mask_base +
                         (i * map->reg_stride * d->irq_reg_stride);
                 if (d->chip->mask_invert) {
@@ -258,7 +261,7 @@ static int regmap_irq_set_type(struct irq_data *data, unsigned int type)
         const struct regmap_irq_type *t = &irq_data->type;
 
         if ((t->types_supported & type) != type)
-                return -ENOTSUPP;
+                return 0;
 
         reg = t->type_reg_offset / map->reg_stride;
 
@@ -588,6 +591,9 @@ int regmap_add_irq_chip(struct regmap *map, int irq, int irq_flags,
         /* Mask all the interrupts by default */
         for (i = 0; i < chip->num_regs; i++) {
                 d->mask_buf[i] = d->mask_buf_def[i];
+                if (!chip->mask_base)
+                        continue;
+
                 reg = chip->mask_base +
                         (i * map->reg_stride * d->irq_reg_stride);
                 if (chip->mask_invert)
diff --git a/drivers/block/loop.c b/drivers/block/loop.c
index b8a0720d3653..cf5538942834 100644
--- a/drivers/block/loop.c
+++ b/drivers/block/loop.c
@@ -1190,6 +1190,12 @@ loop_set_status(struct loop_device *lo, const struct loop_info64 *info)
                 goto out_unlock;
         }
 
+        if (lo->lo_offset != info->lo_offset ||
+            lo->lo_sizelimit != info->lo_sizelimit) {
+                sync_blockdev(lo->lo_device);
+                kill_bdev(lo->lo_device);
+        }
+
         /* I/O need to be drained during transfer transition */
         blk_mq_freeze_queue(lo->lo_queue);
 
@@ -1218,6 +1224,14 @@ loop_set_status(struct loop_device *lo, const struct loop_info64 *info)
 
         if (lo->lo_offset != info->lo_offset ||
             lo->lo_sizelimit != info->lo_sizelimit) {
+                /* kill_bdev should have truncated all the pages */
+                if (lo->lo_device->bd_inode->i_mapping->nrpages) {
+                        err = -EAGAIN;
+                        pr_warn("%s: loop%d (%s) has still dirty pages (nrpages=%lu)\n",
+                                __func__, lo->lo_number, lo->lo_file_name,
+                                lo->lo_device->bd_inode->i_mapping->nrpages);
+                        goto out_unfreeze;
+                }
                 if (figure_loop_size(lo, info->lo_offset, info->lo_sizelimit)) {
                         err = -EFBIG;
                         goto out_unfreeze;
@@ -1443,22 +1457,39 @@ static int loop_set_dio(struct loop_device *lo, unsigned long arg)
 
 static int loop_set_block_size(struct loop_device *lo, unsigned long arg)
 {
+        int err = 0;
+
         if (lo->lo_state != Lo_bound)
                 return -ENXIO;
 
         if (arg < 512 || arg > PAGE_SIZE || !is_power_of_2(arg))
                 return -EINVAL;
 
+        if (lo->lo_queue->limits.logical_block_size != arg) {
+                sync_blockdev(lo->lo_device);
+                kill_bdev(lo->lo_device);
+        }
+
         blk_mq_freeze_queue(lo->lo_queue);
 
+        /* kill_bdev should have truncated all the pages */
+        if (lo->lo_queue->limits.logical_block_size != arg &&
+                        lo->lo_device->bd_inode->i_mapping->nrpages) {
+                err = -EAGAIN;
+                pr_warn("%s: loop%d (%s) has still dirty pages (nrpages=%lu)\n",
+                        __func__, lo->lo_number, lo->lo_file_name,
+                        lo->lo_device->bd_inode->i_mapping->nrpages);
+                goto out_unfreeze;
+        }
+
         blk_queue_logical_block_size(lo->lo_queue, arg);
         blk_queue_physical_block_size(lo->lo_queue, arg);
         blk_queue_io_min(lo->lo_queue, arg);
         loop_update_dio(lo);
-
+out_unfreeze:
         blk_mq_unfreeze_queue(lo->lo_queue);
 
-        return 0;
+        return err;
 }
 
 static int lo_simple_ioctl(struct loop_device *lo, unsigned int cmd,
diff --git a/drivers/block/nbd.c b/drivers/block/nbd.c
index 08696f5f00bb..7c9a949e876b 100644
--- a/drivers/block/nbd.c
+++ b/drivers/block/nbd.c
@@ -288,9 +288,10 @@ static void nbd_size_update(struct nbd_device *nbd)
         blk_queue_physical_block_size(nbd->disk->queue, config->blksize);
         set_capacity(nbd->disk, config->bytesize >> 9);
         if (bdev) {
-                if (bdev->bd_disk)
+                if (bdev->bd_disk) {
                         bd_set_size(bdev, config->bytesize);
-                else
+                        set_blocksize(bdev, config->blksize);
+                } else
                         bdev->bd_invalidated = 1;
                 bdput(bdev);
         }
diff --git a/drivers/block/null_blk.h b/drivers/block/null_blk.h
index b3df2793e7cd..34b22d6523ba 100644
--- a/drivers/block/null_blk.h
+++ b/drivers/block/null_blk.h
@@ -97,6 +97,7 @@ void null_zone_reset(struct nullb_cmd *cmd, sector_t sector);
 #else
 static inline int null_zone_init(struct nullb_device *dev)
 {
+        pr_err("null_blk: CONFIG_BLK_DEV_ZONED not enabled\n");
         return -EINVAL;
 }
 static inline void null_zone_exit(struct nullb_device *dev) {}
diff --git a/drivers/block/rbd.c b/drivers/block/rbd.c
index 8e5140bbf241..1e92b61d0bd5 100644
--- a/drivers/block/rbd.c
+++ b/drivers/block/rbd.c
@@ -5986,7 +5986,6 @@ static ssize_t do_rbd_remove(struct bus_type *bus,
         struct list_head *tmp;
         int dev_id;
         char opt_buf[6];
-        bool already = false;
         bool force = false;
         int ret;
 
@@ -6019,13 +6018,13 @@ static ssize_t do_rbd_remove(struct bus_type *bus,
                 spin_lock_irq(&rbd_dev->lock);
                 if (rbd_dev->open_count && !force)
                         ret = -EBUSY;
-                else
-                        already = test_and_set_bit(RBD_DEV_FLAG_REMOVING,
-                                                        &rbd_dev->flags);
+                else if (test_and_set_bit(RBD_DEV_FLAG_REMOVING,
+                                          &rbd_dev->flags))
+                        ret = -EINPROGRESS;
                 spin_unlock_irq(&rbd_dev->lock);
         }
         spin_unlock(&rbd_dev_list_lock);
-        if (ret < 0 || already)
+        if (ret)
                 return ret;
 
         if (force) {
diff --git a/drivers/block/skd_main.c b/drivers/block/skd_main.c
index a10d5736d8f7..ab893a7571a2 100644
--- a/drivers/block/skd_main.c
+++ b/drivers/block/skd_main.c
@@ -2641,8 +2641,8 @@ static int skd_cons_skcomp(struct skd_device *skdev)
                 "comp pci_alloc, total bytes %zd entries %d\n",
                 SKD_SKCOMP_SIZE, SKD_N_COMPLETION_ENTRY);
 
-        skcomp = dma_zalloc_coherent(&skdev->pdev->dev, SKD_SKCOMP_SIZE,
-                                     &skdev->cq_dma_address, GFP_KERNEL);
+        skcomp = dma_alloc_coherent(&skdev->pdev->dev, SKD_SKCOMP_SIZE,
+                                    &skdev->cq_dma_address, GFP_KERNEL);
 
         if (skcomp == NULL) {
                 rc = -ENOMEM;
diff --git a/drivers/block/zram/zram_drv.c b/drivers/block/zram/zram_drv.c
index 33c5cc879f24..04ca65912638 100644
--- a/drivers/block/zram/zram_drv.c
+++ b/drivers/block/zram/zram_drv.c
@@ -316,11 +316,9 @@ static ssize_t idle_store(struct device *dev,
                  * See the comment in writeback_store.
                  */
                 zram_slot_lock(zram, index);
-                if (!zram_allocated(zram, index) ||
-                                zram_test_flag(zram, index, ZRAM_UNDER_WB))
-                        goto next;
-                zram_set_flag(zram, index, ZRAM_IDLE);
-next:
+                if (zram_allocated(zram, index) &&
+                                !zram_test_flag(zram, index, ZRAM_UNDER_WB))
+                        zram_set_flag(zram, index, ZRAM_IDLE);
                 zram_slot_unlock(zram, index);
         }
 
@@ -330,6 +328,41 @@ next:
 }
 
 #ifdef CONFIG_ZRAM_WRITEBACK
+static ssize_t writeback_limit_enable_store(struct device *dev,
+                struct device_attribute *attr, const char *buf, size_t len)
+{
+        struct zram *zram = dev_to_zram(dev);
+        u64 val;
+        ssize_t ret = -EINVAL;
+
+        if (kstrtoull(buf, 10, &val))
+                return ret;
+
+        down_read(&zram->init_lock);
+        spin_lock(&zram->wb_limit_lock);
+        zram->wb_limit_enable = val;
+        spin_unlock(&zram->wb_limit_lock);
+        up_read(&zram->init_lock);
+        ret = len;
+
+        return ret;
+}
+
+static ssize_t writeback_limit_enable_show(struct device *dev,
+                struct device_attribute *attr, char *buf)
+{
+        bool val;
+        struct zram *zram = dev_to_zram(dev);
+
+        down_read(&zram->init_lock);
+        spin_lock(&zram->wb_limit_lock);
+        val = zram->wb_limit_enable;
+        spin_unlock(&zram->wb_limit_lock);
+        up_read(&zram->init_lock);
+
+        return scnprintf(buf, PAGE_SIZE, "%d\n", val);
+}
+
 static ssize_t writeback_limit_store(struct device *dev,
                 struct device_attribute *attr, const char *buf, size_t len)
 {
@@ -341,9 +374,9 @@ static ssize_t writeback_limit_store(struct device *dev,
                 return ret;
 
         down_read(&zram->init_lock);
-        atomic64_set(&zram->stats.bd_wb_limit, val);
-        if (val == 0)
-                zram->stop_writeback = false;
+        spin_lock(&zram->wb_limit_lock);
+        zram->bd_wb_limit = val;
+        spin_unlock(&zram->wb_limit_lock);
         up_read(&zram->init_lock);
         ret = len;
 
@@ -357,7 +390,9 @@ static ssize_t writeback_limit_show(struct device *dev,
         struct zram *zram = dev_to_zram(dev);
 
         down_read(&zram->init_lock);
-        val = atomic64_read(&zram->stats.bd_wb_limit);
+        spin_lock(&zram->wb_limit_lock);
+        val = zram->bd_wb_limit;
+        spin_unlock(&zram->wb_limit_lock);
         up_read(&zram->init_lock);
 
         return scnprintf(buf, PAGE_SIZE, "%llu\n", val);
@@ -588,8 +623,8 @@ static int read_from_bdev_async(struct zram *zram, struct bio_vec *bvec,
         return 1;
 }
 
-#define HUGE_WRITEBACK 0x1
-#define IDLE_WRITEBACK 0x2
+#define HUGE_WRITEBACK 1
+#define IDLE_WRITEBACK 2
 
 static ssize_t writeback_store(struct device *dev,
                 struct device_attribute *attr, const char *buf, size_t len)
@@ -602,7 +637,7 @@ static ssize_t writeback_store(struct device *dev,
         struct page *page;
         ssize_t ret, sz;
         char mode_buf[8];
-        unsigned long mode = -1UL;
+        int mode = -1;
         unsigned long blk_idx = 0;
 
         sz = strscpy(mode_buf, buf, sizeof(mode_buf));
@@ -618,7 +653,7 @@ static ssize_t writeback_store(struct device *dev,
         else if (!strcmp(mode_buf, "huge"))
                 mode = HUGE_WRITEBACK;
 
-        if (mode == -1UL)
+        if (mode == -1)
                 return -EINVAL;
 
         down_read(&zram->init_lock);
@@ -645,10 +680,13 @@ static ssize_t writeback_store(struct device *dev,
                 bvec.bv_len = PAGE_SIZE;
                 bvec.bv_offset = 0;
 
-                if (zram->stop_writeback) {
+                spin_lock(&zram->wb_limit_lock);
+                if (zram->wb_limit_enable && !zram->bd_wb_limit) {
+                        spin_unlock(&zram->wb_limit_lock);
                         ret = -EIO;
                         break;
                 }
+                spin_unlock(&zram->wb_limit_lock);
 
                 if (!blk_idx) {
                         blk_idx = alloc_block_bdev(zram);
@@ -667,10 +705,11 @@ static ssize_t writeback_store(struct device *dev,
                                 zram_test_flag(zram, index, ZRAM_UNDER_WB))
                         goto next;
 
-                if ((mode & IDLE_WRITEBACK &&
-                          !zram_test_flag(zram, index, ZRAM_IDLE)) &&
-                    (mode & HUGE_WRITEBACK &&
-                          !zram_test_flag(zram, index, ZRAM_HUGE)))
+                if (mode == IDLE_WRITEBACK &&
+                          !zram_test_flag(zram, index, ZRAM_IDLE))
+                        goto next;
+                if (mode == HUGE_WRITEBACK &&
+                          !zram_test_flag(zram, index, ZRAM_HUGE))
                         goto next;
                 /*
                  * Clearing ZRAM_UNDER_WB is duty of caller.
@@ -732,11 +771,10 @@ static ssize_t writeback_store(struct device *dev,
                 zram_set_element(zram, index, blk_idx);
                 blk_idx = 0;
                 atomic64_inc(&zram->stats.pages_stored);
-                if (atomic64_add_unless(&zram->stats.bd_wb_limit,
-                                        -1 << (PAGE_SHIFT - 12), 0)) {
-                        if (atomic64_read(&zram->stats.bd_wb_limit) == 0)
-                                zram->stop_writeback = true;
-                }
+                spin_lock(&zram->wb_limit_lock);
+                if (zram->wb_limit_enable && zram->bd_wb_limit > 0)
+                        zram->bd_wb_limit -=  1UL << (PAGE_SHIFT - 12);
+                spin_unlock(&zram->wb_limit_lock);
 next:
                 zram_slot_unlock(zram, index);
         }
@@ -1812,6 +1850,7 @@ static DEVICE_ATTR_RW(comp_algorithm);
 static DEVICE_ATTR_RW(backing_dev);
 static DEVICE_ATTR_WO(writeback);
 static DEVICE_ATTR_RW(writeback_limit);
+static DEVICE_ATTR_RW(writeback_limit_enable);
 #endif
 
 static struct attribute *zram_disk_attrs[] = {
@@ -1828,6 +1867,7 @@ static struct attribute *zram_disk_attrs[] = {
         &dev_attr_backing_dev.attr,
         &dev_attr_writeback.attr,
         &dev_attr_writeback_limit.attr,
+        &dev_attr_writeback_limit_enable.attr,
 #endif
         &dev_attr_io_stat.attr,
         &dev_attr_mm_stat.attr,
@@ -1867,7 +1907,9 @@ static int zram_add(void)
         device_id = ret;
 
         init_rwsem(&zram->init_lock);
-
+#ifdef CONFIG_ZRAM_WRITEBACK
+        spin_lock_init(&zram->wb_limit_lock);
+#endif
         queue = blk_alloc_queue(GFP_KERNEL);
         if (!queue) {
                 pr_err("Error allocating disk queue for device %d\n",
diff --git a/drivers/block/zram/zram_drv.h b/drivers/block/zram/zram_drv.h
index 4bd3afd15e83..f2fd46daa760 100644
--- a/drivers/block/zram/zram_drv.h
+++ b/drivers/block/zram/zram_drv.h
@@ -86,7 +86,6 @@ struct zram_stats {
         atomic64_t bd_count;            /* no. of pages in backing device */
         atomic64_t bd_reads;            /* no. of reads from backing device */
         atomic64_t bd_writes;           /* no. of writes from backing device */
-        atomic64_t bd_wb_limit;         /* writeback limit of backing device */
 #endif
 };
 
@@ -114,8 +113,10 @@ struct zram {
          */
         bool claim; /* Protected by bdev->bd_mutex */
         struct file *backing_dev;
-        bool stop_writeback;
 #ifdef CONFIG_ZRAM_WRITEBACK
+        spinlock_t wb_limit_lock;
+        bool wb_limit_enable;
+        u64 bd_wb_limit;
         struct block_device *bdev;
         unsigned int old_block_size;
         unsigned long *bitmap;
diff --git a/drivers/char/ipmi/ipmi_msghandler.c b/drivers/char/ipmi/ipmi_msghandler.c
index a74ce885b541..c518659b4d9f 100644
--- a/drivers/char/ipmi/ipmi_msghandler.c
+++ b/drivers/char/ipmi/ipmi_msghandler.c
@@ -32,6 +32,7 @@
 #include <linux/moduleparam.h>
 #include <linux/workqueue.h>
 #include <linux/uuid.h>
+#include <linux/nospec.h>
 
 #define IPMI_DRIVER_VERSION "39.2"
 
@@ -62,7 +63,8 @@ static void ipmi_debug_msg(const char *title, unsigned char *data,
 { }
 #endif
 
-static int initialized;
+static bool initialized;
+static bool drvregistered;
 
 enum ipmi_panic_event_op {
         IPMI_SEND_PANIC_EVENT_NONE,
@@ -612,7 +614,7 @@ static DEFINE_MUTEX(ipmidriver_mutex);
 
 static LIST_HEAD(ipmi_interfaces);
 static DEFINE_MUTEX(ipmi_interfaces_mutex);
-DEFINE_STATIC_SRCU(ipmi_interfaces_srcu);
+struct srcu_struct ipmi_interfaces_srcu;
 
 /*
  * List of watchers that want to know when smi's are added and deleted.
@@ -720,7 +722,15 @@ struct watcher_entry {
 int ipmi_smi_watcher_register(struct ipmi_smi_watcher *watcher)
 {
         struct ipmi_smi *intf;
-        int index;
+        int index, rv;
+
+        /*
+         * Make sure the driver is actually initialized, this handles
+         * problems with initialization order.
+         */
+        rv = ipmi_init_msghandler();
+        if (rv)
+                return rv;
 
         mutex_lock(&smi_watchers_mutex);
 
@@ -884,7 +894,7 @@ static int deliver_response(struct ipmi_smi *intf, struct ipmi_recv_msg *msg)
 
                 if (user) {
                         user->handler->ipmi_recv_hndl(msg, user->handler_data);
-                        release_ipmi_user(msg->user, index);
+                        release_ipmi_user(user, index);
                 } else {
                         /* User went away, give up. */
                         ipmi_free_recv_msg(msg);
@@ -1076,7 +1086,7 @@ int ipmi_create_user(unsigned int          if_num,
 {
         unsigned long flags;
         struct ipmi_user *new_user;
-        int           rv = 0, index;
+        int           rv, index;
         struct ipmi_smi *intf;
 
         /*
@@ -1094,18 +1104,9 @@ int ipmi_create_user(unsigned int          if_num,
          * Make sure the driver is actually initialized, this handles
          * problems with initialization order.
          */
-        if (!initialized) {
-                rv = ipmi_init_msghandler();
-                if (rv)
-                        return rv;
-
-                /*
-                 * The init code doesn't return an error if it was turned
-                 * off, but it won't initialize.  Check that.
-                 */
-                if (!initialized)
-                        return -ENODEV;
-        }
+        rv = ipmi_init_msghandler();
+        if (rv)
+                return rv;
 
         new_user = kmalloc(sizeof(*new_user), GFP_KERNEL);
         if (!new_user)
@@ -1183,6 +1184,7 @@ EXPORT_SYMBOL(ipmi_get_smi_info);
 static void free_user(struct kref *ref)
 {
         struct ipmi_user *user = container_of(ref, struct ipmi_user, refcount);
+        cleanup_srcu_struct(&user->release_barrier);
         kfree(user);
 }
 
@@ -1259,7 +1261,6 @@ int ipmi_destroy_user(struct ipmi_user *user)
 {
         _ipmi_destroy_user(user);
 
-        cleanup_srcu_struct(&user->release_barrier);
         kref_put(&user->refcount, free_user);
 
         return 0;
@@ -1298,10 +1299,12 @@ int ipmi_set_my_address(struct ipmi_user *user,
         if (!user)
                 return -ENODEV;
 
-        if (channel >= IPMI_MAX_CHANNELS)
+        if (channel >= IPMI_MAX_CHANNELS) {
                 rv = -EINVAL;
-        else
+        } else {
+                channel = array_index_nospec(channel, IPMI_MAX_CHANNELS);
                 user->intf->addrinfo[channel].address = address;
+        }
         release_ipmi_user(user, index);
 
         return rv;
@@ -1318,10 +1321,12 @@ int ipmi_get_my_address(struct ipmi_user *user,
         if (!user)
                 return -ENODEV;
 
-        if (channel >= IPMI_MAX_CHANNELS)
+        if (channel >= IPMI_MAX_CHANNELS) {
                 rv = -EINVAL;
-        else
+        } else {
+                channel = array_index_nospec(channel, IPMI_MAX_CHANNELS);
                 *address = user->intf->addrinfo[channel].address;
+        }
         release_ipmi_user(user, index);
 
         return rv;
@@ -1338,10 +1343,12 @@ int ipmi_set_my_LUN(struct ipmi_user *user,
         if (!user)
                 return -ENODEV;
 
-        if (channel >= IPMI_MAX_CHANNELS)
+        if (channel >= IPMI_MAX_CHANNELS) {
                 rv = -EINVAL;
-        else
+        } else {
+                channel = array_index_nospec(channel, IPMI_MAX_CHANNELS);
                 user->intf->addrinfo[channel].lun = LUN & 0x3;
+        }
         release_ipmi_user(user, index);
 
         return rv;
@@ -1358,10 +1365,12 @@ int ipmi_get_my_LUN(struct ipmi_user *user,
         if (!user)
                 return -ENODEV;
 
-        if (channel >= IPMI_MAX_CHANNELS)
+        if (channel >= IPMI_MAX_CHANNELS) {
                 rv = -EINVAL;
-        else
+        } else {
+                channel = array_index_nospec(channel, IPMI_MAX_CHANNELS);
                 *address = user->intf->addrinfo[channel].lun;
+        }
         release_ipmi_user(user, index);
 
         return rv;
@@ -2184,6 +2193,7 @@ static int check_addr(struct ipmi_smi  *intf,
 {
         if (addr->channel >= IPMI_MAX_CHANNELS)
                 return -EINVAL;
+        addr->channel = array_index_nospec(addr->channel, IPMI_MAX_CHANNELS);
         *lun = intf->addrinfo[addr->channel].lun;
         *saddr = intf->addrinfo[addr->channel].address;
         return 0;
@@ -3291,17 +3301,9 @@ int ipmi_register_smi(const struct ipmi_smi_handlers *handlers,
          * Make sure the driver is actually initialized, this handles
          * problems with initialization order.
          */
-        if (!initialized) {
-                rv = ipmi_init_msghandler();
-                if (rv)
-                        return rv;
-                /*
-                 * The init code doesn't return an error if it was turned
-                 * off, but it won't initialize.  Check that.
-                 */
-                if (!initialized)
-                        return -ENODEV;
-        }
+        rv = ipmi_init_msghandler();
+        if (rv)
+                return rv;
 
         intf = kzalloc(sizeof(*intf), GFP_KERNEL);
         if (!intf)
@@ -5017,6 +5019,22 @@ static int panic_event(struct notifier_block *this,
         return NOTIFY_DONE;
 }
 
+/* Must be called with ipmi_interfaces_mutex held. */
+static int ipmi_register_driver(void)
+{
+        int rv;
+
+        if (drvregistered)
+                return 0;
+
+        rv = driver_register(&ipmidriver.driver);
+        if (rv)
+                pr_err("Could not register IPMI driver\n");
+        else
+                drvregistered = true;
+        return rv;
+}
+
 static struct notifier_block panic_block = {
         .notifier_call  = panic_event,
         .next           = NULL,
@@ -5027,66 +5045,75 @@ static int ipmi_init_msghandler(void)
 {
         int rv;
 
+        mutex_lock(&ipmi_interfaces_mutex);
+        rv = ipmi_register_driver();
+        if (rv)
+                goto out;
         if (initialized)
-                return 0;
-
-        rv = driver_register(&ipmidriver.driver);
-        if (rv) {
-                pr_err("Could not register IPMI driver\n");
-                return rv;
-        }
+                goto out;
 
-        pr_info("version " IPMI_DRIVER_VERSION "\n");
+        init_srcu_struct(&ipmi_interfaces_srcu);
 
         timer_setup(&ipmi_timer, ipmi_timeout, 0);
         mod_timer(&ipmi_timer, jiffies + IPMI_TIMEOUT_JIFFIES);
 
         atomic_notifier_chain_register(&panic_notifier_list, &panic_block);
 
-        initialized = 1;
+        initialized = true;
 
-        return 0;
+out:
+        mutex_unlock(&ipmi_interfaces_mutex);
+        return rv;
 }
 
 static int __init ipmi_init_msghandler_mod(void)
 {
-        ipmi_init_msghandler();
-        return 0;
+        int rv;
+
+        pr_info("version " IPMI_DRIVER_VERSION "\n");
+
+        mutex_lock(&ipmi_interfaces_mutex);
+        rv = ipmi_register_driver();
+        mutex_unlock(&ipmi_interfaces_mutex);
+
+        return rv;
 }
 
 static void __exit cleanup_ipmi(void)
 {
         int count;
 
-        if (!initialized)
-                return;
-
-        atomic_notifier_chain_unregister(&panic_notifier_list, &panic_block);
+        if (initialized) {
+                atomic_notifier_chain_unregister(&panic_notifier_list,
+                                                 &panic_block);
 
-        /*
-         * This can't be called if any interfaces exist, so no worry
-         * about shutting down the interfaces.
-         */
+                /*
+                 * This can't be called if any interfaces exist, so no worry
+                 * about shutting down the interfaces.
+                 */
 
-        /*
-         * Tell the timer to stop, then wait for it to stop.  This
-         * avoids problems with race conditions removing the timer
-         * here.
-         */
-        atomic_inc(&stop_operation);
-        del_timer_sync(&ipmi_timer);
+                /*
+                 * Tell the timer to stop, then wait for it to stop.  This
+                 * avoids problems with race conditions removing the timer
+                 * here.
+                 */
+                atomic_inc(&stop_operation);
+                del_timer_sync(&ipmi_timer);
 
-        driver_unregister(&ipmidriver.driver);
+                initialized = false;
 
-        initialized = 0;
+                /* Check for buffer leaks. */
+                count = atomic_read(&smi_msg_inuse_count);
+                if (count != 0)
+                        pr_warn("SMI message count %d at exit\n", count);
+                count = atomic_read(&recv_msg_inuse_count);
+                if (count != 0)
+                        pr_warn("recv message count %d at exit\n", count);
 
-        /* Check for buffer leaks. */
-        count = atomic_read(&smi_msg_inuse_count);
-        if (count != 0)
-                pr_warn("SMI message count %d at exit\n", count);
-        count = atomic_read(&recv_msg_inuse_count);
-        if (count != 0)
-                pr_warn("recv message count %d at exit\n", count);
+                cleanup_srcu_struct(&ipmi_interfaces_srcu);
+        }
+        if (drvregistered)
+                driver_unregister(&ipmidriver.driver);
 }
 module_exit(cleanup_ipmi);
 
diff --git a/drivers/char/ipmi/ipmi_ssif.c b/drivers/char/ipmi/ipmi_ssif.c
index ca9528c4f183..b7a1ae2afaea 100644
--- a/drivers/char/ipmi/ipmi_ssif.c
+++ b/drivers/char/ipmi/ipmi_ssif.c
@@ -632,8 +632,9 @@ static void msg_done_handler(struct ssif_info *ssif_info, int result,
 
                 /* Remove the multi-part read marker. */
                 len -= 2;
+                data += 2;
                 for (i = 0; i < len; i++)
-                        ssif_info->data[i] = data[i+2];
+                        ssif_info->data[i] = data[i];
                 ssif_info->multi_len = len;
                 ssif_info->multi_pos = 1;
 
@@ -661,8 +662,19 @@ static void msg_done_handler(struct ssif_info *ssif_info, int result,
                 }
 
                 blocknum = data[0];
+                len--;
+                data++;
+
+                if (blocknum != 0xff && len != 31) {
+                    /* All blocks but the last must have 31 data bytes. */
+                        result = -EIO;
+                        if (ssif_info->ssif_debug & SSIF_DEBUG_MSG)
+                                pr_info("Received middle message <31\n");
 
-                if (ssif_info->multi_len + len - 1 > IPMI_MAX_MSG_LENGTH) {
+                        goto continue_op;
+                }
+
+                if (ssif_info->multi_len + len > IPMI_MAX_MSG_LENGTH) {
                         /* Received message too big, abort the operation. */
                         result = -E2BIG;
                         if (ssif_info->ssif_debug & SSIF_DEBUG_MSG)
@@ -671,16 +683,14 @@ static void msg_done_handler(struct ssif_info *ssif_info, int result,
                         goto continue_op;
                 }
 
-                /* Remove the blocknum from the data. */
-                len--;
                 for (i = 0; i < len; i++)
-                        ssif_info->data[i + ssif_info->multi_len] = data[i + 1];
+                        ssif_info->data[i + ssif_info->multi_len] = data[i];
                 ssif_info->multi_len += len;
                 if (blocknum == 0xff) {
                         /* End of read */
                         len = ssif_info->multi_len;
                         data = ssif_info->data;
-                } else if (blocknum + 1 != ssif_info->multi_pos) {
+                } else if (blocknum != ssif_info->multi_pos) {
                         /*
                          * Out of sequence block, just abort.  Block
                          * numbers start at zero for the second block,
@@ -707,6 +717,7 @@ static void msg_done_handler(struct ssif_info *ssif_info, int result,
                 }
         }
 
+ continue_op:
         if (result < 0) {
                 ssif_inc_stat(ssif_info, receive_errors);
         } else {
@@ -714,8 +725,6 @@ static void msg_done_handler(struct ssif_info *ssif_info, int result,
                 ssif_inc_stat(ssif_info, received_message_parts);
         }
 
-
- continue_op:
         if (ssif_info->ssif_debug & SSIF_DEBUG_STATE)
                 pr_info("DONE 1: state = %d, result=%d\n",
                         ssif_info->ssif_state, result);
diff --git a/drivers/char/mwave/mwavedd.c b/drivers/char/mwave/mwavedd.c
index b5e3103c1175..e43c876a9223 100644
--- a/drivers/char/mwave/mwavedd.c
+++ b/drivers/char/mwave/mwavedd.c
@@ -59,6 +59,7 @@
 #include <linux/mutex.h>
 #include <linux/delay.h>
 #include <linux/serial_8250.h>
+#include <linux/nospec.h>
 #include "smapi.h"
 #include "mwavedd.h"
 #include "3780i.h"
@@ -289,6 +290,8 @@ static long mwave_ioctl(struct file *file, unsigned int iocmd,
                                                 ipcnum);
                                 return -EINVAL;
                         }
+                        ipcnum = array_index_nospec(ipcnum,
+                                                    ARRAY_SIZE(pDrvData->IPCs));
                         PRINTK_3(TRACE_MWAVE,
                                 "mwavedd::mwave_ioctl IOCTL_MW_REGISTER_IPC"
                                 " ipcnum %x entry usIntCount %x\n",
@@ -317,6 +320,8 @@ static long mwave_ioctl(struct file *file, unsigned int iocmd,
                                                 " Invalid ipcnum %x\n", ipcnum);
                                 return -EINVAL;
                         }
+                        ipcnum = array_index_nospec(ipcnum,
+                                                    ARRAY_SIZE(pDrvData->IPCs));
                         PRINTK_3(TRACE_MWAVE,
                                 "mwavedd::mwave_ioctl IOCTL_MW_GET_IPC"
                                 " ipcnum %x, usIntCount %x\n",
@@ -383,6 +388,8 @@ static long mwave_ioctl(struct file *file, unsigned int iocmd,
                                                 ipcnum);
                                 return -EINVAL;
                         }
+                        ipcnum = array_index_nospec(ipcnum,
+                                                    ARRAY_SIZE(pDrvData->IPCs));
                         mutex_lock(&mwave_mutex);
                         if (pDrvData->IPCs[ipcnum].bIsEnabled == true) {
                                 pDrvData->IPCs[ipcnum].bIsEnabled = false;
diff --git a/drivers/clk/Kconfig b/drivers/clk/Kconfig
index e5b2fe80eab4..d2f0bb5ba47e 100644
--- a/drivers/clk/Kconfig
+++ b/drivers/clk/Kconfig
@@ -293,7 +293,6 @@ config COMMON_CLK_BD718XX
 source "drivers/clk/actions/Kconfig"
 source "drivers/clk/bcm/Kconfig"
 source "drivers/clk/hisilicon/Kconfig"
-source "drivers/clk/imx/Kconfig"
 source "drivers/clk/imgtec/Kconfig"
 source "drivers/clk/imx/Kconfig"
 source "drivers/clk/ingenic/Kconfig"
diff --git a/drivers/clk/clk-versaclock5.c b/drivers/clk/clk-versaclock5.c
index 5b393e711e94..7d16ab0784ec 100644
--- a/drivers/clk/clk-versaclock5.c
+++ b/drivers/clk/clk-versaclock5.c
@@ -262,8 +262,10 @@ static int vc5_mux_set_parent(struct clk_hw *hw, u8 index)
 
                 if (vc5->clk_mux_ins == VC5_MUX_IN_XIN)
                         src = VC5_PRIM_SRC_SHDN_EN_XTAL;
-                if (vc5->clk_mux_ins == VC5_MUX_IN_CLKIN)
+                else if (vc5->clk_mux_ins == VC5_MUX_IN_CLKIN)
                         src = VC5_PRIM_SRC_SHDN_EN_CLKIN;
+                else /* Invalid; should have been caught by vc5_probe() */
+                        return -EINVAL;
         }
 
         return regmap_update_bits(vc5->regmap, VC5_PRIM_SRC_SHDN, mask, src);
diff --git a/drivers/clk/clk.c b/drivers/clk/clk.c
index 75d13c0eff12..6ccdbedb02f3 100644
--- a/drivers/clk/clk.c
+++ b/drivers/clk/clk.c
@@ -2779,7 +2779,7 @@ static void clk_dump_one(struct seq_file *s, struct clk_core *c, int level)
         seq_printf(s, "\"protect_count\": %d,", c->protect_count);
         seq_printf(s, "\"rate\": %lu,", clk_core_get_rate(c));
         seq_printf(s, "\"accuracy\": %lu,", clk_core_get_accuracy(c));
-        seq_printf(s, "\"phase\": %d", clk_core_get_phase(c));
+        seq_printf(s, "\"phase\": %d,", clk_core_get_phase(c));
         seq_printf(s, "\"duty_cycle\": %u",
                    clk_core_get_scaled_duty_cycle(c, 100000));
 }
diff --git a/drivers/clk/imx/clk-imx8qxp-lpcg.c b/drivers/clk/imx/clk-imx8qxp-lpcg.c
index 99c2508de8e5..fb6edf1b8aa2 100644
--- a/drivers/clk/imx/clk-imx8qxp-lpcg.c
+++ b/drivers/clk/imx/clk-imx8qxp-lpcg.c
@@ -169,6 +169,8 @@ static int imx8qxp_lpcg_clk_probe(struct platform_device *pdev)
                 return -ENODEV;
 
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res)
+                return -EINVAL;
         base = devm_ioremap(dev, res->start, resource_size(res));
         if (!base)
                 return -ENOMEM;
diff --git a/drivers/clk/qcom/Kconfig b/drivers/clk/qcom/Kconfig
index 1b1ba54e33dd..1c04575c118f 100644
--- a/drivers/clk/qcom/Kconfig
+++ b/drivers/clk/qcom/Kconfig
@@ -215,6 +215,7 @@ config MSM_MMCC_8996
 
 config MSM_GCC_8998
         tristate "MSM8998 Global Clock Controller"
+        select QCOM_GDSC
         help
           Support for the global clock controller on msm8998 devices.
           Say Y if you want to use peripheral devices such as UART, SPI,
diff --git a/drivers/clk/socfpga/clk-pll-s10.c b/drivers/clk/socfpga/clk-pll-s10.c
index 2d5d8b43727e..c4d0b6f6abf2 100644
--- a/drivers/clk/socfpga/clk-pll-s10.c
+++ b/drivers/clk/socfpga/clk-pll-s10.c
@@ -43,7 +43,7 @@ static unsigned long clk_pll_recalc_rate(struct clk_hw *hwclk,
         /* Read mdiv and fdiv from the fdbck register */
         reg = readl(socfpgaclk->hw.reg + 0x4);
         mdiv = (reg & SOCFPGA_PLL_MDIV_MASK) >> SOCFPGA_PLL_MDIV_SHIFT;
-        vco_freq = (unsigned long long)parent_rate * (mdiv + 6);
+        vco_freq = (unsigned long long)vco_freq * (mdiv + 6);
 
         return (unsigned long)vco_freq;
 }
diff --git a/drivers/clk/socfpga/clk-s10.c b/drivers/clk/socfpga/clk-s10.c
index 5b238fc314ac..8281dfbf38c2 100644
--- a/drivers/clk/socfpga/clk-s10.c
+++ b/drivers/clk/socfpga/clk-s10.c
@@ -12,17 +12,17 @@
 
 #include "stratix10-clk.h"
 
-static const char * const pll_mux[] = { "osc1", "cb_intosc_hs_div2_clk",
-                                        "f2s_free_clk",};
+static const char * const pll_mux[] = { "osc1", "cb-intosc-hs-div2-clk",
+                                        "f2s-free-clk",};
 static const char * const cntr_mux[] = { "main_pll", "periph_pll",
-                                         "osc1", "cb_intosc_hs_div2_clk",
-                                         "f2s_free_clk"};
-static const char * const boot_mux[] = { "osc1", "cb_intosc_hs_div2_clk",};
+                                         "osc1", "cb-intosc-hs-div2-clk",
+                                         "f2s-free-clk"};
+static const char * const boot_mux[] = { "osc1", "cb-intosc-hs-div2-clk",};
 
 static const char * const noc_free_mux[] = {"main_noc_base_clk",
                                             "peri_noc_base_clk",
-                                            "osc1", "cb_intosc_hs_div2_clk",
-                                            "f2s_free_clk"};
+                                            "osc1", "cb-intosc-hs-div2-clk",
+                                            "f2s-free-clk"};
 
 static const char * const emaca_free_mux[] = {"peri_emaca_clk", "boot_clk"};
 static const char * const emacb_free_mux[] = {"peri_emacb_clk", "boot_clk"};
@@ -33,14 +33,14 @@ static const char * const s2f_usr1_free_mux[] = {"peri_s2f_usr1_clk", "boot_clk"
 static const char * const psi_ref_free_mux[] = {"peri_psi_ref_clk", "boot_clk"};
 static const char * const mpu_mux[] = { "mpu_free_clk", "boot_clk",};
 
-static const char * const s2f_usr0_mux[] = {"f2s_free_clk", "boot_clk"};
+static const char * const s2f_usr0_mux[] = {"f2s-free-clk", "boot_clk"};
 static const char * const emac_mux[] = {"emaca_free_clk", "emacb_free_clk"};
 static const char * const noc_mux[] = {"noc_free_clk", "boot_clk"};
 
 static const char * const mpu_free_mux[] = {"main_mpu_base_clk",
                                             "peri_mpu_base_clk",
-                                            "osc1", "cb_intosc_hs_div2_clk",
-                                            "f2s_free_clk"};
+                                            "osc1", "cb-intosc-hs-div2-clk",
+                                            "f2s-free-clk"};
 
 /* clocks in AO (always on) controller */
 static const struct stratix10_pll_clock s10_pll_clks[] = {
diff --git a/drivers/clk/tegra/clk-tegra124-dfll-fcpu.c b/drivers/clk/tegra/clk-tegra124-dfll-fcpu.c
index 269d3595758b..edc31bb56674 100644
--- a/drivers/clk/tegra/clk-tegra124-dfll-fcpu.c
+++ b/drivers/clk/tegra/clk-tegra124-dfll-fcpu.c
@@ -133,9 +133,11 @@ static int tegra124_dfll_fcpu_remove(struct platform_device *pdev)
         struct tegra_dfll_soc_data *soc;
 
         soc = tegra_dfll_unregister(pdev);
-        if (IS_ERR(soc))
+        if (IS_ERR(soc)) {
                 dev_err(&pdev->dev, "failed to unregister DFLL: %ld\n",
                         PTR_ERR(soc));
+                return PTR_ERR(soc);
+        }
 
         tegra_cvb_remove_opp_table(soc->dev, soc->cvb, soc->max_freq);
 
diff --git a/drivers/clk/zynqmp/clkc.c b/drivers/clk/zynqmp/clkc.c
index f65cc0ff76ab..b0908ec62f73 100644
--- a/drivers/clk/zynqmp/clkc.c
+++ b/drivers/clk/zynqmp/clkc.c
@@ -669,8 +669,8 @@ static int zynqmp_clk_setup(struct device_node *np)
         if (ret)
                 return ret;
 
-        zynqmp_data = kzalloc(sizeof(*zynqmp_data) + sizeof(*zynqmp_data) *
-                                                clock_max_idx, GFP_KERNEL);
+        zynqmp_data = kzalloc(struct_size(zynqmp_data, hws, clock_max_idx),
+                              GFP_KERNEL);
         if (!zynqmp_data)
                 return -ENOMEM;
 
diff --git a/drivers/cpufreq/cpufreq.c b/drivers/cpufreq/cpufreq.c
index 6f23ebb395f1..e35a886e00bc 100644
--- a/drivers/cpufreq/cpufreq.c
+++ b/drivers/cpufreq/cpufreq.c
@@ -1530,17 +1530,16 @@ static unsigned int __cpufreq_get(struct cpufreq_policy *policy)
 {
         unsigned int ret_freq = 0;
 
-        if (!cpufreq_driver->get)
+        if (unlikely(policy_is_inactive(policy)) || !cpufreq_driver->get)
                 return ret_freq;
 
         ret_freq = cpufreq_driver->get(policy->cpu);
 
         /*
-         * Updating inactive policies is invalid, so avoid doing that.  Also
-         * if fast frequency switching is used with the given policy, the check
+         * If fast frequency switching is used with the given policy, the check
          * against policy->cur is pointless, so skip it in that case too.
          */
-        if (unlikely(policy_is_inactive(policy)) || policy->fast_switch_enabled)
+        if (policy->fast_switch_enabled)
                 return ret_freq;
 
         if (ret_freq && policy->cur &&
@@ -1569,10 +1568,7 @@ unsigned int cpufreq_get(unsigned int cpu)
 
         if (policy) {
                 down_read(&policy->rwsem);
-
-                if (!policy_is_inactive(policy))
-                        ret_freq = __cpufreq_get(policy);
-
+                ret_freq = __cpufreq_get(policy);
                 up_read(&policy->rwsem);
 
                 cpufreq_cpu_put(policy);
diff --git a/drivers/cpufreq/scmi-cpufreq.c b/drivers/cpufreq/scmi-cpufreq.c
index 50b1551ba894..242c3370544e 100644
--- a/drivers/cpufreq/scmi-cpufreq.c
+++ b/drivers/cpufreq/scmi-cpufreq.c
@@ -52,9 +52,9 @@ scmi_cpufreq_set_target(struct cpufreq_policy *policy, unsigned int index)
         int ret;
         struct scmi_data *priv = policy->driver_data;
         struct scmi_perf_ops *perf_ops = handle->perf_ops;
-        u64 freq = policy->freq_table[index].frequency * 1000;
+        u64 freq = policy->freq_table[index].frequency;
 
-        ret = perf_ops->freq_set(handle, priv->domain_id, freq, false);
+        ret = perf_ops->freq_set(handle, priv->domain_id, freq * 1000, false);
         if (!ret)
                 arch_set_freq_scale(policy->related_cpus, freq,
                                     policy->cpuinfo.max_freq);
@@ -176,7 +176,7 @@ static int scmi_cpufreq_init(struct cpufreq_policy *policy)
 out_free_priv:
         kfree(priv);
 out_free_opp:
-        dev_pm_opp_cpumask_remove_table(policy->cpus);
+        dev_pm_opp_remove_all_dynamic(cpu_dev);
 
         return ret;
 }
@@ -188,7 +188,7 @@ static int scmi_cpufreq_exit(struct cpufreq_policy *policy)
         cpufreq_cooling_unregister(priv->cdev);
         dev_pm_opp_free_cpufreq_table(priv->cpu_dev, &policy->freq_table);
         kfree(priv);
-        dev_pm_opp_cpumask_remove_table(policy->related_cpus);
+        dev_pm_opp_remove_all_dynamic(priv->cpu_dev);
 
         return 0;
 }
diff --git a/drivers/cpufreq/scpi-cpufreq.c b/drivers/cpufreq/scpi-cpufreq.c
index 87a98ec77773..99449738faa4 100644
--- a/drivers/cpufreq/scpi-cpufreq.c
+++ b/drivers/cpufreq/scpi-cpufreq.c
@@ -177,7 +177,7 @@ out_free_cpufreq_table:
 out_free_priv:
         kfree(priv);
 out_free_opp:
-        dev_pm_opp_cpumask_remove_table(policy->cpus);
+        dev_pm_opp_remove_all_dynamic(cpu_dev);
 
         return ret;
 }
@@ -190,7 +190,7 @@ static int scpi_cpufreq_exit(struct cpufreq_policy *policy)
         clk_put(priv->clk);
         dev_pm_opp_free_cpufreq_table(priv->cpu_dev, &policy->freq_table);
         kfree(priv);
-        dev_pm_opp_cpumask_remove_table(policy->related_cpus);
+        dev_pm_opp_remove_all_dynamic(priv->cpu_dev);
 
         return 0;
 }
diff --git a/drivers/crypto/Kconfig b/drivers/crypto/Kconfig
index 5a90075f719d..0be55fcc19ba 100644
--- a/drivers/crypto/Kconfig
+++ b/drivers/crypto/Kconfig
@@ -692,6 +692,7 @@ config CRYPTO_DEV_BCM_SPU
         depends on ARCH_BCM_IPROC
         depends on MAILBOX
         default m
+        select CRYPTO_AUTHENC
         select CRYPTO_DES
         select CRYPTO_MD5
         select CRYPTO_SHA1
diff --git a/drivers/crypto/amcc/crypto4xx_core.c b/drivers/crypto/amcc/crypto4xx_core.c
index 63cb6956c948..acf79889d903 100644
--- a/drivers/crypto/amcc/crypto4xx_core.c
+++ b/drivers/crypto/amcc/crypto4xx_core.c
@@ -283,9 +283,9 @@ static u32 crypto4xx_put_pd_to_pdr(struct crypto4xx_device *dev, u32 idx)
  */
 static u32 crypto4xx_build_gdr(struct crypto4xx_device *dev)
 {
-        dev->gdr = dma_zalloc_coherent(dev->core_dev->device,
-                                       sizeof(struct ce_gd) * PPC4XX_NUM_GD,
-                                       &dev->gdr_pa, GFP_ATOMIC);
+        dev->gdr = dma_alloc_coherent(dev->core_dev->device,
+                                      sizeof(struct ce_gd) * PPC4XX_NUM_GD,
+                                      &dev->gdr_pa, GFP_ATOMIC);
         if (!dev->gdr)
                 return -ENOMEM;
 
diff --git a/drivers/crypto/bcm/cipher.c b/drivers/crypto/bcm/cipher.c
index c9393ffb70ed..5567cbda2798 100644
--- a/drivers/crypto/bcm/cipher.c
+++ b/drivers/crypto/bcm/cipher.c
@@ -2845,44 +2845,28 @@ static int aead_authenc_setkey(struct crypto_aead *cipher,
         struct spu_hw *spu = &iproc_priv.spu;
         struct iproc_ctx_s *ctx = crypto_aead_ctx(cipher);
         struct crypto_tfm *tfm = crypto_aead_tfm(cipher);
-        struct rtattr *rta = (void *)key;
-        struct crypto_authenc_key_param *param;
-        const u8 *origkey = key;
-        const unsigned int origkeylen = keylen;
-
-        int ret = 0;
+        struct crypto_authenc_keys keys;
+        int ret;
 
         flow_log("%s() aead:%p key:%p keylen:%u\n", __func__, cipher, key,
                  keylen);
         flow_dump("  key: ", key, keylen);
 
-        if (!RTA_OK(rta, keylen))
-                goto badkey;
-        if (rta->rta_type != CRYPTO_AUTHENC_KEYA_PARAM)
-                goto badkey;
-        if (RTA_PAYLOAD(rta) < sizeof(*param))
+        ret = crypto_authenc_extractkeys(&keys, key, keylen);
+        if (ret)
                 goto badkey;
 
-        param = RTA_DATA(rta);
-        ctx->enckeylen = be32_to_cpu(param->enckeylen);
-
-        key += RTA_ALIGN(rta->rta_len);
-        keylen -= RTA_ALIGN(rta->rta_len);
-
-        if (keylen < ctx->enckeylen)
-                goto badkey;
-        if (ctx->enckeylen > MAX_KEY_SIZE)
+        if (keys.enckeylen > MAX_KEY_SIZE ||
+            keys.authkeylen > MAX_KEY_SIZE)
                 goto badkey;
 
-        ctx->authkeylen = keylen - ctx->enckeylen;
-
-        if (ctx->authkeylen > MAX_KEY_SIZE)
-                goto badkey;
+        ctx->enckeylen = keys.enckeylen;
+        ctx->authkeylen = keys.authkeylen;
 
-        memcpy(ctx->enckey, key + ctx->authkeylen, ctx->enckeylen);
+        memcpy(ctx->enckey, keys.enckey, keys.enckeylen);
         /* May end up padding auth key. So make sure it's zeroed. */
         memset(ctx->authkey, 0, sizeof(ctx->authkey));
-        memcpy(ctx->authkey, key, ctx->authkeylen);
+        memcpy(ctx->authkey, keys.authkey, keys.authkeylen);
 
         switch (ctx->alg->cipher_info.alg) {
         case CIPHER_ALG_DES:
@@ -2890,7 +2874,7 @@ static int aead_authenc_setkey(struct crypto_aead *cipher,
                         u32 tmp[DES_EXPKEY_WORDS];
                         u32 flags = CRYPTO_TFM_RES_WEAK_KEY;
 
-                        if (des_ekey(tmp, key) == 0) {
+                        if (des_ekey(tmp, keys.enckey) == 0) {
                                 if (crypto_aead_get_flags(cipher) &
                                     CRYPTO_TFM_REQ_WEAK_KEY) {
                                         crypto_aead_set_flags(cipher, flags);
@@ -2905,7 +2889,7 @@ static int aead_authenc_setkey(struct crypto_aead *cipher,
                 break;
         case CIPHER_ALG_3DES:
                 if (ctx->enckeylen == (DES_KEY_SIZE * 3)) {
-                        const u32 *K = (const u32 *)key;
+                        const u32 *K = (const u32 *)keys.enckey;
                         u32 flags = CRYPTO_TFM_RES_BAD_KEY_SCHED;
 
                         if (!((K[0] ^ K[2]) | (K[1] ^ K[3])) ||
@@ -2956,9 +2940,7 @@ static int aead_authenc_setkey(struct crypto_aead *cipher,
                 ctx->fallback_cipher->base.crt_flags &= ~CRYPTO_TFM_REQ_MASK;
                 ctx->fallback_cipher->base.crt_flags |=
                     tfm->crt_flags & CRYPTO_TFM_REQ_MASK;
-                ret =
-                    crypto_aead_setkey(ctx->fallback_cipher, origkey,
-                                       origkeylen);
+                ret = crypto_aead_setkey(ctx->fallback_cipher, key, keylen);
                 if (ret) {
                         flow_log("  fallback setkey() returned:%d\n", ret);
                         tfm->crt_flags &= ~CRYPTO_TFM_RES_MASK;
diff --git a/drivers/crypto/caam/caamalg.c b/drivers/crypto/caam/caamalg.c
index 92e593e2069a..80ae69f906fb 100644
--- a/drivers/crypto/caam/caamalg.c
+++ b/drivers/crypto/caam/caamalg.c
@@ -3476,7 +3476,7 @@ static int __init caam_algapi_init(void)
                  * Skip algorithms requiring message digests
                  * if MD or MD size is not supported by device.
                  */
-                if ((c2_alg_sel & ~OP_ALG_ALGSEL_SUBMASK) == 0x40 &&
+                if (is_mdha(c2_alg_sel) &&
                     (!md_inst || t_alg->aead.maxauthsize > md_limit))
                         continue;
 
diff --git a/drivers/crypto/caam/caamhash.c b/drivers/crypto/caam/caamhash.c
index 81712aa5d0f2..bb1a2cdf1951 100644
--- a/drivers/crypto/caam/caamhash.c
+++ b/drivers/crypto/caam/caamhash.c
@@ -1072,13 +1072,16 @@ static int ahash_final_no_ctx(struct ahash_request *req)
 
         desc = edesc->hw_desc;
 
-        state->buf_dma = dma_map_single(jrdev, buf, buflen, DMA_TO_DEVICE);
-        if (dma_mapping_error(jrdev, state->buf_dma)) {
-                dev_err(jrdev, "unable to map src\n");
-                goto unmap;
-        }
+        if (buflen) {
+                state->buf_dma = dma_map_single(jrdev, buf, buflen,
+                                                DMA_TO_DEVICE);
+                if (dma_mapping_error(jrdev, state->buf_dma)) {
+                        dev_err(jrdev, "unable to map src\n");
+                        goto unmap;
+                }
 
-        append_seq_in_ptr(desc, state->buf_dma, buflen, 0);
+                append_seq_in_ptr(desc, state->buf_dma, buflen, 0);
+        }
 
         edesc->dst_dma = map_seq_out_ptr_result(desc, jrdev, req->result,
                                                 digestsize);
diff --git a/drivers/crypto/caam/desc.h b/drivers/crypto/caam/desc.h
index ec10230178c5..4b6854bf896a 100644
--- a/drivers/crypto/caam/desc.h
+++ b/drivers/crypto/caam/desc.h
@@ -1155,6 +1155,7 @@
 #define OP_ALG_ALGSEL_DES       (0x20 << OP_ALG_ALGSEL_SHIFT)
 #define OP_ALG_ALGSEL_3DES      (0x21 << OP_ALG_ALGSEL_SHIFT)
 #define OP_ALG_ALGSEL_ARC4      (0x30 << OP_ALG_ALGSEL_SHIFT)
+#define OP_ALG_CHA_MDHA         (0x40 << OP_ALG_ALGSEL_SHIFT)
 #define OP_ALG_ALGSEL_MD5       (0x40 << OP_ALG_ALGSEL_SHIFT)
 #define OP_ALG_ALGSEL_SHA1      (0x41 << OP_ALG_ALGSEL_SHIFT)
 #define OP_ALG_ALGSEL_SHA224    (0x42 << OP_ALG_ALGSEL_SHIFT)
diff --git a/drivers/crypto/caam/error.h b/drivers/crypto/caam/error.h
index 67ea94079837..8c6b83e02a70 100644
--- a/drivers/crypto/caam/error.h
+++ b/drivers/crypto/caam/error.h
@@ -7,6 +7,9 @@
 
 #ifndef CAAM_ERROR_H
 #define CAAM_ERROR_H
+
+#include "desc.h"
+
 #define CAAM_ERROR_STR_MAX 302
 
 void caam_strstatus(struct device *dev, u32 status, bool qi_v2);
@@ -17,4 +20,10 @@ void caam_strstatus(struct device *dev, u32 status, bool qi_v2);
 void caam_dump_sg(const char *level, const char *prefix_str, int prefix_type,
                   int rowsize, int groupsize, struct scatterlist *sg,
                   size_t tlen, bool ascii);
+
+static inline bool is_mdha(u32 algtype)
+{
+        return (algtype & OP_ALG_ALGSEL_MASK & ~OP_ALG_ALGSEL_SUBMASK) ==
+               OP_ALG_CHA_MDHA;
+}
 #endif /* CAAM_ERROR_H */
diff --git a/drivers/crypto/cavium/cpt/cptpf_main.c b/drivers/crypto/cavium/cpt/cptpf_main.c
index 06ad85ab5e86..a876535529d1 100644
--- a/drivers/crypto/cavium/cpt/cptpf_main.c
+++ b/drivers/crypto/cavium/cpt/cptpf_main.c
@@ -278,8 +278,8 @@ static int cpt_ucode_load_fw(struct cpt_device *cpt, const u8 *fw, bool is_ae)
         mcode->num_cores = is_ae ? 6 : 10;
 
         /*  Allocate DMAable space */
-        mcode->code = dma_zalloc_coherent(&cpt->pdev->dev, mcode->code_size,
-                                          &mcode->phys_base, GFP_KERNEL);
+        mcode->code = dma_alloc_coherent(&cpt->pdev->dev, mcode->code_size,
+                                         &mcode->phys_base, GFP_KERNEL);
         if (!mcode->code) {
                 dev_err(dev, "Unable to allocate space for microcode");
                 ret = -ENOMEM;
diff --git a/drivers/crypto/cavium/cpt/cptvf_main.c b/drivers/crypto/cavium/cpt/cptvf_main.c
index 5c796ed55eba..2ca431ed1db8 100644
--- a/drivers/crypto/cavium/cpt/cptvf_main.c
+++ b/drivers/crypto/cavium/cpt/cptvf_main.c
@@ -236,9 +236,10 @@ static int alloc_command_queues(struct cpt_vf *cptvf,
 
                         c_size = (rem_q_size > qcsize_bytes) ? qcsize_bytes :
                                         rem_q_size;
-                        curr->head = (u8 *)dma_zalloc_coherent(&pdev->dev,
-                                          c_size + CPT_NEXT_CHUNK_PTR_SIZE,
-                                          &curr->dma_addr, GFP_KERNEL);
+                        curr->head = (u8 *)dma_alloc_coherent(&pdev->dev,
+                                                              c_size + CPT_NEXT_CHUNK_PTR_SIZE,
+                                                              &curr->dma_addr,
+                                                              GFP_KERNEL);
                         if (!curr->head) {
                                 dev_err(&pdev->dev, "Command Q (%d) chunk (%d) allocation failed\n",
                                         i, queue->nchunks);
diff --git a/drivers/crypto/cavium/nitrox/nitrox_lib.c b/drivers/crypto/cavium/nitrox/nitrox_lib.c
index 9138bae12521..4ace9bcd603a 100644
--- a/drivers/crypto/cavium/nitrox/nitrox_lib.c
+++ b/drivers/crypto/cavium/nitrox/nitrox_lib.c
@@ -25,9 +25,9 @@ static int nitrox_cmdq_init(struct nitrox_cmdq *cmdq, int align_bytes)
         struct nitrox_device *ndev = cmdq->ndev;
 
         cmdq->qsize = (ndev->qlen * cmdq->instr_size) + align_bytes;
-        cmdq->unalign_base = dma_zalloc_coherent(DEV(ndev), cmdq->qsize,
-                                                 &cmdq->unalign_dma,
-                                                 GFP_KERNEL);
+        cmdq->unalign_base = dma_alloc_coherent(DEV(ndev), cmdq->qsize,
+                                                &cmdq->unalign_dma,
+                                                GFP_KERNEL);
         if (!cmdq->unalign_base)
                 return -ENOMEM;
 
diff --git a/drivers/crypto/cavium/nitrox/nitrox_reqmgr.c b/drivers/crypto/cavium/nitrox/nitrox_reqmgr.c
index e34e4df8fd24..fe070d75c842 100644
--- a/drivers/crypto/cavium/nitrox/nitrox_reqmgr.c
+++ b/drivers/crypto/cavium/nitrox/nitrox_reqmgr.c
@@ -567,10 +567,10 @@ static void process_response_list(struct nitrox_cmdq *cmdq)
 
                 /* ORH error code */
                 err = READ_ONCE(*sr->resp.orh) & 0xff;
-                softreq_destroy(sr);
 
                 if (sr->callback)
                         sr->callback(sr->cb_arg, err);
+                softreq_destroy(sr);
 
                 req_completed++;
         }
diff --git a/drivers/crypto/ccp/ccp-dev-v5.c b/drivers/crypto/ccp/ccp-dev-v5.c
index 44a4d2779b15..c9bfd4f439ce 100644
--- a/drivers/crypto/ccp/ccp-dev-v5.c
+++ b/drivers/crypto/ccp/ccp-dev-v5.c
@@ -822,9 +822,9 @@ static int ccp5_init(struct ccp_device *ccp)
                 /* Page alignment satisfies our needs for N <= 128 */
                 BUILD_BUG_ON(COMMANDS_PER_QUEUE > 128);
                 cmd_q->qsize = Q_SIZE(Q_DESC_SIZE);
-                cmd_q->qbase = dma_zalloc_coherent(dev, cmd_q->qsize,
-                                                   &cmd_q->qbase_dma,
-                                                   GFP_KERNEL);
+                cmd_q->qbase = dma_alloc_coherent(dev, cmd_q->qsize,
+                                                  &cmd_q->qbase_dma,
+                                                  GFP_KERNEL);
                 if (!cmd_q->qbase) {
                         dev_err(dev, "unable to allocate command queue\n");
                         ret = -ENOMEM;
diff --git a/drivers/crypto/ccree/cc_aead.c b/drivers/crypto/ccree/cc_aead.c
index f2643cda45db..a3527c00b29a 100644
--- a/drivers/crypto/ccree/cc_aead.c
+++ b/drivers/crypto/ccree/cc_aead.c
@@ -549,13 +549,12 @@ static int cc_aead_setkey(struct crypto_aead *tfm, const u8 *key,
                           unsigned int keylen)
 {
         struct cc_aead_ctx *ctx = crypto_aead_ctx(tfm);
-        struct rtattr *rta = (struct rtattr *)key;
         struct cc_crypto_req cc_req = {};
-        struct crypto_authenc_key_param *param;
         struct cc_hw_desc desc[MAX_AEAD_SETKEY_SEQ];
-        int rc = -EINVAL;
         unsigned int seq_len = 0;
         struct device *dev = drvdata_to_dev(ctx->drvdata);
+        const u8 *enckey, *authkey;
+        int rc;
 
         dev_dbg(dev, "Setting key in context @%p for %s. key=%p keylen=%u\n",
                 ctx, crypto_tfm_alg_name(crypto_aead_tfm(tfm)), key, keylen);
@@ -563,35 +562,33 @@ static int cc_aead_setkey(struct crypto_aead *tfm, const u8 *key,
         /* STAT_PHASE_0: Init and sanity checks */
 
         if (ctx->auth_mode != DRV_HASH_NULL) { /* authenc() alg. */
-                if (!RTA_OK(rta, keylen))
-                        goto badkey;
-                if (rta->rta_type != CRYPTO_AUTHENC_KEYA_PARAM)
-                        goto badkey;
-                if (RTA_PAYLOAD(rta) < sizeof(*param))
-                        goto badkey;
-                param = RTA_DATA(rta);
-                ctx->enc_keylen = be32_to_cpu(param->enckeylen);
-                key += RTA_ALIGN(rta->rta_len);
-                keylen -= RTA_ALIGN(rta->rta_len);
-                if (keylen < ctx->enc_keylen)
+                struct crypto_authenc_keys keys;
+
+                rc = crypto_authenc_extractkeys(&keys, key, keylen);
+                if (rc)
                         goto badkey;
-                ctx->auth_keylen = keylen - ctx->enc_keylen;
+                enckey = keys.enckey;
+                authkey = keys.authkey;
+                ctx->enc_keylen = keys.enckeylen;
+                ctx->auth_keylen = keys.authkeylen;
 
                 if (ctx->cipher_mode == DRV_CIPHER_CTR) {
                         /* the nonce is stored in bytes at end of key */
+                        rc = -EINVAL;
                         if (ctx->enc_keylen <
                             (AES_MIN_KEY_SIZE + CTR_RFC3686_NONCE_SIZE))
                                 goto badkey;
                         /* Copy nonce from last 4 bytes in CTR key to
                          *  first 4 bytes in CTR IV
                          */
-                        memcpy(ctx->ctr_nonce, key + ctx->auth_keylen +
-                               ctx->enc_keylen - CTR_RFC3686_NONCE_SIZE,
-                               CTR_RFC3686_NONCE_SIZE);
+                        memcpy(ctx->ctr_nonce, enckey + ctx->enc_keylen -
+                               CTR_RFC3686_NONCE_SIZE, CTR_RFC3686_NONCE_SIZE);
                         /* Set CTR key size */
                         ctx->enc_keylen -= CTR_RFC3686_NONCE_SIZE;
                 }
         } else { /* non-authenc - has just one key */
+                enckey = key;
+                authkey = NULL;
                 ctx->enc_keylen = keylen;
                 ctx->auth_keylen = 0;
         }
@@ -603,13 +600,14 @@ static int cc_aead_setkey(struct crypto_aead *tfm, const u8 *key,
         /* STAT_PHASE_1: Copy key to ctx */
 
         /* Get key material */
-        memcpy(ctx->enckey, key + ctx->auth_keylen, ctx->enc_keylen);
+        memcpy(ctx->enckey, enckey, ctx->enc_keylen);
         if (ctx->enc_keylen == 24)
                 memset(ctx->enckey + 24, 0, CC_AES_KEY_SIZE_MAX - 24);
         if (ctx->auth_mode == DRV_HASH_XCBC_MAC) {
-                memcpy(ctx->auth_state.xcbc.xcbc_keys, key, ctx->auth_keylen);
+                memcpy(ctx->auth_state.xcbc.xcbc_keys, authkey,
+                       ctx->auth_keylen);
         } else if (ctx->auth_mode != DRV_HASH_NULL) { /* HMAC */
-                rc = cc_get_plain_hmac_key(tfm, key, ctx->auth_keylen);
+                rc = cc_get_plain_hmac_key(tfm, authkey, ctx->auth_keylen);
                 if (rc)
                         goto badkey;
         }
diff --git a/drivers/crypto/hisilicon/sec/sec_algs.c b/drivers/crypto/hisilicon/sec/sec_algs.c
index cdc4f9a171d9..adc0cd8ae97b 100644
--- a/drivers/crypto/hisilicon/sec/sec_algs.c
+++ b/drivers/crypto/hisilicon/sec/sec_algs.c
@@ -241,8 +241,8 @@ static int sec_alg_skcipher_setkey(struct crypto_skcipher *tfm,
                 memset(ctx->key, 0, SEC_MAX_CIPHER_KEY);
         } else {
                 /* new key */
-                ctx->key = dma_zalloc_coherent(dev, SEC_MAX_CIPHER_KEY,
-                                               &ctx->pkey, GFP_KERNEL);
+                ctx->key = dma_alloc_coherent(dev, SEC_MAX_CIPHER_KEY,
+                                              &ctx->pkey, GFP_KERNEL);
                 if (!ctx->key) {
                         mutex_unlock(&ctx->lock);
                         return -ENOMEM;
diff --git a/drivers/crypto/hisilicon/sec/sec_drv.c b/drivers/crypto/hisilicon/sec/sec_drv.c
index c1ee4e7bf996..91ee2bb575df 100644
--- a/drivers/crypto/hisilicon/sec/sec_drv.c
+++ b/drivers/crypto/hisilicon/sec/sec_drv.c
@@ -1082,9 +1082,8 @@ static int sec_queue_res_cfg(struct sec_queue *queue)
         struct sec_queue_ring_db *ring_db = &queue->ring_db;
         int ret;
 
-        ring_cmd->vaddr = dma_zalloc_coherent(dev, SEC_Q_CMD_SIZE,
-                                              &ring_cmd->paddr,
-                                              GFP_KERNEL);
+        ring_cmd->vaddr = dma_alloc_coherent(dev, SEC_Q_CMD_SIZE,
+                                             &ring_cmd->paddr, GFP_KERNEL);
         if (!ring_cmd->vaddr)
                 return -ENOMEM;
 
@@ -1092,17 +1091,15 @@ static int sec_queue_res_cfg(struct sec_queue *queue)
         mutex_init(&ring_cmd->lock);
         ring_cmd->callback = sec_alg_callback;
 
-        ring_cq->vaddr = dma_zalloc_coherent(dev, SEC_Q_CQ_SIZE,
-                                             &ring_cq->paddr,
-                                             GFP_KERNEL);
+        ring_cq->vaddr = dma_alloc_coherent(dev, SEC_Q_CQ_SIZE,
+                                            &ring_cq->paddr, GFP_KERNEL);
         if (!ring_cq->vaddr) {
                 ret = -ENOMEM;
                 goto err_free_ring_cmd;
         }
 
-        ring_db->vaddr = dma_zalloc_coherent(dev, SEC_Q_DB_SIZE,
-                                             &ring_db->paddr,
-                                             GFP_KERNEL);
+        ring_db->vaddr = dma_alloc_coherent(dev, SEC_Q_DB_SIZE,
+                                            &ring_db->paddr, GFP_KERNEL);
         if (!ring_db->vaddr) {
                 ret = -ENOMEM;
                 goto err_free_ring_cq;
diff --git a/drivers/crypto/ixp4xx_crypto.c b/drivers/crypto/ixp4xx_crypto.c
index 19fba998b86b..1b0d156bb9be 100644
--- a/drivers/crypto/ixp4xx_crypto.c
+++ b/drivers/crypto/ixp4xx_crypto.c
@@ -260,9 +260,9 @@ static int setup_crypt_desc(void)
 {
         struct device *dev = &pdev->dev;
         BUILD_BUG_ON(sizeof(struct crypt_ctl) != 64);
-        crypt_virt = dma_zalloc_coherent(dev,
-                                         NPE_QLEN * sizeof(struct crypt_ctl),
-                                         &crypt_phys, GFP_ATOMIC);
+        crypt_virt = dma_alloc_coherent(dev,
+                                        NPE_QLEN * sizeof(struct crypt_ctl),
+                                        &crypt_phys, GFP_ATOMIC);
         if (!crypt_virt)
                 return -ENOMEM;
         return 0;
diff --git a/drivers/crypto/mediatek/mtk-platform.c b/drivers/crypto/mediatek/mtk-platform.c
index ee0404e27a0f..5660e5e5e022 100644
--- a/drivers/crypto/mediatek/mtk-platform.c
+++ b/drivers/crypto/mediatek/mtk-platform.c
@@ -453,17 +453,17 @@ static int mtk_desc_ring_alloc(struct mtk_cryp *cryp)
                 if (!ring[i])
                         goto err_cleanup;
 
-                ring[i]->cmd_base = dma_zalloc_coherent(cryp->dev,
-                                           MTK_DESC_RING_SZ,
-                                           &ring[i]->cmd_dma,
-                                           GFP_KERNEL);
+                ring[i]->cmd_base = dma_alloc_coherent(cryp->dev,
+                                                       MTK_DESC_RING_SZ,
+                                                       &ring[i]->cmd_dma,
+                                                       GFP_KERNEL);
                 if (!ring[i]->cmd_base)
                         goto err_cleanup;
 
-                ring[i]->res_base = dma_zalloc_coherent(cryp->dev,
-                                           MTK_DESC_RING_SZ,
-                                           &ring[i]->res_dma,
-                                           GFP_KERNEL);
+                ring[i]->res_base = dma_alloc_coherent(cryp->dev,
+                                                       MTK_DESC_RING_SZ,
+                                                       &ring[i]->res_dma,
+                                                       GFP_KERNEL);
                 if (!ring[i]->res_base)
                         goto err_cleanup;
 
diff --git a/drivers/crypto/qat/qat_common/adf_admin.c b/drivers/crypto/qat/qat_common/adf_admin.c
index 3744b22f0c46..d28cba34773e 100644
--- a/drivers/crypto/qat/qat_common/adf_admin.c
+++ b/drivers/crypto/qat/qat_common/adf_admin.c
@@ -244,18 +244,18 @@ int adf_init_admin_comms(struct adf_accel_dev *accel_dev)
                              dev_to_node(&GET_DEV(accel_dev)));
         if (!admin)
                 return -ENOMEM;
-        admin->virt_addr = dma_zalloc_coherent(&GET_DEV(accel_dev), PAGE_SIZE,
-                                               &admin->phy_addr, GFP_KERNEL);
+        admin->virt_addr = dma_alloc_coherent(&GET_DEV(accel_dev), PAGE_SIZE,
+                                              &admin->phy_addr, GFP_KERNEL);
         if (!admin->virt_addr) {
                 dev_err(&GET_DEV(accel_dev), "Failed to allocate dma buff\n");
                 kfree(admin);
                 return -ENOMEM;
         }
 
-        admin->virt_tbl_addr = dma_zalloc_coherent(&GET_DEV(accel_dev),
-                                                   PAGE_SIZE,
-                                                   &admin->const_tbl_addr,
-                                                   GFP_KERNEL);
+        admin->virt_tbl_addr = dma_alloc_coherent(&GET_DEV(accel_dev),
+                                                  PAGE_SIZE,
+                                                  &admin->const_tbl_addr,
+                                                  GFP_KERNEL);
         if (!admin->virt_tbl_addr) {
                 dev_err(&GET_DEV(accel_dev), "Failed to allocate const_tbl\n");
                 dma_free_coherent(&GET_DEV(accel_dev), PAGE_SIZE,
diff --git a/drivers/crypto/qat/qat_common/qat_algs.c b/drivers/crypto/qat/qat_common/qat_algs.c
index d2698299896f..975c75198f56 100644
--- a/drivers/crypto/qat/qat_common/qat_algs.c
+++ b/drivers/crypto/qat/qat_common/qat_algs.c
@@ -601,15 +601,15 @@ static int qat_alg_aead_setkey(struct crypto_aead *tfm, const uint8_t *key,
 
                 dev = &GET_DEV(inst->accel_dev);
                 ctx->inst = inst;
-                ctx->enc_cd = dma_zalloc_coherent(dev, sizeof(*ctx->enc_cd),
-                                                  &ctx->enc_cd_paddr,
-                                                  GFP_ATOMIC);
+                ctx->enc_cd = dma_alloc_coherent(dev, sizeof(*ctx->enc_cd),
+                                                 &ctx->enc_cd_paddr,
+                                                 GFP_ATOMIC);
                 if (!ctx->enc_cd) {
                         return -ENOMEM;
                 }
-                ctx->dec_cd = dma_zalloc_coherent(dev, sizeof(*ctx->dec_cd),
-                                                  &ctx->dec_cd_paddr,
-                                                  GFP_ATOMIC);
+                ctx->dec_cd = dma_alloc_coherent(dev, sizeof(*ctx->dec_cd),
+                                                 &ctx->dec_cd_paddr,
+                                                 GFP_ATOMIC);
                 if (!ctx->dec_cd) {
                         goto out_free_enc;
                 }
@@ -933,16 +933,16 @@ static int qat_alg_ablkcipher_setkey(struct crypto_ablkcipher *tfm,
 
                 dev = &GET_DEV(inst->accel_dev);
                 ctx->inst = inst;
-                ctx->enc_cd = dma_zalloc_coherent(dev, sizeof(*ctx->enc_cd),
-                                                  &ctx->enc_cd_paddr,
-                                                  GFP_ATOMIC);
+                ctx->enc_cd = dma_alloc_coherent(dev, sizeof(*ctx->enc_cd),
+                                                 &ctx->enc_cd_paddr,
+                                                 GFP_ATOMIC);
                 if (!ctx->enc_cd) {
                         spin_unlock(&ctx->lock);
                         return -ENOMEM;
                 }
-                ctx->dec_cd = dma_zalloc_coherent(dev, sizeof(*ctx->dec_cd),
-                                                  &ctx->dec_cd_paddr,
-                                                  GFP_ATOMIC);
+                ctx->dec_cd = dma_alloc_coherent(dev, sizeof(*ctx->dec_cd),
+                                                 &ctx->dec_cd_paddr,
+                                                 GFP_ATOMIC);
                 if (!ctx->dec_cd) {
                         spin_unlock(&ctx->lock);
                         goto out_free_enc;
diff --git a/drivers/crypto/qat/qat_common/qat_asym_algs.c b/drivers/crypto/qat/qat_common/qat_asym_algs.c
index 320e7854b4ee..c9f324730d71 100644
--- a/drivers/crypto/qat/qat_common/qat_asym_algs.c
+++ b/drivers/crypto/qat/qat_common/qat_asym_algs.c
@@ -332,10 +332,10 @@ static int qat_dh_compute_value(struct kpp_request *req)
                 } else {
                         int shift = ctx->p_size - req->src_len;
 
-                        qat_req->src_align = dma_zalloc_coherent(dev,
-                                                                 ctx->p_size,
-                                                                 &qat_req->in.dh.in.b,
-                                                                 GFP_KERNEL);
+                        qat_req->src_align = dma_alloc_coherent(dev,
+                                                                ctx->p_size,
+                                                                &qat_req->in.dh.in.b,
+                                                                GFP_KERNEL);
                         if (unlikely(!qat_req->src_align))
                                 return ret;
 
@@ -360,9 +360,9 @@ static int qat_dh_compute_value(struct kpp_request *req)
                         goto unmap_src;
 
         } else {
-                qat_req->dst_align = dma_zalloc_coherent(dev, ctx->p_size,
-                                                         &qat_req->out.dh.r,
-                                                         GFP_KERNEL);
+                qat_req->dst_align = dma_alloc_coherent(dev, ctx->p_size,
+                                                        &qat_req->out.dh.r,
+                                                        GFP_KERNEL);
                 if (unlikely(!qat_req->dst_align))
                         goto unmap_src;
         }
@@ -447,7 +447,7 @@ static int qat_dh_set_params(struct qat_dh_ctx *ctx, struct dh *params)
                 return -EINVAL;
 
         ctx->p_size = params->p_size;
-        ctx->p = dma_zalloc_coherent(dev, ctx->p_size, &ctx->dma_p, GFP_KERNEL);
+        ctx->p = dma_alloc_coherent(dev, ctx->p_size, &ctx->dma_p, GFP_KERNEL);
         if (!ctx->p)
                 return -ENOMEM;
         memcpy(ctx->p, params->p, ctx->p_size);
@@ -458,7 +458,7 @@ static int qat_dh_set_params(struct qat_dh_ctx *ctx, struct dh *params)
                 return 0;
         }
 
-        ctx->g = dma_zalloc_coherent(dev, ctx->p_size, &ctx->dma_g, GFP_KERNEL);
+        ctx->g = dma_alloc_coherent(dev, ctx->p_size, &ctx->dma_g, GFP_KERNEL);
         if (!ctx->g)
                 return -ENOMEM;
         memcpy(ctx->g + (ctx->p_size - params->g_size), params->g,
@@ -503,8 +503,8 @@ static int qat_dh_set_secret(struct crypto_kpp *tfm, const void *buf,
         if (ret < 0)
                 goto err_clear_ctx;
 
-        ctx->xa = dma_zalloc_coherent(dev, ctx->p_size, &ctx->dma_xa,
-                                      GFP_KERNEL);
+        ctx->xa = dma_alloc_coherent(dev, ctx->p_size, &ctx->dma_xa,
+                                     GFP_KERNEL);
         if (!ctx->xa) {
                 ret = -ENOMEM;
                 goto err_clear_ctx;
@@ -737,9 +737,9 @@ static int qat_rsa_enc(struct akcipher_request *req)
         } else {
                 int shift = ctx->key_sz - req->src_len;
 
-                qat_req->src_align = dma_zalloc_coherent(dev, ctx->key_sz,
-                                                         &qat_req->in.rsa.enc.m,
-                                                         GFP_KERNEL);
+                qat_req->src_align = dma_alloc_coherent(dev, ctx->key_sz,
+                                                        &qat_req->in.rsa.enc.m,
+                                                        GFP_KERNEL);
                 if (unlikely(!qat_req->src_align))
                         return ret;
 
@@ -756,9 +756,9 @@ static int qat_rsa_enc(struct akcipher_request *req)
                         goto unmap_src;
 
         } else {
-                qat_req->dst_align = dma_zalloc_coherent(dev, ctx->key_sz,
-                                                         &qat_req->out.rsa.enc.c,
-                                                         GFP_KERNEL);
+                qat_req->dst_align = dma_alloc_coherent(dev, ctx->key_sz,
+                                                        &qat_req->out.rsa.enc.c,
+                                                        GFP_KERNEL);
                 if (unlikely(!qat_req->dst_align))
                         goto unmap_src;
 
@@ -881,9 +881,9 @@ static int qat_rsa_dec(struct akcipher_request *req)
         } else {
                 int shift = ctx->key_sz - req->src_len;
 
-                qat_req->src_align = dma_zalloc_coherent(dev, ctx->key_sz,
-                                                         &qat_req->in.rsa.dec.c,
-                                                         GFP_KERNEL);
+                qat_req->src_align = dma_alloc_coherent(dev, ctx->key_sz,
+                                                        &qat_req->in.rsa.dec.c,
+                                                        GFP_KERNEL);
                 if (unlikely(!qat_req->src_align))
                         return ret;
 
@@ -900,9 +900,9 @@ static int qat_rsa_dec(struct akcipher_request *req)
                         goto unmap_src;
 
         } else {
-                qat_req->dst_align = dma_zalloc_coherent(dev, ctx->key_sz,
-                                                         &qat_req->out.rsa.dec.m,
-                                                         GFP_KERNEL);
+                qat_req->dst_align = dma_alloc_coherent(dev, ctx->key_sz,
+                                                        &qat_req->out.rsa.dec.m,
+                                                        GFP_KERNEL);
                 if (unlikely(!qat_req->dst_align))
                         goto unmap_src;
 
@@ -989,7 +989,7 @@ static int qat_rsa_set_n(struct qat_rsa_ctx *ctx, const char *value,
                 goto err;
 
         ret = -ENOMEM;
-        ctx->n = dma_zalloc_coherent(dev, ctx->key_sz, &ctx->dma_n, GFP_KERNEL);
+        ctx->n = dma_alloc_coherent(dev, ctx->key_sz, &ctx->dma_n, GFP_KERNEL);
         if (!ctx->n)
                 goto err;
 
@@ -1018,7 +1018,7 @@ static int qat_rsa_set_e(struct qat_rsa_ctx *ctx, const char *value,
                 return -EINVAL;
         }
 
-        ctx->e = dma_zalloc_coherent(dev, ctx->key_sz, &ctx->dma_e, GFP_KERNEL);
+        ctx->e = dma_alloc_coherent(dev, ctx->key_sz, &ctx->dma_e, GFP_KERNEL);
         if (!ctx->e)
                 return -ENOMEM;
 
@@ -1044,7 +1044,7 @@ static int qat_rsa_set_d(struct qat_rsa_ctx *ctx, const char *value,
                 goto err;
 
         ret = -ENOMEM;
-        ctx->d = dma_zalloc_coherent(dev, ctx->key_sz, &ctx->dma_d, GFP_KERNEL);
+        ctx->d = dma_alloc_coherent(dev, ctx->key_sz, &ctx->dma_d, GFP_KERNEL);
         if (!ctx->d)
                 goto err;
 
@@ -1077,7 +1077,7 @@ static void qat_rsa_setkey_crt(struct qat_rsa_ctx *ctx, struct rsa_key *rsa_key)
         qat_rsa_drop_leading_zeros(&ptr, &len);
         if (!len)
                 goto err;
-        ctx->p = dma_zalloc_coherent(dev, half_key_sz, &ctx->dma_p, GFP_KERNEL);
+        ctx->p = dma_alloc_coherent(dev, half_key_sz, &ctx->dma_p, GFP_KERNEL);
         if (!ctx->p)
                 goto err;
         memcpy(ctx->p + (half_key_sz - len), ptr, len);
@@ -1088,7 +1088,7 @@ static void qat_rsa_setkey_crt(struct qat_rsa_ctx *ctx, struct rsa_key *rsa_key)
         qat_rsa_drop_leading_zeros(&ptr, &len);
         if (!len)
                 goto free_p;
-        ctx->q = dma_zalloc_coherent(dev, half_key_sz, &ctx->dma_q, GFP_KERNEL);
+        ctx->q = dma_alloc_coherent(dev, half_key_sz, &ctx->dma_q, GFP_KERNEL);
         if (!ctx->q)
                 goto free_p;
         memcpy(ctx->q + (half_key_sz - len), ptr, len);
@@ -1099,8 +1099,8 @@ static void qat_rsa_setkey_crt(struct qat_rsa_ctx *ctx, struct rsa_key *rsa_key)
         qat_rsa_drop_leading_zeros(&ptr, &len);
         if (!len)
                 goto free_q;
-        ctx->dp = dma_zalloc_coherent(dev, half_key_sz, &ctx->dma_dp,
-                                      GFP_KERNEL);
+        ctx->dp = dma_alloc_coherent(dev, half_key_sz, &ctx->dma_dp,
+                                     GFP_KERNEL);
         if (!ctx->dp)
                 goto free_q;
         memcpy(ctx->dp + (half_key_sz - len), ptr, len);
@@ -1111,8 +1111,8 @@ static void qat_rsa_setkey_crt(struct qat_rsa_ctx *ctx, struct rsa_key *rsa_key)
         qat_rsa_drop_leading_zeros(&ptr, &len);
         if (!len)
                 goto free_dp;
-        ctx->dq = dma_zalloc_coherent(dev, half_key_sz, &ctx->dma_dq,
-                                      GFP_KERNEL);
+        ctx->dq = dma_alloc_coherent(dev, half_key_sz, &ctx->dma_dq,
+                                     GFP_KERNEL);
         if (!ctx->dq)
                 goto free_dp;
         memcpy(ctx->dq + (half_key_sz - len), ptr, len);
@@ -1123,8 +1123,8 @@ static void qat_rsa_setkey_crt(struct qat_rsa_ctx *ctx, struct rsa_key *rsa_key)
         qat_rsa_drop_leading_zeros(&ptr, &len);
         if (!len)
                 goto free_dq;
-        ctx->qinv = dma_zalloc_coherent(dev, half_key_sz, &ctx->dma_qinv,
-                                        GFP_KERNEL);
+        ctx->qinv = dma_alloc_coherent(dev, half_key_sz, &ctx->dma_qinv,
+                                       GFP_KERNEL);
         if (!ctx->qinv)
                 goto free_dq;
         memcpy(ctx->qinv + (half_key_sz - len), ptr, len);
diff --git a/drivers/crypto/talitos.c b/drivers/crypto/talitos.c
index 45e20707cef8..f8e2c5c3f4eb 100644
--- a/drivers/crypto/talitos.c
+++ b/drivers/crypto/talitos.c
@@ -1361,23 +1361,18 @@ static struct talitos_edesc *talitos_edesc_alloc(struct device *dev,
         struct talitos_private *priv = dev_get_drvdata(dev);
         bool is_sec1 = has_ftr_sec1(priv);
         int max_len = is_sec1 ? TALITOS1_MAX_DATA_LEN : TALITOS2_MAX_DATA_LEN;
-        void *err;
 
         if (cryptlen + authsize > max_len) {
                 dev_err(dev, "length exceeds h/w max limit\n");
                 return ERR_PTR(-EINVAL);
         }
 
-        if (ivsize)
-                iv_dma = dma_map_single(dev, iv, ivsize, DMA_TO_DEVICE);
-
         if (!dst || dst == src) {
                 src_len = assoclen + cryptlen + authsize;
                 src_nents = sg_nents_for_len(src, src_len);
                 if (src_nents < 0) {
                         dev_err(dev, "Invalid number of src SG.\n");
-                        err = ERR_PTR(-EINVAL);
-                        goto error_sg;
+                        return ERR_PTR(-EINVAL);
                 }
                 src_nents = (src_nents == 1) ? 0 : src_nents;
                 dst_nents = dst ? src_nents : 0;
@@ -1387,16 +1382,14 @@ static struct talitos_edesc *talitos_edesc_alloc(struct device *dev,
                 src_nents = sg_nents_for_len(src, src_len);
                 if (src_nents < 0) {
                         dev_err(dev, "Invalid number of src SG.\n");
-                        err = ERR_PTR(-EINVAL);
-                        goto error_sg;
+                        return ERR_PTR(-EINVAL);
                 }
                 src_nents = (src_nents == 1) ? 0 : src_nents;
                 dst_len = assoclen + cryptlen + (encrypt ? authsize : 0);
                 dst_nents = sg_nents_for_len(dst, dst_len);
                 if (dst_nents < 0) {
                         dev_err(dev, "Invalid number of dst SG.\n");
-                        err = ERR_PTR(-EINVAL);
-                        goto error_sg;
+                        return ERR_PTR(-EINVAL);
                 }
                 dst_nents = (dst_nents == 1) ? 0 : dst_nents;
         }
@@ -1423,11 +1416,14 @@ static struct talitos_edesc *talitos_edesc_alloc(struct device *dev,
         /* if its a ahash, add space for a second desc next to the first one */
         if (is_sec1 && !dst)
                 alloc_len += sizeof(struct talitos_desc);
+        alloc_len += ivsize;
 
         edesc = kmalloc(alloc_len, GFP_DMA | flags);
-        if (!edesc) {
-                err = ERR_PTR(-ENOMEM);
-                goto error_sg;
+        if (!edesc)
+                return ERR_PTR(-ENOMEM);
+        if (ivsize) {
+                iv = memcpy(((u8 *)edesc) + alloc_len - ivsize, iv, ivsize);
+                iv_dma = dma_map_single(dev, iv, ivsize, DMA_TO_DEVICE);
         }
         memset(&edesc->desc, 0, sizeof(edesc->desc));
 
@@ -1445,10 +1441,6 @@ static struct talitos_edesc *talitos_edesc_alloc(struct device *dev,
                                                      DMA_BIDIRECTIONAL);
         }
         return edesc;
-error_sg:
-        if (iv_dma)
-                dma_unmap_single(dev, iv_dma, ivsize, DMA_TO_DEVICE);
-        return err;
 }
 
 static struct talitos_edesc *aead_edesc_alloc(struct aead_request *areq, u8 *iv,
diff --git a/drivers/dma/imx-sdma.c b/drivers/dma/imx-sdma.c
index a2b0a0e71168..86708fb9bda1 100644
--- a/drivers/dma/imx-sdma.c
+++ b/drivers/dma/imx-sdma.c
@@ -1182,8 +1182,8 @@ static int sdma_request_channel0(struct sdma_engine *sdma)
 {
         int ret = -EBUSY;
 
-        sdma->bd0 = dma_zalloc_coherent(NULL, PAGE_SIZE, &sdma->bd0_phys,
-                                        GFP_NOWAIT);
+        sdma->bd0 = dma_alloc_coherent(NULL, PAGE_SIZE, &sdma->bd0_phys,
+                                       GFP_NOWAIT);
         if (!sdma->bd0) {
                 ret = -ENOMEM;
                 goto out;
@@ -1205,8 +1205,8 @@ static int sdma_alloc_bd(struct sdma_desc *desc)
         u32 bd_size = desc->num_bd * sizeof(struct sdma_buffer_descriptor);
         int ret = 0;
 
-        desc->bd = dma_zalloc_coherent(NULL, bd_size, &desc->bd_phys,
-                                        GFP_NOWAIT);
+        desc->bd = dma_alloc_coherent(NULL, bd_size, &desc->bd_phys,
+                                      GFP_NOWAIT);
         if (!desc->bd) {
                 ret = -ENOMEM;
                 goto out;
diff --git a/drivers/dma/mediatek/mtk-hsdma.c b/drivers/dma/mediatek/mtk-hsdma.c
index b7ec56ae02a6..1a2028e1c29e 100644
--- a/drivers/dma/mediatek/mtk-hsdma.c
+++ b/drivers/dma/mediatek/mtk-hsdma.c
@@ -325,8 +325,8 @@ static int mtk_hsdma_alloc_pchan(struct mtk_hsdma_device *hsdma,
          * and [MTK_DMA_SIZE ... 2 * MTK_DMA_SIZE - 1] is for RX ring.
          */
         pc->sz_ring = 2 * MTK_DMA_SIZE * sizeof(*ring->txd);
-        ring->txd = dma_zalloc_coherent(hsdma2dev(hsdma), pc->sz_ring,
-                                        &ring->tphys, GFP_NOWAIT);
+        ring->txd = dma_alloc_coherent(hsdma2dev(hsdma), pc->sz_ring,
+                                       &ring->tphys, GFP_NOWAIT);
         if (!ring->txd)
                 return -ENOMEM;
 
diff --git a/drivers/dma/mxs-dma.c b/drivers/dma/mxs-dma.c
index 35193b31a9e0..22cc7f68ef6e 100644
--- a/drivers/dma/mxs-dma.c
+++ b/drivers/dma/mxs-dma.c
@@ -416,9 +416,9 @@ static int mxs_dma_alloc_chan_resources(struct dma_chan *chan)
         struct mxs_dma_engine *mxs_dma = mxs_chan->mxs_dma;
         int ret;
 
-        mxs_chan->ccw = dma_zalloc_coherent(mxs_dma->dma_device.dev,
-                                            CCW_BLOCK_SIZE,
-                                            &mxs_chan->ccw_phys, GFP_KERNEL);
+        mxs_chan->ccw = dma_alloc_coherent(mxs_dma->dma_device.dev,
+                                           CCW_BLOCK_SIZE,
+                                           &mxs_chan->ccw_phys, GFP_KERNEL);
         if (!mxs_chan->ccw) {
                 ret = -ENOMEM;
                 goto err_alloc;
diff --git a/drivers/dma/xgene-dma.c b/drivers/dma/xgene-dma.c
index 1d5988849aa6..eafd6c4b90fe 100644
--- a/drivers/dma/xgene-dma.c
+++ b/drivers/dma/xgene-dma.c
@@ -1208,8 +1208,8 @@ static int xgene_dma_create_ring_one(struct xgene_dma_chan *chan,
         ring->size = ret;
 
         /* Allocate memory for DMA ring descriptor */
-        ring->desc_vaddr = dma_zalloc_coherent(chan->dev, ring->size,
-                                               &ring->desc_paddr, GFP_KERNEL);
+        ring->desc_vaddr = dma_alloc_coherent(chan->dev, ring->size,
+                                              &ring->desc_paddr, GFP_KERNEL);
         if (!ring->desc_vaddr) {
                 chan_err(chan, "Failed to allocate ring desc\n");
                 return -ENOMEM;
diff --git a/drivers/dma/xilinx/xilinx_dma.c b/drivers/dma/xilinx/xilinx_dma.c
index 02880963092f..cb20b411493e 100644
--- a/drivers/dma/xilinx/xilinx_dma.c
+++ b/drivers/dma/xilinx/xilinx_dma.c
@@ -879,10 +879,9 @@ static int xilinx_dma_alloc_chan_resources(struct dma_chan *dchan)
          */
         if (chan->xdev->dma_config->dmatype == XDMA_TYPE_AXIDMA) {
                 /* Allocate the buffer descriptors. */
-                chan->seg_v = dma_zalloc_coherent(chan->dev,
-                                                  sizeof(*chan->seg_v) *
-                                                  XILINX_DMA_NUM_DESCS,
-                                                  &chan->seg_p, GFP_KERNEL);
+                chan->seg_v = dma_alloc_coherent(chan->dev,
+                                                 sizeof(*chan->seg_v) * XILINX_DMA_NUM_DESCS,
+                                                 &chan->seg_p, GFP_KERNEL);
                 if (!chan->seg_v) {
                         dev_err(chan->dev,
                                 "unable to allocate channel %d descriptors\n",
@@ -895,9 +894,10 @@ static int xilinx_dma_alloc_chan_resources(struct dma_chan *dchan)
                  * so allocating a desc segment during channel allocation for
                  * programming tail descriptor.
                  */
-                chan->cyclic_seg_v = dma_zalloc_coherent(chan->dev,
-                                        sizeof(*chan->cyclic_seg_v),
-                                        &chan->cyclic_seg_p, GFP_KERNEL);
+                chan->cyclic_seg_v = dma_alloc_coherent(chan->dev,
+                                                        sizeof(*chan->cyclic_seg_v),
+                                                        &chan->cyclic_seg_p,
+                                                        GFP_KERNEL);
                 if (!chan->cyclic_seg_v) {
                         dev_err(chan->dev,
                                 "unable to allocate desc segment for cyclic DMA\n");
diff --git a/drivers/dma/xilinx/zynqmp_dma.c b/drivers/dma/xilinx/zynqmp_dma.c
index 8db51750ce93..4478787a247f 100644
--- a/drivers/dma/xilinx/zynqmp_dma.c
+++ b/drivers/dma/xilinx/zynqmp_dma.c
@@ -490,9 +490,9 @@ static int zynqmp_dma_alloc_chan_resources(struct dma_chan *dchan)
                 list_add_tail(&desc->node, &chan->free_list);
         }
 
-        chan->desc_pool_v = dma_zalloc_coherent(chan->dev,
-                                (2 * chan->desc_size * ZYNQMP_DMA_NUM_DESCS),
-                                &chan->desc_pool_p, GFP_KERNEL);
+        chan->desc_pool_v = dma_alloc_coherent(chan->dev,
+                                               (2 * chan->desc_size * ZYNQMP_DMA_NUM_DESCS),
+                                               &chan->desc_pool_p, GFP_KERNEL);
         if (!chan->desc_pool_v)
                 return -ENOMEM;
 
diff --git a/drivers/edac/altera_edac.h b/drivers/edac/altera_edac.h
index 4213cb0bb2a7..f8664bac9fa8 100644
--- a/drivers/edac/altera_edac.h
+++ b/drivers/edac/altera_edac.h
@@ -295,8 +295,8 @@ struct altr_sdram_mc_data {
 #define S10_SYSMGR_ECC_INTSTAT_DERR_OFST  0xA0
 
 /* Sticky registers for Uncorrected Errors */
-#define S10_SYSMGR_UE_VAL_OFST            0x120
-#define S10_SYSMGR_UE_ADDR_OFST           0x124
+#define S10_SYSMGR_UE_VAL_OFST            0x220
+#define S10_SYSMGR_UE_ADDR_OFST           0x224
 
 #define S10_DDR0_IRQ_MASK                 BIT(16)
 
diff --git a/drivers/firewire/sbp2.c b/drivers/firewire/sbp2.c
index 09b845e90114..a785ffd5af89 100644
--- a/drivers/firewire/sbp2.c
+++ b/drivers/firewire/sbp2.c
@@ -1144,10 +1144,6 @@ static int sbp2_probe(struct fw_unit *unit, const struct ieee1394_device_id *id)
         if (device->is_local)
                 return -ENODEV;
 
-        if (dma_get_max_seg_size(device->card->device) > SBP2_MAX_SEG_SIZE)
-                WARN_ON(dma_set_max_seg_size(device->card->device,
-                                             SBP2_MAX_SEG_SIZE));
-
         shost = scsi_host_alloc(&scsi_driver_template, sizeof(*tgt));
         if (shost == NULL)
                 return -ENOMEM;
@@ -1610,6 +1606,7 @@ static struct scsi_host_template scsi_driver_template = {
         .eh_abort_handler       = sbp2_scsi_abort,
         .this_id                = -1,
         .sg_tablesize           = SG_ALL,
+        .max_segment_size       = SBP2_MAX_SEG_SIZE,
         .can_queue              = 1,
         .sdev_attrs             = sbp2_scsi_sysfs_attrs,
 };
diff --git a/drivers/firmware/arm_scmi/bus.c b/drivers/firmware/arm_scmi/bus.c
index 472c88ae1c0f..92f843eaf1e0 100644
--- a/drivers/firmware/arm_scmi/bus.c
+++ b/drivers/firmware/arm_scmi/bus.c
@@ -119,6 +119,11 @@ void scmi_driver_unregister(struct scmi_driver *driver)
 }
 EXPORT_SYMBOL_GPL(scmi_driver_unregister);
 
+static void scmi_device_release(struct device *dev)
+{
+        kfree(to_scmi_dev(dev));
+}
+
 struct scmi_device *
 scmi_device_create(struct device_node *np, struct device *parent, int protocol)
 {
@@ -138,6 +143,7 @@ scmi_device_create(struct device_node *np, struct device *parent, int protocol)
         scmi_dev->dev.parent = parent;
         scmi_dev->dev.of_node = np;
         scmi_dev->dev.bus = &scmi_bus_type;
+        scmi_dev->dev.release = scmi_device_release;
         dev_set_name(&scmi_dev->dev, "scmi_dev.%d", id);
 
         retval = device_register(&scmi_dev->dev);
@@ -156,9 +162,8 @@ free_mem:
 void scmi_device_destroy(struct scmi_device *scmi_dev)
 {
         scmi_handle_put(scmi_dev->handle);
-        device_unregister(&scmi_dev->dev);
         ida_simple_remove(&scmi_bus_id, scmi_dev->id);
-        kfree(scmi_dev);
+        device_unregister(&scmi_dev->dev);
 }
 
 void scmi_set_handle(struct scmi_device *scmi_dev)
diff --git a/drivers/gpio/gpio-pca953x.c b/drivers/gpio/gpio-pca953x.c
index 83617fdc661d..0dc96419efe3 100644
--- a/drivers/gpio/gpio-pca953x.c
+++ b/drivers/gpio/gpio-pca953x.c
@@ -289,7 +289,7 @@ static bool pca953x_volatile_register(struct device *dev, unsigned int reg)
         return pca953x_check_register(chip, reg, bank);
 }
 
-const struct regmap_config pca953x_i2c_regmap = {
+static const struct regmap_config pca953x_i2c_regmap = {
         .reg_bits = 8,
         .val_bits = 8,
 
diff --git a/drivers/gpio/gpiolib-acpi.c b/drivers/gpio/gpiolib-acpi.c
index 48534bda73d3..259cf6ab969b 100644
--- a/drivers/gpio/gpiolib-acpi.c
+++ b/drivers/gpio/gpiolib-acpi.c
@@ -357,8 +357,6 @@ void acpi_gpiochip_free_interrupts(struct gpio_chip *chip)
         mutex_unlock(&acpi_gpio_deferred_req_irqs_lock);
 
         list_for_each_entry_safe_reverse(event, ep, &acpi_gpio->events, node) {
-                struct gpio_desc *desc;
-
                 if (event->irq_requested) {
                         if (event->irq_is_wake)
                                 disable_irq_wake(event->irq);
@@ -366,11 +364,8 @@ void acpi_gpiochip_free_interrupts(struct gpio_chip *chip)
                         free_irq(event->irq, event);
                 }
 
-                desc = event->desc;
-                if (WARN_ON(IS_ERR(desc)))
-                        continue;
                 gpiochip_unlock_as_irq(chip, event->pin);
-                gpiochip_free_own_desc(desc);
+                gpiochip_free_own_desc(event->desc);
                 list_del(&event->node);
                 kfree(event);
         }
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_atpx_handler.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_atpx_handler.c
index a028661d9e20..92b11de19581 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_atpx_handler.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_atpx_handler.c
@@ -576,6 +576,7 @@ static const struct amdgpu_px_quirk amdgpu_px_quirk_list[] = {
         { 0x1002, 0x6900, 0x1028, 0x0812, AMDGPU_PX_QUIRK_FORCE_ATPX },
         { 0x1002, 0x6900, 0x1028, 0x0813, AMDGPU_PX_QUIRK_FORCE_ATPX },
         { 0x1002, 0x6900, 0x1025, 0x125A, AMDGPU_PX_QUIRK_FORCE_ATPX },
+        { 0x1002, 0x6900, 0x17AA, 0x3806, AMDGPU_PX_QUIRK_FORCE_ATPX },
         { 0, 0, 0, 0, 0 },
 };
 
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c
index 8a078f4ae73d..7ff3a28fc903 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c
@@ -1701,8 +1701,10 @@ static int amdgpu_device_ip_init(struct amdgpu_device *adev)
                 amdgpu_xgmi_add_device(adev);
         amdgpu_amdkfd_device_init(adev);
 
-        if (amdgpu_sriov_vf(adev))
+        if (amdgpu_sriov_vf(adev)) {
+                amdgpu_virt_init_data_exchange(adev);
                 amdgpu_virt_release_full_gpu(adev, true);
+        }
 
         return 0;
 }
@@ -2632,9 +2634,6 @@ fence_driver_init:
                 goto failed;
         }
 
-        if (amdgpu_sriov_vf(adev))
-                amdgpu_virt_init_data_exchange(adev);
-
         amdgpu_fbdev_init(adev);
 
         r = amdgpu_pm_sysfs_init(adev);
@@ -2798,7 +2797,7 @@ int amdgpu_device_suspend(struct drm_device *dev, bool suspend, bool fbcon)
                         struct drm_framebuffer *fb = crtc->primary->fb;
                         struct amdgpu_bo *robj;
 
-                        if (amdgpu_crtc->cursor_bo) {
+                        if (amdgpu_crtc->cursor_bo && !adev->enable_virtual_display) {
                                 struct amdgpu_bo *aobj = gem_to_amdgpu_bo(amdgpu_crtc->cursor_bo);
                                 r = amdgpu_bo_reserve(aobj, true);
                                 if (r == 0) {
@@ -2906,7 +2905,7 @@ int amdgpu_device_resume(struct drm_device *dev, bool resume, bool fbcon)
                 list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
                         struct amdgpu_crtc *amdgpu_crtc = to_amdgpu_crtc(crtc);
 
-                        if (amdgpu_crtc->cursor_bo) {
+                        if (amdgpu_crtc->cursor_bo && !adev->enable_virtual_display) {
                                 struct amdgpu_bo *aobj = gem_to_amdgpu_bo(amdgpu_crtc->cursor_bo);
                                 r = amdgpu_bo_reserve(aobj, true);
                                 if (r == 0) {
@@ -3226,6 +3225,7 @@ static int amdgpu_device_reset_sriov(struct amdgpu_device *adev,
         r = amdgpu_ib_ring_tests(adev);
 
 error:
+        amdgpu_virt_init_data_exchange(adev);
         amdgpu_virt_release_full_gpu(adev, true);
         if (!r && adev->virt.gim_feature & AMDGIM_FEATURE_GIM_FLR_VRAMLOST) {
                 atomic_inc(&adev->vram_lost_counter);
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_display.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_display.c
index 15ce7e681d67..b083b219b1a9 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_display.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_display.c
@@ -188,10 +188,12 @@ int amdgpu_display_crtc_page_flip_target(struct drm_crtc *crtc,
                 goto cleanup;
         }
 
-        r = amdgpu_bo_pin(new_abo, amdgpu_display_supported_domains(adev));
-        if (unlikely(r != 0)) {
-                DRM_ERROR("failed to pin new abo buffer before flip\n");
-                goto unreserve;
+        if (!adev->enable_virtual_display) {
+                r = amdgpu_bo_pin(new_abo, amdgpu_display_supported_domains(adev));
+                if (unlikely(r != 0)) {
+                        DRM_ERROR("failed to pin new abo buffer before flip\n");
+                        goto unreserve;
+                }
         }
 
         r = amdgpu_ttm_alloc_gart(&new_abo->tbo);
@@ -211,7 +213,8 @@ int amdgpu_display_crtc_page_flip_target(struct drm_crtc *crtc,
         amdgpu_bo_get_tiling_flags(new_abo, &tiling_flags);
         amdgpu_bo_unreserve(new_abo);
 
-        work->base = amdgpu_bo_gpu_offset(new_abo);
+        if (!adev->enable_virtual_display)
+                work->base = amdgpu_bo_gpu_offset(new_abo);
         work->target_vblank = target - (uint32_t)drm_crtc_vblank_count(crtc) +
                 amdgpu_get_vblank_counter_kms(dev, work->crtc_id);
 
@@ -242,9 +245,10 @@ pflip_cleanup:
                 goto cleanup;
         }
 unpin:
-        if (unlikely(amdgpu_bo_unpin(new_abo) != 0)) {
-                DRM_ERROR("failed to unpin new abo in error path\n");
-        }
+        if (!adev->enable_virtual_display)
+                if (unlikely(amdgpu_bo_unpin(new_abo) != 0))
+                        DRM_ERROR("failed to unpin new abo in error path\n");
+
 unreserve:
         amdgpu_bo_unreserve(new_abo);
 
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_pm.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_pm.c
index 1f61ed95727c..6896dec97fc7 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_pm.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_pm.c
@@ -2008,6 +2008,7 @@ void amdgpu_pm_print_power_states(struct amdgpu_device *adev)
 
 int amdgpu_pm_sysfs_init(struct amdgpu_device *adev)
 {
+        struct pp_hwmgr *hwmgr = adev->powerplay.pp_handle;
         int ret;
 
         if (adev->pm.sysfs_initialized)
@@ -2091,12 +2092,14 @@ int amdgpu_pm_sysfs_init(struct amdgpu_device *adev)
                                 "pp_power_profile_mode\n");
                 return ret;
         }
-        ret = device_create_file(adev->dev,
-                        &dev_attr_pp_od_clk_voltage);
-        if (ret) {
-                DRM_ERROR("failed to create device file "
-                                "pp_od_clk_voltage\n");
-                return ret;
+        if (hwmgr->od_enabled) {
+                ret = device_create_file(adev->dev,
+                                &dev_attr_pp_od_clk_voltage);
+                if (ret) {
+                        DRM_ERROR("failed to create device file "
+                                        "pp_od_clk_voltage\n");
+                        return ret;
+                }
         }
         ret = device_create_file(adev->dev,
                         &dev_attr_gpu_busy_percent);
@@ -2118,6 +2121,8 @@ int amdgpu_pm_sysfs_init(struct amdgpu_device *adev)
 
 void amdgpu_pm_sysfs_fini(struct amdgpu_device *adev)
 {
+        struct pp_hwmgr *hwmgr = adev->powerplay.pp_handle;
+
         if (adev->pm.dpm_enabled == 0)
                 return;
 
@@ -2138,8 +2143,9 @@ void amdgpu_pm_sysfs_fini(struct amdgpu_device *adev)
         device_remove_file(adev->dev, &dev_attr_pp_mclk_od);
         device_remove_file(adev->dev,
                         &dev_attr_pp_power_profile_mode);
-        device_remove_file(adev->dev,
-                        &dev_attr_pp_od_clk_voltage);
+        if (hwmgr->od_enabled)
+                device_remove_file(adev->dev,
+                                &dev_attr_pp_od_clk_voltage);
         device_remove_file(adev->dev, &dev_attr_gpu_busy_percent);
 }
 
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c
index e73d152659a2..d2ea5ce2cefb 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_vm.c
@@ -847,9 +847,6 @@ static void amdgpu_vm_bo_param(struct amdgpu_device *adev, struct amdgpu_vm *vm,
         bp->size = amdgpu_vm_bo_size(adev, level);
         bp->byte_align = AMDGPU_GPU_PAGE_SIZE;
         bp->domain = AMDGPU_GEM_DOMAIN_VRAM;
-        if (bp->size <= PAGE_SIZE && adev->asic_type >= CHIP_VEGA10 &&
-            adev->flags & AMD_IS_APU)
-                bp->domain |= AMDGPU_GEM_DOMAIN_GTT;
         bp->domain = amdgpu_bo_get_preferred_pin_domain(adev, bp->domain);
         bp->flags = AMDGPU_GEM_CREATE_VRAM_CONTIGUOUS |
                 AMDGPU_GEM_CREATE_CPU_GTT_USWC;
diff --git a/drivers/gpu/drm/amd/amdgpu/dce_virtual.c b/drivers/gpu/drm/amd/amdgpu/dce_virtual.c
index fdace004544d..e4cc1d48eaab 100644
--- a/drivers/gpu/drm/amd/amdgpu/dce_virtual.c
+++ b/drivers/gpu/drm/amd/amdgpu/dce_virtual.c
@@ -167,19 +167,6 @@ static void dce_virtual_crtc_disable(struct drm_crtc *crtc)
         struct amdgpu_crtc *amdgpu_crtc = to_amdgpu_crtc(crtc);
 
         dce_virtual_crtc_dpms(crtc, DRM_MODE_DPMS_OFF);
-        if (crtc->primary->fb) {
-                int r;
-                struct amdgpu_bo *abo;
-
-                abo = gem_to_amdgpu_bo(crtc->primary->fb->obj[0]);
-                r = amdgpu_bo_reserve(abo, true);
-                if (unlikely(r))
-                        DRM_ERROR("failed to reserve abo before unpin\n");
-                else {
-                        amdgpu_bo_unpin(abo);
-                        amdgpu_bo_unreserve(abo);
-                }
-        }
 
         amdgpu_crtc->pll_id = ATOM_PPLL_INVALID;
         amdgpu_crtc->encoder = NULL;
@@ -692,7 +679,9 @@ static int dce_virtual_pageflip(struct amdgpu_device *adev,
         spin_unlock_irqrestore(&adev->ddev->event_lock, flags);
 
         drm_crtc_vblank_put(&amdgpu_crtc->base);
-        schedule_work(&works->unpin_work);
+        amdgpu_bo_unref(&works->old_abo);
+        kfree(works->shared);
+        kfree(works);
 
         return 0;
 }
diff --git a/drivers/gpu/drm/amd/amdgpu/gfx_v8_0.c b/drivers/gpu/drm/amd/amdgpu/gfx_v8_0.c
index 381f593b0cda..57cb3a51bda7 100644
--- a/drivers/gpu/drm/amd/amdgpu/gfx_v8_0.c
+++ b/drivers/gpu/drm/amd/amdgpu/gfx_v8_0.c
@@ -4233,7 +4233,6 @@ static int gfx_v8_0_cp_gfx_resume(struct amdgpu_device *adev)
         u32 tmp;
         u32 rb_bufsz;
         u64 rb_addr, rptr_addr, wptr_gpu_addr;
-        int r;
 
         /* Set the write pointer delay */
         WREG32(mmCP_RB_WPTR_DELAY, 0);
@@ -4278,9 +4277,8 @@ static int gfx_v8_0_cp_gfx_resume(struct amdgpu_device *adev)
         amdgpu_ring_clear_ring(ring);
         gfx_v8_0_cp_gfx_start(adev);
         ring->sched.ready = true;
-        r = amdgpu_ring_test_helper(ring);
 
-        return r;
+        return 0;
 }
 
 static void gfx_v8_0_cp_compute_enable(struct amdgpu_device *adev, bool enable)
@@ -4369,10 +4367,9 @@ static int gfx_v8_0_kiq_kcq_enable(struct amdgpu_device *adev)
                 amdgpu_ring_write(kiq_ring, upper_32_bits(wptr_addr));
         }
 
-        r = amdgpu_ring_test_helper(kiq_ring);
-        if (r)
-                DRM_ERROR("KCQ enable failed\n");
-        return r;
+        amdgpu_ring_commit(kiq_ring);
+
+        return 0;
 }
 
 static int gfx_v8_0_deactivate_hqd(struct amdgpu_device *adev, u32 req)
@@ -4709,16 +4706,32 @@ static int gfx_v8_0_kcq_resume(struct amdgpu_device *adev)
         if (r)
                 goto done;
 
-        /* Test KCQs - reversing the order of rings seems to fix ring test failure
-         * after GPU reset
-         */
-        for (i = adev->gfx.num_compute_rings - 1; i >= 0; i--) {
+done:
+        return r;
+}
+
+static int gfx_v8_0_cp_test_all_rings(struct amdgpu_device *adev)
+{
+        int r, i;
+        struct amdgpu_ring *ring;
+
+        /* collect all the ring_tests here, gfx, kiq, compute */
+        ring = &adev->gfx.gfx_ring[0];
+        r = amdgpu_ring_test_helper(ring);
+        if (r)
+                return r;
+
+        ring = &adev->gfx.kiq.ring;
+        r = amdgpu_ring_test_helper(ring);
+        if (r)
+                return r;
+
+        for (i = 0; i < adev->gfx.num_compute_rings; i++) {
                 ring = &adev->gfx.compute_ring[i];
-                r = amdgpu_ring_test_helper(ring);
+                amdgpu_ring_test_helper(ring);
         }
 
-done:
-        return r;
+        return 0;
 }
 
 static int gfx_v8_0_cp_resume(struct amdgpu_device *adev)
@@ -4739,6 +4752,11 @@ static int gfx_v8_0_cp_resume(struct amdgpu_device *adev)
         r = gfx_v8_0_kcq_resume(adev);
         if (r)
                 return r;
+
+        r = gfx_v8_0_cp_test_all_rings(adev);
+        if (r)
+                return r;
+
         gfx_v8_0_enable_gui_idle_interrupt(adev, true);
 
         return 0;
@@ -5086,6 +5104,8 @@ static int gfx_v8_0_post_soft_reset(void *handle)
             REG_GET_FIELD(grbm_soft_reset, GRBM_SOFT_RESET, SOFT_RESET_GFX))
                 gfx_v8_0_cp_gfx_resume(adev);
 
+        gfx_v8_0_cp_test_all_rings(adev);
+
         adev->gfx.rlc.funcs->start(adev);
 
         return 0;
diff --git a/drivers/gpu/drm/amd/amdgpu/gfx_v9_0.c b/drivers/gpu/drm/amd/amdgpu/gfx_v9_0.c
index 7556716038d3..fbca0494f871 100644
--- a/drivers/gpu/drm/amd/amdgpu/gfx_v9_0.c
+++ b/drivers/gpu/drm/amd/amdgpu/gfx_v9_0.c
@@ -113,7 +113,10 @@ static const struct soc15_reg_golden golden_settings_gc_9_0[] =
         SOC15_REG_GOLDEN_VALUE(GC, 0, mmTCP_CHAN_STEER_HI, 0xffffffff, 0x4a2c0e68),
         SOC15_REG_GOLDEN_VALUE(GC, 0, mmTCP_CHAN_STEER_LO, 0xffffffff, 0xb5d3f197),
         SOC15_REG_GOLDEN_VALUE(GC, 0, mmVGT_CACHE_INVALIDATION, 0x3fff3af3, 0x19200000),
-        SOC15_REG_GOLDEN_VALUE(GC, 0, mmVGT_GS_MAX_WAVE_ID, 0x00000fff, 0x000003ff)
+        SOC15_REG_GOLDEN_VALUE(GC, 0, mmVGT_GS_MAX_WAVE_ID, 0x00000fff, 0x000003ff),
+        SOC15_REG_GOLDEN_VALUE(GC, 0, mmCP_MEC1_F32_INT_DIS, 0x00000000, 0x00000800),
+        SOC15_REG_GOLDEN_VALUE(GC, 0, mmCP_MEC2_F32_INT_DIS, 0x00000000, 0x00000800),
+        SOC15_REG_GOLDEN_VALUE(GC, 0, mmCP_DEBUG, 0x00000000, 0x00008000)
 };
 
 static const struct soc15_reg_golden golden_settings_gc_9_0_vg10[] =
@@ -135,10 +138,7 @@ static const struct soc15_reg_golden golden_settings_gc_9_0_vg10[] =
         SOC15_REG_GOLDEN_VALUE(GC, 0, mmRMI_UTCL1_CNTL2, 0x00030000, 0x00020000),
         SOC15_REG_GOLDEN_VALUE(GC, 0, mmSPI_CONFIG_CNTL_1, 0x0000000f, 0x01000107),
         SOC15_REG_GOLDEN_VALUE(GC, 0, mmTD_CNTL, 0x00001800, 0x00000800),
-        SOC15_REG_GOLDEN_VALUE(GC, 0, mmWD_UTCL1_CNTL, 0x08000000, 0x08000080),
-        SOC15_REG_GOLDEN_VALUE(GC, 0, mmCP_MEC1_F32_INT_DIS, 0x00000000, 0x00000800),
-        SOC15_REG_GOLDEN_VALUE(GC, 0, mmCP_MEC2_F32_INT_DIS, 0x00000000, 0x00000800),
-        SOC15_REG_GOLDEN_VALUE(GC, 0, mmCP_DEBUG, 0x00000000, 0x00008000)
+        SOC15_REG_GOLDEN_VALUE(GC, 0, mmWD_UTCL1_CNTL, 0x08000000, 0x08000080)
 };
 
 static const struct soc15_reg_golden golden_settings_gc_9_0_vg20[] =
@@ -3587,6 +3587,8 @@ static void gfx_v9_0_update_medium_grain_clock_gating(struct amdgpu_device *adev
 {
         uint32_t data, def;
 
+        amdgpu_gfx_rlc_enter_safe_mode(adev);
+
         /* It is disabled by HW by default */
         if (enable && (adev->cg_flags & AMD_CG_SUPPORT_GFX_MGCG)) {
                 /* 1 - RLC_CGTT_MGCG_OVERRIDE */
@@ -3651,6 +3653,8 @@ static void gfx_v9_0_update_medium_grain_clock_gating(struct amdgpu_device *adev
                         WREG32_SOC15(GC, 0, mmCP_MEM_SLP_CNTL, data);
                 }
         }
+
+        amdgpu_gfx_rlc_exit_safe_mode(adev);
 }
 
 static void gfx_v9_0_update_3d_clock_gating(struct amdgpu_device *adev,
diff --git a/drivers/gpu/drm/amd/amdgpu/mxgpu_ai.c b/drivers/gpu/drm/amd/amdgpu/mxgpu_ai.c
index 8cbb4655896a..b11a1c17a7f2 100644
--- a/drivers/gpu/drm/amd/amdgpu/mxgpu_ai.c
+++ b/drivers/gpu/drm/amd/amdgpu/mxgpu_ai.c
@@ -174,7 +174,7 @@ static int xgpu_ai_send_access_requests(struct amdgpu_device *adev,
                         return r;
                 }
                 /* Retrieve checksum from mailbox2 */
-                if (req == IDH_REQ_GPU_INIT_ACCESS) {
+                if (req == IDH_REQ_GPU_INIT_ACCESS || req == IDH_REQ_GPU_RESET_ACCESS) {
                         adev->virt.fw_reserve.checksum_key =
                                 RREG32_NO_KIQ(SOC15_REG_OFFSET(NBIO, 0,
                                         mmBIF_BX_PF0_MAILBOX_MSGBUF_RCV_DW2));
diff --git a/drivers/gpu/drm/amd/amdgpu/sdma_v4_0.c b/drivers/gpu/drm/amd/amdgpu/sdma_v4_0.c
index fd0bfe140ee0..6811a5d05b27 100644
--- a/drivers/gpu/drm/amd/amdgpu/sdma_v4_0.c
+++ b/drivers/gpu/drm/amd/amdgpu/sdma_v4_0.c
@@ -78,7 +78,6 @@ static const struct soc15_reg_golden golden_settings_sdma_4[] = {
         SOC15_REG_GOLDEN_VALUE(SDMA0, 0, mmSDMA0_RLC1_RB_WPTR_POLL_CNTL, 0x0000fff0, 0x00403000),
         SOC15_REG_GOLDEN_VALUE(SDMA0, 0, mmSDMA0_UTCL1_PAGE, 0x000003ff, 0x000003c0),
         SOC15_REG_GOLDEN_VALUE(SDMA0, 0, mmSDMA0_UTCL1_WATERMK, 0xfc000000, 0x00000000),
-        SOC15_REG_GOLDEN_VALUE(SDMA1, 0, mmSDMA1_CHICKEN_BITS, 0xfe931f07, 0x02831f07),
         SOC15_REG_GOLDEN_VALUE(SDMA1, 0, mmSDMA1_CLK_CTRL, 0xffffffff, 0x3f000100),
         SOC15_REG_GOLDEN_VALUE(SDMA1, 0, mmSDMA1_GFX_IB_CNTL, 0x800f0100, 0x00000100),
         SOC15_REG_GOLDEN_VALUE(SDMA1, 0, mmSDMA1_GFX_RB_WPTR_POLL_CNTL, 0x0000fff0, 0x00403000),
@@ -96,6 +95,7 @@ static const struct soc15_reg_golden golden_settings_sdma_4[] = {
 static const struct soc15_reg_golden golden_settings_sdma_vg10[] = {
         SOC15_REG_GOLDEN_VALUE(SDMA0, 0, mmSDMA0_GB_ADDR_CONFIG, 0x0018773f, 0x00104002),
         SOC15_REG_GOLDEN_VALUE(SDMA0, 0, mmSDMA0_GB_ADDR_CONFIG_READ, 0x0018773f, 0x00104002),
+        SOC15_REG_GOLDEN_VALUE(SDMA1, 0, mmSDMA1_CHICKEN_BITS, 0xfe931f07, 0x02831d07),
         SOC15_REG_GOLDEN_VALUE(SDMA1, 0, mmSDMA1_GB_ADDR_CONFIG, 0x0018773f, 0x00104002),
         SOC15_REG_GOLDEN_VALUE(SDMA1, 0, mmSDMA1_GB_ADDR_CONFIG_READ, 0x0018773f, 0x00104002)
 };
@@ -103,6 +103,7 @@ static const struct soc15_reg_golden golden_settings_sdma_vg10[] = {
 static const struct soc15_reg_golden golden_settings_sdma_vg12[] = {
         SOC15_REG_GOLDEN_VALUE(SDMA0, 0, mmSDMA0_GB_ADDR_CONFIG, 0x0018773f, 0x00104001),
         SOC15_REG_GOLDEN_VALUE(SDMA0, 0, mmSDMA0_GB_ADDR_CONFIG_READ, 0x0018773f, 0x00104001),
+        SOC15_REG_GOLDEN_VALUE(SDMA1, 0, mmSDMA1_CHICKEN_BITS, 0xfe931f07, 0x02831d07),
         SOC15_REG_GOLDEN_VALUE(SDMA1, 0, mmSDMA1_GB_ADDR_CONFIG, 0x0018773f, 0x00104001),
         SOC15_REG_GOLDEN_VALUE(SDMA1, 0, mmSDMA1_GB_ADDR_CONFIG_READ, 0x0018773f, 0x00104001)
 };
diff --git a/drivers/gpu/drm/amd/amdkfd/Kconfig b/drivers/gpu/drm/amd/amdkfd/Kconfig
index fbf0ee5201c3..c3613604a4f8 100644
--- a/drivers/gpu/drm/amd/amdkfd/Kconfig
+++ b/drivers/gpu/drm/amd/amdkfd/Kconfig
@@ -4,8 +4,8 @@
 
 config HSA_AMD
         bool "HSA kernel driver for AMD GPU devices"
-        depends on DRM_AMDGPU && X86_64
-        imply AMD_IOMMU_V2
+        depends on DRM_AMDGPU && (X86_64 || ARM64)
+        imply AMD_IOMMU_V2 if X86_64
         select MMU_NOTIFIER
         help
           Enable this if you want to use HSA features on AMD GPU devices.
diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_crat.c b/drivers/gpu/drm/amd/amdkfd/kfd_crat.c
index b7bc7d7d048f..5d85ff341385 100644
--- a/drivers/gpu/drm/amd/amdkfd/kfd_crat.c
+++ b/drivers/gpu/drm/amd/amdkfd/kfd_crat.c
@@ -863,6 +863,7 @@ static int kfd_fill_mem_info_for_cpu(int numa_node_id, int *avail_size,
         return 0;
 }
 
+#if CONFIG_X86_64
 static int kfd_fill_iolink_info_for_cpu(int numa_node_id, int *avail_size,
                                 uint32_t *num_entries,
                                 struct crat_subtype_iolink *sub_type_hdr)
@@ -905,6 +906,7 @@ static int kfd_fill_iolink_info_for_cpu(int numa_node_id, int *avail_size,
 
         return 0;
 }
+#endif
 
 /* kfd_create_vcrat_image_cpu - Create Virtual CRAT for CPU
  *
@@ -920,7 +922,9 @@ static int kfd_create_vcrat_image_cpu(void *pcrat_image, size_t *size)
         struct crat_subtype_generic *sub_type_hdr;
         int avail_size = *size;
         int numa_node_id;
+#ifdef CONFIG_X86_64
         uint32_t entries = 0;
+#endif
         int ret = 0;
 
         if (!pcrat_image || avail_size < VCRAT_SIZE_FOR_CPU)
@@ -982,6 +986,7 @@ static int kfd_create_vcrat_image_cpu(void *pcrat_image, size_t *size)
                         sub_type_hdr->length);
 
                 /* Fill in Subtype: IO Link */
+#ifdef CONFIG_X86_64
                 ret = kfd_fill_iolink_info_for_cpu(numa_node_id, &avail_size,
                                 &entries,
                                 (struct crat_subtype_iolink *)sub_type_hdr);
@@ -992,6 +997,9 @@ static int kfd_create_vcrat_image_cpu(void *pcrat_image, size_t *size)
 
                 sub_type_hdr = (typeof(sub_type_hdr))((char *)sub_type_hdr +
                                 sub_type_hdr->length * entries);
+#else
+                pr_info("IO link not available for non x86 platforms\n");
+#endif
 
                 crat_table->num_domains++;
         }
diff --git a/drivers/gpu/drm/amd/amdkfd/kfd_topology.c b/drivers/gpu/drm/amd/amdkfd/kfd_topology.c
index 5f5b2acedbac..09da91644f9f 100644
--- a/drivers/gpu/drm/amd/amdkfd/kfd_topology.c
+++ b/drivers/gpu/drm/amd/amdkfd/kfd_topology.c
@@ -1093,8 +1093,6 @@ static uint32_t kfd_generate_gpu_id(struct kfd_dev *gpu)
  *              the GPU device is not already present in the topology device
  *              list then return NULL. This means a new topology device has to
  *              be created for this GPU.
- * TODO: Rather than assiging @gpu to first topology device withtout
- *              gpu attached, it will better to have more stringent check.
  */
 static struct kfd_topology_device *kfd_assign_gpu(struct kfd_dev *gpu)
 {
@@ -1102,12 +1100,20 @@ static struct kfd_topology_device *kfd_assign_gpu(struct kfd_dev *gpu)
         struct kfd_topology_device *out_dev = NULL;
 
         down_write(&topology_lock);
-        list_for_each_entry(dev, &topology_device_list, list)
+        list_for_each_entry(dev, &topology_device_list, list) {
+                /* Discrete GPUs need their own topology device list
+                 * entries. Don't assign them to CPU/APU nodes.
+                 */
+                if (!gpu->device_info->needs_iommu_device &&
+                    dev->node_props.cpu_cores_count)
+                        continue;
+
                 if (!dev->gpu && (dev->node_props.simd_count > 0)) {
                         dev->gpu = gpu;
                         out_dev = dev;
                         break;
                 }
+        }
         up_write(&topology_lock);
         return out_dev;
 }
@@ -1392,7 +1398,6 @@ int kfd_topology_enum_kfd_devices(uint8_t idx, struct kfd_dev **kdev)
 
 static int kfd_cpumask_to_apic_id(const struct cpumask *cpumask)
 {
-        const struct cpuinfo_x86 *cpuinfo;
         int first_cpu_of_numa_node;
 
         if (!cpumask || cpumask == cpu_none_mask)
@@ -1400,9 +1405,11 @@ static int kfd_cpumask_to_apic_id(const struct cpumask *cpumask)
         first_cpu_of_numa_node = cpumask_first(cpumask);
         if (first_cpu_of_numa_node >= nr_cpu_ids)
                 return -1;
-        cpuinfo = &cpu_data(first_cpu_of_numa_node);
-
-        return cpuinfo->apicid;
+#ifdef CONFIG_X86_64
+        return cpu_data(first_cpu_of_numa_node).apicid;
+#else
+        return first_cpu_of_numa_node;
+#endif
 }
 
 /* kfd_numa_node_to_apic_id - Returns the APIC ID of the first logical processor
diff --git a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c
index a9a28dbc3e24..f4fa40c387d3 100644
--- a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c
+++ b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c
@@ -699,22 +699,36 @@ static void s3_handle_mst(struct drm_device *dev, bool suspend)
 {
         struct amdgpu_dm_connector *aconnector;
         struct drm_connector *connector;
+        struct drm_dp_mst_topology_mgr *mgr;
+        int ret;
+        bool need_hotplug = false;
 
         drm_modeset_lock(&dev->mode_config.connection_mutex, NULL);
 
-        list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
-                   aconnector = to_amdgpu_dm_connector(connector);
-                   if (aconnector->dc_link->type == dc_connection_mst_branch &&
-                                   !aconnector->mst_port) {
+        list_for_each_entry(connector, &dev->mode_config.connector_list,
+                            head) {
+                aconnector = to_amdgpu_dm_connector(connector);
+                if (aconnector->dc_link->type != dc_connection_mst_branch ||
+                    aconnector->mst_port)
+                        continue;
 
-                           if (suspend)
-                                   drm_dp_mst_topology_mgr_suspend(&aconnector->mst_mgr);
-                           else
-                                   drm_dp_mst_topology_mgr_resume(&aconnector->mst_mgr);
-                   }
+                mgr = &aconnector->mst_mgr;
+
+                if (suspend) {
+                        drm_dp_mst_topology_mgr_suspend(mgr);
+                } else {
+                        ret = drm_dp_mst_topology_mgr_resume(mgr);
+                        if (ret < 0) {
+                                drm_dp_mst_topology_mgr_set_mst(mgr, false);
+                                need_hotplug = true;
+                        }
+                }
         }
 
         drm_modeset_unlock(&dev->mode_config.connection_mutex);
+
+        if (need_hotplug)
+                drm_kms_helper_hotplug_event(dev);
 }
 
 /**
@@ -898,7 +912,6 @@ static int dm_resume(void *handle)
         struct drm_plane_state *new_plane_state;
         struct dm_plane_state *dm_new_plane_state;
         enum dc_connection_type new_connection_type = dc_connection_none;
-        int ret;
         int i;
 
         /* power on hardware */
@@ -971,13 +984,13 @@ static int dm_resume(void *handle)
                 }
         }
 
-        ret = drm_atomic_helper_resume(ddev, dm->cached_state);
+        drm_atomic_helper_resume(ddev, dm->cached_state);
 
         dm->cached_state = NULL;
 
         amdgpu_dm_irq_resume_late(adev);
 
-        return ret;
+        return 0;
 }
 
 /**
@@ -1759,7 +1772,7 @@ static int amdgpu_dm_backlight_update_status(struct backlight_device *bd)
                 + caps.min_input_signal * 0x101;
 
         if (dc_link_set_backlight_level(dm->backlight_link,
-                        brightness, 0, 0))
+                        brightness, 0))
                 return 0;
         else
                 return 1;
@@ -5920,7 +5933,7 @@ static int amdgpu_dm_atomic_check(struct drm_device *dev,
         for_each_oldnew_crtc_in_state(state, crtc, old_crtc_state, new_crtc_state, i) {
                 if (!drm_atomic_crtc_needs_modeset(new_crtc_state) &&
                     !new_crtc_state->color_mgmt_changed &&
-                    !new_crtc_state->vrr_enabled)
+                    old_crtc_state->vrr_enabled == new_crtc_state->vrr_enabled)
                         continue;
 
                 if (!new_crtc_state->enable)
diff --git a/drivers/gpu/drm/amd/display/dc/core/dc_link.c b/drivers/gpu/drm/amd/display/dc/core/dc_link.c
index 52deacf39841..b0265dbebd4c 100644
--- a/drivers/gpu/drm/amd/display/dc/core/dc_link.c
+++ b/drivers/gpu/drm/amd/display/dc/core/dc_link.c
@@ -2190,8 +2190,7 @@ int dc_link_get_backlight_level(const struct dc_link *link)
 
 bool dc_link_set_backlight_level(const struct dc_link *link,
                 uint32_t backlight_pwm_u16_16,
-                uint32_t frame_ramp,
-                const struct dc_stream_state *stream)
+                uint32_t frame_ramp)
 {
         struct dc  *core_dc = link->ctx->dc;
         struct abm *abm = core_dc->res_pool->abm;
@@ -2206,10 +2205,6 @@ bool dc_link_set_backlight_level(const struct dc_link *link,
                 (abm->funcs->set_backlight_level_pwm == NULL))
                 return false;
 
-        if (stream)
-                ((struct dc_stream_state *)stream)->bl_pwm_level =
-                                backlight_pwm_u16_16;
-
         use_smooth_brightness = dmcu->funcs->is_dmcu_initialized(dmcu);
 
         DC_LOG_BACKLIGHT("New Backlight level: %d (0x%X)\n",
@@ -2637,11 +2632,6 @@ void core_link_enable_stream(
 
                 if (dc_is_dp_signal(pipe_ctx->stream->signal))
                         enable_stream_features(pipe_ctx);
-
-                dc_link_set_backlight_level(pipe_ctx->stream->sink->link,
-                                pipe_ctx->stream->bl_pwm_level,
-                                0,
-                                pipe_ctx->stream);
         }
 
 }
diff --git a/drivers/gpu/drm/amd/display/dc/dc_link.h b/drivers/gpu/drm/amd/display/dc/dc_link.h
index 29f19d57ff7a..b2243e0dad1f 100644
--- a/drivers/gpu/drm/amd/display/dc/dc_link.h
+++ b/drivers/gpu/drm/amd/display/dc/dc_link.h
@@ -146,8 +146,7 @@ static inline struct dc_link *dc_get_link_at_index(struct dc *dc, uint32_t link_
  */
 bool dc_link_set_backlight_level(const struct dc_link *dc_link,
                 uint32_t backlight_pwm_u16_16,
-                uint32_t frame_ramp,
-                const struct dc_stream_state *stream);
+                uint32_t frame_ramp);
 
 int dc_link_get_backlight_level(const struct dc_link *dc_link);
 
diff --git a/drivers/gpu/drm/amd/display/dc/dc_stream.h b/drivers/gpu/drm/amd/display/dc/dc_stream.h
index be34d638e15d..d70c9e1cda3d 100644
--- a/drivers/gpu/drm/amd/display/dc/dc_stream.h
+++ b/drivers/gpu/drm/amd/display/dc/dc_stream.h
@@ -91,7 +91,6 @@ struct dc_stream_state {
 
         /* DMCU info */
         unsigned int abm_level;
-        unsigned int bl_pwm_level;
 
         /* from core_stream struct */
         struct dc_context *ctx;
diff --git a/drivers/gpu/drm/amd/display/dc/dce110/dce110_hw_sequencer.c b/drivers/gpu/drm/amd/display/dc/dce110/dce110_hw_sequencer.c
index 4bf24758217f..8f09b8625c5d 100644
--- a/drivers/gpu/drm/amd/display/dc/dce110/dce110_hw_sequencer.c
+++ b/drivers/gpu/drm/amd/display/dc/dce110/dce110_hw_sequencer.c
@@ -1000,7 +1000,7 @@ void dce110_enable_audio_stream(struct pipe_ctx *pipe_ctx)
 
                 pipe_ctx->stream_res.audio->funcs->az_enable(pipe_ctx->stream_res.audio);
 
-                if (num_audio == 1 && pp_smu != NULL && pp_smu->set_pme_wa_enable != NULL)
+                if (num_audio >= 1 && pp_smu != NULL && pp_smu->set_pme_wa_enable != NULL)
                         /*this is the first audio. apply the PME w/a in order to wake AZ from D3*/
                         pp_smu->set_pme_wa_enable(&pp_smu->pp_smu);
                 /* un-mute audio */
@@ -1017,6 +1017,8 @@ void dce110_disable_audio_stream(struct pipe_ctx *pipe_ctx, int option)
         pipe_ctx->stream_res.stream_enc->funcs->audio_mute_control(
                         pipe_ctx->stream_res.stream_enc, true);
         if (pipe_ctx->stream_res.audio) {
+                struct pp_smu_funcs_rv *pp_smu = dc->res_pool->pp_smu;
+
                 if (option != KEEP_ACQUIRED_RESOURCE ||
                                 !dc->debug.az_endpoint_mute_only) {
                         /*only disalbe az_endpoint if power down or free*/
@@ -1036,6 +1038,9 @@ void dce110_disable_audio_stream(struct pipe_ctx *pipe_ctx, int option)
                         update_audio_usage(&dc->current_state->res_ctx, dc->res_pool, pipe_ctx->stream_res.audio, false);
                         pipe_ctx->stream_res.audio = NULL;
                 }
+                if (pp_smu != NULL && pp_smu->set_pme_wa_enable != NULL)
+                        /*this is the first audio. apply the PME w/a in order to wake AZ from D3*/
+                        pp_smu->set_pme_wa_enable(&pp_smu->pp_smu);
 
                 /* TODO: notify audio driver for if audio modes list changed
                  * add audio mode list change flag */
diff --git a/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_dpp.c b/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_dpp.c
index dcb3c5530236..cd1ebe57ed59 100644
--- a/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_dpp.c
+++ b/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_dpp.c
@@ -463,7 +463,7 @@ void dpp1_set_cursor_position(
         if (src_y_offset >= (int)param->viewport.height)
                 cur_en = 0;  /* not visible beyond bottom edge*/
 
-        if (src_y_offset < 0)
+        if (src_y_offset + (int)height <= 0)
                 cur_en = 0;  /* not visible beyond top edge*/
 
         REG_UPDATE(CURSOR0_CONTROL,
diff --git a/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_hubp.c b/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_hubp.c
index 345af015d061..d1acd7165bc8 100644
--- a/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_hubp.c
+++ b/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_hubp.c
@@ -1140,7 +1140,7 @@ void hubp1_cursor_set_position(
         if (src_y_offset >= (int)param->viewport.height)
                 cur_en = 0;  /* not visible beyond bottom edge*/
 
-        if (src_y_offset < 0) //+ (int)hubp->curs_attr.height
+        if (src_y_offset + (int)hubp->curs_attr.height <= 0)
                 cur_en = 0;  /* not visible beyond top edge*/
 
         if (cur_en && REG_READ(CURSOR_SURFACE_ADDRESS) == 0)
diff --git a/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_hw_sequencer.c b/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_hw_sequencer.c
index 91e015e14355..58a12ddf12f3 100644
--- a/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_hw_sequencer.c
+++ b/drivers/gpu/drm/amd/display/dc/dcn10/dcn10_hw_sequencer.c
@@ -2355,29 +2355,22 @@ static void dcn10_apply_ctx_for_surface(
                         top_pipe_to_program->plane_state->update_flags.bits.full_update)
                 for (i = 0; i < dc->res_pool->pipe_count; i++) {
                         struct pipe_ctx *pipe_ctx = &context->res_ctx.pipe_ctx[i];
-
+                        tg = pipe_ctx->stream_res.tg;
                         /* Skip inactive pipes and ones already updated */
                         if (!pipe_ctx->stream || pipe_ctx->stream == stream
-                                        || !pipe_ctx->plane_state)
+                                        || !pipe_ctx->plane_state
+                                        || !tg->funcs->is_tg_enabled(tg))
                                 continue;
 
-                        pipe_ctx->stream_res.tg->funcs->lock(pipe_ctx->stream_res.tg);
+                        tg->funcs->lock(tg);
 
                         pipe_ctx->plane_res.hubp->funcs->hubp_setup_interdependent(
                                 pipe_ctx->plane_res.hubp,
                                 &pipe_ctx->dlg_regs,
                                 &pipe_ctx->ttu_regs);
-                }
-
-        for (i = 0; i < dc->res_pool->pipe_count; i++) {
-                struct pipe_ctx *pipe_ctx = &context->res_ctx.pipe_ctx[i];
 
-                if (!pipe_ctx->stream || pipe_ctx->stream == stream
-                                || !pipe_ctx->plane_state)
-                        continue;
-
-                dcn10_pipe_control_lock(dc, pipe_ctx, false);
-        }
+                        tg->funcs->unlock(tg);
+                }
 
         if (num_planes == 0)
                 false_optc_underflow_wa(dc, stream, tg);
diff --git a/drivers/gpu/drm/amd/display/modules/power/power_helpers.c b/drivers/gpu/drm/amd/display/modules/power/power_helpers.c
index 00f63b7dd32f..c11a443dcbc8 100644
--- a/drivers/gpu/drm/amd/display/modules/power/power_helpers.c
+++ b/drivers/gpu/drm/amd/display/modules/power/power_helpers.c
@@ -57,6 +57,7 @@ static const unsigned char abm_config[abm_defines_max_config][abm_defines_max_le
 #define NUM_POWER_FN_SEGS 8
 #define NUM_BL_CURVE_SEGS 16
 
+#pragma pack(push, 1)
 /* NOTE: iRAM is 256B in size */
 struct iram_table_v_2 {
         /* flags                      */
@@ -100,6 +101,7 @@ struct iram_table_v_2 {
         uint8_t dummy8;                                                 /* 0xfe       */
         uint8_t dummy9;                                                 /* 0xff       */
 };
+#pragma pack(pop)
 
 static uint16_t backlight_8_to_16(unsigned int backlight_8bit)
 {
diff --git a/drivers/gpu/drm/amd/include/kgd_pp_interface.h b/drivers/gpu/drm/amd/include/kgd_pp_interface.h
index 1479ea1dc3e7..789c4f288485 100644
--- a/drivers/gpu/drm/amd/include/kgd_pp_interface.h
+++ b/drivers/gpu/drm/amd/include/kgd_pp_interface.h
@@ -127,12 +127,13 @@ enum amd_pp_task {
 };
 
 enum PP_SMC_POWER_PROFILE {
-        PP_SMC_POWER_PROFILE_FULLSCREEN3D = 0x0,
-        PP_SMC_POWER_PROFILE_POWERSAVING  = 0x1,
-        PP_SMC_POWER_PROFILE_VIDEO        = 0x2,
-        PP_SMC_POWER_PROFILE_VR           = 0x3,
-        PP_SMC_POWER_PROFILE_COMPUTE      = 0x4,
-        PP_SMC_POWER_PROFILE_CUSTOM       = 0x5,
+        PP_SMC_POWER_PROFILE_BOOTUP_DEFAULT = 0x0,
+        PP_SMC_POWER_PROFILE_FULLSCREEN3D = 0x1,
+        PP_SMC_POWER_PROFILE_POWERSAVING  = 0x2,
+        PP_SMC_POWER_PROFILE_VIDEO        = 0x3,
+        PP_SMC_POWER_PROFILE_VR           = 0x4,
+        PP_SMC_POWER_PROFILE_COMPUTE      = 0x5,
+        PP_SMC_POWER_PROFILE_CUSTOM       = 0x6,
 };
 
 enum {
diff --git a/drivers/gpu/drm/amd/powerplay/hwmgr/hwmgr.c b/drivers/gpu/drm/amd/powerplay/hwmgr/hwmgr.c
index 0173d0480024..310b102a9292 100644
--- a/drivers/gpu/drm/amd/powerplay/hwmgr/hwmgr.c
+++ b/drivers/gpu/drm/amd/powerplay/hwmgr/hwmgr.c
@@ -64,17 +64,19 @@ static int ci_set_asic_special_caps(struct pp_hwmgr *hwmgr);
 
 static void hwmgr_init_workload_prority(struct pp_hwmgr *hwmgr)
 {
-        hwmgr->workload_prority[PP_SMC_POWER_PROFILE_FULLSCREEN3D] = 2;
-        hwmgr->workload_prority[PP_SMC_POWER_PROFILE_POWERSAVING] = 0;
-        hwmgr->workload_prority[PP_SMC_POWER_PROFILE_VIDEO] = 1;
-        hwmgr->workload_prority[PP_SMC_POWER_PROFILE_VR] = 3;
-        hwmgr->workload_prority[PP_SMC_POWER_PROFILE_COMPUTE] = 4;
-
-        hwmgr->workload_setting[0] = PP_SMC_POWER_PROFILE_POWERSAVING;
-        hwmgr->workload_setting[1] = PP_SMC_POWER_PROFILE_VIDEO;
-        hwmgr->workload_setting[2] = PP_SMC_POWER_PROFILE_FULLSCREEN3D;
-        hwmgr->workload_setting[3] = PP_SMC_POWER_PROFILE_VR;
-        hwmgr->workload_setting[4] = PP_SMC_POWER_PROFILE_COMPUTE;
+        hwmgr->workload_prority[PP_SMC_POWER_PROFILE_BOOTUP_DEFAULT] = 0;
+        hwmgr->workload_prority[PP_SMC_POWER_PROFILE_FULLSCREEN3D] = 1;
+        hwmgr->workload_prority[PP_SMC_POWER_PROFILE_POWERSAVING] = 2;
+        hwmgr->workload_prority[PP_SMC_POWER_PROFILE_VIDEO] = 3;
+        hwmgr->workload_prority[PP_SMC_POWER_PROFILE_VR] = 4;
+        hwmgr->workload_prority[PP_SMC_POWER_PROFILE_COMPUTE] = 5;
+
+        hwmgr->workload_setting[0] = PP_SMC_POWER_PROFILE_BOOTUP_DEFAULT;
+        hwmgr->workload_setting[1] = PP_SMC_POWER_PROFILE_FULLSCREEN3D;
+        hwmgr->workload_setting[2] = PP_SMC_POWER_PROFILE_POWERSAVING;
+        hwmgr->workload_setting[3] = PP_SMC_POWER_PROFILE_VIDEO;
+        hwmgr->workload_setting[4] = PP_SMC_POWER_PROFILE_VR;
+        hwmgr->workload_setting[5] = PP_SMC_POWER_PROFILE_COMPUTE;
 }
 
 int hwmgr_early_init(struct pp_hwmgr *hwmgr)
diff --git a/drivers/gpu/drm/amd/powerplay/hwmgr/smu7_hwmgr.c b/drivers/gpu/drm/amd/powerplay/hwmgr/smu7_hwmgr.c
index d91390459326..c8f5c00dd1e7 100644
--- a/drivers/gpu/drm/amd/powerplay/hwmgr/smu7_hwmgr.c
+++ b/drivers/gpu/drm/amd/powerplay/hwmgr/smu7_hwmgr.c
@@ -77,8 +77,9 @@
 #define PCIE_BUS_CLK                10000
 #define TCLK                        (PCIE_BUS_CLK / 10)
 
-static const struct profile_mode_setting smu7_profiling[6] =
-                                        {{1, 0, 100, 30, 1, 0, 100, 10},
+static const struct profile_mode_setting smu7_profiling[7] =
+                                        {{0, 0, 0, 0, 0, 0, 0, 0},
+                                         {1, 0, 100, 30, 1, 0, 100, 10},
                                          {1, 10, 0, 30, 0, 0, 0, 0},
                                          {0, 0, 0, 0, 1, 10, 16, 31},
                                          {1, 0, 11, 50, 1, 0, 100, 10},
@@ -4889,7 +4890,8 @@ static int smu7_get_power_profile_mode(struct pp_hwmgr *hwmgr, char *buf)
         uint32_t i, size = 0;
         uint32_t len;
 
-        static const char *profile_name[6] = {"3D_FULL_SCREEN",
+        static const char *profile_name[7] = {"BOOTUP_DEFAULT",
+                                        "3D_FULL_SCREEN",
                                         "POWER_SAVING",
                                         "VIDEO",
                                         "VR",
diff --git a/drivers/gpu/drm/amd/powerplay/hwmgr/vega10_hwmgr.c b/drivers/gpu/drm/amd/powerplay/hwmgr/vega10_hwmgr.c
index 79c86247d0ac..91e3bbe6d61d 100644
--- a/drivers/gpu/drm/amd/powerplay/hwmgr/vega10_hwmgr.c
+++ b/drivers/gpu/drm/amd/powerplay/hwmgr/vega10_hwmgr.c
@@ -804,9 +804,9 @@ static int vega10_hwmgr_backend_init(struct pp_hwmgr *hwmgr)
 
         hwmgr->backend = data;
 
-        hwmgr->workload_mask = 1 << hwmgr->workload_prority[PP_SMC_POWER_PROFILE_VIDEO];
-        hwmgr->power_profile_mode = PP_SMC_POWER_PROFILE_VIDEO;
-        hwmgr->default_power_profile_mode = PP_SMC_POWER_PROFILE_VIDEO;
+        hwmgr->workload_mask = 1 << hwmgr->workload_prority[PP_SMC_POWER_PROFILE_BOOTUP_DEFAULT];
+        hwmgr->power_profile_mode = PP_SMC_POWER_PROFILE_BOOTUP_DEFAULT;
+        hwmgr->default_power_profile_mode = PP_SMC_POWER_PROFILE_BOOTUP_DEFAULT;
 
         vega10_set_default_registry_data(hwmgr);
         data->disable_dpm_mask = 0xff;
@@ -4668,13 +4668,15 @@ static int vega10_get_power_profile_mode(struct pp_hwmgr *hwmgr, char *buf)
 {
         struct vega10_hwmgr *data = hwmgr->backend;
         uint32_t i, size = 0;
-        static const uint8_t profile_mode_setting[5][4] = {{70, 60, 1, 3,},
+        static const uint8_t profile_mode_setting[6][4] = {{70, 60, 0, 0,},
+                                                {70, 60, 1, 3,},
                                                 {90, 60, 0, 0,},
                                                 {70, 60, 0, 0,},
                                                 {70, 90, 0, 0,},
                                                 {30, 60, 0, 6,},
                                                 };
-        static const char *profile_name[6] = {"3D_FULL_SCREEN",
+        static const char *profile_name[7] = {"BOOTUP_DEFAULT",
+                                        "3D_FULL_SCREEN",
                                         "POWER_SAVING",
                                         "VIDEO",
                                         "VR",
diff --git a/drivers/gpu/drm/amd/powerplay/hwmgr/vega10_processpptables.c b/drivers/gpu/drm/amd/powerplay/hwmgr/vega10_processpptables.c
index b8747a5c9204..99d596dc0e89 100644
--- a/drivers/gpu/drm/amd/powerplay/hwmgr/vega10_processpptables.c
+++ b/drivers/gpu/drm/amd/powerplay/hwmgr/vega10_processpptables.c
@@ -32,6 +32,7 @@
 #include "vega10_pptable.h"
 
 #define NUM_DSPCLK_LEVELS 8
+#define VEGA10_ENGINECLOCK_HARDMAX 198000
 
 static void set_hw_cap(struct pp_hwmgr *hwmgr, bool enable,
                 enum phm_platform_caps cap)
@@ -258,7 +259,26 @@ static int init_over_drive_limits(
                 struct pp_hwmgr *hwmgr,
                 const ATOM_Vega10_POWERPLAYTABLE *powerplay_table)
 {
-        hwmgr->platform_descriptor.overdriveLimit.engineClock =
+        const ATOM_Vega10_GFXCLK_Dependency_Table *gfxclk_dep_table =
+                        (const ATOM_Vega10_GFXCLK_Dependency_Table *)
+                        (((unsigned long) powerplay_table) +
+                        le16_to_cpu(powerplay_table->usGfxclkDependencyTableOffset));
+        bool is_acg_enabled = false;
+        ATOM_Vega10_GFXCLK_Dependency_Record_V2 *patom_record_v2;
+
+        if (gfxclk_dep_table->ucRevId == 1) {
+                patom_record_v2 =
+                        (ATOM_Vega10_GFXCLK_Dependency_Record_V2 *)gfxclk_dep_table->entries;
+                is_acg_enabled =
+                        (bool)patom_record_v2[gfxclk_dep_table->ucNumEntries-1].ucACGEnable;
+        }
+
+        if (powerplay_table->ulMaxODEngineClock > VEGA10_ENGINECLOCK_HARDMAX &&
+                !is_acg_enabled)
+                hwmgr->platform_descriptor.overdriveLimit.engineClock =
+                        VEGA10_ENGINECLOCK_HARDMAX;
+        else
+                hwmgr->platform_descriptor.overdriveLimit.engineClock =
                         le32_to_cpu(powerplay_table->ulMaxODEngineClock);
         hwmgr->platform_descriptor.overdriveLimit.memoryClock =
                         le32_to_cpu(powerplay_table->ulMaxODMemoryClock);
diff --git a/drivers/gpu/drm/amd/powerplay/hwmgr/vega12_hwmgr.c b/drivers/gpu/drm/amd/powerplay/hwmgr/vega12_hwmgr.c
index 54364444ecd1..0c8212902275 100644
--- a/drivers/gpu/drm/amd/powerplay/hwmgr/vega12_hwmgr.c
+++ b/drivers/gpu/drm/amd/powerplay/hwmgr/vega12_hwmgr.c
@@ -753,6 +753,22 @@ static int vega12_init_smc_table(struct pp_hwmgr *hwmgr)
         return 0;
 }
 
+static int vega12_run_acg_btc(struct pp_hwmgr *hwmgr)
+{
+        uint32_t result;
+
+        PP_ASSERT_WITH_CODE(
+                smum_send_msg_to_smc(hwmgr, PPSMC_MSG_RunAcgBtc) == 0,
+                "[Run_ACG_BTC] Attempt to run ACG BTC failed!",
+                return -EINVAL);
+
+        result = smum_get_argument(hwmgr);
+        PP_ASSERT_WITH_CODE(result == 1,
+                        "Failed to run ACG BTC!", return -EINVAL);
+
+        return 0;
+}
+
 static int vega12_set_allowed_featuresmask(struct pp_hwmgr *hwmgr)
 {
         struct vega12_hwmgr *data =
@@ -931,6 +947,11 @@ static int vega12_enable_dpm_tasks(struct pp_hwmgr *hwmgr)
                         "Failed to initialize SMC table!",
                         result = tmp_result);
 
+        tmp_result = vega12_run_acg_btc(hwmgr);
+        PP_ASSERT_WITH_CODE(!tmp_result,
+                        "Failed to run ACG BTC!",
+                        result = tmp_result);
+
         result = vega12_enable_all_smu_features(hwmgr);
         PP_ASSERT_WITH_CODE(!result,
                         "Failed to enable all smu features!",
diff --git a/drivers/gpu/drm/amd/powerplay/hwmgr/vega20_hwmgr.c b/drivers/gpu/drm/amd/powerplay/hwmgr/vega20_hwmgr.c
index 26154f9b2178..82935a3bd950 100644
--- a/drivers/gpu/drm/amd/powerplay/hwmgr/vega20_hwmgr.c
+++ b/drivers/gpu/drm/amd/powerplay/hwmgr/vega20_hwmgr.c
@@ -390,9 +390,9 @@ static int vega20_hwmgr_backend_init(struct pp_hwmgr *hwmgr)
 
         hwmgr->backend = data;
 
-        hwmgr->workload_mask = 1 << hwmgr->workload_prority[PP_SMC_POWER_PROFILE_VIDEO];
-        hwmgr->power_profile_mode = PP_SMC_POWER_PROFILE_VIDEO;
-        hwmgr->default_power_profile_mode = PP_SMC_POWER_PROFILE_VIDEO;
+        hwmgr->workload_mask = 1 << hwmgr->workload_prority[PP_SMC_POWER_PROFILE_BOOTUP_DEFAULT];
+        hwmgr->power_profile_mode = PP_SMC_POWER_PROFILE_BOOTUP_DEFAULT;
+        hwmgr->default_power_profile_mode = PP_SMC_POWER_PROFILE_BOOTUP_DEFAULT;
 
         vega20_set_default_registry_data(hwmgr);
 
@@ -980,6 +980,9 @@ static int vega20_od8_set_feature_capabilities(
             pp_table->FanZeroRpmEnable)
                 od_settings->overdrive8_capabilities |= OD8_FAN_ZERO_RPM_CONTROL;
 
+        if (!od_settings->overdrive8_capabilities)
+                hwmgr->od_enabled = false;
+
         return 0;
 }
 
@@ -1689,13 +1692,6 @@ static int vega20_upload_dpm_min_level(struct pp_hwmgr *hwmgr, uint32_t feature_
                                         (PPCLK_UCLK << 16) | (min_freq & 0xffff))),
                                         "Failed to set soft min memclk !",
                                         return ret);
-
-                min_freq = data->dpm_table.mem_table.dpm_state.hard_min_level;
-                PP_ASSERT_WITH_CODE(!(ret = smum_send_msg_to_smc_with_parameter(
-                                        hwmgr, PPSMC_MSG_SetHardMinByFreq,
-                                        (PPCLK_UCLK << 16) | (min_freq & 0xffff))),
-                                        "Failed to set hard min memclk !",
-                                        return ret);
         }
 
         if (data->smu_features[GNLD_DPM_UVD].enabled &&
@@ -2248,6 +2244,13 @@ static int vega20_force_clock_level(struct pp_hwmgr *hwmgr,
                 soft_min_level = mask ? (ffs(mask) - 1) : 0;
                 soft_max_level = mask ? (fls(mask) - 1) : 0;
 
+                if (soft_max_level >= data->dpm_table.gfx_table.count) {
+                        pr_err("Clock level specified %d is over max allowed %d\n",
+                                        soft_max_level,
+                                        data->dpm_table.gfx_table.count - 1);
+                        return -EINVAL;
+                }
+
                 data->dpm_table.gfx_table.dpm_state.soft_min_level =
                         data->dpm_table.gfx_table.dpm_levels[soft_min_level].value;
                 data->dpm_table.gfx_table.dpm_state.soft_max_level =
@@ -2268,6 +2271,13 @@ static int vega20_force_clock_level(struct pp_hwmgr *hwmgr,
                 soft_min_level = mask ? (ffs(mask) - 1) : 0;
                 soft_max_level = mask ? (fls(mask) - 1) : 0;
 
+                if (soft_max_level >= data->dpm_table.mem_table.count) {
+                        pr_err("Clock level specified %d is over max allowed %d\n",
+                                        soft_max_level,
+                                        data->dpm_table.mem_table.count - 1);
+                        return -EINVAL;
+                }
+
                 data->dpm_table.mem_table.dpm_state.soft_min_level =
                         data->dpm_table.mem_table.dpm_levels[soft_min_level].value;
                 data->dpm_table.mem_table.dpm_state.soft_max_level =
@@ -3261,6 +3271,9 @@ static int conv_power_profile_to_pplib_workload(int power_profile)
         int pplib_workload = 0;
 
         switch (power_profile) {
+        case PP_SMC_POWER_PROFILE_BOOTUP_DEFAULT:
+                pplib_workload = WORKLOAD_DEFAULT_BIT;
+                break;
         case PP_SMC_POWER_PROFILE_FULLSCREEN3D:
                 pplib_workload = WORKLOAD_PPLIB_FULL_SCREEN_3D_BIT;
                 break;
@@ -3290,6 +3303,7 @@ static int vega20_get_power_profile_mode(struct pp_hwmgr *hwmgr, char *buf)
         uint32_t i, size = 0;
         uint16_t workload_type = 0;
         static const char *profile_name[] = {
+                                        "BOOTUP_DEFAULT",
                                         "3D_FULL_SCREEN",
                                         "POWER_SAVING",
                                         "VIDEO",
diff --git a/drivers/gpu/drm/amd/powerplay/inc/hwmgr.h b/drivers/gpu/drm/amd/powerplay/inc/hwmgr.h
index 0d298a0409f5..8cb831b6a016 100644
--- a/drivers/gpu/drm/amd/powerplay/inc/hwmgr.h
+++ b/drivers/gpu/drm/amd/powerplay/inc/hwmgr.h
@@ -705,7 +705,7 @@ enum PP_TABLE_VERSION {
 /**
  * The main hardware manager structure.
  */
-#define Workload_Policy_Max 5
+#define Workload_Policy_Max 6
 
 struct pp_hwmgr {
         void *adev;
diff --git a/drivers/gpu/drm/bridge/tc358767.c b/drivers/gpu/drm/bridge/tc358767.c
index 8e28e738cb52..e6403b9549f1 100644
--- a/drivers/gpu/drm/bridge/tc358767.c
+++ b/drivers/gpu/drm/bridge/tc358767.c
@@ -98,6 +98,8 @@
 #define DP0_STARTVAL            0x064c
 #define DP0_ACTIVEVAL           0x0650
 #define DP0_SYNCVAL             0x0654
+#define SYNCVAL_HS_POL_ACTIVE_LOW       (1 << 15)
+#define SYNCVAL_VS_POL_ACTIVE_LOW       (1 << 31)
 #define DP0_MISC                0x0658
 #define TU_SIZE_RECOMMENDED             (63) /* LSCLK cycles per TU */
 #define BPC_6                           (0 << 5)
@@ -142,6 +144,8 @@
 #define DP0_LTLOOPCTRL          0x06d8
 #define DP0_SNKLTCTRL           0x06e4
 
+#define DP1_SRCCTRL             0x07a0
+
 /* PHY */
 #define DP_PHY_CTRL             0x0800
 #define DP_PHY_RST                      BIT(28)  /* DP PHY Global Soft Reset */
@@ -150,6 +154,7 @@
 #define PHY_M1_RST                      BIT(12)  /* Reset PHY1 Main Channel */
 #define PHY_RDY                         BIT(16)  /* PHY Main Channels Ready */
 #define PHY_M0_RST                      BIT(8)   /* Reset PHY0 Main Channel */
+#define PHY_2LANE                       BIT(2)   /* PHY Enable 2 lanes */
 #define PHY_A0_EN                       BIT(1)   /* PHY Aux Channel0 Enable */
 #define PHY_M0_EN                       BIT(0)   /* PHY Main Channel0 Enable */
 
@@ -540,6 +545,7 @@ static int tc_aux_link_setup(struct tc_data *tc)
         unsigned long rate;
         u32 value;
         int ret;
+        u32 dp_phy_ctrl;
 
         rate = clk_get_rate(tc->refclk);
         switch (rate) {
@@ -564,7 +570,10 @@ static int tc_aux_link_setup(struct tc_data *tc)
         value |= SYSCLK_SEL_LSCLK | LSCLK_DIV_2;
         tc_write(SYS_PLLPARAM, value);
 
-        tc_write(DP_PHY_CTRL, BGREN | PWR_SW_EN | BIT(2) | PHY_A0_EN);
+        dp_phy_ctrl = BGREN | PWR_SW_EN | PHY_A0_EN;
+        if (tc->link.base.num_lanes == 2)
+                dp_phy_ctrl |= PHY_2LANE;
+        tc_write(DP_PHY_CTRL, dp_phy_ctrl);
 
         /*
          * Initially PLLs are in bypass. Force PLL parameter update,
@@ -719,7 +728,9 @@ static int tc_set_video_mode(struct tc_data *tc, struct drm_display_mode *mode)
 
         tc_write(DP0_ACTIVEVAL, (mode->vdisplay << 16) | (mode->hdisplay));
 
-        tc_write(DP0_SYNCVAL, (vsync_len << 16) | (hsync_len << 0));
+        tc_write(DP0_SYNCVAL, (vsync_len << 16) | (hsync_len << 0) |
+                 ((mode->flags & DRM_MODE_FLAG_NHSYNC) ? SYNCVAL_HS_POL_ACTIVE_LOW : 0) |
+                 ((mode->flags & DRM_MODE_FLAG_NVSYNC) ? SYNCVAL_VS_POL_ACTIVE_LOW : 0));
 
         tc_write(DPIPXLFMT, VS_POL_ACTIVE_LOW | HS_POL_ACTIVE_LOW |
                  DE_POL_ACTIVE_HIGH | SUB_CFG_TYPE_CONFIG1 | DPI_BPP_RGB888);
@@ -829,12 +840,11 @@ static int tc_main_link_setup(struct tc_data *tc)
         if (!tc->mode)
                 return -EINVAL;
 
-        /* from excel file - DP0_SrcCtrl */
-        tc_write(DP0_SRCCTRL, DP0_SRCCTRL_SCRMBLDIS | DP0_SRCCTRL_EN810B |
-                 DP0_SRCCTRL_LANESKEW | DP0_SRCCTRL_LANES_2 |
-                 DP0_SRCCTRL_BW27 | DP0_SRCCTRL_AUTOCORRECT);
-        /* from excel file - DP1_SrcCtrl */
-        tc_write(0x07a0, 0x00003083);
+        tc_write(DP0_SRCCTRL, tc_srcctrl(tc));
+        /* SSCG and BW27 on DP1 must be set to the same as on DP0 */
+        tc_write(DP1_SRCCTRL,
+                 (tc->link.spread ? DP0_SRCCTRL_SSCG : 0) |
+                 ((tc->link.base.rate != 162000) ? DP0_SRCCTRL_BW27 : 0));
 
         rate = clk_get_rate(tc->refclk);
         switch (rate) {
@@ -855,8 +865,11 @@ static int tc_main_link_setup(struct tc_data *tc)
         }
         value |= SYSCLK_SEL_LSCLK | LSCLK_DIV_2;
         tc_write(SYS_PLLPARAM, value);
+
         /* Setup Main Link */
-        dp_phy_ctrl = BGREN | PWR_SW_EN | BIT(2) | PHY_A0_EN |  PHY_M0_EN;
+        dp_phy_ctrl = BGREN | PWR_SW_EN | PHY_A0_EN | PHY_M0_EN;
+        if (tc->link.base.num_lanes == 2)
+                dp_phy_ctrl |= PHY_2LANE;
         tc_write(DP_PHY_CTRL, dp_phy_ctrl);
         msleep(100);
 
@@ -1105,10 +1118,20 @@ static bool tc_bridge_mode_fixup(struct drm_bridge *bridge,
 static enum drm_mode_status tc_connector_mode_valid(struct drm_connector *connector,
                                    struct drm_display_mode *mode)
 {
+        struct tc_data *tc = connector_to_tc(connector);
+        u32 req, avail;
+        u32 bits_per_pixel = 24;
+
         /* DPI interface clock limitation: upto 154 MHz */
         if (mode->clock > 154000)
                 return MODE_CLOCK_HIGH;
 
+        req = mode->clock * bits_per_pixel / 8;
+        avail = tc->link.base.num_lanes * tc->link.base.rate;
+
+        if (req > avail)
+                return MODE_BAD;
+
         return MODE_OK;
 }
 
@@ -1186,7 +1209,8 @@ static int tc_bridge_attach(struct drm_bridge *bridge)
         /* Create eDP connector */
         drm_connector_helper_add(&tc->connector, &tc_connector_helper_funcs);
         ret = drm_connector_init(drm, &tc->connector, &tc_connector_funcs,
-                                 DRM_MODE_CONNECTOR_eDP);
+                                 tc->panel ? DRM_MODE_CONNECTOR_eDP :
+                                 DRM_MODE_CONNECTOR_DisplayPort);
         if (ret)
                 return ret;
 
@@ -1195,6 +1219,10 @@ static int tc_bridge_attach(struct drm_bridge *bridge)
 
         drm_display_info_set_bus_formats(&tc->connector.display_info,
                                          &bus_format, 1);
+        tc->connector.display_info.bus_flags =
+                DRM_BUS_FLAG_DE_HIGH |
+                DRM_BUS_FLAG_PIXDATA_NEGEDGE |
+                DRM_BUS_FLAG_SYNC_NEGEDGE;
         drm_connector_attach_encoder(&tc->connector, tc->bridge.encoder);
 
         return 0;
diff --git a/drivers/gpu/drm/drm_atomic_uapi.c b/drivers/gpu/drm/drm_atomic_uapi.c
index c40889888a16..9a1f41adfc67 100644
--- a/drivers/gpu/drm/drm_atomic_uapi.c
+++ b/drivers/gpu/drm/drm_atomic_uapi.c
@@ -1296,12 +1296,11 @@ int drm_mode_atomic_ioctl(struct drm_device *dev,
                         (arg->flags & DRM_MODE_PAGE_FLIP_EVENT))
                 return -EINVAL;
 
-        drm_modeset_acquire_init(&ctx, DRM_MODESET_ACQUIRE_INTERRUPTIBLE);
-
         state = drm_atomic_state_alloc(dev);
         if (!state)
                 return -ENOMEM;
 
+        drm_modeset_acquire_init(&ctx, DRM_MODESET_ACQUIRE_INTERRUPTIBLE);
         state->acquire_ctx = &ctx;
         state->allow_modeset = !!(arg->flags & DRM_MODE_ATOMIC_ALLOW_MODESET);
 
diff --git a/drivers/gpu/drm/drm_dp_helper.c b/drivers/gpu/drm/drm_dp_helper.c
index 2d6c491a0542..516e82d0ed50 100644
--- a/drivers/gpu/drm/drm_dp_helper.c
+++ b/drivers/gpu/drm/drm_dp_helper.c
@@ -1273,6 +1273,8 @@ static const struct dpcd_quirk dpcd_quirk_list[] = {
         { OUI(0x00, 0x22, 0xb9), DEVICE_ID_ANY, true, BIT(DP_DPCD_QUIRK_CONSTANT_N) },
         /* LG LP140WF6-SPM1 eDP panel */
         { OUI(0x00, 0x22, 0xb9), DEVICE_ID('s', 'i', 'v', 'a', 'r', 'T'), false, BIT(DP_DPCD_QUIRK_CONSTANT_N) },
+        /* Apple panels need some additional handling to support PSR */
+        { OUI(0x00, 0x10, 0xfa), DEVICE_ID_ANY, false, BIT(DP_DPCD_QUIRK_NO_PSR) }
 };
 
 #undef OUI
diff --git a/drivers/gpu/drm/drm_fb_helper.c b/drivers/gpu/drm/drm_fb_helper.c
index d3af098b0922..d73703a695e8 100644
--- a/drivers/gpu/drm/drm_fb_helper.c
+++ b/drivers/gpu/drm/drm_fb_helper.c
@@ -1621,6 +1621,64 @@ static bool drm_fb_pixel_format_equal(const struct fb_var_screeninfo *var_1,
                var_1->transp.msb_right == var_2->transp.msb_right;
 }
 
+static void drm_fb_helper_fill_pixel_fmt(struct fb_var_screeninfo *var,
+                                         u8 depth)
+{
+        switch (depth) {
+        case 8:
+                var->red.offset = 0;
+                var->green.offset = 0;
+                var->blue.offset = 0;
+                var->red.length = 8; /* 8bit DAC */
+                var->green.length = 8;
+                var->blue.length = 8;
+                var->transp.offset = 0;
+                var->transp.length = 0;
+                break;
+        case 15:
+                var->red.offset = 10;
+                var->green.offset = 5;
+                var->blue.offset = 0;
+                var->red.length = 5;
+                var->green.length = 5;
+                var->blue.length = 5;
+                var->transp.offset = 15;
+                var->transp.length = 1;
+                break;
+        case 16:
+                var->red.offset = 11;
+                var->green.offset = 5;
+                var->blue.offset = 0;
+                var->red.length = 5;
+                var->green.length = 6;
+                var->blue.length = 5;
+                var->transp.offset = 0;
+                break;
+        case 24:
+                var->red.offset = 16;
+                var->green.offset = 8;
+                var->blue.offset = 0;
+                var->red.length = 8;
+                var->green.length = 8;
+                var->blue.length = 8;
+                var->transp.offset = 0;
+                var->transp.length = 0;
+                break;
+        case 32:
+                var->red.offset = 16;
+                var->green.offset = 8;
+                var->blue.offset = 0;
+                var->red.length = 8;
+                var->green.length = 8;
+                var->blue.length = 8;
+                var->transp.offset = 24;
+                var->transp.length = 8;
+                break;
+        default:
+                break;
+        }
+}
+
 /**
  * drm_fb_helper_check_var - implementation for &fb_ops.fb_check_var
  * @var: screeninfo to check
@@ -1632,9 +1690,14 @@ int drm_fb_helper_check_var(struct fb_var_screeninfo *var,
         struct drm_fb_helper *fb_helper = info->par;
         struct drm_framebuffer *fb = fb_helper->fb;
 
-        if (var->pixclock != 0 || in_dbg_master())
+        if (in_dbg_master())
                 return -EINVAL;
 
+        if (var->pixclock != 0) {
+                DRM_DEBUG("fbdev emulation doesn't support changing the pixel clock, value of pixclock is ignored\n");
+                var->pixclock = 0;
+        }
+
         if ((drm_format_info_block_width(fb->format, 0) > 1) ||
             (drm_format_info_block_height(fb->format, 0) > 1))
                 return -EINVAL;
@@ -1655,6 +1718,20 @@ int drm_fb_helper_check_var(struct fb_var_screeninfo *var,
         }
 
         /*
+         * Workaround for SDL 1.2, which is known to be setting all pixel format
+         * fields values to zero in some cases. We treat this situation as a
+         * kind of "use some reasonable autodetected values".
+         */
+        if (!var->red.offset     && !var->green.offset    &&
+            !var->blue.offset    && !var->transp.offset   &&
+            !var->red.length     && !var->green.length    &&
+            !var->blue.length    && !var->transp.length   &&
+            !var->red.msb_right  && !var->green.msb_right &&
+            !var->blue.msb_right && !var->transp.msb_right) {
+                drm_fb_helper_fill_pixel_fmt(var, fb->format->depth);
+        }
+
+        /*
          * drm fbdev emulation doesn't support changing the pixel format at all,
          * so reject all pixel format changing requests.
          */
@@ -1967,59 +2044,7 @@ void drm_fb_helper_fill_var(struct fb_info *info, struct drm_fb_helper *fb_helpe
         info->var.yoffset = 0;
         info->var.activate = FB_ACTIVATE_NOW;
 
-        switch (fb->format->depth) {
-        case 8:
-                info->var.red.offset = 0;
-                info->var.green.offset = 0;
-                info->var.blue.offset = 0;
-                info->var.red.length = 8; /* 8bit DAC */
-                info->var.green.length = 8;
-                info->var.blue.length = 8;
-                info->var.transp.offset = 0;
-                info->var.transp.length = 0;
-                break;
-        case 15:
-                info->var.red.offset = 10;
-                info->var.green.offset = 5;
-                info->var.blue.offset = 0;
-                info->var.red.length = 5;
-                info->var.green.length = 5;
-                info->var.blue.length = 5;
-                info->var.transp.offset = 15;
-                info->var.transp.length = 1;
-                break;
-        case 16:
-                info->var.red.offset = 11;
-                info->var.green.offset = 5;
-                info->var.blue.offset = 0;
-                info->var.red.length = 5;
-                info->var.green.length = 6;
-                info->var.blue.length = 5;
-                info->var.transp.offset = 0;
-                break;
-        case 24:
-                info->var.red.offset = 16;
-                info->var.green.offset = 8;
-                info->var.blue.offset = 0;
-                info->var.red.length = 8;
-                info->var.green.length = 8;
-                info->var.blue.length = 8;
-                info->var.transp.offset = 0;
-                info->var.transp.length = 0;
-                break;
-        case 32:
-                info->var.red.offset = 16;
-                info->var.green.offset = 8;
-                info->var.blue.offset = 0;
-                info->var.red.length = 8;
-                info->var.green.length = 8;
-                info->var.blue.length = 8;
-                info->var.transp.offset = 24;
-                info->var.transp.length = 8;
-                break;
-        default:
-                break;
-        }
+        drm_fb_helper_fill_pixel_fmt(&info->var, fb->format->depth);
 
         info->var.xres = fb_width;
         info->var.yres = fb_height;
diff --git a/drivers/gpu/drm/drm_mode_object.c b/drivers/gpu/drm/drm_mode_object.c
index cd9bc0ce9be0..004191d01772 100644
--- a/drivers/gpu/drm/drm_mode_object.c
+++ b/drivers/gpu/drm/drm_mode_object.c
@@ -459,11 +459,11 @@ static int set_property_atomic(struct drm_mode_object *obj,
         struct drm_modeset_acquire_ctx ctx;
         int ret;
 
-        drm_modeset_acquire_init(&ctx, 0);
-
         state = drm_atomic_state_alloc(dev);
         if (!state)
                 return -ENOMEM;
+
+        drm_modeset_acquire_init(&ctx, 0);
         state->acquire_ctx = &ctx;
 retry:
         if (prop == state->dev->mode_config.dpms_property) {
diff --git a/drivers/gpu/drm/drm_pci.c b/drivers/gpu/drm/drm_pci.c
index a9d9df6c85ad..693748ad8b88 100644
--- a/drivers/gpu/drm/drm_pci.c
+++ b/drivers/gpu/drm/drm_pci.c
@@ -61,8 +61,9 @@ drm_dma_handle_t *drm_pci_alloc(struct drm_device * dev, size_t size, size_t ali
                 return NULL;
 
         dmah->size = size;
-        dmah->vaddr = dma_zalloc_coherent(&dev->pdev->dev, size, &dmah->busaddr,
-                                                GFP_KERNEL | __GFP_COMP);
+        dmah->vaddr = dma_alloc_coherent(&dev->pdev->dev, size,
+                                         &dmah->busaddr,
+                                         GFP_KERNEL | __GFP_COMP);
 
         if (dmah->vaddr == NULL) {
                 kfree(dmah);
diff --git a/drivers/gpu/drm/i915/gvt/handlers.c b/drivers/gpu/drm/i915/gvt/handlers.c
index b5475c91e2ef..e9f343b124b0 100644
--- a/drivers/gpu/drm/i915/gvt/handlers.c
+++ b/drivers/gpu/drm/i915/gvt/handlers.c
@@ -2799,6 +2799,7 @@ static int init_broadwell_mmio_info(struct intel_gvt *gvt)
         MMIO_DFH(_MMIO(0xe2a0), D_BDW_PLUS, F_CMD_ACCESS, NULL, NULL);
         MMIO_DFH(_MMIO(0xe2b0), D_BDW_PLUS, F_CMD_ACCESS, NULL, NULL);
         MMIO_DFH(_MMIO(0xe2c0), D_BDW_PLUS, F_CMD_ACCESS, NULL, NULL);
+        MMIO_DFH(_MMIO(0x21f0), D_BDW_PLUS, F_CMD_ACCESS, NULL, NULL);
         return 0;
 }
 
diff --git a/drivers/gpu/drm/i915/gvt/hypercall.h b/drivers/gpu/drm/i915/gvt/hypercall.h
index 5af11cf1b482..e1675a00df12 100644
--- a/drivers/gpu/drm/i915/gvt/hypercall.h
+++ b/drivers/gpu/drm/i915/gvt/hypercall.h
@@ -41,7 +41,7 @@ struct intel_gvt_mpt {
         int (*host_init)(struct device *dev, void *gvt, const void *ops);
         void (*host_exit)(struct device *dev, void *gvt);
         int (*attach_vgpu)(void *vgpu, unsigned long *handle);
-        void (*detach_vgpu)(unsigned long handle);
+        void (*detach_vgpu)(void *vgpu);
         int (*inject_msi)(unsigned long handle, u32 addr, u16 data);
         unsigned long (*from_virt_to_mfn)(void *p);
         int (*enable_page_track)(unsigned long handle, u64 gfn);
diff --git a/drivers/gpu/drm/i915/gvt/kvmgt.c b/drivers/gpu/drm/i915/gvt/kvmgt.c
index c1072143da1d..dd3dfd00f4e6 100644
--- a/drivers/gpu/drm/i915/gvt/kvmgt.c
+++ b/drivers/gpu/drm/i915/gvt/kvmgt.c
@@ -996,7 +996,7 @@ static int intel_vgpu_mmap(struct mdev_device *mdev, struct vm_area_struct *vma)
 {
         unsigned int index;
         u64 virtaddr;
-        unsigned long req_size, pgoff = 0;
+        unsigned long req_size, pgoff, req_start;
         pgprot_t pg_prot;
         struct intel_vgpu *vgpu = mdev_get_drvdata(mdev);
 
@@ -1014,7 +1014,17 @@ static int intel_vgpu_mmap(struct mdev_device *mdev, struct vm_area_struct *vma)
         pg_prot = vma->vm_page_prot;
         virtaddr = vma->vm_start;
         req_size = vma->vm_end - vma->vm_start;
-        pgoff = vgpu_aperture_pa_base(vgpu) >> PAGE_SHIFT;
+        pgoff = vma->vm_pgoff &
+                ((1U << (VFIO_PCI_OFFSET_SHIFT - PAGE_SHIFT)) - 1);
+        req_start = pgoff << PAGE_SHIFT;
+
+        if (!intel_vgpu_in_aperture(vgpu, req_start))
+                return -EINVAL;
+        if (req_start + req_size >
+            vgpu_aperture_offset(vgpu) + vgpu_aperture_sz(vgpu))
+                return -EINVAL;
+
+        pgoff = (gvt_aperture_pa_base(vgpu->gvt) >> PAGE_SHIFT) + pgoff;
 
         return remap_pfn_range(vma, virtaddr, pgoff, req_size, pg_prot);
 }
@@ -1662,9 +1672,21 @@ static int kvmgt_attach_vgpu(void *vgpu, unsigned long *handle)
         return 0;
 }
 
-static void kvmgt_detach_vgpu(unsigned long handle)
+static void kvmgt_detach_vgpu(void *p_vgpu)
 {
-        /* nothing to do here */
+        int i;
+        struct intel_vgpu *vgpu = (struct intel_vgpu *)p_vgpu;
+
+        if (!vgpu->vdev.region)
+                return;
+
+        for (i = 0; i < vgpu->vdev.num_regions; i++)
+                if (vgpu->vdev.region[i].ops->release)
+                        vgpu->vdev.region[i].ops->release(vgpu,
+                                        &vgpu->vdev.region[i]);
+        vgpu->vdev.num_regions = 0;
+        kfree(vgpu->vdev.region);
+        vgpu->vdev.region = NULL;
 }
 
 static int kvmgt_inject_msi(unsigned long handle, u32 addr, u16 data)
diff --git a/drivers/gpu/drm/i915/gvt/mpt.h b/drivers/gpu/drm/i915/gvt/mpt.h
index 67f19992b226..3ed34123d8d1 100644
--- a/drivers/gpu/drm/i915/gvt/mpt.h
+++ b/drivers/gpu/drm/i915/gvt/mpt.h
@@ -101,7 +101,7 @@ static inline void intel_gvt_hypervisor_detach_vgpu(struct intel_vgpu *vgpu)
         if (!intel_gvt_host.mpt->detach_vgpu)
                 return;
 
-        intel_gvt_host.mpt->detach_vgpu(vgpu->handle);
+        intel_gvt_host.mpt->detach_vgpu(vgpu);
 }
 
 #define MSI_CAP_CONTROL(offset) (offset + 2)
diff --git a/drivers/gpu/drm/i915/gvt/scheduler.c b/drivers/gpu/drm/i915/gvt/scheduler.c
index 1ad8c5e1455d..55bb7885e228 100644
--- a/drivers/gpu/drm/i915/gvt/scheduler.c
+++ b/drivers/gpu/drm/i915/gvt/scheduler.c
@@ -332,6 +332,9 @@ static void release_shadow_wa_ctx(struct intel_shadow_wa_ctx *wa_ctx)
 
         i915_gem_object_unpin_map(wa_ctx->indirect_ctx.obj);
         i915_gem_object_put(wa_ctx->indirect_ctx.obj);
+
+        wa_ctx->indirect_ctx.obj = NULL;
+        wa_ctx->indirect_ctx.shadow_va = NULL;
 }
 
 static int set_context_ppgtt_from_shadow(struct intel_vgpu_workload *workload,
@@ -356,6 +359,33 @@ static int set_context_ppgtt_from_shadow(struct intel_vgpu_workload *workload,
         return 0;
 }
 
+static int
+intel_gvt_workload_req_alloc(struct intel_vgpu_workload *workload)
+{
+        struct intel_vgpu *vgpu = workload->vgpu;
+        struct intel_vgpu_submission *s = &vgpu->submission;
+        struct i915_gem_context *shadow_ctx = s->shadow_ctx;
+        struct drm_i915_private *dev_priv = vgpu->gvt->dev_priv;
+        struct intel_engine_cs *engine = dev_priv->engine[workload->ring_id];
+        struct i915_request *rq;
+        int ret = 0;
+
+        lockdep_assert_held(&dev_priv->drm.struct_mutex);
+
+        if (workload->req)
+                goto out;
+
+        rq = i915_request_alloc(engine, shadow_ctx);
+        if (IS_ERR(rq)) {
+                gvt_vgpu_err("fail to allocate gem request\n");
+                ret = PTR_ERR(rq);
+                goto out;
+        }
+        workload->req = i915_request_get(rq);
+out:
+        return ret;
+}
+
 /**
  * intel_gvt_scan_and_shadow_workload - audit the workload by scanning and
  * shadow it as well, include ringbuffer,wa_ctx and ctx.
@@ -372,12 +402,11 @@ int intel_gvt_scan_and_shadow_workload(struct intel_vgpu_workload *workload)
         struct drm_i915_private *dev_priv = vgpu->gvt->dev_priv;
         struct intel_engine_cs *engine = dev_priv->engine[workload->ring_id];
         struct intel_context *ce;
-        struct i915_request *rq;
         int ret;
 
         lockdep_assert_held(&dev_priv->drm.struct_mutex);
 
-        if (workload->req)
+        if (workload->shadow)
                 return 0;
 
         ret = set_context_ppgtt_from_shadow(workload, shadow_ctx);
@@ -417,22 +446,8 @@ int intel_gvt_scan_and_shadow_workload(struct intel_vgpu_workload *workload)
                         goto err_shadow;
         }
 
-        rq = i915_request_alloc(engine, shadow_ctx);
-        if (IS_ERR(rq)) {
-                gvt_vgpu_err("fail to allocate gem request\n");
-                ret = PTR_ERR(rq);
-                goto err_shadow;
-        }
-        workload->req = i915_request_get(rq);
-
-        ret = populate_shadow_context(workload);
-        if (ret)
-                goto err_req;
-
+        workload->shadow = true;
         return 0;
-err_req:
-        rq = fetch_and_zero(&workload->req);
-        i915_request_put(rq);
 err_shadow:
         release_shadow_wa_ctx(&workload->wa_ctx);
 err_unpin:
@@ -671,23 +686,31 @@ static int dispatch_workload(struct intel_vgpu_workload *workload)
         mutex_lock(&vgpu->vgpu_lock);
         mutex_lock(&dev_priv->drm.struct_mutex);
 
+        ret = intel_gvt_workload_req_alloc(workload);
+        if (ret)
+                goto err_req;
+
         ret = intel_gvt_scan_and_shadow_workload(workload);
         if (ret)
                 goto out;
 
-        ret = prepare_workload(workload);
+        ret = populate_shadow_context(workload);
+        if (ret) {
+                release_shadow_wa_ctx(&workload->wa_ctx);
+                goto out;
+        }
 
+        ret = prepare_workload(workload);
 out:
-        if (ret)
-                workload->status = ret;
-
         if (!IS_ERR_OR_NULL(workload->req)) {
                 gvt_dbg_sched("ring id %d submit workload to i915 %p\n",
                                 ring_id, workload->req);
                 i915_request_add(workload->req);
                 workload->dispatched = true;
         }
-
+err_req:
+        if (ret)
+                workload->status = ret;
         mutex_unlock(&dev_priv->drm.struct_mutex);
         mutex_unlock(&vgpu->vgpu_lock);
         return ret;
@@ -891,11 +914,6 @@ static void complete_current_workload(struct intel_gvt *gvt, int ring_id)
 
         list_del_init(&workload->list);
 
-        if (!workload->status) {
-                release_shadow_batch_buffer(workload);
-                release_shadow_wa_ctx(&workload->wa_ctx);
-        }
-
         if (workload->status || (vgpu->resetting_eng & ENGINE_MASK(ring_id))) {
                 /* if workload->status is not successful means HW GPU
                  * has occurred GPU hang or something wrong with i915/GVT,
@@ -1263,6 +1281,9 @@ void intel_vgpu_destroy_workload(struct intel_vgpu_workload *workload)
 {
         struct intel_vgpu_submission *s = &workload->vgpu->submission;
 
+        release_shadow_batch_buffer(workload);
+        release_shadow_wa_ctx(&workload->wa_ctx);
+
         if (workload->shadow_mm)
                 intel_vgpu_mm_put(workload->shadow_mm);
 
diff --git a/drivers/gpu/drm/i915/gvt/scheduler.h b/drivers/gpu/drm/i915/gvt/scheduler.h
index ca5529d0e48e..2065cba59aab 100644
--- a/drivers/gpu/drm/i915/gvt/scheduler.h
+++ b/drivers/gpu/drm/i915/gvt/scheduler.h
@@ -83,6 +83,7 @@ struct intel_vgpu_workload {
         struct i915_request *req;
         /* if this workload has been dispatched to i915? */
         bool dispatched;
+        bool shadow;      /* if workload has done shadow of guest request */
         int status;
 
         struct intel_vgpu_mm *shadow_mm;
diff --git a/drivers/gpu/drm/i915/i915_debugfs.c b/drivers/gpu/drm/i915/i915_debugfs.c
index 38dcee1ca062..40a61ef9aac1 100644
--- a/drivers/gpu/drm/i915/i915_debugfs.c
+++ b/drivers/gpu/drm/i915/i915_debugfs.c
@@ -984,8 +984,8 @@ static int i915_gpu_info_open(struct inode *inode, struct file *file)
         intel_runtime_pm_get(i915);
         gpu = i915_capture_gpu_state(i915);
         intel_runtime_pm_put(i915);
-        if (!gpu)
-                return -ENOMEM;
+        if (IS_ERR(gpu))
+                return PTR_ERR(gpu);
 
         file->private_data = gpu;
         return 0;
@@ -1018,7 +1018,13 @@ i915_error_state_write(struct file *filp,
 
 static int i915_error_state_open(struct inode *inode, struct file *file)
 {
-        file->private_data = i915_first_error_state(inode->i_private);
+        struct i915_gpu_state *error;
+
+        error = i915_first_error_state(inode->i_private);
+        if (IS_ERR(error))
+                return PTR_ERR(error);
+
+        file->private_data  = error;
         return 0;
 }
 
diff --git a/drivers/gpu/drm/i915/i915_gem_gtt.c b/drivers/gpu/drm/i915/i915_gem_gtt.c
index add1fe7aeb93..bd17dd1f5da5 100644
--- a/drivers/gpu/drm/i915/i915_gem_gtt.c
+++ b/drivers/gpu/drm/i915/i915_gem_gtt.c
@@ -2075,6 +2075,7 @@ static struct i915_vma *pd_vma_create(struct gen6_hw_ppgtt *ppgtt, int size)
 int gen6_ppgtt_pin(struct i915_hw_ppgtt *base)
 {
         struct gen6_hw_ppgtt *ppgtt = to_gen6_ppgtt(base);
+        int err;
 
         /*
          * Workaround the limited maximum vma->pin_count and the aliasing_ppgtt
@@ -2090,9 +2091,17 @@ int gen6_ppgtt_pin(struct i915_hw_ppgtt *base)
          * allocator works in address space sizes, so it's multiplied by page
          * size. We allocate at the top of the GTT to avoid fragmentation.
          */
-        return i915_vma_pin(ppgtt->vma,
-                            0, GEN6_PD_ALIGN,
-                            PIN_GLOBAL | PIN_HIGH);
+        err = i915_vma_pin(ppgtt->vma,
+                           0, GEN6_PD_ALIGN,
+                           PIN_GLOBAL | PIN_HIGH);
+        if (err)
+                goto unpin;
+
+        return 0;
+
+unpin:
+        ppgtt->pin_count = 0;
+        return err;
 }
 
 void gen6_ppgtt_unpin(struct i915_hw_ppgtt *base)
diff --git a/drivers/gpu/drm/i915/i915_gpu_error.c b/drivers/gpu/drm/i915/i915_gpu_error.c
index 07465123c166..3f9ce403c755 100644
--- a/drivers/gpu/drm/i915/i915_gpu_error.c
+++ b/drivers/gpu/drm/i915/i915_gpu_error.c
@@ -1907,9 +1907,16 @@ i915_capture_gpu_state(struct drm_i915_private *i915)
 {
         struct i915_gpu_state *error;
 
+        /* Check if GPU capture has been disabled */
+        error = READ_ONCE(i915->gpu_error.first_error);
+        if (IS_ERR(error))
+                return error;
+
         error = kzalloc(sizeof(*error), GFP_ATOMIC);
-        if (!error)
-                return NULL;
+        if (!error) {
+                i915_disable_error_state(i915, -ENOMEM);
+                return ERR_PTR(-ENOMEM);
+        }
 
         kref_init(&error->ref);
         error->i915 = i915;
@@ -1945,11 +1952,8 @@ void i915_capture_error_state(struct drm_i915_private *i915,
                 return;
 
         error = i915_capture_gpu_state(i915);
-        if (!error) {
-                DRM_DEBUG_DRIVER("out of memory, not capturing error state\n");
-                i915_disable_error_state(i915, -ENOMEM);
+        if (IS_ERR(error))
                 return;
-        }
 
         i915_error_capture_msg(i915, error, engine_mask, error_msg);
         DRM_INFO("%s\n", error->error_msg);
@@ -1987,7 +1991,7 @@ i915_first_error_state(struct drm_i915_private *i915)
 
         spin_lock_irq(&i915->gpu_error.lock);
         error = i915->gpu_error.first_error;
-        if (error)
+        if (!IS_ERR_OR_NULL(error))
                 i915_gpu_state_get(error);
         spin_unlock_irq(&i915->gpu_error.lock);
 
@@ -2000,10 +2004,11 @@ void i915_reset_error_state(struct drm_i915_private *i915)
 
         spin_lock_irq(&i915->gpu_error.lock);
         error = i915->gpu_error.first_error;
-        i915->gpu_error.first_error = NULL;
+        if (error != ERR_PTR(-ENODEV)) /* if disabled, always disabled */
+                i915->gpu_error.first_error = NULL;
         spin_unlock_irq(&i915->gpu_error.lock);
 
-        if (!IS_ERR(error))
+        if (!IS_ERR_OR_NULL(error))
                 i915_gpu_state_put(error);
 }
 
diff --git a/drivers/gpu/drm/i915/i915_sysfs.c b/drivers/gpu/drm/i915/i915_sysfs.c
index 535caebd9813..c0cfe7ae2ba5 100644
--- a/drivers/gpu/drm/i915/i915_sysfs.c
+++ b/drivers/gpu/drm/i915/i915_sysfs.c
@@ -521,7 +521,9 @@ static ssize_t error_state_read(struct file *filp, struct kobject *kobj,
         ssize_t ret;
 
         gpu = i915_first_error_state(i915);
-        if (gpu) {
+        if (IS_ERR(gpu)) {
+                ret = PTR_ERR(gpu);
+        } else if (gpu) {
                 ret = i915_gpu_state_copy_to_buffer(gpu, buf, off, count);
                 i915_gpu_state_put(gpu);
         } else {
diff --git a/drivers/gpu/drm/i915/intel_lrc.c b/drivers/gpu/drm/i915/intel_lrc.c
index 4be167dcd209..eab9341a5152 100644
--- a/drivers/gpu/drm/i915/intel_lrc.c
+++ b/drivers/gpu/drm/i915/intel_lrc.c
@@ -303,6 +303,7 @@ static void __unwind_incomplete_requests(struct intel_engine_cs *engine)
          */
         if (!(prio & I915_PRIORITY_NEWCLIENT)) {
                 prio |= I915_PRIORITY_NEWCLIENT;
+                active->sched.attr.priority = prio;
                 list_move_tail(&active->sched.link,
                                i915_sched_lookup_priolist(engine, prio));
         }
@@ -645,6 +646,9 @@ static void execlists_dequeue(struct intel_engine_cs *engine)
                 int i;
 
                 priolist_for_each_request_consume(rq, rn, p, i) {
+                        GEM_BUG_ON(last &&
+                                   need_preempt(engine, last, rq_prio(rq)));
+
                         /*
                          * Can we combine this request with the current port?
                          * It has to be the same context/ringbuffer and not
@@ -2244,6 +2248,8 @@ static int logical_ring_init(struct intel_engine_cs *engine)
         if (ret)
                 return ret;
 
+        intel_engine_init_workarounds(engine);
+
         if (HAS_LOGICAL_RING_ELSQ(i915)) {
                 execlists->submit_reg = i915->regs +
                         i915_mmio_reg_offset(RING_EXECLIST_SQ_CONTENTS(engine));
@@ -2310,7 +2316,6 @@ int logical_render_ring_init(struct intel_engine_cs *engine)
         }
 
         intel_engine_init_whitelist(engine);
-        intel_engine_init_workarounds(engine);
 
         return 0;
 }
diff --git a/drivers/gpu/drm/i915/intel_psr.c b/drivers/gpu/drm/i915/intel_psr.c
index 419e56342523..f71970df9936 100644
--- a/drivers/gpu/drm/i915/intel_psr.c
+++ b/drivers/gpu/drm/i915/intel_psr.c
@@ -274,10 +274,16 @@ void intel_psr_init_dpcd(struct intel_dp *intel_dp)
         DRM_DEBUG_KMS("eDP panel supports PSR version %x\n",
                       intel_dp->psr_dpcd[0]);
 
+        if (drm_dp_has_quirk(&intel_dp->desc, DP_DPCD_QUIRK_NO_PSR)) {
+                DRM_DEBUG_KMS("PSR support not currently available for this panel\n");
+                return;
+        }
+
         if (!(intel_dp->edp_dpcd[1] & DP_EDP_SET_POWER_CAP)) {
                 DRM_DEBUG_KMS("Panel lacks power state control, PSR cannot be enabled\n");
                 return;
         }
+
         dev_priv->psr.sink_support = true;
         dev_priv->psr.sink_sync_latency =
                 intel_dp_get_sink_sync_latency(intel_dp);
diff --git a/drivers/gpu/drm/meson/meson_crtc.c b/drivers/gpu/drm/meson/meson_crtc.c
index 75d97f1b2e8f..4f5c67f70c4d 100644
--- a/drivers/gpu/drm/meson/meson_crtc.c
+++ b/drivers/gpu/drm/meson/meson_crtc.c
@@ -46,7 +46,6 @@ struct meson_crtc {
         struct drm_crtc base;
         struct drm_pending_vblank_event *event;
         struct meson_drm *priv;
-        bool enabled;
 };
 #define to_meson_crtc(x) container_of(x, struct meson_crtc, base)
 
@@ -82,7 +81,8 @@ static const struct drm_crtc_funcs meson_crtc_funcs = {
 
 };
 
-static void meson_crtc_enable(struct drm_crtc *crtc)
+static void meson_crtc_atomic_enable(struct drm_crtc *crtc,
+                                     struct drm_crtc_state *old_state)
 {
         struct meson_crtc *meson_crtc = to_meson_crtc(crtc);
         struct drm_crtc_state *crtc_state = crtc->state;
@@ -108,20 +108,6 @@ static void meson_crtc_enable(struct drm_crtc *crtc)
 
         drm_crtc_vblank_on(crtc);
 
-        meson_crtc->enabled = true;
-}
-
-static void meson_crtc_atomic_enable(struct drm_crtc *crtc,
-                                     struct drm_crtc_state *old_state)
-{
-        struct meson_crtc *meson_crtc = to_meson_crtc(crtc);
-        struct meson_drm *priv = meson_crtc->priv;
-
-        DRM_DEBUG_DRIVER("\n");
-
-        if (!meson_crtc->enabled)
-                meson_crtc_enable(crtc);
-
         priv->viu.osd1_enabled = true;
 }
 
@@ -153,8 +139,6 @@ static void meson_crtc_atomic_disable(struct drm_crtc *crtc,
 
                 crtc->state->event = NULL;
         }
-
-        meson_crtc->enabled = false;
 }
 
 static void meson_crtc_atomic_begin(struct drm_crtc *crtc,
@@ -163,9 +147,6 @@ static void meson_crtc_atomic_begin(struct drm_crtc *crtc,
         struct meson_crtc *meson_crtc = to_meson_crtc(crtc);
         unsigned long flags;
 
-        if (crtc->state->enable && !meson_crtc->enabled)
-                meson_crtc_enable(crtc);
-
         if (crtc->state->event) {
                 WARN_ON(drm_crtc_vblank_get(crtc) != 0);
 
diff --git a/drivers/gpu/drm/meson/meson_drv.c b/drivers/gpu/drm/meson/meson_drv.c
index 3ee4d4a4ecba..12ff47b13668 100644
--- a/drivers/gpu/drm/meson/meson_drv.c
+++ b/drivers/gpu/drm/meson/meson_drv.c
@@ -75,6 +75,10 @@ static const struct drm_mode_config_funcs meson_mode_config_funcs = {
         .fb_create           = drm_gem_fb_create,
 };
 
+static const struct drm_mode_config_helper_funcs meson_mode_config_helpers = {
+        .atomic_commit_tail = drm_atomic_helper_commit_tail_rpm,
+};
+
 static irqreturn_t meson_irq(int irq, void *arg)
 {
         struct drm_device *dev = arg;
@@ -266,6 +270,7 @@ static int meson_drv_bind_master(struct device *dev, bool has_components)
         drm->mode_config.max_width = 3840;
         drm->mode_config.max_height = 2160;
         drm->mode_config.funcs = &meson_mode_config_funcs;
+        drm->mode_config.helper_private = &meson_mode_config_helpers;
 
         /* Hardware Initialization */
 
@@ -388,8 +393,10 @@ static int meson_probe_remote(struct platform_device *pdev,
                 remote_node = of_graph_get_remote_port_parent(ep);
                 if (!remote_node ||
                     remote_node == parent || /* Ignore parent endpoint */
-                    !of_device_is_available(remote_node))
+                    !of_device_is_available(remote_node)) {
+                        of_node_put(remote_node);
                         continue;
+                }
 
                 count += meson_probe_remote(pdev, match, remote, remote_node);
 
@@ -408,10 +415,13 @@ static int meson_drv_probe(struct platform_device *pdev)
 
         for_each_endpoint_of_node(np, ep) {
                 remote = of_graph_get_remote_port_parent(ep);
-                if (!remote || !of_device_is_available(remote))
+                if (!remote || !of_device_is_available(remote)) {
+                        of_node_put(remote);
                         continue;
+                }
 
                 count += meson_probe_remote(pdev, &match, np, remote);
+                of_node_put(remote);
         }
 
         if (count && !match)
diff --git a/drivers/gpu/drm/msm/adreno/a6xx_gmu.c b/drivers/gpu/drm/msm/adreno/a6xx_gmu.c
index 5beb83d1cf87..ce1b3cc4bf6d 100644
--- a/drivers/gpu/drm/msm/adreno/a6xx_gmu.c
+++ b/drivers/gpu/drm/msm/adreno/a6xx_gmu.c
@@ -944,7 +944,7 @@ static u32 a6xx_gmu_get_arc_level(struct device *dev, unsigned long freq)
         np = dev_pm_opp_get_of_node(opp);
 
         if (np) {
-                of_property_read_u32(np, "qcom,level", &val);
+                of_property_read_u32(np, "opp-level", &val);
                 of_node_put(np);
         }
 
diff --git a/drivers/gpu/drm/msm/adreno/adreno_gpu.c b/drivers/gpu/drm/msm/adreno/adreno_gpu.c
index 2e4372ef17a3..2cfee1a4fe0b 100644
--- a/drivers/gpu/drm/msm/adreno/adreno_gpu.c
+++ b/drivers/gpu/drm/msm/adreno/adreno_gpu.c
@@ -765,7 +765,6 @@ int adreno_gpu_init(struct drm_device *drm, struct platform_device *pdev,
         adreno_gpu->rev = config->rev;
 
         adreno_gpu_config.ioname = "kgsl_3d0_reg_memory";
-        adreno_gpu_config.irqname = "kgsl_3d0_irq";
 
         adreno_gpu_config.va_start = SZ_16M;
         adreno_gpu_config.va_end = 0xffffffff;
diff --git a/drivers/gpu/drm/msm/disp/dpu1/dpu_plane.c b/drivers/gpu/drm/msm/disp/dpu1/dpu_plane.c
index fd75870eb17f..6aefcd6db46b 100644
--- a/drivers/gpu/drm/msm/disp/dpu1/dpu_plane.c
+++ b/drivers/gpu/drm/msm/disp/dpu1/dpu_plane.c
@@ -365,19 +365,6 @@ static void _dpu_plane_set_qos_ctrl(struct drm_plane *plane,
                         &pdpu->pipe_qos_cfg);
 }
 
-static void dpu_plane_danger_signal_ctrl(struct drm_plane *plane, bool enable)
-{
-        struct dpu_plane *pdpu = to_dpu_plane(plane);
-        struct dpu_kms *dpu_kms = _dpu_plane_get_kms(plane);
-
-        if (!pdpu->is_rt_pipe)
-                return;
-
-        pm_runtime_get_sync(&dpu_kms->pdev->dev);
-        _dpu_plane_set_qos_ctrl(plane, enable, DPU_PLANE_QOS_PANIC_CTRL);
-        pm_runtime_put_sync(&dpu_kms->pdev->dev);
-}
-
 /**
  * _dpu_plane_set_ot_limit - set OT limit for the given plane
  * @plane:              Pointer to drm plane
@@ -1248,6 +1235,19 @@ static void dpu_plane_reset(struct drm_plane *plane)
 }
 
 #ifdef CONFIG_DEBUG_FS
+static void dpu_plane_danger_signal_ctrl(struct drm_plane *plane, bool enable)
+{
+        struct dpu_plane *pdpu = to_dpu_plane(plane);
+        struct dpu_kms *dpu_kms = _dpu_plane_get_kms(plane);
+
+        if (!pdpu->is_rt_pipe)
+                return;
+
+        pm_runtime_get_sync(&dpu_kms->pdev->dev);
+        _dpu_plane_set_qos_ctrl(plane, enable, DPU_PLANE_QOS_PANIC_CTRL);
+        pm_runtime_put_sync(&dpu_kms->pdev->dev);
+}
+
 static ssize_t _dpu_plane_danger_read(struct file *file,
                         char __user *buff, size_t count, loff_t *ppos)
 {
diff --git a/drivers/gpu/drm/msm/msm_drv.h b/drivers/gpu/drm/msm/msm_drv.h
index 9cd6a96c6bf2..927e5d86f7c1 100644
--- a/drivers/gpu/drm/msm/msm_drv.h
+++ b/drivers/gpu/drm/msm/msm_drv.h
@@ -250,7 +250,8 @@ void msm_gem_purge_vma(struct msm_gem_address_space *aspace,
 void msm_gem_unmap_vma(struct msm_gem_address_space *aspace,
                 struct msm_gem_vma *vma);
 int msm_gem_map_vma(struct msm_gem_address_space *aspace,
-                struct msm_gem_vma *vma, struct sg_table *sgt, int npages);
+                struct msm_gem_vma *vma, int prot,
+                struct sg_table *sgt, int npages);
 void msm_gem_close_vma(struct msm_gem_address_space *aspace,
                 struct msm_gem_vma *vma);
 
@@ -333,6 +334,7 @@ void msm_gem_kernel_put(struct drm_gem_object *bo,
 struct drm_gem_object *msm_gem_import(struct drm_device *dev,
                 struct dma_buf *dmabuf, struct sg_table *sgt);
 
+__printf(2, 3)
 void msm_gem_object_set_name(struct drm_gem_object *bo, const char *fmt, ...);
 
 int msm_framebuffer_prepare(struct drm_framebuffer *fb,
@@ -396,12 +398,14 @@ void msm_framebuffer_describe(struct drm_framebuffer *fb, struct seq_file *m);
 int msm_debugfs_late_init(struct drm_device *dev);
 int msm_rd_debugfs_init(struct drm_minor *minor);
 void msm_rd_debugfs_cleanup(struct msm_drm_private *priv);
+__printf(3, 4)
 void msm_rd_dump_submit(struct msm_rd_state *rd, struct msm_gem_submit *submit,
                 const char *fmt, ...);
 int msm_perf_debugfs_init(struct drm_minor *minor);
 void msm_perf_debugfs_cleanup(struct msm_drm_private *priv);
 #else
 static inline int msm_debugfs_late_init(struct drm_device *dev) { return 0; }
+__printf(3, 4)
 static inline void msm_rd_dump_submit(struct msm_rd_state *rd, struct msm_gem_submit *submit,
                 const char *fmt, ...) {}
 static inline void msm_rd_debugfs_cleanup(struct msm_drm_private *priv) {}
diff --git a/drivers/gpu/drm/msm/msm_gem.c b/drivers/gpu/drm/msm/msm_gem.c
index 51a95da694d8..c8886d3071fa 100644
--- a/drivers/gpu/drm/msm/msm_gem.c
+++ b/drivers/gpu/drm/msm/msm_gem.c
@@ -391,6 +391,10 @@ static int msm_gem_pin_iova(struct drm_gem_object *obj,
         struct msm_gem_object *msm_obj = to_msm_bo(obj);
         struct msm_gem_vma *vma;
         struct page **pages;
+        int prot = IOMMU_READ;
+
+        if (!(msm_obj->flags & MSM_BO_GPU_READONLY))
+                prot |= IOMMU_WRITE;
 
         WARN_ON(!mutex_is_locked(&msm_obj->lock));
 
@@ -405,8 +409,8 @@ static int msm_gem_pin_iova(struct drm_gem_object *obj,
         if (IS_ERR(pages))
                 return PTR_ERR(pages);
 
-        return msm_gem_map_vma(aspace, vma, msm_obj->sgt,
-                        obj->size >> PAGE_SHIFT);
+        return msm_gem_map_vma(aspace, vma, prot,
+                        msm_obj->sgt, obj->size >> PAGE_SHIFT);
 }
 
 /* get iova and pin it. Should have a matching put */
diff --git a/drivers/gpu/drm/msm/msm_gem_vma.c b/drivers/gpu/drm/msm/msm_gem_vma.c
index 557360788084..49c04829cf34 100644
--- a/drivers/gpu/drm/msm/msm_gem_vma.c
+++ b/drivers/gpu/drm/msm/msm_gem_vma.c
@@ -68,7 +68,8 @@ void msm_gem_unmap_vma(struct msm_gem_address_space *aspace,
 
 int
 msm_gem_map_vma(struct msm_gem_address_space *aspace,
-                struct msm_gem_vma *vma, struct sg_table *sgt, int npages)
+                struct msm_gem_vma *vma, int prot,
+                struct sg_table *sgt, int npages)
 {
         unsigned size = npages << PAGE_SHIFT;
         int ret = 0;
@@ -86,7 +87,7 @@ msm_gem_map_vma(struct msm_gem_address_space *aspace,
 
         if (aspace->mmu)
                 ret = aspace->mmu->funcs->map(aspace->mmu, vma->iova, sgt,
-                                size, IOMMU_READ | IOMMU_WRITE);
+                                size, prot);
 
         if (ret)
                 vma->mapped = false;
diff --git a/drivers/gpu/drm/msm/msm_gpu.c b/drivers/gpu/drm/msm/msm_gpu.c
index 5f3eff304355..10babd18e286 100644
--- a/drivers/gpu/drm/msm/msm_gpu.c
+++ b/drivers/gpu/drm/msm/msm_gpu.c
@@ -900,7 +900,7 @@ int msm_gpu_init(struct drm_device *drm, struct platform_device *pdev,
         }
 
         /* Get Interrupt: */
-        gpu->irq = platform_get_irq_byname(pdev, config->irqname);
+        gpu->irq = platform_get_irq(pdev, 0);
         if (gpu->irq < 0) {
                 ret = gpu->irq;
                 DRM_DEV_ERROR(drm->dev, "failed to get irq: %d\n", ret);
diff --git a/drivers/gpu/drm/msm/msm_gpu.h b/drivers/gpu/drm/msm/msm_gpu.h
index efb49bb64191..ca17086f72c9 100644
--- a/drivers/gpu/drm/msm/msm_gpu.h
+++ b/drivers/gpu/drm/msm/msm_gpu.h
@@ -31,7 +31,6 @@ struct msm_gpu_state;
 
 struct msm_gpu_config {
         const char *ioname;
-        const char *irqname;
         uint64_t va_start;
         uint64_t va_end;
         unsigned int nr_rings;
@@ -63,7 +62,7 @@ struct msm_gpu_funcs {
         struct msm_ringbuffer *(*active_ring)(struct msm_gpu *gpu);
         void (*recover)(struct msm_gpu *gpu);
         void (*destroy)(struct msm_gpu *gpu);
-#ifdef CONFIG_DEBUG_FS
+#if defined(CONFIG_DEBUG_FS) || defined(CONFIG_DEV_COREDUMP)
         /* show GPU status in debugfs: */
         void (*show)(struct msm_gpu *gpu, struct msm_gpu_state *state,
                         struct drm_printer *p);
diff --git a/drivers/gpu/drm/msm/msm_rd.c b/drivers/gpu/drm/msm/msm_rd.c
index 90e9d0a48dc0..d21172933d92 100644
--- a/drivers/gpu/drm/msm/msm_rd.c
+++ b/drivers/gpu/drm/msm/msm_rd.c
@@ -115,7 +115,9 @@ static void rd_write(struct msm_rd_state *rd, const void *buf, int sz)
                 char *fptr = &fifo->buf[fifo->head];
                 int n;
 
-                wait_event(rd->fifo_event, circ_space(&rd->fifo) > 0);
+                wait_event(rd->fifo_event, circ_space(&rd->fifo) > 0 || !rd->open);
+                if (!rd->open)
+                        return;
 
                 /* Note that smp_load_acquire() is not strictly required
                  * as CIRC_SPACE_TO_END() does not access the tail more
@@ -213,7 +215,10 @@ out:
 static int rd_release(struct inode *inode, struct file *file)
 {
         struct msm_rd_state *rd = inode->i_private;
+
         rd->open = false;
+        wake_up_all(&rd->fifo_event);
+
         return 0;
 }
 
diff --git a/drivers/gpu/drm/nouveau/nouveau_backlight.c b/drivers/gpu/drm/nouveau/nouveau_backlight.c
index 5f5be6368aed..c7a94c94dbf3 100644
--- a/drivers/gpu/drm/nouveau/nouveau_backlight.c
+++ b/drivers/gpu/drm/nouveau/nouveau_backlight.c
@@ -253,6 +253,9 @@ nouveau_backlight_init(struct drm_connector *connector)
         case NV_DEVICE_INFO_V0_FERMI:
         case NV_DEVICE_INFO_V0_KEPLER:
         case NV_DEVICE_INFO_V0_MAXWELL:
+        case NV_DEVICE_INFO_V0_PASCAL:
+        case NV_DEVICE_INFO_V0_VOLTA:
+        case NV_DEVICE_INFO_V0_TURING:
                 ret = nv50_backlight_init(nv_encoder, &props, &ops);
                 break;
         default:
diff --git a/drivers/gpu/drm/nouveau/nvkm/engine/device/base.c b/drivers/gpu/drm/nouveau/nvkm/engine/device/base.c
index bfbc9341e0c2..d9edb5785813 100644
--- a/drivers/gpu/drm/nouveau/nvkm/engine/device/base.c
+++ b/drivers/gpu/drm/nouveau/nvkm/engine/device/base.c
@@ -2435,6 +2435,38 @@ nv140_chipset = {
 };
 
 static const struct nvkm_device_chip
+nv162_chipset = {
+        .name = "TU102",
+        .bar = tu104_bar_new,
+        .bios = nvkm_bios_new,
+        .bus = gf100_bus_new,
+        .devinit = tu104_devinit_new,
+        .fault = tu104_fault_new,
+        .fb = gv100_fb_new,
+        .fuse = gm107_fuse_new,
+        .gpio = gk104_gpio_new,
+        .i2c = gm200_i2c_new,
+        .ibus = gm200_ibus_new,
+        .imem = nv50_instmem_new,
+        .ltc = gp102_ltc_new,
+        .mc = tu104_mc_new,
+        .mmu = tu104_mmu_new,
+        .pci = gp100_pci_new,
+        .pmu = gp102_pmu_new,
+        .therm = gp100_therm_new,
+        .timer = gk20a_timer_new,
+        .top = gk104_top_new,
+        .ce[0] = tu104_ce_new,
+        .ce[1] = tu104_ce_new,
+        .ce[2] = tu104_ce_new,
+        .ce[3] = tu104_ce_new,
+        .ce[4] = tu104_ce_new,
+        .disp = tu104_disp_new,
+        .dma = gv100_dma_new,
+        .fifo = tu104_fifo_new,
+};
+
+static const struct nvkm_device_chip
 nv164_chipset = {
         .name = "TU104",
         .bar = tu104_bar_new,
@@ -2950,6 +2982,7 @@ nvkm_device_ctor(const struct nvkm_device_func *func,
                 case 0x138: device->chip = &nv138_chipset; break;
                 case 0x13b: device->chip = &nv13b_chipset; break;
                 case 0x140: device->chip = &nv140_chipset; break;
+                case 0x162: device->chip = &nv162_chipset; break;
                 case 0x164: device->chip = &nv164_chipset; break;
                 case 0x166: device->chip = &nv166_chipset; break;
                 default:
diff --git a/drivers/gpu/drm/nouveau/nvkm/engine/falcon.c b/drivers/gpu/drm/nouveau/nvkm/engine/falcon.c
index 816ccaedfc73..8675613e142b 100644
--- a/drivers/gpu/drm/nouveau/nvkm/engine/falcon.c
+++ b/drivers/gpu/drm/nouveau/nvkm/engine/falcon.c
@@ -22,6 +22,7 @@
 #include <engine/falcon.h>
 
 #include <core/gpuobj.h>
+#include <subdev/mc.h>
 #include <subdev/timer.h>
 #include <engine/fifo.h>
 
@@ -107,8 +108,10 @@ nvkm_falcon_fini(struct nvkm_engine *engine, bool suspend)
                 }
         }
 
-        nvkm_mask(device, base + 0x048, 0x00000003, 0x00000000);
-        nvkm_wr32(device, base + 0x014, 0xffffffff);
+        if (nvkm_mc_enabled(device, engine->subdev.index)) {
+                nvkm_mask(device, base + 0x048, 0x00000003, 0x00000000);
+                nvkm_wr32(device, base + 0x014, 0xffffffff);
+        }
         return 0;
 }
 
diff --git a/drivers/gpu/drm/nouveau/nvkm/subdev/therm/base.c b/drivers/gpu/drm/nouveau/nvkm/subdev/therm/base.c
index 3695cde669f8..07914e36939e 100644
--- a/drivers/gpu/drm/nouveau/nvkm/subdev/therm/base.c
+++ b/drivers/gpu/drm/nouveau/nvkm/subdev/therm/base.c
@@ -132,11 +132,12 @@ nvkm_therm_update(struct nvkm_therm *therm, int mode)
                         duty = nvkm_therm_update_linear(therm);
                         break;
                 case NVBIOS_THERM_FAN_OTHER:
-                        if (therm->cstate)
+                        if (therm->cstate) {
                                 duty = therm->cstate;
-                        else
+                                poll = false;
+                        } else {
                                 duty = nvkm_therm_update_linear_fallback(therm);
-                        poll = false;
+                        }
                         break;
                 }
                 immd = false;
diff --git a/drivers/gpu/drm/qxl/qxl_drv.c b/drivers/gpu/drm/qxl/qxl_drv.c
index 13c8a662f9b4..ccb090f3ab30 100644
--- a/drivers/gpu/drm/qxl/qxl_drv.c
+++ b/drivers/gpu/drm/qxl/qxl_drv.c
@@ -250,14 +250,10 @@ static struct drm_driver qxl_driver = {
 #if defined(CONFIG_DEBUG_FS)
         .debugfs_init = qxl_debugfs_init,
 #endif
-        .prime_handle_to_fd = drm_gem_prime_handle_to_fd,
-        .prime_fd_to_handle = drm_gem_prime_fd_to_handle,
         .gem_prime_export = drm_gem_prime_export,
         .gem_prime_import = drm_gem_prime_import,
         .gem_prime_pin = qxl_gem_prime_pin,
         .gem_prime_unpin = qxl_gem_prime_unpin,
-        .gem_prime_get_sg_table = qxl_gem_prime_get_sg_table,
-        .gem_prime_import_sg_table = qxl_gem_prime_import_sg_table,
         .gem_prime_vmap = qxl_gem_prime_vmap,
         .gem_prime_vunmap = qxl_gem_prime_vunmap,
         .gem_prime_mmap = qxl_gem_prime_mmap,
diff --git a/drivers/gpu/drm/qxl/qxl_prime.c b/drivers/gpu/drm/qxl/qxl_prime.c
index a55dece118b2..df65d3c1a7b8 100644
--- a/drivers/gpu/drm/qxl/qxl_prime.c
+++ b/drivers/gpu/drm/qxl/qxl_prime.c
@@ -38,20 +38,6 @@ void qxl_gem_prime_unpin(struct drm_gem_object *obj)
         WARN_ONCE(1, "not implemented");
 }
 
-struct sg_table *qxl_gem_prime_get_sg_table(struct drm_gem_object *obj)
-{
-        WARN_ONCE(1, "not implemented");
-        return ERR_PTR(-ENOSYS);
-}
-
-struct drm_gem_object *qxl_gem_prime_import_sg_table(
-        struct drm_device *dev, struct dma_buf_attachment *attach,
-        struct sg_table *table)
-{
-        WARN_ONCE(1, "not implemented");
-        return ERR_PTR(-ENOSYS);
-}
-
 void *qxl_gem_prime_vmap(struct drm_gem_object *obj)
 {
         WARN_ONCE(1, "not implemented");
diff --git a/drivers/gpu/drm/rockchip/rockchip_rgb.c b/drivers/gpu/drm/rockchip/rockchip_rgb.c
index 96ac1458a59c..37f93022a106 100644
--- a/drivers/gpu/drm/rockchip/rockchip_rgb.c
+++ b/drivers/gpu/drm/rockchip/rockchip_rgb.c
@@ -113,8 +113,10 @@ struct rockchip_rgb *rockchip_rgb_init(struct device *dev,
                 child_count++;
                 ret = drm_of_find_panel_or_bridge(dev->of_node, 0, endpoint_id,
                                                   &panel, &bridge);
-                if (!ret)
+                if (!ret) {
+                        of_node_put(endpoint);
                         break;
+                }
         }
 
         of_node_put(port);
diff --git a/drivers/gpu/drm/sun4i/sun4i_backend.c b/drivers/gpu/drm/sun4i/sun4i_backend.c
index 9e9255ee59cd..a021bab11a4f 100644
--- a/drivers/gpu/drm/sun4i/sun4i_backend.c
+++ b/drivers/gpu/drm/sun4i/sun4i_backend.c
@@ -786,17 +786,18 @@ static struct sun4i_frontend *sun4i_backend_find_frontend(struct sun4i_drv *drv,
                 remote = of_graph_get_remote_port_parent(ep);
                 if (!remote)
                         continue;
+                of_node_put(remote);
 
                 /* does this node match any registered engines? */
                 list_for_each_entry(frontend, &drv->frontend_list, list) {
                         if (remote == frontend->node) {
-                                of_node_put(remote);
                                 of_node_put(port);
+                                of_node_put(ep);
                                 return frontend;
                         }
                 }
         }
-
+        of_node_put(port);
         return ERR_PTR(-EINVAL);
 }
 
diff --git a/drivers/gpu/drm/sun4i/sun4i_hdmi_enc.c b/drivers/gpu/drm/sun4i/sun4i_hdmi_enc.c
index 061d2e0d9011..416da5376701 100644
--- a/drivers/gpu/drm/sun4i/sun4i_hdmi_enc.c
+++ b/drivers/gpu/drm/sun4i/sun4i_hdmi_enc.c
@@ -92,6 +92,8 @@ static void sun4i_hdmi_disable(struct drm_encoder *encoder)
         val = readl(hdmi->base + SUN4I_HDMI_VID_CTRL_REG);
         val &= ~SUN4I_HDMI_VID_CTRL_ENABLE;
         writel(val, hdmi->base + SUN4I_HDMI_VID_CTRL_REG);
+
+        clk_disable_unprepare(hdmi->tmds_clk);
 }
 
 static void sun4i_hdmi_enable(struct drm_encoder *encoder)
@@ -102,6 +104,8 @@ static void sun4i_hdmi_enable(struct drm_encoder *encoder)
 
         DRM_DEBUG_DRIVER("Enabling the HDMI Output\n");
 
+        clk_prepare_enable(hdmi->tmds_clk);
+
         sun4i_hdmi_setup_avi_infoframes(hdmi, mode);
         val |= SUN4I_HDMI_PKT_CTRL_TYPE(0, SUN4I_HDMI_PKT_AVI);
         val |= SUN4I_HDMI_PKT_CTRL_TYPE(1, SUN4I_HDMI_PKT_END);
diff --git a/drivers/gpu/drm/virtio/virtgpu_drv.c b/drivers/gpu/drm/virtio/virtgpu_drv.c
index f7f32a885af7..2d1aaca49105 100644
--- a/drivers/gpu/drm/virtio/virtgpu_drv.c
+++ b/drivers/gpu/drm/virtio/virtgpu_drv.c
@@ -127,14 +127,10 @@ static struct drm_driver driver = {
 #if defined(CONFIG_DEBUG_FS)
         .debugfs_init = virtio_gpu_debugfs_init,
 #endif
-        .prime_handle_to_fd = drm_gem_prime_handle_to_fd,
-        .prime_fd_to_handle = drm_gem_prime_fd_to_handle,
         .gem_prime_export = drm_gem_prime_export,
         .gem_prime_import = drm_gem_prime_import,
         .gem_prime_pin = virtgpu_gem_prime_pin,
         .gem_prime_unpin = virtgpu_gem_prime_unpin,
-        .gem_prime_get_sg_table = virtgpu_gem_prime_get_sg_table,
-        .gem_prime_import_sg_table = virtgpu_gem_prime_import_sg_table,
         .gem_prime_vmap = virtgpu_gem_prime_vmap,
         .gem_prime_vunmap = virtgpu_gem_prime_vunmap,
         .gem_prime_mmap = virtgpu_gem_prime_mmap,
diff --git a/drivers/gpu/drm/virtio/virtgpu_drv.h b/drivers/gpu/drm/virtio/virtgpu_drv.h
index 1deb41d42ea4..0c15000f926e 100644
--- a/drivers/gpu/drm/virtio/virtgpu_drv.h
+++ b/drivers/gpu/drm/virtio/virtgpu_drv.h
@@ -372,10 +372,6 @@ int virtio_gpu_object_wait(struct virtio_gpu_object *bo, bool no_wait);
 /* virtgpu_prime.c */
 int virtgpu_gem_prime_pin(struct drm_gem_object *obj);
 void virtgpu_gem_prime_unpin(struct drm_gem_object *obj);
-struct sg_table *virtgpu_gem_prime_get_sg_table(struct drm_gem_object *obj);
-struct drm_gem_object *virtgpu_gem_prime_import_sg_table(
-        struct drm_device *dev, struct dma_buf_attachment *attach,
-        struct sg_table *sgt);
 void *virtgpu_gem_prime_vmap(struct drm_gem_object *obj);
 void virtgpu_gem_prime_vunmap(struct drm_gem_object *obj, void *vaddr);
 int virtgpu_gem_prime_mmap(struct drm_gem_object *obj,
diff --git a/drivers/gpu/drm/virtio/virtgpu_prime.c b/drivers/gpu/drm/virtio/virtgpu_prime.c
index 86ce0ae93f59..c59ec34c80a5 100644
--- a/drivers/gpu/drm/virtio/virtgpu_prime.c
+++ b/drivers/gpu/drm/virtio/virtgpu_prime.c
@@ -39,20 +39,6 @@ void virtgpu_gem_prime_unpin(struct drm_gem_object *obj)
         WARN_ONCE(1, "not implemented");
 }
 
-struct sg_table *virtgpu_gem_prime_get_sg_table(struct drm_gem_object *obj)
-{
-        WARN_ONCE(1, "not implemented");
-        return ERR_PTR(-ENODEV);
-}
-
-struct drm_gem_object *virtgpu_gem_prime_import_sg_table(
-        struct drm_device *dev, struct dma_buf_attachment *attach,
-        struct sg_table *table)
-{
-        WARN_ONCE(1, "not implemented");
-        return ERR_PTR(-ENODEV);
-}
-
 void *virtgpu_gem_prime_vmap(struct drm_gem_object *obj)
 {
         struct virtio_gpu_object *bo = gem_to_virtio_gpu_obj(obj);
diff --git a/drivers/gpu/vga/Kconfig b/drivers/gpu/vga/Kconfig
index b677e5d524e6..d5f1d8e1c6f8 100644
--- a/drivers/gpu/vga/Kconfig
+++ b/drivers/gpu/vga/Kconfig
@@ -21,6 +21,7 @@ config VGA_SWITCHEROO
         bool "Laptop Hybrid Graphics - GPU switching support"
         depends on X86
         depends on ACPI
+        depends on PCI
         select VGA_ARB
         help
           Many laptops released in 2008/9/10 have two GPUs with a multiplexer
diff --git a/drivers/hid/hid-core.c b/drivers/hid/hid-core.c
index f41d5fe51abe..9993b692598f 100644
--- a/drivers/hid/hid-core.c
+++ b/drivers/hid/hid-core.c
@@ -125,6 +125,7 @@ static int open_collection(struct hid_parser *parser, unsigned type)
 {
         struct hid_collection *collection;
         unsigned usage;
+        int collection_index;
 
         usage = parser->local.usage[0];
 
@@ -167,13 +168,13 @@ static int open_collection(struct hid_parser *parser, unsigned type)
         parser->collection_stack[parser->collection_stack_ptr++] =
                 parser->device->maxcollection;
 
-        collection = parser->device->collection +
-                parser->device->maxcollection++;
+        collection_index = parser->device->maxcollection++;
+        collection = parser->device->collection + collection_index;
         collection->type = type;
         collection->usage = usage;
         collection->level = parser->collection_stack_ptr - 1;
-        collection->parent = parser->active_collection;
-        parser->active_collection = collection;
+        collection->parent_idx = (collection->level == 0) ? -1 :
+                parser->collection_stack[collection->level - 1];
 
         if (type == HID_COLLECTION_APPLICATION)
                 parser->device->maxapplication++;
@@ -192,8 +193,6 @@ static int close_collection(struct hid_parser *parser)
                 return -EINVAL;
         }
         parser->collection_stack_ptr--;
-        if (parser->active_collection)
-                parser->active_collection = parser->active_collection->parent;
         return 0;
 }
 
@@ -1006,10 +1005,12 @@ static void hid_apply_multiplier_to_field(struct hid_device *hid,
                 usage = &field->usage[i];
 
                 collection = &hid->collection[usage->collection_index];
-                while (collection && collection != multiplier_collection)
-                        collection = collection->parent;
+                while (collection->parent_idx != -1 &&
+                       collection != multiplier_collection)
+                        collection = &hid->collection[collection->parent_idx];
 
-                if (collection || multiplier_collection == NULL)
+                if (collection->parent_idx != -1 ||
+                    multiplier_collection == NULL)
                         usage->resolution_multiplier = effective_multiplier;
 
         }
@@ -1044,9 +1045,9 @@ static void hid_apply_multiplier(struct hid_device *hid,
          * applicable fields later.
          */
         multiplier_collection = &hid->collection[multiplier->usage->collection_index];
-        while (multiplier_collection &&
+        while (multiplier_collection->parent_idx != -1 &&
                multiplier_collection->type != HID_COLLECTION_LOGICAL)
-                multiplier_collection = multiplier_collection->parent;
+                multiplier_collection = &hid->collection[multiplier_collection->parent_idx];
 
         effective_multiplier = hid_calculate_multiplier(hid, multiplier);
 
diff --git a/drivers/hid/hid-ids.h b/drivers/hid/hid-ids.h
index 518fa76414f5..24f846d67478 100644
--- a/drivers/hid/hid-ids.h
+++ b/drivers/hid/hid-ids.h
@@ -461,6 +461,9 @@
 #define USB_DEVICE_ID_GENERAL_TOUCH_WIN8_PIT_010A 0x010a
 #define USB_DEVICE_ID_GENERAL_TOUCH_WIN8_PIT_E100 0xe100
 
+#define I2C_VENDOR_ID_GOODIX            0x27c6
+#define I2C_DEVICE_ID_GOODIX_01F0       0x01f0
+
 #define USB_VENDOR_ID_GOODTOUCH         0x1aad
 #define USB_DEVICE_ID_GOODTOUCH_000f    0x000f
 
diff --git a/drivers/hid/i2c-hid/i2c-hid-core.c b/drivers/hid/i2c-hid/i2c-hid-core.c
index 8555ce7e737b..c5edfa966343 100644
--- a/drivers/hid/i2c-hid/i2c-hid-core.c
+++ b/drivers/hid/i2c-hid/i2c-hid-core.c
@@ -179,6 +179,8 @@ static const struct i2c_hid_quirks {
                 I2C_HID_QUIRK_DELAY_AFTER_SLEEP },
         { USB_VENDOR_ID_LG, I2C_DEVICE_ID_LG_8001,
                 I2C_HID_QUIRK_NO_RUNTIME_PM },
+        { I2C_VENDOR_ID_GOODIX, I2C_DEVICE_ID_GOODIX_01F0,
+                I2C_HID_QUIRK_NO_RUNTIME_PM },
         { 0, 0 }
 };
 
diff --git a/drivers/hv/channel.c b/drivers/hv/channel.c
index ce0ba2062723..bea4c9850247 100644
--- a/drivers/hv/channel.c
+++ b/drivers/hv/channel.c
@@ -701,19 +701,12 @@ static int vmbus_close_internal(struct vmbus_channel *channel)
 int vmbus_disconnect_ring(struct vmbus_channel *channel)
 {
         struct vmbus_channel *cur_channel, *tmp;
-        unsigned long flags;
-        LIST_HEAD(list);
         int ret;
 
         if (channel->primary_channel != NULL)
                 return -EINVAL;
 
-        /* Snapshot the list of subchannels */
-        spin_lock_irqsave(&channel->lock, flags);
-        list_splice_init(&channel->sc_list, &list);
-        spin_unlock_irqrestore(&channel->lock, flags);
-
-        list_for_each_entry_safe(cur_channel, tmp, &list, sc_list) {
+        list_for_each_entry_safe(cur_channel, tmp, &channel->sc_list, sc_list) {
                 if (cur_channel->rescind)
                         wait_for_completion(&cur_channel->rescind_event);
 
diff --git a/drivers/hv/hv_balloon.c b/drivers/hv/hv_balloon.c
index 5301fef16c31..7c6349a50ef1 100644
--- a/drivers/hv/hv_balloon.c
+++ b/drivers/hv/hv_balloon.c
@@ -888,12 +888,14 @@ static unsigned long handle_pg_range(unsigned long pg_start,
                         pfn_cnt -= pgs_ol;
                         /*
                          * Check if the corresponding memory block is already
-                         * online by checking its last previously backed page.
-                         * In case it is we need to bring rest (which was not
-                         * backed previously) online too.
+                         * online. It is possible to observe struct pages still
+                         * being uninitialized here so check section instead.
+                         * In case the section is online we need to bring the
+                         * rest of pfns (which were not backed previously)
+                         * online too.
                          */
                         if (start_pfn > has->start_pfn &&
-                            !PageReserved(pfn_to_page(start_pfn - 1)))
+                            online_section_nr(pfn_to_section_nr(start_pfn)))
                                 hv_bring_pgs_online(has, start_pfn, pgs_ol);
 
                 }
diff --git a/drivers/hv/ring_buffer.c b/drivers/hv/ring_buffer.c
index 64d0c85d5161..1f1a55e07733 100644
--- a/drivers/hv/ring_buffer.c
+++ b/drivers/hv/ring_buffer.c
@@ -164,26 +164,25 @@ hv_get_ringbuffer_availbytes(const struct hv_ring_buffer_info *rbi,
 }
 
 /* Get various debug metrics for the specified ring buffer. */
-void hv_ringbuffer_get_debuginfo(const struct hv_ring_buffer_info *ring_info,
-                                 struct hv_ring_buffer_debug_info *debug_info)
+int hv_ringbuffer_get_debuginfo(const struct hv_ring_buffer_info *ring_info,
+                                struct hv_ring_buffer_debug_info *debug_info)
 {
         u32 bytes_avail_towrite;
         u32 bytes_avail_toread;
 
-        if (ring_info->ring_buffer) {
-                hv_get_ringbuffer_availbytes(ring_info,
-                                        &bytes_avail_toread,
-                                        &bytes_avail_towrite);
-
-                debug_info->bytes_avail_toread = bytes_avail_toread;
-                debug_info->bytes_avail_towrite = bytes_avail_towrite;
-                debug_info->current_read_index =
-                        ring_info->ring_buffer->read_index;
-                debug_info->current_write_index =
-                        ring_info->ring_buffer->write_index;
-                debug_info->current_interrupt_mask =
-                        ring_info->ring_buffer->interrupt_mask;
-        }
+        if (!ring_info->ring_buffer)
+                return -EINVAL;
+
+        hv_get_ringbuffer_availbytes(ring_info,
+                                     &bytes_avail_toread,
+                                     &bytes_avail_towrite);
+        debug_info->bytes_avail_toread = bytes_avail_toread;
+        debug_info->bytes_avail_towrite = bytes_avail_towrite;
+        debug_info->current_read_index = ring_info->ring_buffer->read_index;
+        debug_info->current_write_index = ring_info->ring_buffer->write_index;
+        debug_info->current_interrupt_mask
+                = ring_info->ring_buffer->interrupt_mask;
+        return 0;
 }
 EXPORT_SYMBOL_GPL(hv_ringbuffer_get_debuginfo);
 
diff --git a/drivers/hv/vmbus_drv.c b/drivers/hv/vmbus_drv.c
index d0ff65675292..403fee01572c 100644
--- a/drivers/hv/vmbus_drv.c
+++ b/drivers/hv/vmbus_drv.c
@@ -313,12 +313,16 @@ static ssize_t out_intr_mask_show(struct device *dev,
 {
         struct hv_device *hv_dev = device_to_hv_device(dev);
         struct hv_ring_buffer_debug_info outbound;
+        int ret;
 
         if (!hv_dev->channel)
                 return -ENODEV;
-        if (hv_dev->channel->state != CHANNEL_OPENED_STATE)
-                return -EINVAL;
-        hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound, &outbound);
+
+        ret = hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound,
+                                          &outbound);
+        if (ret < 0)
+                return ret;
+
         return sprintf(buf, "%d\n", outbound.current_interrupt_mask);
 }
 static DEVICE_ATTR_RO(out_intr_mask);
@@ -328,12 +332,15 @@ static ssize_t out_read_index_show(struct device *dev,
 {
         struct hv_device *hv_dev = device_to_hv_device(dev);
         struct hv_ring_buffer_debug_info outbound;
+        int ret;
 
         if (!hv_dev->channel)
                 return -ENODEV;
-        if (hv_dev->channel->state != CHANNEL_OPENED_STATE)
-                return -EINVAL;
-        hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound, &outbound);
+
+        ret = hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound,
+                                          &outbound);
+        if (ret < 0)
+                return ret;
         return sprintf(buf, "%d\n", outbound.current_read_index);
 }
 static DEVICE_ATTR_RO(out_read_index);
@@ -344,12 +351,15 @@ static ssize_t out_write_index_show(struct device *dev,
 {
         struct hv_device *hv_dev = device_to_hv_device(dev);
         struct hv_ring_buffer_debug_info outbound;
+        int ret;
 
         if (!hv_dev->channel)
                 return -ENODEV;
-        if (hv_dev->channel->state != CHANNEL_OPENED_STATE)
-                return -EINVAL;
-        hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound, &outbound);
+
+        ret = hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound,
+                                          &outbound);
+        if (ret < 0)
+                return ret;
         return sprintf(buf, "%d\n", outbound.current_write_index);
 }
 static DEVICE_ATTR_RO(out_write_index);
@@ -360,12 +370,15 @@ static ssize_t out_read_bytes_avail_show(struct device *dev,
 {
         struct hv_device *hv_dev = device_to_hv_device(dev);
         struct hv_ring_buffer_debug_info outbound;
+        int ret;
 
         if (!hv_dev->channel)
                 return -ENODEV;
-        if (hv_dev->channel->state != CHANNEL_OPENED_STATE)
-                return -EINVAL;
-        hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound, &outbound);
+
+        ret = hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound,
+                                          &outbound);
+        if (ret < 0)
+                return ret;
         return sprintf(buf, "%d\n", outbound.bytes_avail_toread);
 }
 static DEVICE_ATTR_RO(out_read_bytes_avail);
@@ -376,12 +389,15 @@ static ssize_t out_write_bytes_avail_show(struct device *dev,
 {
         struct hv_device *hv_dev = device_to_hv_device(dev);
         struct hv_ring_buffer_debug_info outbound;
+        int ret;
 
         if (!hv_dev->channel)
                 return -ENODEV;
-        if (hv_dev->channel->state != CHANNEL_OPENED_STATE)
-                return -EINVAL;
-        hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound, &outbound);
+
+        ret = hv_ringbuffer_get_debuginfo(&hv_dev->channel->outbound,
+                                          &outbound);
+        if (ret < 0)
+                return ret;
         return sprintf(buf, "%d\n", outbound.bytes_avail_towrite);
 }
 static DEVICE_ATTR_RO(out_write_bytes_avail);
@@ -391,12 +407,15 @@ static ssize_t in_intr_mask_show(struct device *dev,
 {
         struct hv_device *hv_dev = device_to_hv_device(dev);
         struct hv_ring_buffer_debug_info inbound;
+        int ret;
 
         if (!hv_dev->channel)
                 return -ENODEV;
-        if (hv_dev->channel->state != CHANNEL_OPENED_STATE)
-                return -EINVAL;
-        hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound);
+
+        ret = hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound);
+        if (ret < 0)
+                return ret;
+
         return sprintf(buf, "%d\n", inbound.current_interrupt_mask);
 }
 static DEVICE_ATTR_RO(in_intr_mask);
@@ -406,12 +425,15 @@ static ssize_t in_read_index_show(struct device *dev,
 {
         struct hv_device *hv_dev = device_to_hv_device(dev);
         struct hv_ring_buffer_debug_info inbound;
+        int ret;
 
         if (!hv_dev->channel)
                 return -ENODEV;
-        if (hv_dev->channel->state != CHANNEL_OPENED_STATE)
-                return -EINVAL;
-        hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound);
+
+        ret = hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound);
+        if (ret < 0)
+                return ret;
+
         return sprintf(buf, "%d\n", inbound.current_read_index);
 }
 static DEVICE_ATTR_RO(in_read_index);
@@ -421,12 +443,15 @@ static ssize_t in_write_index_show(struct device *dev,
 {
         struct hv_device *hv_dev = device_to_hv_device(dev);
         struct hv_ring_buffer_debug_info inbound;
+        int ret;
 
         if (!hv_dev->channel)
                 return -ENODEV;
-        if (hv_dev->channel->state != CHANNEL_OPENED_STATE)
-                return -EINVAL;
-        hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound);
+
+        ret = hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound);
+        if (ret < 0)
+                return ret;
+
         return sprintf(buf, "%d\n", inbound.current_write_index);
 }
 static DEVICE_ATTR_RO(in_write_index);
@@ -437,12 +462,15 @@ static ssize_t in_read_bytes_avail_show(struct device *dev,
 {
         struct hv_device *hv_dev = device_to_hv_device(dev);
         struct hv_ring_buffer_debug_info inbound;
+        int ret;
 
         if (!hv_dev->channel)
                 return -ENODEV;
-        if (hv_dev->channel->state != CHANNEL_OPENED_STATE)
-                return -EINVAL;
-        hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound);
+
+        ret = hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound);
+        if (ret < 0)
+                return ret;
+
         return sprintf(buf, "%d\n", inbound.bytes_avail_toread);
 }
 static DEVICE_ATTR_RO(in_read_bytes_avail);
@@ -453,12 +481,15 @@ static ssize_t in_write_bytes_avail_show(struct device *dev,
 {
         struct hv_device *hv_dev = device_to_hv_device(dev);
         struct hv_ring_buffer_debug_info inbound;
+        int ret;
 
         if (!hv_dev->channel)
                 return -ENODEV;
-        if (hv_dev->channel->state != CHANNEL_OPENED_STATE)
-                return -EINVAL;
-        hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound);
+
+        ret = hv_ringbuffer_get_debuginfo(&hv_dev->channel->inbound, &inbound);
+        if (ret < 0)
+                return ret;
+
         return sprintf(buf, "%d\n", inbound.bytes_avail_towrite);
 }
 static DEVICE_ATTR_RO(in_write_bytes_avail);
diff --git a/drivers/hwmon/lm80.c b/drivers/hwmon/lm80.c
index 0e30fa00204c..f9b8e3e23a8e 100644
--- a/drivers/hwmon/lm80.c
+++ b/drivers/hwmon/lm80.c
@@ -393,8 +393,10 @@ static ssize_t set_fan_div(struct device *dev, struct device_attribute *attr,
         }
 
         rv = lm80_read_value(client, LM80_REG_FANDIV);
-        if (rv < 0)
+        if (rv < 0) {
+                mutex_unlock(&data->update_lock);
                 return rv;
+        }
         reg = (rv & ~(3 << (2 * (nr + 1))))
             | (data->fan_div[nr] << (2 * (nr + 1)));
         lm80_write_value(client, LM80_REG_FANDIV, reg);
diff --git a/drivers/hwmon/nct6775.c b/drivers/hwmon/nct6775.c
index c3040079b1cb..4adec4ab7d06 100644
--- a/drivers/hwmon/nct6775.c
+++ b/drivers/hwmon/nct6775.c
@@ -44,8 +44,8 @@
  * nct6796d    14      7       7       2+6    0xd420 0xc1    0x5ca3
  * nct6797d    14      7       7       2+6    0xd450 0xc1    0x5ca3
  *                                           (0xd451)
- * nct6798d    14      7       7       2+6    0xd458 0xc1    0x5ca3
- *                                           (0xd459)
+ * nct6798d    14      7       7       2+6    0xd428 0xc1    0x5ca3
+ *                                           (0xd429)
  *
  * #temp lists the number of monitored temperature sources (first value) plus
  * the number of directly connectable temperature sensors (second value).
@@ -138,7 +138,7 @@ MODULE_PARM_DESC(fan_debounce, "Enable debouncing for fan RPM signal");
 #define SIO_NCT6795_ID          0xd350
 #define SIO_NCT6796_ID          0xd420
 #define SIO_NCT6797_ID          0xd450
-#define SIO_NCT6798_ID          0xd458
+#define SIO_NCT6798_ID          0xd428
 #define SIO_ID_MASK             0xFFF8
 
 enum pwm_enable { off, manual, thermal_cruise, speed_cruise, sf3, sf4 };
@@ -4508,7 +4508,8 @@ static int __maybe_unused nct6775_resume(struct device *dev)
 
         if (data->kind == nct6791 || data->kind == nct6792 ||
             data->kind == nct6793 || data->kind == nct6795 ||
-            data->kind == nct6796)
+            data->kind == nct6796 || data->kind == nct6797 ||
+            data->kind == nct6798)
                 nct6791_enable_io_mapping(sioreg);
 
         superio_exit(sioreg);
@@ -4644,7 +4645,8 @@ static int __init nct6775_find(int sioaddr, struct nct6775_sio_data *sio_data)
 
         if (sio_data->kind == nct6791 || sio_data->kind == nct6792 ||
             sio_data->kind == nct6793 || sio_data->kind == nct6795 ||
-            sio_data->kind == nct6796)
+            sio_data->kind == nct6796 || sio_data->kind == nct6797 ||
+            sio_data->kind == nct6798)
                 nct6791_enable_io_mapping(sioaddr);
 
         superio_exit(sioaddr);
diff --git a/drivers/hwmon/occ/common.c b/drivers/hwmon/occ/common.c
index 423903f87955..391118c8aae8 100644
--- a/drivers/hwmon/occ/common.c
+++ b/drivers/hwmon/occ/common.c
@@ -380,8 +380,8 @@ static ssize_t occ_show_power_1(struct device *dev,
                 val *= 1000000ULL;
                 break;
         case 2:
-                val = get_unaligned_be32(&power->update_tag) *
-                        occ->powr_sample_time_us;
+                val = (u64)get_unaligned_be32(&power->update_tag) *
+                           occ->powr_sample_time_us;
                 break;
         case 3:
                 val = get_unaligned_be16(&power->value) * 1000000ULL;
@@ -425,8 +425,8 @@ static ssize_t occ_show_power_2(struct device *dev,
                                        &power->update_tag);
                 break;
         case 2:
-                val = get_unaligned_be32(&power->update_tag) *
-                        occ->powr_sample_time_us;
+                val = (u64)get_unaligned_be32(&power->update_tag) *
+                           occ->powr_sample_time_us;
                 break;
         case 3:
                 val = get_unaligned_be16(&power->value) * 1000000ULL;
@@ -463,8 +463,8 @@ static ssize_t occ_show_power_a0(struct device *dev,
                                        &power->system.update_tag);
                 break;
         case 2:
-                val = get_unaligned_be32(&power->system.update_tag) *
-                        occ->powr_sample_time_us;
+                val = (u64)get_unaligned_be32(&power->system.update_tag) *
+                           occ->powr_sample_time_us;
                 break;
         case 3:
                 val = get_unaligned_be16(&power->system.value) * 1000000ULL;
@@ -477,8 +477,8 @@ static ssize_t occ_show_power_a0(struct device *dev,
                                        &power->proc.update_tag);
                 break;
         case 6:
-                val = get_unaligned_be32(&power->proc.update_tag) *
-                        occ->powr_sample_time_us;
+                val = (u64)get_unaligned_be32(&power->proc.update_tag) *
+                           occ->powr_sample_time_us;
                 break;
         case 7:
                 val = get_unaligned_be16(&power->proc.value) * 1000000ULL;
@@ -491,8 +491,8 @@ static ssize_t occ_show_power_a0(struct device *dev,
                                        &power->vdd.update_tag);
                 break;
         case 10:
-                val = get_unaligned_be32(&power->vdd.update_tag) *
-                        occ->powr_sample_time_us;
+                val = (u64)get_unaligned_be32(&power->vdd.update_tag) *
+                           occ->powr_sample_time_us;
                 break;
         case 11:
                 val = get_unaligned_be16(&power->vdd.value) * 1000000ULL;
@@ -505,8 +505,8 @@ static ssize_t occ_show_power_a0(struct device *dev,
                                        &power->vdn.update_tag);
                 break;
         case 14:
-                val = get_unaligned_be32(&power->vdn.update_tag) *
-                        occ->powr_sample_time_us;
+                val = (u64)get_unaligned_be32(&power->vdn.update_tag) *
+                           occ->powr_sample_time_us;
                 break;
         case 15:
                 val = get_unaligned_be16(&power->vdn.value) * 1000000ULL;
diff --git a/drivers/hwmon/tmp421.c b/drivers/hwmon/tmp421.c
index 8844c9565d2a..7053be59ad2e 100644
--- a/drivers/hwmon/tmp421.c
+++ b/drivers/hwmon/tmp421.c
@@ -88,7 +88,7 @@ static const struct of_device_id tmp421_of_match[] = {
                 .data = (void *)2
         },
         {
-                .compatible = "ti,tmp422",
+                .compatible = "ti,tmp442",
                 .data = (void *)3
         },
         { },
diff --git a/drivers/i2c/busses/i2c-tegra.c b/drivers/i2c/busses/i2c-tegra.c
index e417ebf7628c..c77adbbea0c7 100644
--- a/drivers/i2c/busses/i2c-tegra.c
+++ b/drivers/i2c/busses/i2c-tegra.c
@@ -155,6 +155,8 @@ enum msg_end_type {
  * @has_mst_fifo: The I2C controller contains the new MST FIFO interface that
  *              provides additional features and allows for longer messages to
  *              be transferred in one go.
+ * @quirks: i2c adapter quirks for limiting write/read transfer size and not
+ *              allowing 0 length transfers.
  */
 struct tegra_i2c_hw_feature {
         bool has_continue_xfer_support;
@@ -167,6 +169,7 @@ struct tegra_i2c_hw_feature {
         bool has_multi_master_mode;
         bool has_slcg_override_reg;
         bool has_mst_fifo;
+        const struct i2c_adapter_quirks *quirks;
 };
 
 /**
@@ -837,6 +840,10 @@ static const struct i2c_adapter_quirks tegra_i2c_quirks = {
         .max_write_len = 4096,
 };
 
+static const struct i2c_adapter_quirks tegra194_i2c_quirks = {
+        .flags = I2C_AQ_NO_ZERO_LEN,
+};
+
 static const struct tegra_i2c_hw_feature tegra20_i2c_hw = {
         .has_continue_xfer_support = false,
         .has_per_pkt_xfer_complete_irq = false,
@@ -848,6 +855,7 @@ static const struct tegra_i2c_hw_feature tegra20_i2c_hw = {
         .has_multi_master_mode = false,
         .has_slcg_override_reg = false,
         .has_mst_fifo = false,
+        .quirks = &tegra_i2c_quirks,
 };
 
 static const struct tegra_i2c_hw_feature tegra30_i2c_hw = {
@@ -861,6 +869,7 @@ static const struct tegra_i2c_hw_feature tegra30_i2c_hw = {
         .has_multi_master_mode = false,
         .has_slcg_override_reg = false,
         .has_mst_fifo = false,
+        .quirks = &tegra_i2c_quirks,
 };
 
 static const struct tegra_i2c_hw_feature tegra114_i2c_hw = {
@@ -874,6 +883,7 @@ static const struct tegra_i2c_hw_feature tegra114_i2c_hw = {
         .has_multi_master_mode = false,
         .has_slcg_override_reg = false,
         .has_mst_fifo = false,
+        .quirks = &tegra_i2c_quirks,
 };
 
 static const struct tegra_i2c_hw_feature tegra124_i2c_hw = {
@@ -887,6 +897,7 @@ static const struct tegra_i2c_hw_feature tegra124_i2c_hw = {
         .has_multi_master_mode = false,
         .has_slcg_override_reg = true,
         .has_mst_fifo = false,
+        .quirks = &tegra_i2c_quirks,
 };
 
 static const struct tegra_i2c_hw_feature tegra210_i2c_hw = {
@@ -900,6 +911,7 @@ static const struct tegra_i2c_hw_feature tegra210_i2c_hw = {
         .has_multi_master_mode = true,
         .has_slcg_override_reg = true,
         .has_mst_fifo = false,
+        .quirks = &tegra_i2c_quirks,
 };
 
 static const struct tegra_i2c_hw_feature tegra194_i2c_hw = {
@@ -913,6 +925,7 @@ static const struct tegra_i2c_hw_feature tegra194_i2c_hw = {
         .has_multi_master_mode = true,
         .has_slcg_override_reg = true,
         .has_mst_fifo = true,
+        .quirks = &tegra194_i2c_quirks,
 };
 
 /* Match table for of_platform binding */
@@ -964,7 +977,6 @@ static int tegra_i2c_probe(struct platform_device *pdev)
         i2c_dev->base = base;
         i2c_dev->div_clk = div_clk;
         i2c_dev->adapter.algo = &tegra_i2c_algo;
-        i2c_dev->adapter.quirks = &tegra_i2c_quirks;
         i2c_dev->irq = irq;
         i2c_dev->cont_id = pdev->id;
         i2c_dev->dev = &pdev->dev;
@@ -980,6 +992,7 @@ static int tegra_i2c_probe(struct platform_device *pdev)
         i2c_dev->hw = of_device_get_match_data(&pdev->dev);
         i2c_dev->is_dvc = of_device_is_compatible(pdev->dev.of_node,
                                                   "nvidia,tegra20-i2c-dvc");
+        i2c_dev->adapter.quirks = i2c_dev->hw->quirks;
         init_completion(&i2c_dev->msg_complete);
         spin_lock_init(&i2c_dev->xfer_lock);
 
diff --git a/drivers/i2c/i2c-dev.c b/drivers/i2c/i2c-dev.c
index 1aca742fde4a..ccd76c71af09 100644
--- a/drivers/i2c/i2c-dev.c
+++ b/drivers/i2c/i2c-dev.c
@@ -470,9 +470,15 @@ static long i2cdev_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
                                           data_arg.data);
         }
         case I2C_RETRIES:
+                if (arg > INT_MAX)
+                        return -EINVAL;
+
                 client->adapter->retries = arg;
                 break;
         case I2C_TIMEOUT:
+                if (arg > INT_MAX)
+                        return -EINVAL;
+
                 /* For historical reasons, user-space sets the timeout
                  * value in units of 10 ms.
                  */
diff --git a/drivers/i3c/master/dw-i3c-master.c b/drivers/i3c/master/dw-i3c-master.c
index b532e2c9cf5c..f8c00b94817f 100644
--- a/drivers/i3c/master/dw-i3c-master.c
+++ b/drivers/i3c/master/dw-i3c-master.c
@@ -901,9 +901,6 @@ static int dw_i3c_master_reattach_i3c_dev(struct i3c_dev_desc *dev,
                master->regs +
                DEV_ADDR_TABLE_LOC(master->datstartaddr, data->index));
 
-        if (!old_dyn_addr)
-                return 0;
-
         master->addrs[data->index] = dev->info.dyn_addr;
 
         return 0;
@@ -925,11 +922,11 @@ static int dw_i3c_master_attach_i3c_dev(struct i3c_dev_desc *dev)
                 return -ENOMEM;
 
         data->index = pos;
-        master->addrs[pos] = dev->info.dyn_addr;
+        master->addrs[pos] = dev->info.dyn_addr ? : dev->info.static_addr;
         master->free_pos &= ~BIT(pos);
         i3c_dev_set_master_data(dev, data);
 
-        writel(DEV_ADDR_TABLE_DYNAMIC_ADDR(dev->info.dyn_addr),
+        writel(DEV_ADDR_TABLE_DYNAMIC_ADDR(master->addrs[pos]),
                master->regs +
                DEV_ADDR_TABLE_LOC(master->datstartaddr, data->index));
 
diff --git a/drivers/i3c/master/i3c-master-cdns.c b/drivers/i3c/master/i3c-master-cdns.c
index bbd79b8b1a80..8889a4fdb454 100644
--- a/drivers/i3c/master/i3c-master-cdns.c
+++ b/drivers/i3c/master/i3c-master-cdns.c
@@ -1556,8 +1556,8 @@ static int cdns_i3c_master_probe(struct platform_device *pdev)
                 return PTR_ERR(master->pclk);
 
         master->sysclk = devm_clk_get(&pdev->dev, "sysclk");
-        if (IS_ERR(master->pclk))
-                return PTR_ERR(master->pclk);
+        if (IS_ERR(master->sysclk))
+                return PTR_ERR(master->sysclk);
 
         irq = platform_get_irq(pdev, 0);
         if (irq < 0)
diff --git a/drivers/ide/ide-proc.c b/drivers/ide/ide-proc.c
index 4c8c7a620d08..a5dc13576394 100644
--- a/drivers/ide/ide-proc.c
+++ b/drivers/ide/ide-proc.c
@@ -544,7 +544,7 @@ void ide_proc_port_register_devices(ide_hwif_t *hwif)
                 drive->proc = proc_mkdir(drive->name, parent);
                 if (drive->proc) {
                         ide_add_proc_entries(drive->proc, generic_drive_entries, drive);
-                        proc_create_data("setting", S_IFREG|S_IRUSR|S_IWUSR,
+                        proc_create_data("settings", S_IFREG|S_IRUSR|S_IWUSR,
                                         drive->proc, &ide_settings_proc_fops,
                                         drive);
                 }
diff --git a/drivers/iio/adc/ti_am335x_adc.c b/drivers/iio/adc/ti_am335x_adc.c
index cafb1dcadc48..9d984f2a8ba7 100644
--- a/drivers/iio/adc/ti_am335x_adc.c
+++ b/drivers/iio/adc/ti_am335x_adc.c
@@ -142,7 +142,10 @@ static void tiadc_step_config(struct iio_dev *indio_dev)
                         stepconfig |= STEPCONFIG_MODE_SWCNT;
 
                 tiadc_writel(adc_dev, REG_STEPCONFIG(steps),
-                                stepconfig | STEPCONFIG_INP(chan));
+                                stepconfig | STEPCONFIG_INP(chan) |
+                                STEPCONFIG_INM_ADCREFM |
+                                STEPCONFIG_RFP_VREFP |
+                                STEPCONFIG_RFM_VREFN);
 
                 if (adc_dev->open_delay[i] > STEPDELAY_OPEN_MASK) {
                         dev_warn(dev, "chan %d open delay truncating to 0x3FFFF\n",
diff --git a/drivers/infiniband/core/cma.c b/drivers/infiniband/core/cma.c
index 63a7cc00bae0..84f077b2b90a 100644
--- a/drivers/infiniband/core/cma.c
+++ b/drivers/infiniband/core/cma.c
@@ -494,7 +494,10 @@ static void _cma_attach_to_dev(struct rdma_id_private *id_priv,
         id_priv->id.route.addr.dev_addr.transport =
                 rdma_node_get_transport(cma_dev->device->node_type);
         list_add_tail(&id_priv->list, &cma_dev->id_list);
-        rdma_restrack_kadd(&id_priv->res);
+        if (id_priv->res.kern_name)
+                rdma_restrack_kadd(&id_priv->res);
+        else
+                rdma_restrack_uadd(&id_priv->res);
 }
 
 static void cma_attach_to_dev(struct rdma_id_private *id_priv,
diff --git a/drivers/infiniband/core/nldev.c b/drivers/infiniband/core/nldev.c
index e600fc23ae62..3c97a8b6bf1e 100644
--- a/drivers/infiniband/core/nldev.c
+++ b/drivers/infiniband/core/nldev.c
@@ -584,10 +584,6 @@ static int fill_res_pd_entry(struct sk_buff *msg, struct netlink_callback *cb,
         if (nla_put_u64_64bit(msg, RDMA_NLDEV_ATTR_RES_USECNT,
                               atomic_read(&pd->usecnt), RDMA_NLDEV_ATTR_PAD))
                 goto err;
-        if ((pd->flags & IB_PD_UNSAFE_GLOBAL_RKEY) &&
-            nla_put_u32(msg, RDMA_NLDEV_ATTR_RES_UNSAFE_GLOBAL_RKEY,
-                        pd->unsafe_global_rkey))
-                goto err;
 
         if (fill_res_name_pid(msg, res))
                 goto err;
diff --git a/drivers/infiniband/core/rdma_core.h b/drivers/infiniband/core/rdma_core.h
index be6b8e1257d0..69f8db66925e 100644
--- a/drivers/infiniband/core/rdma_core.h
+++ b/drivers/infiniband/core/rdma_core.h
@@ -106,6 +106,8 @@ int uverbs_finalize_object(struct ib_uobject *uobj,
                            enum uverbs_obj_access access,
                            bool commit);
 
+int uverbs_output_written(const struct uverbs_attr_bundle *bundle, size_t idx);
+
 void setup_ufile_idr_uobject(struct ib_uverbs_file *ufile);
 void release_ufile_idr_uobject(struct ib_uverbs_file *ufile);
 
diff --git a/drivers/infiniband/core/uverbs_cmd.c b/drivers/infiniband/core/uverbs_cmd.c
index 6b12cc5f97b2..3317300ab036 100644
--- a/drivers/infiniband/core/uverbs_cmd.c
+++ b/drivers/infiniband/core/uverbs_cmd.c
@@ -60,6 +60,10 @@ static int uverbs_response(struct uverbs_attr_bundle *attrs, const void *resp,
 {
         int ret;
 
+        if (uverbs_attr_is_valid(attrs, UVERBS_ATTR_CORE_OUT))
+                return uverbs_copy_to_struct_or_zero(
+                        attrs, UVERBS_ATTR_CORE_OUT, resp, resp_len);
+
         if (copy_to_user(attrs->ucore.outbuf, resp,
                          min(attrs->ucore.outlen, resp_len)))
                 return -EFAULT;
@@ -1181,6 +1185,9 @@ static int ib_uverbs_poll_cq(struct uverbs_attr_bundle *attrs)
                 goto out_put;
         }
 
+        if (uverbs_attr_is_valid(attrs, UVERBS_ATTR_CORE_OUT))
+                ret = uverbs_output_written(attrs, UVERBS_ATTR_CORE_OUT);
+
         ret = 0;
 
 out_put:
@@ -2012,8 +2019,10 @@ static int ib_uverbs_post_send(struct uverbs_attr_bundle *attrs)
                 return -ENOMEM;
 
         qp = uobj_get_obj_read(qp, UVERBS_OBJECT_QP, cmd.qp_handle, attrs);
-        if (!qp)
+        if (!qp) {
+                ret = -EINVAL;
                 goto out;
+        }
 
         is_ud = qp->qp_type == IB_QPT_UD;
         sg_ind = 0;
diff --git a/drivers/infiniband/core/uverbs_ioctl.c b/drivers/infiniband/core/uverbs_ioctl.c
index 8c81ff698052..0ca04d224015 100644
--- a/drivers/infiniband/core/uverbs_ioctl.c
+++ b/drivers/infiniband/core/uverbs_ioctl.c
@@ -144,6 +144,21 @@ static bool uverbs_is_attr_cleared(const struct ib_uverbs_attr *uattr,
                            0, uattr->len - len);
 }
 
+static int uverbs_set_output(const struct uverbs_attr_bundle *bundle,
+                             const struct uverbs_attr *attr)
+{
+        struct bundle_priv *pbundle =
+                container_of(bundle, struct bundle_priv, bundle);
+        u16 flags;
+
+        flags = pbundle->uattrs[attr->ptr_attr.uattr_idx].flags |
+                UVERBS_ATTR_F_VALID_OUTPUT;
+        if (put_user(flags,
+                     &pbundle->user_attrs[attr->ptr_attr.uattr_idx].flags))
+                return -EFAULT;
+        return 0;
+}
+
 static int uverbs_process_idrs_array(struct bundle_priv *pbundle,
                                      const struct uverbs_api_attr *attr_uapi,
                                      struct uverbs_objs_arr_attr *attr,
@@ -456,6 +471,19 @@ static int ib_uverbs_run_method(struct bundle_priv *pbundle,
         }
 
         /*
+         * Until the drivers are revised to use the bundle directly we have to
+         * assume that the driver wrote to its UHW_OUT and flag userspace
+         * appropriately.
+         */
+        if (!ret && pbundle->method_elm->has_udata) {
+                const struct uverbs_attr *attr =
+                        uverbs_attr_get(&pbundle->bundle, UVERBS_ATTR_UHW_OUT);
+
+                if (!IS_ERR(attr))
+                        ret = uverbs_set_output(&pbundle->bundle, attr);
+        }
+
+        /*
          * EPROTONOSUPPORT is ONLY to be returned if the ioctl framework can
          * not invoke the method because the request is not supported.  No
          * other cases should return this code.
@@ -706,10 +734,7 @@ void uverbs_fill_udata(struct uverbs_attr_bundle *bundle,
 int uverbs_copy_to(const struct uverbs_attr_bundle *bundle, size_t idx,
                    const void *from, size_t size)
 {
-        struct bundle_priv *pbundle =
-                container_of(bundle, struct bundle_priv, bundle);
         const struct uverbs_attr *attr = uverbs_attr_get(bundle, idx);
-        u16 flags;
         size_t min_size;
 
         if (IS_ERR(attr))
@@ -719,16 +744,25 @@ int uverbs_copy_to(const struct uverbs_attr_bundle *bundle, size_t idx,
         if (copy_to_user(u64_to_user_ptr(attr->ptr_attr.data), from, min_size))
                 return -EFAULT;
 
-        flags = pbundle->uattrs[attr->ptr_attr.uattr_idx].flags |
-                UVERBS_ATTR_F_VALID_OUTPUT;
-        if (put_user(flags,
-                     &pbundle->user_attrs[attr->ptr_attr.uattr_idx].flags))
-                return -EFAULT;
-
-        return 0;
+        return uverbs_set_output(bundle, attr);
 }
 EXPORT_SYMBOL(uverbs_copy_to);
 
+
+/*
+ * This is only used if the caller has directly used copy_to_use to write the
+ * data.  It signals to user space that the buffer is filled in.
+ */
+int uverbs_output_written(const struct uverbs_attr_bundle *bundle, size_t idx)
+{
+        const struct uverbs_attr *attr = uverbs_attr_get(bundle, idx);
+
+        if (IS_ERR(attr))
+                return PTR_ERR(attr);
+
+        return uverbs_set_output(bundle, attr);
+}
+
 int _uverbs_get_const(s64 *to, const struct uverbs_attr_bundle *attrs_bundle,
                       size_t idx, s64 lower_bound, u64 upper_bound,
                       s64  *def_val)
@@ -757,8 +791,10 @@ int uverbs_copy_to_struct_or_zero(const struct uverbs_attr_bundle *bundle,
 {
         const struct uverbs_attr *attr = uverbs_attr_get(bundle, idx);
 
-        if (clear_user(u64_to_user_ptr(attr->ptr_attr.data),
-                       attr->ptr_attr.len))
-                return -EFAULT;
+        if (size < attr->ptr_attr.len) {
+                if (clear_user(u64_to_user_ptr(attr->ptr_attr.data) + size,
+                               attr->ptr_attr.len - size))
+                        return -EFAULT;
+        }
         return uverbs_copy_to(bundle, idx, from, size);
 }
diff --git a/drivers/infiniband/core/uverbs_main.c b/drivers/infiniband/core/uverbs_main.c
index fb0007aa0c27..2890a77339e1 100644
--- a/drivers/infiniband/core/uverbs_main.c
+++ b/drivers/infiniband/core/uverbs_main.c
@@ -690,6 +690,7 @@ static ssize_t ib_uverbs_write(struct file *filp, const char __user *buf,
 
         buf += sizeof(hdr);
 
+        memset(bundle.attr_present, 0, sizeof(bundle.attr_present));
         bundle.ufile = file;
         if (!method_elm->is_ex) {
                 size_t in_len = hdr.in_words * 4 - sizeof(hdr);
diff --git a/drivers/infiniband/hw/bnxt_re/qplib_rcfw.c b/drivers/infiniband/hw/bnxt_re/qplib_rcfw.c
index 326805461265..19551aa43850 100644
--- a/drivers/infiniband/hw/bnxt_re/qplib_rcfw.c
+++ b/drivers/infiniband/hw/bnxt_re/qplib_rcfw.c
@@ -766,8 +766,8 @@ struct bnxt_qplib_rcfw_sbuf *bnxt_qplib_rcfw_alloc_sbuf(
                 return NULL;
 
         sbuf->size = size;
-        sbuf->sb = dma_zalloc_coherent(&rcfw->pdev->dev, sbuf->size,
-                                       &sbuf->dma_addr, GFP_ATOMIC);
+        sbuf->sb = dma_alloc_coherent(&rcfw->pdev->dev, sbuf->size,
+                                      &sbuf->dma_addr, GFP_ATOMIC);
         if (!sbuf->sb)
                 goto bail;
 
diff --git a/drivers/infiniband/hw/bnxt_re/qplib_res.c b/drivers/infiniband/hw/bnxt_re/qplib_res.c
index 59eeac55626f..57d4951679cb 100644
--- a/drivers/infiniband/hw/bnxt_re/qplib_res.c
+++ b/drivers/infiniband/hw/bnxt_re/qplib_res.c
@@ -105,10 +105,10 @@ static int __alloc_pbl(struct pci_dev *pdev, struct bnxt_qplib_pbl *pbl,
 
         if (!sghead) {
                 for (i = 0; i < pages; i++) {
-                        pbl->pg_arr[i] = dma_zalloc_coherent(&pdev->dev,
-                                                             pbl->pg_size,
-                                                             &pbl->pg_map_arr[i],
-                                                             GFP_KERNEL);
+                        pbl->pg_arr[i] = dma_alloc_coherent(&pdev->dev,
+                                                            pbl->pg_size,
+                                                            &pbl->pg_map_arr[i],
+                                                            GFP_KERNEL);
                         if (!pbl->pg_arr[i])
                                 goto fail;
                         pbl->pg_count++;
diff --git a/drivers/infiniband/hw/cxgb3/cxio_hal.c b/drivers/infiniband/hw/cxgb3/cxio_hal.c
index df4f7a3f043d..8ac72ac7cbac 100644
--- a/drivers/infiniband/hw/cxgb3/cxio_hal.c
+++ b/drivers/infiniband/hw/cxgb3/cxio_hal.c
@@ -291,9 +291,9 @@ int cxio_create_qp(struct cxio_rdev *rdev_p, u32 kernel_domain,
         if (!wq->sq)
                 goto err3;
 
-        wq->queue = dma_zalloc_coherent(&(rdev_p->rnic_info.pdev->dev),
-                                             depth * sizeof(union t3_wr),
-                                             &(wq->dma_addr), GFP_KERNEL);
+        wq->queue = dma_alloc_coherent(&(rdev_p->rnic_info.pdev->dev),
+                                       depth * sizeof(union t3_wr),
+                                       &(wq->dma_addr), GFP_KERNEL);
         if (!wq->queue)
                 goto err4;
 
diff --git a/drivers/infiniband/hw/cxgb4/qp.c b/drivers/infiniband/hw/cxgb4/qp.c
index 981ff5cfb5d1..504cf525508f 100644
--- a/drivers/infiniband/hw/cxgb4/qp.c
+++ b/drivers/infiniband/hw/cxgb4/qp.c
@@ -2564,9 +2564,8 @@ static int alloc_srq_queue(struct c4iw_srq *srq, struct c4iw_dev_ucontext *uctx,
         wq->rqt_abs_idx = (wq->rqt_hwaddr - rdev->lldi.vr->rq.start) >>
                 T4_RQT_ENTRY_SHIFT;
 
-        wq->queue = dma_zalloc_coherent(&rdev->lldi.pdev->dev,
-                                       wq->memsize, &wq->dma_addr,
-                        GFP_KERNEL);
+        wq->queue = dma_alloc_coherent(&rdev->lldi.pdev->dev, wq->memsize,
+                                       &wq->dma_addr, GFP_KERNEL);
         if (!wq->queue)
                 goto err_free_rqtpool;
 
diff --git a/drivers/infiniband/hw/hfi1/init.c b/drivers/infiniband/hw/hfi1/init.c
index 09044905284f..7835eb52e7c5 100644
--- a/drivers/infiniband/hw/hfi1/init.c
+++ b/drivers/infiniband/hw/hfi1/init.c
@@ -899,10 +899,10 @@ int hfi1_init(struct hfi1_devdata *dd, int reinit)
                 goto done;
 
         /* allocate dummy tail memory for all receive contexts */
-        dd->rcvhdrtail_dummy_kvaddr = dma_zalloc_coherent(
-                &dd->pcidev->dev, sizeof(u64),
-                &dd->rcvhdrtail_dummy_dma,
-                GFP_KERNEL);
+        dd->rcvhdrtail_dummy_kvaddr = dma_alloc_coherent(&dd->pcidev->dev,
+                                                         sizeof(u64),
+                                                         &dd->rcvhdrtail_dummy_dma,
+                                                         GFP_KERNEL);
 
         if (!dd->rcvhdrtail_dummy_kvaddr) {
                 dd_dev_err(dd, "cannot allocate dummy tail memory\n");
@@ -1863,9 +1863,9 @@ int hfi1_create_rcvhdrq(struct hfi1_devdata *dd, struct hfi1_ctxtdata *rcd)
                         gfp_flags = GFP_KERNEL;
                 else
                         gfp_flags = GFP_USER;
-                rcd->rcvhdrq = dma_zalloc_coherent(
-                        &dd->pcidev->dev, amt, &rcd->rcvhdrq_dma,
-                        gfp_flags | __GFP_COMP);
+                rcd->rcvhdrq = dma_alloc_coherent(&dd->pcidev->dev, amt,
+                                                  &rcd->rcvhdrq_dma,
+                                                  gfp_flags | __GFP_COMP);
 
                 if (!rcd->rcvhdrq) {
                         dd_dev_err(dd,
@@ -1876,9 +1876,10 @@ int hfi1_create_rcvhdrq(struct hfi1_devdata *dd, struct hfi1_ctxtdata *rcd)
 
                 if (HFI1_CAP_KGET_MASK(rcd->flags, DMA_RTAIL) ||
                     HFI1_CAP_UGET_MASK(rcd->flags, DMA_RTAIL)) {
-                        rcd->rcvhdrtail_kvaddr = dma_zalloc_coherent(
-                                &dd->pcidev->dev, PAGE_SIZE,
-                                &rcd->rcvhdrqtailaddr_dma, gfp_flags);
+                        rcd->rcvhdrtail_kvaddr = dma_alloc_coherent(&dd->pcidev->dev,
+                                                                    PAGE_SIZE,
+                                                                    &rcd->rcvhdrqtailaddr_dma,
+                                                                    gfp_flags);
                         if (!rcd->rcvhdrtail_kvaddr)
                                 goto bail_free;
                 }
@@ -1974,10 +1975,10 @@ int hfi1_setup_eagerbufs(struct hfi1_ctxtdata *rcd)
         while (alloced_bytes < rcd->egrbufs.size &&
                rcd->egrbufs.alloced < rcd->egrbufs.count) {
                 rcd->egrbufs.buffers[idx].addr =
-                        dma_zalloc_coherent(&dd->pcidev->dev,
-                                            rcd->egrbufs.rcvtid_size,
-                                            &rcd->egrbufs.buffers[idx].dma,
-                                            gfp_flags);
+                        dma_alloc_coherent(&dd->pcidev->dev,
+                                           rcd->egrbufs.rcvtid_size,
+                                           &rcd->egrbufs.buffers[idx].dma,
+                                           gfp_flags);
                 if (rcd->egrbufs.buffers[idx].addr) {
                         rcd->egrbufs.buffers[idx].len =
                                 rcd->egrbufs.rcvtid_size;
diff --git a/drivers/infiniband/hw/hfi1/pio.c b/drivers/infiniband/hw/hfi1/pio.c
index dd5a5c030066..04126d7e318d 100644
--- a/drivers/infiniband/hw/hfi1/pio.c
+++ b/drivers/infiniband/hw/hfi1/pio.c
@@ -2098,11 +2098,10 @@ int init_credit_return(struct hfi1_devdata *dd)
                 int bytes = TXE_NUM_CONTEXTS * sizeof(struct credit_return);
 
                 set_dev_node(&dd->pcidev->dev, i);
-                dd->cr_base[i].va = dma_zalloc_coherent(
-                                        &dd->pcidev->dev,
-                                        bytes,
-                                        &dd->cr_base[i].dma,
-                                        GFP_KERNEL);
+                dd->cr_base[i].va = dma_alloc_coherent(&dd->pcidev->dev,
+                                                       bytes,
+                                                       &dd->cr_base[i].dma,
+                                                       GFP_KERNEL);
                 if (!dd->cr_base[i].va) {
                         set_dev_node(&dd->pcidev->dev, dd->node);
                         dd_dev_err(dd,
diff --git a/drivers/infiniband/hw/hfi1/sdma.c b/drivers/infiniband/hw/hfi1/sdma.c
index b84356e1a4c1..96897a91fb0a 100644
--- a/drivers/infiniband/hw/hfi1/sdma.c
+++ b/drivers/infiniband/hw/hfi1/sdma.c
@@ -1453,12 +1453,9 @@ int sdma_init(struct hfi1_devdata *dd, u8 port)
                 timer_setup(&sde->err_progress_check_timer,
                             sdma_err_progress_check, 0);
 
-                sde->descq = dma_zalloc_coherent(
-                        &dd->pcidev->dev,
-                        descq_cnt * sizeof(u64[2]),
-                        &sde->descq_phys,
-                        GFP_KERNEL
-                );
+                sde->descq = dma_alloc_coherent(&dd->pcidev->dev,
+                                                descq_cnt * sizeof(u64[2]),
+                                                &sde->descq_phys, GFP_KERNEL);
                 if (!sde->descq)
                         goto bail;
                 sde->tx_ring =
@@ -1471,24 +1468,18 @@ int sdma_init(struct hfi1_devdata *dd, u8 port)
 
         dd->sdma_heads_size = L1_CACHE_BYTES * num_engines;
         /* Allocate memory for DMA of head registers to memory */
-        dd->sdma_heads_dma = dma_zalloc_coherent(
-                &dd->pcidev->dev,
-                dd->sdma_heads_size,
-                &dd->sdma_heads_phys,
-                GFP_KERNEL
-        );
+        dd->sdma_heads_dma = dma_alloc_coherent(&dd->pcidev->dev,
+                                                dd->sdma_heads_size,
+                                                &dd->sdma_heads_phys,
+                                                GFP_KERNEL);
         if (!dd->sdma_heads_dma) {
                 dd_dev_err(dd, "failed to allocate SendDMA head memory\n");
                 goto bail;
         }
 
         /* Allocate memory for pad */
-        dd->sdma_pad_dma = dma_zalloc_coherent(
-                &dd->pcidev->dev,
-                sizeof(u32),
-                &dd->sdma_pad_phys,
-                GFP_KERNEL
-        );
+        dd->sdma_pad_dma = dma_alloc_coherent(&dd->pcidev->dev, sizeof(u32),
+                                              &dd->sdma_pad_phys, GFP_KERNEL);
         if (!dd->sdma_pad_dma) {
                 dd_dev_err(dd, "failed to allocate SendDMA pad memory\n");
                 goto bail;
diff --git a/drivers/infiniband/hw/hns/hns_roce_alloc.c b/drivers/infiniband/hw/hns/hns_roce_alloc.c
index 6300033a448f..dac058d3df53 100644
--- a/drivers/infiniband/hw/hns/hns_roce_alloc.c
+++ b/drivers/infiniband/hw/hns/hns_roce_alloc.c
@@ -197,8 +197,8 @@ int hns_roce_buf_alloc(struct hns_roce_dev *hr_dev, u32 size, u32 max_direct,
                 buf->npages = 1 << order;
                 buf->page_shift = page_shift;
                 /* MTT PA must be recorded in 4k alignment, t is 4k aligned */
-                buf->direct.buf = dma_zalloc_coherent(dev,
-                                                      size, &t, GFP_KERNEL);
+                buf->direct.buf = dma_alloc_coherent(dev, size, &t,
+                                                     GFP_KERNEL);
                 if (!buf->direct.buf)
                         return -ENOMEM;
 
@@ -219,9 +219,10 @@ int hns_roce_buf_alloc(struct hns_roce_dev *hr_dev, u32 size, u32 max_direct,
                         return -ENOMEM;
 
                 for (i = 0; i < buf->nbufs; ++i) {
-                        buf->page_list[i].buf = dma_zalloc_coherent(dev,
-                                                                  page_size, &t,
-                                                                  GFP_KERNEL);
+                        buf->page_list[i].buf = dma_alloc_coherent(dev,
+                                                                   page_size,
+                                                                   &t,
+                                                                   GFP_KERNEL);
 
                         if (!buf->page_list[i].buf)
                                 goto err_free;
diff --git a/drivers/infiniband/hw/hns/hns_roce_hw_v2.c b/drivers/infiniband/hw/hns/hns_roce_hw_v2.c
index 3a669451cf86..543fa1504cd3 100644
--- a/drivers/infiniband/hw/hns/hns_roce_hw_v2.c
+++ b/drivers/infiniband/hw/hns/hns_roce_hw_v2.c
@@ -5091,7 +5091,7 @@ static int hns_roce_mhop_alloc_eq(struct hns_roce_dev *hr_dev,
                                 eqe_alloc = i * (buf_chk_sz / eq->eqe_size);
                                 size = (eq->entries - eqe_alloc) * eq->eqe_size;
                         }
-                        eq->buf[i] = dma_zalloc_coherent(dev, size,
+                        eq->buf[i] = dma_alloc_coherent(dev, size,
                                                         &(eq->buf_dma[i]),
                                                         GFP_KERNEL);
                         if (!eq->buf[i])
@@ -5126,9 +5126,9 @@ static int hns_roce_mhop_alloc_eq(struct hns_roce_dev *hr_dev,
                                         size = (eq->entries - eqe_alloc)
                                                 * eq->eqe_size;
                                 }
-                                eq->buf[idx] = dma_zalloc_coherent(dev, size,
-                                                            &(eq->buf_dma[idx]),
-                                                            GFP_KERNEL);
+                                eq->buf[idx] = dma_alloc_coherent(dev, size,
+                                                                  &(eq->buf_dma[idx]),
+                                                                  GFP_KERNEL);
                                 if (!eq->buf[idx])
                                         goto err_dma_alloc_buf;
 
@@ -5241,7 +5241,7 @@ static int hns_roce_v2_create_eq(struct hns_roce_dev *hr_dev,
                         goto free_cmd_mbox;
                 }
 
-                eq->buf_list->buf = dma_zalloc_coherent(dev, buf_chk_sz,
+                eq->buf_list->buf = dma_alloc_coherent(dev, buf_chk_sz,
                                                        &(eq->buf_list->map),
                                                        GFP_KERNEL);
                 if (!eq->buf_list->buf) {
diff --git a/drivers/infiniband/hw/i40iw/i40iw_utils.c b/drivers/infiniband/hw/i40iw/i40iw_utils.c
index a9ea966877f2..59e978141ad4 100644
--- a/drivers/infiniband/hw/i40iw/i40iw_utils.c
+++ b/drivers/infiniband/hw/i40iw/i40iw_utils.c
@@ -745,8 +745,8 @@ enum i40iw_status_code i40iw_allocate_dma_mem(struct i40iw_hw *hw,
         if (!mem)
                 return I40IW_ERR_PARAM;
         mem->size = ALIGN(size, alignment);
-        mem->va = dma_zalloc_coherent(&pcidev->dev, mem->size,
-                                      (dma_addr_t *)&mem->pa, GFP_KERNEL);
+        mem->va = dma_alloc_coherent(&pcidev->dev, mem->size,
+                                     (dma_addr_t *)&mem->pa, GFP_KERNEL);
         if (!mem->va)
                 return I40IW_ERR_NO_MEMORY;
         return 0;
diff --git a/drivers/infiniband/hw/mthca/mthca_memfree.c b/drivers/infiniband/hw/mthca/mthca_memfree.c
index cc9c0c8ccba3..112d2f38e0de 100644
--- a/drivers/infiniband/hw/mthca/mthca_memfree.c
+++ b/drivers/infiniband/hw/mthca/mthca_memfree.c
@@ -623,8 +623,9 @@ int mthca_alloc_db(struct mthca_dev *dev, enum mthca_db_type type,
         page = dev->db_tab->page + end;
 
 alloc:
-        page->db_rec = dma_zalloc_coherent(&dev->pdev->dev, MTHCA_ICM_PAGE_SIZE,
-                                           &page->mapping, GFP_KERNEL);
+        page->db_rec = dma_alloc_coherent(&dev->pdev->dev,
+                                          MTHCA_ICM_PAGE_SIZE, &page->mapping,
+                                          GFP_KERNEL);
         if (!page->db_rec) {
                 ret = -ENOMEM;
                 goto out;
diff --git a/drivers/infiniband/hw/mthca/mthca_provider.c b/drivers/infiniband/hw/mthca/mthca_provider.c
index 82cb6b71ac7c..e3e9dd54caa2 100644
--- a/drivers/infiniband/hw/mthca/mthca_provider.c
+++ b/drivers/infiniband/hw/mthca/mthca_provider.c
@@ -534,7 +534,7 @@ static struct ib_qp *mthca_create_qp(struct ib_pd *pd,
         {
                 struct mthca_ucontext *context;
 
-                qp = kmalloc(sizeof *qp, GFP_KERNEL);
+                qp = kzalloc(sizeof(*qp), GFP_KERNEL);
                 if (!qp)
                         return ERR_PTR(-ENOMEM);
 
@@ -600,7 +600,7 @@ static struct ib_qp *mthca_create_qp(struct ib_pd *pd,
                 if (udata)
                         return ERR_PTR(-EINVAL);
 
-                qp = kmalloc(sizeof (struct mthca_sqp), GFP_KERNEL);
+                qp = kzalloc(sizeof(struct mthca_sqp), GFP_KERNEL);
                 if (!qp)
                         return ERR_PTR(-ENOMEM);
 
diff --git a/drivers/infiniband/hw/ocrdma/ocrdma_hw.c b/drivers/infiniband/hw/ocrdma/ocrdma_hw.c
index 241a57a07485..097e5ab2a19f 100644
--- a/drivers/infiniband/hw/ocrdma/ocrdma_hw.c
+++ b/drivers/infiniband/hw/ocrdma/ocrdma_hw.c
@@ -380,8 +380,8 @@ static int ocrdma_alloc_q(struct ocrdma_dev *dev,
         q->len = len;
         q->entry_size = entry_size;
         q->size = len * entry_size;
-        q->va = dma_zalloc_coherent(&dev->nic_info.pdev->dev, q->size,
-                                    &q->dma, GFP_KERNEL);
+        q->va = dma_alloc_coherent(&dev->nic_info.pdev->dev, q->size, &q->dma,
+                                   GFP_KERNEL);
         if (!q->va)
                 return -ENOMEM;
         return 0;
@@ -1819,7 +1819,7 @@ int ocrdma_mbx_create_cq(struct ocrdma_dev *dev, struct ocrdma_cq *cq,
                 return -ENOMEM;
         ocrdma_init_mch(&cmd->cmd.req, OCRDMA_CMD_CREATE_CQ,
                         OCRDMA_SUBSYS_COMMON, sizeof(*cmd));
-        cq->va = dma_zalloc_coherent(&pdev->dev, cq->len, &cq->pa, GFP_KERNEL);
+        cq->va = dma_alloc_coherent(&pdev->dev, cq->len, &cq->pa, GFP_KERNEL);
         if (!cq->va) {
                 status = -ENOMEM;
                 goto mem_err;
@@ -2209,7 +2209,7 @@ static int ocrdma_set_create_qp_sq_cmd(struct ocrdma_create_qp_req *cmd,
         qp->sq.max_cnt = max_wqe_allocated;
         len = (hw_pages * hw_page_size);
 
-        qp->sq.va = dma_zalloc_coherent(&pdev->dev, len, &pa, GFP_KERNEL);
+        qp->sq.va = dma_alloc_coherent(&pdev->dev, len, &pa, GFP_KERNEL);
         if (!qp->sq.va)
                 return -EINVAL;
         qp->sq.len = len;
@@ -2259,7 +2259,7 @@ static int ocrdma_set_create_qp_rq_cmd(struct ocrdma_create_qp_req *cmd,
         qp->rq.max_cnt = max_rqe_allocated;
         len = (hw_pages * hw_page_size);
 
-        qp->rq.va = dma_zalloc_coherent(&pdev->dev, len, &pa, GFP_KERNEL);
+        qp->rq.va = dma_alloc_coherent(&pdev->dev, len, &pa, GFP_KERNEL);
         if (!qp->rq.va)
                 return -ENOMEM;
         qp->rq.pa = pa;
@@ -2315,8 +2315,8 @@ static int ocrdma_set_create_qp_ird_cmd(struct ocrdma_create_qp_req *cmd,
         if (dev->attr.ird == 0)
                 return 0;
 
-        qp->ird_q_va = dma_zalloc_coherent(&pdev->dev, ird_q_len, &pa,
-                                           GFP_KERNEL);
+        qp->ird_q_va = dma_alloc_coherent(&pdev->dev, ird_q_len, &pa,
+                                          GFP_KERNEL);
         if (!qp->ird_q_va)
                 return -ENOMEM;
         ocrdma_build_q_pages(&cmd->ird_addr[0], dev->attr.num_ird_pages,
diff --git a/drivers/infiniband/hw/ocrdma/ocrdma_stats.c b/drivers/infiniband/hw/ocrdma/ocrdma_stats.c
index dd15474b19b7..6be0ea109138 100644
--- a/drivers/infiniband/hw/ocrdma/ocrdma_stats.c
+++ b/drivers/infiniband/hw/ocrdma/ocrdma_stats.c
@@ -73,8 +73,8 @@ bool ocrdma_alloc_stats_resources(struct ocrdma_dev *dev)
         mem->size = max_t(u32, sizeof(struct ocrdma_rdma_stats_req),
                         sizeof(struct ocrdma_rdma_stats_resp));
 
-        mem->va = dma_zalloc_coherent(&dev->nic_info.pdev->dev, mem->size,
-                                      &mem->pa, GFP_KERNEL);
+        mem->va = dma_alloc_coherent(&dev->nic_info.pdev->dev, mem->size,
+                                     &mem->pa, GFP_KERNEL);
         if (!mem->va) {
                 pr_err("%s: stats mbox allocation failed\n", __func__);
                 return false;
diff --git a/drivers/infiniband/hw/ocrdma/ocrdma_verbs.c b/drivers/infiniband/hw/ocrdma/ocrdma_verbs.c
index c46bed0c5513..287c332ff0e6 100644
--- a/drivers/infiniband/hw/ocrdma/ocrdma_verbs.c
+++ b/drivers/infiniband/hw/ocrdma/ocrdma_verbs.c
@@ -504,8 +504,8 @@ struct ib_ucontext *ocrdma_alloc_ucontext(struct ib_device *ibdev,
         INIT_LIST_HEAD(&ctx->mm_head);
         mutex_init(&ctx->mm_list_lock);
 
-        ctx->ah_tbl.va = dma_zalloc_coherent(&pdev->dev, map_len,
-                                             &ctx->ah_tbl.pa, GFP_KERNEL);
+        ctx->ah_tbl.va = dma_alloc_coherent(&pdev->dev, map_len,
+                                            &ctx->ah_tbl.pa, GFP_KERNEL);
         if (!ctx->ah_tbl.va) {
                 kfree(ctx);
                 return ERR_PTR(-ENOMEM);
@@ -838,7 +838,7 @@ static int ocrdma_build_pbl_tbl(struct ocrdma_dev *dev, struct ocrdma_hw_mr *mr)
                 return -ENOMEM;
 
         for (i = 0; i < mr->num_pbls; i++) {
-                va = dma_zalloc_coherent(&pdev->dev, dma_len, &pa, GFP_KERNEL);
+                va = dma_alloc_coherent(&pdev->dev, dma_len, &pa, GFP_KERNEL);
                 if (!va) {
                         ocrdma_free_mr_pbl_tbl(dev, mr);
                         status = -ENOMEM;
diff --git a/drivers/infiniband/hw/qedr/verbs.c b/drivers/infiniband/hw/qedr/verbs.c
index b342a70e2814..e1ccf32b1c3d 100644
--- a/drivers/infiniband/hw/qedr/verbs.c
+++ b/drivers/infiniband/hw/qedr/verbs.c
@@ -556,8 +556,8 @@ static struct qedr_pbl *qedr_alloc_pbl_tbl(struct qedr_dev *dev,
                 return ERR_PTR(-ENOMEM);
 
         for (i = 0; i < pbl_info->num_pbls; i++) {
-                va = dma_zalloc_coherent(&pdev->dev, pbl_info->pbl_size,
-                                         &pa, flags);
+                va = dma_alloc_coherent(&pdev->dev, pbl_info->pbl_size, &pa,
+                                        flags);
                 if (!va)
                         goto err;
 
diff --git a/drivers/infiniband/hw/vmw_pvrdma/pvrdma.h b/drivers/infiniband/hw/vmw_pvrdma/pvrdma.h
index 42b8685c997e..3c633ab58052 100644
--- a/drivers/infiniband/hw/vmw_pvrdma/pvrdma.h
+++ b/drivers/infiniband/hw/vmw_pvrdma/pvrdma.h
@@ -427,7 +427,40 @@ static inline enum ib_qp_state pvrdma_qp_state_to_ib(enum pvrdma_qp_state state)
 
 static inline enum pvrdma_wr_opcode ib_wr_opcode_to_pvrdma(enum ib_wr_opcode op)
 {
-        return (enum pvrdma_wr_opcode)op;
+        switch (op) {
+        case IB_WR_RDMA_WRITE:
+                return PVRDMA_WR_RDMA_WRITE;
+        case IB_WR_RDMA_WRITE_WITH_IMM:
+                return PVRDMA_WR_RDMA_WRITE_WITH_IMM;
+        case IB_WR_SEND:
+                return PVRDMA_WR_SEND;
+        case IB_WR_SEND_WITH_IMM:
+                return PVRDMA_WR_SEND_WITH_IMM;
+        case IB_WR_RDMA_READ:
+                return PVRDMA_WR_RDMA_READ;
+        case IB_WR_ATOMIC_CMP_AND_SWP:
+                return PVRDMA_WR_ATOMIC_CMP_AND_SWP;
+        case IB_WR_ATOMIC_FETCH_AND_ADD:
+                return PVRDMA_WR_ATOMIC_FETCH_AND_ADD;
+        case IB_WR_LSO:
+                return PVRDMA_WR_LSO;
+        case IB_WR_SEND_WITH_INV:
+                return PVRDMA_WR_SEND_WITH_INV;
+        case IB_WR_RDMA_READ_WITH_INV:
+                return PVRDMA_WR_RDMA_READ_WITH_INV;
+        case IB_WR_LOCAL_INV:
+                return PVRDMA_WR_LOCAL_INV;
+        case IB_WR_REG_MR:
+                return PVRDMA_WR_FAST_REG_MR;
+        case IB_WR_MASKED_ATOMIC_CMP_AND_SWP:
+                return PVRDMA_WR_MASKED_ATOMIC_CMP_AND_SWP;
+        case IB_WR_MASKED_ATOMIC_FETCH_AND_ADD:
+                return PVRDMA_WR_MASKED_ATOMIC_FETCH_AND_ADD;
+        case IB_WR_REG_SIG_MR:
+                return PVRDMA_WR_REG_SIG_MR;
+        default:
+                return PVRDMA_WR_ERROR;
+        }
 }
 
 static inline enum ib_wc_status pvrdma_wc_status_to_ib(
diff --git a/drivers/infiniband/hw/vmw_pvrdma/pvrdma_main.c b/drivers/infiniband/hw/vmw_pvrdma/pvrdma_main.c
index eaa109dbc96a..39c37b6fd715 100644
--- a/drivers/infiniband/hw/vmw_pvrdma/pvrdma_main.c
+++ b/drivers/infiniband/hw/vmw_pvrdma/pvrdma_main.c
@@ -890,8 +890,8 @@ static int pvrdma_pci_probe(struct pci_dev *pdev,
         dev_info(&pdev->dev, "device version %d, driver version %d\n",
                  dev->dsr_version, PVRDMA_VERSION);
 
-        dev->dsr = dma_zalloc_coherent(&pdev->dev, sizeof(*dev->dsr),
-                                       &dev->dsrbase, GFP_KERNEL);
+        dev->dsr = dma_alloc_coherent(&pdev->dev, sizeof(*dev->dsr),
+                                      &dev->dsrbase, GFP_KERNEL);
         if (!dev->dsr) {
                 dev_err(&pdev->dev, "failed to allocate shared region\n");
                 ret = -ENOMEM;
diff --git a/drivers/infiniband/hw/vmw_pvrdma/pvrdma_qp.c b/drivers/infiniband/hw/vmw_pvrdma/pvrdma_qp.c
index 3acf74cbe266..1ec3646087ba 100644
--- a/drivers/infiniband/hw/vmw_pvrdma/pvrdma_qp.c
+++ b/drivers/infiniband/hw/vmw_pvrdma/pvrdma_qp.c
@@ -721,6 +721,12 @@ int pvrdma_post_send(struct ib_qp *ibqp, const struct ib_send_wr *wr,
                     wr->opcode == IB_WR_RDMA_WRITE_WITH_IMM)
                         wqe_hdr->ex.imm_data = wr->ex.imm_data;
 
+                if (unlikely(wqe_hdr->opcode == PVRDMA_WR_ERROR)) {
+                        *bad_wr = wr;
+                        ret = -EINVAL;
+                        goto out;
+                }
+
                 switch (qp->ibqp.qp_type) {
                 case IB_QPT_GSI:
                 case IB_QPT_UD:
diff --git a/drivers/input/joystick/xpad.c b/drivers/input/joystick/xpad.c
index cfc8b94527b9..aa4e431cbcd3 100644
--- a/drivers/input/joystick/xpad.c
+++ b/drivers/input/joystick/xpad.c
@@ -252,6 +252,8 @@ static const struct xpad_device {
         { 0x0f30, 0x0202, "Joytech Advanced Controller", 0, XTYPE_XBOX },
         { 0x0f30, 0x8888, "BigBen XBMiniPad Controller", 0, XTYPE_XBOX },
         { 0x102c, 0xff0c, "Joytech Wireless Advanced Controller", 0, XTYPE_XBOX },
+        { 0x1038, 0x1430, "SteelSeries Stratus Duo", 0, XTYPE_XBOX360 },
+        { 0x1038, 0x1431, "SteelSeries Stratus Duo", 0, XTYPE_XBOX360 },
         { 0x11c9, 0x55f0, "Nacon GC-100XF", 0, XTYPE_XBOX360 },
         { 0x12ab, 0x0004, "Honey Bee Xbox360 dancepad", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX360 },
         { 0x12ab, 0x0301, "PDP AFTERGLOW AX.1", 0, XTYPE_XBOX360 },
@@ -428,6 +430,7 @@ static const struct usb_device_id xpad_table[] = {
         XPAD_XBOXONE_VENDOR(0x0e6f),            /* 0x0e6f X-Box One controllers */
         XPAD_XBOX360_VENDOR(0x0f0d),            /* Hori Controllers */
         XPAD_XBOXONE_VENDOR(0x0f0d),            /* Hori Controllers */
+        XPAD_XBOX360_VENDOR(0x1038),            /* SteelSeries Controllers */
         XPAD_XBOX360_VENDOR(0x11c9),            /* Nacon GC100XF */
         XPAD_XBOX360_VENDOR(0x12ab),            /* X-Box 360 dance pads */
         XPAD_XBOX360_VENDOR(0x1430),            /* RedOctane X-Box 360 controllers */
diff --git a/drivers/input/misc/uinput.c b/drivers/input/misc/uinput.c
index 8ec483e8688b..26ec603fe220 100644
--- a/drivers/input/misc/uinput.c
+++ b/drivers/input/misc/uinput.c
@@ -39,6 +39,7 @@
 #include <linux/init.h>
 #include <linux/fs.h>
 #include <linux/miscdevice.h>
+#include <linux/overflow.h>
 #include <linux/input/mt.h>
 #include "../input-compat.h"
 
@@ -405,7 +406,7 @@ static int uinput_open(struct inode *inode, struct file *file)
 static int uinput_validate_absinfo(struct input_dev *dev, unsigned int code,
                                    const struct input_absinfo *abs)
 {
-        int min, max;
+        int min, max, range;
 
         min = abs->minimum;
         max = abs->maximum;
@@ -417,7 +418,7 @@ static int uinput_validate_absinfo(struct input_dev *dev, unsigned int code,
                 return -EINVAL;
         }
 
-        if (abs->flat > max - min) {
+        if (!check_sub_overflow(max, min, &range) && abs->flat > range) {
                 printk(KERN_DEBUG
                        "%s: abs_flat #%02x out of range: %d (min:%d/max:%d)\n",
                        UINPUT_NAME, code, abs->flat, min, max);
diff --git a/drivers/input/serio/olpc_apsp.c b/drivers/input/serio/olpc_apsp.c
index b36084710f69..bae08226e3d9 100644
--- a/drivers/input/serio/olpc_apsp.c
+++ b/drivers/input/serio/olpc_apsp.c
@@ -195,6 +195,8 @@ static int olpc_apsp_probe(struct platform_device *pdev)
         if (!priv)
                 return -ENOMEM;
 
+        priv->dev = &pdev->dev;
+
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         priv->base = devm_ioremap_resource(&pdev->dev, res);
         if (IS_ERR(priv->base)) {
@@ -248,7 +250,6 @@ static int olpc_apsp_probe(struct platform_device *pdev)
                 goto err_irq;
         }
 
-        priv->dev = &pdev->dev;
         device_init_wakeup(priv->dev, 1);
         platform_set_drvdata(pdev, priv);
 
diff --git a/drivers/input/touchscreen/Kconfig b/drivers/input/touchscreen/Kconfig
index af6027cc7bbf..068dbbc610fc 100644
--- a/drivers/input/touchscreen/Kconfig
+++ b/drivers/input/touchscreen/Kconfig
@@ -698,7 +698,7 @@ config TOUCHSCREEN_EDT_FT5X06
 
 config TOUCHSCREEN_RASPBERRYPI_FW
         tristate "Raspberry Pi's firmware base touch screen support"
-        depends on RASPBERRYPI_FIRMWARE || COMPILE_TEST
+        depends on RASPBERRYPI_FIRMWARE || (RASPBERRYPI_FIRMWARE=n && COMPILE_TEST)
         help
           Say Y here if you have the official Raspberry Pi 7 inch screen on
           your system.
diff --git a/drivers/input/touchscreen/raspberrypi-ts.c b/drivers/input/touchscreen/raspberrypi-ts.c
index f456c1125bd6..69881265d121 100644
--- a/drivers/input/touchscreen/raspberrypi-ts.c
+++ b/drivers/input/touchscreen/raspberrypi-ts.c
@@ -147,8 +147,8 @@ static int rpi_ts_probe(struct platform_device *pdev)
                 return -ENOMEM;
         ts->pdev = pdev;
 
-        ts->fw_regs_va = dma_zalloc_coherent(dev, PAGE_SIZE, &ts->fw_regs_phys,
-                                             GFP_KERNEL);
+        ts->fw_regs_va = dma_alloc_coherent(dev, PAGE_SIZE, &ts->fw_regs_phys,
+                                            GFP_KERNEL);
         if (!ts->fw_regs_va) {
                 dev_err(dev, "failed to dma_alloc_coherent\n");
                 return -ENOMEM;
diff --git a/drivers/iommu/mtk_iommu_v1.c b/drivers/iommu/mtk_iommu_v1.c
index 6ede4286b835..730f7dabcf37 100644
--- a/drivers/iommu/mtk_iommu_v1.c
+++ b/drivers/iommu/mtk_iommu_v1.c
@@ -232,9 +232,8 @@ static int mtk_iommu_domain_finalise(struct mtk_iommu_data *data)
 
         spin_lock_init(&dom->pgtlock);
 
-        dom->pgt_va = dma_zalloc_coherent(data->dev,
-                                M2701_IOMMU_PGT_SIZE,
-                                &dom->pgt_pa, GFP_KERNEL);
+        dom->pgt_va = dma_alloc_coherent(data->dev, M2701_IOMMU_PGT_SIZE,
+                                         &dom->pgt_pa, GFP_KERNEL);
         if (!dom->pgt_va)
                 return -ENOMEM;
 
diff --git a/drivers/iommu/of_iommu.c b/drivers/iommu/of_iommu.c
index d8947b28db2d..f04a6df65eb8 100644
--- a/drivers/iommu/of_iommu.c
+++ b/drivers/iommu/of_iommu.c
@@ -224,7 +224,7 @@ const struct iommu_ops *of_iommu_configure(struct device *dev,
          * If we have reason to believe the IOMMU driver missed the initial
          * probe for dev, replay it to get things in order.
          */
-        if (dev->bus && !device_iommu_mapped(dev))
+        if (!err && dev->bus && !device_iommu_mapped(dev))
                 err = iommu_probe_device(dev);
 
         /* Ignore all other errors apart from EPROBE_DEFER */
diff --git a/drivers/irqchip/irq-csky-apb-intc.c b/drivers/irqchip/irq-csky-apb-intc.c
index 2543baba8b1f..5a2ec43b7ddd 100644
--- a/drivers/irqchip/irq-csky-apb-intc.c
+++ b/drivers/irqchip/irq-csky-apb-intc.c
@@ -95,7 +95,7 @@ static inline void setup_irq_channel(u32 magic, void __iomem *reg_addr)
 
         /* Setup 64 channel slots */
         for (i = 0; i < INTC_IRQS; i += 4)
-                writel_relaxed(build_channel_val(i, magic), reg_addr + i);
+                writel(build_channel_val(i, magic), reg_addr + i);
 }
 
 static int __init
@@ -135,16 +135,10 @@ ck_intc_init_comm(struct device_node *node, struct device_node *parent)
 static inline bool handle_irq_perbit(struct pt_regs *regs, u32 hwirq,
                                      u32 irq_base)
 {
-        u32 irq;
-
         if (hwirq == 0)
                 return 0;
 
-        while (hwirq) {
-                irq = __ffs(hwirq);
-                hwirq &= ~BIT(irq);
-                handle_domain_irq(root_domain, irq_base + irq, regs);
-        }
+        handle_domain_irq(root_domain, irq_base + __fls(hwirq), regs);
 
         return 1;
 }
@@ -154,12 +148,16 @@ static void gx_irq_handler(struct pt_regs *regs)
 {
         bool ret;
 
-        do {
-                ret  = handle_irq_perbit(regs,
-                                readl_relaxed(reg_base + GX_INTC_PEN31_00), 0);
-                ret |= handle_irq_perbit(regs,
-                                readl_relaxed(reg_base + GX_INTC_PEN63_32), 32);
-        } while (ret);
+retry:
+        ret = handle_irq_perbit(regs,
+                        readl(reg_base + GX_INTC_PEN63_32), 32);
+        if (ret)
+                goto retry;
+
+        ret = handle_irq_perbit(regs,
+                        readl(reg_base + GX_INTC_PEN31_00), 0);
+        if (ret)
+                goto retry;
 }
 
 static int __init
@@ -174,14 +172,14 @@ gx_intc_init(struct device_node *node, struct device_node *parent)
         /*
          * Initial enable reg to disable all interrupts
          */
-        writel_relaxed(0x0, reg_base + GX_INTC_NEN31_00);
-        writel_relaxed(0x0, reg_base + GX_INTC_NEN63_32);
+        writel(0x0, reg_base + GX_INTC_NEN31_00);
+        writel(0x0, reg_base + GX_INTC_NEN63_32);
 
         /*
          * Initial mask reg with all unmasked, because we only use enalbe reg
          */
-        writel_relaxed(0x0, reg_base + GX_INTC_NMASK31_00);
-        writel_relaxed(0x0, reg_base + GX_INTC_NMASK63_32);
+        writel(0x0, reg_base + GX_INTC_NMASK31_00);
+        writel(0x0, reg_base + GX_INTC_NMASK63_32);
 
         setup_irq_channel(0x03020100, reg_base + GX_INTC_SOURCE);
 
@@ -204,20 +202,29 @@ static void ck_irq_handler(struct pt_regs *regs)
         void __iomem *reg_pen_lo = reg_base + CK_INTC_PEN31_00;
         void __iomem *reg_pen_hi = reg_base + CK_INTC_PEN63_32;
 
-        do {
-                /* handle 0 - 31 irqs */
-                ret  = handle_irq_perbit(regs, readl_relaxed(reg_pen_lo), 0);
-                ret |= handle_irq_perbit(regs, readl_relaxed(reg_pen_hi), 32);
+retry:
+        /* handle 0 - 63 irqs */
+        ret = handle_irq_perbit(regs, readl(reg_pen_hi), 32);
+        if (ret)
+                goto retry;
 
-                if (nr_irq == INTC_IRQS)
-                        continue;
+        ret = handle_irq_perbit(regs, readl(reg_pen_lo), 0);
+        if (ret)
+                goto retry;
+
+        if (nr_irq == INTC_IRQS)
+                return;
 
-                /* handle 64 - 127 irqs */
-                ret |= handle_irq_perbit(regs,
-                        readl_relaxed(reg_pen_lo + CK_INTC_DUAL_BASE), 64);
-                ret |= handle_irq_perbit(regs,
-                        readl_relaxed(reg_pen_hi + CK_INTC_DUAL_BASE), 96);
-        } while (ret);
+        /* handle 64 - 127 irqs */
+        ret = handle_irq_perbit(regs,
+                        readl(reg_pen_hi + CK_INTC_DUAL_BASE), 96);
+        if (ret)
+                goto retry;
+
+        ret = handle_irq_perbit(regs,
+                        readl(reg_pen_lo + CK_INTC_DUAL_BASE), 64);
+        if (ret)
+                goto retry;
 }
 
 static int __init
@@ -230,11 +237,11 @@ ck_intc_init(struct device_node *node, struct device_node *parent)
                 return ret;
 
         /* Initial enable reg to disable all interrupts */
-        writel_relaxed(0, reg_base + CK_INTC_NEN31_00);
-        writel_relaxed(0, reg_base + CK_INTC_NEN63_32);
+        writel(0, reg_base + CK_INTC_NEN31_00);
+        writel(0, reg_base + CK_INTC_NEN63_32);
 
         /* Enable irq intc */
-        writel_relaxed(BIT(31), reg_base + CK_INTC_ICR);
+        writel(BIT(31), reg_base + CK_INTC_ICR);
 
         ck_set_gc(node, reg_base, CK_INTC_NEN31_00, 0);
         ck_set_gc(node, reg_base, CK_INTC_NEN63_32, 32);
@@ -260,8 +267,8 @@ ck_dual_intc_init(struct device_node *node, struct device_node *parent)
                 return ret;
 
         /* Initial enable reg to disable all interrupts */
-        writel_relaxed(0, reg_base + CK_INTC_NEN31_00 + CK_INTC_DUAL_BASE);
-        writel_relaxed(0, reg_base + CK_INTC_NEN63_32 + CK_INTC_DUAL_BASE);
+        writel(0, reg_base + CK_INTC_NEN31_00 + CK_INTC_DUAL_BASE);
+        writel(0, reg_base + CK_INTC_NEN63_32 + CK_INTC_DUAL_BASE);
 
         ck_set_gc(node, reg_base + CK_INTC_DUAL_BASE, CK_INTC_NEN31_00, 64);
         ck_set_gc(node, reg_base + CK_INTC_DUAL_BASE, CK_INTC_NEN63_32, 96);
diff --git a/drivers/irqchip/irq-gic-v3-its.c b/drivers/irqchip/irq-gic-v3-its.c
index db20e992a40f..7f2a45445b00 100644
--- a/drivers/irqchip/irq-gic-v3-its.c
+++ b/drivers/irqchip/irq-gic-v3-its.c
@@ -2399,13 +2399,14 @@ static void its_free_device(struct its_device *its_dev)
         kfree(its_dev);
 }
 
-static int its_alloc_device_irq(struct its_device *dev, irq_hw_number_t *hwirq)
+static int its_alloc_device_irq(struct its_device *dev, int nvecs, irq_hw_number_t *hwirq)
 {
         int idx;
 
-        idx = find_first_zero_bit(dev->event_map.lpi_map,
-                                  dev->event_map.nr_lpis);
-        if (idx == dev->event_map.nr_lpis)
+        idx = bitmap_find_free_region(dev->event_map.lpi_map,
+                                      dev->event_map.nr_lpis,
+                                      get_count_order(nvecs));
+        if (idx < 0)
                 return -ENOSPC;
 
         *hwirq = dev->event_map.lpi_base + idx;
@@ -2501,21 +2502,21 @@ static int its_irq_domain_alloc(struct irq_domain *domain, unsigned int virq,
         int err;
         int i;
 
-        for (i = 0; i < nr_irqs; i++) {
-                err = its_alloc_device_irq(its_dev, &hwirq);
-                if (err)
-                        return err;
+        err = its_alloc_device_irq(its_dev, nr_irqs, &hwirq);
+        if (err)
+                return err;
 
-                err = its_irq_gic_domain_alloc(domain, virq + i, hwirq);
+        for (i = 0; i < nr_irqs; i++) {
+                err = its_irq_gic_domain_alloc(domain, virq + i, hwirq + i);
                 if (err)
                         return err;
 
                 irq_domain_set_hwirq_and_chip(domain, virq + i,
-                                              hwirq, &its_irq_chip, its_dev);
+                                              hwirq + i, &its_irq_chip, its_dev);
                 irqd_set_single_target(irq_desc_get_irq_data(irq_to_desc(virq + i)));
                 pr_debug("ID:%d pID:%d vID:%d\n",
-                         (int)(hwirq - its_dev->event_map.lpi_base),
-                         (int) hwirq, virq + i);
+                         (int)(hwirq + i - its_dev->event_map.lpi_base),
+                         (int)(hwirq + i), virq + i);
         }
 
         return 0;
diff --git a/drivers/irqchip/irq-gic-v3-mbi.c b/drivers/irqchip/irq-gic-v3-mbi.c
index ad70e7c416e3..fbfa7ff6deb1 100644
--- a/drivers/irqchip/irq-gic-v3-mbi.c
+++ b/drivers/irqchip/irq-gic-v3-mbi.c
@@ -24,7 +24,7 @@ struct mbi_range {
         unsigned long           *bm;
 };
 
-static struct mutex             mbi_lock;
+static DEFINE_MUTEX(mbi_lock);
 static phys_addr_t              mbi_phys_base;
 static struct mbi_range         *mbi_ranges;
 static unsigned int             mbi_range_nr;
diff --git a/drivers/irqchip/irq-madera.c b/drivers/irqchip/irq-madera.c
index e9256dee1a45..8b81271c823c 100644
--- a/drivers/irqchip/irq-madera.c
+++ b/drivers/irqchip/irq-madera.c
@@ -7,7 +7,6 @@
  */
 
 #include <linux/module.h>
-#include <linux/gpio.h>
 #include <linux/interrupt.h>
 #include <linux/irq.h>
 #include <linux/irqdomain.h>
@@ -16,7 +15,6 @@
 #include <linux/slab.h>
 #include <linux/of.h>
 #include <linux/of_device.h>
-#include <linux/of_gpio.h>
 #include <linux/of_irq.h>
 #include <linux/irqchip/irq-madera.h>
 #include <linux/mfd/madera/core.h>
diff --git a/drivers/irqchip/irq-stm32-exti.c b/drivers/irqchip/irq-stm32-exti.c
index 6edfd4bfa169..a93296b9b45d 100644
--- a/drivers/irqchip/irq-stm32-exti.c
+++ b/drivers/irqchip/irq-stm32-exti.c
@@ -822,6 +822,7 @@ out_unmap:
 static const struct irq_domain_ops stm32_exti_h_domain_ops = {
         .alloc  = stm32_exti_h_domain_alloc,
         .free   = irq_domain_free_irqs_common,
+        .xlate = irq_domain_xlate_twocell,
 };
 
 static int
diff --git a/drivers/isdn/hardware/avm/b1.c b/drivers/isdn/hardware/avm/b1.c
index 4ac378e48902..40ca1e8fa09f 100644
--- a/drivers/isdn/hardware/avm/b1.c
+++ b/drivers/isdn/hardware/avm/b1.c
@@ -423,7 +423,7 @@ void b1_parse_version(avmctrl_info *cinfo)
         int i, j;
 
         for (j = 0; j < AVM_MAXVERSION; j++)
-                cinfo->version[j] = "\0\0" + 1;
+                cinfo->version[j] = "";
         for (i = 0, j = 0;
              j < AVM_MAXVERSION && i < cinfo->versionlen;
              j++, i += cinfo->versionbuf[i] + 1)
diff --git a/drivers/isdn/hardware/mISDN/hfcsusb.c b/drivers/isdn/hardware/mISDN/hfcsusb.c
index 6d05946b445e..124ff530da82 100644
--- a/drivers/isdn/hardware/mISDN/hfcsusb.c
+++ b/drivers/isdn/hardware/mISDN/hfcsusb.c
@@ -262,8 +262,7 @@ hfcsusb_ph_info(struct hfcsusb *hw)
         struct dchannel *dch = &hw->dch;
         int i;
 
-        phi = kzalloc(sizeof(struct ph_info) +
-                      dch->dev.nrbchan * sizeof(struct ph_info_ch), GFP_ATOMIC);
+        phi = kzalloc(struct_size(phi, bch, dch->dev.nrbchan), GFP_ATOMIC);
         phi->dch.ch.protocol = hw->protocol;
         phi->dch.ch.Flags = dch->Flags;
         phi->dch.state = dch->state;
diff --git a/drivers/isdn/i4l/isdn_tty.c b/drivers/isdn/i4l/isdn_tty.c
index 1b2239c1d569..dc1cded716c1 100644
--- a/drivers/isdn/i4l/isdn_tty.c
+++ b/drivers/isdn/i4l/isdn_tty.c
@@ -1437,15 +1437,19 @@ isdn_tty_set_termios(struct tty_struct *tty, struct ktermios *old_termios)
 {
         modem_info *info = (modem_info *) tty->driver_data;
 
+        mutex_lock(&modem_info_mutex);
         if (!old_termios)
                 isdn_tty_change_speed(info);
         else {
                 if (tty->termios.c_cflag == old_termios->c_cflag &&
                     tty->termios.c_ispeed == old_termios->c_ispeed &&
-                    tty->termios.c_ospeed == old_termios->c_ospeed)
+                    tty->termios.c_ospeed == old_termios->c_ospeed) {
+                        mutex_unlock(&modem_info_mutex);
                         return;
+                }
                 isdn_tty_change_speed(info);
         }
+        mutex_unlock(&modem_info_mutex);
 }
 
 /*
diff --git a/drivers/leds/leds-lp5523.c b/drivers/leds/leds-lp5523.c
index a2e74feee2b2..fd64df5a57a5 100644
--- a/drivers/leds/leds-lp5523.c
+++ b/drivers/leds/leds-lp5523.c
@@ -318,7 +318,9 @@ static int lp5523_init_program_engine(struct lp55xx_chip *chip)
 
         /* Let the programs run for couple of ms and check the engine status */
         usleep_range(3000, 6000);
-        lp55xx_read(chip, LP5523_REG_STATUS, &status);
+        ret = lp55xx_read(chip, LP5523_REG_STATUS, &status);
+        if (ret)
+                return ret;
         status &= LP5523_ENG_STATUS_MASK;
 
         if (status != LP5523_ENG_STATUS_MASK) {
diff --git a/drivers/md/dm-crypt.c b/drivers/md/dm-crypt.c
index 0ff22159a0ca..47d4e0d30bf0 100644
--- a/drivers/md/dm-crypt.c
+++ b/drivers/md/dm-crypt.c
@@ -2414,9 +2414,21 @@ static int crypt_ctr_cipher_new(struct dm_target *ti, char *cipher_in, char *key
          * capi:cipher_api_spec-iv:ivopts
          */
         tmp = &cipher_in[strlen("capi:")];
-        cipher_api = strsep(&tmp, "-");
-        *ivmode = strsep(&tmp, ":");
-        *ivopts = tmp;
+
+        /* Separate IV options if present, it can contain another '-' in hash name */
+        *ivopts = strrchr(tmp, ':');
+        if (*ivopts) {
+                **ivopts = '\0';
+                (*ivopts)++;
+        }
+        /* Parse IV mode */
+        *ivmode = strrchr(tmp, '-');
+        if (*ivmode) {
+                **ivmode = '\0';
+                (*ivmode)++;
+        }
+        /* The rest is crypto API spec */
+        cipher_api = tmp;
 
         if (*ivmode && !strcmp(*ivmode, "lmk"))
                 cc->tfms_count = 64;
@@ -2486,11 +2498,8 @@ static int crypt_ctr_cipher_old(struct dm_target *ti, char *cipher_in, char *key
                 goto bad_mem;
 
         chainmode = strsep(&tmp, "-");
-        *ivopts = strsep(&tmp, "-");
-        *ivmode = strsep(&*ivopts, ":");
-
-        if (tmp)
-                DMWARN("Ignoring unexpected additional cipher options");
+        *ivmode = strsep(&tmp, ":");
+        *ivopts = tmp;
 
         /*
          * For compatibility with the original dm-crypt mapping format, if
diff --git a/drivers/md/dm-thin-metadata.c b/drivers/md/dm-thin-metadata.c
index 20b0776e39ef..ed3caceaed07 100644
--- a/drivers/md/dm-thin-metadata.c
+++ b/drivers/md/dm-thin-metadata.c
@@ -1678,7 +1678,7 @@ int dm_thin_remove_range(struct dm_thin_device *td,
         return r;
 }
 
-int dm_pool_block_is_used(struct dm_pool_metadata *pmd, dm_block_t b, bool *result)
+int dm_pool_block_is_shared(struct dm_pool_metadata *pmd, dm_block_t b, bool *result)
 {
         int r;
         uint32_t ref_count;
@@ -1686,7 +1686,7 @@ int dm_pool_block_is_used(struct dm_pool_metadata *pmd, dm_block_t b, bool *resu
         down_read(&pmd->root_lock);
         r = dm_sm_get_count(pmd->data_sm, b, &ref_count);
         if (!r)
-                *result = (ref_count != 0);
+                *result = (ref_count > 1);
         up_read(&pmd->root_lock);
 
         return r;
diff --git a/drivers/md/dm-thin-metadata.h b/drivers/md/dm-thin-metadata.h
index 35e954ea20a9..f6be0d733c20 100644
--- a/drivers/md/dm-thin-metadata.h
+++ b/drivers/md/dm-thin-metadata.h
@@ -195,7 +195,7 @@ int dm_pool_get_metadata_dev_size(struct dm_pool_metadata *pmd,
 
 int dm_pool_get_data_dev_size(struct dm_pool_metadata *pmd, dm_block_t *result);
 
-int dm_pool_block_is_used(struct dm_pool_metadata *pmd, dm_block_t b, bool *result);
+int dm_pool_block_is_shared(struct dm_pool_metadata *pmd, dm_block_t b, bool *result);
 
 int dm_pool_inc_data_range(struct dm_pool_metadata *pmd, dm_block_t b, dm_block_t e);
 int dm_pool_dec_data_range(struct dm_pool_metadata *pmd, dm_block_t b, dm_block_t e);
diff --git a/drivers/md/dm-thin.c b/drivers/md/dm-thin.c
index dadd9696340c..ca8af21bf644 100644
--- a/drivers/md/dm-thin.c
+++ b/drivers/md/dm-thin.c
@@ -1048,7 +1048,7 @@ static void passdown_double_checking_shared_status(struct dm_thin_new_mapping *m
          * passdown we have to check that these blocks are now unused.
          */
         int r = 0;
-        bool used = true;
+        bool shared = true;
         struct thin_c *tc = m->tc;
         struct pool *pool = tc->pool;
         dm_block_t b = m->data_block, e, end = m->data_block + m->virt_end - m->virt_begin;
@@ -1058,11 +1058,11 @@ static void passdown_double_checking_shared_status(struct dm_thin_new_mapping *m
         while (b != end) {
                 /* find start of unmapped run */
                 for (; b < end; b++) {
-                        r = dm_pool_block_is_used(pool->pmd, b, &used);
+                        r = dm_pool_block_is_shared(pool->pmd, b, &shared);
                         if (r)
                                 goto out;
 
-                        if (!used)
+                        if (!shared)
                                 break;
                 }
 
@@ -1071,11 +1071,11 @@ static void passdown_double_checking_shared_status(struct dm_thin_new_mapping *m
 
                 /* find end of run */
                 for (e = b + 1; e != end; e++) {
-                        r = dm_pool_block_is_used(pool->pmd, e, &used);
+                        r = dm_pool_block_is_shared(pool->pmd, e, &shared);
                         if (r)
                                 goto out;
 
-                        if (used)
+                        if (shared)
                                 break;
                 }
 
diff --git a/drivers/md/dm.c b/drivers/md/dm.c
index d67c95ef8d7e..2b53c3841b53 100644
--- a/drivers/md/dm.c
+++ b/drivers/md/dm.c
@@ -1320,7 +1320,7 @@ static int clone_bio(struct dm_target_io *tio, struct bio *bio,
 
         __bio_clone_fast(clone, bio);
 
-        if (unlikely(bio_integrity(bio) != NULL)) {
+        if (bio_integrity(bio)) {
                 int r;
 
                 if (unlikely(!dm_target_has_integrity(tio->ti->type) &&
@@ -1336,11 +1336,7 @@ static int clone_bio(struct dm_target_io *tio, struct bio *bio,
                         return r;
         }
 
-        bio_advance(clone, to_bytes(sector - clone->bi_iter.bi_sector));
-        clone->bi_iter.bi_size = to_bytes(len);
-
-        if (unlikely(bio_integrity(bio) != NULL))
-                bio_integrity_trim(clone);
+        bio_trim(clone, sector - clone->bi_iter.bi_sector, len);
 
         return 0;
 }
@@ -1588,6 +1584,9 @@ static void init_clone_info(struct clone_info *ci, struct mapped_device *md,
         ci->sector = bio->bi_iter.bi_sector;
 }
 
+#define __dm_part_stat_sub(part, field, subnd)  \
+        (part_stat_get(part, field) -= (subnd))
+
 /*
  * Entry point to split a bio into clones and submit them to the targets.
  */
@@ -1642,7 +1641,21 @@ static blk_qc_t __split_and_process_bio(struct mapped_device *md,
                                 struct bio *b = bio_split(bio, bio_sectors(bio) - ci.sector_count,
                                                           GFP_NOIO, &md->queue->bio_split);
                                 ci.io->orig_bio = b;
+
+                                /*
+                                 * Adjust IO stats for each split, otherwise upon queue
+                                 * reentry there will be redundant IO accounting.
+                                 * NOTE: this is a stop-gap fix, a proper fix involves
+                                 * significant refactoring of DM core's bio splitting
+                                 * (by eliminating DM's splitting and just using bio_split)
+                                 */
+                                part_stat_lock();
+                                __dm_part_stat_sub(&dm_disk(md)->part0,
+                                                   sectors[op_stat_group(bio_op(bio))], ci.sector_count);
+                                part_stat_unlock();
+
                                 bio_chain(b, bio);
+                                trace_block_split(md->queue, b, bio->bi_iter.bi_sector);
                                 ret = generic_make_request(bio);
                                 break;
                         }
@@ -1713,6 +1726,15 @@ out:
         return ret;
 }
 
+static blk_qc_t dm_process_bio(struct mapped_device *md,
+                               struct dm_table *map, struct bio *bio)
+{
+        if (dm_get_md_type(md) == DM_TYPE_NVME_BIO_BASED)
+                return __process_bio(md, map, bio);
+        else
+                return __split_and_process_bio(md, map, bio);
+}
+
 static blk_qc_t dm_make_request(struct request_queue *q, struct bio *bio)
 {
         struct mapped_device *md = q->queuedata;
@@ -1733,10 +1755,7 @@ static blk_qc_t dm_make_request(struct request_queue *q, struct bio *bio)
                 return ret;
         }
 
-        if (dm_get_md_type(md) == DM_TYPE_NVME_BIO_BASED)
-                ret = __process_bio(md, map, bio);
-        else
-                ret = __split_and_process_bio(md, map, bio);
+        ret = dm_process_bio(md, map, bio);
 
         dm_put_live_table(md, srcu_idx);
         return ret;
@@ -2415,9 +2434,9 @@ static void dm_wq_work(struct work_struct *work)
                         break;
 
                 if (dm_request_based(md))
-                        generic_make_request(c);
+                        (void) generic_make_request(c);
                 else
-                        __split_and_process_bio(md, map, c);
+                        (void) dm_process_bio(md, map, c);
         }
 
         dm_put_live_table(md, srcu_idx);
diff --git a/drivers/md/md.c b/drivers/md/md.c
index fd4af4de03b4..05ffffb8b769 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -207,15 +207,10 @@ static bool create_on_open = true;
 struct bio *bio_alloc_mddev(gfp_t gfp_mask, int nr_iovecs,
                             struct mddev *mddev)
 {
-        struct bio *b;
-
         if (!mddev || !bioset_initialized(&mddev->bio_set))
                 return bio_alloc(gfp_mask, nr_iovecs);
 
-        b = bio_alloc_bioset(gfp_mask, nr_iovecs, &mddev->bio_set);
-        if (!b)
-                return NULL;
-        return b;
+        return bio_alloc_bioset(gfp_mask, nr_iovecs, &mddev->bio_set);
 }
 EXPORT_SYMBOL_GPL(bio_alloc_mddev);
 
diff --git a/drivers/media/pci/intel/ipu3/ipu3-cio2.c b/drivers/media/pci/intel/ipu3/ipu3-cio2.c
index 447baaebca44..cdb79ae2d8dc 100644
--- a/drivers/media/pci/intel/ipu3/ipu3-cio2.c
+++ b/drivers/media/pci/intel/ipu3/ipu3-cio2.c
@@ -218,8 +218,8 @@ static int cio2_fbpt_init(struct cio2_device *cio2, struct cio2_queue *q)
 {
         struct device *dev = &cio2->pci_dev->dev;
 
-        q->fbpt = dma_zalloc_coherent(dev, CIO2_FBPT_SIZE, &q->fbpt_bus_addr,
-                                      GFP_KERNEL);
+        q->fbpt = dma_alloc_coherent(dev, CIO2_FBPT_SIZE, &q->fbpt_bus_addr,
+                                     GFP_KERNEL);
         if (!q->fbpt)
                 return -ENOMEM;
 
diff --git a/drivers/media/platform/mtk-vcodec/mtk_vcodec_util.c b/drivers/media/platform/mtk-vcodec/mtk_vcodec_util.c
index e80123cba406..060c0ad6243a 100644
--- a/drivers/media/platform/mtk-vcodec/mtk_vcodec_util.c
+++ b/drivers/media/platform/mtk-vcodec/mtk_vcodec_util.c
@@ -49,7 +49,7 @@ int mtk_vcodec_mem_alloc(struct mtk_vcodec_ctx *data,
         struct mtk_vcodec_ctx *ctx = (struct mtk_vcodec_ctx *)data;
         struct device *dev = &ctx->dev->plat_dev->dev;
 
-        mem->va = dma_zalloc_coherent(dev, size, &mem->dma_addr, GFP_KERNEL);
+        mem->va = dma_alloc_coherent(dev, size, &mem->dma_addr, GFP_KERNEL);
         if (!mem->va) {
                 mtk_v4l2_err("%s dma_alloc size=%ld failed!", dev_name(dev),
                              size);
diff --git a/drivers/media/platform/vim2m.c b/drivers/media/platform/vim2m.c
index d01821a6906a..89d9c4c21037 100644
--- a/drivers/media/platform/vim2m.c
+++ b/drivers/media/platform/vim2m.c
@@ -807,7 +807,9 @@ static void vim2m_stop_streaming(struct vb2_queue *q)
         struct vb2_v4l2_buffer *vbuf;
         unsigned long flags;
 
-        cancel_delayed_work_sync(&dev->work_run);
+        if (v4l2_m2m_get_curr_priv(dev->m2m_dev) == ctx)
+                cancel_delayed_work_sync(&dev->work_run);
+
         for (;;) {
                 if (V4L2_TYPE_IS_OUTPUT(q->type))
                         vbuf = v4l2_m2m_src_buf_remove(ctx->fh.m2m_ctx);
diff --git a/drivers/media/v4l2-core/v4l2-ioctl.c b/drivers/media/v4l2-core/v4l2-ioctl.c
index 1441a73ce64c..90aad465f9ed 100644
--- a/drivers/media/v4l2-core/v4l2-ioctl.c
+++ b/drivers/media/v4l2-core/v4l2-ioctl.c
@@ -287,6 +287,7 @@ static void v4l_print_format(const void *arg, bool write_only)
         const struct v4l2_window *win;
         const struct v4l2_sdr_format *sdr;
         const struct v4l2_meta_format *meta;
+        u32 planes;
         unsigned i;
 
         pr_cont("type=%s", prt_names(p->type, v4l2_type_names));
@@ -317,7 +318,8 @@ static void v4l_print_format(const void *arg, bool write_only)
                         prt_names(mp->field, v4l2_field_names),
                         mp->colorspace, mp->num_planes, mp->flags,
                         mp->ycbcr_enc, mp->quantization, mp->xfer_func);
-                for (i = 0; i < mp->num_planes; i++)
+                planes = min_t(u32, mp->num_planes, VIDEO_MAX_PLANES);
+                for (i = 0; i < planes; i++)
                         printk(KERN_DEBUG "plane %u: bytesperline=%u sizeimage=%u\n", i,
                                         mp->plane_fmt[i].bytesperline,
                                         mp->plane_fmt[i].sizeimage);
@@ -1551,8 +1553,11 @@ static int v4l_s_fmt(const struct v4l2_ioctl_ops *ops,
                 if (unlikely(!ops->vidioc_s_fmt_vid_cap_mplane))
                         break;
                 CLEAR_AFTER_FIELD(p, fmt.pix_mp.xfer_func);
+                if (p->fmt.pix_mp.num_planes > VIDEO_MAX_PLANES)
+                        break;
                 for (i = 0; i < p->fmt.pix_mp.num_planes; i++)
-                        CLEAR_AFTER_FIELD(p, fmt.pix_mp.plane_fmt[i].bytesperline);
+                        CLEAR_AFTER_FIELD(&p->fmt.pix_mp.plane_fmt[i],
+                                          bytesperline);
                 return ops->vidioc_s_fmt_vid_cap_mplane(file, fh, arg);
         case V4L2_BUF_TYPE_VIDEO_OVERLAY:
                 if (unlikely(!ops->vidioc_s_fmt_vid_overlay))
@@ -1581,8 +1586,11 @@ static int v4l_s_fmt(const struct v4l2_ioctl_ops *ops,
                 if (unlikely(!ops->vidioc_s_fmt_vid_out_mplane))
                         break;
                 CLEAR_AFTER_FIELD(p, fmt.pix_mp.xfer_func);
+                if (p->fmt.pix_mp.num_planes > VIDEO_MAX_PLANES)
+                        break;
                 for (i = 0; i < p->fmt.pix_mp.num_planes; i++)
-                        CLEAR_AFTER_FIELD(p, fmt.pix_mp.plane_fmt[i].bytesperline);
+                        CLEAR_AFTER_FIELD(&p->fmt.pix_mp.plane_fmt[i],
+                                          bytesperline);
                 return ops->vidioc_s_fmt_vid_out_mplane(file, fh, arg);
         case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
                 if (unlikely(!ops->vidioc_s_fmt_vid_out_overlay))
@@ -1648,8 +1656,11 @@ static int v4l_try_fmt(const struct v4l2_ioctl_ops *ops,
                 if (unlikely(!ops->vidioc_try_fmt_vid_cap_mplane))
                         break;
                 CLEAR_AFTER_FIELD(p, fmt.pix_mp.xfer_func);
+                if (p->fmt.pix_mp.num_planes > VIDEO_MAX_PLANES)
+                        break;
                 for (i = 0; i < p->fmt.pix_mp.num_planes; i++)
-                        CLEAR_AFTER_FIELD(p, fmt.pix_mp.plane_fmt[i].bytesperline);
+                        CLEAR_AFTER_FIELD(&p->fmt.pix_mp.plane_fmt[i],
+                                          bytesperline);
                 return ops->vidioc_try_fmt_vid_cap_mplane(file, fh, arg);
         case V4L2_BUF_TYPE_VIDEO_OVERLAY:
                 if (unlikely(!ops->vidioc_try_fmt_vid_overlay))
@@ -1678,8 +1689,11 @@ static int v4l_try_fmt(const struct v4l2_ioctl_ops *ops,
                 if (unlikely(!ops->vidioc_try_fmt_vid_out_mplane))
                         break;
                 CLEAR_AFTER_FIELD(p, fmt.pix_mp.xfer_func);
+                if (p->fmt.pix_mp.num_planes > VIDEO_MAX_PLANES)
+                        break;
                 for (i = 0; i < p->fmt.pix_mp.num_planes; i++)
-                        CLEAR_AFTER_FIELD(p, fmt.pix_mp.plane_fmt[i].bytesperline);
+                        CLEAR_AFTER_FIELD(&p->fmt.pix_mp.plane_fmt[i],
+                                          bytesperline);
                 return ops->vidioc_try_fmt_vid_out_mplane(file, fh, arg);
         case V4L2_BUF_TYPE_VIDEO_OUTPUT_OVERLAY:
                 if (unlikely(!ops->vidioc_try_fmt_vid_out_overlay))
diff --git a/drivers/mfd/Kconfig b/drivers/mfd/Kconfig
index 8c5dfdce4326..f461460a2aeb 100644
--- a/drivers/mfd/Kconfig
+++ b/drivers/mfd/Kconfig
@@ -102,6 +102,7 @@ config MFD_AAT2870_CORE
 config MFD_AT91_USART
         tristate "AT91 USART Driver"
         select MFD_CORE
+        depends on ARCH_AT91 || COMPILE_TEST
         help
           Select this to get support for AT91 USART IP. This is a wrapper
           over at91-usart-serial driver and usart-spi-driver. Only one function
diff --git a/drivers/mfd/ab8500-core.c b/drivers/mfd/ab8500-core.c
index 30d09d177171..11ab17f64c64 100644
--- a/drivers/mfd/ab8500-core.c
+++ b/drivers/mfd/ab8500-core.c
@@ -261,7 +261,7 @@ static int get_register_interruptible(struct ab8500 *ab8500, u8 bank,
         mutex_unlock(&ab8500->lock);
         dev_vdbg(ab8500->dev, "rd: addr %#x => data %#x\n", addr, ret);
 
-        return ret;
+        return (ret < 0) ? ret : 0;
 }
 
 static int ab8500_get_register(struct device *dev, u8 bank,
diff --git a/drivers/mfd/axp20x.c b/drivers/mfd/axp20x.c
index e1450a56fc07..3c97f2c0fdfe 100644
--- a/drivers/mfd/axp20x.c
+++ b/drivers/mfd/axp20x.c
@@ -641,9 +641,9 @@ static const struct mfd_cell axp221_cells[] = {
 
 static const struct mfd_cell axp223_cells[] = {
         {
-                .name                   = "axp221-pek",
-                .num_resources          = ARRAY_SIZE(axp22x_pek_resources),
-                .resources              = axp22x_pek_resources,
+                .name           = "axp221-pek",
+                .num_resources  = ARRAY_SIZE(axp22x_pek_resources),
+                .resources      = axp22x_pek_resources,
         }, {
                 .name           = "axp22x-adc",
                 .of_compatible  = "x-powers,axp221-adc",
@@ -651,7 +651,7 @@ static const struct mfd_cell axp223_cells[] = {
                 .name           = "axp20x-battery-power-supply",
                 .of_compatible  = "x-powers,axp221-battery-power-supply",
         }, {
-                .name                   = "axp20x-regulator",
+                .name           = "axp20x-regulator",
         }, {
                 .name           = "axp20x-ac-power-supply",
                 .of_compatible  = "x-powers,axp221-ac-power-supply",
@@ -667,9 +667,9 @@ static const struct mfd_cell axp223_cells[] = {
 
 static const struct mfd_cell axp152_cells[] = {
         {
-                .name                   = "axp20x-pek",
-                .num_resources          = ARRAY_SIZE(axp152_pek_resources),
-                .resources              = axp152_pek_resources,
+                .name           = "axp20x-pek",
+                .num_resources  = ARRAY_SIZE(axp152_pek_resources),
+                .resources      = axp152_pek_resources,
         },
 };
 
@@ -698,87 +698,101 @@ static const struct resource axp288_charger_resources[] = {
 
 static const struct mfd_cell axp288_cells[] = {
         {
-                .name = "axp288_adc",
-                .num_resources = ARRAY_SIZE(axp288_adc_resources),
-                .resources = axp288_adc_resources,
-        },
-        {
-                .name = "axp288_extcon",
-                .num_resources = ARRAY_SIZE(axp288_extcon_resources),
-                .resources = axp288_extcon_resources,
-        },
-        {
-                .name = "axp288_charger",
-                .num_resources = ARRAY_SIZE(axp288_charger_resources),
-                .resources = axp288_charger_resources,
-        },
-        {
-                .name = "axp288_fuel_gauge",
-                .num_resources = ARRAY_SIZE(axp288_fuel_gauge_resources),
-                .resources = axp288_fuel_gauge_resources,
-        },
-        {
-                .name = "axp221-pek",
-                .num_resources = ARRAY_SIZE(axp288_power_button_resources),
-                .resources = axp288_power_button_resources,
-        },
-        {
-                .name = "axp288_pmic_acpi",
+                .name           = "axp288_adc",
+                .num_resources  = ARRAY_SIZE(axp288_adc_resources),
+                .resources      = axp288_adc_resources,
+        }, {
+                .name           = "axp288_extcon",
+                .num_resources  = ARRAY_SIZE(axp288_extcon_resources),
+                .resources      = axp288_extcon_resources,
+        }, {
+                .name           = "axp288_charger",
+                .num_resources  = ARRAY_SIZE(axp288_charger_resources),
+                .resources      = axp288_charger_resources,
+        }, {
+                .name           = "axp288_fuel_gauge",
+                .num_resources  = ARRAY_SIZE(axp288_fuel_gauge_resources),
+                .resources      = axp288_fuel_gauge_resources,
+        }, {
+                .name           = "axp221-pek",
+                .num_resources  = ARRAY_SIZE(axp288_power_button_resources),
+                .resources      = axp288_power_button_resources,
+        }, {
+                .name           = "axp288_pmic_acpi",
         },
 };
 
 static const struct mfd_cell axp803_cells[] = {
         {
-                .name                   = "axp221-pek",
-                .num_resources          = ARRAY_SIZE(axp803_pek_resources),
-                .resources              = axp803_pek_resources,
+                .name           = "axp221-pek",
+                .num_resources  = ARRAY_SIZE(axp803_pek_resources),
+                .resources      = axp803_pek_resources,
+        }, {
+                .name           = "axp20x-gpio",
+                .of_compatible  = "x-powers,axp813-gpio",
+        }, {
+                .name           = "axp813-adc",
+                .of_compatible  = "x-powers,axp813-adc",
+        }, {
+                .name           = "axp20x-battery-power-supply",
+                .of_compatible  = "x-powers,axp813-battery-power-supply",
+        }, {
+                .name           = "axp20x-ac-power-supply",
+                .of_compatible  = "x-powers,axp813-ac-power-supply",
+                .num_resources  = ARRAY_SIZE(axp20x_ac_power_supply_resources),
+                .resources      = axp20x_ac_power_supply_resources,
         },
-        {       .name                   = "axp20x-regulator" },
+        {       .name           = "axp20x-regulator" },
 };
 
 static const struct mfd_cell axp806_self_working_cells[] = {
         {
-                .name                   = "axp221-pek",
-                .num_resources          = ARRAY_SIZE(axp806_pek_resources),
-                .resources              = axp806_pek_resources,
+                .name           = "axp221-pek",
+                .num_resources  = ARRAY_SIZE(axp806_pek_resources),
+                .resources      = axp806_pek_resources,
         },
-        {       .name                   = "axp20x-regulator" },
+        {       .name           = "axp20x-regulator" },
 };
 
 static const struct mfd_cell axp806_cells[] = {
         {
-                .id                     = 2,
-                .name                   = "axp20x-regulator",
+                .id             = 2,
+                .name           = "axp20x-regulator",
         },
 };
 
 static const struct mfd_cell axp809_cells[] = {
         {
-                .name                   = "axp221-pek",
-                .num_resources          = ARRAY_SIZE(axp809_pek_resources),
-                .resources              = axp809_pek_resources,
+                .name           = "axp221-pek",
+                .num_resources  = ARRAY_SIZE(axp809_pek_resources),
+                .resources      = axp809_pek_resources,
         }, {
-                .id                     = 1,
-                .name                   = "axp20x-regulator",
+                .id             = 1,
+                .name           = "axp20x-regulator",
         },
 };
 
 static const struct mfd_cell axp813_cells[] = {
         {
-                .name                   = "axp221-pek",
-                .num_resources          = ARRAY_SIZE(axp803_pek_resources),
-                .resources              = axp803_pek_resources,
+                .name           = "axp221-pek",
+                .num_resources  = ARRAY_SIZE(axp803_pek_resources),
+                .resources      = axp803_pek_resources,
         }, {
-                .name                   = "axp20x-regulator",
+                .name           = "axp20x-regulator",
         }, {
-                .name                   = "axp20x-gpio",
-                .of_compatible          = "x-powers,axp813-gpio",
+                .name           = "axp20x-gpio",
+                .of_compatible  = "x-powers,axp813-gpio",
         }, {
-                .name                   = "axp813-adc",
-                .of_compatible          = "x-powers,axp813-adc",
+                .name           = "axp813-adc",
+                .of_compatible  = "x-powers,axp813-adc",
         }, {
                 .name           = "axp20x-battery-power-supply",
                 .of_compatible  = "x-powers,axp813-battery-power-supply",
+        }, {
+                .name           = "axp20x-ac-power-supply",
+                .of_compatible  = "x-powers,axp813-ac-power-supply",
+                .num_resources  = ARRAY_SIZE(axp20x_ac_power_supply_resources),
+                .resources      = axp20x_ac_power_supply_resources,
         },
 };
 
diff --git a/drivers/mfd/bd9571mwv.c b/drivers/mfd/bd9571mwv.c
index 503979c81dae..fab3cdc27ed6 100644
--- a/drivers/mfd/bd9571mwv.c
+++ b/drivers/mfd/bd9571mwv.c
@@ -59,6 +59,7 @@ static const struct regmap_access_table bd9571mwv_writable_table = {
 };
 
 static const struct regmap_range bd9571mwv_volatile_yes_ranges[] = {
+        regmap_reg_range(BD9571MWV_DVFS_MONIVDAC, BD9571MWV_DVFS_MONIVDAC),
         regmap_reg_range(BD9571MWV_GPIO_IN, BD9571MWV_GPIO_IN),
         regmap_reg_range(BD9571MWV_GPIO_INT, BD9571MWV_GPIO_INT),
         regmap_reg_range(BD9571MWV_INT_INTREQ, BD9571MWV_INT_INTREQ),
diff --git a/drivers/mfd/cros_ec_dev.c b/drivers/mfd/cros_ec_dev.c
index b99a194ce5a4..2d0fee488c5a 100644
--- a/drivers/mfd/cros_ec_dev.c
+++ b/drivers/mfd/cros_ec_dev.c
@@ -499,6 +499,7 @@ static int ec_device_remove(struct platform_device *pdev)
 
         cros_ec_debugfs_remove(ec);
 
+        mfd_remove_devices(ec->dev);
         cdev_del(&ec->cdev);
         device_unregister(&ec->class_dev);
         return 0;
diff --git a/drivers/mfd/db8500-prcmu.c b/drivers/mfd/db8500-prcmu.c
index 5970b8def548..aec20e1c7d3d 100644
--- a/drivers/mfd/db8500-prcmu.c
+++ b/drivers/mfd/db8500-prcmu.c
@@ -2584,7 +2584,7 @@ static struct irq_chip prcmu_irq_chip = {
         .irq_unmask     = prcmu_irq_unmask,
 };
 
-static __init char *fw_project_name(u32 project)
+static char *fw_project_name(u32 project)
 {
         switch (project) {
         case PRCMU_FW_PROJECT_U8500:
@@ -2732,7 +2732,7 @@ void __init db8500_prcmu_early_init(u32 phy_base, u32 size)
         INIT_WORK(&mb0_transfer.mask_work, prcmu_mask_work);
 }
 
-static void __init init_prcm_registers(void)
+static void init_prcm_registers(void)
 {
         u32 val;
 
diff --git a/drivers/mfd/exynos-lpass.c b/drivers/mfd/exynos-lpass.c
index ca829f85672f..2713de989f05 100644
--- a/drivers/mfd/exynos-lpass.c
+++ b/drivers/mfd/exynos-lpass.c
@@ -82,11 +82,13 @@ static void exynos_lpass_enable(struct exynos_lpass *lpass)
                      LPASS_INTR_SFR | LPASS_INTR_DMA | LPASS_INTR_I2S);
 
         regmap_write(lpass->top, SFR_LPASS_INTR_CPU_MASK,
-                     LPASS_INTR_SFR | LPASS_INTR_DMA | LPASS_INTR_I2S);
+                     LPASS_INTR_SFR | LPASS_INTR_DMA | LPASS_INTR_I2S |
+                     LPASS_INTR_UART);
 
         exynos_lpass_core_sw_reset(lpass, LPASS_I2S_SW_RESET);
         exynos_lpass_core_sw_reset(lpass, LPASS_DMA_SW_RESET);
         exynos_lpass_core_sw_reset(lpass, LPASS_MEM_SW_RESET);
+        exynos_lpass_core_sw_reset(lpass, LPASS_UART_SW_RESET);
 }
 
 static void exynos_lpass_disable(struct exynos_lpass *lpass)
diff --git a/drivers/mfd/madera-core.c b/drivers/mfd/madera-core.c
index 440030cecbbd..2a77988d0462 100644
--- a/drivers/mfd/madera-core.c
+++ b/drivers/mfd/madera-core.c
@@ -15,6 +15,7 @@
 #include <linux/gpio.h>
 #include <linux/mfd/core.h>
 #include <linux/module.h>
+#include <linux/mutex.h>
 #include <linux/notifier.h>
 #include <linux/of.h>
 #include <linux/of_gpio.h>
@@ -155,7 +156,7 @@ static int madera_wait_for_boot(struct madera *madera)
                 usleep_range(MADERA_BOOT_POLL_INTERVAL_USEC / 2,
                              MADERA_BOOT_POLL_INTERVAL_USEC);
                 regmap_read(madera->regmap, MADERA_IRQ1_RAW_STATUS_1, &val);
-        };
+        }
 
         if (!(val & MADERA_BOOT_DONE_STS1)) {
                 dev_err(madera->dev, "Polling BOOT_DONE_STS timed out\n");
@@ -357,6 +358,8 @@ int madera_dev_init(struct madera *madera)
 
         dev_set_drvdata(madera->dev, madera);
         BLOCKING_INIT_NOTIFIER_HEAD(&madera->notifier);
+        mutex_init(&madera->dapm_ptr_lock);
+
         madera_set_micbias_info(madera);
 
         /*
diff --git a/drivers/mfd/max77620.c b/drivers/mfd/max77620.c
index d8217366ed36..d8ddd1a6f304 100644
--- a/drivers/mfd/max77620.c
+++ b/drivers/mfd/max77620.c
@@ -280,7 +280,7 @@ static int max77620_config_fps(struct max77620_chip *chip,
 
         for (fps_id = 0; fps_id < MAX77620_FPS_COUNT; fps_id++) {
                 sprintf(fps_name, "fps%d", fps_id);
-                if (!strcmp(fps_np->name, fps_name))
+                if (of_node_name_eq(fps_np, fps_name))
                         break;
         }
 
diff --git a/drivers/mfd/mc13xxx-core.c b/drivers/mfd/mc13xxx-core.c
index f475e848252f..d0bf50e3568d 100644
--- a/drivers/mfd/mc13xxx-core.c
+++ b/drivers/mfd/mc13xxx-core.c
@@ -274,7 +274,9 @@ int mc13xxx_adc_do_conversion(struct mc13xxx *mc13xxx, unsigned int mode,
 
         mc13xxx->adcflags |= MC13XXX_ADC_WORKING;
 
-        mc13xxx_reg_read(mc13xxx, MC13XXX_ADC0, &old_adc0);
+        ret = mc13xxx_reg_read(mc13xxx, MC13XXX_ADC0, &old_adc0);
+        if (ret)
+                goto out;
 
         adc0 = MC13XXX_ADC0_ADINC1 | MC13XXX_ADC0_ADINC2 |
                MC13XXX_ADC0_CHRGRAWDIV;
diff --git a/drivers/mfd/mt6397-core.c b/drivers/mfd/mt6397-core.c
index 77b64bd64df3..ab24e176ef44 100644
--- a/drivers/mfd/mt6397-core.c
+++ b/drivers/mfd/mt6397-core.c
@@ -329,8 +329,7 @@ static int mt6397_probe(struct platform_device *pdev)
 
         default:
                 dev_err(&pdev->dev, "unsupported chip: %d\n", id);
-                ret = -ENODEV;
-                break;
+                return -ENODEV;
         }
 
         if (ret) {
diff --git a/drivers/mfd/qcom_rpm.c b/drivers/mfd/qcom_rpm.c
index 52fafea06067..8d420c37b2a6 100644
--- a/drivers/mfd/qcom_rpm.c
+++ b/drivers/mfd/qcom_rpm.c
@@ -638,6 +638,10 @@ static int qcom_rpm_probe(struct platform_device *pdev)
                 return -EFAULT;
         }
 
+        writel(fw_version[0], RPM_CTRL_REG(rpm, 0));
+        writel(fw_version[1], RPM_CTRL_REG(rpm, 1));
+        writel(fw_version[2], RPM_CTRL_REG(rpm, 2));
+
         dev_info(&pdev->dev, "RPM firmware %u.%u.%u\n", fw_version[0],
                                                         fw_version[1],
                                                         fw_version[2]);
diff --git a/drivers/mfd/rave-sp.c b/drivers/mfd/rave-sp.c
index 2a8369657e38..26c7b63e008a 100644
--- a/drivers/mfd/rave-sp.c
+++ b/drivers/mfd/rave-sp.c
@@ -109,7 +109,7 @@ struct rave_sp_reply {
 /**
  * struct rave_sp_checksum - Variant specific checksum implementation details
  *
- * @length:     Caculated checksum length
+ * @length:     Calculated checksum length
  * @subroutine: Utilized checksum algorithm implementation
  */
 struct rave_sp_checksum {
diff --git a/drivers/mfd/stmpe.c b/drivers/mfd/stmpe.c
index 566caca4efd8..7569a4be0608 100644
--- a/drivers/mfd/stmpe.c
+++ b/drivers/mfd/stmpe.c
@@ -1302,17 +1302,17 @@ static void stmpe_of_probe(struct stmpe_platform_data *pdata,
         pdata->autosleep = (pdata->autosleep_timeout) ? true : false;
 
         for_each_child_of_node(np, child) {
-                if (!strcmp(child->name, "stmpe_gpio")) {
+                if (of_node_name_eq(child, "stmpe_gpio")) {
                         pdata->blocks |= STMPE_BLOCK_GPIO;
-                } else if (!strcmp(child->name, "stmpe_keypad")) {
+                } else if (of_node_name_eq(child, "stmpe_keypad")) {
                         pdata->blocks |= STMPE_BLOCK_KEYPAD;
-                } else if (!strcmp(child->name, "stmpe_touchscreen")) {
+                } else if (of_node_name_eq(child, "stmpe_touchscreen")) {
                         pdata->blocks |= STMPE_BLOCK_TOUCHSCREEN;
-                } else if (!strcmp(child->name, "stmpe_adc")) {
+                } else if (of_node_name_eq(child, "stmpe_adc")) {
                         pdata->blocks |= STMPE_BLOCK_ADC;
-                } else if (!strcmp(child->name, "stmpe_pwm")) {
+                } else if (of_node_name_eq(child, "stmpe_pwm")) {
                         pdata->blocks |= STMPE_BLOCK_PWM;
-                } else if (!strcmp(child->name, "stmpe_rotator")) {
+                } else if (of_node_name_eq(child, "stmpe_rotator")) {
                         pdata->blocks |= STMPE_BLOCK_ROTATOR;
                 }
         }
diff --git a/drivers/mfd/ti_am335x_tscadc.c b/drivers/mfd/ti_am335x_tscadc.c
index c2d47d78705b..fd111296b959 100644
--- a/drivers/mfd/ti_am335x_tscadc.c
+++ b/drivers/mfd/ti_am335x_tscadc.c
@@ -264,8 +264,9 @@ static	int ti_tscadc_probe(struct platform_device *pdev)
                 cell->pdata_size = sizeof(tscadc);
         }
 
-        err = mfd_add_devices(&pdev->dev, pdev->id, tscadc->cells,
-                        tscadc->used_cells, NULL, 0, NULL);
+        err = mfd_add_devices(&pdev->dev, PLATFORM_DEVID_AUTO,
+                              tscadc->cells, tscadc->used_cells, NULL,
+                              0, NULL);
         if (err < 0)
                 goto err_disable_clk;
 
diff --git a/drivers/mfd/tps65218.c b/drivers/mfd/tps65218.c
index 910f569ff77c..8bcdecf494d0 100644
--- a/drivers/mfd/tps65218.c
+++ b/drivers/mfd/tps65218.c
@@ -235,9 +235,9 @@ static int tps65218_probe(struct i2c_client *client,
 
         mutex_init(&tps->tps_lock);
 
-        ret = regmap_add_irq_chip(tps->regmap, tps->irq,
-                        IRQF_ONESHOT, 0, &tps65218_irq_chip,
-                        &tps->irq_data);
+        ret = devm_regmap_add_irq_chip(&client->dev, tps->regmap, tps->irq,
+                                       IRQF_ONESHOT, 0, &tps65218_irq_chip,
+                                       &tps->irq_data);
         if (ret < 0)
                 return ret;
 
@@ -253,26 +253,9 @@ static int tps65218_probe(struct i2c_client *client,
                               ARRAY_SIZE(tps65218_cells), NULL, 0,
                               regmap_irq_get_domain(tps->irq_data));
 
-        if (ret < 0)
-                goto err_irq;
-
-        return 0;
-
-err_irq:
-        regmap_del_irq_chip(tps->irq, tps->irq_data);
-
         return ret;
 }
 
-static int tps65218_remove(struct i2c_client *client)
-{
-        struct tps65218 *tps = i2c_get_clientdata(client);
-
-        regmap_del_irq_chip(tps->irq, tps->irq_data);
-
-        return 0;
-}
-
 static const struct i2c_device_id tps65218_id_table[] = {
         { "tps65218", TPS65218 },
         { },
@@ -285,7 +268,6 @@ static struct i2c_driver tps65218_driver = {
                 .of_match_table = of_tps65218_match_table,
         },
         .probe          = tps65218_probe,
-        .remove         = tps65218_remove,
         .id_table       = tps65218_id_table,
 };
 
diff --git a/drivers/mfd/tps6586x.c b/drivers/mfd/tps6586x.c
index b89379782741..9c7925ca13cf 100644
--- a/drivers/mfd/tps6586x.c
+++ b/drivers/mfd/tps6586x.c
@@ -592,6 +592,29 @@ static int tps6586x_i2c_remove(struct i2c_client *client)
         return 0;
 }
 
+static int __maybe_unused tps6586x_i2c_suspend(struct device *dev)
+{
+        struct tps6586x *tps6586x = dev_get_drvdata(dev);
+
+        if (tps6586x->client->irq)
+                disable_irq(tps6586x->client->irq);
+
+        return 0;
+}
+
+static int __maybe_unused tps6586x_i2c_resume(struct device *dev)
+{
+        struct tps6586x *tps6586x = dev_get_drvdata(dev);
+
+        if (tps6586x->client->irq)
+                enable_irq(tps6586x->client->irq);
+
+        return 0;
+}
+
+static SIMPLE_DEV_PM_OPS(tps6586x_pm_ops, tps6586x_i2c_suspend,
+                         tps6586x_i2c_resume);
+
 static const struct i2c_device_id tps6586x_id_table[] = {
         { "tps6586x", 0 },
         { },
@@ -602,6 +625,7 @@ static struct i2c_driver tps6586x_driver = {
         .driver = {
                 .name   = "tps6586x",
                 .of_match_table = of_match_ptr(tps6586x_of_match),
+                .pm     = &tps6586x_pm_ops,
         },
         .probe          = tps6586x_i2c_probe,
         .remove         = tps6586x_i2c_remove,
diff --git a/drivers/mfd/twl-core.c b/drivers/mfd/twl-core.c
index 4be3d239da9e..299016bc46d9 100644
--- a/drivers/mfd/twl-core.c
+++ b/drivers/mfd/twl-core.c
@@ -979,7 +979,7 @@ add_children(struct twl4030_platform_data *pdata, unsigned irq_base,
  * letting it generate the right frequencies for USB, MADC, and
  * other purposes.
  */
-static inline int __init protect_pm_master(void)
+static inline int protect_pm_master(void)
 {
         int e = 0;
 
@@ -988,7 +988,7 @@ static inline int __init protect_pm_master(void)
         return e;
 }
 
-static inline int __init unprotect_pm_master(void)
+static inline int unprotect_pm_master(void)
 {
         int e = 0;
 
diff --git a/drivers/mfd/wm5110-tables.c b/drivers/mfd/wm5110-tables.c
index 1ee68bd440fb..16c6e2accfaa 100644
--- a/drivers/mfd/wm5110-tables.c
+++ b/drivers/mfd/wm5110-tables.c
@@ -1618,6 +1618,7 @@ static const struct reg_default wm5110_reg_default[] = {
         { 0x00000ECD, 0x0000 },    /* R3789  - HPLPF4_2 */
         { 0x00000EE0, 0x0000 },    /* R3808  - ASRC_ENABLE */
         { 0x00000EE2, 0x0000 },    /* R3810  - ASRC_RATE1 */
+        { 0x00000EE3, 0x4000 },    /* R3811  - ASRC_RATE2 */
         { 0x00000EF0, 0x0000 },    /* R3824  - ISRC 1 CTRL 1 */
         { 0x00000EF1, 0x0000 },    /* R3825  - ISRC 1 CTRL 2 */
         { 0x00000EF2, 0x0000 },    /* R3826  - ISRC 1 CTRL 3 */
@@ -2869,6 +2870,7 @@ static bool wm5110_readable_register(struct device *dev, unsigned int reg)
         case ARIZONA_ASRC_ENABLE:
         case ARIZONA_ASRC_STATUS:
         case ARIZONA_ASRC_RATE1:
+        case ARIZONA_ASRC_RATE2:
         case ARIZONA_ISRC_1_CTRL_1:
         case ARIZONA_ISRC_1_CTRL_2:
         case ARIZONA_ISRC_1_CTRL_3:
diff --git a/drivers/misc/genwqe/card_utils.c b/drivers/misc/genwqe/card_utils.c
index efe2fb72d54b..25265fd0fd6e 100644
--- a/drivers/misc/genwqe/card_utils.c
+++ b/drivers/misc/genwqe/card_utils.c
@@ -218,8 +218,8 @@ void *__genwqe_alloc_consistent(struct genwqe_dev *cd, size_t size,
         if (get_order(size) >= MAX_ORDER)
                 return NULL;
 
-        return dma_zalloc_coherent(&cd->pci_dev->dev, size, dma_handle,
-                                   GFP_KERNEL);
+        return dma_alloc_coherent(&cd->pci_dev->dev, size, dma_handle,
+                                  GFP_KERNEL);
 }
 
 void __genwqe_free_consistent(struct genwqe_dev *cd, size_t size,
diff --git a/drivers/misc/ibmvmc.c b/drivers/misc/ibmvmc.c
index b8aaa684c397..2ed23c99f59f 100644
--- a/drivers/misc/ibmvmc.c
+++ b/drivers/misc/ibmvmc.c
@@ -820,21 +820,24 @@ static int ibmvmc_send_msg(struct crq_server_adapter *adapter,
  *
  * Return:
  *      0 - Success
+ *      Non-zero - Failure
  */
 static int ibmvmc_open(struct inode *inode, struct file *file)
 {
         struct ibmvmc_file_session *session;
-        int rc = 0;
 
         pr_debug("%s: inode = 0x%lx, file = 0x%lx, state = 0x%x\n", __func__,
                  (unsigned long)inode, (unsigned long)file,
                  ibmvmc.state);
 
         session = kzalloc(sizeof(*session), GFP_KERNEL);
+        if (!session)
+                return -ENOMEM;
+
         session->file = file;
         file->private_data = session;
 
-        return rc;
+        return 0;
 }
 
 /**
diff --git a/drivers/misc/mei/hbm.c b/drivers/misc/mei/hbm.c
index 78c26cebf5d4..8f7616557c97 100644
--- a/drivers/misc/mei/hbm.c
+++ b/drivers/misc/mei/hbm.c
@@ -1187,9 +1187,15 @@ int mei_hbm_dispatch(struct mei_device *dev, struct mei_msg_hdr *hdr)
                 dma_setup_res = (struct hbm_dma_setup_response *)mei_msg;
 
                 if (dma_setup_res->status) {
-                        dev_info(dev->dev, "hbm: dma setup response: failure = %d %s\n",
-                                 dma_setup_res->status,
-                                 mei_hbm_status_str(dma_setup_res->status));
+                        u8 status = dma_setup_res->status;
+
+                        if (status == MEI_HBMS_NOT_ALLOWED) {
+                                dev_dbg(dev->dev, "hbm: dma setup not allowed\n");
+                        } else {
+                                dev_info(dev->dev, "hbm: dma setup response: failure = %d %s\n",
+                                         status,
+                                         mei_hbm_status_str(status));
+                        }
                         dev->hbm_f_dr_supported = 0;
                         mei_dmam_ring_free(dev);
                 }
diff --git a/drivers/misc/mei/hw-me-regs.h b/drivers/misc/mei/hw-me-regs.h
index e4b10b2d1a08..23739a60517f 100644
--- a/drivers/misc/mei/hw-me-regs.h
+++ b/drivers/misc/mei/hw-me-regs.h
@@ -127,6 +127,8 @@
 #define MEI_DEV_ID_BXT_M      0x1A9A  /* Broxton M */
 #define MEI_DEV_ID_APL_I      0x5A9A  /* Apollo Lake I */
 
+#define MEI_DEV_ID_DNV_IE     0x19E5  /* Denverton IE */
+
 #define MEI_DEV_ID_GLK        0x319A  /* Gemini Lake */
 
 #define MEI_DEV_ID_KBP        0xA2BA  /* Kaby Point */
diff --git a/drivers/misc/mei/pci-me.c b/drivers/misc/mei/pci-me.c
index 73ace2d59dea..e89497f858ae 100644
--- a/drivers/misc/mei/pci-me.c
+++ b/drivers/misc/mei/pci-me.c
@@ -88,11 +88,13 @@ static const struct pci_device_id mei_me_pci_tbl[] = {
         {MEI_PCI_DEVICE(MEI_DEV_ID_SPT_2, MEI_ME_PCH8_CFG)},
         {MEI_PCI_DEVICE(MEI_DEV_ID_SPT_H, MEI_ME_PCH8_SPS_CFG)},
         {MEI_PCI_DEVICE(MEI_DEV_ID_SPT_H_2, MEI_ME_PCH8_SPS_CFG)},
-        {MEI_PCI_DEVICE(MEI_DEV_ID_LBG, MEI_ME_PCH8_CFG)},
+        {MEI_PCI_DEVICE(MEI_DEV_ID_LBG, MEI_ME_PCH12_CFG)},
 
         {MEI_PCI_DEVICE(MEI_DEV_ID_BXT_M, MEI_ME_PCH8_CFG)},
         {MEI_PCI_DEVICE(MEI_DEV_ID_APL_I, MEI_ME_PCH8_CFG)},
 
+        {MEI_PCI_DEVICE(MEI_DEV_ID_DNV_IE, MEI_ME_PCH8_CFG)},
+
         {MEI_PCI_DEVICE(MEI_DEV_ID_GLK, MEI_ME_PCH8_CFG)},
 
         {MEI_PCI_DEVICE(MEI_DEV_ID_KBP, MEI_ME_PCH8_CFG)},
diff --git a/drivers/misc/mic/vop/vop_main.c b/drivers/misc/mic/vop/vop_main.c
index 6b212c8b78e7..2bfa3a903bf9 100644
--- a/drivers/misc/mic/vop/vop_main.c
+++ b/drivers/misc/mic/vop/vop_main.c
@@ -394,16 +394,21 @@ static int vop_find_vqs(struct virtio_device *dev, unsigned nvqs,
         struct _vop_vdev *vdev = to_vopvdev(dev);
         struct vop_device *vpdev = vdev->vpdev;
         struct mic_device_ctrl __iomem *dc = vdev->dc;
-        int i, err, retry;
+        int i, err, retry, queue_idx = 0;
 
         /* We must have this many virtqueues. */
         if (nvqs > ioread8(&vdev->desc->num_vq))
                 return -ENOENT;
 
         for (i = 0; i < nvqs; ++i) {
+                if (!names[i]) {
+                        vqs[i] = NULL;
+                        continue;
+                }
+
                 dev_dbg(_vop_dev(vdev), "%s: %d: %s\n",
                         __func__, i, names[i]);
-                vqs[i] = vop_find_vq(dev, i, callbacks[i], names[i],
+                vqs[i] = vop_find_vq(dev, queue_idx++, callbacks[i], names[i],
                                      ctx ? ctx[i] : false);
                 if (IS_ERR(vqs[i])) {
                         err = PTR_ERR(vqs[i]);
diff --git a/drivers/misc/pvpanic.c b/drivers/misc/pvpanic.c
index 595ac065b401..95ff7c5a1dfb 100644
--- a/drivers/misc/pvpanic.c
+++ b/drivers/misc/pvpanic.c
@@ -70,8 +70,12 @@ pvpanic_walk_resources(struct acpi_resource *res, void *context)
         struct resource r;
 
         if (acpi_dev_resource_io(res, &r)) {
+#ifdef CONFIG_HAS_IOPORT_MAP
                 base = ioport_map(r.start, resource_size(&r));
                 return AE_OK;
+#else
+                return AE_ERROR;
+#endif
         } else if (acpi_dev_resource_memory(res, &r)) {
                 base = ioremap(r.start, resource_size(&r));
                 return AE_OK;
diff --git a/drivers/mmc/core/host.c b/drivers/mmc/core/host.c
index f57f5de54206..cf58ccaf22d5 100644
--- a/drivers/mmc/core/host.c
+++ b/drivers/mmc/core/host.c
@@ -234,7 +234,7 @@ int mmc_of_parse(struct mmc_host *host)
                 if (device_property_read_bool(dev, "broken-cd"))
                         host->caps |= MMC_CAP_NEEDS_POLL;
 
-                ret = mmc_gpiod_request_cd(host, "cd", 0, true,
+                ret = mmc_gpiod_request_cd(host, "cd", 0, false,
                                            cd_debounce_delay_ms * 1000,
                                            &cd_gpio_invert);
                 if (!ret)
diff --git a/drivers/mmc/host/Kconfig b/drivers/mmc/host/Kconfig
index e26b8145efb3..a44ec8bb5418 100644
--- a/drivers/mmc/host/Kconfig
+++ b/drivers/mmc/host/Kconfig
@@ -116,7 +116,7 @@ config MMC_RICOH_MMC
 
 config MMC_SDHCI_ACPI
         tristate "SDHCI support for ACPI enumerated SDHCI controllers"
-        depends on MMC_SDHCI && ACPI
+        depends on MMC_SDHCI && ACPI && PCI
         select IOSF_MBI if X86
         help
           This selects support for ACPI enumerated SDHCI controllers,
@@ -978,7 +978,7 @@ config MMC_SDHCI_OMAP
         tristate "TI SDHCI Controller Support"
         depends on MMC_SDHCI_PLTFM && OF
         select THERMAL
-        select TI_SOC_THERMAL
+        imply TI_SOC_THERMAL
         help
           This selects the Secure Digital Host Controller Interface (SDHCI)
           support present in TI's DRA7 SOCs. The controller supports
diff --git a/drivers/mmc/host/dw_mmc-bluefield.c b/drivers/mmc/host/dw_mmc-bluefield.c
index ed8f2254b66a..aa38b1a8017e 100644
--- a/drivers/mmc/host/dw_mmc-bluefield.c
+++ b/drivers/mmc/host/dw_mmc-bluefield.c
@@ -1,11 +1,6 @@
 // SPDX-License-Identifier: GPL-2.0
 /*
  * Copyright (C) 2018 Mellanox Technologies.
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
  */
 
 #include <linux/bitfield.h>
diff --git a/drivers/mmc/host/meson-gx-mmc.c b/drivers/mmc/host/meson-gx-mmc.c
index c2690c1a50ff..f19ec60bcbdc 100644
--- a/drivers/mmc/host/meson-gx-mmc.c
+++ b/drivers/mmc/host/meson-gx-mmc.c
@@ -179,6 +179,8 @@ struct meson_host {
         struct sd_emmc_desc *descs;
         dma_addr_t descs_dma_addr;
 
+        int irq;
+
         bool vqmmc_enabled;
 };
 
@@ -738,6 +740,11 @@ static int meson_mmc_clk_phase_tuning(struct mmc_host *mmc, u32 opcode,
 static int meson_mmc_execute_tuning(struct mmc_host *mmc, u32 opcode)
 {
         struct meson_host *host = mmc_priv(mmc);
+        int adj = 0;
+
+        /* enable signal resampling w/o delay */
+        adj = ADJUST_ADJ_EN;
+        writel(adj, host->regs + host->data->adjust);
 
         return meson_mmc_clk_phase_tuning(mmc, opcode, host->rx_clk);
 }
@@ -768,6 +775,9 @@ static void meson_mmc_set_ios(struct mmc_host *mmc, struct mmc_ios *ios)
                 if (!IS_ERR(mmc->supply.vmmc))
                         mmc_regulator_set_ocr(mmc, mmc->supply.vmmc, ios->vdd);
 
+                /* disable signal resampling */
+                writel(0, host->regs + host->data->adjust);
+
                 /* Reset rx phase */
                 clk_set_phase(host->rx_clk, 0);
 
@@ -1166,7 +1176,7 @@ static int meson_mmc_get_cd(struct mmc_host *mmc)
 
 static void meson_mmc_cfg_init(struct meson_host *host)
 {
-        u32 cfg = 0, adj = 0;
+        u32 cfg = 0;
 
         cfg |= FIELD_PREP(CFG_RESP_TIMEOUT_MASK,
                           ilog2(SD_EMMC_CFG_RESP_TIMEOUT));
@@ -1177,10 +1187,6 @@ static void meson_mmc_cfg_init(struct meson_host *host)
         cfg |= CFG_ERR_ABORT;
 
         writel(cfg, host->regs + SD_EMMC_CFG);
-
-        /* enable signal resampling w/o delay */
-        adj = ADJUST_ADJ_EN;
-        writel(adj, host->regs + host->data->adjust);
 }
 
 static int meson_mmc_card_busy(struct mmc_host *mmc)
@@ -1231,7 +1237,7 @@ static int meson_mmc_probe(struct platform_device *pdev)
         struct resource *res;
         struct meson_host *host;
         struct mmc_host *mmc;
-        int ret, irq;
+        int ret;
 
         mmc = mmc_alloc_host(sizeof(struct meson_host), &pdev->dev);
         if (!mmc)
@@ -1276,8 +1282,8 @@ static int meson_mmc_probe(struct platform_device *pdev)
                 goto free_host;
         }
 
-        irq = platform_get_irq(pdev, 0);
-        if (irq <= 0) {
+        host->irq = platform_get_irq(pdev, 0);
+        if (host->irq <= 0) {
                 dev_err(&pdev->dev, "failed to get interrupt resource.\n");
                 ret = -EINVAL;
                 goto free_host;
@@ -1331,9 +1337,8 @@ static int meson_mmc_probe(struct platform_device *pdev)
         writel(IRQ_CRC_ERR | IRQ_TIMEOUTS | IRQ_END_OF_CHAIN,
                host->regs + SD_EMMC_IRQ_EN);
 
-        ret = devm_request_threaded_irq(&pdev->dev, irq, meson_mmc_irq,
-                                        meson_mmc_irq_thread, IRQF_SHARED,
-                                        NULL, host);
+        ret = request_threaded_irq(host->irq, meson_mmc_irq,
+                        meson_mmc_irq_thread, IRQF_SHARED, NULL, host);
         if (ret)
                 goto err_init_clk;
 
@@ -1351,7 +1356,7 @@ static int meson_mmc_probe(struct platform_device *pdev)
         if (host->bounce_buf == NULL) {
                 dev_err(host->dev, "Unable to map allocate DMA bounce buffer.\n");
                 ret = -ENOMEM;
-                goto err_init_clk;
+                goto err_free_irq;
         }
 
         host->descs = dma_alloc_coherent(host->dev, SD_EMMC_DESC_BUF_LEN,
@@ -1370,6 +1375,8 @@ static int meson_mmc_probe(struct platform_device *pdev)
 err_bounce_buf:
         dma_free_coherent(host->dev, host->bounce_buf_size,
                           host->bounce_buf, host->bounce_dma_addr);
+err_free_irq:
+        free_irq(host->irq, host);
 err_init_clk:
         clk_disable_unprepare(host->mmc_clk);
 err_core_clk:
@@ -1387,6 +1394,7 @@ static int meson_mmc_remove(struct platform_device *pdev)
 
         /* disable interrupts */
         writel(0, host->regs + SD_EMMC_IRQ_EN);
+        free_irq(host->irq, host);
 
         dma_free_coherent(host->dev, SD_EMMC_DESC_BUF_LEN,
                           host->descs, host->descs_dma_addr);
diff --git a/drivers/mmc/host/sdhci-iproc.c b/drivers/mmc/host/sdhci-iproc.c
index 0db99057c44f..9d12c06c7fd6 100644
--- a/drivers/mmc/host/sdhci-iproc.c
+++ b/drivers/mmc/host/sdhci-iproc.c
@@ -296,7 +296,10 @@ static int sdhci_iproc_probe(struct platform_device *pdev)
 
         iproc_host->data = iproc_data;
 
-        mmc_of_parse(host->mmc);
+        ret = mmc_of_parse(host->mmc);
+        if (ret)
+                goto err;
+
         sdhci_get_property(pdev);
 
         host->mmc->caps |= iproc_host->data->mmc_caps;
diff --git a/drivers/mmc/host/sdhci.c b/drivers/mmc/host/sdhci.c
index a22e11a65658..eba9bcc92ad3 100644
--- a/drivers/mmc/host/sdhci.c
+++ b/drivers/mmc/host/sdhci.c
@@ -3763,8 +3763,9 @@ int sdhci_setup_host(struct sdhci_host *host)
                  * Use zalloc to zero the reserved high 32-bits of 128-bit
                  * descriptors so that they never need to be written.
                  */
-                buf = dma_zalloc_coherent(mmc_dev(mmc), host->align_buffer_sz +
-                                         host->adma_table_sz, &dma, GFP_KERNEL);
+                buf = dma_alloc_coherent(mmc_dev(mmc),
+                                         host->align_buffer_sz + host->adma_table_sz,
+                                         &dma, GFP_KERNEL);
                 if (!buf) {
                         pr_warn("%s: Unable to allocate ADMA buffers - falling back to standard DMA\n",
                                 mmc_hostname(mmc));
diff --git a/drivers/mtd/mtdcore.c b/drivers/mtd/mtdcore.c
index 21e3cdc04036..999b705769a8 100644
--- a/drivers/mtd/mtdcore.c
+++ b/drivers/mtd/mtdcore.c
@@ -522,7 +522,7 @@ static int mtd_nvmem_add(struct mtd_info *mtd)
         mtd->nvmem = nvmem_register(&config);
         if (IS_ERR(mtd->nvmem)) {
                 /* Just ignore if there is no NVMEM support in the kernel */
-                if (PTR_ERR(mtd->nvmem) == -ENOSYS) {
+                if (PTR_ERR(mtd->nvmem) == -EOPNOTSUPP) {
                         mtd->nvmem = NULL;
                 } else {
                         dev_err(&mtd->dev, "Failed to register NVMEM device\n");
diff --git a/drivers/mtd/mtdcore.h b/drivers/mtd/mtdcore.h
index 9887bda317cd..b31c868019ad 100644
--- a/drivers/mtd/mtdcore.h
+++ b/drivers/mtd/mtdcore.h
@@ -7,7 +7,7 @@
 extern struct mutex mtd_table_mutex;
 
 struct mtd_info *__mtd_next_device(int i);
-int add_mtd_device(struct mtd_info *mtd);
+int __must_check add_mtd_device(struct mtd_info *mtd);
 int del_mtd_device(struct mtd_info *mtd);
 int add_mtd_partitions(struct mtd_info *, const struct mtd_partition *, int);
 int del_mtd_partitions(struct mtd_info *);
diff --git a/drivers/mtd/mtdpart.c b/drivers/mtd/mtdpart.c
index b6af41b04622..60104e1079c5 100644
--- a/drivers/mtd/mtdpart.c
+++ b/drivers/mtd/mtdpart.c
@@ -618,10 +618,22 @@ int mtd_add_partition(struct mtd_info *parent, const char *name,
         list_add(&new->list, &mtd_partitions);
         mutex_unlock(&mtd_partitions_mutex);
 
-        add_mtd_device(&new->mtd);
+        ret = add_mtd_device(&new->mtd);
+        if (ret)
+                goto err_remove_part;
 
         mtd_add_partition_attrs(new);
 
+        return 0;
+
+err_remove_part:
+        mutex_lock(&mtd_partitions_mutex);
+        list_del(&new->list);
+        mutex_unlock(&mtd_partitions_mutex);
+
+        free_partition(new);
+        pr_info("%s:%i\n", __func__, __LINE__);
+
         return ret;
 }
 EXPORT_SYMBOL_GPL(mtd_add_partition);
@@ -712,22 +724,31 @@ int add_mtd_partitions(struct mtd_info *master,
 {
         struct mtd_part *slave;
         uint64_t cur_offset = 0;
-        int i;
+        int i, ret;
 
         printk(KERN_NOTICE "Creating %d MTD partitions on \"%s\":\n", nbparts, master->name);
 
         for (i = 0; i < nbparts; i++) {
                 slave = allocate_partition(master, parts + i, i, cur_offset);
                 if (IS_ERR(slave)) {
-                        del_mtd_partitions(master);
-                        return PTR_ERR(slave);
+                        ret = PTR_ERR(slave);
+                        goto err_del_partitions;
                 }
 
                 mutex_lock(&mtd_partitions_mutex);
                 list_add(&slave->list, &mtd_partitions);
                 mutex_unlock(&mtd_partitions_mutex);
 
-                add_mtd_device(&slave->mtd);
+                ret = add_mtd_device(&slave->mtd);
+                if (ret) {
+                        mutex_lock(&mtd_partitions_mutex);
+                        list_del(&slave->list);
+                        mutex_unlock(&mtd_partitions_mutex);
+
+                        free_partition(slave);
+                        goto err_del_partitions;
+                }
+
                 mtd_add_partition_attrs(slave);
                 /* Look for subpartitions */
                 parse_mtd_partitions(&slave->mtd, parts[i].types, NULL);
@@ -736,6 +757,11 @@ int add_mtd_partitions(struct mtd_info *master,
         }
 
         return 0;
+
+err_del_partitions:
+        del_mtd_partitions(master);
+
+        return ret;
 }
 
 static DEFINE_SPINLOCK(part_parser_lock);
diff --git a/drivers/mtd/nand/raw/denali.c b/drivers/mtd/nand/raw/denali.c
index eebac35304c6..6e8edc9375dd 100644
--- a/drivers/mtd/nand/raw/denali.c
+++ b/drivers/mtd/nand/raw/denali.c
@@ -1322,7 +1322,7 @@ int denali_init(struct denali_nand_info *denali)
         }
 
         /* clk rate info is needed for setup_data_interface */
-        if (denali->clk_rate && denali->clk_x_rate)
+        if (!denali->clk_rate || !denali->clk_x_rate)
                 chip->options |= NAND_KEEP_TIMINGS;
 
         chip->legacy.dummy_controller.ops = &denali_controller_ops;
diff --git a/drivers/mtd/nand/raw/fsmc_nand.c b/drivers/mtd/nand/raw/fsmc_nand.c
index 325b4414dccc..c9149a37f8f0 100644
--- a/drivers/mtd/nand/raw/fsmc_nand.c
+++ b/drivers/mtd/nand/raw/fsmc_nand.c
@@ -593,23 +593,6 @@ static void fsmc_write_buf_dma(struct fsmc_nand_data *host, const u8 *buf,
         dma_xfer(host, (void *)buf, len, DMA_TO_DEVICE);
 }
 
-/* fsmc_select_chip - assert or deassert nCE */
-static void fsmc_ce_ctrl(struct fsmc_nand_data *host, bool assert)
-{
-        u32 pc = readl(host->regs_va + FSMC_PC);
-
-        if (!assert)
-                writel_relaxed(pc & ~FSMC_ENABLE, host->regs_va + FSMC_PC);
-        else
-                writel_relaxed(pc | FSMC_ENABLE, host->regs_va + FSMC_PC);
-
-        /*
-         * nCE line changes must be applied before returning from this
-         * function.
-         */
-        mb();
-}
-
 /*
  * fsmc_exec_op - hook called by the core to execute NAND operations
  *
@@ -627,8 +610,6 @@ static int fsmc_exec_op(struct nand_chip *chip, const struct nand_operation *op,
 
         pr_debug("Executing operation [%d instructions]:\n", op->ninstrs);
 
-        fsmc_ce_ctrl(host, true);
-
         for (op_id = 0; op_id < op->ninstrs; op_id++) {
                 instr = &op->instrs[op_id];
 
@@ -686,8 +667,6 @@ static int fsmc_exec_op(struct nand_chip *chip, const struct nand_operation *op,
                 }
         }
 
-        fsmc_ce_ctrl(host, false);
-
         return ret;
 }
 
diff --git a/drivers/mtd/nand/raw/jz4740_nand.c b/drivers/mtd/nand/raw/jz4740_nand.c
index f92ae5aa2a54..9526d5b23c80 100644
--- a/drivers/mtd/nand/raw/jz4740_nand.c
+++ b/drivers/mtd/nand/raw/jz4740_nand.c
@@ -260,7 +260,7 @@ static int jz_nand_correct_ecc_rs(struct nand_chip *chip, uint8_t *dat,
 }
 
 static int jz_nand_ioremap_resource(struct platform_device *pdev,
-        const char *name, struct resource **res, void *__iomem *base)
+        const char *name, struct resource **res, void __iomem **base)
 {
         int ret;
 
diff --git a/drivers/mtd/nand/raw/qcom_nandc.c b/drivers/mtd/nand/raw/qcom_nandc.c
index 46c62a31fa46..920e7375084f 100644
--- a/drivers/mtd/nand/raw/qcom_nandc.c
+++ b/drivers/mtd/nand/raw/qcom_nandc.c
@@ -2833,6 +2833,16 @@ static int qcom_nand_host_init_and_register(struct qcom_nand_controller *nandc,
         if (ret)
                 return ret;
 
+        if (nandc->props->is_bam) {
+                free_bam_transaction(nandc);
+                nandc->bam_txn = alloc_bam_transaction(nandc);
+                if (!nandc->bam_txn) {
+                        dev_err(nandc->dev,
+                                "failed to allocate bam transaction\n");
+                        return -ENOMEM;
+                }
+        }
+
         ret = mtd_device_register(mtd, NULL, 0);
         if (ret)
                 nand_cleanup(chip);
@@ -2847,16 +2857,6 @@ static int qcom_probe_nand_devices(struct qcom_nand_controller *nandc)
         struct qcom_nand_host *host;
         int ret;
 
-        if (nandc->props->is_bam) {
-                free_bam_transaction(nandc);
-                nandc->bam_txn = alloc_bam_transaction(nandc);
-                if (!nandc->bam_txn) {
-                        dev_err(nandc->dev,
-                                "failed to allocate bam transaction\n");
-                        return -ENOMEM;
-                }
-        }
-
         for_each_available_child_of_node(dn, child) {
                 host = devm_kzalloc(dev, sizeof(*host), GFP_KERNEL);
                 if (!host) {
diff --git a/drivers/net/Kconfig b/drivers/net/Kconfig
index 6371958dd170..edb1c023a753 100644
--- a/drivers/net/Kconfig
+++ b/drivers/net/Kconfig
@@ -519,7 +519,7 @@ config NET_FAILOVER
           and destroy a failover master netdev and manages a primary and
           standby slave netdevs that get registered via the generic failover
           infrastructure. This can be used by paravirtual drivers to enable
-          an alternate low latency datapath. It alsoenables live migration of
+          an alternate low latency datapath. It also enables live migration of
           a VM with direct attached VF by failing over to the paravirtual
           datapath when the VF is unplugged.
 
diff --git a/drivers/net/bonding/bond_main.c b/drivers/net/bonding/bond_main.c
index a9d597f28023..485462d3087f 100644
--- a/drivers/net/bonding/bond_main.c
+++ b/drivers/net/bonding/bond_main.c
@@ -1963,6 +1963,9 @@ static int __bond_release_one(struct net_device *bond_dev,
         if (!bond_has_slaves(bond)) {
                 bond_set_carrier(bond);
                 eth_hw_addr_random(bond_dev);
+                bond->nest_level = SINGLE_DEPTH_NESTING;
+        } else {
+                bond->nest_level = dev_get_nest_level(bond_dev) + 1;
         }
 
         unblock_netpoll_tx();
diff --git a/drivers/net/can/dev.c b/drivers/net/can/dev.c
index 3b3f88ffab53..c05e4d50d43d 100644
--- a/drivers/net/can/dev.c
+++ b/drivers/net/can/dev.c
@@ -480,8 +480,6 @@ EXPORT_SYMBOL_GPL(can_put_echo_skb);
 struct sk_buff *__can_get_echo_skb(struct net_device *dev, unsigned int idx, u8 *len_ptr)
 {
         struct can_priv *priv = netdev_priv(dev);
-        struct sk_buff *skb = priv->echo_skb[idx];
-        struct canfd_frame *cf;
 
         if (idx >= priv->echo_skb_max) {
                 netdev_err(dev, "%s: BUG! Trying to access can_priv::echo_skb out of bounds (%u/max %u)\n",
@@ -489,20 +487,21 @@ struct sk_buff *__can_get_echo_skb(struct net_device *dev, unsigned int idx, u8
                 return NULL;
         }
 
-        if (!skb) {
-                netdev_err(dev, "%s: BUG! Trying to echo non existing skb: can_priv::echo_skb[%u]\n",
-                           __func__, idx);
-                return NULL;
-        }
+        if (priv->echo_skb[idx]) {
+                /* Using "struct canfd_frame::len" for the frame
+                 * length is supported on both CAN and CANFD frames.
+                 */
+                struct sk_buff *skb = priv->echo_skb[idx];
+                struct canfd_frame *cf = (struct canfd_frame *)skb->data;
+                u8 len = cf->len;
 
-        /* Using "struct canfd_frame::len" for the frame
-         * length is supported on both CAN and CANFD frames.
-         */
-        cf = (struct canfd_frame *)skb->data;
-        *len_ptr = cf->len;
-        priv->echo_skb[idx] = NULL;
+                *len_ptr = len;
+                priv->echo_skb[idx] = NULL;
 
-        return skb;
+                return skb;
+        }
+
+        return NULL;
 }
 
 /*
diff --git a/drivers/net/can/flexcan.c b/drivers/net/can/flexcan.c
index 0f36eafe3ac1..1c66fb2ad76b 100644
--- a/drivers/net/can/flexcan.c
+++ b/drivers/net/can/flexcan.c
@@ -1106,7 +1106,7 @@ static int flexcan_chip_start(struct net_device *dev)
                 }
         } else {
                 /* clear and invalidate unused mailboxes first */
-                for (i = FLEXCAN_TX_MB_RESERVED_OFF_FIFO; i <= priv->mb_count; i++) {
+                for (i = FLEXCAN_TX_MB_RESERVED_OFF_FIFO; i < priv->mb_count; i++) {
                         mb = flexcan_get_mb(priv, i);
                         priv->write(FLEXCAN_MB_CODE_RX_INACTIVE,
                                     &mb->can_ctrl);
@@ -1432,7 +1432,7 @@ static int flexcan_setup_stop_mode(struct platform_device *pdev)
         gpr_np = of_find_node_by_phandle(phandle);
         if (!gpr_np) {
                 dev_dbg(&pdev->dev, "could not find gpr node by phandle\n");
-                return PTR_ERR(gpr_np);
+                return -ENODEV;
         }
 
         priv = netdev_priv(dev);
diff --git a/drivers/net/dsa/microchip/ksz_common.c b/drivers/net/dsa/microchip/ksz_common.c
index 3b12e2dcff31..8a5111f9414c 100644
--- a/drivers/net/dsa/microchip/ksz_common.c
+++ b/drivers/net/dsa/microchip/ksz_common.c
@@ -7,7 +7,6 @@
 
 #include <linux/delay.h>
 #include <linux/export.h>
-#include <linux/gpio.h>
 #include <linux/gpio/consumer.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
@@ -15,7 +14,6 @@
 #include <linux/phy.h>
 #include <linux/etherdevice.h>
 #include <linux/if_bridge.h>
-#include <linux/of_gpio.h>
 #include <linux/of_net.h>
 #include <net/dsa.h>
 #include <net/switchdev.h>
diff --git a/drivers/net/dsa/mt7530.c b/drivers/net/dsa/mt7530.c
index 74547f43b938..a8a2c728afba 100644
--- a/drivers/net/dsa/mt7530.c
+++ b/drivers/net/dsa/mt7530.c
@@ -18,7 +18,6 @@
 #include <linux/mfd/syscon.h>
 #include <linux/module.h>
 #include <linux/netdevice.h>
-#include <linux/of_gpio.h>
 #include <linux/of_mdio.h>
 #include <linux/of_net.h>
 #include <linux/of_platform.h>
diff --git a/drivers/net/dsa/mv88e6xxx/chip.c b/drivers/net/dsa/mv88e6xxx/chip.c
index 8a517d8fb9d1..8dca2c949e73 100644
--- a/drivers/net/dsa/mv88e6xxx/chip.c
+++ b/drivers/net/dsa/mv88e6xxx/chip.c
@@ -2403,6 +2403,107 @@ static int mv88e6xxx_stats_setup(struct mv88e6xxx_chip *chip)
         return mv88e6xxx_g1_stats_clear(chip);
 }
 
+/* The mv88e6390 has some hidden registers used for debug and
+ * development. The errata also makes use of them.
+ */
+static int mv88e6390_hidden_write(struct mv88e6xxx_chip *chip, int port,
+                                  int reg, u16 val)
+{
+        u16 ctrl;
+        int err;
+
+        err = mv88e6xxx_port_write(chip, PORT_RESERVED_1A_DATA_PORT,
+                                   PORT_RESERVED_1A, val);
+        if (err)
+                return err;
+
+        ctrl = PORT_RESERVED_1A_BUSY | PORT_RESERVED_1A_WRITE |
+               PORT_RESERVED_1A_BLOCK | port << PORT_RESERVED_1A_PORT_SHIFT |
+               reg;
+
+        return mv88e6xxx_port_write(chip, PORT_RESERVED_1A_CTRL_PORT,
+                                    PORT_RESERVED_1A, ctrl);
+}
+
+static int mv88e6390_hidden_wait(struct mv88e6xxx_chip *chip)
+{
+        return mv88e6xxx_wait(chip, PORT_RESERVED_1A_CTRL_PORT,
+                              PORT_RESERVED_1A, PORT_RESERVED_1A_BUSY);
+}
+
+
+static int mv88e6390_hidden_read(struct mv88e6xxx_chip *chip, int port,
+                                  int reg, u16 *val)
+{
+        u16 ctrl;
+        int err;
+
+        ctrl = PORT_RESERVED_1A_BUSY | PORT_RESERVED_1A_READ |
+               PORT_RESERVED_1A_BLOCK | port << PORT_RESERVED_1A_PORT_SHIFT |
+               reg;
+
+        err = mv88e6xxx_port_write(chip, PORT_RESERVED_1A_CTRL_PORT,
+                                   PORT_RESERVED_1A, ctrl);
+        if (err)
+                return err;
+
+        err = mv88e6390_hidden_wait(chip);
+        if (err)
+                return err;
+
+        return  mv88e6xxx_port_read(chip, PORT_RESERVED_1A_DATA_PORT,
+                                    PORT_RESERVED_1A, val);
+}
+
+/* Check if the errata has already been applied. */
+static bool mv88e6390_setup_errata_applied(struct mv88e6xxx_chip *chip)
+{
+        int port;
+        int err;
+        u16 val;
+
+        for (port = 0; port < mv88e6xxx_num_ports(chip); port++) {
+                err = mv88e6390_hidden_read(chip, port, 0, &val);
+                if (err) {
+                        dev_err(chip->dev,
+                                "Error reading hidden register: %d\n", err);
+                        return false;
+                }
+                if (val != 0x01c0)
+                        return false;
+        }
+
+        return true;
+}
+
+/* The 6390 copper ports have an errata which require poking magic
+ * values into undocumented hidden registers and then performing a
+ * software reset.
+ */
+static int mv88e6390_setup_errata(struct mv88e6xxx_chip *chip)
+{
+        int port;
+        int err;
+
+        if (mv88e6390_setup_errata_applied(chip))
+                return 0;
+
+        /* Set the ports into blocking mode */
+        for (port = 0; port < mv88e6xxx_num_ports(chip); port++) {
+                err = mv88e6xxx_port_set_state(chip, port, BR_STATE_DISABLED);
+                if (err)
+                        return err;
+        }
+
+        for (port = 0; port < mv88e6xxx_num_ports(chip); port++) {
+                err = mv88e6390_hidden_write(chip, port, 0, 0x01c0);
+                if (err)
+                        return err;
+        }
+
+        return mv88e6xxx_software_reset(chip);
+}
+
 static int mv88e6xxx_setup(struct dsa_switch *ds)
 {
         struct mv88e6xxx_chip *chip = ds->priv;
@@ -2415,6 +2516,12 @@ static int mv88e6xxx_setup(struct dsa_switch *ds)
 
         mutex_lock(&chip->reg_lock);
 
+        if (chip->info->ops->setup_errata) {
+                err = chip->info->ops->setup_errata(chip);
+                if (err)
+                        goto unlock;
+        }
+
         /* Cache the cmode of each port. */
         for (i = 0; i < mv88e6xxx_num_ports(chip); i++) {
                 if (chip->info->ops->port_get_cmode) {
@@ -3226,6 +3333,7 @@ static const struct mv88e6xxx_ops mv88e6185_ops = {
 
 static const struct mv88e6xxx_ops mv88e6190_ops = {
         /* MV88E6XXX_FAMILY_6390 */
+        .setup_errata = mv88e6390_setup_errata,
         .irl_init_all = mv88e6390_g2_irl_init_all,
         .get_eeprom = mv88e6xxx_g2_get_eeprom8,
         .set_eeprom = mv88e6xxx_g2_set_eeprom8,
@@ -3269,6 +3377,7 @@ static const struct mv88e6xxx_ops mv88e6190_ops = {
 
 static const struct mv88e6xxx_ops mv88e6190x_ops = {
         /* MV88E6XXX_FAMILY_6390 */
+        .setup_errata = mv88e6390_setup_errata,
         .irl_init_all = mv88e6390_g2_irl_init_all,
         .get_eeprom = mv88e6xxx_g2_get_eeprom8,
         .set_eeprom = mv88e6xxx_g2_set_eeprom8,
@@ -3312,6 +3421,7 @@ static const struct mv88e6xxx_ops mv88e6190x_ops = {
 
 static const struct mv88e6xxx_ops mv88e6191_ops = {
         /* MV88E6XXX_FAMILY_6390 */
+        .setup_errata = mv88e6390_setup_errata,
         .irl_init_all = mv88e6390_g2_irl_init_all,
         .get_eeprom = mv88e6xxx_g2_get_eeprom8,
         .set_eeprom = mv88e6xxx_g2_set_eeprom8,
@@ -3404,6 +3514,7 @@ static const struct mv88e6xxx_ops mv88e6240_ops = {
 
 static const struct mv88e6xxx_ops mv88e6290_ops = {
         /* MV88E6XXX_FAMILY_6390 */
+        .setup_errata = mv88e6390_setup_errata,
         .irl_init_all = mv88e6390_g2_irl_init_all,
         .get_eeprom = mv88e6xxx_g2_get_eeprom8,
         .set_eeprom = mv88e6xxx_g2_set_eeprom8,
@@ -3709,6 +3820,7 @@ static const struct mv88e6xxx_ops mv88e6352_ops = {
 
 static const struct mv88e6xxx_ops mv88e6390_ops = {
         /* MV88E6XXX_FAMILY_6390 */
+        .setup_errata = mv88e6390_setup_errata,
         .irl_init_all = mv88e6390_g2_irl_init_all,
         .get_eeprom = mv88e6xxx_g2_get_eeprom8,
         .set_eeprom = mv88e6xxx_g2_set_eeprom8,
@@ -3756,6 +3868,7 @@ static const struct mv88e6xxx_ops mv88e6390_ops = {
 
 static const struct mv88e6xxx_ops mv88e6390x_ops = {
         /* MV88E6XXX_FAMILY_6390 */
+        .setup_errata = mv88e6390_setup_errata,
         .irl_init_all = mv88e6390_g2_irl_init_all,
         .get_eeprom = mv88e6xxx_g2_get_eeprom8,
         .set_eeprom = mv88e6xxx_g2_set_eeprom8,
diff --git a/drivers/net/dsa/mv88e6xxx/chip.h b/drivers/net/dsa/mv88e6xxx/chip.h
index f9ecb7872d32..546651d8c3e1 100644
--- a/drivers/net/dsa/mv88e6xxx/chip.h
+++ b/drivers/net/dsa/mv88e6xxx/chip.h
@@ -300,6 +300,11 @@ struct mv88e6xxx_mdio_bus {
 };
 
 struct mv88e6xxx_ops {
+        /* Switch Setup Errata, called early in the switch setup to
+         * allow any errata actions to be performed
+         */
+        int (*setup_errata)(struct mv88e6xxx_chip *chip);
+
         int (*ieee_pri_map)(struct mv88e6xxx_chip *chip);
         int (*ip_pri_map)(struct mv88e6xxx_chip *chip);
 
diff --git a/drivers/net/dsa/mv88e6xxx/port.h b/drivers/net/dsa/mv88e6xxx/port.h
index 0d81866d0e4a..e583641de758 100644
--- a/drivers/net/dsa/mv88e6xxx/port.h
+++ b/drivers/net/dsa/mv88e6xxx/port.h
@@ -251,6 +251,16 @@
 /* Offset 0x19: Port IEEE Priority Remapping Registers (4-7) */
 #define MV88E6095_PORT_IEEE_PRIO_REMAP_4567     0x19
 
+/* Offset 0x1a: Magic undocumented errata register */
+#define PORT_RESERVED_1A                        0x1a
+#define PORT_RESERVED_1A_BUSY                   BIT(15)
+#define PORT_RESERVED_1A_WRITE                  BIT(14)
+#define PORT_RESERVED_1A_READ                   0
+#define PORT_RESERVED_1A_PORT_SHIFT             5
+#define PORT_RESERVED_1A_BLOCK                  (0xf << 10)
+#define PORT_RESERVED_1A_CTRL_PORT              4
+#define PORT_RESERVED_1A_DATA_PORT              5
+
 int mv88e6xxx_port_read(struct mv88e6xxx_chip *chip, int port, int reg,
                         u16 *val);
 int mv88e6xxx_port_write(struct mv88e6xxx_chip *chip, int port, int reg,
diff --git a/drivers/net/dsa/realtek-smi.c b/drivers/net/dsa/realtek-smi.c
index b4b839a1d095..ad41ec63cc9f 100644
--- a/drivers/net/dsa/realtek-smi.c
+++ b/drivers/net/dsa/realtek-smi.c
@@ -347,16 +347,17 @@ int realtek_smi_setup_mdio(struct realtek_smi *smi)
         struct device_node *mdio_np;
         int ret;
 
-        mdio_np = of_find_compatible_node(smi->dev->of_node, NULL,
-                                          "realtek,smi-mdio");
+        mdio_np = of_get_compatible_child(smi->dev->of_node, "realtek,smi-mdio");
         if (!mdio_np) {
                 dev_err(smi->dev, "no MDIO bus node\n");
                 return -ENODEV;
         }
 
         smi->slave_mii_bus = devm_mdiobus_alloc(smi->dev);
-        if (!smi->slave_mii_bus)
-                return -ENOMEM;
+        if (!smi->slave_mii_bus) {
+                ret = -ENOMEM;
+                goto err_put_node;
+        }
         smi->slave_mii_bus->priv = smi;
         smi->slave_mii_bus->name = "SMI slave MII";
         smi->slave_mii_bus->read = realtek_smi_mdio_read;
@@ -371,10 +372,15 @@ int realtek_smi_setup_mdio(struct realtek_smi *smi)
         if (ret) {
                 dev_err(smi->dev, "unable to register MDIO bus %s\n",
                         smi->slave_mii_bus->id);
-                of_node_put(mdio_np);
+                goto err_put_node;
         }
 
         return 0;
+
+err_put_node:
+        of_node_put(mdio_np);
+
+        return ret;
 }
 
 static int realtek_smi_probe(struct platform_device *pdev)
@@ -457,6 +463,8 @@ static int realtek_smi_remove(struct platform_device *pdev)
         struct realtek_smi *smi = dev_get_drvdata(&pdev->dev);
 
         dsa_unregister_switch(smi->ds);
+        if (smi->slave_mii_bus)
+                of_node_put(smi->slave_mii_bus->dev.of_node);
         gpiod_set_value(smi->reset, 1);
 
         return 0;
diff --git a/drivers/net/ethernet/aeroflex/greth.c b/drivers/net/ethernet/aeroflex/greth.c
index 91fc64c1145e..47e5984f16fb 100644
--- a/drivers/net/ethernet/aeroflex/greth.c
+++ b/drivers/net/ethernet/aeroflex/greth.c
@@ -1433,18 +1433,18 @@ static int greth_of_probe(struct platform_device *ofdev)
         }
 
         /* Allocate TX descriptor ring in coherent memory */
-        greth->tx_bd_base = dma_zalloc_coherent(greth->dev, 1024,
-                                                &greth->tx_bd_base_phys,
-                                                GFP_KERNEL);
+        greth->tx_bd_base = dma_alloc_coherent(greth->dev, 1024,
+                                               &greth->tx_bd_base_phys,
+                                               GFP_KERNEL);
         if (!greth->tx_bd_base) {
                 err = -ENOMEM;
                 goto error3;
         }
 
         /* Allocate RX descriptor ring in coherent memory */
-        greth->rx_bd_base = dma_zalloc_coherent(greth->dev, 1024,
-                                                &greth->rx_bd_base_phys,
-                                                GFP_KERNEL);
+        greth->rx_bd_base = dma_alloc_coherent(greth->dev, 1024,
+                                               &greth->rx_bd_base_phys,
+                                               GFP_KERNEL);
         if (!greth->rx_bd_base) {
                 err = -ENOMEM;
                 goto error4;
diff --git a/drivers/net/ethernet/alacritech/slicoss.c b/drivers/net/ethernet/alacritech/slicoss.c
index 0b60921c392f..16477aa6d61f 100644
--- a/drivers/net/ethernet/alacritech/slicoss.c
+++ b/drivers/net/ethernet/alacritech/slicoss.c
@@ -795,8 +795,8 @@ static int slic_init_stat_queue(struct slic_device *sdev)
         size = stq->len * sizeof(*descs) + DESC_ALIGN_MASK;
 
         for (i = 0; i < SLIC_NUM_STAT_DESC_ARRAYS; i++) {
-                descs = dma_zalloc_coherent(&sdev->pdev->dev, size, &paddr,
-                                            GFP_KERNEL);
+                descs = dma_alloc_coherent(&sdev->pdev->dev, size, &paddr,
+                                           GFP_KERNEL);
                 if (!descs) {
                         netdev_err(sdev->netdev,
                                    "failed to allocate status descriptors\n");
@@ -1240,8 +1240,8 @@ static int slic_init_shmem(struct slic_device *sdev)
         struct slic_shmem_data *sm_data;
         dma_addr_t paddr;
 
-        sm_data = dma_zalloc_coherent(&sdev->pdev->dev, sizeof(*sm_data),
-                                      &paddr, GFP_KERNEL);
+        sm_data = dma_alloc_coherent(&sdev->pdev->dev, sizeof(*sm_data),
+                                     &paddr, GFP_KERNEL);
         if (!sm_data) {
                 dev_err(&sdev->pdev->dev, "failed to allocate shared memory\n");
                 return -ENOMEM;
@@ -1621,8 +1621,8 @@ static int slic_read_eeprom(struct slic_device *sdev)
         int err = 0;
         u8 *mac[2];
 
-        eeprom = dma_zalloc_coherent(&sdev->pdev->dev, SLIC_EEPROM_SIZE,
-                                     &paddr, GFP_KERNEL);
+        eeprom = dma_alloc_coherent(&sdev->pdev->dev, SLIC_EEPROM_SIZE,
+                                    &paddr, GFP_KERNEL);
         if (!eeprom)
                 return -ENOMEM;
 
diff --git a/drivers/net/ethernet/altera/altera_tse_main.c b/drivers/net/ethernet/altera/altera_tse_main.c
index 02921d877c08..aa1d1f5339d2 100644
--- a/drivers/net/ethernet/altera/altera_tse_main.c
+++ b/drivers/net/ethernet/altera/altera_tse_main.c
@@ -714,8 +714,10 @@ static struct phy_device *connect_local_phy(struct net_device *dev)
 
                 phydev = phy_connect(dev, phy_id_fmt, &altera_tse_adjust_link,
                                      priv->phy_iface);
-                if (IS_ERR(phydev))
+                if (IS_ERR(phydev)) {
                         netdev_err(dev, "Could not attach to PHY\n");
+                        phydev = NULL;
+                }
 
         } else {
                 int ret;
diff --git a/drivers/net/ethernet/amazon/ena/ena_com.c b/drivers/net/ethernet/amazon/ena/ena_com.c
index 420cede41ca4..b17d435de09f 100644
--- a/drivers/net/ethernet/amazon/ena/ena_com.c
+++ b/drivers/net/ethernet/amazon/ena/ena_com.c
@@ -111,8 +111,8 @@ static int ena_com_admin_init_sq(struct ena_com_admin_queue *queue)
         struct ena_com_admin_sq *sq = &queue->sq;
         u16 size = ADMIN_SQ_SIZE(queue->q_depth);
 
-        sq->entries = dma_zalloc_coherent(queue->q_dmadev, size, &sq->dma_addr,
-                                          GFP_KERNEL);
+        sq->entries = dma_alloc_coherent(queue->q_dmadev, size, &sq->dma_addr,
+                                         GFP_KERNEL);
 
         if (!sq->entries) {
                 pr_err("memory allocation failed");
@@ -133,8 +133,8 @@ static int ena_com_admin_init_cq(struct ena_com_admin_queue *queue)
         struct ena_com_admin_cq *cq = &queue->cq;
         u16 size = ADMIN_CQ_SIZE(queue->q_depth);
 
-        cq->entries = dma_zalloc_coherent(queue->q_dmadev, size, &cq->dma_addr,
-                                          GFP_KERNEL);
+        cq->entries = dma_alloc_coherent(queue->q_dmadev, size, &cq->dma_addr,
+                                         GFP_KERNEL);
 
         if (!cq->entries) {
                 pr_err("memory allocation failed");
@@ -156,8 +156,8 @@ static int ena_com_admin_init_aenq(struct ena_com_dev *dev,
 
         dev->aenq.q_depth = ENA_ASYNC_QUEUE_DEPTH;
         size = ADMIN_AENQ_SIZE(ENA_ASYNC_QUEUE_DEPTH);
-        aenq->entries = dma_zalloc_coherent(dev->dmadev, size, &aenq->dma_addr,
-                                            GFP_KERNEL);
+        aenq->entries = dma_alloc_coherent(dev->dmadev, size, &aenq->dma_addr,
+                                           GFP_KERNEL);
 
         if (!aenq->entries) {
                 pr_err("memory allocation failed");
@@ -344,15 +344,15 @@ static int ena_com_init_io_sq(struct ena_com_dev *ena_dev,
                 dev_node = dev_to_node(ena_dev->dmadev);
                 set_dev_node(ena_dev->dmadev, ctx->numa_node);
                 io_sq->desc_addr.virt_addr =
-                        dma_zalloc_coherent(ena_dev->dmadev, size,
-                                            &io_sq->desc_addr.phys_addr,
-                                            GFP_KERNEL);
+                        dma_alloc_coherent(ena_dev->dmadev, size,
+                                           &io_sq->desc_addr.phys_addr,
+                                           GFP_KERNEL);
                 set_dev_node(ena_dev->dmadev, dev_node);
                 if (!io_sq->desc_addr.virt_addr) {
                         io_sq->desc_addr.virt_addr =
-                                dma_zalloc_coherent(ena_dev->dmadev, size,
-                                                    &io_sq->desc_addr.phys_addr,
-                                                    GFP_KERNEL);
+                                dma_alloc_coherent(ena_dev->dmadev, size,
+                                                   &io_sq->desc_addr.phys_addr,
+                                                   GFP_KERNEL);
                 }
 
                 if (!io_sq->desc_addr.virt_addr) {
@@ -425,14 +425,14 @@ static int ena_com_init_io_cq(struct ena_com_dev *ena_dev,
         prev_node = dev_to_node(ena_dev->dmadev);
         set_dev_node(ena_dev->dmadev, ctx->numa_node);
         io_cq->cdesc_addr.virt_addr =
-                dma_zalloc_coherent(ena_dev->dmadev, size,
-                                    &io_cq->cdesc_addr.phys_addr, GFP_KERNEL);
+                dma_alloc_coherent(ena_dev->dmadev, size,
+                                   &io_cq->cdesc_addr.phys_addr, GFP_KERNEL);
         set_dev_node(ena_dev->dmadev, prev_node);
         if (!io_cq->cdesc_addr.virt_addr) {
                 io_cq->cdesc_addr.virt_addr =
-                        dma_zalloc_coherent(ena_dev->dmadev, size,
-                                            &io_cq->cdesc_addr.phys_addr,
-                                            GFP_KERNEL);
+                        dma_alloc_coherent(ena_dev->dmadev, size,
+                                           &io_cq->cdesc_addr.phys_addr,
+                                           GFP_KERNEL);
         }
 
         if (!io_cq->cdesc_addr.virt_addr) {
@@ -1026,8 +1026,8 @@ static int ena_com_hash_key_allocate(struct ena_com_dev *ena_dev)
         struct ena_rss *rss = &ena_dev->rss;
 
         rss->hash_key =
-                dma_zalloc_coherent(ena_dev->dmadev, sizeof(*rss->hash_key),
-                                    &rss->hash_key_dma_addr, GFP_KERNEL);
+                dma_alloc_coherent(ena_dev->dmadev, sizeof(*rss->hash_key),
+                                   &rss->hash_key_dma_addr, GFP_KERNEL);
 
         if (unlikely(!rss->hash_key))
                 return -ENOMEM;
@@ -1050,8 +1050,8 @@ static int ena_com_hash_ctrl_init(struct ena_com_dev *ena_dev)
         struct ena_rss *rss = &ena_dev->rss;
 
         rss->hash_ctrl =
-                dma_zalloc_coherent(ena_dev->dmadev, sizeof(*rss->hash_ctrl),
-                                    &rss->hash_ctrl_dma_addr, GFP_KERNEL);
+                dma_alloc_coherent(ena_dev->dmadev, sizeof(*rss->hash_ctrl),
+                                   &rss->hash_ctrl_dma_addr, GFP_KERNEL);
 
         if (unlikely(!rss->hash_ctrl))
                 return -ENOMEM;
@@ -1094,8 +1094,8 @@ static int ena_com_indirect_table_allocate(struct ena_com_dev *ena_dev,
                 sizeof(struct ena_admin_rss_ind_table_entry);
 
         rss->rss_ind_tbl =
-                dma_zalloc_coherent(ena_dev->dmadev, tbl_size,
-                                    &rss->rss_ind_tbl_dma_addr, GFP_KERNEL);
+                dma_alloc_coherent(ena_dev->dmadev, tbl_size,
+                                   &rss->rss_ind_tbl_dma_addr, GFP_KERNEL);
         if (unlikely(!rss->rss_ind_tbl))
                 goto mem_err1;
 
@@ -1649,9 +1649,9 @@ int ena_com_mmio_reg_read_request_init(struct ena_com_dev *ena_dev)
 
         spin_lock_init(&mmio_read->lock);
         mmio_read->read_resp =
-                dma_zalloc_coherent(ena_dev->dmadev,
-                                    sizeof(*mmio_read->read_resp),
-                                    &mmio_read->read_resp_dma_addr, GFP_KERNEL);
+                dma_alloc_coherent(ena_dev->dmadev,
+                                   sizeof(*mmio_read->read_resp),
+                                   &mmio_read->read_resp_dma_addr, GFP_KERNEL);
         if (unlikely(!mmio_read->read_resp))
                 goto err;
 
@@ -2623,8 +2623,8 @@ int ena_com_allocate_host_info(struct ena_com_dev *ena_dev)
         struct ena_host_attribute *host_attr = &ena_dev->host_attr;
 
         host_attr->host_info =
-                dma_zalloc_coherent(ena_dev->dmadev, SZ_4K,
-                                    &host_attr->host_info_dma_addr, GFP_KERNEL);
+                dma_alloc_coherent(ena_dev->dmadev, SZ_4K,
+                                   &host_attr->host_info_dma_addr, GFP_KERNEL);
         if (unlikely(!host_attr->host_info))
                 return -ENOMEM;
 
@@ -2641,8 +2641,9 @@ int ena_com_allocate_debug_area(struct ena_com_dev *ena_dev,
         struct ena_host_attribute *host_attr = &ena_dev->host_attr;
 
         host_attr->debug_area_virt_addr =
-                dma_zalloc_coherent(ena_dev->dmadev, debug_area_size,
-                                    &host_attr->debug_area_dma_addr, GFP_KERNEL);
+                dma_alloc_coherent(ena_dev->dmadev, debug_area_size,
+                                   &host_attr->debug_area_dma_addr,
+                                   GFP_KERNEL);
         if (unlikely(!host_attr->debug_area_virt_addr)) {
                 host_attr->debug_area_size = 0;
                 return -ENOMEM;
diff --git a/drivers/net/ethernet/amd/xgbe/xgbe-common.h b/drivers/net/ethernet/amd/xgbe/xgbe-common.h
index d272dc6984ac..b40d4377cc71 100644
--- a/drivers/net/ethernet/amd/xgbe/xgbe-common.h
+++ b/drivers/net/ethernet/amd/xgbe/xgbe-common.h
@@ -431,8 +431,6 @@
 #define MAC_MDIOSCAR_PA_WIDTH           5
 #define MAC_MDIOSCAR_RA_INDEX           0
 #define MAC_MDIOSCAR_RA_WIDTH           16
-#define MAC_MDIOSCAR_REG_INDEX          0
-#define MAC_MDIOSCAR_REG_WIDTH          21
 #define MAC_MDIOSCCDR_BUSY_INDEX        22
 #define MAC_MDIOSCCDR_BUSY_WIDTH        1
 #define MAC_MDIOSCCDR_CMD_INDEX         16
diff --git a/drivers/net/ethernet/amd/xgbe/xgbe-dev.c b/drivers/net/ethernet/amd/xgbe/xgbe-dev.c
index 1e929a1e4ca7..4666084eda16 100644
--- a/drivers/net/ethernet/amd/xgbe/xgbe-dev.c
+++ b/drivers/net/ethernet/amd/xgbe/xgbe-dev.c
@@ -1284,6 +1284,20 @@ static void xgbe_write_mmd_regs(struct xgbe_prv_data *pdata, int prtad,
         }
 }
 
+static unsigned int xgbe_create_mdio_sca(int port, int reg)
+{
+        unsigned int mdio_sca, da;
+
+        da = (reg & MII_ADDR_C45) ? reg >> 16 : 0;
+
+        mdio_sca = 0;
+        XGMAC_SET_BITS(mdio_sca, MAC_MDIOSCAR, RA, reg);
+        XGMAC_SET_BITS(mdio_sca, MAC_MDIOSCAR, PA, port);
+        XGMAC_SET_BITS(mdio_sca, MAC_MDIOSCAR, DA, da);
+
+        return mdio_sca;
+}
+
 static int xgbe_write_ext_mii_regs(struct xgbe_prv_data *pdata, int addr,
                                    int reg, u16 val)
 {
@@ -1291,9 +1305,7 @@ static int xgbe_write_ext_mii_regs(struct xgbe_prv_data *pdata, int addr,
 
         reinit_completion(&pdata->mdio_complete);
 
-        mdio_sca = 0;
-        XGMAC_SET_BITS(mdio_sca, MAC_MDIOSCAR, REG, reg);
-        XGMAC_SET_BITS(mdio_sca, MAC_MDIOSCAR, DA, addr);
+        mdio_sca = xgbe_create_mdio_sca(addr, reg);
         XGMAC_IOWRITE(pdata, MAC_MDIOSCAR, mdio_sca);
 
         mdio_sccd = 0;
@@ -1317,9 +1329,7 @@ static int xgbe_read_ext_mii_regs(struct xgbe_prv_data *pdata, int addr,
 
         reinit_completion(&pdata->mdio_complete);
 
-        mdio_sca = 0;
-        XGMAC_SET_BITS(mdio_sca, MAC_MDIOSCAR, REG, reg);
-        XGMAC_SET_BITS(mdio_sca, MAC_MDIOSCAR, DA, addr);
+        mdio_sca = xgbe_create_mdio_sca(addr, reg);
         XGMAC_IOWRITE(pdata, MAC_MDIOSCAR, mdio_sca);
 
         mdio_sccd = 0;
diff --git a/drivers/net/ethernet/apm/xgene-v2/main.c b/drivers/net/ethernet/apm/xgene-v2/main.c
index 0f2ad50f3bd7..87b142a312e0 100644
--- a/drivers/net/ethernet/apm/xgene-v2/main.c
+++ b/drivers/net/ethernet/apm/xgene-v2/main.c
@@ -206,8 +206,8 @@ static netdev_tx_t xge_start_xmit(struct sk_buff *skb, struct net_device *ndev)
         }
 
         /* Packet buffers should be 64B aligned */
-        pkt_buf = dma_zalloc_coherent(dev, XGENE_ENET_STD_MTU, &dma_addr,
-                                      GFP_ATOMIC);
+        pkt_buf = dma_alloc_coherent(dev, XGENE_ENET_STD_MTU, &dma_addr,
+                                     GFP_ATOMIC);
         if (unlikely(!pkt_buf)) {
                 dev_kfree_skb_any(skb);
                 return NETDEV_TX_OK;
@@ -428,8 +428,8 @@ static struct xge_desc_ring *xge_create_desc_ring(struct net_device *ndev)
         ring->ndev = ndev;
 
         size = XGENE_ENET_DESC_SIZE * XGENE_ENET_NUM_DESC;
-        ring->desc_addr = dma_zalloc_coherent(dev, size, &ring->dma_addr,
-                                              GFP_KERNEL);
+        ring->desc_addr = dma_alloc_coherent(dev, size, &ring->dma_addr,
+                                             GFP_KERNEL);
         if (!ring->desc_addr)
                 goto err;
 
diff --git a/drivers/net/ethernet/atheros/alx/main.c b/drivers/net/ethernet/atheros/alx/main.c
index c131cfc1b79d..e3538ba7d0e7 100644
--- a/drivers/net/ethernet/atheros/alx/main.c
+++ b/drivers/net/ethernet/atheros/alx/main.c
@@ -660,10 +660,9 @@ static int alx_alloc_rings(struct alx_priv *alx)
                             alx->num_txq +
                             sizeof(struct alx_rrd) * alx->rx_ringsz +
                             sizeof(struct alx_rfd) * alx->rx_ringsz;
-        alx->descmem.virt = dma_zalloc_coherent(&alx->hw.pdev->dev,
-                                                alx->descmem.size,
-                                                &alx->descmem.dma,
-                                                GFP_KERNEL);
+        alx->descmem.virt = dma_alloc_coherent(&alx->hw.pdev->dev,
+                                               alx->descmem.size,
+                                               &alx->descmem.dma, GFP_KERNEL);
         if (!alx->descmem.virt)
                 return -ENOMEM;
 
diff --git a/drivers/net/ethernet/atheros/atl1c/atl1c_main.c b/drivers/net/ethernet/atheros/atl1c/atl1c_main.c
index 7087b88550db..3a3b35b5df67 100644
--- a/drivers/net/ethernet/atheros/atl1c/atl1c_main.c
+++ b/drivers/net/ethernet/atheros/atl1c/atl1c_main.c
@@ -1019,8 +1019,8 @@ static int atl1c_setup_ring_resources(struct atl1c_adapter *adapter)
                 sizeof(struct atl1c_recv_ret_status) * rx_desc_count +
                 8 * 4;
 
-        ring_header->desc = dma_zalloc_coherent(&pdev->dev, ring_header->size,
-                                                &ring_header->dma, GFP_KERNEL);
+        ring_header->desc = dma_alloc_coherent(&pdev->dev, ring_header->size,
+                                               &ring_header->dma, GFP_KERNEL);
         if (unlikely(!ring_header->desc)) {
                 dev_err(&pdev->dev, "could not get memory for DMA buffer\n");
                 goto err_nomem;
diff --git a/drivers/net/ethernet/broadcom/bcm63xx_enet.c b/drivers/net/ethernet/broadcom/bcm63xx_enet.c
index 6bae973d4dce..09cd188826b1 100644
--- a/drivers/net/ethernet/broadcom/bcm63xx_enet.c
+++ b/drivers/net/ethernet/broadcom/bcm63xx_enet.c
@@ -936,7 +936,7 @@ static int bcm_enet_open(struct net_device *dev)
 
         /* allocate rx dma ring */
         size = priv->rx_ring_size * sizeof(struct bcm_enet_desc);
-        p = dma_zalloc_coherent(kdev, size, &priv->rx_desc_dma, GFP_KERNEL);
+        p = dma_alloc_coherent(kdev, size, &priv->rx_desc_dma, GFP_KERNEL);
         if (!p) {
                 ret = -ENOMEM;
                 goto out_freeirq_tx;
@@ -947,7 +947,7 @@ static int bcm_enet_open(struct net_device *dev)
 
         /* allocate tx dma ring */
         size = priv->tx_ring_size * sizeof(struct bcm_enet_desc);
-        p = dma_zalloc_coherent(kdev, size, &priv->tx_desc_dma, GFP_KERNEL);
+        p = dma_alloc_coherent(kdev, size, &priv->tx_desc_dma, GFP_KERNEL);
         if (!p) {
                 ret = -ENOMEM;
                 goto out_free_rx_ring;
@@ -2120,7 +2120,7 @@ static int bcm_enetsw_open(struct net_device *dev)
 
         /* allocate rx dma ring */
         size = priv->rx_ring_size * sizeof(struct bcm_enet_desc);
-        p = dma_zalloc_coherent(kdev, size, &priv->rx_desc_dma, GFP_KERNEL);
+        p = dma_alloc_coherent(kdev, size, &priv->rx_desc_dma, GFP_KERNEL);
         if (!p) {
                 dev_err(kdev, "cannot allocate rx ring %u\n", size);
                 ret = -ENOMEM;
@@ -2132,7 +2132,7 @@ static int bcm_enetsw_open(struct net_device *dev)
 
         /* allocate tx dma ring */
         size = priv->tx_ring_size * sizeof(struct bcm_enet_desc);
-        p = dma_zalloc_coherent(kdev, size, &priv->tx_desc_dma, GFP_KERNEL);
+        p = dma_alloc_coherent(kdev, size, &priv->tx_desc_dma, GFP_KERNEL);
         if (!p) {
                 dev_err(kdev, "cannot allocate tx ring\n");
                 ret = -ENOMEM;
diff --git a/drivers/net/ethernet/broadcom/bcmsysport.c b/drivers/net/ethernet/broadcom/bcmsysport.c
index 4574275ef445..f9521d0274b7 100644
--- a/drivers/net/ethernet/broadcom/bcmsysport.c
+++ b/drivers/net/ethernet/broadcom/bcmsysport.c
@@ -1506,8 +1506,8 @@ static int bcm_sysport_init_tx_ring(struct bcm_sysport_priv *priv,
         /* We just need one DMA descriptor which is DMA-able, since writing to
          * the port will allocate a new descriptor in its internal linked-list
          */
-        p = dma_zalloc_coherent(kdev, sizeof(struct dma_desc), &ring->desc_dma,
-                                GFP_KERNEL);
+        p = dma_alloc_coherent(kdev, sizeof(struct dma_desc), &ring->desc_dma,
+                               GFP_KERNEL);
         if (!p) {
                 netif_err(priv, hw, priv->netdev, "DMA alloc failed\n");
                 return -ENOMEM;
diff --git a/drivers/net/ethernet/broadcom/bgmac.c b/drivers/net/ethernet/broadcom/bgmac.c
index cabc8e49ad24..2d3a44c40221 100644
--- a/drivers/net/ethernet/broadcom/bgmac.c
+++ b/drivers/net/ethernet/broadcom/bgmac.c
@@ -634,9 +634,9 @@ static int bgmac_dma_alloc(struct bgmac *bgmac)
 
                 /* Alloc ring of descriptors */
                 size = BGMAC_TX_RING_SLOTS * sizeof(struct bgmac_dma_desc);
-                ring->cpu_base = dma_zalloc_coherent(dma_dev, size,
-                                                     &ring->dma_base,
-                                                     GFP_KERNEL);
+                ring->cpu_base = dma_alloc_coherent(dma_dev, size,
+                                                    &ring->dma_base,
+                                                    GFP_KERNEL);
                 if (!ring->cpu_base) {
                         dev_err(bgmac->dev, "Allocation of TX ring 0x%X failed\n",
                                 ring->mmio_base);
@@ -659,9 +659,9 @@ static int bgmac_dma_alloc(struct bgmac *bgmac)
 
                 /* Alloc ring of descriptors */
                 size = BGMAC_RX_RING_SLOTS * sizeof(struct bgmac_dma_desc);
-                ring->cpu_base = dma_zalloc_coherent(dma_dev, size,
-                                                     &ring->dma_base,
-                                                     GFP_KERNEL);
+                ring->cpu_base = dma_alloc_coherent(dma_dev, size,
+                                                    &ring->dma_base,
+                                                    GFP_KERNEL);
                 if (!ring->cpu_base) {
                         dev_err(bgmac->dev, "Allocation of RX ring 0x%X failed\n",
                                 ring->mmio_base);
diff --git a/drivers/net/ethernet/broadcom/bnx2.c b/drivers/net/ethernet/broadcom/bnx2.c
index bbb247116045..d63371d70bce 100644
--- a/drivers/net/ethernet/broadcom/bnx2.c
+++ b/drivers/net/ethernet/broadcom/bnx2.c
@@ -844,8 +844,8 @@ bnx2_alloc_stats_blk(struct net_device *dev)
                                                  BNX2_SBLK_MSIX_ALIGN_SIZE);
         bp->status_stats_size = status_blk_size +
                                 sizeof(struct statistics_block);
-        status_blk = dma_zalloc_coherent(&bp->pdev->dev, bp->status_stats_size,
-                                         &bp->status_blk_mapping, GFP_KERNEL);
+        status_blk = dma_alloc_coherent(&bp->pdev->dev, bp->status_stats_size,
+                                        &bp->status_blk_mapping, GFP_KERNEL);
         if (!status_blk)
                 return -ENOMEM;
 
diff --git a/drivers/net/ethernet/broadcom/bnx2x/bnx2x.h b/drivers/net/ethernet/broadcom/bnx2x/bnx2x.h
index 5cd3135dfe30..03d131f777bc 100644
--- a/drivers/net/ethernet/broadcom/bnx2x/bnx2x.h
+++ b/drivers/net/ethernet/broadcom/bnx2x/bnx2x.h
@@ -2081,7 +2081,7 @@ void bnx2x_igu_clear_sb_gen(struct bnx2x *bp, u8 func, u8 idu_sb_id,
                             bool is_pf);
 
 #define BNX2X_ILT_ZALLOC(x, y, size)                                    \
-        x = dma_zalloc_coherent(&bp->pdev->dev, size, y, GFP_KERNEL)
+        x = dma_alloc_coherent(&bp->pdev->dev, size, y, GFP_KERNEL)
 
 #define BNX2X_ILT_FREE(x, y, size) \
         do { \
diff --git a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.h b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.h
index 142bc11b9fbb..2462e7aa0c5d 100644
--- a/drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.h
+++ b/drivers/net/ethernet/broadcom/bnx2x/bnx2x_cmn.h
@@ -52,7 +52,7 @@ extern int bnx2x_num_queues;
 
 #define BNX2X_PCI_ALLOC(y, size)                                        \
 ({                                                                      \
-        void *x = dma_zalloc_coherent(&bp->pdev->dev, size, y, GFP_KERNEL); \
+        void *x = dma_alloc_coherent(&bp->pdev->dev, size, y, GFP_KERNEL); \
         if (x)                                                          \
                 DP(NETIF_MSG_HW,                                        \
                    "BNX2X_PCI_ALLOC: Physical %Lx Virtual %p\n",        \
diff --git a/drivers/net/ethernet/broadcom/bnxt/bnxt.c b/drivers/net/ethernet/broadcom/bnxt/bnxt.c
index 3aa80da973d7..6a512871176b 100644
--- a/drivers/net/ethernet/broadcom/bnxt/bnxt.c
+++ b/drivers/net/ethernet/broadcom/bnxt/bnxt.c
@@ -3449,10 +3449,10 @@ alloc_ext_stats:
                         goto alloc_tx_ext_stats;
 
                 bp->hw_rx_port_stats_ext =
-                        dma_zalloc_coherent(&pdev->dev,
-                                            sizeof(struct rx_port_stats_ext),
-                                            &bp->hw_rx_port_stats_ext_map,
-                                            GFP_KERNEL);
+                        dma_alloc_coherent(&pdev->dev,
+                                           sizeof(struct rx_port_stats_ext),
+                                           &bp->hw_rx_port_stats_ext_map,
+                                           GFP_KERNEL);
                 if (!bp->hw_rx_port_stats_ext)
                         return 0;
 
@@ -3462,10 +3462,10 @@ alloc_tx_ext_stats:
 
                 if (bp->hwrm_spec_code >= 0x10902) {
                         bp->hw_tx_port_stats_ext =
-                                dma_zalloc_coherent(&pdev->dev,
-                                            sizeof(struct tx_port_stats_ext),
-                                            &bp->hw_tx_port_stats_ext_map,
-                                            GFP_KERNEL);
+                                dma_alloc_coherent(&pdev->dev,
+                                                   sizeof(struct tx_port_stats_ext),
+                                                   &bp->hw_tx_port_stats_ext_map,
+                                                   GFP_KERNEL);
                 }
                 bp->flags |= BNXT_FLAG_PORT_STATS_EXT;
         }
@@ -5601,7 +5601,8 @@ static int bnxt_hwrm_check_pf_rings(struct bnxt *bp, int tx_rings, int rx_rings,
                          FUNC_CFG_REQ_FLAGS_STAT_CTX_ASSETS_TEST |
                          FUNC_CFG_REQ_FLAGS_VNIC_ASSETS_TEST;
                 if (bp->flags & BNXT_FLAG_CHIP_P5)
-                        flags |= FUNC_CFG_REQ_FLAGS_RSSCOS_CTX_ASSETS_TEST;
+                        flags |= FUNC_CFG_REQ_FLAGS_RSSCOS_CTX_ASSETS_TEST |
+                                 FUNC_CFG_REQ_FLAGS_NQ_ASSETS_TEST;
                 else
                         flags |= FUNC_CFG_REQ_FLAGS_RING_GRP_ASSETS_TEST;
         }
@@ -6221,9 +6222,12 @@ static int bnxt_alloc_ctx_pg_tbls(struct bnxt *bp,
                         rmem->pg_tbl_map = ctx_pg->ctx_dma_arr[i];
                         rmem->depth = 1;
                         rmem->nr_pages = MAX_CTX_PAGES;
-                        if (i == (nr_tbls - 1))
-                                rmem->nr_pages = ctx_pg->nr_pages %
-                                                 MAX_CTX_PAGES;
+                        if (i == (nr_tbls - 1)) {
+                                int rem = ctx_pg->nr_pages % MAX_CTX_PAGES;
+
+                                if (rem)
+                                        rmem->nr_pages = rem;
+                        }
                         rc = bnxt_alloc_ctx_mem_blk(bp, pg_tbl);
                         if (rc)
                                 break;
diff --git a/drivers/net/ethernet/broadcom/bnxt/bnxt_dcb.c b/drivers/net/ethernet/broadcom/bnxt/bnxt_dcb.c
index 15c7041e937b..70775158c8c4 100644
--- a/drivers/net/ethernet/broadcom/bnxt/bnxt_dcb.c
+++ b/drivers/net/ethernet/broadcom/bnxt/bnxt_dcb.c
@@ -316,8 +316,8 @@ static int bnxt_hwrm_set_dcbx_app(struct bnxt *bp, struct dcb_app *app,
 
         n = IEEE_8021QAZ_MAX_TCS;
         data_len = sizeof(*data) + sizeof(*fw_app) * n;
-        data = dma_zalloc_coherent(&bp->pdev->dev, data_len, &mapping,
-                                   GFP_KERNEL);
+        data = dma_alloc_coherent(&bp->pdev->dev, data_len, &mapping,
+                                  GFP_KERNEL);
         if (!data)
                 return -ENOMEM;
 
diff --git a/drivers/net/ethernet/broadcom/bnxt/bnxt_devlink.c b/drivers/net/ethernet/broadcom/bnxt/bnxt_devlink.c
index 140dbd62106d..7f56032e44ac 100644
--- a/drivers/net/ethernet/broadcom/bnxt/bnxt_devlink.c
+++ b/drivers/net/ethernet/broadcom/bnxt/bnxt_devlink.c
@@ -85,8 +85,8 @@ static int bnxt_hwrm_nvm_req(struct bnxt *bp, u32 param_id, void *msg,
                 return -EFAULT;
         }
 
-        data_addr = dma_zalloc_coherent(&bp->pdev->dev, bytesize,
-                                        &data_dma_addr, GFP_KERNEL);
+        data_addr = dma_alloc_coherent(&bp->pdev->dev, bytesize,
+                                       &data_dma_addr, GFP_KERNEL);
         if (!data_addr)
                 return -ENOMEM;
 
diff --git a/drivers/net/ethernet/broadcom/bnxt/bnxt_hsi.h b/drivers/net/ethernet/broadcom/bnxt/bnxt_hsi.h
index f1aaac8e6268..0a0995894ddb 100644
--- a/drivers/net/ethernet/broadcom/bnxt/bnxt_hsi.h
+++ b/drivers/net/ethernet/broadcom/bnxt/bnxt_hsi.h
@@ -386,8 +386,8 @@ struct hwrm_err_output {
 #define HWRM_VERSION_MAJOR 1
 #define HWRM_VERSION_MINOR 10
 #define HWRM_VERSION_UPDATE 0
-#define HWRM_VERSION_RSVD 33
-#define HWRM_VERSION_STR "1.10.0.33"
+#define HWRM_VERSION_RSVD 35
+#define HWRM_VERSION_STR "1.10.0.35"
 
 /* hwrm_ver_get_input (size:192b/24B) */
 struct hwrm_ver_get_input {
@@ -1184,6 +1184,7 @@ struct hwrm_func_cfg_input {
         #define FUNC_CFG_REQ_FLAGS_L2_CTX_ASSETS_TEST             0x100000UL
         #define FUNC_CFG_REQ_FLAGS_TRUSTED_VF_ENABLE              0x200000UL
         #define FUNC_CFG_REQ_FLAGS_DYNAMIC_TX_RING_ALLOC          0x400000UL
+        #define FUNC_CFG_REQ_FLAGS_NQ_ASSETS_TEST                 0x800000UL
         __le32  enables;
         #define FUNC_CFG_REQ_ENABLES_MTU                     0x1UL
         #define FUNC_CFG_REQ_ENABLES_MRU                     0x2UL
diff --git a/drivers/net/ethernet/broadcom/tg3.c b/drivers/net/ethernet/broadcom/tg3.c
index 3b1397af81f7..b1627dd5f2fd 100644
--- a/drivers/net/ethernet/broadcom/tg3.c
+++ b/drivers/net/ethernet/broadcom/tg3.c
@@ -8712,10 +8712,10 @@ static int tg3_mem_rx_acquire(struct tg3 *tp)
                 if (!i && tg3_flag(tp, ENABLE_RSS))
                         continue;
 
-                tnapi->rx_rcb = dma_zalloc_coherent(&tp->pdev->dev,
-                                                    TG3_RX_RCB_RING_BYTES(tp),
-                                                    &tnapi->rx_rcb_mapping,
-                                                    GFP_KERNEL);
+                tnapi->rx_rcb = dma_alloc_coherent(&tp->pdev->dev,
+                                                   TG3_RX_RCB_RING_BYTES(tp),
+                                                   &tnapi->rx_rcb_mapping,
+                                                   GFP_KERNEL);
                 if (!tnapi->rx_rcb)
                         goto err_out;
         }
@@ -8768,9 +8768,9 @@ static int tg3_alloc_consistent(struct tg3 *tp)
 {
         int i;
 
-        tp->hw_stats = dma_zalloc_coherent(&tp->pdev->dev,
-                                           sizeof(struct tg3_hw_stats),
-                                           &tp->stats_mapping, GFP_KERNEL);
+        tp->hw_stats = dma_alloc_coherent(&tp->pdev->dev,
+                                          sizeof(struct tg3_hw_stats),
+                                          &tp->stats_mapping, GFP_KERNEL);
         if (!tp->hw_stats)
                 goto err_out;
 
@@ -8778,10 +8778,10 @@ static int tg3_alloc_consistent(struct tg3 *tp)
                 struct tg3_napi *tnapi = &tp->napi[i];
                 struct tg3_hw_status *sblk;
 
-                tnapi->hw_status = dma_zalloc_coherent(&tp->pdev->dev,
-                                                       TG3_HW_STATUS_SIZE,
-                                                       &tnapi->status_mapping,
-                                                       GFP_KERNEL);
+                tnapi->hw_status = dma_alloc_coherent(&tp->pdev->dev,
+                                                      TG3_HW_STATUS_SIZE,
+                                                      &tnapi->status_mapping,
+                                                      GFP_KERNEL);
                 if (!tnapi->hw_status)
                         goto err_out;
 
diff --git a/drivers/net/ethernet/cadence/macb_main.c b/drivers/net/ethernet/cadence/macb_main.c
index b126926ef7f5..66cc7927061a 100644
--- a/drivers/net/ethernet/cadence/macb_main.c
+++ b/drivers/net/ethernet/cadence/macb_main.c
@@ -1738,12 +1738,8 @@ static int macb_pad_and_fcs(struct sk_buff **skb, struct net_device *ndev)
                 *skb = nskb;
         }
 
-        if (padlen) {
-                if (padlen >= ETH_FCS_LEN)
-                        skb_put_zero(*skb, padlen - ETH_FCS_LEN);
-                else
-                        skb_trim(*skb, ETH_FCS_LEN - padlen);
-        }
+        if (padlen > ETH_FCS_LEN)
+                skb_put_zero(*skb, padlen - ETH_FCS_LEN);
 
 add_fcs:
         /* set FCS to packet */
diff --git a/drivers/net/ethernet/cavium/thunder/nicvf_queues.c b/drivers/net/ethernet/cavium/thunder/nicvf_queues.c
index fcaf18fa3904..5b4d3badcb73 100644
--- a/drivers/net/ethernet/cavium/thunder/nicvf_queues.c
+++ b/drivers/net/ethernet/cavium/thunder/nicvf_queues.c
@@ -59,7 +59,7 @@ static int nicvf_alloc_q_desc_mem(struct nicvf *nic, struct q_desc_mem *dmem,
         dmem->q_len = q_len;
         dmem->size = (desc_size * q_len) + align_bytes;
         /* Save address, need it while freeing */
-        dmem->unalign_base = dma_zalloc_coherent(&nic->pdev->dev, dmem->size,
+        dmem->unalign_base = dma_alloc_coherent(&nic->pdev->dev, dmem->size,
                                                 &dmem->dma, GFP_KERNEL);
         if (!dmem->unalign_base)
                 return -ENOMEM;
diff --git a/drivers/net/ethernet/chelsio/cxgb3/sge.c b/drivers/net/ethernet/chelsio/cxgb3/sge.c
index 20b6e1b3f5e3..89db739b7819 100644
--- a/drivers/net/ethernet/chelsio/cxgb3/sge.c
+++ b/drivers/net/ethernet/chelsio/cxgb3/sge.c
@@ -620,7 +620,7 @@ static void *alloc_ring(struct pci_dev *pdev, size_t nelem, size_t elem_size,
 {
         size_t len = nelem * elem_size;
         void *s = NULL;
-        void *p = dma_zalloc_coherent(&pdev->dev, len, phys, GFP_KERNEL);
+        void *p = dma_alloc_coherent(&pdev->dev, len, phys, GFP_KERNEL);
 
         if (!p)
                 return NULL;
@@ -2381,7 +2381,7 @@ no_mem:
                                         lro_add_page(adap, qs, fl,
                                                      G_RSPD_LEN(len),
                                                      flags & F_RSPD_EOP);
-                                         goto next_fl;
+                                        goto next_fl;
                                 }
 
                                 skb = get_packet_pg(adap, fl, q,
@@ -3214,11 +3214,13 @@ void t3_start_sge_timers(struct adapter *adap)
         for (i = 0; i < SGE_QSETS; ++i) {
                 struct sge_qset *q = &adap->sge.qs[i];
 
-        if (q->tx_reclaim_timer.function)
-                mod_timer(&q->tx_reclaim_timer, jiffies + TX_RECLAIM_PERIOD);
+                if (q->tx_reclaim_timer.function)
+                        mod_timer(&q->tx_reclaim_timer,
+                                  jiffies + TX_RECLAIM_PERIOD);
 
-        if (q->rx_reclaim_timer.function)
-                mod_timer(&q->rx_reclaim_timer, jiffies + RX_RECLAIM_PERIOD);
+                if (q->rx_reclaim_timer.function)
+                        mod_timer(&q->rx_reclaim_timer,
+                                  jiffies + RX_RECLAIM_PERIOD);
         }
 }
 
diff --git a/drivers/net/ethernet/chelsio/cxgb3/t3_hw.c b/drivers/net/ethernet/chelsio/cxgb3/t3_hw.c
index 080918af773c..0a9f2c596624 100644
--- a/drivers/net/ethernet/chelsio/cxgb3/t3_hw.c
+++ b/drivers/net/ethernet/chelsio/cxgb3/t3_hw.c
@@ -1082,7 +1082,7 @@ int t3_check_fw_version(struct adapter *adapter)
                 CH_WARN(adapter, "found newer FW version(%u.%u), "
                         "driver compiled for version %u.%u\n", major, minor,
                         FW_VERSION_MAJOR, FW_VERSION_MINOR);
-                        return 0;
+                return 0;
         }
         return -EINVAL;
 }
@@ -3619,7 +3619,7 @@ int t3_reset_adapter(struct adapter *adapter)
 
 static int init_parity(struct adapter *adap)
 {
-                int i, err, addr;
+        int i, err, addr;
 
         if (t3_read_reg(adap, A_SG_CONTEXT_CMD) & F_CONTEXT_CMD_BUSY)
                 return -EBUSY;
@@ -3806,6 +3806,6 @@ int t3_replay_prep_adapter(struct adapter *adapter)
                 p->phy.ops->power_down(&p->phy, 1);
         }
 
-return 0;
+        return 0;
 }
 
diff --git a/drivers/net/ethernet/chelsio/cxgb4/cxgb4_ptp.c b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_ptp.c
index 9f9d6cae39d5..58a039c3224a 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/cxgb4_ptp.c
+++ b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_ptp.c
@@ -378,10 +378,10 @@ static void cxgb4_init_ptp_timer(struct adapter *adapter)
         int err;
 
         memset(&c, 0, sizeof(c));
-                c.op_to_portid = cpu_to_be32(FW_CMD_OP_V(FW_PTP_CMD) |
-                                             FW_CMD_REQUEST_F |
-                                             FW_CMD_WRITE_F |
-                                             FW_PTP_CMD_PORTID_V(0));
+        c.op_to_portid = cpu_to_be32(FW_CMD_OP_V(FW_PTP_CMD) |
+                                     FW_CMD_REQUEST_F |
+                                     FW_CMD_WRITE_F |
+                                     FW_PTP_CMD_PORTID_V(0));
         c.retval_len16 = cpu_to_be32(FW_CMD_LEN16_V(sizeof(c) / 16));
         c.u.scmd.sc = FW_PTP_SC_INIT_TIMER;
 
diff --git a/drivers/net/ethernet/chelsio/cxgb4/cxgb4_uld.c b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_uld.c
index 9a6065a3fa46..c041f44324db 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/cxgb4_uld.c
+++ b/drivers/net/ethernet/chelsio/cxgb4/cxgb4_uld.c
@@ -78,7 +78,7 @@ static void free_msix_idx_in_bmap(struct adapter *adap, unsigned int msix_idx)
         unsigned long flags;
 
         spin_lock_irqsave(&bmap->lock, flags);
-         __clear_bit(msix_idx, bmap->msix_bmap);
+        __clear_bit(msix_idx, bmap->msix_bmap);
         spin_unlock_irqrestore(&bmap->lock, flags);
 }
 
diff --git a/drivers/net/ethernet/chelsio/cxgb4/sge.c b/drivers/net/ethernet/chelsio/cxgb4/sge.c
index b90188401d4a..fc0bc6458e84 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/sge.c
+++ b/drivers/net/ethernet/chelsio/cxgb4/sge.c
@@ -694,7 +694,7 @@ static void *alloc_ring(struct device *dev, size_t nelem, size_t elem_size,
 {
         size_t len = nelem * elem_size + stat_size;
         void *s = NULL;
-        void *p = dma_zalloc_coherent(dev, len, phys, GFP_KERNEL);
+        void *p = dma_alloc_coherent(dev, len, phys, GFP_KERNEL);
 
         if (!p)
                 return NULL;
diff --git a/drivers/net/ethernet/chelsio/cxgb4/t4_hw.c b/drivers/net/ethernet/chelsio/cxgb4/t4_hw.c
index e8c34292a0ec..2b03f6187a24 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/t4_hw.c
+++ b/drivers/net/ethernet/chelsio/cxgb4/t4_hw.c
@@ -3794,7 +3794,7 @@ int t4_load_phy_fw(struct adapter *adap,
         /* If we have version number support, then check to see if the adapter
          * already has up-to-date PHY firmware loaded.
          */
-         if (phy_fw_version) {
+        if (phy_fw_version) {
                 new_phy_fw_vers = phy_fw_version(phy_fw_data, phy_fw_size);
                 ret = t4_phy_fw_ver(adap, &cur_phy_fw_ver);
                 if (ret < 0)
diff --git a/drivers/net/ethernet/chelsio/cxgb4vf/sge.c b/drivers/net/ethernet/chelsio/cxgb4vf/sge.c
index 3007e1ac1e61..1d534f0baa69 100644
--- a/drivers/net/ethernet/chelsio/cxgb4vf/sge.c
+++ b/drivers/net/ethernet/chelsio/cxgb4vf/sge.c
@@ -756,7 +756,7 @@ static void *alloc_ring(struct device *dev, size_t nelem, size_t hwsize,
          * Allocate the hardware ring and PCI DMA bus address space for said.
          */
         size_t hwlen = nelem * hwsize + stat_size;
-        void *hwring = dma_zalloc_coherent(dev, hwlen, busaddrp, GFP_KERNEL);
+        void *hwring = dma_alloc_coherent(dev, hwlen, busaddrp, GFP_KERNEL);
 
         if (!hwring)
                 return NULL;
diff --git a/drivers/net/ethernet/emulex/benet/be_cmds.c b/drivers/net/ethernet/emulex/benet/be_cmds.c
index 1e9d882c04ef..59a7f0b99069 100644
--- a/drivers/net/ethernet/emulex/benet/be_cmds.c
+++ b/drivers/net/ethernet/emulex/benet/be_cmds.c
@@ -1808,9 +1808,9 @@ int be_cmd_get_fat_dump(struct be_adapter *adapter, u32 buf_len, void *buf)
         total_size = buf_len;
 
         get_fat_cmd.size = sizeof(struct be_cmd_req_get_fat) + 60*1024;
-        get_fat_cmd.va = dma_zalloc_coherent(&adapter->pdev->dev,
-                                             get_fat_cmd.size,
-                                             &get_fat_cmd.dma, GFP_ATOMIC);
+        get_fat_cmd.va = dma_alloc_coherent(&adapter->pdev->dev,
+                                            get_fat_cmd.size,
+                                            &get_fat_cmd.dma, GFP_ATOMIC);
         if (!get_fat_cmd.va)
                 return -ENOMEM;
 
@@ -2302,8 +2302,8 @@ int be_cmd_read_port_transceiver_data(struct be_adapter *adapter,
                 return -EINVAL;
 
         cmd.size = sizeof(struct be_cmd_resp_port_type);
-        cmd.va = dma_zalloc_coherent(&adapter->pdev->dev, cmd.size, &cmd.dma,
-                                     GFP_ATOMIC);
+        cmd.va = dma_alloc_coherent(&adapter->pdev->dev, cmd.size, &cmd.dma,
+                                    GFP_ATOMIC);
         if (!cmd.va) {
                 dev_err(&adapter->pdev->dev, "Memory allocation failed\n");
                 return -ENOMEM;
@@ -3066,8 +3066,8 @@ int lancer_fw_download(struct be_adapter *adapter,
 
         flash_cmd.size = sizeof(struct lancer_cmd_req_write_object)
                                 + LANCER_FW_DOWNLOAD_CHUNK;
-        flash_cmd.va = dma_zalloc_coherent(dev, flash_cmd.size,
-                                           &flash_cmd.dma, GFP_KERNEL);
+        flash_cmd.va = dma_alloc_coherent(dev, flash_cmd.size, &flash_cmd.dma,
+                                          GFP_KERNEL);
         if (!flash_cmd.va)
                 return -ENOMEM;
 
@@ -3184,8 +3184,8 @@ int be_fw_download(struct be_adapter *adapter, const struct firmware *fw)
         }
 
         flash_cmd.size = sizeof(struct be_cmd_write_flashrom);
-        flash_cmd.va = dma_zalloc_coherent(dev, flash_cmd.size, &flash_cmd.dma,
-                                           GFP_KERNEL);
+        flash_cmd.va = dma_alloc_coherent(dev, flash_cmd.size, &flash_cmd.dma,
+                                          GFP_KERNEL);
         if (!flash_cmd.va)
                 return -ENOMEM;
 
@@ -3435,8 +3435,8 @@ int be_cmd_get_phy_info(struct be_adapter *adapter)
                 goto err;
         }
         cmd.size = sizeof(struct be_cmd_req_get_phy_info);
-        cmd.va = dma_zalloc_coherent(&adapter->pdev->dev, cmd.size, &cmd.dma,
-                                     GFP_ATOMIC);
+        cmd.va = dma_alloc_coherent(&adapter->pdev->dev, cmd.size, &cmd.dma,
+                                    GFP_ATOMIC);
         if (!cmd.va) {
                 dev_err(&adapter->pdev->dev, "Memory alloc failure\n");
                 status = -ENOMEM;
@@ -3522,9 +3522,9 @@ int be_cmd_get_cntl_attributes(struct be_adapter *adapter)
 
         memset(&attribs_cmd, 0, sizeof(struct be_dma_mem));
         attribs_cmd.size = sizeof(struct be_cmd_resp_cntl_attribs);
-        attribs_cmd.va = dma_zalloc_coherent(&adapter->pdev->dev,
-                                             attribs_cmd.size,
-                                             &attribs_cmd.dma, GFP_ATOMIC);
+        attribs_cmd.va = dma_alloc_coherent(&adapter->pdev->dev,
+                                            attribs_cmd.size,
+                                            &attribs_cmd.dma, GFP_ATOMIC);
         if (!attribs_cmd.va) {
                 dev_err(&adapter->pdev->dev, "Memory allocation failure\n");
                 status = -ENOMEM;
@@ -3699,10 +3699,10 @@ int be_cmd_get_mac_from_list(struct be_adapter *adapter, u8 *mac,
 
         memset(&get_mac_list_cmd, 0, sizeof(struct be_dma_mem));
         get_mac_list_cmd.size = sizeof(struct be_cmd_resp_get_mac_list);
-        get_mac_list_cmd.va = dma_zalloc_coherent(&adapter->pdev->dev,
-                                                  get_mac_list_cmd.size,
-                                                  &get_mac_list_cmd.dma,
-                                                  GFP_ATOMIC);
+        get_mac_list_cmd.va = dma_alloc_coherent(&adapter->pdev->dev,
+                                                 get_mac_list_cmd.size,
+                                                 &get_mac_list_cmd.dma,
+                                                 GFP_ATOMIC);
 
         if (!get_mac_list_cmd.va) {
                 dev_err(&adapter->pdev->dev,
@@ -3829,8 +3829,8 @@ int be_cmd_set_mac_list(struct be_adapter *adapter, u8 *mac_array,
 
         memset(&cmd, 0, sizeof(struct be_dma_mem));
         cmd.size = sizeof(struct be_cmd_req_set_mac_list);
-        cmd.va = dma_zalloc_coherent(&adapter->pdev->dev, cmd.size, &cmd.dma,
-                                     GFP_KERNEL);
+        cmd.va = dma_alloc_coherent(&adapter->pdev->dev, cmd.size, &cmd.dma,
+                                    GFP_KERNEL);
         if (!cmd.va)
                 return -ENOMEM;
 
@@ -4035,8 +4035,8 @@ int be_cmd_get_acpi_wol_cap(struct be_adapter *adapter)
 
         memset(&cmd, 0, sizeof(struct be_dma_mem));
         cmd.size = sizeof(struct be_cmd_resp_acpi_wol_magic_config_v1);
-        cmd.va = dma_zalloc_coherent(&adapter->pdev->dev, cmd.size, &cmd.dma,
-                                     GFP_ATOMIC);
+        cmd.va = dma_alloc_coherent(&adapter->pdev->dev, cmd.size, &cmd.dma,
+                                    GFP_ATOMIC);
         if (!cmd.va) {
                 dev_err(&adapter->pdev->dev, "Memory allocation failure\n");
                 status = -ENOMEM;
@@ -4089,9 +4089,9 @@ int be_cmd_set_fw_log_level(struct be_adapter *adapter, u32 level)
 
         memset(&extfat_cmd, 0, sizeof(struct be_dma_mem));
         extfat_cmd.size = sizeof(struct be_cmd_resp_get_ext_fat_caps);
-        extfat_cmd.va = dma_zalloc_coherent(&adapter->pdev->dev,
-                                            extfat_cmd.size, &extfat_cmd.dma,
-                                            GFP_ATOMIC);
+        extfat_cmd.va = dma_alloc_coherent(&adapter->pdev->dev,
+                                           extfat_cmd.size, &extfat_cmd.dma,
+                                           GFP_ATOMIC);
         if (!extfat_cmd.va)
                 return -ENOMEM;
 
@@ -4127,9 +4127,9 @@ int be_cmd_get_fw_log_level(struct be_adapter *adapter)
 
         memset(&extfat_cmd, 0, sizeof(struct be_dma_mem));
         extfat_cmd.size = sizeof(struct be_cmd_resp_get_ext_fat_caps);
-        extfat_cmd.va = dma_zalloc_coherent(&adapter->pdev->dev,
-                                            extfat_cmd.size, &extfat_cmd.dma,
-                                            GFP_ATOMIC);
+        extfat_cmd.va = dma_alloc_coherent(&adapter->pdev->dev,
+                                           extfat_cmd.size, &extfat_cmd.dma,
+                                           GFP_ATOMIC);
 
         if (!extfat_cmd.va) {
                 dev_err(&adapter->pdev->dev, "%s: Memory allocation failure\n",
@@ -4354,8 +4354,8 @@ int be_cmd_get_func_config(struct be_adapter *adapter, struct be_resources *res)
 
         memset(&cmd, 0, sizeof(struct be_dma_mem));
         cmd.size = sizeof(struct be_cmd_resp_get_func_config);
-        cmd.va = dma_zalloc_coherent(&adapter->pdev->dev, cmd.size, &cmd.dma,
-                                     GFP_ATOMIC);
+        cmd.va = dma_alloc_coherent(&adapter->pdev->dev, cmd.size, &cmd.dma,
+                                    GFP_ATOMIC);
         if (!cmd.va) {
                 dev_err(&adapter->pdev->dev, "Memory alloc failure\n");
                 status = -ENOMEM;
@@ -4452,8 +4452,8 @@ int be_cmd_get_profile_config(struct be_adapter *adapter,
 
         memset(&cmd, 0, sizeof(struct be_dma_mem));
         cmd.size = sizeof(struct be_cmd_resp_get_profile_config);
-        cmd.va = dma_zalloc_coherent(&adapter->pdev->dev, cmd.size, &cmd.dma,
-                                     GFP_ATOMIC);
+        cmd.va = dma_alloc_coherent(&adapter->pdev->dev, cmd.size, &cmd.dma,
+                                    GFP_ATOMIC);
         if (!cmd.va)
                 return -ENOMEM;
 
@@ -4539,8 +4539,8 @@ static int be_cmd_set_profile_config(struct be_adapter *adapter, void *desc,
 
         memset(&cmd, 0, sizeof(struct be_dma_mem));
         cmd.size = sizeof(struct be_cmd_req_set_profile_config);
-        cmd.va = dma_zalloc_coherent(&adapter->pdev->dev, cmd.size, &cmd.dma,
-                                     GFP_ATOMIC);
+        cmd.va = dma_alloc_coherent(&adapter->pdev->dev, cmd.size, &cmd.dma,
+                                    GFP_ATOMIC);
         if (!cmd.va)
                 return -ENOMEM;
 
diff --git a/drivers/net/ethernet/emulex/benet/be_ethtool.c b/drivers/net/ethernet/emulex/benet/be_ethtool.c
index 3f6749fc889f..4c218341c51b 100644
--- a/drivers/net/ethernet/emulex/benet/be_ethtool.c
+++ b/drivers/net/ethernet/emulex/benet/be_ethtool.c
@@ -274,8 +274,8 @@ static int lancer_cmd_read_file(struct be_adapter *adapter, u8 *file_name,
         int status = 0;
 
         read_cmd.size = LANCER_READ_FILE_CHUNK;
-        read_cmd.va = dma_zalloc_coherent(&adapter->pdev->dev, read_cmd.size,
-                                          &read_cmd.dma, GFP_ATOMIC);
+        read_cmd.va = dma_alloc_coherent(&adapter->pdev->dev, read_cmd.size,
+                                         &read_cmd.dma, GFP_ATOMIC);
 
         if (!read_cmd.va) {
                 dev_err(&adapter->pdev->dev,
@@ -815,7 +815,7 @@ static int be_set_wol(struct net_device *netdev, struct ethtool_wolinfo *wol)
         }
 
         cmd.size = sizeof(struct be_cmd_req_acpi_wol_magic_config);
-        cmd.va = dma_zalloc_coherent(dev, cmd.size, &cmd.dma, GFP_KERNEL);
+        cmd.va = dma_alloc_coherent(dev, cmd.size, &cmd.dma, GFP_KERNEL);
         if (!cmd.va)
                 return -ENOMEM;
 
@@ -851,9 +851,9 @@ static int be_test_ddr_dma(struct be_adapter *adapter)
         };
 
         ddrdma_cmd.size = sizeof(struct be_cmd_req_ddrdma_test);
-        ddrdma_cmd.va = dma_zalloc_coherent(&adapter->pdev->dev,
-                                            ddrdma_cmd.size, &ddrdma_cmd.dma,
-                                            GFP_KERNEL);
+        ddrdma_cmd.va = dma_alloc_coherent(&adapter->pdev->dev,
+                                           ddrdma_cmd.size, &ddrdma_cmd.dma,
+                                           GFP_KERNEL);
         if (!ddrdma_cmd.va)
                 return -ENOMEM;
 
@@ -1014,9 +1014,9 @@ static int be_read_eeprom(struct net_device *netdev,
 
         memset(&eeprom_cmd, 0, sizeof(struct be_dma_mem));
         eeprom_cmd.size = sizeof(struct be_cmd_req_seeprom_read);
-        eeprom_cmd.va = dma_zalloc_coherent(&adapter->pdev->dev,
-                                            eeprom_cmd.size, &eeprom_cmd.dma,
-                                            GFP_KERNEL);
+        eeprom_cmd.va = dma_alloc_coherent(&adapter->pdev->dev,
+                                           eeprom_cmd.size, &eeprom_cmd.dma,
+                                           GFP_KERNEL);
 
         if (!eeprom_cmd.va)
                 return -ENOMEM;
diff --git a/drivers/net/ethernet/emulex/benet/be_main.c b/drivers/net/ethernet/emulex/benet/be_main.c
index 852f5bfe5f6d..d5026909dec5 100644
--- a/drivers/net/ethernet/emulex/benet/be_main.c
+++ b/drivers/net/ethernet/emulex/benet/be_main.c
@@ -167,8 +167,8 @@ static int be_queue_alloc(struct be_adapter *adapter, struct be_queue_info *q,
         q->len = len;
         q->entry_size = entry_size;
         mem->size = len * entry_size;
-        mem->va = dma_zalloc_coherent(&adapter->pdev->dev, mem->size, &mem->dma,
-                                      GFP_KERNEL);
+        mem->va = dma_alloc_coherent(&adapter->pdev->dev, mem->size,
+                                     &mem->dma, GFP_KERNEL);
         if (!mem->va)
                 return -ENOMEM;
         return 0;
@@ -5766,9 +5766,9 @@ static int be_drv_init(struct be_adapter *adapter)
         int status = 0;
 
         mbox_mem_alloc->size = sizeof(struct be_mcc_mailbox) + 16;
-        mbox_mem_alloc->va = dma_zalloc_coherent(dev, mbox_mem_alloc->size,
-                                                 &mbox_mem_alloc->dma,
-                                                 GFP_KERNEL);
+        mbox_mem_alloc->va = dma_alloc_coherent(dev, mbox_mem_alloc->size,
+                                                &mbox_mem_alloc->dma,
+                                                GFP_KERNEL);
         if (!mbox_mem_alloc->va)
                 return -ENOMEM;
 
@@ -5777,8 +5777,8 @@ static int be_drv_init(struct be_adapter *adapter)
         mbox_mem_align->dma = PTR_ALIGN(mbox_mem_alloc->dma, 16);
 
         rx_filter->size = sizeof(struct be_cmd_req_rx_filter);
-        rx_filter->va = dma_zalloc_coherent(dev, rx_filter->size,
-                                            &rx_filter->dma, GFP_KERNEL);
+        rx_filter->va = dma_alloc_coherent(dev, rx_filter->size,
+                                           &rx_filter->dma, GFP_KERNEL);
         if (!rx_filter->va) {
                 status = -ENOMEM;
                 goto free_mbox;
@@ -5792,8 +5792,8 @@ static int be_drv_init(struct be_adapter *adapter)
                 stats_cmd->size = sizeof(struct be_cmd_req_get_stats_v1);
         else
                 stats_cmd->size = sizeof(struct be_cmd_req_get_stats_v2);
-        stats_cmd->va = dma_zalloc_coherent(dev, stats_cmd->size,
-                                            &stats_cmd->dma, GFP_KERNEL);
+        stats_cmd->va = dma_alloc_coherent(dev, stats_cmd->size,
+                                           &stats_cmd->dma, GFP_KERNEL);
         if (!stats_cmd->va) {
                 status = -ENOMEM;
                 goto free_rx_filter;
diff --git a/drivers/net/ethernet/faraday/ftgmac100.c b/drivers/net/ethernet/faraday/ftgmac100.c
index 4d673225ed3e..3e5e97186fc4 100644
--- a/drivers/net/ethernet/faraday/ftgmac100.c
+++ b/drivers/net/ethernet/faraday/ftgmac100.c
@@ -935,16 +935,14 @@ static int ftgmac100_alloc_rings(struct ftgmac100 *priv)
                 return -ENOMEM;
 
         /* Allocate descriptors */
-        priv->rxdes = dma_zalloc_coherent(priv->dev,
-                                          MAX_RX_QUEUE_ENTRIES *
-                                          sizeof(struct ftgmac100_rxdes),
-                                          &priv->rxdes_dma, GFP_KERNEL);
+        priv->rxdes = dma_alloc_coherent(priv->dev,
+                                         MAX_RX_QUEUE_ENTRIES * sizeof(struct ftgmac100_rxdes),
+                                         &priv->rxdes_dma, GFP_KERNEL);
         if (!priv->rxdes)
                 return -ENOMEM;
-        priv->txdes = dma_zalloc_coherent(priv->dev,
-                                          MAX_TX_QUEUE_ENTRIES *
-                                          sizeof(struct ftgmac100_txdes),
-                                          &priv->txdes_dma, GFP_KERNEL);
+        priv->txdes = dma_alloc_coherent(priv->dev,
+                                         MAX_TX_QUEUE_ENTRIES * sizeof(struct ftgmac100_txdes),
+                                         &priv->txdes_dma, GFP_KERNEL);
         if (!priv->txdes)
                 return -ENOMEM;
 
diff --git a/drivers/net/ethernet/faraday/ftmac100.c b/drivers/net/ethernet/faraday/ftmac100.c
index 084f24daf2b5..2a0e820526dc 100644
--- a/drivers/net/ethernet/faraday/ftmac100.c
+++ b/drivers/net/ethernet/faraday/ftmac100.c
@@ -734,10 +734,9 @@ static int ftmac100_alloc_buffers(struct ftmac100 *priv)
 {
         int i;
 
-        priv->descs = dma_zalloc_coherent(priv->dev,
-                                          sizeof(struct ftmac100_descs),
-                                          &priv->descs_dma_addr,
-                                          GFP_KERNEL);
+        priv->descs = dma_alloc_coherent(priv->dev,
+                                         sizeof(struct ftmac100_descs),
+                                         &priv->descs_dma_addr, GFP_KERNEL);
         if (!priv->descs)
                 return -ENOMEM;
 
diff --git a/drivers/net/ethernet/freescale/dpaa/dpaa_eth.c b/drivers/net/ethernet/freescale/dpaa/dpaa_eth.c
index f53090cde041..dfebc30c4841 100644
--- a/drivers/net/ethernet/freescale/dpaa/dpaa_eth.c
+++ b/drivers/net/ethernet/freescale/dpaa/dpaa_eth.c
@@ -2051,6 +2051,7 @@ dpaa_start_xmit(struct sk_buff *skb, struct net_device *net_dev)
         bool nonlinear = skb_is_nonlinear(skb);
         struct rtnl_link_stats64 *percpu_stats;
         struct dpaa_percpu_priv *percpu_priv;
+        struct netdev_queue *txq;
         struct dpaa_priv *priv;
         struct qm_fd fd;
         int offset = 0;
@@ -2100,6 +2101,11 @@ dpaa_start_xmit(struct sk_buff *skb, struct net_device *net_dev)
         if (unlikely(err < 0))
                 goto skb_to_fd_failed;
 
+        txq = netdev_get_tx_queue(net_dev, queue_mapping);
+
+        /* LLTX requires to do our own update of trans_start */
+        txq->trans_start = jiffies;
+
         if (priv->tx_tstamp && skb_shinfo(skb)->tx_flags & SKBTX_HW_TSTAMP) {
                 fd.cmd |= cpu_to_be32(FM_FD_CMD_UPD);
                 skb_shinfo(skb)->tx_flags |= SKBTX_IN_PROGRESS;
diff --git a/drivers/net/ethernet/freescale/dpaa2/Kconfig b/drivers/net/ethernet/freescale/dpaa2/Kconfig
index 809a155eb193..f6d244c663fd 100644
--- a/drivers/net/ethernet/freescale/dpaa2/Kconfig
+++ b/drivers/net/ethernet/freescale/dpaa2/Kconfig
@@ -9,8 +9,9 @@ config FSL_DPAA2_ETH
 
 config FSL_DPAA2_PTP_CLOCK
         tristate "Freescale DPAA2 PTP Clock"
-        depends on FSL_DPAA2_ETH && POSIX_TIMERS
-        select PTP_1588_CLOCK
+        depends on FSL_DPAA2_ETH
+        imply PTP_1588_CLOCK
+        default y
         help
           This driver adds support for using the DPAA2 1588 timer module
           as a PTP clock.
diff --git a/drivers/net/ethernet/freescale/fec_main.c b/drivers/net/ethernet/freescale/fec_main.c
index ae0f88bce9aa..2370dc204202 100644
--- a/drivers/net/ethernet/freescale/fec_main.c
+++ b/drivers/net/ethernet/freescale/fec_main.c
@@ -3467,7 +3467,7 @@ fec_probe(struct platform_device *pdev)
         if (ret)
                 goto failed_clk_ipg;
 
-        fep->reg_phy = devm_regulator_get(&pdev->dev, "phy");
+        fep->reg_phy = devm_regulator_get_optional(&pdev->dev, "phy");
         if (!IS_ERR(fep->reg_phy)) {
                 ret = regulator_enable(fep->reg_phy);
                 if (ret) {
diff --git a/drivers/net/ethernet/hisilicon/hix5hd2_gmac.c b/drivers/net/ethernet/hisilicon/hix5hd2_gmac.c
index 471805ea363b..e5d853b7b454 100644
--- a/drivers/net/ethernet/hisilicon/hix5hd2_gmac.c
+++ b/drivers/net/ethernet/hisilicon/hix5hd2_gmac.c
@@ -1006,8 +1006,8 @@ static int hix5hd2_init_hw_desc_queue(struct hix5hd2_priv *priv)
 
         for (i = 0; i < QUEUE_NUMS; i++) {
                 size = priv->pool[i].count * sizeof(struct hix5hd2_desc);
-                virt_addr = dma_zalloc_coherent(dev, size, &phys_addr,
-                                                GFP_KERNEL);
+                virt_addr = dma_alloc_coherent(dev, size, &phys_addr,
+                                               GFP_KERNEL);
                 if (virt_addr == NULL)
                         goto error_free_pool;
 
diff --git a/drivers/net/ethernet/hisilicon/hns/hns_ae_adapt.c b/drivers/net/ethernet/hisilicon/hns/hns_ae_adapt.c
index ad1779fc410e..a78bfafd212c 100644
--- a/drivers/net/ethernet/hisilicon/hns/hns_ae_adapt.c
+++ b/drivers/net/ethernet/hisilicon/hns/hns_ae_adapt.c
@@ -147,12 +147,10 @@ static void hns_ae_put_handle(struct hnae_handle *handle)
         struct hnae_vf_cb *vf_cb = hns_ae_get_vf_cb(handle);
         int i;
 
-        vf_cb->mac_cb    = NULL;
-
-        kfree(vf_cb);
-
         for (i = 0; i < handle->q_num; i++)
                 hns_ae_get_ring_pair(handle->qs[i])->used_by_vf = 0;
+
+        kfree(vf_cb);
 }
 
 static int hns_ae_wait_flow_down(struct hnae_handle *handle)
diff --git a/drivers/net/ethernet/hisilicon/hns/hns_enet.c b/drivers/net/ethernet/hisilicon/hns/hns_enet.c
index 5748d3f722f6..5b33238c6680 100644
--- a/drivers/net/ethernet/hisilicon/hns/hns_enet.c
+++ b/drivers/net/ethernet/hisilicon/hns/hns_enet.c
@@ -1170,6 +1170,13 @@ int hns_nic_init_phy(struct net_device *ndev, struct hnae_handle *h)
         if (!h->phy_dev)
                 return 0;
 
+        ethtool_convert_legacy_u32_to_link_mode(supported, h->if_support);
+        linkmode_and(phy_dev->supported, phy_dev->supported, supported);
+        linkmode_copy(phy_dev->advertising, phy_dev->supported);
+
+        if (h->phy_if == PHY_INTERFACE_MODE_XGMII)
+                phy_dev->autoneg = false;
+
         if (h->phy_if != PHY_INTERFACE_MODE_XGMII) {
                 phy_dev->dev_flags = 0;
 
@@ -1181,16 +1188,6 @@ int hns_nic_init_phy(struct net_device *ndev, struct hnae_handle *h)
         if (unlikely(ret))
                 return -ENODEV;
 
-        ethtool_convert_legacy_u32_to_link_mode(supported, h->if_support);
-        linkmode_and(phy_dev->supported, phy_dev->supported, supported);
-        linkmode_copy(phy_dev->advertising, phy_dev->supported);
-
-        if (h->phy_if == PHY_INTERFACE_MODE_XGMII)
-                phy_dev->autoneg = false;
-
-        if (h->phy_if == PHY_INTERFACE_MODE_SGMII)
-                phy_stop(phy_dev);
-
         return 0;
 }
 
diff --git a/drivers/net/ethernet/hisilicon/hns3/hns3_enet.c b/drivers/net/ethernet/hisilicon/hns3/hns3_enet.c
index 07cd58798083..1bf7a5f116a0 100644
--- a/drivers/net/ethernet/hisilicon/hns3/hns3_enet.c
+++ b/drivers/net/ethernet/hisilicon/hns3/hns3_enet.c
@@ -2041,9 +2041,8 @@ static int hns3_alloc_desc(struct hns3_enet_ring *ring)
 {
         int size = ring->desc_num * sizeof(ring->desc[0]);
 
-        ring->desc = dma_zalloc_coherent(ring_to_dev(ring), size,
-                                         &ring->desc_dma_addr,
-                                         GFP_KERNEL);
+        ring->desc = dma_alloc_coherent(ring_to_dev(ring), size,
+                                        &ring->desc_dma_addr, GFP_KERNEL);
         if (!ring->desc)
                 return -ENOMEM;
 
diff --git a/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_cmd.c b/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_cmd.c
index 8af0cef5609b..e483a6e730e6 100644
--- a/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_cmd.c
+++ b/drivers/net/ethernet/hisilicon/hns3/hns3pf/hclge_cmd.c
@@ -39,9 +39,8 @@ static int hclge_alloc_cmd_desc(struct hclge_cmq_ring *ring)
 {
         int size  = ring->desc_num * sizeof(struct hclge_desc);
 
-        ring->desc = dma_zalloc_coherent(cmq_ring_to_dev(ring),
-                                         size, &ring->desc_dma_addr,
-                                         GFP_KERNEL);
+        ring->desc = dma_alloc_coherent(cmq_ring_to_dev(ring), size,
+                                        &ring->desc_dma_addr, GFP_KERNEL);
         if (!ring->desc)
                 return -ENOMEM;
 
diff --git a/drivers/net/ethernet/hisilicon/hns3/hns3vf/hclgevf_cmd.c b/drivers/net/ethernet/hisilicon/hns3/hns3vf/hclgevf_cmd.c
index d5765c8cf3a3..4e78e8812a04 100644
--- a/drivers/net/ethernet/hisilicon/hns3/hns3vf/hclgevf_cmd.c
+++ b/drivers/net/ethernet/hisilicon/hns3/hns3vf/hclgevf_cmd.c
@@ -115,9 +115,8 @@ static int hclgevf_alloc_cmd_desc(struct hclgevf_cmq_ring *ring)
 {
         int size = ring->desc_num * sizeof(struct hclgevf_desc);
 
-        ring->desc = dma_zalloc_coherent(cmq_ring_to_dev(ring),
-                                         size, &ring->desc_dma_addr,
-                                         GFP_KERNEL);
+        ring->desc = dma_alloc_coherent(cmq_ring_to_dev(ring), size,
+                                        &ring->desc_dma_addr, GFP_KERNEL);
         if (!ring->desc)
                 return -ENOMEM;
 
diff --git a/drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c b/drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c
index c40603a183df..b4fefb4c3064 100644
--- a/drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c
+++ b/drivers/net/ethernet/huawei/hinic/hinic_hw_api_cmd.c
@@ -613,8 +613,8 @@ static int alloc_cmd_buf(struct hinic_api_cmd_chain *chain,
         u8 *cmd_vaddr;
         int err = 0;
 
-        cmd_vaddr = dma_zalloc_coherent(&pdev->dev, API_CMD_BUF_SIZE,
-                                        &cmd_paddr, GFP_KERNEL);
+        cmd_vaddr = dma_alloc_coherent(&pdev->dev, API_CMD_BUF_SIZE,
+                                       &cmd_paddr, GFP_KERNEL);
         if (!cmd_vaddr) {
                 dev_err(&pdev->dev, "Failed to allocate API CMD DMA memory\n");
                 return -ENOMEM;
@@ -663,8 +663,8 @@ static int api_cmd_create_cell(struct hinic_api_cmd_chain *chain,
         dma_addr_t node_paddr;
         int err;
 
-        node = dma_zalloc_coherent(&pdev->dev, chain->cell_size,
-                                   &node_paddr, GFP_KERNEL);
+        node = dma_alloc_coherent(&pdev->dev, chain->cell_size, &node_paddr,
+                                  GFP_KERNEL);
         if (!node) {
                 dev_err(&pdev->dev, "Failed to allocate dma API CMD cell\n");
                 return -ENOMEM;
@@ -821,10 +821,10 @@ static int api_chain_init(struct hinic_api_cmd_chain *chain,
         if (!chain->cell_ctxt)
                 return -ENOMEM;
 
-        chain->wb_status = dma_zalloc_coherent(&pdev->dev,
-                                               sizeof(*chain->wb_status),
-                                               &chain->wb_status_paddr,
-                                               GFP_KERNEL);
+        chain->wb_status = dma_alloc_coherent(&pdev->dev,
+                                              sizeof(*chain->wb_status),
+                                              &chain->wb_status_paddr,
+                                              GFP_KERNEL);
         if (!chain->wb_status) {
                 dev_err(&pdev->dev, "Failed to allocate DMA wb status\n");
                 return -ENOMEM;
diff --git a/drivers/net/ethernet/huawei/hinic/hinic_hw_eqs.c b/drivers/net/ethernet/huawei/hinic/hinic_hw_eqs.c
index 7cb8b9b94726..683e67515016 100644
--- a/drivers/net/ethernet/huawei/hinic/hinic_hw_eqs.c
+++ b/drivers/net/ethernet/huawei/hinic/hinic_hw_eqs.c
@@ -593,10 +593,10 @@ static int alloc_eq_pages(struct hinic_eq *eq)
         }
 
         for (pg = 0; pg < eq->num_pages; pg++) {
-                eq->virt_addr[pg] = dma_zalloc_coherent(&pdev->dev,
-                                                        eq->page_size,
-                                                        &eq->dma_addr[pg],
-                                                        GFP_KERNEL);
+                eq->virt_addr[pg] = dma_alloc_coherent(&pdev->dev,
+                                                       eq->page_size,
+                                                       &eq->dma_addr[pg],
+                                                       GFP_KERNEL);
                 if (!eq->virt_addr[pg]) {
                         err = -ENOMEM;
                         goto err_dma_alloc;
diff --git a/drivers/net/ethernet/huawei/hinic/hinic_hw_io.c b/drivers/net/ethernet/huawei/hinic/hinic_hw_io.c
index 8e5897669a3a..a322a22d9357 100644
--- a/drivers/net/ethernet/huawei/hinic/hinic_hw_io.c
+++ b/drivers/net/ethernet/huawei/hinic/hinic_hw_io.c
@@ -355,9 +355,9 @@ int hinic_io_create_qps(struct hinic_func_to_io *func_to_io,
                 goto err_sq_db;
         }
 
-        ci_addr_base = dma_zalloc_coherent(&pdev->dev, CI_TABLE_SIZE(num_qps),
-                                           &func_to_io->ci_dma_base,
-                                           GFP_KERNEL);
+        ci_addr_base = dma_alloc_coherent(&pdev->dev, CI_TABLE_SIZE(num_qps),
+                                          &func_to_io->ci_dma_base,
+                                          GFP_KERNEL);
         if (!ci_addr_base) {
                 dev_err(&pdev->dev, "Failed to allocate CI area\n");
                 err = -ENOMEM;
diff --git a/drivers/net/ethernet/huawei/hinic/hinic_hw_qp.c b/drivers/net/ethernet/huawei/hinic/hinic_hw_qp.c
index bbf9bdd0ee3e..d62cf509646a 100644
--- a/drivers/net/ethernet/huawei/hinic/hinic_hw_qp.c
+++ b/drivers/net/ethernet/huawei/hinic/hinic_hw_qp.c
@@ -336,9 +336,9 @@ static int alloc_rq_cqe(struct hinic_rq *rq)
                 goto err_cqe_dma_arr_alloc;
 
         for (i = 0; i < wq->q_depth; i++) {
-                rq->cqe[i] = dma_zalloc_coherent(&pdev->dev,
-                                                 sizeof(*rq->cqe[i]),
-                                                 &rq->cqe_dma[i], GFP_KERNEL);
+                rq->cqe[i] = dma_alloc_coherent(&pdev->dev,
+                                                sizeof(*rq->cqe[i]),
+                                                &rq->cqe_dma[i], GFP_KERNEL);
                 if (!rq->cqe[i])
                         goto err_cqe_alloc;
         }
@@ -415,8 +415,8 @@ int hinic_init_rq(struct hinic_rq *rq, struct hinic_hwif *hwif,
 
         /* HW requirements: Must be at least 32 bit */
         pi_size = ALIGN(sizeof(*rq->pi_virt_addr), sizeof(u32));
-        rq->pi_virt_addr = dma_zalloc_coherent(&pdev->dev, pi_size,
-                                               &rq->pi_dma_addr, GFP_KERNEL);
+        rq->pi_virt_addr = dma_alloc_coherent(&pdev->dev, pi_size,
+                                              &rq->pi_dma_addr, GFP_KERNEL);
         if (!rq->pi_virt_addr) {
                 dev_err(&pdev->dev, "Failed to allocate PI address\n");
                 err = -ENOMEM;
diff --git a/drivers/net/ethernet/huawei/hinic/hinic_hw_wq.c b/drivers/net/ethernet/huawei/hinic/hinic_hw_wq.c
index 1dfa7eb05c10..cb66e7024659 100644
--- a/drivers/net/ethernet/huawei/hinic/hinic_hw_wq.c
+++ b/drivers/net/ethernet/huawei/hinic/hinic_hw_wq.c
@@ -114,8 +114,8 @@ static int queue_alloc_page(struct hinic_hwif *hwif, u64 **vaddr, u64 *paddr,
         struct pci_dev *pdev = hwif->pdev;
         dma_addr_t dma_addr;
 
-        *vaddr = dma_zalloc_coherent(&pdev->dev, page_sz, &dma_addr,
-                                     GFP_KERNEL);
+        *vaddr = dma_alloc_coherent(&pdev->dev, page_sz, &dma_addr,
+                                    GFP_KERNEL);
         if (!*vaddr) {
                 dev_err(&pdev->dev, "Failed to allocate dma for wqs page\n");
                 return -ENOMEM;
@@ -482,8 +482,8 @@ static int alloc_wq_pages(struct hinic_wq *wq, struct hinic_hwif *hwif,
                 u64 *paddr = &wq->block_vaddr[i];
                 dma_addr_t dma_addr;
 
-                *vaddr = dma_zalloc_coherent(&pdev->dev, wq->wq_page_size,
-                                             &dma_addr, GFP_KERNEL);
+                *vaddr = dma_alloc_coherent(&pdev->dev, wq->wq_page_size,
+                                            &dma_addr, GFP_KERNEL);
                 if (!*vaddr) {
                         dev_err(&pdev->dev, "Failed to allocate wq page\n");
                         goto err_alloc_wq_pages;
diff --git a/drivers/net/ethernet/ibm/emac/mal.c b/drivers/net/ethernet/ibm/emac/mal.c
index fff09dcf9e34..787d5aca5278 100644
--- a/drivers/net/ethernet/ibm/emac/mal.c
+++ b/drivers/net/ethernet/ibm/emac/mal.c
@@ -636,8 +636,8 @@ static int mal_probe(struct platform_device *ofdev)
         bd_size = sizeof(struct mal_descriptor) *
                 (NUM_TX_BUFF * mal->num_tx_chans +
                  NUM_RX_BUFF * mal->num_rx_chans);
-        mal->bd_virt = dma_zalloc_coherent(&ofdev->dev, bd_size, &mal->bd_dma,
-                                           GFP_KERNEL);
+        mal->bd_virt = dma_alloc_coherent(&ofdev->dev, bd_size, &mal->bd_dma,
+                                          GFP_KERNEL);
         if (mal->bd_virt == NULL) {
                 err = -ENOMEM;
                 goto fail_unmap;
diff --git a/drivers/net/ethernet/ibm/ibmveth.c b/drivers/net/ethernet/ibm/ibmveth.c
index 098d8764c0ea..dd71d5db7274 100644
--- a/drivers/net/ethernet/ibm/ibmveth.c
+++ b/drivers/net/ethernet/ibm/ibmveth.c
@@ -1313,7 +1313,6 @@ static int ibmveth_poll(struct napi_struct *napi, int budget)
         unsigned long lpar_rc;
         u16 mss = 0;
 
-restart_poll:
         while (frames_processed < budget) {
                 if (!ibmveth_rxq_pending_buffer(adapter))
                         break;
@@ -1401,7 +1400,6 @@ restart_poll:
                     napi_reschedule(napi)) {
                         lpar_rc = h_vio_signal(adapter->vdev->unit_address,
                                                VIO_IRQ_DISABLE);
-                        goto restart_poll;
                 }
         }
 
diff --git a/drivers/net/ethernet/intel/Kconfig b/drivers/net/ethernet/intel/Kconfig
index 31fb76ee9d82..a1246e89aad4 100644
--- a/drivers/net/ethernet/intel/Kconfig
+++ b/drivers/net/ethernet/intel/Kconfig
@@ -159,7 +159,7 @@ config IXGBE
         tristate "Intel(R) 10GbE PCI Express adapters support"
         depends on PCI
         select MDIO
-        select MDIO_DEVICE
+        select PHYLIB
         imply PTP_1588_CLOCK
         ---help---
           This driver supports Intel(R) 10GbE PCI Express family of
diff --git a/drivers/net/ethernet/intel/e1000/e1000_ethtool.c b/drivers/net/ethernet/intel/e1000/e1000_ethtool.c
index 2569a168334c..a41008523c98 100644
--- a/drivers/net/ethernet/intel/e1000/e1000_ethtool.c
+++ b/drivers/net/ethernet/intel/e1000/e1000_ethtool.c
@@ -993,8 +993,8 @@ static int e1000_setup_desc_rings(struct e1000_adapter *adapter)
 
         txdr->size = txdr->count * sizeof(struct e1000_tx_desc);
         txdr->size = ALIGN(txdr->size, 4096);
-        txdr->desc = dma_zalloc_coherent(&pdev->dev, txdr->size, &txdr->dma,
-                                         GFP_KERNEL);
+        txdr->desc = dma_alloc_coherent(&pdev->dev, txdr->size, &txdr->dma,
+                                        GFP_KERNEL);
         if (!txdr->desc) {
                 ret_val = 2;
                 goto err_nomem;
@@ -1051,8 +1051,8 @@ static int e1000_setup_desc_rings(struct e1000_adapter *adapter)
         }
 
         rxdr->size = rxdr->count * sizeof(struct e1000_rx_desc);
-        rxdr->desc = dma_zalloc_coherent(&pdev->dev, rxdr->size, &rxdr->dma,
-                                         GFP_KERNEL);
+        rxdr->desc = dma_alloc_coherent(&pdev->dev, rxdr->size, &rxdr->dma,
+                                        GFP_KERNEL);
         if (!rxdr->desc) {
                 ret_val = 6;
                 goto err_nomem;
diff --git a/drivers/net/ethernet/intel/e1000e/netdev.c b/drivers/net/ethernet/intel/e1000e/netdev.c
index 308c006cb41d..189f231075c2 100644
--- a/drivers/net/ethernet/intel/e1000e/netdev.c
+++ b/drivers/net/ethernet/intel/e1000e/netdev.c
@@ -2305,8 +2305,8 @@ static int e1000_alloc_ring_dma(struct e1000_adapter *adapter,
 {
         struct pci_dev *pdev = adapter->pdev;
 
-        ring->desc = dma_zalloc_coherent(&pdev->dev, ring->size, &ring->dma,
-                                         GFP_KERNEL);
+        ring->desc = dma_alloc_coherent(&pdev->dev, ring->size, &ring->dma,
+                                        GFP_KERNEL);
         if (!ring->desc)
                 return -ENOMEM;
 
diff --git a/drivers/net/ethernet/intel/i40e/i40e_main.c b/drivers/net/ethernet/intel/i40e/i40e_main.c
index 4d40878e395a..f52e2c46e6a7 100644
--- a/drivers/net/ethernet/intel/i40e/i40e_main.c
+++ b/drivers/net/ethernet/intel/i40e/i40e_main.c
@@ -109,8 +109,8 @@ int i40e_allocate_dma_mem_d(struct i40e_hw *hw, struct i40e_dma_mem *mem,
         struct i40e_pf *pf = (struct i40e_pf *)hw->back;
 
         mem->size = ALIGN(size, alignment);
-        mem->va = dma_zalloc_coherent(&pf->pdev->dev, mem->size,
-                                      &mem->pa, GFP_KERNEL);
+        mem->va = dma_alloc_coherent(&pf->pdev->dev, mem->size, &mem->pa,
+                                     GFP_KERNEL);
         if (!mem->va)
                 return -ENOMEM;
 
diff --git a/drivers/net/ethernet/intel/igb/igb.h b/drivers/net/ethernet/intel/igb/igb.h
index fe1592ae8769..ca54e268d157 100644
--- a/drivers/net/ethernet/intel/igb/igb.h
+++ b/drivers/net/ethernet/intel/igb/igb.h
@@ -515,7 +515,7 @@ struct igb_adapter {
         /* OS defined structs */
         struct pci_dev *pdev;
 
-        struct mutex stats64_lock;
+        spinlock_t stats64_lock;
         struct rtnl_link_stats64 stats64;
 
         /* structs defined in e1000_hw.h */
diff --git a/drivers/net/ethernet/intel/igb/igb_ethtool.c b/drivers/net/ethernet/intel/igb/igb_ethtool.c
index 7426060b678f..c57671068245 100644
--- a/drivers/net/ethernet/intel/igb/igb_ethtool.c
+++ b/drivers/net/ethernet/intel/igb/igb_ethtool.c
@@ -2295,7 +2295,7 @@ static void igb_get_ethtool_stats(struct net_device *netdev,
         int i, j;
         char *p;
 
-        mutex_lock(&adapter->stats64_lock);
+        spin_lock(&adapter->stats64_lock);
         igb_update_stats(adapter);
 
         for (i = 0; i < IGB_GLOBAL_STATS_LEN; i++) {
@@ -2338,7 +2338,7 @@ static void igb_get_ethtool_stats(struct net_device *netdev,
                 } while (u64_stats_fetch_retry_irq(&ring->rx_syncp, start));
                 i += IGB_RX_QUEUE_STATS_LEN;
         }
-        mutex_unlock(&adapter->stats64_lock);
+        spin_unlock(&adapter->stats64_lock);
 }
 
 static void igb_get_strings(struct net_device *netdev, u32 stringset, u8 *data)
diff --git a/drivers/net/ethernet/intel/igb/igb_main.c b/drivers/net/ethernet/intel/igb/igb_main.c
index 87bdf1604ae2..7137e7f9c7f3 100644
--- a/drivers/net/ethernet/intel/igb/igb_main.c
+++ b/drivers/net/ethernet/intel/igb/igb_main.c
@@ -2203,9 +2203,9 @@ void igb_down(struct igb_adapter *adapter)
         del_timer_sync(&adapter->phy_info_timer);
 
         /* record the stats before reset*/
-        mutex_lock(&adapter->stats64_lock);
+        spin_lock(&adapter->stats64_lock);
         igb_update_stats(adapter);
-        mutex_unlock(&adapter->stats64_lock);
+        spin_unlock(&adapter->stats64_lock);
 
         adapter->link_speed = 0;
         adapter->link_duplex = 0;
@@ -3840,7 +3840,7 @@ static int igb_sw_init(struct igb_adapter *adapter)
         adapter->min_frame_size = ETH_ZLEN + ETH_FCS_LEN;
 
         spin_lock_init(&adapter->nfc_lock);
-        mutex_init(&adapter->stats64_lock);
+        spin_lock_init(&adapter->stats64_lock);
 #ifdef CONFIG_PCI_IOV
         switch (hw->mac.type) {
         case e1000_82576:
@@ -5406,9 +5406,9 @@ no_wait:
                 }
         }
 
-        mutex_lock(&adapter->stats64_lock);
+        spin_lock(&adapter->stats64_lock);
         igb_update_stats(adapter);
-        mutex_unlock(&adapter->stats64_lock);
+        spin_unlock(&adapter->stats64_lock);
 
         for (i = 0; i < adapter->num_tx_queues; i++) {
                 struct igb_ring *tx_ring = adapter->tx_ring[i];
@@ -6235,10 +6235,10 @@ static void igb_get_stats64(struct net_device *netdev,
 {
         struct igb_adapter *adapter = netdev_priv(netdev);
 
-        mutex_lock(&adapter->stats64_lock);
+        spin_lock(&adapter->stats64_lock);
         igb_update_stats(adapter);
         memcpy(stats, &adapter->stats64, sizeof(*stats));
-        mutex_unlock(&adapter->stats64_lock);
+        spin_unlock(&adapter->stats64_lock);
 }
 
 /**
diff --git a/drivers/net/ethernet/intel/ixgb/ixgb_main.c b/drivers/net/ethernet/intel/ixgb/ixgb_main.c
index 1d4d1686909a..e5ac2d3fd816 100644
--- a/drivers/net/ethernet/intel/ixgb/ixgb_main.c
+++ b/drivers/net/ethernet/intel/ixgb/ixgb_main.c
@@ -680,8 +680,8 @@ ixgb_setup_tx_resources(struct ixgb_adapter *adapter)
         txdr->size = txdr->count * sizeof(struct ixgb_tx_desc);
         txdr->size = ALIGN(txdr->size, 4096);
 
-        txdr->desc = dma_zalloc_coherent(&pdev->dev, txdr->size, &txdr->dma,
-                                         GFP_KERNEL);
+        txdr->desc = dma_alloc_coherent(&pdev->dev, txdr->size, &txdr->dma,
+                                        GFP_KERNEL);
         if (!txdr->desc) {
                 vfree(txdr->buffer_info);
                 return -ENOMEM;
@@ -763,8 +763,8 @@ ixgb_setup_rx_resources(struct ixgb_adapter *adapter)
         rxdr->size = rxdr->count * sizeof(struct ixgb_rx_desc);
         rxdr->size = ALIGN(rxdr->size, 4096);
 
-        rxdr->desc = dma_zalloc_coherent(&pdev->dev, rxdr->size, &rxdr->dma,
-                                         GFP_KERNEL);
+        rxdr->desc = dma_alloc_coherent(&pdev->dev, rxdr->size, &rxdr->dma,
+                                        GFP_KERNEL);
 
         if (!rxdr->desc) {
                 vfree(rxdr->buffer_info);
diff --git a/drivers/net/ethernet/marvell/mvpp2/mvpp2_main.c b/drivers/net/ethernet/marvell/mvpp2/mvpp2_main.c
index e0875476a780..16066c2d5b3a 100644
--- a/drivers/net/ethernet/marvell/mvpp2/mvpp2_main.c
+++ b/drivers/net/ethernet/marvell/mvpp2/mvpp2_main.c
@@ -2044,9 +2044,9 @@ static int mvpp2_aggr_txq_init(struct platform_device *pdev,
         u32 txq_dma;
 
         /* Allocate memory for TX descriptors */
-        aggr_txq->descs = dma_zalloc_coherent(&pdev->dev,
-                                MVPP2_AGGR_TXQ_SIZE * MVPP2_DESC_ALIGNED_SIZE,
-                                &aggr_txq->descs_dma, GFP_KERNEL);
+        aggr_txq->descs = dma_alloc_coherent(&pdev->dev,
+                                             MVPP2_AGGR_TXQ_SIZE * MVPP2_DESC_ALIGNED_SIZE,
+                                             &aggr_txq->descs_dma, GFP_KERNEL);
         if (!aggr_txq->descs)
                 return -ENOMEM;
 
diff --git a/drivers/net/ethernet/marvell/octeontx2/af/cgx.c b/drivers/net/ethernet/marvell/octeontx2/af/cgx.c
index 742f0c1f60df..6d55e3d0b7ea 100644
--- a/drivers/net/ethernet/marvell/octeontx2/af/cgx.c
+++ b/drivers/net/ethernet/marvell/octeontx2/af/cgx.c
@@ -825,7 +825,7 @@ static int cgx_probe(struct pci_dev *pdev, const struct pci_device_id *id)
         if (!cgx->cgx_cmd_workq) {
                 dev_err(dev, "alloc workqueue failed for cgx cmd");
                 err = -ENOMEM;
-                goto err_release_regions;
+                goto err_free_irq_vectors;
         }
 
         list_add(&cgx->cgx_list, &cgx_list);
@@ -841,6 +841,8 @@ static int cgx_probe(struct pci_dev *pdev, const struct pci_device_id *id)
 err_release_lmac:
         cgx_lmac_exit(cgx);
         list_del(&cgx->cgx_list);
+err_free_irq_vectors:
+        pci_free_irq_vectors(pdev);
 err_release_regions:
         pci_release_regions(pdev);
 err_disable_device:
diff --git a/drivers/net/ethernet/marvell/octeontx2/af/common.h b/drivers/net/ethernet/marvell/octeontx2/af/common.h
index ec50a21c5aaf..e332e82fc066 100644
--- a/drivers/net/ethernet/marvell/octeontx2/af/common.h
+++ b/drivers/net/ethernet/marvell/octeontx2/af/common.h
@@ -64,7 +64,7 @@ static inline int qmem_alloc(struct device *dev, struct qmem **q,
 
         qmem->entry_sz = entry_sz;
         qmem->alloc_sz = (qsize * entry_sz) + OTX2_ALIGN;
-        qmem->base = dma_zalloc_coherent(dev, qmem->alloc_sz,
+        qmem->base = dma_alloc_coherent(dev, qmem->alloc_sz,
                                          &qmem->iova, GFP_KERNEL);
         if (!qmem->base)
                 return -ENOMEM;
diff --git a/drivers/net/ethernet/marvell/pxa168_eth.c b/drivers/net/ethernet/marvell/pxa168_eth.c
index 0bd4351b2a49..f8a6d6e3cb7a 100644
--- a/drivers/net/ethernet/marvell/pxa168_eth.c
+++ b/drivers/net/ethernet/marvell/pxa168_eth.c
@@ -557,9 +557,9 @@ static int init_hash_table(struct pxa168_eth_private *pep)
          * table is full.
          */
         if (!pep->htpr) {
-                pep->htpr = dma_zalloc_coherent(pep->dev->dev.parent,
-                                                HASH_ADDR_TABLE_SIZE,
-                                                &pep->htpr_dma, GFP_KERNEL);
+                pep->htpr = dma_alloc_coherent(pep->dev->dev.parent,
+                                               HASH_ADDR_TABLE_SIZE,
+                                               &pep->htpr_dma, GFP_KERNEL);
                 if (!pep->htpr)
                         return -ENOMEM;
         } else {
@@ -1044,9 +1044,9 @@ static int rxq_init(struct net_device *dev)
         pep->rx_desc_count = 0;
         size = pep->rx_ring_size * sizeof(struct rx_desc);
         pep->rx_desc_area_size = size;
-        pep->p_rx_desc_area = dma_zalloc_coherent(pep->dev->dev.parent, size,
-                                                  &pep->rx_desc_dma,
-                                                  GFP_KERNEL);
+        pep->p_rx_desc_area = dma_alloc_coherent(pep->dev->dev.parent, size,
+                                                 &pep->rx_desc_dma,
+                                                 GFP_KERNEL);
         if (!pep->p_rx_desc_area)
                 goto out;
 
@@ -1103,9 +1103,9 @@ static int txq_init(struct net_device *dev)
         pep->tx_desc_count = 0;
         size = pep->tx_ring_size * sizeof(struct tx_desc);
         pep->tx_desc_area_size = size;
-        pep->p_tx_desc_area = dma_zalloc_coherent(pep->dev->dev.parent, size,
-                                                  &pep->tx_desc_dma,
-                                                  GFP_KERNEL);
+        pep->p_tx_desc_area = dma_alloc_coherent(pep->dev->dev.parent, size,
+                                                 &pep->tx_desc_dma,
+                                                 GFP_KERNEL);
         if (!pep->p_tx_desc_area)
                 goto out;
         /* Initialize the next_desc_ptr links in the Tx descriptors ring */
diff --git a/drivers/net/ethernet/mediatek/mtk_eth_soc.c b/drivers/net/ethernet/mediatek/mtk_eth_soc.c
index 399f565dd85a..49f926b7a91c 100644
--- a/drivers/net/ethernet/mediatek/mtk_eth_soc.c
+++ b/drivers/net/ethernet/mediatek/mtk_eth_soc.c
@@ -258,11 +258,6 @@ static void mtk_phy_link_adjust(struct net_device *dev)
 
         mtk_w32(mac->hw, mcr, MTK_MAC_MCR(mac->id));
 
-        if (dev->phydev->link)
-                netif_carrier_on(dev);
-        else
-                netif_carrier_off(dev);
-
         if (!of_phy_is_fixed_link(mac->of_node))
                 phy_print_status(dev->phydev);
 }
@@ -347,17 +342,6 @@ static int mtk_phy_connect(struct net_device *dev)
         if (mtk_phy_connect_node(eth, mac, np))
                 goto err_phy;
 
-        dev->phydev->autoneg = AUTONEG_ENABLE;
-        dev->phydev->speed = 0;
-        dev->phydev->duplex = 0;
-
-        phy_set_max_speed(dev->phydev, SPEED_1000);
-        phy_support_asym_pause(dev->phydev);
-        linkmode_copy(dev->phydev->advertising, dev->phydev->supported);
-        linkmode_set_bit(ETHTOOL_LINK_MODE_Autoneg_BIT,
-                         dev->phydev->advertising);
-        phy_start_aneg(dev->phydev);
-
         of_node_put(np);
 
         return 0;
@@ -598,10 +582,10 @@ static int mtk_init_fq_dma(struct mtk_eth *eth)
         dma_addr_t dma_addr;
         int i;
 
-        eth->scratch_ring = dma_zalloc_coherent(eth->dev,
-                                                cnt * sizeof(struct mtk_tx_dma),
-                                                &eth->phy_scratch_ring,
-                                                GFP_ATOMIC);
+        eth->scratch_ring = dma_alloc_coherent(eth->dev,
+                                               cnt * sizeof(struct mtk_tx_dma),
+                                               &eth->phy_scratch_ring,
+                                               GFP_ATOMIC);
         if (unlikely(!eth->scratch_ring))
                 return -ENOMEM;
 
@@ -1213,8 +1197,8 @@ static int mtk_tx_alloc(struct mtk_eth *eth)
         if (!ring->buf)
                 goto no_tx_mem;
 
-        ring->dma = dma_zalloc_coherent(eth->dev, MTK_DMA_SIZE * sz,
-                                        &ring->phys, GFP_ATOMIC);
+        ring->dma = dma_alloc_coherent(eth->dev, MTK_DMA_SIZE * sz,
+                                       &ring->phys, GFP_ATOMIC);
         if (!ring->dma)
                 goto no_tx_mem;
 
@@ -1310,9 +1294,9 @@ static int mtk_rx_alloc(struct mtk_eth *eth, int ring_no, int rx_flag)
                         return -ENOMEM;
         }
 
-        ring->dma = dma_zalloc_coherent(eth->dev,
-                                        rx_dma_size * sizeof(*ring->dma),
-                                        &ring->phys, GFP_ATOMIC);
+        ring->dma = dma_alloc_coherent(eth->dev,
+                                       rx_dma_size * sizeof(*ring->dma),
+                                       &ring->phys, GFP_ATOMIC);
         if (!ring->dma)
                 return -ENOMEM;
 
diff --git a/drivers/net/ethernet/mellanox/mlx4/alloc.c b/drivers/net/ethernet/mellanox/mlx4/alloc.c
index 9af34e03892c..dbc483e4a2ef 100644
--- a/drivers/net/ethernet/mellanox/mlx4/alloc.c
+++ b/drivers/net/ethernet/mellanox/mlx4/alloc.c
@@ -584,8 +584,8 @@ static int mlx4_buf_direct_alloc(struct mlx4_dev *dev, int size,
         buf->npages       = 1;
         buf->page_shift   = get_order(size) + PAGE_SHIFT;
         buf->direct.buf   =
-                dma_zalloc_coherent(&dev->persist->pdev->dev,
-                                    size, &t, GFP_KERNEL);
+                dma_alloc_coherent(&dev->persist->pdev->dev, size, &t,
+                                   GFP_KERNEL);
         if (!buf->direct.buf)
                 return -ENOMEM;
 
@@ -624,8 +624,8 @@ int mlx4_buf_alloc(struct mlx4_dev *dev, int size, int max_direct,
 
                 for (i = 0; i < buf->nbufs; ++i) {
                         buf->page_list[i].buf =
-                                dma_zalloc_coherent(&dev->persist->pdev->dev,
-                                                    PAGE_SIZE, &t, GFP_KERNEL);
+                                dma_alloc_coherent(&dev->persist->pdev->dev,
+                                                   PAGE_SIZE, &t, GFP_KERNEL);
                         if (!buf->page_list[i].buf)
                                 goto err_free;
 
diff --git a/drivers/net/ethernet/mellanox/mlx4/cq.c b/drivers/net/ethernet/mellanox/mlx4/cq.c
index db909b6069b5..65f8a4b6ed0c 100644
--- a/drivers/net/ethernet/mellanox/mlx4/cq.c
+++ b/drivers/net/ethernet/mellanox/mlx4/cq.c
@@ -306,14 +306,16 @@ static int mlx4_init_user_cqes(void *buf, int entries, int cqe_size)
 
         if (entries_per_copy < entries) {
                 for (i = 0; i < entries / entries_per_copy; i++) {
-                        err = copy_to_user(buf, init_ents, PAGE_SIZE);
+                        err = copy_to_user((void __user *)buf, init_ents, PAGE_SIZE) ?
+                                -EFAULT : 0;
                         if (err)
                                 goto out;
 
                         buf += PAGE_SIZE;
                 }
         } else {
-                err = copy_to_user(buf, init_ents, entries * cqe_size);
+                err = copy_to_user((void __user *)buf, init_ents, entries * cqe_size) ?
+                        -EFAULT : 0;
         }
 
 out:
diff --git a/drivers/net/ethernet/mellanox/mlx4/fw.c b/drivers/net/ethernet/mellanox/mlx4/fw.c
index 7df728f1e5b5..6e501af0e532 100644
--- a/drivers/net/ethernet/mellanox/mlx4/fw.c
+++ b/drivers/net/ethernet/mellanox/mlx4/fw.c
@@ -2067,9 +2067,11 @@ int mlx4_QUERY_HCA(struct mlx4_dev *dev,
 {
         struct mlx4_cmd_mailbox *mailbox;
         __be32 *outbox;
+        u64 qword_field;
         u32 dword_field;
-        int err;
+        u16 word_field;
         u8 byte_field;
+        int err;
         static const u8 a0_dmfs_query_hw_steering[] =  {
                 [0] = MLX4_STEERING_DMFS_A0_DEFAULT,
                 [1] = MLX4_STEERING_DMFS_A0_DYNAMIC,
@@ -2097,19 +2099,32 @@ int mlx4_QUERY_HCA(struct mlx4_dev *dev,
 
         /* QPC/EEC/CQC/EQC/RDMARC attributes */
 
-        MLX4_GET(param->qpc_base,      outbox, INIT_HCA_QPC_BASE_OFFSET);
-        MLX4_GET(param->log_num_qps,   outbox, INIT_HCA_LOG_QP_OFFSET);
-        MLX4_GET(param->srqc_base,     outbox, INIT_HCA_SRQC_BASE_OFFSET);
-        MLX4_GET(param->log_num_srqs,  outbox, INIT_HCA_LOG_SRQ_OFFSET);
-        MLX4_GET(param->cqc_base,      outbox, INIT_HCA_CQC_BASE_OFFSET);
-        MLX4_GET(param->log_num_cqs,   outbox, INIT_HCA_LOG_CQ_OFFSET);
-        MLX4_GET(param->altc_base,     outbox, INIT_HCA_ALTC_BASE_OFFSET);
-        MLX4_GET(param->auxc_base,     outbox, INIT_HCA_AUXC_BASE_OFFSET);
-        MLX4_GET(param->eqc_base,      outbox, INIT_HCA_EQC_BASE_OFFSET);
-        MLX4_GET(param->log_num_eqs,   outbox, INIT_HCA_LOG_EQ_OFFSET);
-        MLX4_GET(param->num_sys_eqs,   outbox, INIT_HCA_NUM_SYS_EQS_OFFSET);
-        MLX4_GET(param->rdmarc_base,   outbox, INIT_HCA_RDMARC_BASE_OFFSET);
-        MLX4_GET(param->log_rd_per_qp, outbox, INIT_HCA_LOG_RD_OFFSET);
+        MLX4_GET(qword_field, outbox, INIT_HCA_QPC_BASE_OFFSET);
+        param->qpc_base = qword_field & ~((u64)0x1f);
+        MLX4_GET(byte_field, outbox, INIT_HCA_LOG_QP_OFFSET);
+        param->log_num_qps = byte_field & 0x1f;
+        MLX4_GET(qword_field, outbox, INIT_HCA_SRQC_BASE_OFFSET);
+        param->srqc_base = qword_field & ~((u64)0x1f);
+        MLX4_GET(byte_field, outbox, INIT_HCA_LOG_SRQ_OFFSET);
+        param->log_num_srqs = byte_field & 0x1f;
+        MLX4_GET(qword_field, outbox, INIT_HCA_CQC_BASE_OFFSET);
+        param->cqc_base = qword_field & ~((u64)0x1f);
+        MLX4_GET(byte_field, outbox, INIT_HCA_LOG_CQ_OFFSET);
+        param->log_num_cqs = byte_field & 0x1f;
+        MLX4_GET(qword_field, outbox, INIT_HCA_ALTC_BASE_OFFSET);
+        param->altc_base = qword_field;
+        MLX4_GET(qword_field, outbox, INIT_HCA_AUXC_BASE_OFFSET);
+        param->auxc_base = qword_field;
+        MLX4_GET(qword_field, outbox, INIT_HCA_EQC_BASE_OFFSET);
+        param->eqc_base = qword_field & ~((u64)0x1f);
+        MLX4_GET(byte_field, outbox, INIT_HCA_LOG_EQ_OFFSET);
+        param->log_num_eqs = byte_field & 0x1f;
+        MLX4_GET(word_field, outbox, INIT_HCA_NUM_SYS_EQS_OFFSET);
+        param->num_sys_eqs = word_field & 0xfff;
+        MLX4_GET(qword_field, outbox, INIT_HCA_RDMARC_BASE_OFFSET);
+        param->rdmarc_base = qword_field & ~((u64)0x1f);
+        MLX4_GET(byte_field, outbox, INIT_HCA_LOG_RD_OFFSET);
+        param->log_rd_per_qp = byte_field & 0x7;
 
         MLX4_GET(dword_field, outbox, INIT_HCA_FLAGS_OFFSET);
         if (dword_field & (1 << INIT_HCA_DEVICE_MANAGED_FLOW_STEERING_EN)) {
@@ -2128,22 +2143,21 @@ int mlx4_QUERY_HCA(struct mlx4_dev *dev,
         /* steering attributes */
         if (param->steering_mode == MLX4_STEERING_MODE_DEVICE_MANAGED) {
                 MLX4_GET(param->mc_base, outbox, INIT_HCA_FS_BASE_OFFSET);
-                MLX4_GET(param->log_mc_entry_sz, outbox,
-                         INIT_HCA_FS_LOG_ENTRY_SZ_OFFSET);
-                MLX4_GET(param->log_mc_table_sz, outbox,
-                         INIT_HCA_FS_LOG_TABLE_SZ_OFFSET);
-                MLX4_GET(byte_field, outbox,
-                         INIT_HCA_FS_A0_OFFSET);
+                MLX4_GET(byte_field, outbox, INIT_HCA_FS_LOG_ENTRY_SZ_OFFSET);
+                param->log_mc_entry_sz = byte_field & 0x1f;
+                MLX4_GET(byte_field, outbox, INIT_HCA_FS_LOG_TABLE_SZ_OFFSET);
+                param->log_mc_table_sz = byte_field & 0x1f;
+                MLX4_GET(byte_field, outbox, INIT_HCA_FS_A0_OFFSET);
                 param->dmfs_high_steer_mode =
                         a0_dmfs_query_hw_steering[(byte_field >> 6) & 3];
         } else {
                 MLX4_GET(param->mc_base, outbox, INIT_HCA_MC_BASE_OFFSET);
-                MLX4_GET(param->log_mc_entry_sz, outbox,
-                         INIT_HCA_LOG_MC_ENTRY_SZ_OFFSET);
-                MLX4_GET(param->log_mc_hash_sz,  outbox,
-                         INIT_HCA_LOG_MC_HASH_SZ_OFFSET);
-                MLX4_GET(param->log_mc_table_sz, outbox,
-                         INIT_HCA_LOG_MC_TABLE_SZ_OFFSET);
+                MLX4_GET(byte_field, outbox, INIT_HCA_LOG_MC_ENTRY_SZ_OFFSET);
+                param->log_mc_entry_sz = byte_field & 0x1f;
+                MLX4_GET(byte_field,  outbox, INIT_HCA_LOG_MC_HASH_SZ_OFFSET);
+                param->log_mc_hash_sz = byte_field & 0x1f;
+                MLX4_GET(byte_field, outbox, INIT_HCA_LOG_MC_TABLE_SZ_OFFSET);
+                param->log_mc_table_sz = byte_field & 0x1f;
         }
 
         /* CX3 is capable of extending CQEs/EQEs from 32 to 64 bytes */
@@ -2167,15 +2181,18 @@ int mlx4_QUERY_HCA(struct mlx4_dev *dev,
         /* TPT attributes */
 
         MLX4_GET(param->dmpt_base,  outbox, INIT_HCA_DMPT_BASE_OFFSET);
-        MLX4_GET(param->mw_enabled, outbox, INIT_HCA_TPT_MW_OFFSET);
-        MLX4_GET(param->log_mpt_sz, outbox, INIT_HCA_LOG_MPT_SZ_OFFSET);
+        MLX4_GET(byte_field, outbox, INIT_HCA_TPT_MW_OFFSET);
+        param->mw_enabled = byte_field >> 7;
+        MLX4_GET(byte_field, outbox, INIT_HCA_LOG_MPT_SZ_OFFSET);
+        param->log_mpt_sz = byte_field & 0x3f;
         MLX4_GET(param->mtt_base,   outbox, INIT_HCA_MTT_BASE_OFFSET);
         MLX4_GET(param->cmpt_base,  outbox, INIT_HCA_CMPT_BASE_OFFSET);
 
         /* UAR attributes */
 
         MLX4_GET(param->uar_page_sz, outbox, INIT_HCA_UAR_PAGE_SZ_OFFSET);
-        MLX4_GET(param->log_uar_sz, outbox, INIT_HCA_LOG_UAR_SZ_OFFSET);
+        MLX4_GET(byte_field, outbox, INIT_HCA_LOG_UAR_SZ_OFFSET);
+        param->log_uar_sz = byte_field & 0xf;
 
         /* phv_check enable */
         MLX4_GET(byte_field, outbox, INIT_HCA_CACHELINE_SZ_OFFSET);
diff --git a/drivers/net/ethernet/mellanox/mlx4/icm.c b/drivers/net/ethernet/mellanox/mlx4/icm.c
index 4b4351141b94..d89a3da89e5a 100644
--- a/drivers/net/ethernet/mellanox/mlx4/icm.c
+++ b/drivers/net/ethernet/mellanox/mlx4/icm.c
@@ -57,12 +57,12 @@ static void mlx4_free_icm_pages(struct mlx4_dev *dev, struct mlx4_icm_chunk *chu
         int i;
 
         if (chunk->nsg > 0)
-                pci_unmap_sg(dev->persist->pdev, chunk->mem, chunk->npages,
-                             PCI_DMA_BIDIRECTIONAL);
+                dma_unmap_sg(&dev->persist->pdev->dev, chunk->sg, chunk->npages,
+                             DMA_BIDIRECTIONAL);
 
         for (i = 0; i < chunk->npages; ++i)
-                __free_pages(sg_page(&chunk->mem[i]),
-                             get_order(chunk->mem[i].length));
+                __free_pages(sg_page(&chunk->sg[i]),
+                             get_order(chunk->sg[i].length));
 }
 
 static void mlx4_free_icm_coherent(struct mlx4_dev *dev, struct mlx4_icm_chunk *chunk)
@@ -71,9 +71,9 @@ static void mlx4_free_icm_coherent(struct mlx4_dev *dev, struct mlx4_icm_chunk *
 
         for (i = 0; i < chunk->npages; ++i)
                 dma_free_coherent(&dev->persist->pdev->dev,
-                                  chunk->mem[i].length,
-                                  lowmem_page_address(sg_page(&chunk->mem[i])),
-                                  sg_dma_address(&chunk->mem[i]));
+                                  chunk->buf[i].size,
+                                  chunk->buf[i].addr,
+                                  chunk->buf[i].dma_addr);
 }
 
 void mlx4_free_icm(struct mlx4_dev *dev, struct mlx4_icm *icm, int coherent)
@@ -111,22 +111,21 @@ static int mlx4_alloc_icm_pages(struct scatterlist *mem, int order,
         return 0;
 }
 
-static int mlx4_alloc_icm_coherent(struct device *dev, struct scatterlist *mem,
-                                    int order, gfp_t gfp_mask)
+static int mlx4_alloc_icm_coherent(struct device *dev, struct mlx4_icm_buf *buf,
+                                   int order, gfp_t gfp_mask)
 {
-        void *buf = dma_alloc_coherent(dev, PAGE_SIZE << order,
-                                       &sg_dma_address(mem), gfp_mask);
-        if (!buf)
+        buf->addr = dma_alloc_coherent(dev, PAGE_SIZE << order,
+                                       &buf->dma_addr, gfp_mask);
+        if (!buf->addr)
                 return -ENOMEM;
 
-        if (offset_in_page(buf)) {
-                dma_free_coherent(dev, PAGE_SIZE << order,
-                                  buf, sg_dma_address(mem));
+        if (offset_in_page(buf->addr)) {
+                dma_free_coherent(dev, PAGE_SIZE << order, buf->addr,
+                                  buf->dma_addr);
                 return -ENOMEM;
         }
 
-        sg_set_buf(mem, buf, PAGE_SIZE << order);
-        sg_dma_len(mem) = PAGE_SIZE << order;
+        buf->size = PAGE_SIZE << order;
         return 0;
 }
 
@@ -159,21 +158,21 @@ struct mlx4_icm *mlx4_alloc_icm(struct mlx4_dev *dev, int npages,
 
         while (npages > 0) {
                 if (!chunk) {
-                        chunk = kmalloc_node(sizeof(*chunk),
+                        chunk = kzalloc_node(sizeof(*chunk),
                                              gfp_mask & ~(__GFP_HIGHMEM |
                                                           __GFP_NOWARN),
                                              dev->numa_node);
                         if (!chunk) {
-                                chunk = kmalloc(sizeof(*chunk),
+                                chunk = kzalloc(sizeof(*chunk),
                                                 gfp_mask & ~(__GFP_HIGHMEM |
                                                              __GFP_NOWARN));
                                 if (!chunk)
                                         goto fail;
                         }
+                        chunk->coherent = coherent;
 
-                        sg_init_table(chunk->mem, MLX4_ICM_CHUNK_LEN);
-                        chunk->npages = 0;
-                        chunk->nsg    = 0;
+                        if (!coherent)
+                                sg_init_table(chunk->sg, MLX4_ICM_CHUNK_LEN);
                         list_add_tail(&chunk->list, &icm->chunk_list);
                 }
 
@@ -186,10 +185,10 @@ struct mlx4_icm *mlx4_alloc_icm(struct mlx4_dev *dev, int npages,
 
                 if (coherent)
                         ret = mlx4_alloc_icm_coherent(&dev->persist->pdev->dev,
-                                                      &chunk->mem[chunk->npages],
-                                                      cur_order, mask);
+                                                &chunk->buf[chunk->npages],
+                                                cur_order, mask);
                 else
-                        ret = mlx4_alloc_icm_pages(&chunk->mem[chunk->npages],
+                        ret = mlx4_alloc_icm_pages(&chunk->sg[chunk->npages],
                                                    cur_order, mask,
                                                    dev->numa_node);
 
@@ -205,9 +204,9 @@ struct mlx4_icm *mlx4_alloc_icm(struct mlx4_dev *dev, int npages,
                 if (coherent)
                         ++chunk->nsg;
                 else if (chunk->npages == MLX4_ICM_CHUNK_LEN) {
-                        chunk->nsg = pci_map_sg(dev->persist->pdev, chunk->mem,
-                                                chunk->npages,
-                                                PCI_DMA_BIDIRECTIONAL);
+                        chunk->nsg = dma_map_sg(&dev->persist->pdev->dev,
+                                                chunk->sg, chunk->npages,
+                                                DMA_BIDIRECTIONAL);
 
                         if (chunk->nsg <= 0)
                                 goto fail;
@@ -220,9 +219,8 @@ struct mlx4_icm *mlx4_alloc_icm(struct mlx4_dev *dev, int npages,
         }
 
         if (!coherent && chunk) {
-                chunk->nsg = pci_map_sg(dev->persist->pdev, chunk->mem,
-                                        chunk->npages,
-                                        PCI_DMA_BIDIRECTIONAL);
+                chunk->nsg = dma_map_sg(&dev->persist->pdev->dev, chunk->sg,
+                                        chunk->npages, DMA_BIDIRECTIONAL);
 
                 if (chunk->nsg <= 0)
                         goto fail;
@@ -320,7 +318,7 @@ void *mlx4_table_find(struct mlx4_icm_table *table, u32 obj,
         u64 idx;
         struct mlx4_icm_chunk *chunk;
         struct mlx4_icm *icm;
-        struct page *page = NULL;
+        void *addr = NULL;
 
         if (!table->lowmem)
                 return NULL;
@@ -336,28 +334,49 @@ void *mlx4_table_find(struct mlx4_icm_table *table, u32 obj,
 
         list_for_each_entry(chunk, &icm->chunk_list, list) {
                 for (i = 0; i < chunk->npages; ++i) {
+                        dma_addr_t dma_addr;
+                        size_t len;
+
+                        if (table->coherent) {
+                                len = chunk->buf[i].size;
+                                dma_addr = chunk->buf[i].dma_addr;
+                                addr = chunk->buf[i].addr;
+                        } else {
+                                struct page *page;
+
+                                len = sg_dma_len(&chunk->sg[i]);
+                                dma_addr = sg_dma_address(&chunk->sg[i]);
+
+                                /* XXX: we should never do this for highmem
+                                 * allocation.  This function either needs
+                                 * to be split, or the kernel virtual address
+                                 * return needs to be made optional.
+                                 */
+                                page = sg_page(&chunk->sg[i]);
+                                addr = lowmem_page_address(page);
+                        }
+
                         if (dma_handle && dma_offset >= 0) {
-                                if (sg_dma_len(&chunk->mem[i]) > dma_offset)
-                                        *dma_handle = sg_dma_address(&chunk->mem[i]) +
-                                                dma_offset;
-                                dma_offset -= sg_dma_len(&chunk->mem[i]);
+                                if (len > dma_offset)
+                                        *dma_handle = dma_addr + dma_offset;
+                                dma_offset -= len;
                         }
+
                         /*
                          * DMA mapping can merge pages but not split them,
                          * so if we found the page, dma_handle has already
                          * been assigned to.
                          */
-                        if (chunk->mem[i].length > offset) {
-                                page = sg_page(&chunk->mem[i]);
+                        if (len > offset)
                                 goto out;
-                        }
-                        offset -= chunk->mem[i].length;
+                        offset -= len;
                 }
         }
 
+        addr = NULL;
 out:
         mutex_unlock(&table->mutex);
-        return page ? lowmem_page_address(page) + offset : NULL;
+        return addr ? addr + offset : NULL;
 }
 
 int mlx4_table_get_range(struct mlx4_dev *dev, struct mlx4_icm_table *table,
diff --git a/drivers/net/ethernet/mellanox/mlx4/icm.h b/drivers/net/ethernet/mellanox/mlx4/icm.h
index c9169a490557..d199874b1c07 100644
--- a/drivers/net/ethernet/mellanox/mlx4/icm.h
+++ b/drivers/net/ethernet/mellanox/mlx4/icm.h
@@ -47,11 +47,21 @@ enum {
         MLX4_ICM_PAGE_SIZE      = 1 << MLX4_ICM_PAGE_SHIFT,
 };
 
+struct mlx4_icm_buf {
+        void                    *addr;
+        size_t                  size;
+        dma_addr_t              dma_addr;
+};
+
 struct mlx4_icm_chunk {
         struct list_head        list;
         int                     npages;
         int                     nsg;
-        struct scatterlist      mem[MLX4_ICM_CHUNK_LEN];
+        bool                    coherent;
+        union {
+                struct scatterlist      sg[MLX4_ICM_CHUNK_LEN];
+                struct mlx4_icm_buf     buf[MLX4_ICM_CHUNK_LEN];
+        };
 };
 
 struct mlx4_icm {
@@ -114,12 +124,18 @@ static inline void mlx4_icm_next(struct mlx4_icm_iter *iter)
 
 static inline dma_addr_t mlx4_icm_addr(struct mlx4_icm_iter *iter)
 {
-        return sg_dma_address(&iter->chunk->mem[iter->page_idx]);
+        if (iter->chunk->coherent)
+                return iter->chunk->buf[iter->page_idx].dma_addr;
+        else
+                return sg_dma_address(&iter->chunk->sg[iter->page_idx]);
 }
 
 static inline unsigned long mlx4_icm_size(struct mlx4_icm_iter *iter)
 {
-        return sg_dma_len(&iter->chunk->mem[iter->page_idx]);
+        if (iter->chunk->coherent)
+                return iter->chunk->buf[iter->page_idx].size;
+        else
+                return sg_dma_len(&iter->chunk->sg[iter->page_idx]);
 }
 
 int mlx4_MAP_ICM_AUX(struct mlx4_dev *dev, struct mlx4_icm *icm);
diff --git a/drivers/net/ethernet/mellanox/mlx5/core/alloc.c b/drivers/net/ethernet/mellanox/mlx5/core/alloc.c
index 456f30007ad6..421b9c3c8bf7 100644
--- a/drivers/net/ethernet/mellanox/mlx5/core/alloc.c
+++ b/drivers/net/ethernet/mellanox/mlx5/core/alloc.c
@@ -63,8 +63,8 @@ static void *mlx5_dma_zalloc_coherent_node(struct mlx5_core_dev *dev,
         mutex_lock(&priv->alloc_mutex);
         original_node = dev_to_node(&dev->pdev->dev);
         set_dev_node(&dev->pdev->dev, node);
-        cpu_handle = dma_zalloc_coherent(&dev->pdev->dev, size,
-                                         dma_handle, GFP_KERNEL);
+        cpu_handle = dma_alloc_coherent(&dev->pdev->dev, size, dma_handle,
+                                        GFP_KERNEL);
         set_dev_node(&dev->pdev->dev, original_node);
         mutex_unlock(&priv->alloc_mutex);
         return cpu_handle;
diff --git a/drivers/net/ethernet/mellanox/mlx5/core/cmd.c b/drivers/net/ethernet/mellanox/mlx5/core/cmd.c
index d3125cdf69db..3e0fa8a8077b 100644
--- a/drivers/net/ethernet/mellanox/mlx5/core/cmd.c
+++ b/drivers/net/ethernet/mellanox/mlx5/core/cmd.c
@@ -1789,8 +1789,8 @@ static int alloc_cmd_page(struct mlx5_core_dev *dev, struct mlx5_cmd *cmd)
 {
         struct device *ddev = &dev->pdev->dev;
 
-        cmd->cmd_alloc_buf = dma_zalloc_coherent(ddev, MLX5_ADAPTER_PAGE_SIZE,
-                                                 &cmd->alloc_dma, GFP_KERNEL);
+        cmd->cmd_alloc_buf = dma_alloc_coherent(ddev, MLX5_ADAPTER_PAGE_SIZE,
+                                                &cmd->alloc_dma, GFP_KERNEL);
         if (!cmd->cmd_alloc_buf)
                 return -ENOMEM;
 
@@ -1804,9 +1804,9 @@ static int alloc_cmd_page(struct mlx5_core_dev *dev, struct mlx5_cmd *cmd)
 
         dma_free_coherent(ddev, MLX5_ADAPTER_PAGE_SIZE, cmd->cmd_alloc_buf,
                           cmd->alloc_dma);
-        cmd->cmd_alloc_buf = dma_zalloc_coherent(ddev,
-                                                 2 * MLX5_ADAPTER_PAGE_SIZE - 1,
-                                                 &cmd->alloc_dma, GFP_KERNEL);
+        cmd->cmd_alloc_buf = dma_alloc_coherent(ddev,
+                                                2 * MLX5_ADAPTER_PAGE_SIZE - 1,
+                                                &cmd->alloc_dma, GFP_KERNEL);
         if (!cmd->cmd_alloc_buf)
                 return -ENOMEM;
 
diff --git a/drivers/net/ethernet/mellanox/mlx5/core/en_ethtool.c b/drivers/net/ethernet/mellanox/mlx5/core/en_ethtool.c
index c9df08133718..3bbccead2f63 100644
--- a/drivers/net/ethernet/mellanox/mlx5/core/en_ethtool.c
+++ b/drivers/net/ethernet/mellanox/mlx5/core/en_ethtool.c
@@ -844,9 +844,12 @@ int mlx5e_ethtool_get_link_ksettings(struct mlx5e_priv *priv,
         ethtool_link_ksettings_add_link_mode(link_ksettings, supported,
                                              Autoneg);
 
-        if (get_fec_supported_advertised(mdev, link_ksettings))
+        err = get_fec_supported_advertised(mdev, link_ksettings);
+        if (err) {
                 netdev_dbg(priv->netdev, "%s: FEC caps query failed: %d\n",
                            __func__, err);
+                err = 0; /* don't fail caps query because of FEC error */
+        }
 
         if (!an_disable_admin)
                 ethtool_link_ksettings_add_link_mode(link_ksettings,
diff --git a/drivers/net/ethernet/mellanox/mlx5/core/en_rep.c b/drivers/net/ethernet/mellanox/mlx5/core/en_rep.c
index 96cc0c6a4014..04736212a21c 100644
--- a/drivers/net/ethernet/mellanox/mlx5/core/en_rep.c
+++ b/drivers/net/ethernet/mellanox/mlx5/core/en_rep.c
@@ -58,7 +58,8 @@ struct mlx5e_rep_indr_block_priv {
         struct list_head list;
 };
 
-static void mlx5e_rep_indr_unregister_block(struct net_device *netdev);
+static void mlx5e_rep_indr_unregister_block(struct mlx5e_rep_priv *rpriv,
+                                            struct net_device *netdev);
 
 static void mlx5e_rep_get_drvinfo(struct net_device *dev,
                                   struct ethtool_drvinfo *drvinfo)
@@ -179,6 +180,7 @@ static void mlx5e_rep_update_sw_counters(struct mlx5e_priv *priv)
 
                         s->tx_packets           += sq_stats->packets;
                         s->tx_bytes             += sq_stats->bytes;
+                        s->tx_queue_dropped     += sq_stats->dropped;
                 }
         }
 }
@@ -663,7 +665,7 @@ static void mlx5e_rep_indr_clean_block_privs(struct mlx5e_rep_priv *rpriv)
         struct list_head *head = &rpriv->uplink_priv.tc_indr_block_priv_list;
 
         list_for_each_entry_safe(cb_priv, temp, head, list) {
-                mlx5e_rep_indr_unregister_block(cb_priv->netdev);
+                mlx5e_rep_indr_unregister_block(rpriv, cb_priv->netdev);
                 kfree(cb_priv);
         }
 }
@@ -735,7 +737,7 @@ mlx5e_rep_indr_setup_tc_block(struct net_device *netdev,
 
                 err = tcf_block_cb_register(f->block,
                                             mlx5e_rep_indr_setup_block_cb,
-                                            netdev, indr_priv, f->extack);
+                                            indr_priv, indr_priv, f->extack);
                 if (err) {
                         list_del(&indr_priv->list);
                         kfree(indr_priv);
@@ -743,14 +745,15 @@ mlx5e_rep_indr_setup_tc_block(struct net_device *netdev,
 
                 return err;
         case TC_BLOCK_UNBIND:
+                indr_priv = mlx5e_rep_indr_block_priv_lookup(rpriv, netdev);
+                if (!indr_priv)
+                        return -ENOENT;
+
                 tcf_block_cb_unregister(f->block,
                                         mlx5e_rep_indr_setup_block_cb,
-                                        netdev);
-                indr_priv = mlx5e_rep_indr_block_priv_lookup(rpriv, netdev);
-                if (indr_priv) {
-                        list_del(&indr_priv->list);
-                        kfree(indr_priv);
-                }
+                                        indr_priv);
+                list_del(&indr_priv->list);
+                kfree(indr_priv);
 
                 return 0;
         default:
@@ -779,7 +782,7 @@ static int mlx5e_rep_indr_register_block(struct mlx5e_rep_priv *rpriv,
 
         err = __tc_indr_block_cb_register(netdev, rpriv,
                                           mlx5e_rep_indr_setup_tc_cb,
-                                          netdev);
+                                          rpriv);
         if (err) {
                 struct mlx5e_priv *priv = netdev_priv(rpriv->netdev);
 
@@ -789,10 +792,11 @@ static int mlx5e_rep_indr_register_block(struct mlx5e_rep_priv *rpriv,
         return err;
 }
 
-static void mlx5e_rep_indr_unregister_block(struct net_device *netdev)
+static void mlx5e_rep_indr_unregister_block(struct mlx5e_rep_priv *rpriv,
+                                            struct net_device *netdev)
 {
         __tc_indr_block_cb_unregister(netdev, mlx5e_rep_indr_setup_tc_cb,
-                                      netdev);
+                                      rpriv);
 }
 
 static int mlx5e_nic_rep_netdevice_event(struct notifier_block *nb,
@@ -811,7 +815,7 @@ static int mlx5e_nic_rep_netdevice_event(struct notifier_block *nb,
                 mlx5e_rep_indr_register_block(rpriv, netdev);
                 break;
         case NETDEV_UNREGISTER:
-                mlx5e_rep_indr_unregister_block(netdev);
+                mlx5e_rep_indr_unregister_block(rpriv, netdev);
                 break;
         }
         return NOTIFY_OK;
diff --git a/drivers/net/ethernet/mellanox/mlx5/core/en_rx.c b/drivers/net/ethernet/mellanox/mlx5/core/en_rx.c
index 1d0bb5ff8c26..f86e4804e83e 100644
--- a/drivers/net/ethernet/mellanox/mlx5/core/en_rx.c
+++ b/drivers/net/ethernet/mellanox/mlx5/core/en_rx.c
@@ -732,6 +732,8 @@ static u8 get_ip_proto(struct sk_buff *skb, int network_depth, __be16 proto)
                                             ((struct ipv6hdr *)ip_p)->nexthdr;
 }
 
+#define short_frame(size) ((size) <= ETH_ZLEN + ETH_FCS_LEN)
+
 static inline void mlx5e_handle_csum(struct net_device *netdev,
                                      struct mlx5_cqe64 *cqe,
                                      struct mlx5e_rq *rq,
@@ -754,6 +756,17 @@ static inline void mlx5e_handle_csum(struct net_device *netdev,
         if (unlikely(test_bit(MLX5E_RQ_STATE_NO_CSUM_COMPLETE, &rq->state)))
                 goto csum_unnecessary;
 
+        /* CQE csum doesn't cover padding octets in short ethernet
+         * frames. And the pad field is appended prior to calculating
+         * and appending the FCS field.
+         *
+         * Detecting these padded frames requires to verify and parse
+         * IP headers, so we simply force all those small frames to be
+         * CHECKSUM_UNNECESSARY even if they are not padded.
+         */
+        if (short_frame(skb->len))
+                goto csum_unnecessary;
+
         if (likely(is_last_ethertype_ip(skb, &network_depth, &proto))) {
                 if (unlikely(get_ip_proto(skb, network_depth, proto) == IPPROTO_SCTP))
                         goto csum_unnecessary;
diff --git a/drivers/net/ethernet/mellanox/mlxsw/Kconfig b/drivers/net/ethernet/mellanox/mlxsw/Kconfig
index 080ddd1942ec..b9a25aed5d11 100644
--- a/drivers/net/ethernet/mellanox/mlxsw/Kconfig
+++ b/drivers/net/ethernet/mellanox/mlxsw/Kconfig
@@ -78,6 +78,7 @@ config MLXSW_SPECTRUM
         depends on IPV6 || IPV6=n
         depends on NET_IPGRE || NET_IPGRE=n
         depends on IPV6_GRE || IPV6_GRE=n
+        depends on VXLAN || VXLAN=n
         select GENERIC_ALLOCATOR
         select PARMAN
         select OBJAGG
diff --git a/drivers/net/ethernet/mellanox/mlxsw/pci.c b/drivers/net/ethernet/mellanox/mlxsw/pci.c
index 66b8098c6fd2..a2321fe8d6a0 100644
--- a/drivers/net/ethernet/mellanox/mlxsw/pci.c
+++ b/drivers/net/ethernet/mellanox/mlxsw/pci.c
@@ -604,29 +604,31 @@ static void mlxsw_pci_cq_tasklet(unsigned long data)
                 u16 wqe_counter = mlxsw_pci_cqe_wqe_counter_get(cqe);
                 u8 sendq = mlxsw_pci_cqe_sr_get(q->u.cq.v, cqe);
                 u8 dqn = mlxsw_pci_cqe_dqn_get(q->u.cq.v, cqe);
+                char ncqe[MLXSW_PCI_CQE_SIZE_MAX];
+
+                memcpy(ncqe, cqe, q->elem_size);
+                mlxsw_pci_queue_doorbell_consumer_ring(mlxsw_pci, q);
 
                 if (sendq) {
                         struct mlxsw_pci_queue *sdq;
 
                         sdq = mlxsw_pci_sdq_get(mlxsw_pci, dqn);
                         mlxsw_pci_cqe_sdq_handle(mlxsw_pci, sdq,
-                                                 wqe_counter, cqe);
+                                                 wqe_counter, ncqe);
                         q->u.cq.comp_sdq_count++;
                 } else {
                         struct mlxsw_pci_queue *rdq;
 
                         rdq = mlxsw_pci_rdq_get(mlxsw_pci, dqn);
                         mlxsw_pci_cqe_rdq_handle(mlxsw_pci, rdq,
-                                                 wqe_counter, q->u.cq.v, cqe);
+                                                 wqe_counter, q->u.cq.v, ncqe);
                         q->u.cq.comp_rdq_count++;
                 }
                 if (++items == credits)
                         break;
         }
-        if (items) {
-                mlxsw_pci_queue_doorbell_consumer_ring(mlxsw_pci, q);
+        if (items)
                 mlxsw_pci_queue_doorbell_arm_consumer_ring(mlxsw_pci, q);
-        }
 }
 
 static u16 mlxsw_pci_cq_elem_count(const struct mlxsw_pci_queue *q)
@@ -1365,10 +1367,10 @@ static int mlxsw_pci_sw_reset(struct mlxsw_pci *mlxsw_pci,
                 u32 val = mlxsw_pci_read32(mlxsw_pci, FW_READY);
 
                 if ((val & MLXSW_PCI_FW_READY_MASK) == MLXSW_PCI_FW_READY_MAGIC)
-                        break;
+                        return 0;
                 cond_resched();
         } while (time_before(jiffies, end));
-        return 0;
+        return -EBUSY;
 }
 
 static int mlxsw_pci_alloc_irq_vectors(struct mlxsw_pci *mlxsw_pci)
diff --git a/drivers/net/ethernet/mellanox/mlxsw/pci_hw.h b/drivers/net/ethernet/mellanox/mlxsw/pci_hw.h
index bb99f6d41fe0..ffee38e36ce8 100644
--- a/drivers/net/ethernet/mellanox/mlxsw/pci_hw.h
+++ b/drivers/net/ethernet/mellanox/mlxsw/pci_hw.h
@@ -27,7 +27,7 @@
 
 #define MLXSW_PCI_SW_RESET                      0xF0010
 #define MLXSW_PCI_SW_RESET_RST_BIT              BIT(0)
-#define MLXSW_PCI_SW_RESET_TIMEOUT_MSECS        5000
+#define MLXSW_PCI_SW_RESET_TIMEOUT_MSECS        13000
 #define MLXSW_PCI_SW_RESET_WAIT_MSECS           100
 #define MLXSW_PCI_FW_READY                      0xA1844
 #define MLXSW_PCI_FW_READY_MASK                 0xFFFF
@@ -53,6 +53,7 @@
 #define MLXSW_PCI_WQE_SIZE      32 /* 32 bytes per element */
 #define MLXSW_PCI_CQE01_SIZE    16 /* 16 bytes per element */
 #define MLXSW_PCI_CQE2_SIZE     32 /* 32 bytes per element */
+#define MLXSW_PCI_CQE_SIZE_MAX  MLXSW_PCI_CQE2_SIZE
 #define MLXSW_PCI_EQE_SIZE      16 /* 16 bytes per element */
 #define MLXSW_PCI_WQE_COUNT     (MLXSW_PCI_AQ_SIZE / MLXSW_PCI_WQE_SIZE)
 #define MLXSW_PCI_CQE01_COUNT   (MLXSW_PCI_AQ_SIZE / MLXSW_PCI_CQE01_SIZE)
diff --git a/drivers/net/ethernet/mellanox/mlxsw/spectrum.c b/drivers/net/ethernet/mellanox/mlxsw/spectrum.c
index eed1045e4d96..32519c93df17 100644
--- a/drivers/net/ethernet/mellanox/mlxsw/spectrum.c
+++ b/drivers/net/ethernet/mellanox/mlxsw/spectrum.c
@@ -5005,12 +5005,15 @@ static int mlxsw_sp_netdevice_port_upper_event(struct net_device *lower_dev,
                                                            lower_dev,
                                                            upper_dev);
                 } else if (netif_is_lag_master(upper_dev)) {
-                        if (info->linking)
+                        if (info->linking) {
                                 err = mlxsw_sp_port_lag_join(mlxsw_sp_port,
                                                              upper_dev);
-                        else
+                        } else {
+                                mlxsw_sp_port_lag_tx_en_set(mlxsw_sp_port,
+                                                            false);
                                 mlxsw_sp_port_lag_leave(mlxsw_sp_port,
                                                         upper_dev);
+                        }
                 } else if (netif_is_ovs_master(upper_dev)) {
                         if (info->linking)
                                 err = mlxsw_sp_port_ovs_join(mlxsw_sp_port);
diff --git a/drivers/net/ethernet/mellanox/mlxsw/spectrum_acl_ctcam.c b/drivers/net/ethernet/mellanox/mlxsw/spectrum_acl_ctcam.c
index b0f2d8e8ded0..ac222833a5cf 100644
--- a/drivers/net/ethernet/mellanox/mlxsw/spectrum_acl_ctcam.c
+++ b/drivers/net/ethernet/mellanox/mlxsw/spectrum_acl_ctcam.c
@@ -72,7 +72,15 @@ mlxsw_sp_acl_ctcam_region_entry_insert(struct mlxsw_sp *mlxsw_sp,
         act_set = mlxsw_afa_block_first_set(rulei->act_block);
         mlxsw_reg_ptce2_flex_action_set_memcpy_to(ptce2_pl, act_set);
 
-        return mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ptce2), ptce2_pl);
+        err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(ptce2), ptce2_pl);
+        if (err)
+                goto err_ptce2_write;
+
+        return 0;
+
+err_ptce2_write:
+        cregion->ops->entry_remove(cregion, centry);
+        return err;
 }
 
 static void
diff --git a/drivers/net/ethernet/mellanox/mlxsw/spectrum_acl_erp.c b/drivers/net/ethernet/mellanox/mlxsw/spectrum_acl_erp.c
index 1c19feefa5f2..2941967e1cc5 100644
--- a/drivers/net/ethernet/mellanox/mlxsw/spectrum_acl_erp.c
+++ b/drivers/net/ethernet/mellanox/mlxsw/spectrum_acl_erp.c
@@ -1022,7 +1022,6 @@ void mlxsw_sp_acl_erp_mask_put(struct mlxsw_sp_acl_atcam_region *aregion,
 {
         struct objagg_obj *objagg_obj = (struct objagg_obj *) erp_mask;
 
-        ASSERT_RTNL();
         objagg_obj_put(aregion->erp_table->objagg, objagg_obj);
 }
 
@@ -1054,7 +1053,6 @@ void mlxsw_sp_acl_erp_bf_remove(struct mlxsw_sp *mlxsw_sp,
         const struct mlxsw_sp_acl_erp *erp = objagg_obj_root_priv(objagg_obj);
         unsigned int erp_bank;
 
-        ASSERT_RTNL();
         if (!mlxsw_sp_acl_erp_table_is_used(erp->erp_table))
                 return;
 
diff --git a/drivers/net/ethernet/mellanox/mlxsw/spectrum_fid.c b/drivers/net/ethernet/mellanox/mlxsw/spectrum_fid.c
index 055cc6943b34..9d9aa28684af 100644
--- a/drivers/net/ethernet/mellanox/mlxsw/spectrum_fid.c
+++ b/drivers/net/ethernet/mellanox/mlxsw/spectrum_fid.c
@@ -997,8 +997,8 @@ static const struct mlxsw_sp_fid_ops mlxsw_sp_fid_dummy_ops = {
 static const struct mlxsw_sp_fid_family mlxsw_sp_fid_dummy_family = {
         .type                   = MLXSW_SP_FID_TYPE_DUMMY,
         .fid_size               = sizeof(struct mlxsw_sp_fid),
-        .start_index            = MLXSW_SP_RFID_BASE - 1,
-        .end_index              = MLXSW_SP_RFID_BASE - 1,
+        .start_index            = VLAN_N_VID - 1,
+        .end_index              = VLAN_N_VID - 1,
         .ops                    = &mlxsw_sp_fid_dummy_ops,
 };
 
diff --git a/drivers/net/ethernet/mellanox/mlxsw/spectrum_nve.c b/drivers/net/ethernet/mellanox/mlxsw/spectrum_nve.c
index 0a31fff2516e..fb1c48c698f2 100644
--- a/drivers/net/ethernet/mellanox/mlxsw/spectrum_nve.c
+++ b/drivers/net/ethernet/mellanox/mlxsw/spectrum_nve.c
@@ -816,14 +816,14 @@ int mlxsw_sp_nve_fid_enable(struct mlxsw_sp *mlxsw_sp, struct mlxsw_sp_fid *fid,
         ops = nve->nve_ops_arr[params->type];
 
         if (!ops->can_offload(nve, params->dev, extack))
-                return -EOPNOTSUPP;
+                return -EINVAL;
 
         memset(&config, 0, sizeof(config));
         ops->nve_config(nve, params->dev, &config);
         if (nve->num_nve_tunnels &&
             memcmp(&config, &nve->config, sizeof(config))) {
                 NL_SET_ERR_MSG_MOD(extack, "Conflicting NVE tunnels configuration");
-                return -EOPNOTSUPP;
+                return -EINVAL;
         }
 
         err = mlxsw_sp_nve_tunnel_init(mlxsw_sp, &config);
diff --git a/drivers/net/ethernet/mellanox/mlxsw/spectrum_switchdev.c b/drivers/net/ethernet/mellanox/mlxsw/spectrum_switchdev.c
index 1bd2c6e15f8d..c772109b638d 100644
--- a/drivers/net/ethernet/mellanox/mlxsw/spectrum_switchdev.c
+++ b/drivers/net/ethernet/mellanox/mlxsw/spectrum_switchdev.c
@@ -1078,8 +1078,7 @@ static int
 mlxsw_sp_bridge_port_vlan_add(struct mlxsw_sp_port *mlxsw_sp_port,
                               struct mlxsw_sp_bridge_port *bridge_port,
                               u16 vid, bool is_untagged, bool is_pvid,
-                              struct netlink_ext_ack *extack,
-                              struct switchdev_trans *trans)
+                              struct netlink_ext_ack *extack)
 {
         u16 pvid = mlxsw_sp_port_pvid_determine(mlxsw_sp_port, vid, is_pvid);
         struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
@@ -1095,9 +1094,6 @@ mlxsw_sp_bridge_port_vlan_add(struct mlxsw_sp_port *mlxsw_sp_port,
             mlxsw_sp_port_vlan->bridge_port != bridge_port)
                 return -EEXIST;
 
-        if (switchdev_trans_ph_prepare(trans))
-                return 0;
-
         if (!mlxsw_sp_port_vlan) {
                 mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_create(mlxsw_sp_port,
                                                                vid);
@@ -1188,6 +1184,9 @@ static int mlxsw_sp_port_vlans_add(struct mlxsw_sp_port *mlxsw_sp_port,
                 return err;
         }
 
+        if (switchdev_trans_ph_commit(trans))
+                return 0;
+
         bridge_port = mlxsw_sp_bridge_port_find(mlxsw_sp->bridge, orig_dev);
         if (WARN_ON(!bridge_port))
                 return -EINVAL;
@@ -1200,7 +1199,7 @@ static int mlxsw_sp_port_vlans_add(struct mlxsw_sp_port *mlxsw_sp_port,
 
                 err = mlxsw_sp_bridge_port_vlan_add(mlxsw_sp_port, bridge_port,
                                                     vid, flag_untagged,
-                                                    flag_pvid, extack, trans);
+                                                    flag_pvid, extack);
                 if (err)
                         return err;
         }
@@ -1234,7 +1233,7 @@ mlxsw_sp_bridge_port_fdb_flush(struct mlxsw_sp *mlxsw_sp,
 static enum mlxsw_reg_sfd_rec_policy mlxsw_sp_sfd_rec_policy(bool dynamic)
 {
         return dynamic ? MLXSW_REG_SFD_REC_POLICY_DYNAMIC_ENTRY_INGRESS :
-                         MLXSW_REG_SFD_REC_POLICY_STATIC_ENTRY;
+                         MLXSW_REG_SFD_REC_POLICY_DYNAMIC_ENTRY_MLAG;
 }
 
 static enum mlxsw_reg_sfd_op mlxsw_sp_sfd_op(bool adding)
@@ -1291,7 +1290,7 @@ out:
 static int __mlxsw_sp_port_fdb_uc_op(struct mlxsw_sp *mlxsw_sp, u8 local_port,
                                      const char *mac, u16 fid, bool adding,
                                      enum mlxsw_reg_sfd_rec_action action,
-                                     bool dynamic)
+                                     enum mlxsw_reg_sfd_rec_policy policy)
 {
         char *sfd_pl;
         u8 num_rec;
@@ -1302,8 +1301,7 @@ static int __mlxsw_sp_port_fdb_uc_op(struct mlxsw_sp *mlxsw_sp, u8 local_port,
                 return -ENOMEM;
 
         mlxsw_reg_sfd_pack(sfd_pl, mlxsw_sp_sfd_op(adding), 0);
-        mlxsw_reg_sfd_uc_pack(sfd_pl, 0, mlxsw_sp_sfd_rec_policy(dynamic),
-                              mac, fid, action, local_port);
+        mlxsw_reg_sfd_uc_pack(sfd_pl, 0, policy, mac, fid, action, local_port);
         num_rec = mlxsw_reg_sfd_num_rec_get(sfd_pl);
         err = mlxsw_reg_write(mlxsw_sp->core, MLXSW_REG(sfd), sfd_pl);
         if (err)
@@ -1322,7 +1320,8 @@ static int mlxsw_sp_port_fdb_uc_op(struct mlxsw_sp *mlxsw_sp, u8 local_port,
                                    bool dynamic)
 {
         return __mlxsw_sp_port_fdb_uc_op(mlxsw_sp, local_port, mac, fid, adding,
-                                         MLXSW_REG_SFD_REC_ACTION_NOP, dynamic);
+                                         MLXSW_REG_SFD_REC_ACTION_NOP,
+                                         mlxsw_sp_sfd_rec_policy(dynamic));
 }
 
 int mlxsw_sp_rif_fdb_op(struct mlxsw_sp *mlxsw_sp, const char *mac, u16 fid,
@@ -1330,7 +1329,7 @@ int mlxsw_sp_rif_fdb_op(struct mlxsw_sp *mlxsw_sp, const char *mac, u16 fid,
 {
         return __mlxsw_sp_port_fdb_uc_op(mlxsw_sp, 0, mac, fid, adding,
                                          MLXSW_REG_SFD_REC_ACTION_FORWARD_IP_ROUTER,
-                                         false);
+                                         MLXSW_REG_SFD_REC_POLICY_STATIC_ENTRY);
 }
 
 static int mlxsw_sp_port_fdb_uc_lag_op(struct mlxsw_sp *mlxsw_sp, u16 lag_id,
@@ -1808,7 +1807,7 @@ static void
 mlxsw_sp_bridge_port_vlan_del(struct mlxsw_sp_port *mlxsw_sp_port,
                               struct mlxsw_sp_bridge_port *bridge_port, u16 vid)
 {
-        u16 pvid = mlxsw_sp_port->pvid == vid ? 0 : vid;
+        u16 pvid = mlxsw_sp_port->pvid == vid ? 0 : mlxsw_sp_port->pvid;
         struct mlxsw_sp_port_vlan *mlxsw_sp_port_vlan;
 
         mlxsw_sp_port_vlan = mlxsw_sp_port_vlan_find_by_vid(mlxsw_sp_port, vid);
@@ -3207,7 +3206,6 @@ mlxsw_sp_switchdev_vxlan_vlan_add(struct mlxsw_sp *mlxsw_sp,
                                   struct mlxsw_sp_bridge_device *bridge_device,
                                   const struct net_device *vxlan_dev, u16 vid,
                                   bool flag_untagged, bool flag_pvid,
-                                  struct switchdev_trans *trans,
                                   struct netlink_ext_ack *extack)
 {
         struct vxlan_dev *vxlan = netdev_priv(vxlan_dev);
@@ -3225,9 +3223,6 @@ mlxsw_sp_switchdev_vxlan_vlan_add(struct mlxsw_sp *mlxsw_sp,
             mlxsw_sp_bridge_8021q_vxlan_dev_find(bridge_device->dev, vid))
                 return -EINVAL;
 
-        if (switchdev_trans_ph_prepare(trans))
-                return 0;
-
         if (!netif_running(vxlan_dev))
                 return 0;
 
@@ -3345,6 +3340,9 @@ mlxsw_sp_switchdev_vxlan_vlans_add(struct net_device *vxlan_dev,
 
         port_obj_info->handled = true;
 
+        if (switchdev_trans_ph_commit(trans))
+                return 0;
+
         bridge_device = mlxsw_sp_bridge_device_find(mlxsw_sp->bridge, br_dev);
         if (!bridge_device)
                 return -EINVAL;
@@ -3358,8 +3356,7 @@ mlxsw_sp_switchdev_vxlan_vlans_add(struct net_device *vxlan_dev,
                 err = mlxsw_sp_switchdev_vxlan_vlan_add(mlxsw_sp, bridge_device,
                                                         vxlan_dev, vid,
                                                         flag_untagged,
-                                                        flag_pvid, trans,
-                                                        extack);
+                                                        flag_pvid, extack);
                 if (err)
                         return err;
         }
diff --git a/drivers/net/ethernet/microchip/lan743x_main.c b/drivers/net/ethernet/microchip/lan743x_main.c
index 20c9377e99cb..310807ef328b 100644
--- a/drivers/net/ethernet/microchip/lan743x_main.c
+++ b/drivers/net/ethernet/microchip/lan743x_main.c
@@ -962,13 +962,10 @@ static void lan743x_phy_link_status_change(struct net_device *netdev)
 
                 memset(&ksettings, 0, sizeof(ksettings));
                 phy_ethtool_get_link_ksettings(netdev, &ksettings);
-                local_advertisement = phy_read(phydev, MII_ADVERTISE);
-                if (local_advertisement < 0)
-                        return;
-
-                remote_advertisement = phy_read(phydev, MII_LPA);
-                if (remote_advertisement < 0)
-                        return;
+                local_advertisement =
+                        linkmode_adv_to_mii_adv_t(phydev->advertising);
+                remote_advertisement =
+                        linkmode_adv_to_mii_adv_t(phydev->lp_advertising);
 
                 lan743x_phy_update_flowcontrol(adapter,
                                                ksettings.base.duplex,
diff --git a/drivers/net/ethernet/myricom/myri10ge/myri10ge.c b/drivers/net/ethernet/myricom/myri10ge/myri10ge.c
index 5f384f73007d..19ce0e605096 100644
--- a/drivers/net/ethernet/myricom/myri10ge/myri10ge.c
+++ b/drivers/net/ethernet/myricom/myri10ge/myri10ge.c
@@ -3604,9 +3604,9 @@ static int myri10ge_alloc_slices(struct myri10ge_priv *mgp)
         for (i = 0; i < mgp->num_slices; i++) {
                 ss = &mgp->ss[i];
                 bytes = mgp->max_intr_slots * sizeof(*ss->rx_done.entry);
-                ss->rx_done.entry = dma_zalloc_coherent(&pdev->dev, bytes,
-                                                        &ss->rx_done.bus,
-                                                        GFP_KERNEL);
+                ss->rx_done.entry = dma_alloc_coherent(&pdev->dev, bytes,
+                                                       &ss->rx_done.bus,
+                                                       GFP_KERNEL);
                 if (ss->rx_done.entry == NULL)
                         goto abort;
                 bytes = sizeof(*ss->fw_stats);
diff --git a/drivers/net/ethernet/netronome/nfp/nfp_net_common.c b/drivers/net/ethernet/netronome/nfp/nfp_net_common.c
index e97636d2e6ee..7d2d4241498f 100644
--- a/drivers/net/ethernet/netronome/nfp/nfp_net_common.c
+++ b/drivers/net/ethernet/netronome/nfp/nfp_net_common.c
@@ -2170,9 +2170,9 @@ nfp_net_tx_ring_alloc(struct nfp_net_dp *dp, struct nfp_net_tx_ring *tx_ring)
         tx_ring->cnt = dp->txd_cnt;
 
         tx_ring->size = array_size(tx_ring->cnt, sizeof(*tx_ring->txds));
-        tx_ring->txds = dma_zalloc_coherent(dp->dev, tx_ring->size,
-                                            &tx_ring->dma,
-                                            GFP_KERNEL | __GFP_NOWARN);
+        tx_ring->txds = dma_alloc_coherent(dp->dev, tx_ring->size,
+                                           &tx_ring->dma,
+                                           GFP_KERNEL | __GFP_NOWARN);
         if (!tx_ring->txds) {
                 netdev_warn(dp->netdev, "failed to allocate TX descriptor ring memory, requested descriptor count: %d, consider lowering descriptor count\n",
                             tx_ring->cnt);
@@ -2328,9 +2328,9 @@ nfp_net_rx_ring_alloc(struct nfp_net_dp *dp, struct nfp_net_rx_ring *rx_ring)
 
         rx_ring->cnt = dp->rxd_cnt;
         rx_ring->size = array_size(rx_ring->cnt, sizeof(*rx_ring->rxds));
-        rx_ring->rxds = dma_zalloc_coherent(dp->dev, rx_ring->size,
-                                            &rx_ring->dma,
-                                            GFP_KERNEL | __GFP_NOWARN);
+        rx_ring->rxds = dma_alloc_coherent(dp->dev, rx_ring->size,
+                                           &rx_ring->dma,
+                                           GFP_KERNEL | __GFP_NOWARN);
         if (!rx_ring->rxds) {
                 netdev_warn(dp->netdev, "failed to allocate RX descriptor ring memory, requested descriptor count: %d, consider lowering descriptor count\n",
                             rx_ring->cnt);
diff --git a/drivers/net/ethernet/ni/nixge.c b/drivers/net/ethernet/ni/nixge.c
index 0611f2335b4a..1e408d1a9b5f 100644
--- a/drivers/net/ethernet/ni/nixge.c
+++ b/drivers/net/ethernet/ni/nixge.c
@@ -287,9 +287,9 @@ static int nixge_hw_dma_bd_init(struct net_device *ndev)
         priv->rx_bd_ci = 0;
 
         /* Allocate the Tx and Rx buffer descriptors. */
-        priv->tx_bd_v = dma_zalloc_coherent(ndev->dev.parent,
-                                            sizeof(*priv->tx_bd_v) * TX_BD_NUM,
-                                            &priv->tx_bd_p, GFP_KERNEL);
+        priv->tx_bd_v = dma_alloc_coherent(ndev->dev.parent,
+                                           sizeof(*priv->tx_bd_v) * TX_BD_NUM,
+                                           &priv->tx_bd_p, GFP_KERNEL);
         if (!priv->tx_bd_v)
                 goto out;
 
@@ -299,9 +299,9 @@ static int nixge_hw_dma_bd_init(struct net_device *ndev)
         if (!priv->tx_skb)
                 goto out;
 
-        priv->rx_bd_v = dma_zalloc_coherent(ndev->dev.parent,
-                                            sizeof(*priv->rx_bd_v) * RX_BD_NUM,
-                                            &priv->rx_bd_p, GFP_KERNEL);
+        priv->rx_bd_v = dma_alloc_coherent(ndev->dev.parent,
+                                           sizeof(*priv->rx_bd_v) * RX_BD_NUM,
+                                           &priv->rx_bd_p, GFP_KERNEL);
         if (!priv->rx_bd_v)
                 goto out;
 
diff --git a/drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c b/drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c
index 43c0c10dfeb7..552d930e3940 100644
--- a/drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c
+++ b/drivers/net/ethernet/oki-semi/pch_gbe/pch_gbe_main.c
@@ -1440,8 +1440,8 @@ pch_gbe_alloc_rx_buffers_pool(struct pch_gbe_adapter *adapter,
 
         size = rx_ring->count * bufsz + PCH_GBE_RESERVE_MEMORY;
         rx_ring->rx_buff_pool =
-                dma_zalloc_coherent(&pdev->dev, size,
-                                    &rx_ring->rx_buff_pool_logic, GFP_KERNEL);
+                dma_alloc_coherent(&pdev->dev, size,
+                                   &rx_ring->rx_buff_pool_logic, GFP_KERNEL);
         if (!rx_ring->rx_buff_pool)
                 return -ENOMEM;
 
@@ -1755,8 +1755,8 @@ int pch_gbe_setup_tx_resources(struct pch_gbe_adapter *adapter,
 
         tx_ring->size = tx_ring->count * (int)sizeof(struct pch_gbe_tx_desc);
 
-        tx_ring->desc = dma_zalloc_coherent(&pdev->dev, tx_ring->size,
-                                            &tx_ring->dma, GFP_KERNEL);
+        tx_ring->desc = dma_alloc_coherent(&pdev->dev, tx_ring->size,
+                                           &tx_ring->dma, GFP_KERNEL);
         if (!tx_ring->desc) {
                 vfree(tx_ring->buffer_info);
                 return -ENOMEM;
@@ -1798,8 +1798,8 @@ int pch_gbe_setup_rx_resources(struct pch_gbe_adapter *adapter,
                 return -ENOMEM;
 
         rx_ring->size = rx_ring->count * (int)sizeof(struct pch_gbe_rx_desc);
-        rx_ring->desc = dma_zalloc_coherent(&pdev->dev, rx_ring->size,
-                                            &rx_ring->dma, GFP_KERNEL);
+        rx_ring->desc = dma_alloc_coherent(&pdev->dev, rx_ring->size,
+                                                  &rx_ring->dma, GFP_KERNEL);
         if (!rx_ring->desc) {
                 vfree(rx_ring->buffer_info);
                 return -ENOMEM;
diff --git a/drivers/net/ethernet/pasemi/pasemi_mac.c b/drivers/net/ethernet/pasemi/pasemi_mac.c
index 8a31a02c9f47..d21041554507 100644
--- a/drivers/net/ethernet/pasemi/pasemi_mac.c
+++ b/drivers/net/ethernet/pasemi/pasemi_mac.c
@@ -401,9 +401,9 @@ static int pasemi_mac_setup_rx_resources(const struct net_device *dev)
         if (pasemi_dma_alloc_ring(&ring->chan, RX_RING_SIZE))
                 goto out_ring_desc;
 
-        ring->buffers = dma_zalloc_coherent(&mac->dma_pdev->dev,
-                                            RX_RING_SIZE * sizeof(u64),
-                                            &ring->buf_dma, GFP_KERNEL);
+        ring->buffers = dma_alloc_coherent(&mac->dma_pdev->dev,
+                                           RX_RING_SIZE * sizeof(u64),
+                                           &ring->buf_dma, GFP_KERNEL);
         if (!ring->buffers)
                 goto out_ring_desc;
 
diff --git a/drivers/net/ethernet/qlogic/qed/qed_cxt.c b/drivers/net/ethernet/qlogic/qed/qed_cxt.c
index dc1c1b616084..c2ad405b2f50 100644
--- a/drivers/net/ethernet/qlogic/qed/qed_cxt.c
+++ b/drivers/net/ethernet/qlogic/qed/qed_cxt.c
@@ -936,9 +936,9 @@ static int qed_cxt_src_t2_alloc(struct qed_hwfn *p_hwfn)
                 u32 size = min_t(u32, total_size, psz);
                 void **p_virt = &p_mngr->t2[i].p_virt;
 
-                *p_virt = dma_zalloc_coherent(&p_hwfn->cdev->pdev->dev,
-                                              size, &p_mngr->t2[i].p_phys,
-                                              GFP_KERNEL);
+                *p_virt = dma_alloc_coherent(&p_hwfn->cdev->pdev->dev, size,
+                                             &p_mngr->t2[i].p_phys,
+                                             GFP_KERNEL);
                 if (!p_mngr->t2[i].p_virt) {
                         rc = -ENOMEM;
                         goto t2_fail;
@@ -1054,8 +1054,8 @@ static int qed_ilt_blk_alloc(struct qed_hwfn *p_hwfn,
                 u32 size;
 
                 size = min_t(u32, sz_left, p_blk->real_size_in_page);
-                p_virt = dma_zalloc_coherent(&p_hwfn->cdev->pdev->dev, size,
-                                             &p_phys, GFP_KERNEL);
+                p_virt = dma_alloc_coherent(&p_hwfn->cdev->pdev->dev, size,
+                                            &p_phys, GFP_KERNEL);
                 if (!p_virt)
                         return -ENOMEM;
 
@@ -2306,9 +2306,9 @@ qed_cxt_dynamic_ilt_alloc(struct qed_hwfn *p_hwfn,
                 goto out0;
         }
 
-        p_virt = dma_zalloc_coherent(&p_hwfn->cdev->pdev->dev,
-                                     p_blk->real_size_in_page, &p_phys,
-                                     GFP_KERNEL);
+        p_virt = dma_alloc_coherent(&p_hwfn->cdev->pdev->dev,
+                                    p_blk->real_size_in_page, &p_phys,
+                                    GFP_KERNEL);
         if (!p_virt) {
                 rc = -ENOMEM;
                 goto out1;
diff --git a/drivers/net/ethernet/qlogic/qed/qed_ll2.c b/drivers/net/ethernet/qlogic/qed/qed_ll2.c
index 90afd514ffe1..d9237c65a838 100644
--- a/drivers/net/ethernet/qlogic/qed/qed_ll2.c
+++ b/drivers/net/ethernet/qlogic/qed/qed_ll2.c
@@ -1619,6 +1619,10 @@ static void qed_ll2_post_rx_buffer_notify_fw(struct qed_hwfn *p_hwfn,
         cq_prod = qed_chain_get_prod_idx(&p_rx->rcq_chain);
         rx_prod.bd_prod = cpu_to_le16(bd_prod);
         rx_prod.cqe_prod = cpu_to_le16(cq_prod);
+
+        /* Make sure chain element is updated before ringing the doorbell */
+        dma_wmb();
+
         DIRECT_REG_WR(p_rx->set_prod_addr, *((u32 *)&rx_prod));
 }
 
diff --git a/drivers/net/ethernet/qlogic/qlcnic/qlcnic_ctx.c b/drivers/net/ethernet/qlogic/qlcnic/qlcnic_ctx.c
index d344e9d43832..af38d3d73291 100644
--- a/drivers/net/ethernet/qlogic/qlcnic/qlcnic_ctx.c
+++ b/drivers/net/ethernet/qlogic/qlcnic/qlcnic_ctx.c
@@ -434,14 +434,14 @@ int qlcnic_82xx_fw_cmd_create_tx_ctx(struct qlcnic_adapter *adapter,
         *(tx_ring->hw_consumer) = 0;
 
         rq_size = SIZEOF_HOSTRQ_TX(struct qlcnic_hostrq_tx_ctx);
-        rq_addr = dma_zalloc_coherent(&adapter->pdev->dev, rq_size,
-                                      &rq_phys_addr, GFP_KERNEL);
+        rq_addr = dma_alloc_coherent(&adapter->pdev->dev, rq_size,
+                                     &rq_phys_addr, GFP_KERNEL);
         if (!rq_addr)
                 return -ENOMEM;
 
         rsp_size = SIZEOF_CARDRSP_TX(struct qlcnic_cardrsp_tx_ctx);
-        rsp_addr = dma_zalloc_coherent(&adapter->pdev->dev, rsp_size,
-                                       &rsp_phys_addr, GFP_KERNEL);
+        rsp_addr = dma_alloc_coherent(&adapter->pdev->dev, rsp_size,
+                                      &rsp_phys_addr, GFP_KERNEL);
         if (!rsp_addr) {
                 err = -ENOMEM;
                 goto out_free_rq;
@@ -855,8 +855,8 @@ int qlcnic_82xx_get_nic_info(struct qlcnic_adapter *adapter,
         struct qlcnic_cmd_args cmd;
         size_t  nic_size = sizeof(struct qlcnic_info_le);
 
-        nic_info_addr = dma_zalloc_coherent(&adapter->pdev->dev, nic_size,
-                                            &nic_dma_t, GFP_KERNEL);
+        nic_info_addr = dma_alloc_coherent(&adapter->pdev->dev, nic_size,
+                                           &nic_dma_t, GFP_KERNEL);
         if (!nic_info_addr)
                 return -ENOMEM;
 
@@ -909,8 +909,8 @@ int qlcnic_82xx_set_nic_info(struct qlcnic_adapter *adapter,
         if (adapter->ahw->op_mode != QLCNIC_MGMT_FUNC)
                 return err;
 
-        nic_info_addr = dma_zalloc_coherent(&adapter->pdev->dev, nic_size,
-                                            &nic_dma_t, GFP_KERNEL);
+        nic_info_addr = dma_alloc_coherent(&adapter->pdev->dev, nic_size,
+                                           &nic_dma_t, GFP_KERNEL);
         if (!nic_info_addr)
                 return -ENOMEM;
 
@@ -964,8 +964,8 @@ int qlcnic_82xx_get_pci_info(struct qlcnic_adapter *adapter,
         void *pci_info_addr;
         int err = 0, i;
 
-        pci_info_addr = dma_zalloc_coherent(&adapter->pdev->dev, pci_size,
-                                            &pci_info_dma_t, GFP_KERNEL);
+        pci_info_addr = dma_alloc_coherent(&adapter->pdev->dev, pci_size,
+                                           &pci_info_dma_t, GFP_KERNEL);
         if (!pci_info_addr)
                 return -ENOMEM;
 
@@ -1078,8 +1078,8 @@ int qlcnic_get_port_stats(struct qlcnic_adapter *adapter, const u8 func,
                 return -EIO;
         }
 
-        stats_addr = dma_zalloc_coherent(&adapter->pdev->dev, stats_size,
-                                         &stats_dma_t, GFP_KERNEL);
+        stats_addr = dma_alloc_coherent(&adapter->pdev->dev, stats_size,
+                                        &stats_dma_t, GFP_KERNEL);
         if (!stats_addr)
                 return -ENOMEM;
 
@@ -1134,8 +1134,8 @@ int qlcnic_get_mac_stats(struct qlcnic_adapter *adapter,
         if (mac_stats == NULL)
                 return -ENOMEM;
 
-        stats_addr = dma_zalloc_coherent(&adapter->pdev->dev, stats_size,
-                                         &stats_dma_t, GFP_KERNEL);
+        stats_addr = dma_alloc_coherent(&adapter->pdev->dev, stats_size,
+                                        &stats_dma_t, GFP_KERNEL);
         if (!stats_addr)
                 return -ENOMEM;
 
diff --git a/drivers/net/ethernet/qualcomm/emac/emac-mac.c b/drivers/net/ethernet/qualcomm/emac/emac-mac.c
index 031f6e6ee9c1..8d790313ee3d 100644
--- a/drivers/net/ethernet/qualcomm/emac/emac-mac.c
+++ b/drivers/net/ethernet/qualcomm/emac/emac-mac.c
@@ -776,7 +776,7 @@ int emac_mac_rx_tx_rings_alloc_all(struct emac_adapter *adpt)
                             8 + 2 * 8; /* 8 byte per one Tx and two Rx rings */
 
         ring_header->used = 0;
-        ring_header->v_addr = dma_zalloc_coherent(dev, ring_header->size,
+        ring_header->v_addr = dma_alloc_coherent(dev, ring_header->size,
                                                  &ring_header->dma_addr,
                                                  GFP_KERNEL);
         if (!ring_header->v_addr)
diff --git a/drivers/net/ethernet/realtek/r8169.c b/drivers/net/ethernet/realtek/r8169.c
index 298930d39b79..abb94c543aa2 100644
--- a/drivers/net/ethernet/realtek/r8169.c
+++ b/drivers/net/ethernet/realtek/r8169.c
@@ -205,6 +205,8 @@ enum cfg_version {
 };
 
 static const struct pci_device_id rtl8169_pci_tbl[] = {
+        { PCI_VDEVICE(REALTEK,  0x2502), RTL_CFG_1 },
+        { PCI_VDEVICE(REALTEK,  0x2600), RTL_CFG_1 },
         { PCI_VDEVICE(REALTEK,  0x8129), RTL_CFG_0 },
         { PCI_VDEVICE(REALTEK,  0x8136), RTL_CFG_2 },
         { PCI_VDEVICE(REALTEK,  0x8161), RTL_CFG_1 },
@@ -706,6 +708,7 @@ module_param(use_dac, int, 0);
 MODULE_PARM_DESC(use_dac, "Enable PCI DAC. Unsafe on 32 bit PCI slot.");
 module_param_named(debug, debug.msg_enable, int, 0);
 MODULE_PARM_DESC(debug, "Debug verbosity level (0=none, ..., 16=all)");
+MODULE_SOFTDEP("pre: realtek");
 MODULE_LICENSE("GPL");
 MODULE_FIRMWARE(FIRMWARE_8168D_1);
 MODULE_FIRMWARE(FIRMWARE_8168D_2);
@@ -1679,11 +1682,13 @@ static bool rtl8169_reset_counters(struct rtl8169_private *tp)
 
 static bool rtl8169_update_counters(struct rtl8169_private *tp)
 {
+        u8 val = RTL_R8(tp, ChipCmd);
+
         /*
          * Some chips are unable to dump tally counters when the receiver
-         * is disabled.
+         * is disabled. If 0xff chip may be in a PCI power-save state.
          */
-        if ((RTL_R8(tp, ChipCmd) & CmdRxEnb) == 0)
+        if (!(val & CmdRxEnb) || val == 0xff)
                 return true;
 
         return rtl8169_do_counters(tp, CounterDump);
diff --git a/drivers/net/ethernet/renesas/ravb_main.c b/drivers/net/ethernet/renesas/ravb_main.c
index ffc1ada4e6da..d28c8f9ca55b 100644
--- a/drivers/net/ethernet/renesas/ravb_main.c
+++ b/drivers/net/ethernet/renesas/ravb_main.c
@@ -343,7 +343,7 @@ static int ravb_ring_init(struct net_device *ndev, int q)
         int i;
 
         priv->rx_buf_sz = (ndev->mtu <= 1492 ? PKT_BUF_SZ : ndev->mtu) +
-                ETH_HLEN + VLAN_HLEN;
+                ETH_HLEN + VLAN_HLEN + sizeof(__sum16);
 
         /* Allocate RX and TX skb rings */
         priv->rx_skb[q] = kcalloc(priv->num_rx_ring[q],
@@ -524,13 +524,15 @@ static void ravb_rx_csum(struct sk_buff *skb)
 {
         u8 *hw_csum;
 
-        /* The hardware checksum is 2 bytes appended to packet data */
-        if (unlikely(skb->len < 2))
+        /* The hardware checksum is contained in sizeof(__sum16) (2) bytes
+         * appended to packet data
+         */
+        if (unlikely(skb->len < sizeof(__sum16)))
                 return;
-        hw_csum = skb_tail_pointer(skb) - 2;
+        hw_csum = skb_tail_pointer(skb) - sizeof(__sum16);
         skb->csum = csum_unfold((__force __sum16)get_unaligned_le16(hw_csum));
         skb->ip_summed = CHECKSUM_COMPLETE;
-        skb_trim(skb, skb->len - 2);
+        skb_trim(skb, skb->len - sizeof(__sum16));
 }
 
 /* Packet receive function for Ethernet AVB */
diff --git a/drivers/net/ethernet/samsung/sxgbe/sxgbe_main.c b/drivers/net/ethernet/samsung/sxgbe/sxgbe_main.c
index 690aee88f0eb..6d22dd500790 100644
--- a/drivers/net/ethernet/samsung/sxgbe/sxgbe_main.c
+++ b/drivers/net/ethernet/samsung/sxgbe/sxgbe_main.c
@@ -400,9 +400,9 @@ static int init_tx_ring(struct device *dev, u8 queue_no,
         }
 
         /* allocate memory for TX descriptors */
-        tx_ring->dma_tx = dma_zalloc_coherent(dev,
-                                              tx_rsize * sizeof(struct sxgbe_tx_norm_desc),
-                                              &tx_ring->dma_tx_phy, GFP_KERNEL);
+        tx_ring->dma_tx = dma_alloc_coherent(dev,
+                                             tx_rsize * sizeof(struct sxgbe_tx_norm_desc),
+                                             &tx_ring->dma_tx_phy, GFP_KERNEL);
         if (!tx_ring->dma_tx)
                 return -ENOMEM;
 
@@ -479,9 +479,9 @@ static int init_rx_ring(struct net_device *dev, u8 queue_no,
         rx_ring->queue_no = queue_no;
 
         /* allocate memory for RX descriptors */
-        rx_ring->dma_rx = dma_zalloc_coherent(priv->device,
-                                              rx_rsize * sizeof(struct sxgbe_rx_norm_desc),
-                                              &rx_ring->dma_rx_phy, GFP_KERNEL);
+        rx_ring->dma_rx = dma_alloc_coherent(priv->device,
+                                             rx_rsize * sizeof(struct sxgbe_rx_norm_desc),
+                                             &rx_ring->dma_rx_phy, GFP_KERNEL);
 
         if (rx_ring->dma_rx == NULL)
                 return -ENOMEM;
diff --git a/drivers/net/ethernet/sfc/ef10.c b/drivers/net/ethernet/sfc/ef10.c
index b6a50058bb8d..2f2bda68d861 100644
--- a/drivers/net/ethernet/sfc/ef10.c
+++ b/drivers/net/ethernet/sfc/ef10.c
@@ -6046,22 +6046,25 @@ static const struct efx_ef10_nvram_type_info efx_ef10_nvram_types[] = {
         { NVRAM_PARTITION_TYPE_EXPANSION_UEFI,     0,    0, "sfc_uefi" },
         { NVRAM_PARTITION_TYPE_STATUS,             0,    0, "sfc_status" }
 };
+#define EF10_NVRAM_PARTITION_COUNT      ARRAY_SIZE(efx_ef10_nvram_types)
 
 static int efx_ef10_mtd_probe_partition(struct efx_nic *efx,
                                         struct efx_mcdi_mtd_partition *part,
-                                        unsigned int type)
+                                        unsigned int type,
+                                        unsigned long *found)
 {
         MCDI_DECLARE_BUF(inbuf, MC_CMD_NVRAM_METADATA_IN_LEN);
         MCDI_DECLARE_BUF(outbuf, MC_CMD_NVRAM_METADATA_OUT_LENMAX);
         const struct efx_ef10_nvram_type_info *info;
         size_t size, erase_size, outlen;
+        int type_idx = 0;
         bool protected;
         int rc;
 
-        for (info = efx_ef10_nvram_types; ; info++) {
-                if (info ==
-                    efx_ef10_nvram_types + ARRAY_SIZE(efx_ef10_nvram_types))
+        for (type_idx = 0; ; type_idx++) {
+                if (type_idx == EF10_NVRAM_PARTITION_COUNT)
                         return -ENODEV;
+                info = efx_ef10_nvram_types + type_idx;
                 if ((type & ~info->type_mask) == info->type)
                         break;
         }
@@ -6074,6 +6077,13 @@ static int efx_ef10_mtd_probe_partition(struct efx_nic *efx,
         if (protected)
                 return -ENODEV; /* hide it */
 
+        /* If we've already exposed a partition of this type, hide this
+         * duplicate.  All operations on MTDs are keyed by the type anyway,
+         * so we can't act on the duplicate.
+         */
+        if (__test_and_set_bit(type_idx, found))
+                return -EEXIST;
+
         part->nvram_type = type;
 
         MCDI_SET_DWORD(inbuf, NVRAM_METADATA_IN_TYPE, type);
@@ -6105,6 +6115,7 @@ static int efx_ef10_mtd_probe_partition(struct efx_nic *efx,
 static int efx_ef10_mtd_probe(struct efx_nic *efx)
 {
         MCDI_DECLARE_BUF(outbuf, MC_CMD_NVRAM_PARTITIONS_OUT_LENMAX);
+        DECLARE_BITMAP(found, EF10_NVRAM_PARTITION_COUNT);
         struct efx_mcdi_mtd_partition *parts;
         size_t outlen, n_parts_total, i, n_parts;
         unsigned int type;
@@ -6133,11 +6144,13 @@ static int efx_ef10_mtd_probe(struct efx_nic *efx)
         for (i = 0; i < n_parts_total; i++) {
                 type = MCDI_ARRAY_DWORD(outbuf, NVRAM_PARTITIONS_OUT_TYPE_ID,
                                         i);
-                rc = efx_ef10_mtd_probe_partition(efx, &parts[n_parts], type);
-                if (rc == 0)
-                        n_parts++;
-                else if (rc != -ENODEV)
+                rc = efx_ef10_mtd_probe_partition(efx, &parts[n_parts], type,
+                                                  found);
+                if (rc == -EEXIST || rc == -ENODEV)
+                        continue;
+                if (rc)
                         goto fail;
+                n_parts++;
         }
 
         rc = efx_mtd_add(efx, &parts[0].common, n_parts, sizeof(*parts));
diff --git a/drivers/net/ethernet/sfc/falcon/nic.c b/drivers/net/ethernet/sfc/falcon/nic.c
index a8ecb33390da..9c07b5175581 100644
--- a/drivers/net/ethernet/sfc/falcon/nic.c
+++ b/drivers/net/ethernet/sfc/falcon/nic.c
@@ -33,8 +33,8 @@
 int ef4_nic_alloc_buffer(struct ef4_nic *efx, struct ef4_buffer *buffer,
                          unsigned int len, gfp_t gfp_flags)
 {
-        buffer->addr = dma_zalloc_coherent(&efx->pci_dev->dev, len,
-                                           &buffer->dma_addr, gfp_flags);
+        buffer->addr = dma_alloc_coherent(&efx->pci_dev->dev, len,
+                                          &buffer->dma_addr, gfp_flags);
         if (!buffer->addr)
                 return -ENOMEM;
         buffer->len = len;
diff --git a/drivers/net/ethernet/sfc/nic.c b/drivers/net/ethernet/sfc/nic.c
index aa1945a858d5..c2d45a40eb48 100644
--- a/drivers/net/ethernet/sfc/nic.c
+++ b/drivers/net/ethernet/sfc/nic.c
@@ -34,8 +34,8 @@
 int efx_nic_alloc_buffer(struct efx_nic *efx, struct efx_buffer *buffer,
                          unsigned int len, gfp_t gfp_flags)
 {
-        buffer->addr = dma_zalloc_coherent(&efx->pci_dev->dev, len,
-                                           &buffer->dma_addr, gfp_flags);
+        buffer->addr = dma_alloc_coherent(&efx->pci_dev->dev, len,
+                                          &buffer->dma_addr, gfp_flags);
         if (!buffer->addr)
                 return -ENOMEM;
         buffer->len = len;
diff --git a/drivers/net/ethernet/sgi/meth.c b/drivers/net/ethernet/sgi/meth.c
index 703fbbefea44..0e1b7e960b98 100644
--- a/drivers/net/ethernet/sgi/meth.c
+++ b/drivers/net/ethernet/sgi/meth.c
@@ -211,8 +211,8 @@ static void meth_check_link(struct net_device *dev)
 static int meth_init_tx_ring(struct meth_private *priv)
 {
         /* Init TX ring */
-        priv->tx_ring = dma_zalloc_coherent(NULL, TX_RING_BUFFER_SIZE,
-                                            &priv->tx_ring_dma, GFP_ATOMIC);
+        priv->tx_ring = dma_alloc_coherent(NULL, TX_RING_BUFFER_SIZE,
+                                           &priv->tx_ring_dma, GFP_ATOMIC);
         if (!priv->tx_ring)
                 return -ENOMEM;
 
diff --git a/drivers/net/ethernet/socionext/netsec.c b/drivers/net/ethernet/socionext/netsec.c
index 05a0948ad929..a18149720aa2 100644
--- a/drivers/net/ethernet/socionext/netsec.c
+++ b/drivers/net/ethernet/socionext/netsec.c
@@ -1029,8 +1029,8 @@ static int netsec_alloc_dring(struct netsec_priv *priv, enum ring_id id)
         struct netsec_desc_ring *dring = &priv->desc_ring[id];
         int i;
 
-        dring->vaddr = dma_zalloc_coherent(priv->dev, DESC_SZ * DESC_NUM,
-                                           &dring->desc_dma, GFP_KERNEL);
+        dring->vaddr = dma_alloc_coherent(priv->dev, DESC_SZ * DESC_NUM,
+                                          &dring->desc_dma, GFP_KERNEL);
         if (!dring->vaddr)
                 goto err;
 
diff --git a/drivers/net/ethernet/stmicro/stmmac/dwxgmac2_dma.c b/drivers/net/ethernet/stmicro/stmmac/dwxgmac2_dma.c
index 6c5092e7771c..c5e25580a43f 100644
--- a/drivers/net/ethernet/stmicro/stmmac/dwxgmac2_dma.c
+++ b/drivers/net/ethernet/stmicro/stmmac/dwxgmac2_dma.c
@@ -263,6 +263,7 @@ static int dwxgmac2_dma_interrupt(void __iomem *ioaddr,
                                   struct stmmac_extra_stats *x, u32 chan)
 {
         u32 intr_status = readl(ioaddr + XGMAC_DMA_CH_STATUS(chan));
+        u32 intr_en = readl(ioaddr + XGMAC_DMA_CH_INT_EN(chan));
         int ret = 0;
 
         /* ABNORMAL interrupts */
@@ -282,8 +283,7 @@ static int dwxgmac2_dma_interrupt(void __iomem *ioaddr,
                 x->normal_irq_n++;
 
                 if (likely(intr_status & XGMAC_RI)) {
-                        u32 value = readl(ioaddr + XGMAC_DMA_CH_INT_EN(chan));
-                        if (likely(value & XGMAC_RIE)) {
+                        if (likely(intr_en & XGMAC_RIE)) {
                                 x->rx_normal_irq_n++;
                                 ret |= handle_rx;
                         }
@@ -295,7 +295,7 @@ static int dwxgmac2_dma_interrupt(void __iomem *ioaddr,
         }
 
         /* Clear interrupts */
-        writel(~0x0, ioaddr + XGMAC_DMA_CH_STATUS(chan));
+        writel(intr_en & intr_status, ioaddr + XGMAC_DMA_CH_STATUS(chan));
 
         return ret;
 }
diff --git a/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c b/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c
index 0e0a0789c2ed..5afba69981cf 100644
--- a/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c
+++ b/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c
@@ -1549,22 +1549,18 @@ static int alloc_dma_rx_desc_resources(struct stmmac_priv *priv)
                         goto err_dma;
 
                 if (priv->extend_desc) {
-                        rx_q->dma_erx = dma_zalloc_coherent(priv->device,
-                                                            DMA_RX_SIZE *
-                                                            sizeof(struct
-                                                            dma_extended_desc),
-                                                            &rx_q->dma_rx_phy,
-                                                            GFP_KERNEL);
+                        rx_q->dma_erx = dma_alloc_coherent(priv->device,
+                                                           DMA_RX_SIZE * sizeof(struct dma_extended_desc),
+                                                           &rx_q->dma_rx_phy,
+                                                           GFP_KERNEL);
                         if (!rx_q->dma_erx)
                                 goto err_dma;
 
                 } else {
-                        rx_q->dma_rx = dma_zalloc_coherent(priv->device,
-                                                           DMA_RX_SIZE *
-                                                           sizeof(struct
-                                                           dma_desc),
-                                                           &rx_q->dma_rx_phy,
-                                                           GFP_KERNEL);
+                        rx_q->dma_rx = dma_alloc_coherent(priv->device,
+                                                          DMA_RX_SIZE * sizeof(struct dma_desc),
+                                                          &rx_q->dma_rx_phy,
+                                                          GFP_KERNEL);
                         if (!rx_q->dma_rx)
                                 goto err_dma;
                 }
@@ -1612,21 +1608,17 @@ static int alloc_dma_tx_desc_resources(struct stmmac_priv *priv)
                         goto err_dma;
 
                 if (priv->extend_desc) {
-                        tx_q->dma_etx = dma_zalloc_coherent(priv->device,
-                                                            DMA_TX_SIZE *
-                                                            sizeof(struct
-                                                            dma_extended_desc),
-                                                            &tx_q->dma_tx_phy,
-                                                            GFP_KERNEL);
+                        tx_q->dma_etx = dma_alloc_coherent(priv->device,
+                                                           DMA_TX_SIZE * sizeof(struct dma_extended_desc),
+                                                           &tx_q->dma_tx_phy,
+                                                           GFP_KERNEL);
                         if (!tx_q->dma_etx)
                                 goto err_dma;
                 } else {
-                        tx_q->dma_tx = dma_zalloc_coherent(priv->device,
-                                                           DMA_TX_SIZE *
-                                                           sizeof(struct
-                                                                  dma_desc),
-                                                           &tx_q->dma_tx_phy,
-                                                           GFP_KERNEL);
+                        tx_q->dma_tx = dma_alloc_coherent(priv->device,
+                                                          DMA_TX_SIZE * sizeof(struct dma_desc),
+                                                          &tx_q->dma_tx_phy,
+                                                          GFP_KERNEL);
                         if (!tx_q->dma_tx)
                                 goto err_dma;
                 }
@@ -3525,27 +3517,28 @@ static int stmmac_napi_poll(struct napi_struct *napi, int budget)
         struct stmmac_channel *ch =
                 container_of(napi, struct stmmac_channel, napi);
         struct stmmac_priv *priv = ch->priv_data;
-        int work_done = 0, work_rem = budget;
+        int work_done, rx_done = 0, tx_done = 0;
         u32 chan = ch->index;
 
         priv->xstats.napi_poll++;
 
-        if (ch->has_tx) {
-                int done = stmmac_tx_clean(priv, work_rem, chan);
-
-                work_done += done;
-                work_rem -= done;
-        }
+        if (ch->has_tx)
+                tx_done = stmmac_tx_clean(priv, budget, chan);
+        if (ch->has_rx)
+                rx_done = stmmac_rx(priv, budget, chan);
 
-        if (ch->has_rx) {
-                int done = stmmac_rx(priv, work_rem, chan);
+        work_done = max(rx_done, tx_done);
+        work_done = min(work_done, budget);
 
-                work_done += done;
-                work_rem -= done;
-        }
+        if (work_done < budget && napi_complete_done(napi, work_done)) {
+                int stat;
 
-        if (work_done < budget && napi_complete_done(napi, work_done))
                 stmmac_enable_dma_irq(priv, priv->ioaddr, chan);
+                stat = stmmac_dma_interrupt_status(priv, priv->ioaddr,
+                                                   &priv->xstats, chan);
+                if (stat && napi_reschedule(napi))
+                        stmmac_disable_dma_irq(priv, priv->ioaddr, chan);
+        }
 
         return work_done;
 }
@@ -4168,6 +4161,18 @@ static int stmmac_hw_init(struct stmmac_priv *priv)
                         return ret;
         }
 
+        /* Rx Watchdog is available in the COREs newer than the 3.40.
+         * In some case, for example on bugged HW this feature
+         * has to be disable and this can be done by passing the
+         * riwt_off field from the platform.
+         */
+        if (((priv->synopsys_id >= DWMAC_CORE_3_50) ||
+            (priv->plat->has_xgmac)) && (!priv->plat->riwt_off)) {
+                priv->use_riwt = 1;
+                dev_info(priv->device,
+                         "Enable RX Mitigation via HW Watchdog Timer\n");
+        }
+
         return 0;
 }
 
@@ -4300,18 +4305,6 @@ int stmmac_dvr_probe(struct device *device,
         if (flow_ctrl)
                 priv->flow_ctrl = FLOW_AUTO;    /* RX/TX pause on */
 
-        /* Rx Watchdog is available in the COREs newer than the 3.40.
-         * In some case, for example on bugged HW this feature
-         * has to be disable and this can be done by passing the
-         * riwt_off field from the platform.
-         */
-        if (((priv->synopsys_id >= DWMAC_CORE_3_50) ||
-            (priv->plat->has_xgmac)) && (!priv->plat->riwt_off)) {
-                priv->use_riwt = 1;
-                dev_info(priv->device,
-                         "Enable RX Mitigation via HW Watchdog Timer\n");
-        }
-
         /* Setup channels NAPI */
         maxq = max(priv->plat->rx_queues_to_use, priv->plat->tx_queues_to_use);
 
diff --git a/drivers/net/ethernet/stmicro/stmmac/stmmac_pci.c b/drivers/net/ethernet/stmicro/stmmac/stmmac_pci.c
index c54a50dbd5ac..d819e8eaba12 100644
--- a/drivers/net/ethernet/stmicro/stmmac/stmmac_pci.c
+++ b/drivers/net/ethernet/stmicro/stmmac/stmmac_pci.c
@@ -299,7 +299,17 @@ static int stmmac_pci_probe(struct pci_dev *pdev,
  */
 static void stmmac_pci_remove(struct pci_dev *pdev)
 {
+        int i;
+
         stmmac_dvr_remove(&pdev->dev);
+
+        for (i = 0; i <= PCI_STD_RESOURCE_END; i++) {
+                if (pci_resource_len(pdev, i) == 0)
+                        continue;
+                pcim_iounmap_regions(pdev, BIT(i));
+                break;
+        }
+
         pci_disable_device(pdev);
 }
 
diff --git a/drivers/net/ethernet/stmicro/stmmac/stmmac_tc.c b/drivers/net/ethernet/stmicro/stmmac/stmmac_tc.c
index 531294f4978b..58ea18af9813 100644
--- a/drivers/net/ethernet/stmicro/stmmac/stmmac_tc.c
+++ b/drivers/net/ethernet/stmicro/stmmac/stmmac_tc.c
@@ -301,6 +301,8 @@ static int tc_setup_cbs(struct stmmac_priv *priv,
         /* Queue 0 is not AVB capable */
         if (queue <= 0 || queue >= tx_queues_count)
                 return -EINVAL;
+        if (!priv->dma_cap.av)
+                return -EOPNOTSUPP;
         if (priv->speed != SPEED_100 && priv->speed != SPEED_1000)
                 return -EOPNOTSUPP;
 
diff --git a/drivers/net/ethernet/sun/cassini.c b/drivers/net/ethernet/sun/cassini.c
index 9020b084b953..7ec4eb74fe21 100644
--- a/drivers/net/ethernet/sun/cassini.c
+++ b/drivers/net/ethernet/sun/cassini.c
@@ -1,22 +1,9 @@
-// SPDX-License-Identifier: GPL-2.0
+// SPDX-License-Identifier: GPL-2.0+
 /* cassini.c: Sun Microsystems Cassini(+) ethernet driver.
  *
  * Copyright (C) 2004 Sun Microsystems Inc.
  * Copyright (C) 2003 Adrian Sun (asun@darksunrising.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, see <http://www.gnu.org/licenses/>.
- *
  * This driver uses the sungem driver (c) David Miller
  * (davem@redhat.com) as its basis.
  *
diff --git a/drivers/net/ethernet/sun/cassini.h b/drivers/net/ethernet/sun/cassini.h
index 13f3860496a8..ae5f05f03f88 100644
--- a/drivers/net/ethernet/sun/cassini.h
+++ b/drivers/net/ethernet/sun/cassini.h
@@ -1,23 +1,10 @@
-/* SPDX-License-Identifier: GPL-2.0 */
+/* SPDX-License-Identifier: GPL-2.0+ */
 /* $Id: cassini.h,v 1.16 2004/08/17 21:15:16 zaumen Exp $
  * cassini.h: Definitions for Sun Microsystems Cassini(+) ethernet driver.
  *
  * Copyright (C) 2004 Sun Microsystems Inc.
  * Copyright (c) 2003 Adrian Sun (asun@darksunrising.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, see <http://www.gnu.org/licenses/>.
- *
  * vendor id: 0x108E (Sun Microsystems, Inc.)
  * device id: 0xabba (Cassini)
  * revision ids: 0x01 = Cassini
diff --git a/drivers/net/ethernet/tundra/tsi108_eth.c b/drivers/net/ethernet/tundra/tsi108_eth.c
index edcd1e60b30d..37925a1d58de 100644
--- a/drivers/net/ethernet/tundra/tsi108_eth.c
+++ b/drivers/net/ethernet/tundra/tsi108_eth.c
@@ -1311,13 +1311,13 @@ static int tsi108_open(struct net_device *dev)
                        data->id, dev->irq, dev->name);
         }
 
-        data->rxring = dma_zalloc_coherent(&data->pdev->dev, rxring_size,
-                        &data->rxdma, GFP_KERNEL);
+        data->rxring = dma_alloc_coherent(&data->pdev->dev, rxring_size,
+                                          &data->rxdma, GFP_KERNEL);
         if (!data->rxring)
                 return -ENOMEM;
 
-        data->txring = dma_zalloc_coherent(&data->pdev->dev, txring_size,
-                        &data->txdma, GFP_KERNEL);
+        data->txring = dma_alloc_coherent(&data->pdev->dev, txring_size,
+                                          &data->txdma, GFP_KERNEL);
         if (!data->txring) {
                 dma_free_coherent(&data->pdev->dev, rxring_size, data->rxring,
                                     data->rxdma);
diff --git a/drivers/net/ethernet/xilinx/ll_temac_main.c b/drivers/net/ethernet/xilinx/ll_temac_main.c
index 2241f9897092..15bb058db392 100644
--- a/drivers/net/ethernet/xilinx/ll_temac_main.c
+++ b/drivers/net/ethernet/xilinx/ll_temac_main.c
@@ -243,15 +243,15 @@ static int temac_dma_bd_init(struct net_device *ndev)
 
         /* allocate the tx and rx ring buffer descriptors. */
         /* returns a virtual address and a physical address. */
-        lp->tx_bd_v = dma_zalloc_coherent(ndev->dev.parent,
-                                          sizeof(*lp->tx_bd_v) * TX_BD_NUM,
-                                          &lp->tx_bd_p, GFP_KERNEL);
+        lp->tx_bd_v = dma_alloc_coherent(ndev->dev.parent,
+                                         sizeof(*lp->tx_bd_v) * TX_BD_NUM,
+                                         &lp->tx_bd_p, GFP_KERNEL);
         if (!lp->tx_bd_v)
                 goto out;
 
-        lp->rx_bd_v = dma_zalloc_coherent(ndev->dev.parent,
-                                          sizeof(*lp->rx_bd_v) * RX_BD_NUM,
-                                          &lp->rx_bd_p, GFP_KERNEL);
+        lp->rx_bd_v = dma_alloc_coherent(ndev->dev.parent,
+                                         sizeof(*lp->rx_bd_v) * RX_BD_NUM,
+                                         &lp->rx_bd_p, GFP_KERNEL);
         if (!lp->rx_bd_v)
                 goto out;
 
diff --git a/drivers/net/ethernet/xilinx/xilinx_axienet_main.c b/drivers/net/ethernet/xilinx/xilinx_axienet_main.c
index 12a14609ec47..0789d8af7d72 100644
--- a/drivers/net/ethernet/xilinx/xilinx_axienet_main.c
+++ b/drivers/net/ethernet/xilinx/xilinx_axienet_main.c
@@ -199,15 +199,15 @@ static int axienet_dma_bd_init(struct net_device *ndev)
         lp->rx_bd_ci = 0;
 
         /* Allocate the Tx and Rx buffer descriptors. */
-        lp->tx_bd_v = dma_zalloc_coherent(ndev->dev.parent,
-                                          sizeof(*lp->tx_bd_v) * TX_BD_NUM,
-                                          &lp->tx_bd_p, GFP_KERNEL);
+        lp->tx_bd_v = dma_alloc_coherent(ndev->dev.parent,
+                                         sizeof(*lp->tx_bd_v) * TX_BD_NUM,
+                                         &lp->tx_bd_p, GFP_KERNEL);
         if (!lp->tx_bd_v)
                 goto out;
 
-        lp->rx_bd_v = dma_zalloc_coherent(ndev->dev.parent,
-                                          sizeof(*lp->rx_bd_v) * RX_BD_NUM,
-                                          &lp->rx_bd_p, GFP_KERNEL);
+        lp->rx_bd_v = dma_alloc_coherent(ndev->dev.parent,
+                                         sizeof(*lp->rx_bd_v) * RX_BD_NUM,
+                                         &lp->rx_bd_p, GFP_KERNEL);
         if (!lp->rx_bd_v)
                 goto out;
 
diff --git a/drivers/net/fddi/defxx.c b/drivers/net/fddi/defxx.c
index 61fceee73c1b..38ac8ef41f5f 100644
--- a/drivers/net/fddi/defxx.c
+++ b/drivers/net/fddi/defxx.c
@@ -1139,9 +1139,9 @@ static int dfx_driver_init(struct net_device *dev, const char *print_name,
 #endif
                                         sizeof(PI_CONSUMER_BLOCK) +
                                         (PI_ALIGN_K_DESC_BLK - 1);
-        bp->kmalloced = top_v = dma_zalloc_coherent(bp->bus_dev, alloc_size,
-                                                    &bp->kmalloced_dma,
-                                                    GFP_ATOMIC);
+        bp->kmalloced = top_v = dma_alloc_coherent(bp->bus_dev, alloc_size,
+                                                   &bp->kmalloced_dma,
+                                                   GFP_ATOMIC);
         if (top_v == NULL)
                 return DFX_K_FAILURE;
 
diff --git a/drivers/net/fddi/skfp/skfddi.c b/drivers/net/fddi/skfp/skfddi.c
index 72433f3efc74..5d661f60b101 100644
--- a/drivers/net/fddi/skfp/skfddi.c
+++ b/drivers/net/fddi/skfp/skfddi.c
@@ -409,10 +409,10 @@ static  int skfp_driver_init(struct net_device *dev)
         if (bp->SharedMemSize > 0) {
                 bp->SharedMemSize += 16;        // for descriptor alignment
 
-                bp->SharedMemAddr = dma_zalloc_coherent(&bp->pdev.dev,
-                                                        bp->SharedMemSize,
-                                                        &bp->SharedMemDMA,
-                                                        GFP_ATOMIC);
+                bp->SharedMemAddr = dma_alloc_coherent(&bp->pdev.dev,
+                                                       bp->SharedMemSize,
+                                                       &bp->SharedMemDMA,
+                                                       GFP_ATOMIC);
                 if (!bp->SharedMemAddr) {
                         printk("could not allocate mem for ");
                         printk("hardware module: %ld byte\n",
diff --git a/drivers/net/hyperv/hyperv_net.h b/drivers/net/hyperv/hyperv_net.h
index ef6f766f6389..e859ae2e42d5 100644
--- a/drivers/net/hyperv/hyperv_net.h
+++ b/drivers/net/hyperv/hyperv_net.h
@@ -144,6 +144,8 @@ struct hv_netvsc_packet {
         u32 total_data_buflen;
 };
 
+#define NETVSC_HASH_KEYLEN 40
+
 struct netvsc_device_info {
         unsigned char mac_adr[ETH_ALEN];
         u32  num_chn;
@@ -151,6 +153,8 @@ struct netvsc_device_info {
         u32  recv_sections;
         u32  send_section_size;
         u32  recv_section_size;
+
+        u8 rss_key[NETVSC_HASH_KEYLEN];
 };
 
 enum rndis_device_state {
@@ -160,8 +164,6 @@ enum rndis_device_state {
         RNDIS_DEV_DATAINITIALIZED,
 };
 
-#define NETVSC_HASH_KEYLEN 40
-
 struct rndis_device {
         struct net_device *ndev;
 
@@ -209,7 +211,9 @@ int netvsc_recv_callback(struct net_device *net,
 void netvsc_channel_cb(void *context);
 int netvsc_poll(struct napi_struct *napi, int budget);
 
-int rndis_set_subchannel(struct net_device *ndev, struct netvsc_device *nvdev);
+int rndis_set_subchannel(struct net_device *ndev,
+                         struct netvsc_device *nvdev,
+                         struct netvsc_device_info *dev_info);
 int rndis_filter_open(struct netvsc_device *nvdev);
 int rndis_filter_close(struct netvsc_device *nvdev);
 struct netvsc_device *rndis_filter_device_add(struct hv_device *dev,
@@ -1177,7 +1181,7 @@ enum ndis_per_pkt_info_type {
 
 enum rndis_per_pkt_info_interal_type {
         RNDIS_PKTINFO_ID = 1,
-        /* Add more memebers here */
+        /* Add more members here */
 
         RNDIS_PKTINFO_MAX
 };
diff --git a/drivers/net/hyperv/netvsc.c b/drivers/net/hyperv/netvsc.c
index 922054c1d544..813d195bbd57 100644
--- a/drivers/net/hyperv/netvsc.c
+++ b/drivers/net/hyperv/netvsc.c
@@ -84,7 +84,7 @@ static void netvsc_subchan_work(struct work_struct *w)
 
         rdev = nvdev->extension;
         if (rdev) {
-                ret = rndis_set_subchannel(rdev->ndev, nvdev);
+                ret = rndis_set_subchannel(rdev->ndev, nvdev, NULL);
                 if (ret == 0) {
                         netif_device_attach(rdev->ndev);
                 } else {
@@ -1331,7 +1331,7 @@ void netvsc_channel_cb(void *context)
         prefetch(hv_get_ring_buffer(rbi) + rbi->priv_read_index);
 
         if (napi_schedule_prep(&nvchan->napi)) {
-                /* disable interupts from host */
+                /* disable interrupts from host */
                 hv_begin_read(rbi);
 
                 __napi_schedule_irqoff(&nvchan->napi);
diff --git a/drivers/net/hyperv/netvsc_drv.c b/drivers/net/hyperv/netvsc_drv.c
index 91ed15ea5883..256adbd044f5 100644
--- a/drivers/net/hyperv/netvsc_drv.c
+++ b/drivers/net/hyperv/netvsc_drv.c
@@ -370,7 +370,7 @@ static u32 fill_pg_buf(struct page *page, u32 offset, u32 len,
 {
         int j = 0;
 
-        /* Deal with compund pages by ignoring unused part
+        /* Deal with compound pages by ignoring unused part
          * of the page.
          */
         page += (offset >> PAGE_SHIFT);
@@ -858,6 +858,39 @@ static void netvsc_get_channels(struct net_device *net,
         }
 }
 
+/* Alloc struct netvsc_device_info, and initialize it from either existing
+ * struct netvsc_device, or from default values.
+ */
+static struct netvsc_device_info *netvsc_devinfo_get
+                        (struct netvsc_device *nvdev)
+{
+        struct netvsc_device_info *dev_info;
+
+        dev_info = kzalloc(sizeof(*dev_info), GFP_ATOMIC);
+
+        if (!dev_info)
+                return NULL;
+
+        if (nvdev) {
+                dev_info->num_chn = nvdev->num_chn;
+                dev_info->send_sections = nvdev->send_section_cnt;
+                dev_info->send_section_size = nvdev->send_section_size;
+                dev_info->recv_sections = nvdev->recv_section_cnt;
+                dev_info->recv_section_size = nvdev->recv_section_size;
+
+                memcpy(dev_info->rss_key, nvdev->extension->rss_key,
+                       NETVSC_HASH_KEYLEN);
+        } else {
+                dev_info->num_chn = VRSS_CHANNEL_DEFAULT;
+                dev_info->send_sections = NETVSC_DEFAULT_TX;
+                dev_info->send_section_size = NETVSC_SEND_SECTION_SIZE;
+                dev_info->recv_sections = NETVSC_DEFAULT_RX;
+                dev_info->recv_section_size = NETVSC_RECV_SECTION_SIZE;
+        }
+
+        return dev_info;
+}
+
 static int netvsc_detach(struct net_device *ndev,
                          struct netvsc_device *nvdev)
 {
@@ -909,7 +942,7 @@ static int netvsc_attach(struct net_device *ndev,
                 return PTR_ERR(nvdev);
 
         if (nvdev->num_chn > 1) {
-                ret = rndis_set_subchannel(ndev, nvdev);
+                ret = rndis_set_subchannel(ndev, nvdev, dev_info);
 
                 /* if unavailable, just proceed with one queue */
                 if (ret) {
@@ -943,7 +976,7 @@ static int netvsc_set_channels(struct net_device *net,
         struct net_device_context *net_device_ctx = netdev_priv(net);
         struct netvsc_device *nvdev = rtnl_dereference(net_device_ctx->nvdev);
         unsigned int orig, count = channels->combined_count;
-        struct netvsc_device_info device_info;
+        struct netvsc_device_info *device_info;
         int ret;
 
         /* We do not support separate count for rx, tx, or other */
@@ -962,24 +995,26 @@ static int netvsc_set_channels(struct net_device *net,
 
         orig = nvdev->num_chn;
 
-        memset(&device_info, 0, sizeof(device_info));
-        device_info.num_chn = count;
-        device_info.send_sections = nvdev->send_section_cnt;
-        device_info.send_section_size = nvdev->send_section_size;
-        device_info.recv_sections = nvdev->recv_section_cnt;
-        device_info.recv_section_size = nvdev->recv_section_size;
+        device_info = netvsc_devinfo_get(nvdev);
+
+        if (!device_info)
+                return -ENOMEM;
+
+        device_info->num_chn = count;
 
         ret = netvsc_detach(net, nvdev);
         if (ret)
-                return ret;
+                goto out;
 
-        ret = netvsc_attach(net, &device_info);
+        ret = netvsc_attach(net, device_info);
         if (ret) {
-                device_info.num_chn = orig;
-                if (netvsc_attach(net, &device_info))
+                device_info->num_chn = orig;
+                if (netvsc_attach(net, device_info))
                         netdev_err(net, "restoring channel setting failed\n");
         }
 
+out:
+        kfree(device_info);
         return ret;
 }
 
@@ -1048,48 +1083,45 @@ static int netvsc_change_mtu(struct net_device *ndev, int mtu)
         struct net_device *vf_netdev = rtnl_dereference(ndevctx->vf_netdev);
         struct netvsc_device *nvdev = rtnl_dereference(ndevctx->nvdev);
         int orig_mtu = ndev->mtu;
-        struct netvsc_device_info device_info;
+        struct netvsc_device_info *device_info;
         int ret = 0;
 
         if (!nvdev || nvdev->destroy)
                 return -ENODEV;
 
+        device_info = netvsc_devinfo_get(nvdev);
+
+        if (!device_info)
+                return -ENOMEM;
+
         /* Change MTU of underlying VF netdev first. */
         if (vf_netdev) {
                 ret = dev_set_mtu(vf_netdev, mtu);
                 if (ret)
-                        return ret;
+                        goto out;
         }
 
-        memset(&device_info, 0, sizeof(device_info));
-        device_info.num_chn = nvdev->num_chn;
-        device_info.send_sections = nvdev->send_section_cnt;
-        device_info.send_section_size = nvdev->send_section_size;
-        device_info.recv_sections = nvdev->recv_section_cnt;
-        device_info.recv_section_size = nvdev->recv_section_size;
-
         ret = netvsc_detach(ndev, nvdev);
         if (ret)
                 goto rollback_vf;
 
         ndev->mtu = mtu;
 
-        ret = netvsc_attach(ndev, &device_info);
-        if (ret)
-                goto rollback;
-
-        return 0;
+        ret = netvsc_attach(ndev, device_info);
+        if (!ret)
+                goto out;
 
-rollback:
         /* Attempt rollback to original MTU */
         ndev->mtu = orig_mtu;
 
-        if (netvsc_attach(ndev, &device_info))
+        if (netvsc_attach(ndev, device_info))
                 netdev_err(ndev, "restoring mtu failed\n");
 rollback_vf:
         if (vf_netdev)
                 dev_set_mtu(vf_netdev, orig_mtu);
 
+out:
+        kfree(device_info);
         return ret;
 }
 
@@ -1674,7 +1706,7 @@ static int netvsc_set_ringparam(struct net_device *ndev,
 {
         struct net_device_context *ndevctx = netdev_priv(ndev);
         struct netvsc_device *nvdev = rtnl_dereference(ndevctx->nvdev);
-        struct netvsc_device_info device_info;
+        struct netvsc_device_info *device_info;
         struct ethtool_ringparam orig;
         u32 new_tx, new_rx;
         int ret = 0;
@@ -1694,26 +1726,29 @@ static int netvsc_set_ringparam(struct net_device *ndev,
             new_rx == orig.rx_pending)
                 return 0;        /* no change */
 
-        memset(&device_info, 0, sizeof(device_info));
-        device_info.num_chn = nvdev->num_chn;
-        device_info.send_sections = new_tx;
-        device_info.send_section_size = nvdev->send_section_size;
-        device_info.recv_sections = new_rx;
-        device_info.recv_section_size = nvdev->recv_section_size;
+        device_info = netvsc_devinfo_get(nvdev);
+
+        if (!device_info)
+                return -ENOMEM;
+
+        device_info->send_sections = new_tx;
+        device_info->recv_sections = new_rx;
 
         ret = netvsc_detach(ndev, nvdev);
         if (ret)
-                return ret;
+                goto out;
 
-        ret = netvsc_attach(ndev, &device_info);
+        ret = netvsc_attach(ndev, device_info);
         if (ret) {
-                device_info.send_sections = orig.tx_pending;
-                device_info.recv_sections = orig.rx_pending;
+                device_info->send_sections = orig.tx_pending;
+                device_info->recv_sections = orig.rx_pending;
 
-                if (netvsc_attach(ndev, &device_info))
+                if (netvsc_attach(ndev, device_info))
                         netdev_err(ndev, "restoring ringparam failed");
         }
 
+out:
+        kfree(device_info);
         return ret;
 }
 
@@ -2088,7 +2123,7 @@ static int netvsc_register_vf(struct net_device *vf_netdev)
         if (!netvsc_dev || rtnl_dereference(net_device_ctx->vf_netdev))
                 return NOTIFY_DONE;
 
-        /* if syntihetic interface is a different namespace,
+        /* if synthetic interface is a different namespace,
          * then move the VF to that namespace; join will be
          * done again in that context.
          */
@@ -2167,7 +2202,7 @@ static int netvsc_probe(struct hv_device *dev,
 {
         struct net_device *net = NULL;
         struct net_device_context *net_device_ctx;
-        struct netvsc_device_info device_info;
+        struct netvsc_device_info *device_info = NULL;
         struct netvsc_device *nvdev;
         int ret = -ENOMEM;
 
@@ -2214,21 +2249,21 @@ static int netvsc_probe(struct hv_device *dev,
         netif_set_real_num_rx_queues(net, 1);
 
         /* Notify the netvsc driver of the new device */
-        memset(&device_info, 0, sizeof(device_info));
-        device_info.num_chn = VRSS_CHANNEL_DEFAULT;
-        device_info.send_sections = NETVSC_DEFAULT_TX;
-        device_info.send_section_size = NETVSC_SEND_SECTION_SIZE;
-        device_info.recv_sections = NETVSC_DEFAULT_RX;
-        device_info.recv_section_size = NETVSC_RECV_SECTION_SIZE;
-
-        nvdev = rndis_filter_device_add(dev, &device_info);
+        device_info = netvsc_devinfo_get(NULL);
+
+        if (!device_info) {
+                ret = -ENOMEM;
+                goto devinfo_failed;
+        }
+
+        nvdev = rndis_filter_device_add(dev, device_info);
         if (IS_ERR(nvdev)) {
                 ret = PTR_ERR(nvdev);
                 netdev_err(net, "unable to add netvsc device (ret %d)\n", ret);
                 goto rndis_failed;
         }
 
-        memcpy(net->dev_addr, device_info.mac_adr, ETH_ALEN);
+        memcpy(net->dev_addr, device_info->mac_adr, ETH_ALEN);
 
         /* We must get rtnl lock before scheduling nvdev->subchan_work,
          * otherwise netvsc_subchan_work() can get rtnl lock first and wait
@@ -2236,7 +2271,7 @@ static int netvsc_probe(struct hv_device *dev,
          * netvsc_probe() can't get rtnl lock and as a result vmbus_onoffer()
          * -> ... -> device_add() -> ... -> __device_attach() can't get
          * the device lock, so all the subchannels can't be processed --
-         * finally netvsc_subchan_work() hangs for ever.
+         * finally netvsc_subchan_work() hangs forever.
          */
         rtnl_lock();
 
@@ -2266,12 +2301,16 @@ static int netvsc_probe(struct hv_device *dev,
 
         list_add(&net_device_ctx->list, &netvsc_dev_list);
         rtnl_unlock();
+
+        kfree(device_info);
         return 0;
 
 register_failed:
         rtnl_unlock();
         rndis_filter_device_remove(dev, nvdev);
 rndis_failed:
+        kfree(device_info);
+devinfo_failed:
         free_percpu(net_device_ctx->vf_stats);
 no_stats:
         hv_set_drvdata(dev, NULL);
diff --git a/drivers/net/hyperv/rndis_filter.c b/drivers/net/hyperv/rndis_filter.c
index 8b537a049c1e..73b60592de06 100644
--- a/drivers/net/hyperv/rndis_filter.c
+++ b/drivers/net/hyperv/rndis_filter.c
@@ -774,8 +774,8 @@ cleanup:
         return ret;
 }
 
-int rndis_filter_set_rss_param(struct rndis_device *rdev,
-                               const u8 *rss_key)
+static int rndis_set_rss_param_msg(struct rndis_device *rdev,
+                                   const u8 *rss_key, u16 flag)
 {
         struct net_device *ndev = rdev->ndev;
         struct rndis_request *request;
@@ -804,7 +804,7 @@ int rndis_filter_set_rss_param(struct rndis_device *rdev,
         rssp->hdr.type = NDIS_OBJECT_TYPE_RSS_PARAMETERS;
         rssp->hdr.rev = NDIS_RECEIVE_SCALE_PARAMETERS_REVISION_2;
         rssp->hdr.size = sizeof(struct ndis_recv_scale_param);
-        rssp->flag = 0;
+        rssp->flag = flag;
         rssp->hashinfo = NDIS_HASH_FUNC_TOEPLITZ | NDIS_HASH_IPV4 |
                          NDIS_HASH_TCP_IPV4 | NDIS_HASH_IPV6 |
                          NDIS_HASH_TCP_IPV6;
@@ -829,9 +829,12 @@ int rndis_filter_set_rss_param(struct rndis_device *rdev,
 
         wait_for_completion(&request->wait_event);
         set_complete = &request->response_msg.msg.set_complete;
-        if (set_complete->status == RNDIS_STATUS_SUCCESS)
-                memcpy(rdev->rss_key, rss_key, NETVSC_HASH_KEYLEN);
-        else {
+        if (set_complete->status == RNDIS_STATUS_SUCCESS) {
+                if (!(flag & NDIS_RSS_PARAM_FLAG_DISABLE_RSS) &&
+                    !(flag & NDIS_RSS_PARAM_FLAG_HASH_KEY_UNCHANGED))
+                        memcpy(rdev->rss_key, rss_key, NETVSC_HASH_KEYLEN);
+
+        } else {
                 netdev_err(ndev, "Fail to set RSS parameters:0x%x\n",
                            set_complete->status);
                 ret = -EINVAL;
@@ -842,6 +845,16 @@ cleanup:
         return ret;
 }
 
+int rndis_filter_set_rss_param(struct rndis_device *rdev,
+                               const u8 *rss_key)
+{
+        /* Disable RSS before change */
+        rndis_set_rss_param_msg(rdev, rss_key,
+                                NDIS_RSS_PARAM_FLAG_DISABLE_RSS);
+
+        return rndis_set_rss_param_msg(rdev, rss_key, 0);
+}
+
 static int rndis_filter_query_device_link_status(struct rndis_device *dev,
                                                  struct netvsc_device *net_device)
 {
@@ -1121,7 +1134,9 @@ static void netvsc_sc_open(struct vmbus_channel *new_sc)
  * This breaks overlap of processing the host message for the
  * new primary channel with the initialization of sub-channels.
  */
-int rndis_set_subchannel(struct net_device *ndev, struct netvsc_device *nvdev)
+int rndis_set_subchannel(struct net_device *ndev,
+                         struct netvsc_device *nvdev,
+                         struct netvsc_device_info *dev_info)
 {
         struct nvsp_message *init_packet = &nvdev->channel_init_pkt;
         struct net_device_context *ndev_ctx = netdev_priv(ndev);
@@ -1161,8 +1176,11 @@ int rndis_set_subchannel(struct net_device *ndev, struct netvsc_device *nvdev)
         wait_event(nvdev->subchan_open,
                    atomic_read(&nvdev->open_chn) == nvdev->num_chn);
 
-        /* ignore failues from setting rss parameters, still have channels */
-        rndis_filter_set_rss_param(rdev, netvsc_hash_key);
+        /* ignore failures from setting rss parameters, still have channels */
+        if (dev_info)
+                rndis_filter_set_rss_param(rdev, dev_info->rss_key);
+        else
+                rndis_filter_set_rss_param(rdev, netvsc_hash_key);
 
         netif_set_real_num_tx_queues(ndev, nvdev->num_chn);
         netif_set_real_num_rx_queues(ndev, nvdev->num_chn);
diff --git a/drivers/net/macvlan.c b/drivers/net/macvlan.c
index fc726ce4c164..6d067176320f 100644
--- a/drivers/net/macvlan.c
+++ b/drivers/net/macvlan.c
@@ -337,7 +337,7 @@ static void macvlan_process_broadcast(struct work_struct *w)
 
                 if (src)
                         dev_put(src->dev);
-                kfree_skb(skb);
+                consume_skb(skb);
         }
 }
 
diff --git a/drivers/net/phy/asix.c b/drivers/net/phy/asix.c
index 8ebe7f5484ae..f14ba5366b91 100644
--- a/drivers/net/phy/asix.c
+++ b/drivers/net/phy/asix.c
@@ -1,13 +1,7 @@
-// SPDX-License-Identifier: GPL-2.0
+// SPDX-License-Identifier: GPL-2.0+
 /* Driver for Asix PHYs
  *
  * Author: Michael Schmitz <schmitzmic@gmail.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.
- *
  */
 #include <linux/kernel.h>
 #include <linux/errno.h>
diff --git a/drivers/net/phy/bcm87xx.c b/drivers/net/phy/bcm87xx.c
index 1b350183bffb..a271239748f2 100644
--- a/drivers/net/phy/bcm87xx.c
+++ b/drivers/net/phy/bcm87xx.c
@@ -197,6 +197,7 @@ static struct phy_driver bcm87xx_driver[] = {
         .phy_id         = PHY_ID_BCM8706,
         .phy_id_mask    = 0xffffffff,
         .name           = "Broadcom BCM8706",
+        .features       = PHY_10GBIT_FEC_FEATURES,
         .config_init    = bcm87xx_config_init,
         .config_aneg    = bcm87xx_config_aneg,
         .read_status    = bcm87xx_read_status,
@@ -208,6 +209,7 @@ static struct phy_driver bcm87xx_driver[] = {
         .phy_id         = PHY_ID_BCM8727,
         .phy_id_mask    = 0xffffffff,
         .name           = "Broadcom BCM8727",
+        .features       = PHY_10GBIT_FEC_FEATURES,
         .config_init    = bcm87xx_config_init,
         .config_aneg    = bcm87xx_config_aneg,
         .read_status    = bcm87xx_read_status,
diff --git a/drivers/net/phy/cortina.c b/drivers/net/phy/cortina.c
index 8022cd317f62..1a4d04afb7f0 100644
--- a/drivers/net/phy/cortina.c
+++ b/drivers/net/phy/cortina.c
@@ -88,6 +88,7 @@ static struct phy_driver cortina_driver[] = {
         .phy_id         = PHY_ID_CS4340,
         .phy_id_mask    = 0xffffffff,
         .name           = "Cortina CS4340",
+        .features       = PHY_10GBIT_FEATURES,
         .config_init    = gen10g_config_init,
         .config_aneg    = gen10g_config_aneg,
         .read_status    = cortina_read_status,
diff --git a/drivers/net/phy/marvell.c b/drivers/net/phy/marvell.c
index a9c7c7f41b0c..2e12f982534f 100644
--- a/drivers/net/phy/marvell.c
+++ b/drivers/net/phy/marvell.c
@@ -1046,6 +1046,39 @@ static int m88e1145_config_init(struct phy_device *phydev)
         return 0;
 }
 
+/* The VOD can be out of specification on link up. Poke an
+ * undocumented register, in an undocumented page, with a magic value
+ * to fix this.
+ */
+static int m88e6390_errata(struct phy_device *phydev)
+{
+        int err;
+
+        err = phy_write(phydev, MII_BMCR,
+                        BMCR_ANENABLE | BMCR_SPEED1000 | BMCR_FULLDPLX);
+        if (err)
+                return err;
+
+        usleep_range(300, 400);
+
+        err = phy_write_paged(phydev, 0xf8, 0x08, 0x36);
+        if (err)
+                return err;
+
+        return genphy_soft_reset(phydev);
+}
+
+static int m88e6390_config_aneg(struct phy_device *phydev)
+{
+        int err;
+
+        err = m88e6390_errata(phydev);
+        if (err)
+                return err;
+
+        return m88e1510_config_aneg(phydev);
+}
+
 /**
  * fiber_lpa_mod_linkmode_lpa_t
  * @advertising: the linkmode advertisement settings
@@ -1402,7 +1435,7 @@ static int m88e1318_set_wol(struct phy_device *phydev,
                  * before enabling it if !phy_interrupt_is_valid()
                  */
                 if (!phy_interrupt_is_valid(phydev))
-                        phy_read(phydev, MII_M1011_IEVENT);
+                        __phy_read(phydev, MII_M1011_IEVENT);
 
                 /* Enable the WOL interrupt */
                 err = __phy_modify(phydev, MII_88E1318S_PHY_CSIER, 0,
@@ -2283,7 +2316,7 @@ static struct phy_driver marvell_drivers[] = {
                 .features = PHY_GBIT_FEATURES,
                 .probe = m88e6390_probe,
                 .config_init = &marvell_config_init,
-                .config_aneg = &m88e1510_config_aneg,
+                .config_aneg = &m88e6390_config_aneg,
                 .read_status = &marvell_read_status,
                 .ack_interrupt = &marvell_ack_interrupt,
                 .config_intr = &marvell_config_intr,
diff --git a/drivers/net/phy/mdio-hisi-femac.c b/drivers/net/phy/mdio-hisi-femac.c
index b03fedd6c1d8..287f3ccf1da1 100644
--- a/drivers/net/phy/mdio-hisi-femac.c
+++ b/drivers/net/phy/mdio-hisi-femac.c
@@ -1,20 +1,8 @@
+// SPDX-License-Identifier: GPL-2.0+
 /*
  * Hisilicon Fast Ethernet MDIO Bus Driver
  *
  * Copyright (c) 2016 HiSilicon Technologies Co., Ltd.
- *
- * 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, see <http://www.gnu.org/licenses/>.
  */
 
 #include <linux/clk.h>
@@ -163,4 +151,4 @@ module_platform_driver(hisi_femac_mdio_driver);
 
 MODULE_DESCRIPTION("Hisilicon Fast Ethernet MAC MDIO interface driver");
 MODULE_AUTHOR("Dongpo Li <lidongpo@hisilicon.com>");
-MODULE_LICENSE("GPL v2");
+MODULE_LICENSE("GPL");
diff --git a/drivers/net/phy/mdio_bus.c b/drivers/net/phy/mdio_bus.c
index 2e59a8419b17..66b9cfe692fc 100644
--- a/drivers/net/phy/mdio_bus.c
+++ b/drivers/net/phy/mdio_bus.c
@@ -390,6 +390,7 @@ int __mdiobus_register(struct mii_bus *bus, struct module *owner)
         if (IS_ERR(gpiod)) {
                 dev_err(&bus->dev, "mii_bus %s couldn't get reset GPIO\n",
                         bus->id);
+                device_del(&bus->dev);
                 return PTR_ERR(gpiod);
         } else  if (gpiod) {
                 bus->reset_gpiod = gpiod;
diff --git a/drivers/net/phy/meson-gxl.c b/drivers/net/phy/meson-gxl.c
index b03bcf2c388a..3ddaf9595697 100644
--- a/drivers/net/phy/meson-gxl.c
+++ b/drivers/net/phy/meson-gxl.c
@@ -233,6 +233,7 @@ static struct phy_driver meson_gxl_phy[] = {
                 .name           = "Meson GXL Internal PHY",
                 .features       = PHY_BASIC_FEATURES,
                 .flags          = PHY_IS_INTERNAL,
+                .soft_reset     = genphy_soft_reset,
                 .config_init    = meson_gxl_config_init,
                 .aneg_done      = genphy_aneg_done,
                 .read_status    = meson_gxl_read_status,
diff --git a/drivers/net/phy/micrel.c b/drivers/net/phy/micrel.c
index c33384710d26..b1f959935f50 100644
--- a/drivers/net/phy/micrel.c
+++ b/drivers/net/phy/micrel.c
@@ -1070,6 +1070,7 @@ static struct phy_driver ksphy_driver[] = {
         .driver_data    = &ksz9021_type,
         .probe          = kszphy_probe,
         .config_init    = ksz9031_config_init,
+        .soft_reset     = genphy_soft_reset,
         .read_status    = ksz9031_read_status,
         .ack_interrupt  = kszphy_ack_interrupt,
         .config_intr    = kszphy_config_intr,
@@ -1098,6 +1099,7 @@ static struct phy_driver ksphy_driver[] = {
         .phy_id         = PHY_ID_KSZ8873MLL,
         .phy_id_mask    = MICREL_PHY_ID_MASK,
         .name           = "Micrel KSZ8873MLL Switch",
+        .features       = PHY_BASIC_FEATURES,
         .config_init    = kszphy_config_init,
         .config_aneg    = ksz8873mll_config_aneg,
         .read_status    = ksz8873mll_read_status,
diff --git a/drivers/net/phy/phy.c b/drivers/net/phy/phy.c
index d33e7b3caf03..189cd2048c3a 100644
--- a/drivers/net/phy/phy.c
+++ b/drivers/net/phy/phy.c
@@ -543,13 +543,6 @@ int phy_start_aneg(struct phy_device *phydev)
 
         mutex_lock(&phydev->lock);
 
-        if (!__phy_is_started(phydev)) {
-                WARN(1, "called from state %s\n",
-                     phy_state_to_str(phydev->state));
-                err = -EBUSY;
-                goto out_unlock;
-        }
-
         if (AUTONEG_DISABLE == phydev->autoneg)
                 phy_sanitize_settings(phydev);
 
@@ -560,11 +553,13 @@ int phy_start_aneg(struct phy_device *phydev)
         if (err < 0)
                 goto out_unlock;
 
-        if (phydev->autoneg == AUTONEG_ENABLE) {
-                err = phy_check_link_status(phydev);
-        } else {
-                phydev->state = PHY_FORCING;
-                phydev->link_timeout = PHY_FORCE_TIMEOUT;
+        if (__phy_is_started(phydev)) {
+                if (phydev->autoneg == AUTONEG_ENABLE) {
+                        err = phy_check_link_status(phydev);
+                } else {
+                        phydev->state = PHY_FORCING;
+                        phydev->link_timeout = PHY_FORCE_TIMEOUT;
+                }
         }
 
 out_unlock:
diff --git a/drivers/net/phy/phy_device.c b/drivers/net/phy/phy_device.c
index 51990002d495..46c86725a693 100644
--- a/drivers/net/phy/phy_device.c
+++ b/drivers/net/phy/phy_device.c
@@ -61,6 +61,9 @@ EXPORT_SYMBOL_GPL(phy_gbit_all_ports_features);
 __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_10gbit_features) __ro_after_init;
 EXPORT_SYMBOL_GPL(phy_10gbit_features);
 
+__ETHTOOL_DECLARE_LINK_MODE_MASK(phy_10gbit_fec_features) __ro_after_init;
+EXPORT_SYMBOL_GPL(phy_10gbit_fec_features);
+
 static const int phy_basic_ports_array[] = {
         ETHTOOL_LINK_MODE_Autoneg_BIT,
         ETHTOOL_LINK_MODE_TP_BIT,
@@ -109,6 +112,11 @@ const int phy_10gbit_features_array[1] = {
 };
 EXPORT_SYMBOL_GPL(phy_10gbit_features_array);
 
+const int phy_10gbit_fec_features_array[1] = {
+        ETHTOOL_LINK_MODE_10000baseR_FEC_BIT,
+};
+EXPORT_SYMBOL_GPL(phy_10gbit_fec_features_array);
+
 __ETHTOOL_DECLARE_LINK_MODE_MASK(phy_10gbit_full_features) __ro_after_init;
 EXPORT_SYMBOL_GPL(phy_10gbit_full_features);
 
@@ -191,6 +199,10 @@ static void features_init(void)
         linkmode_set_bit_array(phy_10gbit_full_features_array,
                                ARRAY_SIZE(phy_10gbit_full_features_array),
                                phy_10gbit_full_features);
+        /* 10G FEC only */
+        linkmode_set_bit_array(phy_10gbit_fec_features_array,
+                               ARRAY_SIZE(phy_10gbit_fec_features_array),
+                               phy_10gbit_fec_features);
 }
 
 void phy_device_free(struct phy_device *phydev)
@@ -2243,6 +2255,11 @@ int phy_driver_register(struct phy_driver *new_driver, struct module *owner)
 {
         int retval;
 
+        if (WARN_ON(!new_driver->features)) {
+                pr_err("%s: Driver features are missing\n", new_driver->name);
+                return -EINVAL;
+        }
+
         new_driver->mdiodrv.flags |= MDIO_DEVICE_IS_PHY;
         new_driver->mdiodrv.driver.name = new_driver->name;
         new_driver->mdiodrv.driver.bus = &mdio_bus_type;
diff --git a/drivers/net/phy/rockchip.c b/drivers/net/phy/rockchip.c
index f1da70b9b55f..95abf7072f32 100644
--- a/drivers/net/phy/rockchip.c
+++ b/drivers/net/phy/rockchip.c
@@ -1,3 +1,4 @@
+// SPDX-License-Identifier: GPL-2.0+
 /**
  * drivers/net/phy/rockchip.c
  *
@@ -6,12 +7,6 @@
  * Copyright (c) 2017, Fuzhou Rockchip Electronics Co., Ltd
  *
  * David Wu <david.wu@rock-chips.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.
- *
  */
 
 #include <linux/ethtool.h>
@@ -229,4 +224,4 @@ MODULE_DEVICE_TABLE(mdio, rockchip_phy_tbl);
 
 MODULE_AUTHOR("David Wu <david.wu@rock-chips.com>");
 MODULE_DESCRIPTION("Rockchip Ethernet PHY driver");
-MODULE_LICENSE("GPL v2");
+MODULE_LICENSE("GPL");
diff --git a/drivers/net/phy/teranetics.c b/drivers/net/phy/teranetics.c
index 22f3bdd8206c..91247182bc52 100644
--- a/drivers/net/phy/teranetics.c
+++ b/drivers/net/phy/teranetics.c
@@ -80,6 +80,7 @@ static struct phy_driver teranetics_driver[] = {
         .phy_id         = PHY_ID_TN2020,
         .phy_id_mask    = 0xffffffff,
         .name           = "Teranetics TN2020",
+        .features       = PHY_10GBIT_FEATURES,
         .soft_reset     = gen10g_no_soft_reset,
         .aneg_done      = teranetics_aneg_done,
         .config_init    = gen10g_config_init,
diff --git a/drivers/net/ppp/pppoe.c b/drivers/net/ppp/pppoe.c
index 62dc564b251d..f22639f0116a 100644
--- a/drivers/net/ppp/pppoe.c
+++ b/drivers/net/ppp/pppoe.c
@@ -445,6 +445,7 @@ static int pppoe_rcv(struct sk_buff *skb, struct net_device *dev,
         if (pskb_trim_rcsum(skb, len))
                 goto drop;
 
+        ph = pppoe_hdr(skb);
         pn = pppoe_pernet(dev_net(dev));
 
         /* Note that get_item does a sock_hold(), so sk_pppox(po)
diff --git a/drivers/net/tun.c b/drivers/net/tun.c
index a4fdad475594..18656c4094b3 100644
--- a/drivers/net/tun.c
+++ b/drivers/net/tun.c
@@ -856,10 +856,6 @@ static int tun_attach(struct tun_struct *tun, struct file *file,
                 err = 0;
         }
 
-        rcu_assign_pointer(tfile->tun, tun);
-        rcu_assign_pointer(tun->tfiles[tun->numqueues], tfile);
-        tun->numqueues++;
-
         if (tfile->detached) {
                 tun_enable_queue(tfile);
         } else {
@@ -876,6 +872,13 @@ static int tun_attach(struct tun_struct *tun, struct file *file,
          * refcnt.
          */
 
+        /* Publish tfile->tun and tun->tfiles only after we've fully
+         * initialized tfile; otherwise we risk using half-initialized
+         * object.
+         */
+        rcu_assign_pointer(tfile->tun, tun);
+        rcu_assign_pointer(tun->tfiles[tun->numqueues], tfile);
+        tun->numqueues++;
 out:
         return err;
 }
diff --git a/drivers/net/usb/aqc111.c b/drivers/net/usb/aqc111.c
index 57f1c94fca0b..820a2fe7d027 100644
--- a/drivers/net/usb/aqc111.c
+++ b/drivers/net/usb/aqc111.c
@@ -1287,6 +1287,20 @@ static const struct driver_info asix112_info = {
 
 #undef ASIX112_DESC
 
+static const struct driver_info trendnet_info = {
+        .description    = "USB-C 3.1 to 5GBASE-T Ethernet Adapter",
+        .bind           = aqc111_bind,
+        .unbind         = aqc111_unbind,
+        .status         = aqc111_status,
+        .link_reset     = aqc111_link_reset,
+        .reset          = aqc111_reset,
+        .stop           = aqc111_stop,
+        .flags          = FLAG_ETHER | FLAG_FRAMING_AX |
+                          FLAG_AVOID_UNLINK_URBS | FLAG_MULTI_PACKET,
+        .rx_fixup       = aqc111_rx_fixup,
+        .tx_fixup       = aqc111_tx_fixup,
+};
+
 static int aqc111_suspend(struct usb_interface *intf, pm_message_t message)
 {
         struct usbnet *dev = usb_get_intfdata(intf);
@@ -1440,6 +1454,7 @@ static const struct usb_device_id products[] = {
         {AQC111_USB_ETH_DEV(0x2eca, 0xc101, aqc111_info)},
         {AQC111_USB_ETH_DEV(0x0b95, 0x2790, asix111_info)},
         {AQC111_USB_ETH_DEV(0x0b95, 0x2791, asix112_info)},
+        {AQC111_USB_ETH_DEV(0x20f4, 0xe05a, trendnet_info)},
         { },/* END */
 };
 MODULE_DEVICE_TABLE(usb, products);
diff --git a/drivers/net/usb/asix_devices.c b/drivers/net/usb/asix_devices.c
index b654f05b2ccd..3d93993e74da 100644
--- a/drivers/net/usb/asix_devices.c
+++ b/drivers/net/usb/asix_devices.c
@@ -739,8 +739,13 @@ static int ax88772_bind(struct usbnet *dev, struct usb_interface *intf)
         asix_read_cmd(dev, AX_CMD_STATMNGSTS_REG, 0, 0, 1, &chipcode, 0);
         chipcode &= AX_CHIPCODE_MASK;
 
-        (chipcode == AX_AX88772_CHIPCODE) ? ax88772_hw_reset(dev, 0) :
-                                            ax88772a_hw_reset(dev, 0);
+        ret = (chipcode == AX_AX88772_CHIPCODE) ? ax88772_hw_reset(dev, 0) :
+                                                  ax88772a_hw_reset(dev, 0);
+
+        if (ret < 0) {
+                netdev_dbg(dev->net, "Failed to reset AX88772: %d\n", ret);
+                return ret;
+        }
 
         /* Read PHYID register *AFTER* the PHY was reset properly */
         phyid = asix_get_phyid(dev);
diff --git a/drivers/net/usb/cdc_ether.c b/drivers/net/usb/cdc_ether.c
index b3b3c05903a1..5512a1038721 100644
--- a/drivers/net/usb/cdc_ether.c
+++ b/drivers/net/usb/cdc_ether.c
@@ -179,10 +179,8 @@ int usbnet_generic_cdc_bind(struct usbnet *dev, struct usb_interface *intf)
          * probed with) and a slave/data interface; union
          * descriptors sort this all out.
          */
-        info->control = usb_ifnum_to_if(dev->udev,
-        info->u->bMasterInterface0);
-        info->data = usb_ifnum_to_if(dev->udev,
-                info->u->bSlaveInterface0);
+        info->control = usb_ifnum_to_if(dev->udev, info->u->bMasterInterface0);
+        info->data = usb_ifnum_to_if(dev->udev, info->u->bSlaveInterface0);
         if (!info->control || !info->data) {
                 dev_dbg(&intf->dev,
                         "master #%u/%p slave #%u/%p\n",
@@ -216,18 +214,16 @@ int usbnet_generic_cdc_bind(struct usbnet *dev, struct usb_interface *intf)
         /* a data interface altsetting does the real i/o */
         d = &info->data->cur_altsetting->desc;
         if (d->bInterfaceClass != USB_CLASS_CDC_DATA) {
-                dev_dbg(&intf->dev, "slave class %u\n",
-                        d->bInterfaceClass);
+                dev_dbg(&intf->dev, "slave class %u\n", d->bInterfaceClass);
                 goto bad_desc;
         }
 skip:
-        if (    rndis &&
-                header.usb_cdc_acm_descriptor &&
-                header.usb_cdc_acm_descriptor->bmCapabilities) {
-                        dev_dbg(&intf->dev,
-                                "ACM capabilities %02x, not really RNDIS?\n",
-                                header.usb_cdc_acm_descriptor->bmCapabilities);
-                        goto bad_desc;
+        if (rndis && header.usb_cdc_acm_descriptor &&
+            header.usb_cdc_acm_descriptor->bmCapabilities) {
+                dev_dbg(&intf->dev,
+                        "ACM capabilities %02x, not really RNDIS?\n",
+                        header.usb_cdc_acm_descriptor->bmCapabilities);
+                goto bad_desc;
         }
 
         if (header.usb_cdc_ether_desc && info->ether->wMaxSegmentSize) {
@@ -238,7 +234,7 @@ skip:
         }
 
         if (header.usb_cdc_mdlm_desc &&
-                memcmp(header.usb_cdc_mdlm_desc->bGUID, mbm_guid, 16)) {
+            memcmp(header.usb_cdc_mdlm_desc->bGUID, mbm_guid, 16)) {
                 dev_dbg(&intf->dev, "GUID doesn't match\n");
                 goto bad_desc;
         }
@@ -302,7 +298,7 @@ skip:
         if (info->control->cur_altsetting->desc.bNumEndpoints == 1) {
                 struct usb_endpoint_descriptor  *desc;
 
-                dev->status = &info->control->cur_altsetting->endpoint [0];
+                dev->status = &info->control->cur_altsetting->endpoint[0];
                 desc = &dev->status->desc;
                 if (!usb_endpoint_is_int_in(desc) ||
                     (le16_to_cpu(desc->wMaxPacketSize)
@@ -847,6 +843,14 @@ static const struct usb_device_id	products[] = {
         .driver_info = 0,
 },
 
+/* USB-C 3.1 to 5GBASE-T Ethernet Adapter (based on AQC111U) */
+{
+        USB_DEVICE_AND_INTERFACE_INFO(0x20f4, 0xe05a, USB_CLASS_COMM,
+                                      USB_CDC_SUBCLASS_ETHERNET,
+                                      USB_CDC_PROTO_NONE),
+        .driver_info = 0,
+},
+
 /* WHITELIST!!!
  *
  * CDC Ether uses two interfaces, not necessarily consecutive.
diff --git a/drivers/net/usb/qmi_wwan.c b/drivers/net/usb/qmi_wwan.c
index 774e1ff01c9a..735ad838e2ba 100644
--- a/drivers/net/usb/qmi_wwan.c
+++ b/drivers/net/usb/qmi_wwan.c
@@ -123,6 +123,7 @@ static void qmimux_setup(struct net_device *dev)
         dev->addr_len        = 0;
         dev->flags           = IFF_POINTOPOINT | IFF_NOARP | IFF_MULTICAST;
         dev->netdev_ops      = &qmimux_netdev_ops;
+        dev->mtu             = 1500;
         dev->needs_free_netdev = true;
 }
 
diff --git a/drivers/net/virtio_net.c b/drivers/net/virtio_net.c
index 023725086046..8fadd8eaf601 100644
--- a/drivers/net/virtio_net.c
+++ b/drivers/net/virtio_net.c
@@ -1330,7 +1330,7 @@ static int virtnet_receive(struct receive_queue *rq, int budget,
         return stats.packets;
 }
 
-static void free_old_xmit_skbs(struct send_queue *sq)
+static void free_old_xmit_skbs(struct send_queue *sq, bool in_napi)
 {
         struct sk_buff *skb;
         unsigned int len;
@@ -1343,7 +1343,7 @@ static void free_old_xmit_skbs(struct send_queue *sq)
                 bytes += skb->len;
                 packets++;
 
-                dev_consume_skb_any(skb);
+                napi_consume_skb(skb, in_napi);
         }
 
         /* Avoid overhead when no packets have been processed
@@ -1369,7 +1369,7 @@ static void virtnet_poll_cleantx(struct receive_queue *rq)
                 return;
 
         if (__netif_tx_trylock(txq)) {
-                free_old_xmit_skbs(sq);
+                free_old_xmit_skbs(sq, true);
                 __netif_tx_unlock(txq);
         }
 
@@ -1445,7 +1445,7 @@ static int virtnet_poll_tx(struct napi_struct *napi, int budget)
         struct netdev_queue *txq = netdev_get_tx_queue(vi->dev, vq2txq(sq->vq));
 
         __netif_tx_lock(txq, raw_smp_processor_id());
-        free_old_xmit_skbs(sq);
+        free_old_xmit_skbs(sq, true);
         __netif_tx_unlock(txq);
 
         virtqueue_napi_complete(napi, sq->vq, 0);
@@ -1514,7 +1514,7 @@ static netdev_tx_t start_xmit(struct sk_buff *skb, struct net_device *dev)
         bool use_napi = sq->napi.weight;
 
         /* Free up any pending old buffers before queueing new ones. */
-        free_old_xmit_skbs(sq);
+        free_old_xmit_skbs(sq, false);
 
         if (use_napi && kick)
                 virtqueue_enable_cb_delayed(sq->vq);
@@ -1557,7 +1557,7 @@ static netdev_tx_t start_xmit(struct sk_buff *skb, struct net_device *dev)
                 if (!use_napi &&
                     unlikely(!virtqueue_enable_cb_delayed(sq->vq))) {
                         /* More just got used, free them then recheck. */
-                        free_old_xmit_skbs(sq);
+                        free_old_xmit_skbs(sq, false);
                         if (sq->vq->num_free >= 2+MAX_SKB_FRAGS) {
                                 netif_start_subqueue(dev, qnum);
                                 virtqueue_disable_cb(sq->vq);
diff --git a/drivers/net/vmxnet3/vmxnet3_drv.c b/drivers/net/vmxnet3/vmxnet3_drv.c
index e454dfc9ad8f..89984fcab01e 100644
--- a/drivers/net/vmxnet3/vmxnet3_drv.c
+++ b/drivers/net/vmxnet3/vmxnet3_drv.c
@@ -535,8 +535,8 @@ vmxnet3_tq_create(struct vmxnet3_tx_queue *tq,
         }
 
         sz = tq->tx_ring.size * sizeof(tq->buf_info[0]);
-        tq->buf_info = dma_zalloc_coherent(&adapter->pdev->dev, sz,
-                                           &tq->buf_info_pa, GFP_KERNEL);
+        tq->buf_info = dma_alloc_coherent(&adapter->pdev->dev, sz,
+                                          &tq->buf_info_pa, GFP_KERNEL);
         if (!tq->buf_info)
                 goto err;
 
@@ -1815,8 +1815,8 @@ vmxnet3_rq_create(struct vmxnet3_rx_queue *rq, struct vmxnet3_adapter *adapter)
 
         sz = sizeof(struct vmxnet3_rx_buf_info) * (rq->rx_ring[0].size +
                                                    rq->rx_ring[1].size);
-        bi = dma_zalloc_coherent(&adapter->pdev->dev, sz, &rq->buf_info_pa,
-                                 GFP_KERNEL);
+        bi = dma_alloc_coherent(&adapter->pdev->dev, sz, &rq->buf_info_pa,
+                                GFP_KERNEL);
         if (!bi)
                 goto err;
 
diff --git a/drivers/net/wan/fsl_ucc_hdlc.c b/drivers/net/wan/fsl_ucc_hdlc.c
index 839fa7715709..66d889d54e58 100644
--- a/drivers/net/wan/fsl_ucc_hdlc.c
+++ b/drivers/net/wan/fsl_ucc_hdlc.c
@@ -279,10 +279,9 @@ static int uhdlc_init(struct ucc_hdlc_private *priv)
         iowrite16be(DEFAULT_HDLC_ADDR, &priv->ucc_pram->haddr4);
 
         /* Get BD buffer */
-        bd_buffer = dma_zalloc_coherent(priv->dev,
-                                        (RX_BD_RING_LEN + TX_BD_RING_LEN) *
-                                        MAX_RX_BUF_LENGTH,
-                                        &bd_dma_addr, GFP_KERNEL);
+        bd_buffer = dma_alloc_coherent(priv->dev,
+                                       (RX_BD_RING_LEN + TX_BD_RING_LEN) * MAX_RX_BUF_LENGTH,
+                                       &bd_dma_addr, GFP_KERNEL);
 
         if (!bd_buffer) {
                 dev_err(priv->dev, "Could not allocate buffer descriptors\n");
@@ -1057,6 +1056,54 @@ static const struct net_device_ops uhdlc_ops = {
         .ndo_tx_timeout = uhdlc_tx_timeout,
 };
 
+static int hdlc_map_iomem(char *name, int init_flag, void __iomem **ptr)
+{
+        struct device_node *np;
+        struct platform_device *pdev;
+        struct resource *res;
+        static int siram_init_flag;
+        int ret = 0;
+
+        np = of_find_compatible_node(NULL, NULL, name);
+        if (!np)
+                return -EINVAL;
+
+        pdev = of_find_device_by_node(np);
+        if (!pdev) {
+                pr_err("%pOFn: failed to lookup pdev\n", np);
+                of_node_put(np);
+                return -EINVAL;
+        }
+
+        of_node_put(np);
+        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                ret = -EINVAL;
+                goto error_put_device;
+        }
+        *ptr = ioremap(res->start, resource_size(res));
+        if (!*ptr) {
+                ret = -ENOMEM;
+                goto error_put_device;
+        }
+
+        /* We've remapped the addresses, and we don't need the device any
+         * more, so we should release it.
+         */
+        put_device(&pdev->dev);
+
+        if (init_flag && siram_init_flag == 0) {
+                memset_io(*ptr, 0, resource_size(res));
+                siram_init_flag = 1;
+        }
+        return  0;
+
+error_put_device:
+        put_device(&pdev->dev);
+
+        return ret;
+}
+
 static int ucc_hdlc_probe(struct platform_device *pdev)
 {
         struct device_node *np = pdev->dev.of_node;
@@ -1151,6 +1198,15 @@ static int ucc_hdlc_probe(struct platform_device *pdev)
                 ret = ucc_of_parse_tdm(np, utdm, ut_info);
                 if (ret)
                         goto free_utdm;
+
+                ret = hdlc_map_iomem("fsl,t1040-qe-si", 0,
+                                     (void __iomem **)&utdm->si_regs);
+                if (ret)
+                        goto free_utdm;
+                ret = hdlc_map_iomem("fsl,t1040-qe-siram", 1,
+                                     (void __iomem **)&utdm->siram);
+                if (ret)
+                        goto unmap_si_regs;
         }
 
         if (of_property_read_u16(np, "fsl,hmask", &uhdlc_priv->hmask))
@@ -1159,7 +1215,7 @@ static int ucc_hdlc_probe(struct platform_device *pdev)
         ret = uhdlc_init(uhdlc_priv);
         if (ret) {
                 dev_err(&pdev->dev, "Failed to init uhdlc\n");
-                goto free_utdm;
+                goto undo_uhdlc_init;
         }
 
         dev = alloc_hdlcdev(uhdlc_priv);
@@ -1188,6 +1244,9 @@ static int ucc_hdlc_probe(struct platform_device *pdev)
 free_dev:
         free_netdev(dev);
 undo_uhdlc_init:
+        iounmap(utdm->siram);
+unmap_si_regs:
+        iounmap(utdm->si_regs);
 free_utdm:
         if (uhdlc_priv->tsa)
                 kfree(utdm);
diff --git a/drivers/net/wireless/ath/ath10k/ce.c b/drivers/net/wireless/ath/ath10k/ce.c
index f6d3ecbdd3a3..2a5668b4f6bc 100644
--- a/drivers/net/wireless/ath/ath10k/ce.c
+++ b/drivers/net/wireless/ath/ath10k/ce.c
@@ -1553,10 +1553,9 @@ ath10k_ce_alloc_dest_ring(struct ath10k *ar, unsigned int ce_id,
          * coherent DMA are unsupported
          */
         dest_ring->base_addr_owner_space_unaligned =
-                dma_zalloc_coherent(ar->dev,
-                                    (nentries * sizeof(struct ce_desc) +
-                                     CE_DESC_RING_ALIGN),
-                                    &base_addr, GFP_KERNEL);
+                dma_alloc_coherent(ar->dev,
+                                   (nentries * sizeof(struct ce_desc) + CE_DESC_RING_ALIGN),
+                                   &base_addr, GFP_KERNEL);
         if (!dest_ring->base_addr_owner_space_unaligned) {
                 kfree(dest_ring);
                 return ERR_PTR(-ENOMEM);
diff --git a/drivers/net/wireless/ath/ath10k/mac.c b/drivers/net/wireless/ath/ath10k/mac.c
index e49b36752ba2..49758490eaba 100644
--- a/drivers/net/wireless/ath/ath10k/mac.c
+++ b/drivers/net/wireless/ath/ath10k/mac.c
@@ -5169,10 +5169,10 @@ static int ath10k_add_interface(struct ieee80211_hw *hw,
         if (vif->type == NL80211_IFTYPE_ADHOC ||
             vif->type == NL80211_IFTYPE_MESH_POINT ||
             vif->type == NL80211_IFTYPE_AP) {
-                arvif->beacon_buf = dma_zalloc_coherent(ar->dev,
-                                                        IEEE80211_MAX_FRAME_LEN,
-                                                        &arvif->beacon_paddr,
-                                                        GFP_ATOMIC);
+                arvif->beacon_buf = dma_alloc_coherent(ar->dev,
+                                                       IEEE80211_MAX_FRAME_LEN,
+                                                       &arvif->beacon_paddr,
+                                                       GFP_ATOMIC);
                 if (!arvif->beacon_buf) {
                         ret = -ENOMEM;
                         ath10k_warn(ar, "failed to allocate beacon buffer: %d\n",
diff --git a/drivers/net/wireless/ath/ath10k/pci.c b/drivers/net/wireless/ath/ath10k/pci.c
index 01b4edb00e9e..39e0b1cc2a12 100644
--- a/drivers/net/wireless/ath/ath10k/pci.c
+++ b/drivers/net/wireless/ath/ath10k/pci.c
@@ -936,8 +936,7 @@ static int ath10k_pci_diag_read_mem(struct ath10k *ar, u32 address, void *data,
          */
         alloc_nbytes = min_t(unsigned int, nbytes, DIAG_TRANSFER_LIMIT);
 
-        data_buf = (unsigned char *)dma_zalloc_coherent(ar->dev,
-                                                       alloc_nbytes,
+        data_buf = (unsigned char *)dma_alloc_coherent(ar->dev, alloc_nbytes,
                                                        &ce_data_base,
                                                        GFP_ATOMIC);
 
diff --git a/drivers/net/wireless/ath/ath10k/wmi.c b/drivers/net/wireless/ath/ath10k/wmi.c
index ba837403e266..8e236d158ca6 100644
--- a/drivers/net/wireless/ath/ath10k/wmi.c
+++ b/drivers/net/wireless/ath/ath10k/wmi.c
@@ -5193,7 +5193,7 @@ static int ath10k_wmi_alloc_chunk(struct ath10k *ar, u32 req_id,
         void *vaddr;
 
         pool_size = num_units * round_up(unit_len, 4);
-        vaddr = dma_zalloc_coherent(ar->dev, pool_size, &paddr, GFP_KERNEL);
+        vaddr = dma_alloc_coherent(ar->dev, pool_size, &paddr, GFP_KERNEL);
 
         if (!vaddr)
                 return -ENOMEM;
diff --git a/drivers/net/wireless/ath/wcn36xx/dxe.c b/drivers/net/wireless/ath/wcn36xx/dxe.c
index 5ab3e31c9ffa..bab30f7a443c 100644
--- a/drivers/net/wireless/ath/wcn36xx/dxe.c
+++ b/drivers/net/wireless/ath/wcn36xx/dxe.c
@@ -174,9 +174,8 @@ static int wcn36xx_dxe_init_descs(struct device *dev, struct wcn36xx_dxe_ch *wcn
         int i;
 
         size = wcn_ch->desc_num * sizeof(struct wcn36xx_dxe_desc);
-        wcn_ch->cpu_addr = dma_zalloc_coherent(dev, size,
-                                               &wcn_ch->dma_addr,
-                                               GFP_KERNEL);
+        wcn_ch->cpu_addr = dma_alloc_coherent(dev, size, &wcn_ch->dma_addr,
+                                              GFP_KERNEL);
         if (!wcn_ch->cpu_addr)
                 return -ENOMEM;
 
@@ -627,9 +626,9 @@ int wcn36xx_dxe_allocate_mem_pools(struct wcn36xx *wcn)
                 16 - (WCN36XX_BD_CHUNK_SIZE % 8);
 
         s = wcn->mgmt_mem_pool.chunk_size * WCN36XX_DXE_CH_DESC_NUMB_TX_H;
-        cpu_addr = dma_zalloc_coherent(wcn->dev, s,
-                                       &wcn->mgmt_mem_pool.phy_addr,
-                                       GFP_KERNEL);
+        cpu_addr = dma_alloc_coherent(wcn->dev, s,
+                                      &wcn->mgmt_mem_pool.phy_addr,
+                                      GFP_KERNEL);
         if (!cpu_addr)
                 goto out_err;
 
@@ -642,9 +641,9 @@ int wcn36xx_dxe_allocate_mem_pools(struct wcn36xx *wcn)
                 16 - (WCN36XX_BD_CHUNK_SIZE % 8);
 
         s = wcn->data_mem_pool.chunk_size * WCN36XX_DXE_CH_DESC_NUMB_TX_L;
-        cpu_addr = dma_zalloc_coherent(wcn->dev, s,
-                                       &wcn->data_mem_pool.phy_addr,
-                                       GFP_KERNEL);
+        cpu_addr = dma_alloc_coherent(wcn->dev, s,
+                                      &wcn->data_mem_pool.phy_addr,
+                                      GFP_KERNEL);
         if (!cpu_addr)
                 goto out_err;
 
diff --git a/drivers/net/wireless/ath/wil6210/txrx_edma.c b/drivers/net/wireless/ath/wil6210/txrx_edma.c
index 05a8348bd7b9..3380aaef456c 100644
--- a/drivers/net/wireless/ath/wil6210/txrx_edma.c
+++ b/drivers/net/wireless/ath/wil6210/txrx_edma.c
@@ -99,7 +99,7 @@ static int wil_sring_alloc(struct wil6210_priv *wil,
         /* Status messages are allocated and initialized to 0. This is necessary
          * since DR bit should be initialized to 0.
          */
-        sring->va = dma_zalloc_coherent(dev, sz, &sring->pa, GFP_KERNEL);
+        sring->va = dma_alloc_coherent(dev, sz, &sring->pa, GFP_KERNEL);
         if (!sring->va)
                 return -ENOMEM;
 
@@ -381,15 +381,15 @@ static int wil_ring_alloc_desc_ring(struct wil6210_priv *wil,
         if (!ring->ctx)
                 goto err;
 
-        ring->va = dma_zalloc_coherent(dev, sz, &ring->pa, GFP_KERNEL);
+        ring->va = dma_alloc_coherent(dev, sz, &ring->pa, GFP_KERNEL);
         if (!ring->va)
                 goto err_free_ctx;
 
         if (ring->is_rx) {
                 sz = sizeof(*ring->edma_rx_swtail.va);
                 ring->edma_rx_swtail.va =
-                        dma_zalloc_coherent(dev, sz, &ring->edma_rx_swtail.pa,
-                                            GFP_KERNEL);
+                        dma_alloc_coherent(dev, sz, &ring->edma_rx_swtail.pa,
+                                           GFP_KERNEL);
                 if (!ring->edma_rx_swtail.va)
                         goto err_free_va;
         }
diff --git a/drivers/net/wireless/broadcom/b43/dma.c b/drivers/net/wireless/broadcom/b43/dma.c
index dfc4c34298d4..b34e51933257 100644
--- a/drivers/net/wireless/broadcom/b43/dma.c
+++ b/drivers/net/wireless/broadcom/b43/dma.c
@@ -431,9 +431,9 @@ static int alloc_ringmemory(struct b43_dmaring *ring)
         u16 ring_mem_size = (ring->type == B43_DMA_64BIT) ?
                                 B43_DMA64_RINGMEMSIZE : B43_DMA32_RINGMEMSIZE;
 
-        ring->descbase = dma_zalloc_coherent(ring->dev->dev->dma_dev,
-                                             ring_mem_size, &(ring->dmabase),
-                                             GFP_KERNEL);
+        ring->descbase = dma_alloc_coherent(ring->dev->dev->dma_dev,
+                                            ring_mem_size, &(ring->dmabase),
+                                            GFP_KERNEL);
         if (!ring->descbase)
                 return -ENOMEM;
 
diff --git a/drivers/net/wireless/broadcom/b43legacy/dma.c b/drivers/net/wireless/broadcom/b43legacy/dma.c
index 1b1da7d83652..2ce1537d983c 100644
--- a/drivers/net/wireless/broadcom/b43legacy/dma.c
+++ b/drivers/net/wireless/broadcom/b43legacy/dma.c
@@ -331,9 +331,9 @@ void free_descriptor_buffer(struct b43legacy_dmaring *ring,
 static int alloc_ringmemory(struct b43legacy_dmaring *ring)
 {
         /* GFP flags must match the flags in free_ringmemory()! */
-        ring->descbase = dma_zalloc_coherent(ring->dev->dev->dma_dev,
-                                             B43legacy_DMA_RINGMEMSIZE,
-                                             &(ring->dmabase), GFP_KERNEL);
+        ring->descbase = dma_alloc_coherent(ring->dev->dev->dma_dev,
+                                            B43legacy_DMA_RINGMEMSIZE,
+                                            &(ring->dmabase), GFP_KERNEL);
         if (!ring->descbase)
                 return -ENOMEM;
 
diff --git a/drivers/net/wireless/broadcom/brcm80211/brcmfmac/pcie.c b/drivers/net/wireless/broadcom/brcm80211/brcmfmac/pcie.c
index 16d7dda965d8..0f69b3fa296e 100644
--- a/drivers/net/wireless/broadcom/brcm80211/brcmfmac/pcie.c
+++ b/drivers/net/wireless/broadcom/brcm80211/brcmfmac/pcie.c
@@ -1281,10 +1281,10 @@ static int brcmf_pcie_init_scratchbuffers(struct brcmf_pciedev_info *devinfo)
         u32 addr;
 
         devinfo->shared.scratch =
-                dma_zalloc_coherent(&devinfo->pdev->dev,
-                                        BRCMF_DMA_D2H_SCRATCH_BUF_LEN,
-                                        &devinfo->shared.scratch_dmahandle,
-                                        GFP_KERNEL);
+                dma_alloc_coherent(&devinfo->pdev->dev,
+                                   BRCMF_DMA_D2H_SCRATCH_BUF_LEN,
+                                   &devinfo->shared.scratch_dmahandle,
+                                   GFP_KERNEL);
         if (!devinfo->shared.scratch)
                 goto fail;
 
@@ -1298,10 +1298,10 @@ static int brcmf_pcie_init_scratchbuffers(struct brcmf_pciedev_info *devinfo)
         brcmf_pcie_write_tcm32(devinfo, addr, BRCMF_DMA_D2H_SCRATCH_BUF_LEN);
 
         devinfo->shared.ringupd =
-                dma_zalloc_coherent(&devinfo->pdev->dev,
-                                        BRCMF_DMA_D2H_RINGUPD_BUF_LEN,
-                                        &devinfo->shared.ringupd_dmahandle,
-                                        GFP_KERNEL);
+                dma_alloc_coherent(&devinfo->pdev->dev,
+                                   BRCMF_DMA_D2H_RINGUPD_BUF_LEN,
+                                   &devinfo->shared.ringupd_dmahandle,
+                                   GFP_KERNEL);
         if (!devinfo->shared.ringupd)
                 goto fail;
 
diff --git a/drivers/net/wireless/intel/iwlwifi/pcie/rx.c b/drivers/net/wireless/intel/iwlwifi/pcie/rx.c
index e965cc588850..9e850c25877b 100644
--- a/drivers/net/wireless/intel/iwlwifi/pcie/rx.c
+++ b/drivers/net/wireless/intel/iwlwifi/pcie/rx.c
@@ -711,30 +711,24 @@ static int iwl_pcie_alloc_rxq_dma(struct iwl_trans *trans,
          * Allocate the circular buffer of Read Buffer Descriptors
          * (RBDs)
          */
-        rxq->bd = dma_zalloc_coherent(dev,
-                                      free_size * rxq->queue_size,
-                                      &rxq->bd_dma, GFP_KERNEL);
+        rxq->bd = dma_alloc_coherent(dev, free_size * rxq->queue_size,
+                                     &rxq->bd_dma, GFP_KERNEL);
         if (!rxq->bd)
                 goto err;
 
         if (trans->cfg->mq_rx_supported) {
-                rxq->used_bd = dma_zalloc_coherent(dev,
-                                                   (use_rx_td ?
-                                                   sizeof(*rxq->cd) :
-                                                   sizeof(__le32)) *
-                                                   rxq->queue_size,
-                                                   &rxq->used_bd_dma,
-                                                   GFP_KERNEL);
+                rxq->used_bd = dma_alloc_coherent(dev,
+                                                  (use_rx_td ? sizeof(*rxq->cd) : sizeof(__le32)) * rxq->queue_size,
+                                                  &rxq->used_bd_dma,
+                                                  GFP_KERNEL);
                 if (!rxq->used_bd)
                         goto err;
         }
 
         /* Allocate the driver's pointer to receive buffer status */
-        rxq->rb_stts = dma_zalloc_coherent(dev, use_rx_td ?
-                                           sizeof(__le16) :
-                                           sizeof(struct iwl_rb_status),
-                                           &rxq->rb_stts_dma,
-                                           GFP_KERNEL);
+        rxq->rb_stts = dma_alloc_coherent(dev,
+                                          use_rx_td ? sizeof(__le16) : sizeof(struct iwl_rb_status),
+                                          &rxq->rb_stts_dma, GFP_KERNEL);
         if (!rxq->rb_stts)
                 goto err;
 
@@ -742,16 +736,14 @@ static int iwl_pcie_alloc_rxq_dma(struct iwl_trans *trans,
                 return 0;
 
         /* Allocate the driver's pointer to TR tail */
-        rxq->tr_tail = dma_zalloc_coherent(dev, sizeof(__le16),
-                                           &rxq->tr_tail_dma,
-                                           GFP_KERNEL);
+        rxq->tr_tail = dma_alloc_coherent(dev, sizeof(__le16),
+                                          &rxq->tr_tail_dma, GFP_KERNEL);
         if (!rxq->tr_tail)
                 goto err;
 
         /* Allocate the driver's pointer to CR tail */
-        rxq->cr_tail = dma_zalloc_coherent(dev, sizeof(__le16),
-                                           &rxq->cr_tail_dma,
-                                           GFP_KERNEL);
+        rxq->cr_tail = dma_alloc_coherent(dev, sizeof(__le16),
+                                          &rxq->cr_tail_dma, GFP_KERNEL);
         if (!rxq->cr_tail)
                 goto err;
         /*
@@ -1947,9 +1939,8 @@ int iwl_pcie_alloc_ict(struct iwl_trans *trans)
         struct iwl_trans_pcie *trans_pcie = IWL_TRANS_GET_PCIE_TRANS(trans);
 
         trans_pcie->ict_tbl =
-                dma_zalloc_coherent(trans->dev, ICT_SIZE,
-                                   &trans_pcie->ict_tbl_dma,
-                                   GFP_KERNEL);
+                dma_alloc_coherent(trans->dev, ICT_SIZE,
+                                   &trans_pcie->ict_tbl_dma, GFP_KERNEL);
         if (!trans_pcie->ict_tbl)
                 return -ENOMEM;
 
diff --git a/drivers/net/wireless/mac80211_hwsim.c b/drivers/net/wireless/mac80211_hwsim.c
index 3a4b8786f7ea..320edcac4699 100644
--- a/drivers/net/wireless/mac80211_hwsim.c
+++ b/drivers/net/wireless/mac80211_hwsim.c
@@ -2761,6 +2761,11 @@ static int mac80211_hwsim_new_radio(struct genl_info *info,
                                         BIT(NL80211_CHAN_WIDTH_160);
         }
 
+        if (!n_limits) {
+                err = -EINVAL;
+                goto failed_hw;
+        }
+
         data->if_combination.n_limits = n_limits;
         data->if_combination.max_interfaces = 2048;
         data->if_combination.limits = data->if_limits;
diff --git a/drivers/net/wireless/ralink/rt2x00/rt2x00mmio.c b/drivers/net/wireless/ralink/rt2x00/rt2x00mmio.c
index 528cb0401df1..4956a54151cb 100644
--- a/drivers/net/wireless/ralink/rt2x00/rt2x00mmio.c
+++ b/drivers/net/wireless/ralink/rt2x00/rt2x00mmio.c
@@ -119,9 +119,9 @@ static int rt2x00mmio_alloc_queue_dma(struct rt2x00_dev *rt2x00dev,
         /*
          * Allocate DMA memory for descriptor and buffer.
          */
-        addr = dma_zalloc_coherent(rt2x00dev->dev,
-                                   queue->limit * queue->desc_size, &dma,
-                                   GFP_KERNEL);
+        addr = dma_alloc_coherent(rt2x00dev->dev,
+                                  queue->limit * queue->desc_size, &dma,
+                                  GFP_KERNEL);
         if (!addr)
                 return -ENOMEM;
 
diff --git a/drivers/net/wireless/virt_wifi.c b/drivers/net/wireless/virt_wifi.c
index 64b218699656..3a93e4d9828b 100644
--- a/drivers/net/wireless/virt_wifi.c
+++ b/drivers/net/wireless/virt_wifi.c
@@ -530,8 +530,10 @@ static int virt_wifi_newlink(struct net *src_net, struct net_device *dev,
         SET_NETDEV_DEV(dev, &priv->lowerdev->dev);
         dev->ieee80211_ptr = kzalloc(sizeof(*dev->ieee80211_ptr), GFP_KERNEL);
 
-        if (!dev->ieee80211_ptr)
+        if (!dev->ieee80211_ptr) {
+                err = -ENOMEM;
                 goto remove_handler;
+        }
 
         dev->ieee80211_ptr->iftype = NL80211_IFTYPE_STATION;
         dev->ieee80211_ptr->wiphy = common_wiphy;
diff --git a/drivers/ntb/hw/mscc/ntb_hw_switchtec.c b/drivers/ntb/hw/mscc/ntb_hw_switchtec.c
index 5ee5f40b4dfc..f1eaa3c4d46a 100644
--- a/drivers/ntb/hw/mscc/ntb_hw_switchtec.c
+++ b/drivers/ntb/hw/mscc/ntb_hw_switchtec.c
@@ -1339,10 +1339,10 @@ static int switchtec_ntb_init_shared_mw(struct switchtec_ntb *sndev)
         int rc;
 
         sndev->nr_rsvd_luts++;
-        sndev->self_shared = dma_zalloc_coherent(&sndev->stdev->pdev->dev,
-                                                 LUT_SIZE,
-                                                 &sndev->self_shared_dma,
-                                                 GFP_KERNEL);
+        sndev->self_shared = dma_alloc_coherent(&sndev->stdev->pdev->dev,
+                                                LUT_SIZE,
+                                                &sndev->self_shared_dma,
+                                                GFP_KERNEL);
         if (!sndev->self_shared) {
                 dev_err(&sndev->stdev->dev,
                         "unable to allocate memory for shared mw\n");
diff --git a/drivers/nvdimm/dimm.c b/drivers/nvdimm/dimm.c
index 0cf58cabc9ed..3cf50274fadb 100644
--- a/drivers/nvdimm/dimm.c
+++ b/drivers/nvdimm/dimm.c
@@ -26,6 +26,12 @@ static int nvdimm_probe(struct device *dev)
         struct nvdimm_drvdata *ndd;
         int rc;
 
+        rc = nvdimm_security_setup_events(dev);
+        if (rc < 0) {
+                dev_err(dev, "security event setup failed: %d\n", rc);
+                return rc;
+        }
+
         rc = nvdimm_check_config_data(dev);
         if (rc) {
                 /* not required for non-aliased nvdimm, ex. NVDIMM-N */
diff --git a/drivers/nvdimm/dimm_devs.c b/drivers/nvdimm/dimm_devs.c
index 4890310df874..efe412a6b5b9 100644
--- a/drivers/nvdimm/dimm_devs.c
+++ b/drivers/nvdimm/dimm_devs.c
@@ -578,13 +578,25 @@ struct nvdimm *__nvdimm_create(struct nvdimm_bus *nvdimm_bus,
 }
 EXPORT_SYMBOL_GPL(__nvdimm_create);
 
-int nvdimm_security_setup_events(struct nvdimm *nvdimm)
+static void shutdown_security_notify(void *data)
 {
-        nvdimm->sec.overwrite_state = sysfs_get_dirent(nvdimm->dev.kobj.sd,
-                        "security");
+        struct nvdimm *nvdimm = data;
+
+        sysfs_put(nvdimm->sec.overwrite_state);
+}
+
+int nvdimm_security_setup_events(struct device *dev)
+{
+        struct nvdimm *nvdimm = to_nvdimm(dev);
+
+        if (nvdimm->sec.state < 0 || !nvdimm->sec.ops
+                        || !nvdimm->sec.ops->overwrite)
+                return 0;
+        nvdimm->sec.overwrite_state = sysfs_get_dirent(dev->kobj.sd, "security");
         if (!nvdimm->sec.overwrite_state)
-                return -ENODEV;
-        return 0;
+                return -ENOMEM;
+
+        return devm_add_action_or_reset(dev, shutdown_security_notify, nvdimm);
 }
 EXPORT_SYMBOL_GPL(nvdimm_security_setup_events);
 
diff --git a/drivers/nvdimm/nd-core.h b/drivers/nvdimm/nd-core.h
index 2b2cf4e554d3..e5ffd5733540 100644
--- a/drivers/nvdimm/nd-core.h
+++ b/drivers/nvdimm/nd-core.h
@@ -54,12 +54,12 @@ struct nvdimm {
 };
 
 static inline enum nvdimm_security_state nvdimm_security_state(
-                struct nvdimm *nvdimm, bool master)
+                struct nvdimm *nvdimm, enum nvdimm_passphrase_type ptype)
 {
         if (!nvdimm->sec.ops)
                 return -ENXIO;
 
-        return nvdimm->sec.ops->state(nvdimm, master);
+        return nvdimm->sec.ops->state(nvdimm, ptype);
 }
 int nvdimm_security_freeze(struct nvdimm *nvdimm);
 #if IS_ENABLED(CONFIG_NVDIMM_KEYS)
diff --git a/drivers/nvdimm/nd.h b/drivers/nvdimm/nd.h
index cfde992684e7..379bf4305e61 100644
--- a/drivers/nvdimm/nd.h
+++ b/drivers/nvdimm/nd.h
@@ -250,6 +250,7 @@ long nvdimm_clear_poison(struct device *dev, phys_addr_t phys,
 void nvdimm_set_aliasing(struct device *dev);
 void nvdimm_set_locked(struct device *dev);
 void nvdimm_clear_locked(struct device *dev);
+int nvdimm_security_setup_events(struct device *dev);
 #if IS_ENABLED(CONFIG_NVDIMM_KEYS)
 int nvdimm_security_unlock(struct device *dev);
 #else
diff --git a/drivers/nvme/host/core.c b/drivers/nvme/host/core.c
index 08f2c92602f4..150e49723c15 100644
--- a/drivers/nvme/host/core.c
+++ b/drivers/nvme/host/core.c
@@ -2173,18 +2173,20 @@ static void nvme_init_subnqn(struct nvme_subsystem *subsys, struct nvme_ctrl *ct
         size_t nqnlen;
         int off;
 
-        nqnlen = strnlen(id->subnqn, NVMF_NQN_SIZE);
-        if (nqnlen > 0 && nqnlen < NVMF_NQN_SIZE) {
-                strlcpy(subsys->subnqn, id->subnqn, NVMF_NQN_SIZE);
-                return;
-        }
+        if(!(ctrl->quirks & NVME_QUIRK_IGNORE_DEV_SUBNQN)) {
+                nqnlen = strnlen(id->subnqn, NVMF_NQN_SIZE);
+                if (nqnlen > 0 && nqnlen < NVMF_NQN_SIZE) {
+                        strlcpy(subsys->subnqn, id->subnqn, NVMF_NQN_SIZE);
+                        return;
+                }
 
-        if (ctrl->vs >= NVME_VS(1, 2, 1))
-                dev_warn(ctrl->device, "missing or invalid SUBNQN field.\n");
+                if (ctrl->vs >= NVME_VS(1, 2, 1))
+                        dev_warn(ctrl->device, "missing or invalid SUBNQN field.\n");
+        }
 
         /* Generate a "fake" NQN per Figure 254 in NVMe 1.3 + ECN 001 */
         off = snprintf(subsys->subnqn, NVMF_NQN_SIZE,
-                        "nqn.2014.08.org.nvmexpress:%4x%4x",
+                        "nqn.2014.08.org.nvmexpress:%04x%04x",
                         le16_to_cpu(id->vid), le16_to_cpu(id->ssvid));
         memcpy(subsys->subnqn + off, id->sn, sizeof(id->sn));
         off += sizeof(id->sn);
@@ -2500,7 +2502,6 @@ int nvme_init_identify(struct nvme_ctrl *ctrl)
         ctrl->oaes = le32_to_cpu(id->oaes);
         atomic_set(&ctrl->abort_limit, id->acl + 1);
         ctrl->vwc = id->vwc;
-        ctrl->cntlid = le16_to_cpup(&id->cntlid);
         if (id->mdts)
                 max_hw_sectors = 1 << (id->mdts + page_shift - 9);
         else
diff --git a/drivers/nvme/host/fabrics.c b/drivers/nvme/host/fabrics.c
index b2ab213f43de..3eb908c50e1a 100644
--- a/drivers/nvme/host/fabrics.c
+++ b/drivers/nvme/host/fabrics.c
@@ -874,6 +874,8 @@ static int nvmf_parse_options(struct nvmf_ctrl_options *opts,
         if (opts->discovery_nqn) {
                 opts->kato = 0;
                 opts->nr_io_queues = 0;
+                opts->nr_write_queues = 0;
+                opts->nr_poll_queues = 0;
                 opts->duplicate_connect = true;
         }
         if (ctrl_loss_tmo < 0)
diff --git a/drivers/nvme/host/multipath.c b/drivers/nvme/host/multipath.c
index 183ec17ba067..b9fff3b8ed1b 100644
--- a/drivers/nvme/host/multipath.c
+++ b/drivers/nvme/host/multipath.c
@@ -545,8 +545,7 @@ int nvme_mpath_init(struct nvme_ctrl *ctrl, struct nvme_id_ctrl *id)
         timer_setup(&ctrl->anatt_timer, nvme_anatt_timeout, 0);
         ctrl->ana_log_size = sizeof(struct nvme_ana_rsp_hdr) +
                 ctrl->nanagrpid * sizeof(struct nvme_ana_group_desc);
-        if (!(ctrl->anacap & (1 << 6)))
-                ctrl->ana_log_size += ctrl->max_namespaces * sizeof(__le32);
+        ctrl->ana_log_size += ctrl->max_namespaces * sizeof(__le32);
 
         if (ctrl->ana_log_size > ctrl->max_hw_sectors << SECTOR_SHIFT) {
                 dev_err(ctrl->device,
@@ -570,6 +569,7 @@ int nvme_mpath_init(struct nvme_ctrl *ctrl, struct nvme_id_ctrl *id)
         return 0;
 out_free_ana_log_buf:
         kfree(ctrl->ana_log_buf);
+        ctrl->ana_log_buf = NULL;
 out:
         return error;
 }
@@ -577,5 +577,6 @@ out:
 void nvme_mpath_uninit(struct nvme_ctrl *ctrl)
 {
         kfree(ctrl->ana_log_buf);
+        ctrl->ana_log_buf = NULL;
 }
 
diff --git a/drivers/nvme/host/nvme.h b/drivers/nvme/host/nvme.h
index 2b36ac922596..ab961bdeea89 100644
--- a/drivers/nvme/host/nvme.h
+++ b/drivers/nvme/host/nvme.h
@@ -90,6 +90,11 @@ enum nvme_quirks {
          * Set MEDIUM priority on SQ creation
          */
         NVME_QUIRK_MEDIUM_PRIO_SQ               = (1 << 7),
+
+        /*
+         * Ignore device provided subnqn.
+         */
+        NVME_QUIRK_IGNORE_DEV_SUBNQN            = (1 << 8),
 };
 
 /*
diff --git a/drivers/nvme/host/pci.c b/drivers/nvme/host/pci.c
index 5a0bf6a24d50..9bc585415d9b 100644
--- a/drivers/nvme/host/pci.c
+++ b/drivers/nvme/host/pci.c
@@ -95,6 +95,7 @@ struct nvme_dev;
 struct nvme_queue;
 
 static void nvme_dev_disable(struct nvme_dev *dev, bool shutdown);
+static bool __nvme_disable_io_queues(struct nvme_dev *dev, u8 opcode);
 
 /*
  * Represents an NVM Express device.  Each nvme_dev is a PCI function.
@@ -1019,9 +1020,11 @@ static void nvme_complete_cqes(struct nvme_queue *nvmeq, u16 start, u16 end)
 
 static inline void nvme_update_cq_head(struct nvme_queue *nvmeq)
 {
-        if (++nvmeq->cq_head == nvmeq->q_depth) {
+        if (nvmeq->cq_head == nvmeq->q_depth - 1) {
                 nvmeq->cq_head = 0;
                 nvmeq->cq_phase = !nvmeq->cq_phase;
+        } else {
+                nvmeq->cq_head++;
         }
 }
 
@@ -1420,6 +1423,14 @@ static int nvme_suspend_queue(struct nvme_queue *nvmeq)
         return 0;
 }
 
+static void nvme_suspend_io_queues(struct nvme_dev *dev)
+{
+        int i;
+
+        for (i = dev->ctrl.queue_count - 1; i > 0; i--)
+                nvme_suspend_queue(&dev->queues[i]);
+}
+
 static void nvme_disable_admin_queue(struct nvme_dev *dev, bool shutdown)
 {
         struct nvme_queue *nvmeq = &dev->queues[0];
@@ -1485,8 +1496,8 @@ static int nvme_alloc_queue(struct nvme_dev *dev, int qid, int depth)
         if (dev->ctrl.queue_count > qid)
                 return 0;
 
-        nvmeq->cqes = dma_zalloc_coherent(dev->dev, CQ_SIZE(depth),
-                                          &nvmeq->cq_dma_addr, GFP_KERNEL);
+        nvmeq->cqes = dma_alloc_coherent(dev->dev, CQ_SIZE(depth),
+                                         &nvmeq->cq_dma_addr, GFP_KERNEL);
         if (!nvmeq->cqes)
                 goto free_nvmeq;
 
@@ -1885,8 +1896,9 @@ static void nvme_free_host_mem(struct nvme_dev *dev)
                 struct nvme_host_mem_buf_desc *desc = &dev->host_mem_descs[i];
                 size_t size = le32_to_cpu(desc->size) * dev->ctrl.page_size;
 
-                dma_free_coherent(dev->dev, size, dev->host_mem_desc_bufs[i],
-                                le64_to_cpu(desc->addr));
+                dma_free_attrs(dev->dev, size, dev->host_mem_desc_bufs[i],
+                               le64_to_cpu(desc->addr),
+                               DMA_ATTR_NO_KERNEL_MAPPING | DMA_ATTR_NO_WARN);
         }
 
         kfree(dev->host_mem_desc_bufs);
@@ -1915,8 +1927,8 @@ static int __nvme_alloc_host_mem(struct nvme_dev *dev, u64 preferred,
         if (dev->ctrl.hmmaxd && dev->ctrl.hmmaxd < max_entries)
                 max_entries = dev->ctrl.hmmaxd;
 
-        descs = dma_zalloc_coherent(dev->dev, max_entries * sizeof(*descs),
-                        &descs_dma, GFP_KERNEL);
+        descs = dma_alloc_coherent(dev->dev, max_entries * sizeof(*descs),
+                                   &descs_dma, GFP_KERNEL);
         if (!descs)
                 goto out;
 
@@ -1952,8 +1964,9 @@ out_free_bufs:
         while (--i >= 0) {
                 size_t size = le32_to_cpu(descs[i].size) * dev->ctrl.page_size;
 
-                dma_free_coherent(dev->dev, size, bufs[i],
-                                le64_to_cpu(descs[i].addr));
+                dma_free_attrs(dev->dev, size, bufs[i],
+                               le64_to_cpu(descs[i].addr),
+                               DMA_ATTR_NO_KERNEL_MAPPING | DMA_ATTR_NO_WARN);
         }
 
         kfree(bufs);
@@ -2028,14 +2041,18 @@ static int nvme_setup_host_mem(struct nvme_dev *dev)
         return ret;
 }
 
+/* irq_queues covers admin queue */
 static void nvme_calc_io_queues(struct nvme_dev *dev, unsigned int irq_queues)
 {
         unsigned int this_w_queues = write_queues;
 
+        WARN_ON(!irq_queues);
+
         /*
-         * Setup read/write queue split
+         * Setup read/write queue split, assign admin queue one independent
+         * irq vector if irq_queues is > 1.
          */
-        if (irq_queues == 1) {
+        if (irq_queues <= 2) {
                 dev->io_queues[HCTX_TYPE_DEFAULT] = 1;
                 dev->io_queues[HCTX_TYPE_READ] = 0;
                 return;
@@ -2043,21 +2060,21 @@ static void nvme_calc_io_queues(struct nvme_dev *dev, unsigned int irq_queues)
 
         /*
          * If 'write_queues' is set, ensure it leaves room for at least
-         * one read queue
+         * one read queue and one admin queue
          */
         if (this_w_queues >= irq_queues)
-                this_w_queues = irq_queues - 1;
+                this_w_queues = irq_queues - 2;
 
         /*
          * If 'write_queues' is set to zero, reads and writes will share
          * a queue set.
          */
         if (!this_w_queues) {
-                dev->io_queues[HCTX_TYPE_DEFAULT] = irq_queues;
+                dev->io_queues[HCTX_TYPE_DEFAULT] = irq_queues - 1;
                 dev->io_queues[HCTX_TYPE_READ] = 0;
         } else {
                 dev->io_queues[HCTX_TYPE_DEFAULT] = this_w_queues;
-                dev->io_queues[HCTX_TYPE_READ] = irq_queues - this_w_queues;
+                dev->io_queues[HCTX_TYPE_READ] = irq_queues - this_w_queues - 1;
         }
 }
 
@@ -2082,7 +2099,7 @@ static int nvme_setup_irqs(struct nvme_dev *dev, unsigned int nr_io_queues)
                 this_p_queues = nr_io_queues - 1;
                 irq_queues = 1;
         } else {
-                irq_queues = nr_io_queues - this_p_queues;
+                irq_queues = nr_io_queues - this_p_queues + 1;
         }
         dev->io_queues[HCTX_TYPE_POLL] = this_p_queues;
 
@@ -2102,8 +2119,9 @@ static int nvme_setup_irqs(struct nvme_dev *dev, unsigned int nr_io_queues)
                  * If we got a failure and we're down to asking for just
                  * 1 + 1 queues, just ask for a single vector. We'll share
                  * that between the single IO queue and the admin queue.
+                 * Otherwise, we assign one independent vector to admin queue.
                  */
-                if (result >= 0 && irq_queues > 1)
+                if (irq_queues > 1)
                         irq_queues = irq_sets[0] + irq_sets[1] + 1;
 
                 result = pci_alloc_irq_vectors_affinity(pdev, irq_queues,
@@ -2132,6 +2150,12 @@ static int nvme_setup_irqs(struct nvme_dev *dev, unsigned int nr_io_queues)
         return result;
 }
 
+static void nvme_disable_io_queues(struct nvme_dev *dev)
+{
+        if (__nvme_disable_io_queues(dev, nvme_admin_delete_sq))
+                __nvme_disable_io_queues(dev, nvme_admin_delete_cq);
+}
+
 static int nvme_setup_io_queues(struct nvme_dev *dev)
 {
         struct nvme_queue *adminq = &dev->queues[0];
@@ -2168,6 +2192,7 @@ static int nvme_setup_io_queues(struct nvme_dev *dev)
         } while (1);
         adminq->q_db = dev->dbs;
 
+ retry:
         /* Deregister the admin queue's interrupt */
         pci_free_irq(pdev, 0, adminq);
 
@@ -2185,25 +2210,34 @@ static int nvme_setup_io_queues(struct nvme_dev *dev)
         result = max(result - 1, 1);
         dev->max_qid = result + dev->io_queues[HCTX_TYPE_POLL];
 
-        dev_info(dev->ctrl.device, "%d/%d/%d default/read/poll queues\n",
-                                        dev->io_queues[HCTX_TYPE_DEFAULT],
-                                        dev->io_queues[HCTX_TYPE_READ],
-                                        dev->io_queues[HCTX_TYPE_POLL]);
-
         /*
          * Should investigate if there's a performance win from allocating
          * more queues than interrupt vectors; it might allow the submission
          * path to scale better, even if the receive path is limited by the
          * number of interrupts.
          */
-
         result = queue_request_irq(adminq);
         if (result) {
                 adminq->cq_vector = -1;
                 return result;
         }
         set_bit(NVMEQ_ENABLED, &adminq->flags);
-        return nvme_create_io_queues(dev);
+
+        result = nvme_create_io_queues(dev);
+        if (result || dev->online_queues < 2)
+                return result;
+
+        if (dev->online_queues - 1 < dev->max_qid) {
+                nr_io_queues = dev->online_queues - 1;
+                nvme_disable_io_queues(dev);
+                nvme_suspend_io_queues(dev);
+                goto retry;
+        }
+        dev_info(dev->ctrl.device, "%d/%d/%d default/read/poll queues\n",
+                                        dev->io_queues[HCTX_TYPE_DEFAULT],
+                                        dev->io_queues[HCTX_TYPE_READ],
+                                        dev->io_queues[HCTX_TYPE_POLL]);
+        return 0;
 }
 
 static void nvme_del_queue_end(struct request *req, blk_status_t error)
@@ -2248,7 +2282,7 @@ static int nvme_delete_queue(struct nvme_queue *nvmeq, u8 opcode)
         return 0;
 }
 
-static bool nvme_disable_io_queues(struct nvme_dev *dev, u8 opcode)
+static bool __nvme_disable_io_queues(struct nvme_dev *dev, u8 opcode)
 {
         int nr_queues = dev->online_queues - 1, sent = 0;
         unsigned long timeout;
@@ -2294,7 +2328,6 @@ static int nvme_dev_add(struct nvme_dev *dev)
                 dev->tagset.nr_maps = 2; /* default + read */
                 if (dev->io_queues[HCTX_TYPE_POLL])
                         dev->tagset.nr_maps++;
-                dev->tagset.nr_maps = HCTX_MAX_TYPES;
                 dev->tagset.timeout = NVME_IO_TIMEOUT;
                 dev->tagset.numa_node = dev_to_node(dev->dev);
                 dev->tagset.queue_depth =
@@ -2410,7 +2443,6 @@ static void nvme_pci_disable(struct nvme_dev *dev)
 
 static void nvme_dev_disable(struct nvme_dev *dev, bool shutdown)
 {
-        int i;
         bool dead = true;
         struct pci_dev *pdev = to_pci_dev(dev->dev);
 
@@ -2437,13 +2469,11 @@ static void nvme_dev_disable(struct nvme_dev *dev, bool shutdown)
         nvme_stop_queues(&dev->ctrl);
 
         if (!dead && dev->ctrl.queue_count > 0) {
-                if (nvme_disable_io_queues(dev, nvme_admin_delete_sq))
-                        nvme_disable_io_queues(dev, nvme_admin_delete_cq);
+                nvme_disable_io_queues(dev);
                 nvme_disable_admin_queue(dev, shutdown);
         }
-        for (i = dev->ctrl.queue_count - 1; i >= 0; i--)
-                nvme_suspend_queue(&dev->queues[i]);
-
+        nvme_suspend_io_queues(dev);
+        nvme_suspend_queue(&dev->queues[0]);
         nvme_pci_disable(dev);
 
         blk_mq_tagset_busy_iter(&dev->tagset, nvme_cancel_request, &dev->ctrl);
@@ -2946,6 +2976,8 @@ static const struct pci_device_id nvme_id_table[] = {
         { PCI_VDEVICE(INTEL, 0xf1a5),   /* Intel 600P/P3100 */
                 .driver_data = NVME_QUIRK_NO_DEEPEST_PS |
                                 NVME_QUIRK_MEDIUM_PRIO_SQ },
+        { PCI_VDEVICE(INTEL, 0xf1a6),   /* Intel 760p/Pro 7600p */
+                .driver_data = NVME_QUIRK_IGNORE_DEV_SUBNQN, },
         { PCI_VDEVICE(INTEL, 0x5845),   /* Qemu emulated controller */
                 .driver_data = NVME_QUIRK_IDENTIFY_CNS, },
         { PCI_DEVICE(0x1bb1, 0x0100),   /* Seagate Nytro Flash Storage */
diff --git a/drivers/nvme/host/rdma.c b/drivers/nvme/host/rdma.c
index 0a2fd2949ad7..52abc3a6de12 100644
--- a/drivers/nvme/host/rdma.c
+++ b/drivers/nvme/host/rdma.c
@@ -119,6 +119,7 @@ struct nvme_rdma_ctrl {
 
         struct nvme_ctrl        ctrl;
         bool                    use_inline_data;
+        u32                     io_queues[HCTX_MAX_TYPES];
 };
 
 static inline struct nvme_rdma_ctrl *to_rdma_ctrl(struct nvme_ctrl *ctrl)
@@ -165,8 +166,8 @@ static inline int nvme_rdma_queue_idx(struct nvme_rdma_queue *queue)
 static bool nvme_rdma_poll_queue(struct nvme_rdma_queue *queue)
 {
         return nvme_rdma_queue_idx(queue) >
-                queue->ctrl->ctrl.opts->nr_io_queues +
-                queue->ctrl->ctrl.opts->nr_write_queues;
+                queue->ctrl->io_queues[HCTX_TYPE_DEFAULT] +
+                queue->ctrl->io_queues[HCTX_TYPE_READ];
 }
 
 static inline size_t nvme_rdma_inline_data_size(struct nvme_rdma_queue *queue)
@@ -661,8 +662,21 @@ static int nvme_rdma_alloc_io_queues(struct nvme_rdma_ctrl *ctrl)
         nr_io_queues = min_t(unsigned int, nr_io_queues,
                                 ibdev->num_comp_vectors);
 
-        nr_io_queues += min(opts->nr_write_queues, num_online_cpus());
-        nr_io_queues += min(opts->nr_poll_queues, num_online_cpus());
+        if (opts->nr_write_queues) {
+                ctrl->io_queues[HCTX_TYPE_DEFAULT] =
+                                min(opts->nr_write_queues, nr_io_queues);
+                nr_io_queues += ctrl->io_queues[HCTX_TYPE_DEFAULT];
+        } else {
+                ctrl->io_queues[HCTX_TYPE_DEFAULT] = nr_io_queues;
+        }
+
+        ctrl->io_queues[HCTX_TYPE_READ] = nr_io_queues;
+
+        if (opts->nr_poll_queues) {
+                ctrl->io_queues[HCTX_TYPE_POLL] =
+                        min(opts->nr_poll_queues, num_online_cpus());
+                nr_io_queues += ctrl->io_queues[HCTX_TYPE_POLL];
+        }
 
         ret = nvme_set_queue_count(&ctrl->ctrl, &nr_io_queues);
         if (ret)
@@ -1689,18 +1703,28 @@ static enum blk_eh_timer_return
 nvme_rdma_timeout(struct request *rq, bool reserved)
 {
         struct nvme_rdma_request *req = blk_mq_rq_to_pdu(rq);
+        struct nvme_rdma_queue *queue = req->queue;
+        struct nvme_rdma_ctrl *ctrl = queue->ctrl;
 
-        dev_warn(req->queue->ctrl->ctrl.device,
-                 "I/O %d QID %d timeout, reset controller\n",
-                 rq->tag, nvme_rdma_queue_idx(req->queue));
+        dev_warn(ctrl->ctrl.device, "I/O %d QID %d timeout\n",
+                 rq->tag, nvme_rdma_queue_idx(queue));
 
-        /* queue error recovery */
-        nvme_rdma_error_recovery(req->queue->ctrl);
+        if (ctrl->ctrl.state != NVME_CTRL_LIVE) {
+                /*
+                 * Teardown immediately if controller times out while starting
+                 * or we are already started error recovery. all outstanding
+                 * requests are completed on shutdown, so we return BLK_EH_DONE.
+                 */
+                flush_work(&ctrl->err_work);
+                nvme_rdma_teardown_io_queues(ctrl, false);
+                nvme_rdma_teardown_admin_queue(ctrl, false);
+                return BLK_EH_DONE;
+        }
 
-        /* fail with DNR on cmd timeout */
-        nvme_req(rq)->status = NVME_SC_ABORT_REQ | NVME_SC_DNR;
+        dev_warn(ctrl->ctrl.device, "starting error recovery\n");
+        nvme_rdma_error_recovery(ctrl);
 
-        return BLK_EH_DONE;
+        return BLK_EH_RESET_TIMER;
 }
 
 static blk_status_t nvme_rdma_queue_rq(struct blk_mq_hw_ctx *hctx,
@@ -1779,17 +1803,15 @@ static int nvme_rdma_map_queues(struct blk_mq_tag_set *set)
         struct nvme_rdma_ctrl *ctrl = set->driver_data;
 
         set->map[HCTX_TYPE_DEFAULT].queue_offset = 0;
-        set->map[HCTX_TYPE_READ].nr_queues = ctrl->ctrl.opts->nr_io_queues;
+        set->map[HCTX_TYPE_DEFAULT].nr_queues =
+                        ctrl->io_queues[HCTX_TYPE_DEFAULT];
+        set->map[HCTX_TYPE_READ].nr_queues = ctrl->io_queues[HCTX_TYPE_READ];
         if (ctrl->ctrl.opts->nr_write_queues) {
                 /* separate read/write queues */
-                set->map[HCTX_TYPE_DEFAULT].nr_queues =
-                                ctrl->ctrl.opts->nr_write_queues;
                 set->map[HCTX_TYPE_READ].queue_offset =
-                                ctrl->ctrl.opts->nr_write_queues;
+                                ctrl->io_queues[HCTX_TYPE_DEFAULT];
         } else {
                 /* mixed read/write queues */
-                set->map[HCTX_TYPE_DEFAULT].nr_queues =
-                                ctrl->ctrl.opts->nr_io_queues;
                 set->map[HCTX_TYPE_READ].queue_offset = 0;
         }
         blk_mq_rdma_map_queues(&set->map[HCTX_TYPE_DEFAULT],
@@ -1799,12 +1821,12 @@ static int nvme_rdma_map_queues(struct blk_mq_tag_set *set)
 
         if (ctrl->ctrl.opts->nr_poll_queues) {
                 set->map[HCTX_TYPE_POLL].nr_queues =
-                                ctrl->ctrl.opts->nr_poll_queues;
+                                ctrl->io_queues[HCTX_TYPE_POLL];
                 set->map[HCTX_TYPE_POLL].queue_offset =
-                                ctrl->ctrl.opts->nr_io_queues;
+                                ctrl->io_queues[HCTX_TYPE_DEFAULT];
                 if (ctrl->ctrl.opts->nr_write_queues)
                         set->map[HCTX_TYPE_POLL].queue_offset +=
-                                ctrl->ctrl.opts->nr_write_queues;
+                                ctrl->io_queues[HCTX_TYPE_READ];
                 blk_mq_map_queues(&set->map[HCTX_TYPE_POLL]);
         }
         return 0;
diff --git a/drivers/nvme/host/tcp.c b/drivers/nvme/host/tcp.c
index de174912445e..5f0a00425242 100644
--- a/drivers/nvme/host/tcp.c
+++ b/drivers/nvme/host/tcp.c
@@ -1565,8 +1565,7 @@ static void nvme_tcp_destroy_io_queues(struct nvme_ctrl *ctrl, bool remove)
 {
         nvme_tcp_stop_io_queues(ctrl);
         if (remove) {
-                if (ctrl->ops->flags & NVME_F_FABRICS)
-                        blk_cleanup_queue(ctrl->connect_q);
+                blk_cleanup_queue(ctrl->connect_q);
                 blk_mq_free_tag_set(ctrl->tagset);
         }
         nvme_tcp_free_io_queues(ctrl);
@@ -1587,12 +1586,10 @@ static int nvme_tcp_configure_io_queues(struct nvme_ctrl *ctrl, bool new)
                         goto out_free_io_queues;
                 }
 
-                if (ctrl->ops->flags & NVME_F_FABRICS) {
-                        ctrl->connect_q = blk_mq_init_queue(ctrl->tagset);
-                        if (IS_ERR(ctrl->connect_q)) {
-                                ret = PTR_ERR(ctrl->connect_q);
-                                goto out_free_tag_set;
-                        }
+                ctrl->connect_q = blk_mq_init_queue(ctrl->tagset);
+                if (IS_ERR(ctrl->connect_q)) {
+                        ret = PTR_ERR(ctrl->connect_q);
+                        goto out_free_tag_set;
                 }
         } else {
                 blk_mq_update_nr_hw_queues(ctrl->tagset,
@@ -1606,7 +1603,7 @@ static int nvme_tcp_configure_io_queues(struct nvme_ctrl *ctrl, bool new)
         return 0;
 
 out_cleanup_connect_q:
-        if (new && (ctrl->ops->flags & NVME_F_FABRICS))
+        if (new)
                 blk_cleanup_queue(ctrl->connect_q);
 out_free_tag_set:
         if (new)
@@ -1620,7 +1617,6 @@ static void nvme_tcp_destroy_admin_queue(struct nvme_ctrl *ctrl, bool remove)
 {
         nvme_tcp_stop_queue(ctrl, 0);
         if (remove) {
-                free_opal_dev(ctrl->opal_dev);
                 blk_cleanup_queue(ctrl->admin_q);
                 blk_mq_free_tag_set(ctrl->admin_tagset);
         }
@@ -1952,20 +1948,23 @@ nvme_tcp_timeout(struct request *rq, bool reserved)
         struct nvme_tcp_ctrl *ctrl = req->queue->ctrl;
         struct nvme_tcp_cmd_pdu *pdu = req->pdu;
 
-        dev_dbg(ctrl->ctrl.device,
+        dev_warn(ctrl->ctrl.device,
                 "queue %d: timeout request %#x type %d\n",
-                nvme_tcp_queue_id(req->queue), rq->tag,
-                pdu->hdr.type);
+                nvme_tcp_queue_id(req->queue), rq->tag, pdu->hdr.type);
 
         if (ctrl->ctrl.state != NVME_CTRL_LIVE) {
-                union nvme_result res = {};
-
-                nvme_req(rq)->flags |= NVME_REQ_CANCELLED;
-                nvme_end_request(rq, cpu_to_le16(NVME_SC_ABORT_REQ), res);
+                /*
+                 * Teardown immediately if controller times out while starting
+                 * or we are already started error recovery. all outstanding
+                 * requests are completed on shutdown, so we return BLK_EH_DONE.
+                 */
+                flush_work(&ctrl->err_work);
+                nvme_tcp_teardown_io_queues(&ctrl->ctrl, false);
+                nvme_tcp_teardown_admin_queue(&ctrl->ctrl, false);
                 return BLK_EH_DONE;
         }
 
-        /* queue error recovery */
+        dev_warn(ctrl->ctrl.device, "starting error recovery\n");
         nvme_tcp_error_recovery(&ctrl->ctrl);
 
         return BLK_EH_RESET_TIMER;
diff --git a/drivers/nvme/target/rdma.c b/drivers/nvme/target/rdma.c
index a8d23eb80192..a884e3a0e8af 100644
--- a/drivers/nvme/target/rdma.c
+++ b/drivers/nvme/target/rdma.c
@@ -139,6 +139,10 @@ static void nvmet_rdma_recv_done(struct ib_cq *cq, struct ib_wc *wc);
 static void nvmet_rdma_read_data_done(struct ib_cq *cq, struct ib_wc *wc);
 static void nvmet_rdma_qp_event(struct ib_event *event, void *priv);
 static void nvmet_rdma_queue_disconnect(struct nvmet_rdma_queue *queue);
+static void nvmet_rdma_free_rsp(struct nvmet_rdma_device *ndev,
+                                struct nvmet_rdma_rsp *r);
+static int nvmet_rdma_alloc_rsp(struct nvmet_rdma_device *ndev,
+                                struct nvmet_rdma_rsp *r);
 
 static const struct nvmet_fabrics_ops nvmet_rdma_ops;
 
@@ -182,9 +186,17 @@ nvmet_rdma_get_rsp(struct nvmet_rdma_queue *queue)
         spin_unlock_irqrestore(&queue->rsps_lock, flags);
 
         if (unlikely(!rsp)) {
-                rsp = kmalloc(sizeof(*rsp), GFP_KERNEL);
+                int ret;
+
+                rsp = kzalloc(sizeof(*rsp), GFP_KERNEL);
                 if (unlikely(!rsp))
                         return NULL;
+                ret = nvmet_rdma_alloc_rsp(queue->dev, rsp);
+                if (unlikely(ret)) {
+                        kfree(rsp);
+                        return NULL;
+                }
+
                 rsp->allocated = true;
         }
 
@@ -197,6 +209,7 @@ nvmet_rdma_put_rsp(struct nvmet_rdma_rsp *rsp)
         unsigned long flags;
 
         if (unlikely(rsp->allocated)) {
+                nvmet_rdma_free_rsp(rsp->queue->dev, rsp);
                 kfree(rsp);
                 return;
         }
diff --git a/drivers/nvme/target/tcp.c b/drivers/nvme/target/tcp.c
index 44b37b202e39..ad0df786fe93 100644
--- a/drivers/nvme/target/tcp.c
+++ b/drivers/nvme/target/tcp.c
@@ -1089,7 +1089,7 @@ out:
 
 static int nvmet_tcp_try_recv_one(struct nvmet_tcp_queue *queue)
 {
-        int result;
+        int result = 0;
 
         if (unlikely(queue->rcv_state == NVMET_TCP_RECV_ERR))
                 return 0;
diff --git a/drivers/of/dynamic.c b/drivers/of/dynamic.c
index a09c1c3cf831..49b16f76d78e 100644
--- a/drivers/of/dynamic.c
+++ b/drivers/of/dynamic.c
@@ -207,11 +207,8 @@ static void __of_attach_node(struct device_node *np)
 
         if (!of_node_check_flag(np, OF_OVERLAY)) {
                 np->name = __of_get_property(np, "name", NULL);
-                np->type = __of_get_property(np, "device_type", NULL);
                 if (!np->name)
                         np->name = "<NULL>";
-                if (!np->type)
-                        np->type = "<NULL>";
 
                 phandle = __of_get_property(np, "phandle", &sz);
                 if (!phandle)
diff --git a/drivers/of/fdt.c b/drivers/of/fdt.c
index 7099c652c6a5..9cc1461aac7d 100644
--- a/drivers/of/fdt.c
+++ b/drivers/of/fdt.c
@@ -314,12 +314,8 @@ static bool populate_node(const void *blob,
         populate_properties(blob, offset, mem, np, pathp, dryrun);
         if (!dryrun) {
                 np->name = of_get_property(np, "name", NULL);
-                np->type = of_get_property(np, "device_type", NULL);
-
                 if (!np->name)
                         np->name = "<NULL>";
-                if (!np->type)
-                        np->type = "<NULL>";
         }
 
         *pnp = np;
diff --git a/drivers/of/overlay.c b/drivers/of/overlay.c
index 2b5ac43a5690..c423e94baf0f 100644
--- a/drivers/of/overlay.c
+++ b/drivers/of/overlay.c
@@ -423,12 +423,9 @@ static int add_changeset_node(struct overlay_changeset *ovcs,
 
                 tchild->parent = target->np;
                 tchild->name = __of_get_property(node, "name", NULL);
-                tchild->type = __of_get_property(node, "device_type", NULL);
 
                 if (!tchild->name)
                         tchild->name = "<NULL>";
-                if (!tchild->type)
-                        tchild->type = "<NULL>";
 
                 /* ignore obsolete "linux,phandle" */
                 phandle = __of_get_property(node, "phandle", &size);
diff --git a/drivers/of/pdt.c b/drivers/of/pdt.c
index d3185063d369..7eda43c66c91 100644
--- a/drivers/of/pdt.c
+++ b/drivers/of/pdt.c
@@ -155,7 +155,6 @@ static struct device_node * __init of_pdt_create_node(phandle node,
         dp->parent = parent;
 
         dp->name = of_pdt_get_one_property(node, "name");
-        dp->type = of_pdt_get_one_property(node, "device_type");
         dp->phandle = node;
 
         dp->properties = of_pdt_build_prop_list(node);
diff --git a/drivers/of/property.c b/drivers/of/property.c
index 08430031bd28..8631efa1daa1 100644
--- a/drivers/of/property.c
+++ b/drivers/of/property.c
@@ -806,6 +806,7 @@ struct device_node *of_graph_get_remote_node(const struct device_node *node,
 
         if (!of_device_is_available(remote)) {
                 pr_debug("not available for remote node\n");
+                of_node_put(remote);
                 return NULL;
         }
 
diff --git a/drivers/opp/core.c b/drivers/opp/core.c
index e5507add8f04..18f1639dbc4a 100644
--- a/drivers/opp/core.c
+++ b/drivers/opp/core.c
@@ -988,11 +988,9 @@ void _opp_free(struct dev_pm_opp *opp)
         kfree(opp);
 }
 
-static void _opp_kref_release(struct kref *kref)
+static void _opp_kref_release(struct dev_pm_opp *opp,
+                              struct opp_table *opp_table)
 {
-        struct dev_pm_opp *opp = container_of(kref, struct dev_pm_opp, kref);
-        struct opp_table *opp_table = opp->opp_table;
-
         /*
          * Notify the changes in the availability of the operable
          * frequency/voltage list.
@@ -1002,7 +1000,22 @@ static void _opp_kref_release(struct kref *kref)
         opp_debug_remove_one(opp);
         list_del(&opp->node);
         kfree(opp);
+}
 
+static void _opp_kref_release_unlocked(struct kref *kref)
+{
+        struct dev_pm_opp *opp = container_of(kref, struct dev_pm_opp, kref);
+        struct opp_table *opp_table = opp->opp_table;
+
+        _opp_kref_release(opp, opp_table);
+}
+
+static void _opp_kref_release_locked(struct kref *kref)
+{
+        struct dev_pm_opp *opp = container_of(kref, struct dev_pm_opp, kref);
+        struct opp_table *opp_table = opp->opp_table;
+
+        _opp_kref_release(opp, opp_table);
         mutex_unlock(&opp_table->lock);
 }
 
@@ -1013,10 +1026,16 @@ void dev_pm_opp_get(struct dev_pm_opp *opp)
 
 void dev_pm_opp_put(struct dev_pm_opp *opp)
 {
-        kref_put_mutex(&opp->kref, _opp_kref_release, &opp->opp_table->lock);
+        kref_put_mutex(&opp->kref, _opp_kref_release_locked,
+                       &opp->opp_table->lock);
 }
 EXPORT_SYMBOL_GPL(dev_pm_opp_put);
 
+static void dev_pm_opp_put_unlocked(struct dev_pm_opp *opp)
+{
+        kref_put(&opp->kref, _opp_kref_release_unlocked);
+}
+
 /**
  * dev_pm_opp_remove()  - Remove an OPP from OPP table
  * @dev:        device for which we do this operation
@@ -1060,6 +1079,40 @@ void dev_pm_opp_remove(struct device *dev, unsigned long freq)
 }
 EXPORT_SYMBOL_GPL(dev_pm_opp_remove);
 
+/**
+ * dev_pm_opp_remove_all_dynamic() - Remove all dynamically created OPPs
+ * @dev:        device for which we do this operation
+ *
+ * This function removes all dynamically created OPPs from the opp table.
+ */
+void dev_pm_opp_remove_all_dynamic(struct device *dev)
+{
+        struct opp_table *opp_table;
+        struct dev_pm_opp *opp, *temp;
+        int count = 0;
+
+        opp_table = _find_opp_table(dev);
+        if (IS_ERR(opp_table))
+                return;
+
+        mutex_lock(&opp_table->lock);
+        list_for_each_entry_safe(opp, temp, &opp_table->opp_list, node) {
+                if (opp->dynamic) {
+                        dev_pm_opp_put_unlocked(opp);
+                        count++;
+                }
+        }
+        mutex_unlock(&opp_table->lock);
+
+        /* Drop the references taken by dev_pm_opp_add() */
+        while (count--)
+                dev_pm_opp_put_opp_table(opp_table);
+
+        /* Drop the reference taken by _find_opp_table() */
+        dev_pm_opp_put_opp_table(opp_table);
+}
+EXPORT_SYMBOL_GPL(dev_pm_opp_remove_all_dynamic);
+
 struct dev_pm_opp *_opp_allocate(struct opp_table *table)
 {
         struct dev_pm_opp *opp;
diff --git a/drivers/pci/Kconfig b/drivers/pci/Kconfig
index 4310c7a4212e..2ab92409210a 100644
--- a/drivers/pci/Kconfig
+++ b/drivers/pci/Kconfig
@@ -21,13 +21,14 @@ menuconfig PCI
           support for PCI-X and the foundations for PCI Express support.
           Say 'Y' here unless you know what you are doing.
 
+if PCI
+
 config PCI_DOMAINS
         bool
         depends on PCI
 
 config PCI_DOMAINS_GENERIC
         bool
-        depends on PCI
         select PCI_DOMAINS
 
 config PCI_SYSCALL
@@ -37,7 +38,6 @@ source "drivers/pci/pcie/Kconfig"
 
 config PCI_MSI
         bool "Message Signaled Interrupts (MSI and MSI-X)"
-        depends on PCI
         select GENERIC_MSI_IRQ
         help
            This allows device drivers to enable MSI (Message Signaled
@@ -59,7 +59,6 @@ config PCI_MSI_IRQ_DOMAIN
 config PCI_QUIRKS
         default y
         bool "Enable PCI quirk workarounds" if EXPERT
-        depends on PCI
         help
           This enables workarounds for various PCI chipset bugs/quirks.
           Disable this only if your target machine is unaffected by PCI
@@ -67,7 +66,7 @@ config PCI_QUIRKS
 
 config PCI_DEBUG
         bool "PCI Debugging"
-        depends on PCI && DEBUG_KERNEL
+        depends on DEBUG_KERNEL
         help
           Say Y here if you want the PCI core to produce a bunch of debug
           messages to the system log.  Select this if you are having a
@@ -77,7 +76,6 @@ config PCI_DEBUG
 
 config PCI_REALLOC_ENABLE_AUTO
         bool "Enable PCI resource re-allocation detection"
-        depends on PCI
         depends on PCI_IOV
         help
           Say Y here if you want the PCI core to detect if PCI resource
@@ -90,7 +88,6 @@ config PCI_REALLOC_ENABLE_AUTO
 
 config PCI_STUB
         tristate "PCI Stub driver"
-        depends on PCI
         help
           Say Y or M here if you want be able to reserve a PCI device
           when it is going to be assigned to a guest operating system.
@@ -99,7 +96,6 @@ config PCI_STUB
 
 config PCI_PF_STUB
         tristate "PCI PF Stub driver"
-        depends on PCI
         depends on PCI_IOV
         help
           Say Y or M here if you want to enable support for devices that
@@ -111,7 +107,7 @@ config PCI_PF_STUB
 
 config XEN_PCIDEV_FRONTEND
         tristate "Xen PCI Frontend"
-        depends on PCI && X86 && XEN
+        depends on X86 && XEN
         select PCI_XEN
         select XEN_XENBUS_FRONTEND
         default y
@@ -133,7 +129,6 @@ config PCI_BRIDGE_EMUL
 
 config PCI_IOV
         bool "PCI IOV support"
-        depends on PCI
         select PCI_ATS
         help
           I/O Virtualization is a PCI feature supported by some devices
@@ -144,7 +139,6 @@ config PCI_IOV
 
 config PCI_PRI
         bool "PCI PRI support"
-        depends on PCI
         select PCI_ATS
         help
           PRI is the PCI Page Request Interface. It allows PCI devices that are
@@ -154,7 +148,6 @@ config PCI_PRI
 
 config PCI_PASID
         bool "PCI PASID support"
-        depends on PCI
         select PCI_ATS
         help
           Process Address Space Identifiers (PASIDs) can be used by PCI devices
@@ -167,7 +160,7 @@ config PCI_PASID
 
 config PCI_P2PDMA
         bool "PCI peer-to-peer transfer support"
-        depends on PCI && ZONE_DEVICE
+        depends on ZONE_DEVICE
         select GENERIC_ALLOCATOR
         help
           Enableѕ drivers to do PCI peer-to-peer transactions to and from
@@ -184,12 +177,11 @@ config PCI_P2PDMA
 
 config PCI_LABEL
         def_bool y if (DMI || ACPI)
-        depends on PCI
         select NLS
 
 config PCI_HYPERV
         tristate "Hyper-V PCI Frontend"
-        depends on PCI && X86 && HYPERV && PCI_MSI && PCI_MSI_IRQ_DOMAIN && X86_64
+        depends on X86 && HYPERV && PCI_MSI && PCI_MSI_IRQ_DOMAIN && X86_64
         help
           The PCI device frontend driver allows the kernel to import arbitrary
           PCI devices from a PCI backend to support PCI driver domains.
@@ -198,3 +190,5 @@ source "drivers/pci/hotplug/Kconfig"
 source "drivers/pci/controller/Kconfig"
 source "drivers/pci/endpoint/Kconfig"
 source "drivers/pci/switch/Kconfig"
+
+endif
diff --git a/drivers/pci/controller/dwc/pci-meson.c b/drivers/pci/controller/dwc/pci-meson.c
index 241ebe0c4505..e35e9eaa50ee 100644
--- a/drivers/pci/controller/dwc/pci-meson.c
+++ b/drivers/pci/controller/dwc/pci-meson.c
@@ -8,6 +8,7 @@
 
 #include <linux/clk.h>
 #include <linux/delay.h>
+#include <linux/gpio/consumer.h>
 #include <linux/of_device.h>
 #include <linux/of_gpio.h>
 #include <linux/pci.h>
diff --git a/drivers/pci/controller/pcie-iproc-msi.c b/drivers/pci/controller/pcie-iproc-msi.c
index 9deb56989d72..cb3401a931f8 100644
--- a/drivers/pci/controller/pcie-iproc-msi.c
+++ b/drivers/pci/controller/pcie-iproc-msi.c
@@ -602,9 +602,9 @@ int iproc_msi_init(struct iproc_pcie *pcie, struct device_node *node)
         }
 
         /* Reserve memory for event queue and make sure memories are zeroed */
-        msi->eq_cpu = dma_zalloc_coherent(pcie->dev,
-                                          msi->nr_eq_region * EQ_MEM_REGION_SIZE,
-                                          &msi->eq_dma, GFP_KERNEL);
+        msi->eq_cpu = dma_alloc_coherent(pcie->dev,
+                                         msi->nr_eq_region * EQ_MEM_REGION_SIZE,
+                                         &msi->eq_dma, GFP_KERNEL);
         if (!msi->eq_cpu) {
                 ret = -ENOMEM;
                 goto free_irqs;
diff --git a/drivers/pci/msi.c b/drivers/pci/msi.c
index 7a1c8a09efa5..4c0b47867258 100644
--- a/drivers/pci/msi.c
+++ b/drivers/pci/msi.c
@@ -1168,7 +1168,8 @@ int pci_alloc_irq_vectors_affinity(struct pci_dev *dev, unsigned int min_vecs,
                                    const struct irq_affinity *affd)
 {
         static const struct irq_affinity msi_default_affd;
-        int vecs = -ENOSPC;
+        int msix_vecs = -ENOSPC;
+        int msi_vecs = -ENOSPC;
 
         if (flags & PCI_IRQ_AFFINITY) {
                 if (!affd)
@@ -1179,16 +1180,17 @@ int pci_alloc_irq_vectors_affinity(struct pci_dev *dev, unsigned int min_vecs,
         }
 
         if (flags & PCI_IRQ_MSIX) {
-                vecs = __pci_enable_msix_range(dev, NULL, min_vecs, max_vecs,
-                                affd);
-                if (vecs > 0)
-                        return vecs;
+                msix_vecs = __pci_enable_msix_range(dev, NULL, min_vecs,
+                                                    max_vecs, affd);
+                if (msix_vecs > 0)
+                        return msix_vecs;
         }
 
         if (flags & PCI_IRQ_MSI) {
-                vecs = __pci_enable_msi_range(dev, min_vecs, max_vecs, affd);
-                if (vecs > 0)
-                        return vecs;
+                msi_vecs = __pci_enable_msi_range(dev, min_vecs, max_vecs,
+                                                  affd);
+                if (msi_vecs > 0)
+                        return msi_vecs;
         }
 
         /* use legacy irq if allowed */
@@ -1199,7 +1201,9 @@ int pci_alloc_irq_vectors_affinity(struct pci_dev *dev, unsigned int min_vecs,
                 }
         }
 
-        return vecs;
+        if (msix_vecs == -ENOSPC)
+                return -ENOSPC;
+        return msi_vecs;
 }
 EXPORT_SYMBOL(pci_alloc_irq_vectors_affinity);
 
diff --git a/drivers/pci/pci.c b/drivers/pci/pci.c
index c9d8e3c837de..c25acace7d91 100644
--- a/drivers/pci/pci.c
+++ b/drivers/pci/pci.c
@@ -6195,7 +6195,8 @@ static int __init pci_setup(char *str)
                         } else if (!strncmp(str, "pcie_scan_all", 13)) {
                                 pci_add_flags(PCI_SCAN_ALL_PCIE_DEVS);
                         } else if (!strncmp(str, "disable_acs_redir=", 18)) {
-                                disable_acs_redir_param = str + 18;
+                                disable_acs_redir_param =
+                                        kstrdup(str + 18, GFP_KERNEL);
                         } else {
                                 printk(KERN_ERR "PCI: Unknown option `%s'\n",
                                                 str);
diff --git a/drivers/pci/switch/switchtec.c b/drivers/pci/switch/switchtec.c
index 6c5536d3d42a..e22766c79fe9 100644
--- a/drivers/pci/switch/switchtec.c
+++ b/drivers/pci/switch/switchtec.c
@@ -1373,10 +1373,10 @@ static int switchtec_init_pci(struct switchtec_dev *stdev,
         if (ioread32(&stdev->mmio_mrpc->dma_ver) == 0)
                 return 0;
 
-        stdev->dma_mrpc = dma_zalloc_coherent(&stdev->pdev->dev,
-                                              sizeof(*stdev->dma_mrpc),
-                                              &stdev->dma_mrpc_dma_addr,
-                                              GFP_KERNEL);
+        stdev->dma_mrpc = dma_alloc_coherent(&stdev->pdev->dev,
+                                             sizeof(*stdev->dma_mrpc),
+                                             &stdev->dma_mrpc_dma_addr,
+                                             GFP_KERNEL);
         if (stdev->dma_mrpc == NULL)
                 return -ENOMEM;
 
diff --git a/drivers/phy/marvell/phy-berlin-sata.c b/drivers/phy/marvell/phy-berlin-sata.c
index a91fc67fc4e0..d70ba9bc42d9 100644
--- a/drivers/phy/marvell/phy-berlin-sata.c
+++ b/drivers/phy/marvell/phy-berlin-sata.c
@@ -32,7 +32,7 @@
 
 /* register 0x01 */
 #define REF_FREF_SEL_25         BIT(0)
-#define PHY_MODE_SATA           (0x0 << 5)
+#define PHY_BERLIN_MODE_SATA    (0x0 << 5)
 
 /* register 0x02 */
 #define USE_MAX_PLL_RATE        BIT(12)
@@ -102,7 +102,8 @@ static int phy_berlin_sata_power_on(struct phy *phy)
 
         /* set PHY mode and ref freq to 25 MHz */
         phy_berlin_sata_reg_setbits(ctrl_reg, priv->phy_base, 0x01,
-                                    0x00ff, REF_FREF_SEL_25 | PHY_MODE_SATA);
+                                    0x00ff,
+                                    REF_FREF_SEL_25 | PHY_BERLIN_MODE_SATA);
 
         /* set PHY up to 6 Gbps */
         phy_berlin_sata_reg_setbits(ctrl_reg, priv->phy_base, 0x25,
diff --git a/drivers/phy/qualcomm/phy-ath79-usb.c b/drivers/phy/qualcomm/phy-ath79-usb.c
index 6fd6e07ab345..09a77e556ece 100644
--- a/drivers/phy/qualcomm/phy-ath79-usb.c
+++ b/drivers/phy/qualcomm/phy-ath79-usb.c
@@ -31,7 +31,7 @@ static int ath79_usb_phy_power_on(struct phy *phy)
 
         err = reset_control_deassert(priv->reset);
         if (err && priv->no_suspend_override)
-                reset_control_assert(priv->no_suspend_override);
+                reset_control_deassert(priv->no_suspend_override);
 
         return err;
 }
@@ -69,7 +69,7 @@ static int ath79_usb_phy_probe(struct platform_device *pdev)
         if (!priv)
                 return -ENOMEM;
 
-        priv->reset = devm_reset_control_get(&pdev->dev, "usb-phy");
+        priv->reset = devm_reset_control_get(&pdev->dev, "phy");
         if (IS_ERR(priv->reset))
                 return PTR_ERR(priv->reset);
 
diff --git a/drivers/phy/ti/Kconfig b/drivers/phy/ti/Kconfig
index f137e0107764..c4709ed7fb0e 100644
--- a/drivers/phy/ti/Kconfig
+++ b/drivers/phy/ti/Kconfig
@@ -82,6 +82,7 @@ config PHY_TI_GMII_SEL
         default y if TI_CPSW=y
         depends on TI_CPSW || COMPILE_TEST
         select GENERIC_PHY
+        select REGMAP
         default m
         help
           This driver supports configuring of the TI CPSW Port mode depending on
diff --git a/drivers/phy/ti/phy-gmii-sel.c b/drivers/phy/ti/phy-gmii-sel.c
index 77fdaa551977..a52c5bb35033 100644
--- a/drivers/phy/ti/phy-gmii-sel.c
+++ b/drivers/phy/ti/phy-gmii-sel.c
@@ -204,11 +204,11 @@ static struct phy *phy_gmii_sel_of_xlate(struct device *dev,
 
         if (args->args_count < 1)
                 return ERR_PTR(-EINVAL);
+        if (!priv || !priv->if_phys)
+                return ERR_PTR(-ENODEV);
         if (priv->soc_data->features & BIT(PHY_GMII_SEL_RMII_IO_CLK_EN) &&
             args->args_count < 2)
                 return ERR_PTR(-EINVAL);
-        if (!priv || !priv->if_phys)
-                return ERR_PTR(-ENODEV);
         if (phy_id > priv->soc_data->num_ports)
                 return ERR_PTR(-EINVAL);
         if (phy_id != priv->if_phys[phy_id - 1].id)
diff --git a/drivers/platform/x86/Kconfig b/drivers/platform/x86/Kconfig
index e3b62c2ee8d1..5e2109c54c7c 100644
--- a/drivers/platform/x86/Kconfig
+++ b/drivers/platform/x86/Kconfig
@@ -1009,7 +1009,7 @@ config INTEL_MFLD_THERMAL
 
 config INTEL_IPS
         tristate "Intel Intelligent Power Sharing"
-        depends on ACPI
+        depends on ACPI && PCI
         ---help---
           Intel Calpella platforms support dynamic power sharing between the
           CPU and GPU, maximizing performance in a given TDP.  This driver,
@@ -1135,7 +1135,7 @@ config SAMSUNG_Q10
 
 config APPLE_GMUX
         tristate "Apple Gmux Driver"
-        depends on ACPI
+        depends on ACPI && PCI
         depends on PNP
         depends on BACKLIGHT_CLASS_DEVICE
         depends on BACKLIGHT_APPLE=n || BACKLIGHT_APPLE
@@ -1174,7 +1174,7 @@ config INTEL_SMARTCONNECT
 
 config INTEL_PMC_IPC
         tristate "Intel PMC IPC Driver"
-        depends on ACPI
+        depends on ACPI && PCI
         ---help---
         This driver provides support for PMC control on some Intel platforms.
         The PMC is an ARC processor which defines IPC commands for communication
diff --git a/drivers/ptp/ptp_chardev.c b/drivers/ptp/ptp_chardev.c
index 797fab33bb98..7cbea796652a 100644
--- a/drivers/ptp/ptp_chardev.c
+++ b/drivers/ptp/ptp_chardev.c
@@ -224,7 +224,8 @@ long ptp_ioctl(struct posix_clock *pc, unsigned int cmd, unsigned long arg)
                         extoff = NULL;
                         break;
                 }
-                if (extoff->n_samples > PTP_MAX_SAMPLES) {
+                if (extoff->n_samples > PTP_MAX_SAMPLES
+                    || extoff->rsv[0] || extoff->rsv[1] || extoff->rsv[2]) {
                         err = -EINVAL;
                         break;
                 }
diff --git a/drivers/rapidio/devices/tsi721.c b/drivers/rapidio/devices/tsi721.c
index bb655854713d..b64c56c33c3b 100644
--- a/drivers/rapidio/devices/tsi721.c
+++ b/drivers/rapidio/devices/tsi721.c
@@ -1382,9 +1382,9 @@ static int tsi721_doorbell_init(struct tsi721_device *priv)
         INIT_WORK(&priv->idb_work, tsi721_db_dpc);
 
         /* Allocate buffer for inbound doorbells queue */
-        priv->idb_base = dma_zalloc_coherent(&priv->pdev->dev,
-                                IDB_QSIZE * TSI721_IDB_ENTRY_SIZE,
-                                &priv->idb_dma, GFP_KERNEL);
+        priv->idb_base = dma_alloc_coherent(&priv->pdev->dev,
+                                            IDB_QSIZE * TSI721_IDB_ENTRY_SIZE,
+                                            &priv->idb_dma, GFP_KERNEL);
         if (!priv->idb_base)
                 return -ENOMEM;
 
@@ -1447,9 +1447,9 @@ static int tsi721_bdma_maint_init(struct tsi721_device *priv)
         regs = priv->regs + TSI721_DMAC_BASE(TSI721_DMACH_MAINT);
 
         /* Allocate space for DMA descriptors */
-        bd_ptr = dma_zalloc_coherent(&priv->pdev->dev,
-                                        bd_num * sizeof(struct tsi721_dma_desc),
-                                        &bd_phys, GFP_KERNEL);
+        bd_ptr = dma_alloc_coherent(&priv->pdev->dev,
+                                    bd_num * sizeof(struct tsi721_dma_desc),
+                                    &bd_phys, GFP_KERNEL);
         if (!bd_ptr)
                 return -ENOMEM;
 
@@ -1464,7 +1464,7 @@ static int tsi721_bdma_maint_init(struct tsi721_device *priv)
         sts_size = (bd_num >= TSI721_DMA_MINSTSSZ) ?
                                         bd_num : TSI721_DMA_MINSTSSZ;
         sts_size = roundup_pow_of_two(sts_size);
-        sts_ptr = dma_zalloc_coherent(&priv->pdev->dev,
+        sts_ptr = dma_alloc_coherent(&priv->pdev->dev,
                                      sts_size * sizeof(struct tsi721_dma_sts),
                                      &sts_phys, GFP_KERNEL);
         if (!sts_ptr) {
@@ -1939,10 +1939,10 @@ static int tsi721_open_outb_mbox(struct rio_mport *mport, void *dev_id,
 
         /* Outbound message descriptor status FIFO allocation */
         priv->omsg_ring[mbox].sts_size = roundup_pow_of_two(entries + 1);
-        priv->omsg_ring[mbox].sts_base = dma_zalloc_coherent(&priv->pdev->dev,
-                        priv->omsg_ring[mbox].sts_size *
-                                                sizeof(struct tsi721_dma_sts),
-                        &priv->omsg_ring[mbox].sts_phys, GFP_KERNEL);
+        priv->omsg_ring[mbox].sts_base = dma_alloc_coherent(&priv->pdev->dev,
+                                                            priv->omsg_ring[mbox].sts_size * sizeof(struct tsi721_dma_sts),
+                                                            &priv->omsg_ring[mbox].sts_phys,
+                                                            GFP_KERNEL);
         if (priv->omsg_ring[mbox].sts_base == NULL) {
                 tsi_debug(OMSG, &priv->pdev->dev,
                         "ENOMEM for OB_MSG_%d status FIFO", mbox);
diff --git a/drivers/rapidio/devices/tsi721_dma.c b/drivers/rapidio/devices/tsi721_dma.c
index 006ea5a45020..7f5d4436f594 100644
--- a/drivers/rapidio/devices/tsi721_dma.c
+++ b/drivers/rapidio/devices/tsi721_dma.c
@@ -90,9 +90,9 @@ static int tsi721_bdma_ch_init(struct tsi721_bdma_chan *bdma_chan, int bd_num)
          * Allocate space for DMA descriptors
          * (add an extra element for link descriptor)
          */
-        bd_ptr = dma_zalloc_coherent(dev,
-                                (bd_num + 1) * sizeof(struct tsi721_dma_desc),
-                                &bd_phys, GFP_ATOMIC);
+        bd_ptr = dma_alloc_coherent(dev,
+                                    (bd_num + 1) * sizeof(struct tsi721_dma_desc),
+                                    &bd_phys, GFP_ATOMIC);
         if (!bd_ptr)
                 return -ENOMEM;
 
@@ -108,7 +108,7 @@ static int tsi721_bdma_ch_init(struct tsi721_bdma_chan *bdma_chan, int bd_num)
         sts_size = ((bd_num + 1) >= TSI721_DMA_MINSTSSZ) ?
                                         (bd_num + 1) : TSI721_DMA_MINSTSSZ;
         sts_size = roundup_pow_of_two(sts_size);
-        sts_ptr = dma_zalloc_coherent(dev,
+        sts_ptr = dma_alloc_coherent(dev,
                                      sts_size * sizeof(struct tsi721_dma_sts),
                                      &sts_phys, GFP_ATOMIC);
         if (!sts_ptr) {
diff --git a/drivers/remoteproc/remoteproc_virtio.c b/drivers/remoteproc/remoteproc_virtio.c
index 183fc42a510a..2d7cd344f3bf 100644
--- a/drivers/remoteproc/remoteproc_virtio.c
+++ b/drivers/remoteproc/remoteproc_virtio.c
@@ -153,10 +153,15 @@ static int rproc_virtio_find_vqs(struct virtio_device *vdev, unsigned int nvqs,
                                  const bool * ctx,
                                  struct irq_affinity *desc)
 {
-        int i, ret;
+        int i, ret, queue_idx = 0;
 
         for (i = 0; i < nvqs; ++i) {
-                vqs[i] = rp_find_vq(vdev, i, callbacks[i], names[i],
+                if (!names[i]) {
+                        vqs[i] = NULL;
+                        continue;
+                }
+
+                vqs[i] = rp_find_vq(vdev, queue_idx++, callbacks[i], names[i],
                                     ctx ? ctx[i] : false);
                 if (IS_ERR(vqs[i])) {
                         ret = PTR_ERR(vqs[i]);
diff --git a/drivers/reset/Kconfig b/drivers/reset/Kconfig
index c21da9fe51ec..2e01bd833ffd 100644
--- a/drivers/reset/Kconfig
+++ b/drivers/reset/Kconfig
@@ -109,7 +109,7 @@ config RESET_QCOM_PDC
 
 config RESET_SIMPLE
         bool "Simple Reset Controller Driver" if COMPILE_TEST
-        default ARCH_SOCFPGA || ARCH_STM32 || ARCH_STRATIX10 || ARCH_SUNXI || ARCH_ZX || ARCH_ASPEED
+        default ARCH_STM32 || ARCH_STRATIX10 || ARCH_SUNXI || ARCH_ZX || ARCH_ASPEED
         help
           This enables a simple reset controller driver for reset lines that
           that can be asserted and deasserted by toggling bits in a contiguous,
@@ -128,6 +128,14 @@ config RESET_STM32MP157
         help
           This enables the RCC reset controller driver for STM32 MPUs.
 
+config RESET_SOCFPGA
+        bool "SoCFPGA Reset Driver" if COMPILE_TEST && !ARCH_SOCFPGA
+        default ARCH_SOCFPGA
+        select RESET_SIMPLE
+        help
+          This enables the reset driver for the SoCFPGA ARMv7 platforms. This
+          driver gets initialized early during platform init calls.
+
 config RESET_SUNXI
         bool "Allwinner SoCs Reset Driver" if COMPILE_TEST && !ARCH_SUNXI
         default ARCH_SUNXI
@@ -163,15 +171,15 @@ config RESET_UNIPHIER
           Say Y if you want to control reset signals provided by System Control
           block, Media I/O block, Peripheral Block.
 
-config RESET_UNIPHIER_USB3
-        tristate "USB3 reset driver for UniPhier SoCs"
+config RESET_UNIPHIER_GLUE
+        tristate "Reset driver in glue layer for UniPhier SoCs"
         depends on (ARCH_UNIPHIER || COMPILE_TEST) && OF
         default ARCH_UNIPHIER
         select RESET_SIMPLE
         help
-          Support for the USB3 core reset on UniPhier SoCs.
-          Say Y if you want to control reset signals provided by
-          USB3 glue layer.
+          Support for peripheral core reset included in its own glue layer
+          on UniPhier SoCs. Say Y if you want to control reset signals
+          provided by the glue layer.
 
 config RESET_ZYNQ
         bool "ZYNQ Reset Driver" if COMPILE_TEST
diff --git a/drivers/reset/Makefile b/drivers/reset/Makefile
index d08e8b90046a..dc7874df78d9 100644
--- a/drivers/reset/Makefile
+++ b/drivers/reset/Makefile
@@ -19,10 +19,11 @@ obj-$(CONFIG_RESET_QCOM_AOSS) += reset-qcom-aoss.o
 obj-$(CONFIG_RESET_QCOM_PDC) += reset-qcom-pdc.o
 obj-$(CONFIG_RESET_SIMPLE) += reset-simple.o
 obj-$(CONFIG_RESET_STM32MP157) += reset-stm32mp1.o
+obj-$(CONFIG_RESET_SOCFPGA) += reset-socfpga.o
 obj-$(CONFIG_RESET_SUNXI) += reset-sunxi.o
 obj-$(CONFIG_RESET_TI_SCI) += reset-ti-sci.o
 obj-$(CONFIG_RESET_TI_SYSCON) += reset-ti-syscon.o
 obj-$(CONFIG_RESET_UNIPHIER) += reset-uniphier.o
-obj-$(CONFIG_RESET_UNIPHIER_USB3) += reset-uniphier-usb3.o
+obj-$(CONFIG_RESET_UNIPHIER_GLUE) += reset-uniphier-glue.o
 obj-$(CONFIG_RESET_ZYNQ) += reset-zynq.o
 
diff --git a/drivers/reset/core.c b/drivers/reset/core.c
index d1887c0ed5d3..9582efb70025 100644
--- a/drivers/reset/core.c
+++ b/drivers/reset/core.c
@@ -795,3 +795,45 @@ devm_reset_control_array_get(struct device *dev, bool shared, bool optional)
         return rstc;
 }
 EXPORT_SYMBOL_GPL(devm_reset_control_array_get);
+
+static int reset_control_get_count_from_lookup(struct device *dev)
+{
+        const struct reset_control_lookup *lookup;
+        const char *dev_id;
+        int count = 0;
+
+        if (!dev)
+                return -EINVAL;
+
+        dev_id = dev_name(dev);
+        mutex_lock(&reset_lookup_mutex);
+
+        list_for_each_entry(lookup, &reset_lookup_list, list) {
+                if (!strcmp(lookup->dev_id, dev_id))
+                        count++;
+        }
+
+        mutex_unlock(&reset_lookup_mutex);
+
+        if (count == 0)
+                count = -ENOENT;
+
+        return count;
+}
+
+/**
+ * reset_control_get_count - Count number of resets available with a device
+ *
+ * @dev: device for which to return the number of resets
+ *
+ * Returns positive reset count on success, or error number on failure and
+ * on count being zero.
+ */
+int reset_control_get_count(struct device *dev)
+{
+        if (dev->of_node)
+                return of_reset_control_get_count(dev->of_node);
+
+        return reset_control_get_count_from_lookup(dev);
+}
+EXPORT_SYMBOL_GPL(reset_control_get_count);
diff --git a/drivers/reset/reset-hsdk.c b/drivers/reset/reset-hsdk.c
index 8bce391c6943..4c7b8647b49c 100644
--- a/drivers/reset/reset-hsdk.c
+++ b/drivers/reset/reset-hsdk.c
@@ -86,6 +86,7 @@ static int hsdk_reset_reset(struct reset_controller_dev *rcdev,
 
 static const struct reset_control_ops hsdk_reset_ops = {
         .reset  = hsdk_reset_reset,
+        .deassert = hsdk_reset_reset,
 };
 
 static int hsdk_reset_probe(struct platform_device *pdev)
diff --git a/drivers/reset/reset-simple.c b/drivers/reset/reset-simple.c
index a91107fc9e27..77fbba3100c8 100644
--- a/drivers/reset/reset-simple.c
+++ b/drivers/reset/reset-simple.c
@@ -109,7 +109,7 @@ struct reset_simple_devdata {
 #define SOCFPGA_NR_BANKS        8
 
 static const struct reset_simple_devdata reset_simple_socfpga = {
-        .reg_offset = 0x10,
+        .reg_offset = 0x20,
         .nr_resets = SOCFPGA_NR_BANKS * 32,
         .status_active_low = true,
 };
@@ -120,7 +120,8 @@ static const struct reset_simple_devdata reset_simple_active_low = {
 };
 
 static const struct of_device_id reset_simple_dt_ids[] = {
-        { .compatible = "altr,rst-mgr", .data = &reset_simple_socfpga },
+        { .compatible = "altr,stratix10-rst-mgr",
+                .data = &reset_simple_socfpga },
         { .compatible = "st,stm32-rcc", },
         { .compatible = "allwinner,sun6i-a31-clock-reset",
                 .data = &reset_simple_active_low },
@@ -166,14 +167,6 @@ static int reset_simple_probe(struct platform_device *pdev)
                 data->status_active_low = devdata->status_active_low;
         }
 
-        if (of_device_is_compatible(dev->of_node, "altr,rst-mgr") &&
-            of_property_read_u32(dev->of_node, "altr,modrst-offset",
-                                 &reg_offset)) {
-                dev_warn(dev,
-                         "missing altr,modrst-offset property, assuming 0x%x!\n",
-                         reg_offset);
-        }
-
         data->membase += reg_offset;
 
         return devm_reset_controller_register(dev, &data->rcdev);
diff --git a/drivers/reset/reset-socfpga.c b/drivers/reset/reset-socfpga.c
new file mode 100644
index 000000000000..318cfc51c441
--- /dev/null
+++ b/drivers/reset/reset-socfpga.c
@@ -0,0 +1,88 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * Copyright (C) 2018, Intel Corporation
+ * Copied from reset-sunxi.c
+ */
+
+#include <linux/err.h>
+#include <linux/io.h>
+#include <linux/init.h>
+#include <linux/of.h>
+#include <linux/of_address.h>
+#include <linux/platform_device.h>
+#include <linux/reset-controller.h>
+#include <linux/slab.h>
+#include <linux/spinlock.h>
+#include <linux/types.h>
+
+#include "reset-simple.h"
+
+#define SOCFPGA_NR_BANKS        8
+void __init socfpga_reset_init(void);
+
+static int a10_reset_init(struct device_node *np)
+{
+        struct reset_simple_data *data;
+        struct resource res;
+        resource_size_t size;
+        int ret;
+        u32 reg_offset = 0x10;
+
+        data = kzalloc(sizeof(*data), GFP_KERNEL);
+        if (!data)
+                return -ENOMEM;
+
+        ret = of_address_to_resource(np, 0, &res);
+        if (ret)
+                goto err_alloc;
+
+        size = resource_size(&res);
+        if (!request_mem_region(res.start, size, np->name)) {
+                ret = -EBUSY;
+                goto err_alloc;
+        }
+
+        data->membase = ioremap(res.start, size);
+        if (!data->membase) {
+                ret = -ENOMEM;
+                goto err_alloc;
+        }
+
+        if (of_property_read_u32(np, "altr,modrst-offset", &reg_offset))
+                pr_warn("missing altr,modrst-offset property, assuming 0x10\n");
+        data->membase += reg_offset;
+
+        spin_lock_init(&data->lock);
+
+        data->rcdev.owner = THIS_MODULE;
+        data->rcdev.nr_resets = SOCFPGA_NR_BANKS * 32;
+        data->rcdev.ops = &reset_simple_ops;
+        data->rcdev.of_node = np;
+        data->status_active_low = true;
+
+        return reset_controller_register(&data->rcdev);
+
+err_alloc:
+        kfree(data);
+        return ret;
+};
+
+/*
+ * These are the reset controller we need to initialize early on in
+ * our system, before we can even think of using a regular device
+ * driver for it.
+ * The controllers that we can register through the regular device
+ * model are handled by the simple reset driver directly.
+ */
+static const struct of_device_id socfpga_early_reset_dt_ids[] __initconst = {
+        { .compatible = "altr,rst-mgr", },
+        { /* sentinel */ },
+};
+
+void __init socfpga_reset_init(void)
+{
+        struct device_node *np;
+
+        for_each_matching_node(np, socfpga_early_reset_dt_ids)
+                a10_reset_init(np);
+}
diff --git a/drivers/reset/reset-uniphier-usb3.c b/drivers/reset/reset-uniphier-glue.c
index ffa1b19b594d..a45923f4df6d 100644
--- a/drivers/reset/reset-uniphier-usb3.c
+++ b/drivers/reset/reset-uniphier-glue.c
@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: GPL-2.0
 //
-// reset-uniphier-usb3.c - USB3 reset driver for UniPhier
+// reset-uniphier-glue.c - Glue layer reset driver for UniPhier
 // Copyright 2018 Socionext Inc.
 // Author: Kunihiko Hayashi <hayashi.kunihiko@socionext.com>
 
@@ -15,24 +15,24 @@
 #define MAX_CLKS        2
 #define MAX_RSTS        2
 
-struct uniphier_usb3_reset_soc_data {
+struct uniphier_glue_reset_soc_data {
         int nclks;
         const char * const *clock_names;
         int nrsts;
         const char * const *reset_names;
 };
 
-struct uniphier_usb3_reset_priv {
+struct uniphier_glue_reset_priv {
         struct clk_bulk_data clk[MAX_CLKS];
         struct reset_control *rst[MAX_RSTS];
         struct reset_simple_data rdata;
-        const struct uniphier_usb3_reset_soc_data *data;
+        const struct uniphier_glue_reset_soc_data *data;
 };
 
-static int uniphier_usb3_reset_probe(struct platform_device *pdev)
+static int uniphier_glue_reset_probe(struct platform_device *pdev)
 {
         struct device *dev = &pdev->dev;
-        struct uniphier_usb3_reset_priv *priv;
+        struct uniphier_glue_reset_priv *priv;
         struct resource *res;
         resource_size_t size;
         const char *name;
@@ -100,9 +100,9 @@ out_rst_assert:
         return ret;
 }
 
-static int uniphier_usb3_reset_remove(struct platform_device *pdev)
+static int uniphier_glue_reset_remove(struct platform_device *pdev)
 {
-        struct uniphier_usb3_reset_priv *priv = platform_get_drvdata(pdev);
+        struct uniphier_glue_reset_priv *priv = platform_get_drvdata(pdev);
         int i;
 
         for (i = 0; i < priv->data->nrsts; i++)
@@ -117,7 +117,7 @@ static const char * const uniphier_pro4_clock_reset_names[] = {
         "gio", "link",
 };
 
-static const struct uniphier_usb3_reset_soc_data uniphier_pro4_data = {
+static const struct uniphier_glue_reset_soc_data uniphier_pro4_data = {
         .nclks = ARRAY_SIZE(uniphier_pro4_clock_reset_names),
         .clock_names = uniphier_pro4_clock_reset_names,
         .nrsts = ARRAY_SIZE(uniphier_pro4_clock_reset_names),
@@ -128,14 +128,14 @@ static const char * const uniphier_pxs2_clock_reset_names[] = {
         "link",
 };
 
-static const struct uniphier_usb3_reset_soc_data uniphier_pxs2_data = {
+static const struct uniphier_glue_reset_soc_data uniphier_pxs2_data = {
         .nclks = ARRAY_SIZE(uniphier_pxs2_clock_reset_names),
         .clock_names = uniphier_pxs2_clock_reset_names,
         .nrsts = ARRAY_SIZE(uniphier_pxs2_clock_reset_names),
         .reset_names = uniphier_pxs2_clock_reset_names,
 };
 
-static const struct of_device_id uniphier_usb3_reset_match[] = {
+static const struct of_device_id uniphier_glue_reset_match[] = {
         {
                 .compatible = "socionext,uniphier-pro4-usb3-reset",
                 .data = &uniphier_pro4_data,
@@ -152,20 +152,32 @@ static const struct of_device_id uniphier_usb3_reset_match[] = {
                 .compatible = "socionext,uniphier-pxs3-usb3-reset",
                 .data = &uniphier_pxs2_data,
         },
+        {
+                .compatible = "socionext,uniphier-pro4-ahci-reset",
+                .data = &uniphier_pro4_data,
+        },
+        {
+                .compatible = "socionext,uniphier-pxs2-ahci-reset",
+                .data = &uniphier_pxs2_data,
+        },
+        {
+                .compatible = "socionext,uniphier-pxs3-ahci-reset",
+                .data = &uniphier_pxs2_data,
+        },
         { /* Sentinel */ }
 };
-MODULE_DEVICE_TABLE(of, uniphier_usb3_reset_match);
+MODULE_DEVICE_TABLE(of, uniphier_glue_reset_match);
 
-static struct platform_driver uniphier_usb3_reset_driver = {
-        .probe = uniphier_usb3_reset_probe,
-        .remove = uniphier_usb3_reset_remove,
+static struct platform_driver uniphier_glue_reset_driver = {
+        .probe = uniphier_glue_reset_probe,
+        .remove = uniphier_glue_reset_remove,
         .driver = {
-                .name = "uniphier-usb3-reset",
-                .of_match_table = uniphier_usb3_reset_match,
+                .name = "uniphier-glue-reset",
+                .of_match_table = uniphier_glue_reset_match,
         },
 };
-module_platform_driver(uniphier_usb3_reset_driver);
+module_platform_driver(uniphier_glue_reset_driver);
 
 MODULE_AUTHOR("Kunihiko Hayashi <hayashi.kunihiko@socionext.com>");
-MODULE_DESCRIPTION("UniPhier USB3 Reset Driver");
+MODULE_DESCRIPTION("UniPhier Glue layer reset driver");
 MODULE_LICENSE("GPL");
diff --git a/drivers/s390/char/sclp_config.c b/drivers/s390/char/sclp_config.c
index 194ffd5c8580..039b2074db7e 100644
--- a/drivers/s390/char/sclp_config.c
+++ b/drivers/s390/char/sclp_config.c
@@ -60,7 +60,9 @@ static void sclp_cpu_capability_notify(struct work_struct *work)
 
 static void __ref sclp_cpu_change_notify(struct work_struct *work)
 {
+        lock_device_hotplug();
         smp_rescan_cpus();
+        unlock_device_hotplug();
 }
 
 static void sclp_conf_receiver_fn(struct evbuf_header *evbuf)
diff --git a/drivers/s390/net/ism_drv.c b/drivers/s390/net/ism_drv.c
index dcbf5c857743..ed8e58f09054 100644
--- a/drivers/s390/net/ism_drv.c
+++ b/drivers/s390/net/ism_drv.c
@@ -89,8 +89,8 @@ static int register_sba(struct ism_dev *ism)
         dma_addr_t dma_handle;
         struct ism_sba *sba;
 
-        sba = dma_zalloc_coherent(&ism->pdev->dev, PAGE_SIZE,
-                                  &dma_handle, GFP_KERNEL);
+        sba = dma_alloc_coherent(&ism->pdev->dev, PAGE_SIZE, &dma_handle,
+                                 GFP_KERNEL);
         if (!sba)
                 return -ENOMEM;
 
@@ -116,8 +116,8 @@ static int register_ieq(struct ism_dev *ism)
         dma_addr_t dma_handle;
         struct ism_eq *ieq;
 
-        ieq = dma_zalloc_coherent(&ism->pdev->dev, PAGE_SIZE,
-                                  &dma_handle, GFP_KERNEL);
+        ieq = dma_alloc_coherent(&ism->pdev->dev, PAGE_SIZE, &dma_handle,
+                                 GFP_KERNEL);
         if (!ieq)
                 return -ENOMEM;
 
@@ -234,10 +234,9 @@ static int ism_alloc_dmb(struct ism_dev *ism, struct smcd_dmb *dmb)
             test_and_set_bit(dmb->sba_idx, ism->sba_bitmap))
                 return -EINVAL;
 
-        dmb->cpu_addr = dma_zalloc_coherent(&ism->pdev->dev, dmb->dmb_len,
-                                            &dmb->dma_addr, GFP_KERNEL |
-                                            __GFP_NOWARN | __GFP_NOMEMALLOC |
-                                            __GFP_COMP | __GFP_NORETRY);
+        dmb->cpu_addr = dma_alloc_coherent(&ism->pdev->dev, dmb->dmb_len,
+                                           &dmb->dma_addr,
+                                           GFP_KERNEL | __GFP_NOWARN | __GFP_NOMEMALLOC | __GFP_COMP | __GFP_NORETRY);
         if (!dmb->cpu_addr)
                 clear_bit(dmb->sba_idx, ism->sba_bitmap);
 
diff --git a/drivers/s390/virtio/virtio_ccw.c b/drivers/s390/virtio/virtio_ccw.c
index fc9dbad476c0..ae1d56da671d 100644
--- a/drivers/s390/virtio/virtio_ccw.c
+++ b/drivers/s390/virtio/virtio_ccw.c
@@ -635,7 +635,7 @@ static int virtio_ccw_find_vqs(struct virtio_device *vdev, unsigned nvqs,
 {
         struct virtio_ccw_device *vcdev = to_vc_device(vdev);
         unsigned long *indicatorp = NULL;
-        int ret, i;
+        int ret, i, queue_idx = 0;
         struct ccw1 *ccw;
 
         ccw = kzalloc(sizeof(*ccw), GFP_DMA | GFP_KERNEL);
@@ -643,8 +643,14 @@ static int virtio_ccw_find_vqs(struct virtio_device *vdev, unsigned nvqs,
                 return -ENOMEM;
 
         for (i = 0; i < nvqs; ++i) {
-                vqs[i] = virtio_ccw_setup_vq(vdev, i, callbacks[i], names[i],
-                                             ctx ? ctx[i] : false, ccw);
+                if (!names[i]) {
+                        vqs[i] = NULL;
+                        continue;
+                }
+
+                vqs[i] = virtio_ccw_setup_vq(vdev, queue_idx++, callbacks[i],
+                                             names[i], ctx ? ctx[i] : false,
+                                             ccw);
                 if (IS_ERR(vqs[i])) {
                         ret = PTR_ERR(vqs[i]);
                         vqs[i] = NULL;
diff --git a/drivers/scsi/3w-sas.c b/drivers/scsi/3w-sas.c
index e8f5f7c63190..cd096104bcec 100644
--- a/drivers/scsi/3w-sas.c
+++ b/drivers/scsi/3w-sas.c
@@ -646,8 +646,9 @@ static int twl_allocate_memory(TW_Device_Extension *tw_dev, int size, int which)
         unsigned long *cpu_addr;
         int retval = 1;
 
-        cpu_addr = dma_zalloc_coherent(&tw_dev->tw_pci_dev->dev,
-                        size * TW_Q_LENGTH, &dma_handle, GFP_KERNEL);
+        cpu_addr = dma_alloc_coherent(&tw_dev->tw_pci_dev->dev,
+                                      size * TW_Q_LENGTH, &dma_handle,
+                                      GFP_KERNEL);
         if (!cpu_addr) {
                 TW_PRINTK(tw_dev->host, TW_DRIVER, 0x5, "Memory allocation failed");
                 goto out;
diff --git a/drivers/scsi/a100u2w.c b/drivers/scsi/a100u2w.c
index ff53fd0d12f2..66c514310f3c 100644
--- a/drivers/scsi/a100u2w.c
+++ b/drivers/scsi/a100u2w.c
@@ -1123,8 +1123,8 @@ static int inia100_probe_one(struct pci_dev *pdev,
 
         /* Get total memory needed for SCB */
         sz = ORC_MAXQUEUE * sizeof(struct orc_scb);
-        host->scb_virt = dma_zalloc_coherent(&pdev->dev, sz, &host->scb_phys,
-                                             GFP_KERNEL);
+        host->scb_virt = dma_alloc_coherent(&pdev->dev, sz, &host->scb_phys,
+                                            GFP_KERNEL);
         if (!host->scb_virt) {
                 printk("inia100: SCB memory allocation error\n");
                 goto out_host_put;
@@ -1132,8 +1132,8 @@ static int inia100_probe_one(struct pci_dev *pdev,
 
         /* Get total memory needed for ESCB */
         sz = ORC_MAXQUEUE * sizeof(struct orc_extended_scb);
-        host->escb_virt = dma_zalloc_coherent(&pdev->dev, sz, &host->escb_phys,
-                                              GFP_KERNEL);
+        host->escb_virt = dma_alloc_coherent(&pdev->dev, sz, &host->escb_phys,
+                                             GFP_KERNEL);
         if (!host->escb_virt) {
                 printk("inia100: ESCB memory allocation error\n");
                 goto out_free_scb_array;
diff --git a/drivers/scsi/aacraid/linit.c b/drivers/scsi/aacraid/linit.c
index 634ddb90e7aa..7e56a11836c1 100644
--- a/drivers/scsi/aacraid/linit.c
+++ b/drivers/scsi/aacraid/linit.c
@@ -1747,11 +1747,10 @@ static int aac_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
                 shost->max_sectors = (shost->sg_tablesize * 8) + 112;
         }
 
-        error = dma_set_max_seg_size(&pdev->dev,
-                (aac->adapter_info.options & AAC_OPT_NEW_COMM) ?
-                        (shost->max_sectors << 9) : 65536);
-        if (error)
-                goto out_deinit;
+        if (aac->adapter_info.options & AAC_OPT_NEW_COMM)
+                shost->max_segment_size = shost->max_sectors << 9;
+        else
+                shost->max_segment_size = 65536;
 
         /*
          * Firmware printf works only with older firmware.
diff --git a/drivers/scsi/arcmsr/arcmsr_hba.c b/drivers/scsi/arcmsr/arcmsr_hba.c
index 0f6751b0a633..57c6fa388bf6 100644
--- a/drivers/scsi/arcmsr/arcmsr_hba.c
+++ b/drivers/scsi/arcmsr/arcmsr_hba.c
@@ -587,8 +587,10 @@ static bool arcmsr_alloc_io_queue(struct AdapterControlBlock *acb)
         case ACB_ADAPTER_TYPE_B: {
                 struct MessageUnit_B *reg;
                 acb->roundup_ccbsize = roundup(sizeof(struct MessageUnit_B), 32);
-                dma_coherent = dma_zalloc_coherent(&pdev->dev, acb->roundup_ccbsize,
-                        &dma_coherent_handle, GFP_KERNEL);
+                dma_coherent = dma_alloc_coherent(&pdev->dev,
+                                                  acb->roundup_ccbsize,
+                                                  &dma_coherent_handle,
+                                                  GFP_KERNEL);
                 if (!dma_coherent) {
                         pr_notice("arcmsr%d: DMA allocation failed\n", acb->host->host_no);
                         return false;
@@ -617,8 +619,10 @@ static bool arcmsr_alloc_io_queue(struct AdapterControlBlock *acb)
                 struct MessageUnit_D *reg;
 
                 acb->roundup_ccbsize = roundup(sizeof(struct MessageUnit_D), 32);
-                dma_coherent = dma_zalloc_coherent(&pdev->dev, acb->roundup_ccbsize,
-                        &dma_coherent_handle, GFP_KERNEL);
+                dma_coherent = dma_alloc_coherent(&pdev->dev,
+                                                  acb->roundup_ccbsize,
+                                                  &dma_coherent_handle,
+                                                  GFP_KERNEL);
                 if (!dma_coherent) {
                         pr_notice("arcmsr%d: DMA allocation failed\n", acb->host->host_no);
                         return false;
@@ -659,8 +663,10 @@ static bool arcmsr_alloc_io_queue(struct AdapterControlBlock *acb)
                 uint32_t completeQ_size;
                 completeQ_size = sizeof(struct deliver_completeQ) * ARCMSR_MAX_HBE_DONEQUEUE + 128;
                 acb->roundup_ccbsize = roundup(completeQ_size, 32);
-                dma_coherent = dma_zalloc_coherent(&pdev->dev, acb->roundup_ccbsize,
-                        &dma_coherent_handle, GFP_KERNEL);
+                dma_coherent = dma_alloc_coherent(&pdev->dev,
+                                                  acb->roundup_ccbsize,
+                                                  &dma_coherent_handle,
+                                                  GFP_KERNEL);
                 if (!dma_coherent){
                         pr_notice("arcmsr%d: DMA allocation failed\n", acb->host->host_no);
                         return false;
diff --git a/drivers/scsi/be2iscsi/be_main.c b/drivers/scsi/be2iscsi/be_main.c
index 39f3820572b4..74e260027c7d 100644
--- a/drivers/scsi/be2iscsi/be_main.c
+++ b/drivers/scsi/be2iscsi/be_main.c
@@ -3321,8 +3321,8 @@ static int be_queue_alloc(struct beiscsi_hba *phba, struct be_queue_info *q,
         q->len = len;
         q->entry_size = entry_size;
         mem->size = len * entry_size;
-        mem->va = dma_zalloc_coherent(&phba->pcidev->dev, mem->size, &mem->dma,
-                        GFP_KERNEL);
+        mem->va = dma_alloc_coherent(&phba->pcidev->dev, mem->size, &mem->dma,
+                                     GFP_KERNEL);
         if (!mem->va)
                 return -ENOMEM;
         return 0;
diff --git a/drivers/scsi/be2iscsi/be_mgmt.c b/drivers/scsi/be2iscsi/be_mgmt.c
index ca7b7bbc8371..d4febaadfaa3 100644
--- a/drivers/scsi/be2iscsi/be_mgmt.c
+++ b/drivers/scsi/be2iscsi/be_mgmt.c
@@ -293,8 +293,8 @@ static int beiscsi_prep_nemb_cmd(struct beiscsi_hba *phba,
                                  struct be_dma_mem *cmd,
                                  u8 subsystem, u8 opcode, u32 size)
 {
-        cmd->va = dma_zalloc_coherent(&phba->ctrl.pdev->dev, size, &cmd->dma,
-                        GFP_KERNEL);
+        cmd->va = dma_alloc_coherent(&phba->ctrl.pdev->dev, size, &cmd->dma,
+                                     GFP_KERNEL);
         if (!cmd->va) {
                 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_CONFIG,
                             "BG_%d : Failed to allocate memory for if info\n");
@@ -1510,10 +1510,9 @@ int beiscsi_mgmt_invalidate_icds(struct beiscsi_hba *phba,
                 return -EINVAL;
 
         nonemb_cmd.size = sizeof(union be_invldt_cmds_params);
-        nonemb_cmd.va = dma_zalloc_coherent(&phba->ctrl.pdev->dev,
-                                              nonemb_cmd.size,
-                                              &nonemb_cmd.dma,
-                                              GFP_KERNEL);
+        nonemb_cmd.va = dma_alloc_coherent(&phba->ctrl.pdev->dev,
+                                           nonemb_cmd.size, &nonemb_cmd.dma,
+                                           GFP_KERNEL);
         if (!nonemb_cmd.va) {
                 beiscsi_log(phba, KERN_ERR, BEISCSI_LOG_EH,
                             "BM_%d : invldt_cmds_params alloc failed\n");
diff --git a/drivers/scsi/bfa/bfad_bsg.c b/drivers/scsi/bfa/bfad_bsg.c
index 5d163ca1b366..d8e6d7480f35 100644
--- a/drivers/scsi/bfa/bfad_bsg.c
+++ b/drivers/scsi/bfa/bfad_bsg.c
@@ -3264,9 +3264,9 @@ bfad_fcxp_map_sg(struct bfad_s *bfad, void *payload_kbuf,
         /* Allocate dma coherent memory */
         buf_info = buf_base;
         buf_info->size = payload_len;
-        buf_info->virt = dma_zalloc_coherent(&bfad->pcidev->dev,
-                                             buf_info->size, &buf_info->phys,
-                                             GFP_KERNEL);
+        buf_info->virt = dma_alloc_coherent(&bfad->pcidev->dev,
+                                            buf_info->size, &buf_info->phys,
+                                            GFP_KERNEL);
         if (!buf_info->virt)
                 goto out_free_mem;
 
diff --git a/drivers/scsi/bnx2fc/bnx2fc_hwi.c b/drivers/scsi/bnx2fc/bnx2fc_hwi.c
index e8ae4d671d23..039328d9ef13 100644
--- a/drivers/scsi/bnx2fc/bnx2fc_hwi.c
+++ b/drivers/scsi/bnx2fc/bnx2fc_hwi.c
@@ -1857,10 +1857,10 @@ int bnx2fc_setup_task_ctx(struct bnx2fc_hba *hba)
          * entries. Hence the limit with one page is 8192 task context
          * entries.
          */
-        hba->task_ctx_bd_tbl = dma_zalloc_coherent(&hba->pcidev->dev,
-                                                   PAGE_SIZE,
-                                                   &hba->task_ctx_bd_dma,
-                                                   GFP_KERNEL);
+        hba->task_ctx_bd_tbl = dma_alloc_coherent(&hba->pcidev->dev,
+                                                  PAGE_SIZE,
+                                                  &hba->task_ctx_bd_dma,
+                                                  GFP_KERNEL);
         if (!hba->task_ctx_bd_tbl) {
                 printk(KERN_ERR PFX "unable to allocate task context BDT\n");
                 rc = -1;
@@ -1894,10 +1894,10 @@ int bnx2fc_setup_task_ctx(struct bnx2fc_hba *hba)
         task_ctx_bdt = (struct regpair *)hba->task_ctx_bd_tbl;
         for (i = 0; i < task_ctx_arr_sz; i++) {
 
-                hba->task_ctx[i] = dma_zalloc_coherent(&hba->pcidev->dev,
-                                                       PAGE_SIZE,
-                                                       &hba->task_ctx_dma[i],
-                                                       GFP_KERNEL);
+                hba->task_ctx[i] = dma_alloc_coherent(&hba->pcidev->dev,
+                                                      PAGE_SIZE,
+                                                      &hba->task_ctx_dma[i],
+                                                      GFP_KERNEL);
                 if (!hba->task_ctx[i]) {
                         printk(KERN_ERR PFX "unable to alloc task context\n");
                         rc = -1;
@@ -2031,19 +2031,19 @@ static int bnx2fc_allocate_hash_table(struct bnx2fc_hba *hba)
         }
 
         for (i = 0; i < segment_count; ++i) {
-                hba->hash_tbl_segments[i] = dma_zalloc_coherent(&hba->pcidev->dev,
-                                                                BNX2FC_HASH_TBL_CHUNK_SIZE,
-                                                                &dma_segment_array[i],
-                                                                GFP_KERNEL);
+                hba->hash_tbl_segments[i] = dma_alloc_coherent(&hba->pcidev->dev,
+                                                               BNX2FC_HASH_TBL_CHUNK_SIZE,
+                                                               &dma_segment_array[i],
+                                                               GFP_KERNEL);
                 if (!hba->hash_tbl_segments[i]) {
                         printk(KERN_ERR PFX "hash segment alloc failed\n");
                         goto cleanup_dma;
                 }
         }
 
-        hba->hash_tbl_pbl = dma_zalloc_coherent(&hba->pcidev->dev, PAGE_SIZE,
-                                                &hba->hash_tbl_pbl_dma,
-                                                GFP_KERNEL);
+        hba->hash_tbl_pbl = dma_alloc_coherent(&hba->pcidev->dev, PAGE_SIZE,
+                                               &hba->hash_tbl_pbl_dma,
+                                               GFP_KERNEL);
         if (!hba->hash_tbl_pbl) {
                 printk(KERN_ERR PFX "hash table pbl alloc failed\n");
                 goto cleanup_dma;
@@ -2104,10 +2104,9 @@ int bnx2fc_setup_fw_resc(struct bnx2fc_hba *hba)
                 return -ENOMEM;
 
         mem_size = BNX2FC_NUM_MAX_SESS * sizeof(struct regpair);
-        hba->t2_hash_tbl_ptr = dma_zalloc_coherent(&hba->pcidev->dev,
-                                                   mem_size,
-                                                   &hba->t2_hash_tbl_ptr_dma,
-                                                   GFP_KERNEL);
+        hba->t2_hash_tbl_ptr = dma_alloc_coherent(&hba->pcidev->dev, mem_size,
+                                                  &hba->t2_hash_tbl_ptr_dma,
+                                                  GFP_KERNEL);
         if (!hba->t2_hash_tbl_ptr) {
                 printk(KERN_ERR PFX "unable to allocate t2 hash table ptr\n");
                 bnx2fc_free_fw_resc(hba);
@@ -2116,9 +2115,9 @@ int bnx2fc_setup_fw_resc(struct bnx2fc_hba *hba)
 
         mem_size = BNX2FC_NUM_MAX_SESS *
                                 sizeof(struct fcoe_t2_hash_table_entry);
-        hba->t2_hash_tbl = dma_zalloc_coherent(&hba->pcidev->dev, mem_size,
-                                               &hba->t2_hash_tbl_dma,
-                                               GFP_KERNEL);
+        hba->t2_hash_tbl = dma_alloc_coherent(&hba->pcidev->dev, mem_size,
+                                              &hba->t2_hash_tbl_dma,
+                                              GFP_KERNEL);
         if (!hba->t2_hash_tbl) {
                 printk(KERN_ERR PFX "unable to allocate t2 hash table\n");
                 bnx2fc_free_fw_resc(hba);
@@ -2140,9 +2139,9 @@ int bnx2fc_setup_fw_resc(struct bnx2fc_hba *hba)
                 return -ENOMEM;
         }
 
-        hba->stats_buffer = dma_zalloc_coherent(&hba->pcidev->dev, PAGE_SIZE,
-                                                &hba->stats_buf_dma,
-                                                GFP_KERNEL);
+        hba->stats_buffer = dma_alloc_coherent(&hba->pcidev->dev, PAGE_SIZE,
+                                               &hba->stats_buf_dma,
+                                               GFP_KERNEL);
         if (!hba->stats_buffer) {
                 printk(KERN_ERR PFX "unable to alloc Stats Buffer\n");
                 bnx2fc_free_fw_resc(hba);
diff --git a/drivers/scsi/bnx2fc/bnx2fc_tgt.c b/drivers/scsi/bnx2fc/bnx2fc_tgt.c
index e3d1c7c440c8..d735e87e416a 100644
--- a/drivers/scsi/bnx2fc/bnx2fc_tgt.c
+++ b/drivers/scsi/bnx2fc/bnx2fc_tgt.c
@@ -672,8 +672,8 @@ static int bnx2fc_alloc_session_resc(struct bnx2fc_hba *hba,
         tgt->sq_mem_size = (tgt->sq_mem_size + (CNIC_PAGE_SIZE - 1)) &
                            CNIC_PAGE_MASK;
 
-        tgt->sq = dma_zalloc_coherent(&hba->pcidev->dev, tgt->sq_mem_size,
-                                      &tgt->sq_dma, GFP_KERNEL);
+        tgt->sq = dma_alloc_coherent(&hba->pcidev->dev, tgt->sq_mem_size,
+                                     &tgt->sq_dma, GFP_KERNEL);
         if (!tgt->sq) {
                 printk(KERN_ERR PFX "unable to allocate SQ memory %d\n",
                         tgt->sq_mem_size);
@@ -685,8 +685,8 @@ static int bnx2fc_alloc_session_resc(struct bnx2fc_hba *hba,
         tgt->cq_mem_size = (tgt->cq_mem_size + (CNIC_PAGE_SIZE - 1)) &
                            CNIC_PAGE_MASK;
 
-        tgt->cq = dma_zalloc_coherent(&hba->pcidev->dev, tgt->cq_mem_size,
-                                      &tgt->cq_dma, GFP_KERNEL);
+        tgt->cq = dma_alloc_coherent(&hba->pcidev->dev, tgt->cq_mem_size,
+                                     &tgt->cq_dma, GFP_KERNEL);
         if (!tgt->cq) {
                 printk(KERN_ERR PFX "unable to allocate CQ memory %d\n",
                         tgt->cq_mem_size);
@@ -698,8 +698,8 @@ static int bnx2fc_alloc_session_resc(struct bnx2fc_hba *hba,
         tgt->rq_mem_size = (tgt->rq_mem_size + (CNIC_PAGE_SIZE - 1)) &
                            CNIC_PAGE_MASK;
 
-        tgt->rq = dma_zalloc_coherent(&hba->pcidev->dev, tgt->rq_mem_size,
-                                      &tgt->rq_dma, GFP_KERNEL);
+        tgt->rq = dma_alloc_coherent(&hba->pcidev->dev, tgt->rq_mem_size,
+                                     &tgt->rq_dma, GFP_KERNEL);
         if (!tgt->rq) {
                 printk(KERN_ERR PFX "unable to allocate RQ memory %d\n",
                         tgt->rq_mem_size);
@@ -710,8 +710,8 @@ static int bnx2fc_alloc_session_resc(struct bnx2fc_hba *hba,
         tgt->rq_pbl_size = (tgt->rq_pbl_size + (CNIC_PAGE_SIZE - 1)) &
                            CNIC_PAGE_MASK;
 
-        tgt->rq_pbl = dma_zalloc_coherent(&hba->pcidev->dev, tgt->rq_pbl_size,
-                                          &tgt->rq_pbl_dma, GFP_KERNEL);
+        tgt->rq_pbl = dma_alloc_coherent(&hba->pcidev->dev, tgt->rq_pbl_size,
+                                         &tgt->rq_pbl_dma, GFP_KERNEL);
         if (!tgt->rq_pbl) {
                 printk(KERN_ERR PFX "unable to allocate RQ PBL %d\n",
                         tgt->rq_pbl_size);
@@ -735,9 +735,9 @@ static int bnx2fc_alloc_session_resc(struct bnx2fc_hba *hba,
         tgt->xferq_mem_size = (tgt->xferq_mem_size + (CNIC_PAGE_SIZE - 1)) &
                                CNIC_PAGE_MASK;
 
-        tgt->xferq = dma_zalloc_coherent(&hba->pcidev->dev,
-                                         tgt->xferq_mem_size, &tgt->xferq_dma,
-                                         GFP_KERNEL);
+        tgt->xferq = dma_alloc_coherent(&hba->pcidev->dev,
+                                        tgt->xferq_mem_size, &tgt->xferq_dma,
+                                        GFP_KERNEL);
         if (!tgt->xferq) {
                 printk(KERN_ERR PFX "unable to allocate XFERQ %d\n",
                         tgt->xferq_mem_size);
@@ -749,9 +749,9 @@ static int bnx2fc_alloc_session_resc(struct bnx2fc_hba *hba,
         tgt->confq_mem_size = (tgt->confq_mem_size + (CNIC_PAGE_SIZE - 1)) &
                                CNIC_PAGE_MASK;
 
-        tgt->confq = dma_zalloc_coherent(&hba->pcidev->dev,
-                                         tgt->confq_mem_size, &tgt->confq_dma,
-                                         GFP_KERNEL);
+        tgt->confq = dma_alloc_coherent(&hba->pcidev->dev,
+                                        tgt->confq_mem_size, &tgt->confq_dma,
+                                        GFP_KERNEL);
         if (!tgt->confq) {
                 printk(KERN_ERR PFX "unable to allocate CONFQ %d\n",
                         tgt->confq_mem_size);
@@ -763,9 +763,9 @@ static int bnx2fc_alloc_session_resc(struct bnx2fc_hba *hba,
         tgt->confq_pbl_size =
                 (tgt->confq_pbl_size + (CNIC_PAGE_SIZE - 1)) & CNIC_PAGE_MASK;
 
-        tgt->confq_pbl = dma_zalloc_coherent(&hba->pcidev->dev,
-                                             tgt->confq_pbl_size,
-                                             &tgt->confq_pbl_dma, GFP_KERNEL);
+        tgt->confq_pbl = dma_alloc_coherent(&hba->pcidev->dev,
+                                            tgt->confq_pbl_size,
+                                            &tgt->confq_pbl_dma, GFP_KERNEL);
         if (!tgt->confq_pbl) {
                 printk(KERN_ERR PFX "unable to allocate CONFQ PBL %d\n",
                         tgt->confq_pbl_size);
@@ -787,9 +787,9 @@ static int bnx2fc_alloc_session_resc(struct bnx2fc_hba *hba,
         /* Allocate and map ConnDB */
         tgt->conn_db_mem_size = sizeof(struct fcoe_conn_db);
 
-        tgt->conn_db = dma_zalloc_coherent(&hba->pcidev->dev,
-                                           tgt->conn_db_mem_size,
-                                           &tgt->conn_db_dma, GFP_KERNEL);
+        tgt->conn_db = dma_alloc_coherent(&hba->pcidev->dev,
+                                          tgt->conn_db_mem_size,
+                                          &tgt->conn_db_dma, GFP_KERNEL);
         if (!tgt->conn_db) {
                 printk(KERN_ERR PFX "unable to allocate conn_db %d\n",
                                                 tgt->conn_db_mem_size);
@@ -802,8 +802,8 @@ static int bnx2fc_alloc_session_resc(struct bnx2fc_hba *hba,
         tgt->lcq_mem_size = (tgt->lcq_mem_size + (CNIC_PAGE_SIZE - 1)) &
                              CNIC_PAGE_MASK;
 
-        tgt->lcq = dma_zalloc_coherent(&hba->pcidev->dev, tgt->lcq_mem_size,
-                                       &tgt->lcq_dma, GFP_KERNEL);
+        tgt->lcq = dma_alloc_coherent(&hba->pcidev->dev, tgt->lcq_mem_size,
+                                      &tgt->lcq_dma, GFP_KERNEL);
 
         if (!tgt->lcq) {
                 printk(KERN_ERR PFX "unable to allocate lcq %d\n",
diff --git a/drivers/scsi/bnx2i/bnx2i_hwi.c b/drivers/scsi/bnx2i/bnx2i_hwi.c
index 91f5316aa3ab..fae6f71e677d 100644
--- a/drivers/scsi/bnx2i/bnx2i_hwi.c
+++ b/drivers/scsi/bnx2i/bnx2i_hwi.c
@@ -1070,8 +1070,8 @@ int bnx2i_alloc_qp_resc(struct bnx2i_hba *hba, struct bnx2i_endpoint *ep)
 
         /* Allocate memory area for actual SQ element */
         ep->qp.sq_virt =
-                dma_zalloc_coherent(&hba->pcidev->dev, ep->qp.sq_mem_size,
-                                        &ep->qp.sq_phys, GFP_KERNEL);
+                dma_alloc_coherent(&hba->pcidev->dev, ep->qp.sq_mem_size,
+                                   &ep->qp.sq_phys, GFP_KERNEL);
         if (!ep->qp.sq_virt) {
                 printk(KERN_ALERT "bnx2i: unable to alloc SQ BD memory %d\n",
                                   ep->qp.sq_mem_size);
@@ -1106,8 +1106,8 @@ int bnx2i_alloc_qp_resc(struct bnx2i_hba *hba, struct bnx2i_endpoint *ep)
 
         /* Allocate memory area for actual CQ element */
         ep->qp.cq_virt =
-                dma_zalloc_coherent(&hba->pcidev->dev, ep->qp.cq_mem_size,
-                                        &ep->qp.cq_phys, GFP_KERNEL);
+                dma_alloc_coherent(&hba->pcidev->dev, ep->qp.cq_mem_size,
+                                   &ep->qp.cq_phys, GFP_KERNEL);
         if (!ep->qp.cq_virt) {
                 printk(KERN_ALERT "bnx2i: unable to alloc CQ BD memory %d\n",
                                   ep->qp.cq_mem_size);
diff --git a/drivers/scsi/csiostor/csio_attr.c b/drivers/scsi/csiostor/csio_attr.c
index 8a004036e3d7..9bd2bd8dc2be 100644
--- a/drivers/scsi/csiostor/csio_attr.c
+++ b/drivers/scsi/csiostor/csio_attr.c
@@ -594,12 +594,12 @@ csio_vport_create(struct fc_vport *fc_vport, bool disable)
         }
 
         fc_vport_set_state(fc_vport, FC_VPORT_INITIALIZING);
+        ln->fc_vport = fc_vport;
 
         if (csio_fcoe_alloc_vnp(hw, ln))
                 goto error;
 
         *(struct csio_lnode **)fc_vport->dd_data = ln;
-        ln->fc_vport = fc_vport;
         if (!fc_vport->node_name)
                 fc_vport->node_name = wwn_to_u64(csio_ln_wwnn(ln));
         if (!fc_vport->port_name)
diff --git a/drivers/scsi/csiostor/csio_wr.c b/drivers/scsi/csiostor/csio_wr.c
index dc12933533d5..66bbd21819ae 100644
--- a/drivers/scsi/csiostor/csio_wr.c
+++ b/drivers/scsi/csiostor/csio_wr.c
@@ -233,8 +233,8 @@ csio_wr_alloc_q(struct csio_hw *hw, uint32_t qsize, uint32_t wrsize,
 
         q = wrm->q_arr[free_idx];
 
-        q->vstart = dma_zalloc_coherent(&hw->pdev->dev, qsz, &q->pstart,
-                        GFP_KERNEL);
+        q->vstart = dma_alloc_coherent(&hw->pdev->dev, qsz, &q->pstart,
+                                       GFP_KERNEL);
         if (!q->vstart) {
                 csio_err(hw,
                          "Failed to allocate DMA memory for "
diff --git a/drivers/scsi/cxgbi/cxgb3i/cxgb3i.c b/drivers/scsi/cxgbi/cxgb3i/cxgb3i.c
index 8a20411699d9..75e1273a44b3 100644
--- a/drivers/scsi/cxgbi/cxgb3i/cxgb3i.c
+++ b/drivers/scsi/cxgbi/cxgb3i/cxgb3i.c
@@ -1144,7 +1144,7 @@ static void ddp_clear_map(struct cxgbi_device *cdev, struct cxgbi_ppm *ppm,
 }
 
 static int ddp_setup_conn_pgidx(struct cxgbi_sock *csk,
-                                       unsigned int tid, int pg_idx, bool reply)
+                                unsigned int tid, int pg_idx)
 {
         struct sk_buff *skb = alloc_wr(sizeof(struct cpl_set_tcb_field), 0,
                                         GFP_KERNEL);
@@ -1160,7 +1160,7 @@ static int ddp_setup_conn_pgidx(struct cxgbi_sock *csk,
         req = (struct cpl_set_tcb_field *)skb->head;
         req->wr.wr_hi = htonl(V_WR_OP(FW_WROPCODE_FORWARD));
         OPCODE_TID(req) = htonl(MK_OPCODE_TID(CPL_SET_TCB_FIELD, tid));
-        req->reply = V_NO_REPLY(reply ? 0 : 1);
+        req->reply = V_NO_REPLY(1);
         req->cpu_idx = 0;
         req->word = htons(31);
         req->mask = cpu_to_be64(0xF0000000);
@@ -1177,11 +1177,10 @@ static int ddp_setup_conn_pgidx(struct cxgbi_sock *csk,
  * @tid: connection id
  * @hcrc: header digest enabled
  * @dcrc: data digest enabled
- * @reply: request reply from h/w
  * set up the iscsi digest settings for a connection identified by tid
  */
 static int ddp_setup_conn_digest(struct cxgbi_sock *csk, unsigned int tid,
-                             int hcrc, int dcrc, int reply)
+                                 int hcrc, int dcrc)
 {
         struct sk_buff *skb = alloc_wr(sizeof(struct cpl_set_tcb_field), 0,
                                         GFP_KERNEL);
@@ -1197,7 +1196,7 @@ static int ddp_setup_conn_digest(struct cxgbi_sock *csk, unsigned int tid,
         req = (struct cpl_set_tcb_field *)skb->head;
         req->wr.wr_hi = htonl(V_WR_OP(FW_WROPCODE_FORWARD));
         OPCODE_TID(req) = htonl(MK_OPCODE_TID(CPL_SET_TCB_FIELD, tid));
-        req->reply = V_NO_REPLY(reply ? 0 : 1);
+        req->reply = V_NO_REPLY(1);
         req->cpu_idx = 0;
         req->word = htons(31);
         req->mask = cpu_to_be64(0x0F000000);
diff --git a/drivers/scsi/cxgbi/cxgb4i/cxgb4i.c b/drivers/scsi/cxgbi/cxgb4i/cxgb4i.c
index 49f8028ac524..d26f50af00ea 100644
--- a/drivers/scsi/cxgbi/cxgb4i/cxgb4i.c
+++ b/drivers/scsi/cxgbi/cxgb4i/cxgb4i.c
@@ -1548,16 +1548,22 @@ static void do_set_tcb_rpl(struct cxgbi_device *cdev, struct sk_buff *skb)
         struct cxgbi_sock *csk;
 
         csk = lookup_tid(t, tid);
-        if (!csk)
+        if (!csk) {
                 pr_err("can't find conn. for tid %u.\n", tid);
+                return;
+        }
 
         log_debug(1 << CXGBI_DBG_TOE | 1 << CXGBI_DBG_SOCK,
                 "csk 0x%p,%u,%lx,%u, status 0x%x.\n",
                 csk, csk->state, csk->flags, csk->tid, rpl->status);
 
-        if (rpl->status != CPL_ERR_NONE)
+        if (rpl->status != CPL_ERR_NONE) {
                 pr_err("csk 0x%p,%u, SET_TCB_RPL status %u.\n",
                         csk, tid, rpl->status);
+                csk->err = -EINVAL;
+        }
+
+        complete(&csk->cmpl);
 
         __kfree_skb(skb);
 }
@@ -1983,7 +1989,7 @@ static int ddp_set_map(struct cxgbi_ppm *ppm, struct cxgbi_sock *csk,
 }
 
 static int ddp_setup_conn_pgidx(struct cxgbi_sock *csk, unsigned int tid,
-                                int pg_idx, bool reply)
+                                int pg_idx)
 {
         struct sk_buff *skb;
         struct cpl_set_tcb_field *req;
@@ -1999,7 +2005,7 @@ static int ddp_setup_conn_pgidx(struct cxgbi_sock *csk, unsigned int tid,
         req = (struct cpl_set_tcb_field *)skb->head;
         INIT_TP_WR(req, csk->tid);
         OPCODE_TID(req) = htonl(MK_OPCODE_TID(CPL_SET_TCB_FIELD, csk->tid));
-        req->reply_ctrl = htons(NO_REPLY_V(reply) | QUEUENO_V(csk->rss_qid));
+        req->reply_ctrl = htons(NO_REPLY_V(0) | QUEUENO_V(csk->rss_qid));
         req->word_cookie = htons(0);
         req->mask = cpu_to_be64(0x3 << 8);
         req->val = cpu_to_be64(pg_idx << 8);
@@ -2008,12 +2014,15 @@ static int ddp_setup_conn_pgidx(struct cxgbi_sock *csk, unsigned int tid,
         log_debug(1 << CXGBI_DBG_TOE | 1 << CXGBI_DBG_SOCK,
                 "csk 0x%p, tid 0x%x, pg_idx %u.\n", csk, csk->tid, pg_idx);
 
+        reinit_completion(&csk->cmpl);
         cxgb4_ofld_send(csk->cdev->ports[csk->port_id], skb);
-        return 0;
+        wait_for_completion(&csk->cmpl);
+
+        return csk->err;
 }
 
 static int ddp_setup_conn_digest(struct cxgbi_sock *csk, unsigned int tid,
-                                 int hcrc, int dcrc, int reply)
+                                 int hcrc, int dcrc)
 {
         struct sk_buff *skb;
         struct cpl_set_tcb_field *req;
@@ -2031,7 +2040,7 @@ static int ddp_setup_conn_digest(struct cxgbi_sock *csk, unsigned int tid,
         req = (struct cpl_set_tcb_field *)skb->head;
         INIT_TP_WR(req, tid);
         OPCODE_TID(req) = htonl(MK_OPCODE_TID(CPL_SET_TCB_FIELD, tid));
-        req->reply_ctrl = htons(NO_REPLY_V(reply) | QUEUENO_V(csk->rss_qid));
+        req->reply_ctrl = htons(NO_REPLY_V(0) | QUEUENO_V(csk->rss_qid));
         req->word_cookie = htons(0);
         req->mask = cpu_to_be64(0x3 << 4);
         req->val = cpu_to_be64(((hcrc ? ULP_CRC_HEADER : 0) |
@@ -2041,8 +2050,11 @@ static int ddp_setup_conn_digest(struct cxgbi_sock *csk, unsigned int tid,
         log_debug(1 << CXGBI_DBG_TOE | 1 << CXGBI_DBG_SOCK,
                 "csk 0x%p, tid 0x%x, crc %d,%d.\n", csk, csk->tid, hcrc, dcrc);
 
+        reinit_completion(&csk->cmpl);
         cxgb4_ofld_send(csk->cdev->ports[csk->port_id], skb);
-        return 0;
+        wait_for_completion(&csk->cmpl);
+
+        return csk->err;
 }
 
 static struct cxgbi_ppm *cdev2ppm(struct cxgbi_device *cdev)
diff --git a/drivers/scsi/cxgbi/libcxgbi.c b/drivers/scsi/cxgbi/libcxgbi.c
index 75f876409fb9..245742557c03 100644
--- a/drivers/scsi/cxgbi/libcxgbi.c
+++ b/drivers/scsi/cxgbi/libcxgbi.c
@@ -573,6 +573,7 @@ static struct cxgbi_sock *cxgbi_sock_create(struct cxgbi_device *cdev)
         skb_queue_head_init(&csk->receive_queue);
         skb_queue_head_init(&csk->write_queue);
         timer_setup(&csk->retry_timer, NULL, 0);
+        init_completion(&csk->cmpl);
         rwlock_init(&csk->callback_lock);
         csk->cdev = cdev;
         csk->flags = 0;
@@ -2251,14 +2252,14 @@ int cxgbi_set_conn_param(struct iscsi_cls_conn *cls_conn,
                 if (!err && conn->hdrdgst_en)
                         err = csk->cdev->csk_ddp_setup_digest(csk, csk->tid,
                                                         conn->hdrdgst_en,
-                                                        conn->datadgst_en, 0);
+                                                        conn->datadgst_en);
                 break;
         case ISCSI_PARAM_DATADGST_EN:
                 err = iscsi_set_param(cls_conn, param, buf, buflen);
                 if (!err && conn->datadgst_en)
                         err = csk->cdev->csk_ddp_setup_digest(csk, csk->tid,
                                                         conn->hdrdgst_en,
-                                                        conn->datadgst_en, 0);
+                                                        conn->datadgst_en);
                 break;
         case ISCSI_PARAM_MAX_R2T:
                 return iscsi_tcp_set_max_r2t(conn, buf);
@@ -2384,7 +2385,7 @@ int cxgbi_bind_conn(struct iscsi_cls_session *cls_session,
 
         ppm = csk->cdev->cdev2ppm(csk->cdev);
         err = csk->cdev->csk_ddp_setup_pgidx(csk, csk->tid,
-                                             ppm->tformat.pgsz_idx_dflt, 0);
+                                             ppm->tformat.pgsz_idx_dflt);
         if (err < 0)
                 return err;
 
diff --git a/drivers/scsi/cxgbi/libcxgbi.h b/drivers/scsi/cxgbi/libcxgbi.h
index 5d5d8b50d842..1917ff57651d 100644
--- a/drivers/scsi/cxgbi/libcxgbi.h
+++ b/drivers/scsi/cxgbi/libcxgbi.h
@@ -149,6 +149,7 @@ struct cxgbi_sock {
         struct sk_buff_head receive_queue;
         struct sk_buff_head write_queue;
         struct timer_list retry_timer;
+        struct completion cmpl;
         int err;
         rwlock_t callback_lock;
         void *user_data;
@@ -490,9 +491,9 @@ struct cxgbi_device {
                                   struct cxgbi_ppm *,
                                   struct cxgbi_task_tag_info *);
         int (*csk_ddp_setup_digest)(struct cxgbi_sock *,
-                                unsigned int, int, int, int);
+                                    unsigned int, int, int);
         int (*csk_ddp_setup_pgidx)(struct cxgbi_sock *,
-                                unsigned int, int, bool);
+                                   unsigned int, int);
 
         void (*csk_release_offload_resources)(struct cxgbi_sock *);
         int (*csk_rx_pdu_ready)(struct cxgbi_sock *, struct sk_buff *);
diff --git a/drivers/scsi/hisi_sas/hisi_sas_v3_hw.c b/drivers/scsi/hisi_sas/hisi_sas_v3_hw.c
index e2420a810e99..c92b3822c408 100644
--- a/drivers/scsi/hisi_sas/hisi_sas_v3_hw.c
+++ b/drivers/scsi/hisi_sas/hisi_sas_v3_hw.c
@@ -2507,6 +2507,12 @@ hisi_sas_v3_probe(struct pci_dev *pdev, const struct pci_device_id *id)
                 sha->sas_port[i] = &hisi_hba->port[i].sas_port;
         }
 
+        if (hisi_hba->prot_mask) {
+                dev_info(dev, "Registering for DIF/DIX prot_mask=0x%x\n",
+                         prot_mask);
+                scsi_host_set_prot(hisi_hba->shost, prot_mask);
+        }
+
         rc = scsi_add_host(shost, dev);
         if (rc)
                 goto err_out_ha;
@@ -2519,12 +2525,6 @@ hisi_sas_v3_probe(struct pci_dev *pdev, const struct pci_device_id *id)
         if (rc)
                 goto err_out_register_ha;
 
-        if (hisi_hba->prot_mask) {
-                dev_info(dev, "Registering for DIF/DIX prot_mask=0x%x\n",
-                         prot_mask);
-                scsi_host_set_prot(hisi_hba->shost, prot_mask);
-        }
-
         scsi_scan_host(shost);
 
         return 0;
diff --git a/drivers/scsi/isci/init.c b/drivers/scsi/isci/init.c
index 68b90c4f79a3..1727d0c71b12 100644
--- a/drivers/scsi/isci/init.c
+++ b/drivers/scsi/isci/init.c
@@ -576,6 +576,13 @@ static struct isci_host *isci_host_alloc(struct pci_dev *pdev, int id)
         shost->max_lun = ~0;
         shost->max_cmd_len = MAX_COMMAND_SIZE;
 
+        /* turn on DIF support */
+        scsi_host_set_prot(shost,
+                           SHOST_DIF_TYPE1_PROTECTION |
+                           SHOST_DIF_TYPE2_PROTECTION |
+                           SHOST_DIF_TYPE3_PROTECTION);
+        scsi_host_set_guard(shost, SHOST_DIX_GUARD_CRC);
+
         err = scsi_add_host(shost, &pdev->dev);
         if (err)
                 goto err_shost;
@@ -663,13 +670,6 @@ static int isci_pci_probe(struct pci_dev *pdev, const struct pci_device_id *id)
                         goto err_host_alloc;
                 }
                 pci_info->hosts[i] = h;
-
-                /* turn on DIF support */
-                scsi_host_set_prot(to_shost(h),
-                                   SHOST_DIF_TYPE1_PROTECTION |
-                                   SHOST_DIF_TYPE2_PROTECTION |
-                                   SHOST_DIF_TYPE3_PROTECTION);
-                scsi_host_set_guard(to_shost(h), SHOST_DIX_GUARD_CRC);
         }
 
         err = isci_setup_interrupts(pdev);
diff --git a/drivers/scsi/lpfc/lpfc_bsg.c b/drivers/scsi/lpfc/lpfc_bsg.c
index 8698af86485d..2dc564e59430 100644
--- a/drivers/scsi/lpfc/lpfc_bsg.c
+++ b/drivers/scsi/lpfc/lpfc_bsg.c
@@ -2730,8 +2730,8 @@ lpfc_bsg_dma_page_alloc(struct lpfc_hba *phba)
         INIT_LIST_HEAD(&dmabuf->list);
 
         /* now, allocate dma buffer */
-        dmabuf->virt = dma_zalloc_coherent(&pcidev->dev, BSG_MBOX_SIZE,
-                                           &(dmabuf->phys), GFP_KERNEL);
+        dmabuf->virt = dma_alloc_coherent(&pcidev->dev, BSG_MBOX_SIZE,
+                                          &(dmabuf->phys), GFP_KERNEL);
 
         if (!dmabuf->virt) {
                 kfree(dmabuf);
diff --git a/drivers/scsi/lpfc/lpfc_init.c b/drivers/scsi/lpfc/lpfc_init.c
index c1c36812c3d2..bede11e16349 100644
--- a/drivers/scsi/lpfc/lpfc_init.c
+++ b/drivers/scsi/lpfc/lpfc_init.c
@@ -6973,9 +6973,9 @@ lpfc_sli4_create_rpi_hdr(struct lpfc_hba *phba)
         if (!dmabuf)
                 return NULL;
 
-        dmabuf->virt = dma_zalloc_coherent(&phba->pcidev->dev,
-                                           LPFC_HDR_TEMPLATE_SIZE,
-                                           &dmabuf->phys, GFP_KERNEL);
+        dmabuf->virt = dma_alloc_coherent(&phba->pcidev->dev,
+                                          LPFC_HDR_TEMPLATE_SIZE,
+                                          &dmabuf->phys, GFP_KERNEL);
         if (!dmabuf->virt) {
                 rpi_hdr = NULL;
                 goto err_free_dmabuf;
@@ -7397,8 +7397,8 @@ lpfc_sli_pci_mem_setup(struct lpfc_hba *phba)
         }
 
         /* Allocate memory for SLI-2 structures */
-        phba->slim2p.virt = dma_zalloc_coherent(&pdev->dev, SLI2_SLIM_SIZE,
-                                                &phba->slim2p.phys, GFP_KERNEL);
+        phba->slim2p.virt = dma_alloc_coherent(&pdev->dev, SLI2_SLIM_SIZE,
+                                               &phba->slim2p.phys, GFP_KERNEL);
         if (!phba->slim2p.virt)
                 goto out_iounmap;
 
@@ -7816,8 +7816,8 @@ lpfc_create_bootstrap_mbox(struct lpfc_hba *phba)
          * plus an alignment restriction of 16 bytes.
          */
         bmbx_size = sizeof(struct lpfc_bmbx_create) + (LPFC_ALIGN_16_BYTE - 1);
-        dmabuf->virt = dma_zalloc_coherent(&phba->pcidev->dev, bmbx_size,
-                                           &dmabuf->phys, GFP_KERNEL);
+        dmabuf->virt = dma_alloc_coherent(&phba->pcidev->dev, bmbx_size,
+                                          &dmabuf->phys, GFP_KERNEL);
         if (!dmabuf->virt) {
                 kfree(dmabuf);
                 return -ENOMEM;
diff --git a/drivers/scsi/lpfc/lpfc_mbox.c b/drivers/scsi/lpfc/lpfc_mbox.c
index f6a5083a621e..4d3b94317515 100644
--- a/drivers/scsi/lpfc/lpfc_mbox.c
+++ b/drivers/scsi/lpfc/lpfc_mbox.c
@@ -1827,9 +1827,9 @@ lpfc_sli4_config(struct lpfc_hba *phba, struct lpfcMboxq *mbox,
                  * page, this is used as a priori size of SLI4_PAGE_SIZE for
                  * the later DMA memory free.
                  */
-                viraddr = dma_zalloc_coherent(&phba->pcidev->dev,
-                                              SLI4_PAGE_SIZE, &phyaddr,
-                                              GFP_KERNEL);
+                viraddr = dma_alloc_coherent(&phba->pcidev->dev,
+                                             SLI4_PAGE_SIZE, &phyaddr,
+                                             GFP_KERNEL);
                 /* In case of malloc fails, proceed with whatever we have */
                 if (!viraddr)
                         break;
diff --git a/drivers/scsi/lpfc/lpfc_nvme.c b/drivers/scsi/lpfc/lpfc_nvme.c
index 4c66b19e6199..8c9f79042228 100644
--- a/drivers/scsi/lpfc/lpfc_nvme.c
+++ b/drivers/scsi/lpfc/lpfc_nvme.c
@@ -297,7 +297,8 @@ lpfc_nvme_localport_delete(struct nvme_fc_local_port *localport)
                          lport);
 
         /* release any threads waiting for the unreg to complete */
-        complete(&lport->lport_unreg_done);
+        if (lport->vport->localport)
+                complete(lport->lport_unreg_cmp);
 }
 
 /* lpfc_nvme_remoteport_delete
@@ -2545,7 +2546,8 @@ lpfc_nvme_create_localport(struct lpfc_vport *vport)
  */
 void
 lpfc_nvme_lport_unreg_wait(struct lpfc_vport *vport,
-                           struct lpfc_nvme_lport *lport)
+                           struct lpfc_nvme_lport *lport,
+                           struct completion *lport_unreg_cmp)
 {
 #if (IS_ENABLED(CONFIG_NVME_FC))
         u32 wait_tmo;
@@ -2557,8 +2559,7 @@ lpfc_nvme_lport_unreg_wait(struct lpfc_vport *vport,
          */
         wait_tmo = msecs_to_jiffies(LPFC_NVME_WAIT_TMO * 1000);
         while (true) {
-                ret = wait_for_completion_timeout(&lport->lport_unreg_done,
-                                                  wait_tmo);
+                ret = wait_for_completion_timeout(lport_unreg_cmp, wait_tmo);
                 if (unlikely(!ret)) {
                         lpfc_printf_vlog(vport, KERN_ERR, LOG_NVME_IOERR,
                                          "6176 Lport %p Localport %p wait "
@@ -2592,12 +2593,12 @@ lpfc_nvme_destroy_localport(struct lpfc_vport *vport)
         struct lpfc_nvme_lport *lport;
         struct lpfc_nvme_ctrl_stat *cstat;
         int ret;
+        DECLARE_COMPLETION_ONSTACK(lport_unreg_cmp);
 
         if (vport->nvmei_support == 0)
                 return;
 
         localport = vport->localport;
-        vport->localport = NULL;
         lport = (struct lpfc_nvme_lport *)localport->private;
         cstat = lport->cstat;
 
@@ -2608,13 +2609,14 @@ lpfc_nvme_destroy_localport(struct lpfc_vport *vport)
         /* lport's rport list is clear.  Unregister
          * lport and release resources.
          */
-        init_completion(&lport->lport_unreg_done);
+        lport->lport_unreg_cmp = &lport_unreg_cmp;
         ret = nvme_fc_unregister_localport(localport);
 
         /* Wait for completion.  This either blocks
          * indefinitely or succeeds
          */
-        lpfc_nvme_lport_unreg_wait(vport, lport);
+        lpfc_nvme_lport_unreg_wait(vport, lport, &lport_unreg_cmp);
+        vport->localport = NULL;
         kfree(cstat);
 
         /* Regardless of the unregister upcall response, clear
diff --git a/drivers/scsi/lpfc/lpfc_nvme.h b/drivers/scsi/lpfc/lpfc_nvme.h
index cfd4719be25c..b234d0298994 100644
--- a/drivers/scsi/lpfc/lpfc_nvme.h
+++ b/drivers/scsi/lpfc/lpfc_nvme.h
@@ -50,7 +50,7 @@ struct lpfc_nvme_ctrl_stat {
 /* Declare nvme-based local and remote port definitions. */
 struct lpfc_nvme_lport {
         struct lpfc_vport *vport;
-        struct completion lport_unreg_done;
+        struct completion *lport_unreg_cmp;
         /* Add stats counters here */
         struct lpfc_nvme_ctrl_stat *cstat;
         atomic_t fc4NvmeLsRequests;
diff --git a/drivers/scsi/lpfc/lpfc_nvmet.c b/drivers/scsi/lpfc/lpfc_nvmet.c
index 6245f442d784..95fee83090eb 100644
--- a/drivers/scsi/lpfc/lpfc_nvmet.c
+++ b/drivers/scsi/lpfc/lpfc_nvmet.c
@@ -1003,7 +1003,8 @@ lpfc_nvmet_targetport_delete(struct nvmet_fc_target_port *targetport)
         struct lpfc_nvmet_tgtport *tport = targetport->private;
 
         /* release any threads waiting for the unreg to complete */
-        complete(&tport->tport_unreg_done);
+        if (tport->phba->targetport)
+                complete(tport->tport_unreg_cmp);
 }
 
 static void
@@ -1692,6 +1693,7 @@ lpfc_nvmet_destroy_targetport(struct lpfc_hba *phba)
         struct lpfc_nvmet_tgtport *tgtp;
         struct lpfc_queue *wq;
         uint32_t qidx;
+        DECLARE_COMPLETION_ONSTACK(tport_unreg_cmp);
 
         if (phba->nvmet_support == 0)
                 return;
@@ -1701,9 +1703,9 @@ lpfc_nvmet_destroy_targetport(struct lpfc_hba *phba)
                         wq = phba->sli4_hba.nvme_wq[qidx];
                         lpfc_nvmet_wqfull_flush(phba, wq, NULL);
                 }
-                init_completion(&tgtp->tport_unreg_done);
+                tgtp->tport_unreg_cmp = &tport_unreg_cmp;
                 nvmet_fc_unregister_targetport(phba->targetport);
-                wait_for_completion_timeout(&tgtp->tport_unreg_done, 5);
+                wait_for_completion_timeout(&tport_unreg_cmp, 5);
                 lpfc_nvmet_cleanup_io_context(phba);
         }
         phba->targetport = NULL;
diff --git a/drivers/scsi/lpfc/lpfc_nvmet.h b/drivers/scsi/lpfc/lpfc_nvmet.h
index 1aaff63f1f41..0ec1082ce7ef 100644
--- a/drivers/scsi/lpfc/lpfc_nvmet.h
+++ b/drivers/scsi/lpfc/lpfc_nvmet.h
@@ -34,7 +34,7 @@
 /* Used for NVME Target */
 struct lpfc_nvmet_tgtport {
         struct lpfc_hba *phba;
-        struct completion tport_unreg_done;
+        struct completion *tport_unreg_cmp;
 
         /* Stats counters - lpfc_nvmet_unsol_ls_buffer */
         atomic_t rcv_ls_req_in;
diff --git a/drivers/scsi/lpfc/lpfc_sli.c b/drivers/scsi/lpfc/lpfc_sli.c
index 30734caf77e1..2242e9b3ca12 100644
--- a/drivers/scsi/lpfc/lpfc_sli.c
+++ b/drivers/scsi/lpfc/lpfc_sli.c
@@ -5362,8 +5362,8 @@ lpfc_sli4_read_rev(struct lpfc_hba *phba, LPFC_MBOXQ_t *mboxq,
          * mailbox command.
          */
         dma_size = *vpd_size;
-        dmabuf->virt = dma_zalloc_coherent(&phba->pcidev->dev, dma_size,
-                                           &dmabuf->phys, GFP_KERNEL);
+        dmabuf->virt = dma_alloc_coherent(&phba->pcidev->dev, dma_size,
+                                          &dmabuf->phys, GFP_KERNEL);
         if (!dmabuf->virt) {
                 kfree(dmabuf);
                 return -ENOMEM;
@@ -6300,10 +6300,9 @@ lpfc_sli4_ras_dma_alloc(struct lpfc_hba *phba,
                         goto free_mem;
                 }
 
-                dmabuf->virt = dma_zalloc_coherent(&phba->pcidev->dev,
+                dmabuf->virt = dma_alloc_coherent(&phba->pcidev->dev,
                                                   LPFC_RAS_MAX_ENTRY_SIZE,
-                                                  &dmabuf->phys,
-                                                  GFP_KERNEL);
+                                                  &dmabuf->phys, GFP_KERNEL);
                 if (!dmabuf->virt) {
                         kfree(dmabuf);
                         rc = -ENOMEM;
@@ -9408,6 +9407,7 @@ lpfc_sli4_iocb2wqe(struct lpfc_hba *phba, struct lpfc_iocbq *iocbq,
                 cmnd = CMD_XMIT_SEQUENCE64_CR;
                 if (phba->link_flag & LS_LOOPBACK_MODE)
                         bf_set(wqe_xo, &wqe->xmit_sequence.wge_ctl, 1);
+                /* fall through */
         case CMD_XMIT_SEQUENCE64_CR:
                 /* word3 iocb=io_tag32 wqe=reserved */
                 wqe->xmit_sequence.rsvd3 = 0;
@@ -13529,6 +13529,7 @@ lpfc_sli4_sp_handle_rcqe(struct lpfc_hba *phba, struct lpfc_rcqe *rcqe)
         case FC_STATUS_RQ_BUF_LEN_EXCEEDED:
                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
                                 "2537 Receive Frame Truncated!!\n");
+                /* fall through */
         case FC_STATUS_RQ_SUCCESS:
                 spin_lock_irqsave(&phba->hbalock, iflags);
                 lpfc_sli4_rq_release(hrq, drq);
@@ -13938,7 +13939,7 @@ lpfc_sli4_nvmet_handle_rcqe(struct lpfc_hba *phba, struct lpfc_queue *cq,
         case FC_STATUS_RQ_BUF_LEN_EXCEEDED:
                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
                                 "6126 Receive Frame Truncated!!\n");
-                /* Drop thru */
+                /* fall through */
         case FC_STATUS_RQ_SUCCESS:
                 spin_lock_irqsave(&phba->hbalock, iflags);
                 lpfc_sli4_rq_release(hrq, drq);
@@ -14613,9 +14614,9 @@ lpfc_sli4_queue_alloc(struct lpfc_hba *phba, uint32_t page_size,
                 dmabuf = kzalloc(sizeof(struct lpfc_dmabuf), GFP_KERNEL);
                 if (!dmabuf)
                         goto out_fail;
-                dmabuf->virt = dma_zalloc_coherent(&phba->pcidev->dev,
-                                                   hw_page_size, &dmabuf->phys,
-                                                   GFP_KERNEL);
+                dmabuf->virt = dma_alloc_coherent(&phba->pcidev->dev,
+                                                  hw_page_size, &dmabuf->phys,
+                                                  GFP_KERNEL);
                 if (!dmabuf->virt) {
                         kfree(dmabuf);
                         goto out_fail;
@@ -14850,7 +14851,7 @@ lpfc_eq_create(struct lpfc_hba *phba, struct lpfc_queue *eq, uint32_t imax)
                                 eq->entry_count);
                 if (eq->entry_count < 256)
                         return -EINVAL;
-                /* otherwise default to smallest count (drop through) */
+                /* fall through - otherwise default to smallest count */
         case 256:
                 bf_set(lpfc_eq_context_count, &eq_create->u.request.context,
                        LPFC_EQ_CNT_256);
@@ -14981,7 +14982,7 @@ lpfc_cq_create(struct lpfc_hba *phba, struct lpfc_queue *cq,
                                LPFC_CQ_CNT_WORD7);
                         break;
                 }
-                /* Fall Thru */
+                /* fall through */
         default:
                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
                                 "0361 Unsupported CQ count: "
@@ -14992,7 +14993,7 @@ lpfc_cq_create(struct lpfc_hba *phba, struct lpfc_queue *cq,
                         status = -EINVAL;
                         goto out;
                 }
-                /* otherwise default to smallest count (drop through) */
+                /* fall through - otherwise default to smallest count */
         case 256:
                 bf_set(lpfc_cq_context_count, &cq_create->u.request.context,
                        LPFC_CQ_CNT_256);
@@ -15152,7 +15153,7 @@ lpfc_cq_create_set(struct lpfc_hba *phba, struct lpfc_queue **cqp,
                                                LPFC_CQ_CNT_WORD7);
                                         break;
                                 }
-                                /* Fall Thru */
+                                /* fall through */
                         default:
                                 lpfc_printf_log(phba, KERN_ERR, LOG_SLI,
                                                 "3118 Bad CQ count. (%d)\n",
@@ -15161,7 +15162,7 @@ lpfc_cq_create_set(struct lpfc_hba *phba, struct lpfc_queue **cqp,
                                         status = -EINVAL;
                                         goto out;
                                 }
-                                /* otherwise default to smallest (drop thru) */
+                                /* fall through - otherwise default to smallest */
                         case 256:
                                 bf_set(lpfc_mbx_cq_create_set_cqe_cnt,
                                        &cq_set->u.request, LPFC_CQ_CNT_256);
@@ -15433,7 +15434,7 @@ lpfc_mq_create(struct lpfc_hba *phba, struct lpfc_queue *mq,
                         status = -EINVAL;
                         goto out;
                 }
-                /* otherwise default to smallest count (drop through) */
+                /* fall through - otherwise default to smallest count */
         case 16:
                 bf_set(lpfc_mq_context_ring_size,
                        &mq_create_ext->u.request.context,
@@ -15852,7 +15853,7 @@ lpfc_rq_create(struct lpfc_hba *phba, struct lpfc_queue *hrq,
                                 status = -EINVAL;
                                 goto out;
                         }
-                        /* otherwise default to smallest count (drop through) */
+                        /* fall through - otherwise default to smallest count */
                 case 512:
                         bf_set(lpfc_rq_context_rqe_count,
                                &rq_create->u.request.context,
@@ -15989,7 +15990,7 @@ lpfc_rq_create(struct lpfc_hba *phba, struct lpfc_queue *hrq,
                                 status = -EINVAL;
                                 goto out;
                         }
-                        /* otherwise default to smallest count (drop through) */
+                        /* fall through - otherwise default to smallest count */
                 case 512:
                         bf_set(lpfc_rq_context_rqe_count,
                                &rq_create->u.request.context,
diff --git a/drivers/scsi/megaraid/megaraid_mbox.c b/drivers/scsi/megaraid/megaraid_mbox.c
index e836392b75e8..f112458023ff 100644
--- a/drivers/scsi/megaraid/megaraid_mbox.c
+++ b/drivers/scsi/megaraid/megaraid_mbox.c
@@ -967,9 +967,10 @@ megaraid_alloc_cmd_packets(adapter_t *adapter)
          * Allocate the common 16-byte aligned memory for the handshake
          * mailbox.
          */
-        raid_dev->una_mbox64 = dma_zalloc_coherent(&adapter->pdev->dev,
-                        sizeof(mbox64_t), &raid_dev->una_mbox64_dma,
-                        GFP_KERNEL);
+        raid_dev->una_mbox64 = dma_alloc_coherent(&adapter->pdev->dev,
+                                                  sizeof(mbox64_t),
+                                                  &raid_dev->una_mbox64_dma,
+                                                  GFP_KERNEL);
 
         if (!raid_dev->una_mbox64) {
                 con_log(CL_ANN, (KERN_WARNING
@@ -995,8 +996,8 @@ megaraid_alloc_cmd_packets(adapter_t *adapter)
                         align;
 
         // Allocate memory for commands issued internally
-        adapter->ibuf = dma_zalloc_coherent(&pdev->dev, MBOX_IBUF_SIZE,
-                        &adapter->ibuf_dma_h, GFP_KERNEL);
+        adapter->ibuf = dma_alloc_coherent(&pdev->dev, MBOX_IBUF_SIZE,
+                                           &adapter->ibuf_dma_h, GFP_KERNEL);
         if (!adapter->ibuf) {
 
                 con_log(CL_ANN, (KERN_WARNING
@@ -2897,8 +2898,8 @@ megaraid_mbox_product_info(adapter_t *adapter)
          * Issue an ENQUIRY3 command to find out certain adapter parameters,
          * e.g., max channels, max commands etc.
          */
-        pinfo = dma_zalloc_coherent(&adapter->pdev->dev, sizeof(mraid_pinfo_t),
-                        &pinfo_dma_h, GFP_KERNEL);
+        pinfo = dma_alloc_coherent(&adapter->pdev->dev, sizeof(mraid_pinfo_t),
+                                   &pinfo_dma_h, GFP_KERNEL);
         if (pinfo == NULL) {
                 con_log(CL_ANN, (KERN_WARNING
                         "megaraid: out of memory, %s %d\n", __func__,
diff --git a/drivers/scsi/megaraid/megaraid_sas_base.c b/drivers/scsi/megaraid/megaraid_sas_base.c
index f7bdd783360a..fcbff83c0097 100644
--- a/drivers/scsi/megaraid/megaraid_sas_base.c
+++ b/drivers/scsi/megaraid/megaraid_sas_base.c
@@ -2273,9 +2273,9 @@ static int megasas_get_ld_vf_affiliation_111(struct megasas_instance *instance,
                                sizeof(struct MR_LD_VF_AFFILIATION_111));
         else {
                 new_affiliation_111 =
-                        dma_zalloc_coherent(&instance->pdev->dev,
-                                              sizeof(struct MR_LD_VF_AFFILIATION_111),
-                                              &new_affiliation_111_h, GFP_KERNEL);
+                        dma_alloc_coherent(&instance->pdev->dev,
+                                           sizeof(struct MR_LD_VF_AFFILIATION_111),
+                                           &new_affiliation_111_h, GFP_KERNEL);
                 if (!new_affiliation_111) {
                         dev_printk(KERN_DEBUG, &instance->pdev->dev, "SR-IOV: Couldn't allocate "
                                "memory for new affiliation for scsi%d\n",
@@ -2380,10 +2380,9 @@ static int megasas_get_ld_vf_affiliation_12(struct megasas_instance *instance,
                        sizeof(struct MR_LD_VF_AFFILIATION));
         else {
                 new_affiliation =
-                        dma_zalloc_coherent(&instance->pdev->dev,
-                                              (MAX_LOGICAL_DRIVES + 1) *
-                                              sizeof(struct MR_LD_VF_AFFILIATION),
-                                              &new_affiliation_h, GFP_KERNEL);
+                        dma_alloc_coherent(&instance->pdev->dev,
+                                           (MAX_LOGICAL_DRIVES + 1) * sizeof(struct MR_LD_VF_AFFILIATION),
+                                           &new_affiliation_h, GFP_KERNEL);
                 if (!new_affiliation) {
                         dev_printk(KERN_DEBUG, &instance->pdev->dev, "SR-IOV: Couldn't allocate "
                                "memory for new affiliation for scsi%d\n",
@@ -2546,9 +2545,10 @@ int megasas_sriov_start_heartbeat(struct megasas_instance *instance,
 
         if (initial) {
                 instance->hb_host_mem =
-                        dma_zalloc_coherent(&instance->pdev->dev,
-                                              sizeof(struct MR_CTRL_HB_HOST_MEM),
-                                              &instance->hb_host_mem_h, GFP_KERNEL);
+                        dma_alloc_coherent(&instance->pdev->dev,
+                                           sizeof(struct MR_CTRL_HB_HOST_MEM),
+                                           &instance->hb_host_mem_h,
+                                           GFP_KERNEL);
                 if (!instance->hb_host_mem) {
                         dev_printk(KERN_DEBUG, &instance->pdev->dev, "SR-IOV: Couldn't allocate"
                                " memory for heartbeat host memory for scsi%d\n",
@@ -5816,9 +5816,9 @@ megasas_get_seq_num(struct megasas_instance *instance,
         }
 
         dcmd = &cmd->frame->dcmd;
-        el_info = dma_zalloc_coherent(&instance->pdev->dev,
-                        sizeof(struct megasas_evt_log_info), &el_info_h,
-                        GFP_KERNEL);
+        el_info = dma_alloc_coherent(&instance->pdev->dev,
+                                     sizeof(struct megasas_evt_log_info),
+                                     &el_info_h, GFP_KERNEL);
         if (!el_info) {
                 megasas_return_cmd(instance, cmd);
                 return -ENOMEM;
@@ -6236,7 +6236,7 @@ megasas_set_dma_mask(struct megasas_instance *instance)
                 instance->consistent_mask_64bit = true;
 
         dev_info(&pdev->dev, "%s bit DMA mask and %s bit consistent mask\n",
-                 ((*pdev->dev.dma_mask == DMA_BIT_MASK(64)) ? "63" : "32"),
+                 ((*pdev->dev.dma_mask == DMA_BIT_MASK(63)) ? "63" : "32"),
                  (instance->consistent_mask_64bit ? "63" : "32"));
 
         return 0;
diff --git a/drivers/scsi/megaraid/megaraid_sas_fusion.c b/drivers/scsi/megaraid/megaraid_sas_fusion.c
index 211c17c33aa0..647f48a28f85 100644
--- a/drivers/scsi/megaraid/megaraid_sas_fusion.c
+++ b/drivers/scsi/megaraid/megaraid_sas_fusion.c
@@ -175,7 +175,8 @@ megasas_clear_intr_fusion(struct megasas_instance *instance)
         /*
          * Check if it is our interrupt
          */
-        status = readl(&regs->outbound_intr_status);
+        status = megasas_readl(instance,
+                               &regs->outbound_intr_status);
 
         if (status & 1) {
                 writel(status, &regs->outbound_intr_status);
@@ -689,8 +690,9 @@ megasas_alloc_rdpq_fusion(struct megasas_instance *instance)
         array_size = sizeof(struct MPI2_IOC_INIT_RDPQ_ARRAY_ENTRY) *
                      MAX_MSIX_QUEUES_FUSION;
 
-        fusion->rdpq_virt = dma_zalloc_coherent(&instance->pdev->dev,
-                        array_size, &fusion->rdpq_phys, GFP_KERNEL);
+        fusion->rdpq_virt = dma_alloc_coherent(&instance->pdev->dev,
+                                               array_size, &fusion->rdpq_phys,
+                                               GFP_KERNEL);
         if (!fusion->rdpq_virt) {
                 dev_err(&instance->pdev->dev,
                         "Failed from %s %d\n",  __func__, __LINE__);
diff --git a/drivers/scsi/mesh.c b/drivers/scsi/mesh.c
index f3e182eb0970..c9dc7740e9e7 100644
--- a/drivers/scsi/mesh.c
+++ b/drivers/scsi/mesh.c
@@ -1915,8 +1915,9 @@ static int mesh_probe(struct macio_dev *mdev, const struct of_device_id *match)
         /* We use the PCI APIs for now until the generic one gets fixed
          * enough or until we get some macio-specific versions
          */
-        dma_cmd_space = dma_zalloc_coherent(&macio_get_pci_dev(mdev)->dev,
-                        ms->dma_cmd_size, &dma_cmd_bus, GFP_KERNEL);
+        dma_cmd_space = dma_alloc_coherent(&macio_get_pci_dev(mdev)->dev,
+                                           ms->dma_cmd_size, &dma_cmd_bus,
+                                           GFP_KERNEL);
         if (dma_cmd_space == NULL) {
                 printk(KERN_ERR "mesh: can't allocate DMA table\n");
                 goto out_unmap;
diff --git a/drivers/scsi/mvumi.c b/drivers/scsi/mvumi.c
index dbe753fba486..36f64205ecfa 100644
--- a/drivers/scsi/mvumi.c
+++ b/drivers/scsi/mvumi.c
@@ -143,8 +143,9 @@ static struct mvumi_res *mvumi_alloc_mem_resource(struct mvumi_hba *mhba,
 
         case RESOURCE_UNCACHED_MEMORY:
                 size = round_up(size, 8);
-                res->virt_addr = dma_zalloc_coherent(&mhba->pdev->dev, size,
-                                &res->bus_addr, GFP_KERNEL);
+                res->virt_addr = dma_alloc_coherent(&mhba->pdev->dev, size,
+                                                    &res->bus_addr,
+                                                    GFP_KERNEL);
                 if (!res->virt_addr) {
                         dev_err(&mhba->pdev->dev,
                                         "unable to allocate consistent mem,"
@@ -246,8 +247,8 @@ static int mvumi_internal_cmd_sgl(struct mvumi_hba *mhba, struct mvumi_cmd *cmd,
         if (size == 0)
                 return 0;
 
-        virt_addr = dma_zalloc_coherent(&mhba->pdev->dev, size, &phy_addr,
-                        GFP_KERNEL);
+        virt_addr = dma_alloc_coherent(&mhba->pdev->dev, size, &phy_addr,
+                                       GFP_KERNEL);
         if (!virt_addr)
                 return -1;
 
diff --git a/drivers/scsi/pm8001/pm8001_sas.c b/drivers/scsi/pm8001/pm8001_sas.c
index b3be49d41375..084f2fcced0a 100644
--- a/drivers/scsi/pm8001/pm8001_sas.c
+++ b/drivers/scsi/pm8001/pm8001_sas.c
@@ -116,8 +116,8 @@ int pm8001_mem_alloc(struct pci_dev *pdev, void **virt_addr,
         u64 align_offset = 0;
         if (align)
                 align_offset = (dma_addr_t)align - 1;
-        mem_virt_alloc = dma_zalloc_coherent(&pdev->dev, mem_size + align,
-                        &mem_dma_handle, GFP_KERNEL);
+        mem_virt_alloc = dma_alloc_coherent(&pdev->dev, mem_size + align,
+                                            &mem_dma_handle, GFP_KERNEL);
         if (!mem_virt_alloc) {
                 pm8001_printk("memory allocation error\n");
                 return -1;
@@ -657,7 +657,7 @@ static int pm8001_dev_found_notify(struct domain_device *dev)
                 if (dev->dev_type == SAS_SATA_DEV) {
                         pm8001_device->attached_phy =
                                 dev->rphy->identify.phy_identifier;
-                                flag = 1; /* directly sata*/
+                        flag = 1; /* directly sata */
                 }
         } /*register this device to HBA*/
         PM8001_DISC_DBG(pm8001_ha, pm8001_printk("Found device\n"));
diff --git a/drivers/scsi/qedf/qedf_main.c b/drivers/scsi/qedf/qedf_main.c
index edcaf4b0cb0b..9bbc19fc190b 100644
--- a/drivers/scsi/qedf/qedf_main.c
+++ b/drivers/scsi/qedf/qedf_main.c
@@ -1050,16 +1050,17 @@ static int qedf_alloc_sq(struct qedf_ctx *qedf, struct qedf_rport *fcport)
             sizeof(void *);
         fcport->sq_pbl_size = fcport->sq_pbl_size + QEDF_PAGE_SIZE;
 
-        fcport->sq = dma_zalloc_coherent(&qedf->pdev->dev,
-            fcport->sq_mem_size, &fcport->sq_dma, GFP_KERNEL);
+        fcport->sq = dma_alloc_coherent(&qedf->pdev->dev, fcport->sq_mem_size,
+                                        &fcport->sq_dma, GFP_KERNEL);
         if (!fcport->sq) {
                 QEDF_WARN(&(qedf->dbg_ctx), "Could not allocate send queue.\n");
                 rval = 1;
                 goto out;
         }
 
-        fcport->sq_pbl = dma_zalloc_coherent(&qedf->pdev->dev,
-            fcport->sq_pbl_size, &fcport->sq_pbl_dma, GFP_KERNEL);
+        fcport->sq_pbl = dma_alloc_coherent(&qedf->pdev->dev,
+                                            fcport->sq_pbl_size,
+                                            &fcport->sq_pbl_dma, GFP_KERNEL);
         if (!fcport->sq_pbl) {
                 QEDF_WARN(&(qedf->dbg_ctx), "Could not allocate send queue PBL.\n");
                 rval = 1;
@@ -2680,8 +2681,10 @@ static int qedf_alloc_bdq(struct qedf_ctx *qedf)
         }
 
         /* Allocate list of PBL pages */
-        qedf->bdq_pbl_list = dma_zalloc_coherent(&qedf->pdev->dev,
-            QEDF_PAGE_SIZE, &qedf->bdq_pbl_list_dma, GFP_KERNEL);
+        qedf->bdq_pbl_list = dma_alloc_coherent(&qedf->pdev->dev,
+                                                QEDF_PAGE_SIZE,
+                                                &qedf->bdq_pbl_list_dma,
+                                                GFP_KERNEL);
         if (!qedf->bdq_pbl_list) {
                 QEDF_ERR(&(qedf->dbg_ctx), "Could not allocate list of PBL pages.\n");
                 return -ENOMEM;
@@ -2770,9 +2773,10 @@ static int qedf_alloc_global_queues(struct qedf_ctx *qedf)
                     ALIGN(qedf->global_queues[i]->cq_pbl_size, QEDF_PAGE_SIZE);
 
                 qedf->global_queues[i]->cq =
-                    dma_zalloc_coherent(&qedf->pdev->dev,
-                        qedf->global_queues[i]->cq_mem_size,
-                        &qedf->global_queues[i]->cq_dma, GFP_KERNEL);
+                    dma_alloc_coherent(&qedf->pdev->dev,
+                                       qedf->global_queues[i]->cq_mem_size,
+                                       &qedf->global_queues[i]->cq_dma,
+                                       GFP_KERNEL);
 
                 if (!qedf->global_queues[i]->cq) {
                         QEDF_WARN(&(qedf->dbg_ctx), "Could not allocate cq.\n");
@@ -2781,9 +2785,10 @@ static int qedf_alloc_global_queues(struct qedf_ctx *qedf)
                 }
 
                 qedf->global_queues[i]->cq_pbl =
-                    dma_zalloc_coherent(&qedf->pdev->dev,
-                        qedf->global_queues[i]->cq_pbl_size,
-                        &qedf->global_queues[i]->cq_pbl_dma, GFP_KERNEL);
+                    dma_alloc_coherent(&qedf->pdev->dev,
+                                       qedf->global_queues[i]->cq_pbl_size,
+                                       &qedf->global_queues[i]->cq_pbl_dma,
+                                       GFP_KERNEL);
 
                 if (!qedf->global_queues[i]->cq_pbl) {
                         QEDF_WARN(&(qedf->dbg_ctx), "Could not allocate cq PBL.\n");
diff --git a/drivers/scsi/qedi/qedi_iscsi.c b/drivers/scsi/qedi/qedi_iscsi.c
index 4da660c1c431..6d6d6013e35b 100644
--- a/drivers/scsi/qedi/qedi_iscsi.c
+++ b/drivers/scsi/qedi/qedi_iscsi.c
@@ -953,6 +953,7 @@ static int qedi_ep_poll(struct iscsi_endpoint *ep, int timeout_ms)
 
         qedi_ep = ep->dd_data;
         if (qedi_ep->state == EP_STATE_IDLE ||
+            qedi_ep->state == EP_STATE_OFLDCONN_NONE ||
             qedi_ep->state == EP_STATE_OFLDCONN_FAILED)
                 return -1;
 
@@ -1035,6 +1036,7 @@ static void qedi_ep_disconnect(struct iscsi_endpoint *ep)
 
         switch (qedi_ep->state) {
         case EP_STATE_OFLDCONN_START:
+        case EP_STATE_OFLDCONN_NONE:
                 goto ep_release_conn;
         case EP_STATE_OFLDCONN_FAILED:
                         break;
@@ -1225,6 +1227,7 @@ static int qedi_set_path(struct Scsi_Host *shost, struct iscsi_path *path_data)
 
         if (!is_valid_ether_addr(&path_data->mac_addr[0])) {
                 QEDI_NOTICE(&qedi->dbg_ctx, "dst mac NOT VALID\n");
+                qedi_ep->state = EP_STATE_OFLDCONN_NONE;
                 ret = -EIO;
                 goto set_path_exit;
         }
diff --git a/drivers/scsi/qedi/qedi_iscsi.h b/drivers/scsi/qedi/qedi_iscsi.h
index 11260776212f..892d70d54553 100644
--- a/drivers/scsi/qedi/qedi_iscsi.h
+++ b/drivers/scsi/qedi/qedi_iscsi.h
@@ -59,6 +59,7 @@ enum {
         EP_STATE_OFLDCONN_FAILED        = 0x2000,
         EP_STATE_CONNECT_FAILED         = 0x4000,
         EP_STATE_DISCONN_TIMEDOUT       = 0x8000,
+        EP_STATE_OFLDCONN_NONE          = 0x10000,
 };
 
 struct qedi_conn;
diff --git a/drivers/scsi/qedi/qedi_main.c b/drivers/scsi/qedi/qedi_main.c
index 5c53409a8cea..e74a62448ba4 100644
--- a/drivers/scsi/qedi/qedi_main.c
+++ b/drivers/scsi/qedi/qedi_main.c
@@ -1394,10 +1394,9 @@ static int qedi_alloc_nvm_iscsi_cfg(struct qedi_ctx *qedi)
 {
         struct qedi_nvm_iscsi_image nvm_image;
 
-        qedi->iscsi_image = dma_zalloc_coherent(&qedi->pdev->dev,
-                                                sizeof(nvm_image),
-                                                &qedi->nvm_buf_dma,
-                                                GFP_KERNEL);
+        qedi->iscsi_image = dma_alloc_coherent(&qedi->pdev->dev,
+                                               sizeof(nvm_image),
+                                               &qedi->nvm_buf_dma, GFP_KERNEL);
         if (!qedi->iscsi_image) {
                 QEDI_ERR(&qedi->dbg_ctx, "Could not allocate NVM BUF.\n");
                 return -ENOMEM;
@@ -1510,10 +1509,10 @@ static int qedi_alloc_bdq(struct qedi_ctx *qedi)
         }
 
         /* Allocate list of PBL pages */
-        qedi->bdq_pbl_list = dma_zalloc_coherent(&qedi->pdev->dev,
-                                                 QEDI_PAGE_SIZE,
-                                                 &qedi->bdq_pbl_list_dma,
-                                                 GFP_KERNEL);
+        qedi->bdq_pbl_list = dma_alloc_coherent(&qedi->pdev->dev,
+                                                QEDI_PAGE_SIZE,
+                                                &qedi->bdq_pbl_list_dma,
+                                                GFP_KERNEL);
         if (!qedi->bdq_pbl_list) {
                 QEDI_ERR(&qedi->dbg_ctx,
                          "Could not allocate list of PBL pages.\n");
@@ -1609,10 +1608,10 @@ static int qedi_alloc_global_queues(struct qedi_ctx *qedi)
                     (qedi->global_queues[i]->cq_pbl_size +
                     (QEDI_PAGE_SIZE - 1));
 
-                qedi->global_queues[i]->cq = dma_zalloc_coherent(&qedi->pdev->dev,
-                                                                 qedi->global_queues[i]->cq_mem_size,
-                                                                 &qedi->global_queues[i]->cq_dma,
-                                                                 GFP_KERNEL);
+                qedi->global_queues[i]->cq = dma_alloc_coherent(&qedi->pdev->dev,
+                                                                qedi->global_queues[i]->cq_mem_size,
+                                                                &qedi->global_queues[i]->cq_dma,
+                                                                GFP_KERNEL);
 
                 if (!qedi->global_queues[i]->cq) {
                         QEDI_WARN(&qedi->dbg_ctx,
@@ -1620,10 +1619,10 @@ static int qedi_alloc_global_queues(struct qedi_ctx *qedi)
                         status = -ENOMEM;
                         goto mem_alloc_failure;
                 }
-                qedi->global_queues[i]->cq_pbl = dma_zalloc_coherent(&qedi->pdev->dev,
-                                                                     qedi->global_queues[i]->cq_pbl_size,
-                                                                     &qedi->global_queues[i]->cq_pbl_dma,
-                                                                     GFP_KERNEL);
+                qedi->global_queues[i]->cq_pbl = dma_alloc_coherent(&qedi->pdev->dev,
+                                                                    qedi->global_queues[i]->cq_pbl_size,
+                                                                    &qedi->global_queues[i]->cq_pbl_dma,
+                                                                    GFP_KERNEL);
 
                 if (!qedi->global_queues[i]->cq_pbl) {
                         QEDI_WARN(&qedi->dbg_ctx,
@@ -1691,16 +1690,16 @@ int qedi_alloc_sq(struct qedi_ctx *qedi, struct qedi_endpoint *ep)
         ep->sq_pbl_size = (ep->sq_mem_size / QEDI_PAGE_SIZE) * sizeof(void *);
         ep->sq_pbl_size = ep->sq_pbl_size + QEDI_PAGE_SIZE;
 
-        ep->sq = dma_zalloc_coherent(&qedi->pdev->dev, ep->sq_mem_size,
-                                     &ep->sq_dma, GFP_KERNEL);
+        ep->sq = dma_alloc_coherent(&qedi->pdev->dev, ep->sq_mem_size,
+                                    &ep->sq_dma, GFP_KERNEL);
         if (!ep->sq) {
                 QEDI_WARN(&qedi->dbg_ctx,
                           "Could not allocate send queue.\n");
                 rval = -ENOMEM;
                 goto out;
         }
-        ep->sq_pbl = dma_zalloc_coherent(&qedi->pdev->dev, ep->sq_pbl_size,
-                                         &ep->sq_pbl_dma, GFP_KERNEL);
+        ep->sq_pbl = dma_alloc_coherent(&qedi->pdev->dev, ep->sq_pbl_size,
+                                        &ep->sq_pbl_dma, GFP_KERNEL);
         if (!ep->sq_pbl) {
                 QEDI_WARN(&qedi->dbg_ctx,
                           "Could not allocate send queue PBL.\n");
diff --git a/drivers/scsi/qla1280.c b/drivers/scsi/qla1280.c
index a414f51302b7..6856dfdfa473 100644
--- a/drivers/scsi/qla1280.c
+++ b/drivers/scsi/qla1280.c
@@ -4248,7 +4248,7 @@ qla1280_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
         ha->devnum = devnum;    /* specifies microcode load address */
 
 #ifdef QLA_64BIT_PTR
-        if (dma_set_mask(&ha->pdev->dev, DMA_BIT_MASK(64))) {
+        if (dma_set_mask_and_coherent(&ha->pdev->dev, DMA_BIT_MASK(64))) {
                 if (dma_set_mask(&ha->pdev->dev, DMA_BIT_MASK(32))) {
                         printk(KERN_WARNING "scsi(%li): Unable to set a "
                                "suitable DMA mask - aborting\n", ha->host_no);
diff --git a/drivers/scsi/qla2xxx/qla_attr.c b/drivers/scsi/qla2xxx/qla_attr.c
index 00444dc79756..ac504a1ff0ff 100644
--- a/drivers/scsi/qla2xxx/qla_attr.c
+++ b/drivers/scsi/qla2xxx/qla_attr.c
@@ -2415,8 +2415,8 @@ qla2x00_get_fc_host_stats(struct Scsi_Host *shost)
         if (qla2x00_chip_is_down(vha))
                 goto done;
 
-        stats = dma_zalloc_coherent(&ha->pdev->dev, sizeof(*stats),
-                                    &stats_dma, GFP_KERNEL);
+        stats = dma_alloc_coherent(&ha->pdev->dev, sizeof(*stats), &stats_dma,
+                                   GFP_KERNEL);
         if (!stats) {
                 ql_log(ql_log_warn, vha, 0x707d,
                     "Failed to allocate memory for stats.\n");
diff --git a/drivers/scsi/qla2xxx/qla_bsg.c b/drivers/scsi/qla2xxx/qla_bsg.c
index 4a9fd8d944d6..17d42658ad9a 100644
--- a/drivers/scsi/qla2xxx/qla_bsg.c
+++ b/drivers/scsi/qla2xxx/qla_bsg.c
@@ -2312,8 +2312,8 @@ qla2x00_get_priv_stats(struct bsg_job *bsg_job)
         if (!IS_FWI2_CAPABLE(ha))
                 return -EPERM;
 
-        stats = dma_zalloc_coherent(&ha->pdev->dev, sizeof(*stats),
-                                    &stats_dma, GFP_KERNEL);
+        stats = dma_alloc_coherent(&ha->pdev->dev, sizeof(*stats), &stats_dma,
+                                   GFP_KERNEL);
         if (!stats) {
                 ql_log(ql_log_warn, vha, 0x70e2,
                     "Failed to allocate memory for stats.\n");
diff --git a/drivers/scsi/qla2xxx/qla_def.h b/drivers/scsi/qla2xxx/qla_def.h
index 26b93c563f92..d1fc4958222a 100644
--- a/drivers/scsi/qla2xxx/qla_def.h
+++ b/drivers/scsi/qla2xxx/qla_def.h
@@ -4394,6 +4394,8 @@ typedef struct scsi_qla_host {
         uint16_t        n2n_id;
         struct list_head gpnid_list;
         struct fab_scan scan;
+
+        unsigned int irq_offset;
 } scsi_qla_host_t;
 
 struct qla27xx_image_status {
diff --git a/drivers/scsi/qla2xxx/qla_gs.c b/drivers/scsi/qla2xxx/qla_gs.c
index 90cfa394f942..cbc3bc49d4d1 100644
--- a/drivers/scsi/qla2xxx/qla_gs.c
+++ b/drivers/scsi/qla2xxx/qla_gs.c
@@ -4147,9 +4147,10 @@ int qla24xx_async_gpnft(scsi_qla_host_t *vha, u8 fc4_type, srb_t *sp)
                         return rval;
                 }
 
-                sp->u.iocb_cmd.u.ctarg.req = dma_zalloc_coherent(
-                        &vha->hw->pdev->dev, sizeof(struct ct_sns_pkt),
-                        &sp->u.iocb_cmd.u.ctarg.req_dma, GFP_KERNEL);
+                sp->u.iocb_cmd.u.ctarg.req = dma_alloc_coherent(&vha->hw->pdev->dev,
+                                                                sizeof(struct ct_sns_pkt),
+                                                                &sp->u.iocb_cmd.u.ctarg.req_dma,
+                                                                GFP_KERNEL);
                 sp->u.iocb_cmd.u.ctarg.req_allocated_size = sizeof(struct ct_sns_pkt);
                 if (!sp->u.iocb_cmd.u.ctarg.req) {
                         ql_log(ql_log_warn, vha, 0xffff,
@@ -4165,9 +4166,10 @@ int qla24xx_async_gpnft(scsi_qla_host_t *vha, u8 fc4_type, srb_t *sp)
                         ((vha->hw->max_fibre_devices - 1) *
                             sizeof(struct ct_sns_gpn_ft_data));
 
-                sp->u.iocb_cmd.u.ctarg.rsp = dma_zalloc_coherent(
-                        &vha->hw->pdev->dev, rspsz,
-                        &sp->u.iocb_cmd.u.ctarg.rsp_dma, GFP_KERNEL);
+                sp->u.iocb_cmd.u.ctarg.rsp = dma_alloc_coherent(&vha->hw->pdev->dev,
+                                                                rspsz,
+                                                                &sp->u.iocb_cmd.u.ctarg.rsp_dma,
+                                                                GFP_KERNEL);
                 sp->u.iocb_cmd.u.ctarg.rsp_allocated_size = sizeof(struct ct_sns_pkt);
                 if (!sp->u.iocb_cmd.u.ctarg.rsp) {
                         ql_log(ql_log_warn, vha, 0xffff,
diff --git a/drivers/scsi/qla2xxx/qla_init.c b/drivers/scsi/qla2xxx/qla_init.c
index 364bb52ed2a6..aeeb0144bd55 100644
--- a/drivers/scsi/qla2xxx/qla_init.c
+++ b/drivers/scsi/qla2xxx/qla_init.c
@@ -3099,8 +3099,8 @@ qla2x00_alloc_offload_mem(scsi_qla_host_t *vha)
                             FCE_SIZE, ha->fce, ha->fce_dma);
 
                 /* Allocate memory for Fibre Channel Event Buffer. */
-                tc = dma_zalloc_coherent(&ha->pdev->dev, FCE_SIZE, &tc_dma,
-                                         GFP_KERNEL);
+                tc = dma_alloc_coherent(&ha->pdev->dev, FCE_SIZE, &tc_dma,
+                                        GFP_KERNEL);
                 if (!tc) {
                         ql_log(ql_log_warn, vha, 0x00be,
                             "Unable to allocate (%d KB) for FCE.\n",
@@ -3131,8 +3131,8 @@ try_eft:
                             EFT_SIZE, ha->eft, ha->eft_dma);
 
                 /* Allocate memory for Extended Trace Buffer. */
-                tc = dma_zalloc_coherent(&ha->pdev->dev, EFT_SIZE, &tc_dma,
-                                         GFP_KERNEL);
+                tc = dma_alloc_coherent(&ha->pdev->dev, EFT_SIZE, &tc_dma,
+                                        GFP_KERNEL);
                 if (!tc) {
                         ql_log(ql_log_warn, vha, 0x00c1,
                             "Unable to allocate (%d KB) for EFT.\n",
diff --git a/drivers/scsi/qla2xxx/qla_isr.c b/drivers/scsi/qla2xxx/qla_isr.c
index 30d3090842f8..8507c43b918c 100644
--- a/drivers/scsi/qla2xxx/qla_isr.c
+++ b/drivers/scsi/qla2xxx/qla_isr.c
@@ -3446,6 +3446,7 @@ qla24xx_enable_msix(struct qla_hw_data *ha, struct rsp_que *rsp)
                             "Adjusted Max no of queues pairs: %d.\n", ha->max_qpairs);
                 }
         }
+        vha->irq_offset = desc.pre_vectors;
         ha->msix_entries = kcalloc(ha->msix_count,
                                    sizeof(struct qla_msix_entry),
                                    GFP_KERNEL);
diff --git a/drivers/scsi/qla2xxx/qla_os.c b/drivers/scsi/qla2xxx/qla_os.c
index ea69dafc9774..c6ef83d0d99b 100644
--- a/drivers/scsi/qla2xxx/qla_os.c
+++ b/drivers/scsi/qla2xxx/qla_os.c
@@ -6939,7 +6939,7 @@ static int qla2xxx_map_queues(struct Scsi_Host *shost)
         if (USER_CTRL_IRQ(vha->hw))
                 rc = blk_mq_map_queues(qmap);
         else
-                rc = blk_mq_pci_map_queues(qmap, vha->hw->pdev, 0);
+                rc = blk_mq_pci_map_queues(qmap, vha->hw->pdev, vha->irq_offset);
         return rc;
 }
 
diff --git a/drivers/scsi/qla4xxx/ql4_init.c b/drivers/scsi/qla4xxx/ql4_init.c
index 1ef74aa2d00a..2bf5e3e639e1 100644
--- a/drivers/scsi/qla4xxx/ql4_init.c
+++ b/drivers/scsi/qla4xxx/ql4_init.c
@@ -153,8 +153,8 @@ int qla4xxx_get_sys_info(struct scsi_qla_host *ha)
         dma_addr_t sys_info_dma;
         int status = QLA_ERROR;
 
-        sys_info = dma_zalloc_coherent(&ha->pdev->dev, sizeof(*sys_info),
-                                       &sys_info_dma, GFP_KERNEL);
+        sys_info = dma_alloc_coherent(&ha->pdev->dev, sizeof(*sys_info),
+                                      &sys_info_dma, GFP_KERNEL);
         if (sys_info == NULL) {
                 DEBUG2(printk("scsi%ld: %s: Unable to allocate dma buffer.\n",
                               ha->host_no, __func__));
diff --git a/drivers/scsi/qla4xxx/ql4_mbx.c b/drivers/scsi/qla4xxx/ql4_mbx.c
index 5d56904687b9..dac9a7013208 100644
--- a/drivers/scsi/qla4xxx/ql4_mbx.c
+++ b/drivers/scsi/qla4xxx/ql4_mbx.c
@@ -625,9 +625,9 @@ int qla4xxx_initialize_fw_cb(struct scsi_qla_host * ha)
         uint32_t mbox_sts[MBOX_REG_COUNT];
         int status = QLA_ERROR;
 
-        init_fw_cb = dma_zalloc_coherent(&ha->pdev->dev,
-                                         sizeof(struct addr_ctrl_blk),
-                                         &init_fw_cb_dma, GFP_KERNEL);
+        init_fw_cb = dma_alloc_coherent(&ha->pdev->dev,
+                                        sizeof(struct addr_ctrl_blk),
+                                        &init_fw_cb_dma, GFP_KERNEL);
         if (init_fw_cb == NULL) {
                 DEBUG2(printk("scsi%ld: %s: Unable to alloc init_cb\n",
                               ha->host_no, __func__));
@@ -709,9 +709,9 @@ int qla4xxx_get_dhcp_ip_address(struct scsi_qla_host * ha)
         uint32_t mbox_cmd[MBOX_REG_COUNT];
         uint32_t mbox_sts[MBOX_REG_COUNT];
 
-        init_fw_cb = dma_zalloc_coherent(&ha->pdev->dev,
-                                         sizeof(struct addr_ctrl_blk),
-                                         &init_fw_cb_dma, GFP_KERNEL);
+        init_fw_cb = dma_alloc_coherent(&ha->pdev->dev,
+                                        sizeof(struct addr_ctrl_blk),
+                                        &init_fw_cb_dma, GFP_KERNEL);
         if (init_fw_cb == NULL) {
                 printk("scsi%ld: %s: Unable to alloc init_cb\n", ha->host_no,
                        __func__);
@@ -1340,9 +1340,9 @@ int qla4xxx_about_firmware(struct scsi_qla_host *ha)
         uint32_t mbox_sts[MBOX_REG_COUNT];
         int status = QLA_ERROR;
 
-        about_fw = dma_zalloc_coherent(&ha->pdev->dev,
-                                       sizeof(struct about_fw_info),
-                                       &about_fw_dma, GFP_KERNEL);
+        about_fw = dma_alloc_coherent(&ha->pdev->dev,
+                                      sizeof(struct about_fw_info),
+                                      &about_fw_dma, GFP_KERNEL);
         if (!about_fw) {
                 DEBUG2(ql4_printk(KERN_ERR, ha, "%s: Unable to alloc memory "
                                   "for about_fw\n", __func__));
diff --git a/drivers/scsi/qla4xxx/ql4_nx.c b/drivers/scsi/qla4xxx/ql4_nx.c
index d2b333d629be..5a31877c9d04 100644
--- a/drivers/scsi/qla4xxx/ql4_nx.c
+++ b/drivers/scsi/qla4xxx/ql4_nx.c
@@ -4052,8 +4052,8 @@ int qla4_8xxx_get_sys_info(struct scsi_qla_host *ha)
         dma_addr_t sys_info_dma;
         int status = QLA_ERROR;
 
-        sys_info = dma_zalloc_coherent(&ha->pdev->dev, sizeof(*sys_info),
-                                       &sys_info_dma, GFP_KERNEL);
+        sys_info = dma_alloc_coherent(&ha->pdev->dev, sizeof(*sys_info),
+                                      &sys_info_dma, GFP_KERNEL);
         if (sys_info == NULL) {
                 DEBUG2(printk("scsi%ld: %s: Unable to allocate dma buffer.\n",
                     ha->host_no, __func__));
diff --git a/drivers/scsi/qla4xxx/ql4_os.c b/drivers/scsi/qla4xxx/ql4_os.c
index 949e186cc5d7..a77bfb224248 100644
--- a/drivers/scsi/qla4xxx/ql4_os.c
+++ b/drivers/scsi/qla4xxx/ql4_os.c
@@ -2704,9 +2704,9 @@ qla4xxx_iface_set_param(struct Scsi_Host *shost, void *data, uint32_t len)
         uint32_t rem = len;
         struct nlattr *attr;
 
-        init_fw_cb = dma_zalloc_coherent(&ha->pdev->dev,
-                                         sizeof(struct addr_ctrl_blk),
-                                         &init_fw_cb_dma, GFP_KERNEL);
+        init_fw_cb = dma_alloc_coherent(&ha->pdev->dev,
+                                        sizeof(struct addr_ctrl_blk),
+                                        &init_fw_cb_dma, GFP_KERNEL);
         if (!init_fw_cb) {
                 ql4_printk(KERN_ERR, ha, "%s: Unable to alloc init_cb\n",
                            __func__);
@@ -4206,8 +4206,8 @@ static int qla4xxx_mem_alloc(struct scsi_qla_host *ha)
                           sizeof(struct shadow_regs) +
                           MEM_ALIGN_VALUE +
                           (PAGE_SIZE - 1)) & ~(PAGE_SIZE - 1);
-        ha->queues = dma_zalloc_coherent(&ha->pdev->dev, ha->queues_len,
-                                         &ha->queues_dma, GFP_KERNEL);
+        ha->queues = dma_alloc_coherent(&ha->pdev->dev, ha->queues_len,
+                                        &ha->queues_dma, GFP_KERNEL);
         if (ha->queues == NULL) {
                 ql4_printk(KERN_WARNING, ha,
                     "Memory Allocation failed - queues.\n");
@@ -7232,6 +7232,8 @@ static int qla4xxx_sysfs_ddb_tgt_create(struct scsi_qla_host *ha,
 
         rc = qla4xxx_copy_from_fwddb_param(fnode_sess, fnode_conn,
                                            fw_ddb_entry);
+        if (rc)
+                goto free_sess;
 
         ql4_printk(KERN_INFO, ha, "%s: sysfs entry %s created\n",
                    __func__, fnode_sess->dev.kobj.name);
diff --git a/drivers/scsi/scsi_lib.c b/drivers/scsi/scsi_lib.c
index b13cc9288ba0..6d65ac584eba 100644
--- a/drivers/scsi/scsi_lib.c
+++ b/drivers/scsi/scsi_lib.c
@@ -1842,8 +1842,8 @@ void __scsi_init_queue(struct Scsi_Host *shost, struct request_queue *q)
         blk_queue_segment_boundary(q, shost->dma_boundary);
         dma_set_seg_boundary(dev, shost->dma_boundary);
 
-        blk_queue_max_segment_size(q,
-                min(shost->max_segment_size, dma_get_max_seg_size(dev)));
+        blk_queue_max_segment_size(q, shost->max_segment_size);
+        dma_set_max_seg_size(dev, shost->max_segment_size);
 
         /*
          * Set a reasonable default alignment:  The larger of 32-byte (dword),
diff --git a/drivers/scsi/scsi_pm.c b/drivers/scsi/scsi_pm.c
index a2b4179bfdf7..7639df91b110 100644
--- a/drivers/scsi/scsi_pm.c
+++ b/drivers/scsi/scsi_pm.c
@@ -80,8 +80,22 @@ static int scsi_dev_type_resume(struct device *dev,
 
         if (err == 0) {
                 pm_runtime_disable(dev);
-                pm_runtime_set_active(dev);
+                err = pm_runtime_set_active(dev);
                 pm_runtime_enable(dev);
+
+                /*
+                 * Forcibly set runtime PM status of request queue to "active"
+                 * to make sure we can again get requests from the queue
+                 * (see also blk_pm_peek_request()).
+                 *
+                 * The resume hook will correct runtime PM status of the disk.
+                 */
+                if (!err && scsi_is_sdev_device(dev)) {
+                        struct scsi_device *sdev = to_scsi_device(dev);
+
+                        if (sdev->request_queue->dev)
+                                blk_set_runtime_active(sdev->request_queue);
+                }
         }
 
         return err;
@@ -140,16 +154,6 @@ static int scsi_bus_resume_common(struct device *dev,
         else
                 fn = NULL;
 
-        /*
-         * Forcibly set runtime PM status of request queue to "active" to
-         * make sure we can again get requests from the queue (see also
-         * blk_pm_peek_request()).
-         *
-         * The resume hook will correct runtime PM status of the disk.
-         */
-        if (scsi_is_sdev_device(dev) && pm_runtime_suspended(dev))
-                blk_set_runtime_active(to_scsi_device(dev)->request_queue);
-
         if (fn) {
                 async_schedule_domain(fn, dev, &scsi_sd_pm_domain);
 
diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c
index a1a44f52e0e8..b2da8a00ec33 100644
--- a/drivers/scsi/sd.c
+++ b/drivers/scsi/sd.c
@@ -206,6 +206,12 @@ cache_type_store(struct device *dev, struct device_attribute *attr,
         sp = buffer_data[0] & 0x80 ? 1 : 0;
         buffer_data[0] &= ~0x80;
 
+        /*
+         * Ensure WP, DPOFUA, and RESERVED fields are cleared in
+         * received mode parameter buffer before doing MODE SELECT.
+         */
+        data.device_specific = 0;
+
         if (scsi_mode_select(sdp, 1, sp, 8, buffer_data, len, SD_TIMEOUT,
                              SD_MAX_RETRIES, &data, &sshdr)) {
                 if (scsi_sense_valid(&sshdr))
diff --git a/drivers/scsi/smartpqi/smartpqi_init.c b/drivers/scsi/smartpqi/smartpqi_init.c
index e2fa3f476227..f564af8949e8 100644
--- a/drivers/scsi/smartpqi/smartpqi_init.c
+++ b/drivers/scsi/smartpqi/smartpqi_init.c
@@ -323,7 +323,7 @@ static inline void pqi_device_remove_start(struct pqi_scsi_dev *device)
 static inline bool pqi_device_in_remove(struct pqi_ctrl_info *ctrl_info,
                                         struct pqi_scsi_dev *device)
 {
-        return device->in_remove & !ctrl_info->in_shutdown;
+        return device->in_remove && !ctrl_info->in_shutdown;
 }
 
 static inline void pqi_schedule_rescan_worker_with_delay(
@@ -3576,9 +3576,9 @@ static int pqi_alloc_operational_queues(struct pqi_ctrl_info *ctrl_info)
         alloc_length += PQI_EXTRA_SGL_MEMORY;
 
         ctrl_info->queue_memory_base =
-                dma_zalloc_coherent(&ctrl_info->pci_dev->dev,
-                        alloc_length,
-                        &ctrl_info->queue_memory_base_dma_handle, GFP_KERNEL);
+                dma_alloc_coherent(&ctrl_info->pci_dev->dev, alloc_length,
+                                   &ctrl_info->queue_memory_base_dma_handle,
+                                   GFP_KERNEL);
 
         if (!ctrl_info->queue_memory_base)
                 return -ENOMEM;
@@ -3715,10 +3715,9 @@ static int pqi_alloc_admin_queues(struct pqi_ctrl_info *ctrl_info)
                 PQI_QUEUE_ELEMENT_ARRAY_ALIGNMENT;
 
         ctrl_info->admin_queue_memory_base =
-                dma_zalloc_coherent(&ctrl_info->pci_dev->dev,
-                        alloc_length,
-                        &ctrl_info->admin_queue_memory_base_dma_handle,
-                        GFP_KERNEL);
+                dma_alloc_coherent(&ctrl_info->pci_dev->dev, alloc_length,
+                                   &ctrl_info->admin_queue_memory_base_dma_handle,
+                                   GFP_KERNEL);
 
         if (!ctrl_info->admin_queue_memory_base)
                 return -ENOMEM;
@@ -4602,9 +4601,10 @@ static void pqi_free_all_io_requests(struct pqi_ctrl_info *ctrl_info)
 
 static inline int pqi_alloc_error_buffer(struct pqi_ctrl_info *ctrl_info)
 {
-        ctrl_info->error_buffer = dma_zalloc_coherent(&ctrl_info->pci_dev->dev,
-                ctrl_info->error_buffer_length,
-                &ctrl_info->error_buffer_dma_handle, GFP_KERNEL);
+        ctrl_info->error_buffer = dma_alloc_coherent(&ctrl_info->pci_dev->dev,
+                                                     ctrl_info->error_buffer_length,
+                                                     &ctrl_info->error_buffer_dma_handle,
+                                                     GFP_KERNEL);
 
         if (!ctrl_info->error_buffer)
                 return -ENOMEM;
@@ -7487,8 +7487,8 @@ static int pqi_ofa_alloc_mem(struct pqi_ctrl_info *ctrl_info,
                 dma_addr_t dma_handle;
 
                 ctrl_info->pqi_ofa_chunk_virt_addr[i] =
-                        dma_zalloc_coherent(dev, chunk_size, &dma_handle,
-                                                GFP_KERNEL);
+                        dma_alloc_coherent(dev, chunk_size, &dma_handle,
+                                           GFP_KERNEL);
 
                 if (!ctrl_info->pqi_ofa_chunk_virt_addr[i])
                         break;
@@ -7545,10 +7545,10 @@ static void pqi_ofa_setup_host_buffer(struct pqi_ctrl_info *ctrl_info,
         struct device *dev;
 
         dev = &ctrl_info->pci_dev->dev;
-        pqi_ofa_memory = dma_zalloc_coherent(dev,
-                                PQI_OFA_MEMORY_DESCRIPTOR_LENGTH,
-                                &ctrl_info->pqi_ofa_mem_dma_handle,
-                                GFP_KERNEL);
+        pqi_ofa_memory = dma_alloc_coherent(dev,
+                                            PQI_OFA_MEMORY_DESCRIPTOR_LENGTH,
+                                            &ctrl_info->pqi_ofa_mem_dma_handle,
+                                            GFP_KERNEL);
 
         if (!pqi_ofa_memory)
                 return;
diff --git a/drivers/scsi/ufs/ufs.h b/drivers/scsi/ufs/ufs.h
index dd65fea07687..6d176815e6ce 100644
--- a/drivers/scsi/ufs/ufs.h
+++ b/drivers/scsi/ufs/ufs.h
@@ -195,7 +195,7 @@ enum ufs_desc_def_size {
         QUERY_DESC_CONFIGURATION_DEF_SIZE       = 0x90,
         QUERY_DESC_UNIT_DEF_SIZE                = 0x23,
         QUERY_DESC_INTERCONNECT_DEF_SIZE        = 0x06,
-        QUERY_DESC_GEOMETRY_DEF_SIZE            = 0x44,
+        QUERY_DESC_GEOMETRY_DEF_SIZE            = 0x48,
         QUERY_DESC_POWER_DEF_SIZE               = 0x62,
         QUERY_DESC_HEALTH_DEF_SIZE              = 0x25,
 };
diff --git a/drivers/scsi/ufs/ufshcd.c b/drivers/scsi/ufs/ufshcd.c
index 9ba7671b84f8..2ddf24466a62 100644
--- a/drivers/scsi/ufs/ufshcd.c
+++ b/drivers/scsi/ufs/ufshcd.c
@@ -108,13 +108,19 @@
 int ufshcd_dump_regs(struct ufs_hba *hba, size_t offset, size_t len,
                      const char *prefix)
 {
-        u8 *regs;
+        u32 *regs;
+        size_t pos;
+
+        if (offset % 4 != 0 || len % 4 != 0) /* keep readl happy */
+                return -EINVAL;
 
         regs = kzalloc(len, GFP_KERNEL);
         if (!regs)
                 return -ENOMEM;
 
-        memcpy_fromio(regs, hba->mmio_base + offset, len);
+        for (pos = 0; pos < len; pos += 4)
+                regs[pos / 4] = ufshcd_readl(hba, offset + pos);
+
         ufshcd_hex_dump(prefix, regs, len);
         kfree(regs);
 
@@ -8001,6 +8007,8 @@ out:
         trace_ufshcd_system_resume(dev_name(hba->dev), ret,
                 ktime_to_us(ktime_sub(ktime_get(), start)),
                 hba->curr_dev_pwr_mode, hba->uic_link_state);
+        if (!ret)
+                hba->is_sys_suspended = false;
         return ret;
 }
 EXPORT_SYMBOL(ufshcd_system_resume);
diff --git a/drivers/soc/fsl/qbman/dpaa_sys.c b/drivers/soc/fsl/qbman/dpaa_sys.c
index 9436aa83ff1b..e6d48dccb8d5 100644
--- a/drivers/soc/fsl/qbman/dpaa_sys.c
+++ b/drivers/soc/fsl/qbman/dpaa_sys.c
@@ -62,7 +62,7 @@ int qbman_init_private_mem(struct device *dev, int idx, dma_addr_t *addr,
                 return -ENODEV;
         }
 
-        if (!dma_zalloc_coherent(dev, *size, addr, 0)) {
+        if (!dma_alloc_coherent(dev, *size, addr, 0)) {
                 dev_err(dev, "DMA Alloc memory failed\n");
                 return -ENODEV;
         }
diff --git a/drivers/soc/fsl/qbman/qman.c b/drivers/soc/fsl/qbman/qman.c
index 52c153cd795a..636f83f781f5 100644
--- a/drivers/soc/fsl/qbman/qman.c
+++ b/drivers/soc/fsl/qbman/qman.c
@@ -1143,18 +1143,19 @@ static void qm_mr_process_task(struct work_struct *work);
 static irqreturn_t portal_isr(int irq, void *ptr)
 {
         struct qman_portal *p = ptr;
-
-        u32 clear = QM_DQAVAIL_MASK | p->irq_sources;
         u32 is = qm_in(&p->p, QM_REG_ISR) & p->irq_sources;
+        u32 clear = 0;
 
         if (unlikely(!is))
                 return IRQ_NONE;
 
         /* DQRR-handling if it's interrupt-driven */
-        if (is & QM_PIRQ_DQRI)
+        if (is & QM_PIRQ_DQRI) {
                 __poll_portal_fast(p, QMAN_POLL_LIMIT);
+                clear = QM_DQAVAIL_MASK | QM_PIRQ_DQRI;
+        }
         /* Handling of anything else that's interrupt-driven */
-        clear |= __poll_portal_slow(p, is);
+        clear |= __poll_portal_slow(p, is) & QM_PIRQ_SLOW;
         qm_out(&p->p, QM_REG_ISR, clear);
         return IRQ_HANDLED;
 }
diff --git a/drivers/soc/fsl/qe/qe_tdm.c b/drivers/soc/fsl/qe/qe_tdm.c
index f78c34647ca2..76480df195a8 100644
--- a/drivers/soc/fsl/qe/qe_tdm.c
+++ b/drivers/soc/fsl/qe/qe_tdm.c
@@ -44,10 +44,6 @@ int ucc_of_parse_tdm(struct device_node *np, struct ucc_tdm *utdm,
         const char *sprop;
         int ret = 0;
         u32 val;
-        struct resource *res;
-        struct device_node *np2;
-        static int siram_init_flag;
-        struct platform_device *pdev;
 
         sprop = of_get_property(np, "fsl,rx-sync-clock", NULL);
         if (sprop) {
@@ -124,57 +120,6 @@ int ucc_of_parse_tdm(struct device_node *np, struct ucc_tdm *utdm,
         utdm->siram_entry_id = val;
 
         set_si_param(utdm, ut_info);
-
-        np2 = of_find_compatible_node(NULL, NULL, "fsl,t1040-qe-si");
-        if (!np2)
-                return -EINVAL;
-
-        pdev = of_find_device_by_node(np2);
-        if (!pdev) {
-                pr_err("%pOFn: failed to lookup pdev\n", np2);
-                of_node_put(np2);
-                return -EINVAL;
-        }
-
-        of_node_put(np2);
-        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        utdm->si_regs = devm_ioremap_resource(&pdev->dev, res);
-        if (IS_ERR(utdm->si_regs)) {
-                ret = PTR_ERR(utdm->si_regs);
-                goto err_miss_siram_property;
-        }
-
-        np2 = of_find_compatible_node(NULL, NULL, "fsl,t1040-qe-siram");
-        if (!np2) {
-                ret = -EINVAL;
-                goto err_miss_siram_property;
-        }
-
-        pdev = of_find_device_by_node(np2);
-        if (!pdev) {
-                ret = -EINVAL;
-                pr_err("%pOFn: failed to lookup pdev\n", np2);
-                of_node_put(np2);
-                goto err_miss_siram_property;
-        }
-
-        of_node_put(np2);
-        res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
-        utdm->siram = devm_ioremap_resource(&pdev->dev, res);
-        if (IS_ERR(utdm->siram)) {
-                ret = PTR_ERR(utdm->siram);
-                goto err_miss_siram_property;
-        }
-
-        if (siram_init_flag == 0) {
-                memset_io(utdm->siram, 0,  resource_size(res));
-                siram_init_flag = 1;
-        }
-
-        return ret;
-
-err_miss_siram_property:
-        devm_iounmap(&pdev->dev, utdm->si_regs);
         return ret;
 }
 EXPORT_SYMBOL(ucc_of_parse_tdm);
diff --git a/drivers/soc/renesas/Kconfig b/drivers/soc/renesas/Kconfig
index 4d8012e1205c..68bfca6f20dd 100644
--- a/drivers/soc/renesas/Kconfig
+++ b/drivers/soc/renesas/Kconfig
@@ -44,7 +44,7 @@ config ARCH_RZN1
         bool
         select ARM_AMBA
 
-if ARM
+if ARM && ARCH_RENESAS
 
 #comment "Renesas ARM SoCs System Type"
 
diff --git a/drivers/soc/renesas/r8a774c0-sysc.c b/drivers/soc/renesas/r8a774c0-sysc.c
index e1ac4c0f6640..11050e17ea81 100644
--- a/drivers/soc/renesas/r8a774c0-sysc.c
+++ b/drivers/soc/renesas/r8a774c0-sysc.c
@@ -28,19 +28,6 @@ static struct rcar_sysc_area r8a774c0_areas[] __initdata = {
         { "3dg-b",      0x100, 1, R8A774C0_PD_3DG_B,    R8A774C0_PD_3DG_A },
 };
 
-static void __init rcar_sysc_fix_parent(struct rcar_sysc_area *areas,
-                                        unsigned int num_areas, u8 id,
-                                        int new_parent)
-{
-        unsigned int i;
-
-        for (i = 0; i < num_areas; i++)
-                if (areas[i].isr_bit == id) {
-                        areas[i].parent = new_parent;
-                        return;
-                }
-}
-
 /* Fixups for RZ/G2E ES1.0 revision */
 static const struct soc_device_attribute r8a774c0[] __initconst = {
         { .soc_id = "r8a774c0", .revision = "ES1.0" },
@@ -50,12 +37,10 @@ static const struct soc_device_attribute r8a774c0[] __initconst = {
 static int __init r8a774c0_sysc_init(void)
 {
         if (soc_device_match(r8a774c0)) {
-                rcar_sysc_fix_parent(r8a774c0_areas,
-                                     ARRAY_SIZE(r8a774c0_areas),
-                                     R8A774C0_PD_3DG_A, R8A774C0_PD_3DG_B);
-                rcar_sysc_fix_parent(r8a774c0_areas,
-                                     ARRAY_SIZE(r8a774c0_areas),
-                                     R8A774C0_PD_3DG_B, R8A774C0_PD_ALWAYS_ON);
+                /* Fix incorrect 3DG hierarchy */
+                swap(r8a774c0_areas[6], r8a774c0_areas[7]);
+                r8a774c0_areas[6].parent = R8A774C0_PD_ALWAYS_ON;
+                r8a774c0_areas[7].parent = R8A774C0_PD_3DG_B;
         }
 
         return 0;
diff --git a/drivers/spi/spi-pic32-sqi.c b/drivers/spi/spi-pic32-sqi.c
index d7e4e18ec3df..1ae9af5f17ec 100644
--- a/drivers/spi/spi-pic32-sqi.c
+++ b/drivers/spi/spi-pic32-sqi.c
@@ -466,9 +466,9 @@ static int ring_desc_ring_alloc(struct pic32_sqi *sqi)
         int i;
 
         /* allocate coherent DMAable memory for hardware buffer descriptors. */
-        sqi->bd = dma_zalloc_coherent(&sqi->master->dev,
-                                      sizeof(*bd) * PESQI_BD_COUNT,
-                                      &sqi->bd_dma, GFP_KERNEL);
+        sqi->bd = dma_alloc_coherent(&sqi->master->dev,
+                                     sizeof(*bd) * PESQI_BD_COUNT,
+                                     &sqi->bd_dma, GFP_KERNEL);
         if (!sqi->bd) {
                 dev_err(&sqi->master->dev, "failed allocating dma buffer\n");
                 return -ENOMEM;
diff --git a/drivers/staging/android/ion/ion.c b/drivers/staging/android/ion/ion.c
index a0802de8c3a1..6f5afab7c1a1 100644
--- a/drivers/staging/android/ion/ion.c
+++ b/drivers/staging/android/ion/ion.c
@@ -248,10 +248,10 @@ static void ion_dma_buf_detatch(struct dma_buf *dmabuf,
         struct ion_dma_buf_attachment *a = attachment->priv;
         struct ion_buffer *buffer = dmabuf->priv;
 
-        free_duped_table(a->table);
         mutex_lock(&buffer->lock);
         list_del(&a->list);
         mutex_unlock(&buffer->lock);
+        free_duped_table(a->table);
 
         kfree(a);
 }
diff --git a/drivers/staging/mt7621-eth/mtk_eth_soc.c b/drivers/staging/mt7621-eth/mtk_eth_soc.c
index 21a76a8ccc26..6027b19f7bc2 100644
--- a/drivers/staging/mt7621-eth/mtk_eth_soc.c
+++ b/drivers/staging/mt7621-eth/mtk_eth_soc.c
@@ -1396,8 +1396,7 @@ static int mtk_qdma_tx_alloc_tx(struct mtk_eth *eth)
         if (!ring->tx_buf)
                 goto no_tx_mem;
 
-        ring->tx_dma = dma_zalloc_coherent(eth->dev,
-                                          ring->tx_ring_size * sz,
+        ring->tx_dma = dma_alloc_coherent(eth->dev, ring->tx_ring_size * sz,
                                           &ring->tx_phys,
                                           GFP_ATOMIC | __GFP_ZERO);
         if (!ring->tx_dma)
diff --git a/drivers/staging/rtl8188eu/core/rtw_security.c b/drivers/staging/rtl8188eu/core/rtw_security.c
index 364d6ea14bf8..2f90f60f1681 100644
--- a/drivers/staging/rtl8188eu/core/rtw_security.c
+++ b/drivers/staging/rtl8188eu/core/rtw_security.c
@@ -154,7 +154,7 @@ void rtw_wep_encrypt(struct adapter *padapter, u8 *pxmitframe)
 
         pframe = ((struct xmit_frame *)pxmitframe)->buf_addr + hw_hdr_offset;
 
-        crypto_ops = try_then_request_module(lib80211_get_crypto_ops("WEP"), "lib80211_crypt_wep");
+        crypto_ops = lib80211_get_crypto_ops("WEP");
 
         if (!crypto_ops)
                 return;
@@ -210,7 +210,7 @@ int rtw_wep_decrypt(struct adapter  *padapter, u8 *precvframe)
                 void *crypto_private = NULL;
                 int status = _SUCCESS;
                 const int keyindex = prxattrib->key_index;
-                struct lib80211_crypto_ops *crypto_ops = try_then_request_module(lib80211_get_crypto_ops("WEP"), "lib80211_crypt_wep");
+                struct lib80211_crypto_ops *crypto_ops = lib80211_get_crypto_ops("WEP");
                 char iv[4], icv[4];
 
                 if (!crypto_ops) {
@@ -1291,7 +1291,7 @@ u32 rtw_aes_decrypt(struct adapter *padapter, u8 *precvframe)
                         struct sk_buff *skb = ((struct recv_frame *)precvframe)->pkt;
                         void *crypto_private = NULL;
                         u8 *key, *pframe = skb->data;
-                        struct lib80211_crypto_ops *crypto_ops = try_then_request_module(lib80211_get_crypto_ops("CCMP"), "lib80211_crypt_ccmp");
+                        struct lib80211_crypto_ops *crypto_ops = lib80211_get_crypto_ops("CCMP");
                         struct security_priv *psecuritypriv = &padapter->securitypriv;
                         char iv[8], icv[8];
 
diff --git a/drivers/staging/rtl8188eu/os_dep/usb_intf.c b/drivers/staging/rtl8188eu/os_dep/usb_intf.c
index 28cbd6b3d26c..dfee6985efa6 100644
--- a/drivers/staging/rtl8188eu/os_dep/usb_intf.c
+++ b/drivers/staging/rtl8188eu/os_dep/usb_intf.c
@@ -35,6 +35,7 @@ static const struct usb_device_id rtw_usb_id_tbl[] = {
         {USB_DEVICE(0x2001, 0x330F)}, /* DLink DWA-125 REV D1 */
         {USB_DEVICE(0x2001, 0x3310)}, /* Dlink DWA-123 REV D1 */
         {USB_DEVICE(0x2001, 0x3311)}, /* DLink GO-USB-N150 REV B1 */
+        {USB_DEVICE(0x2001, 0x331B)}, /* D-Link DWA-121 rev B1 */
         {USB_DEVICE(0x2357, 0x010c)}, /* TP-Link TL-WN722N v2 */
         {USB_DEVICE(0x0df6, 0x0076)}, /* Sitecom N150 v2 */
         {USB_DEVICE(USB_VENDER_ID_REALTEK, 0xffef)}, /* Rosewill RNX-N150NUB */
diff --git a/drivers/staging/rtl8723bs/include/ieee80211.h b/drivers/staging/rtl8723bs/include/ieee80211.h
index bcc8dfa8e672..9efb4dcb9d3a 100644
--- a/drivers/staging/rtl8723bs/include/ieee80211.h
+++ b/drivers/staging/rtl8723bs/include/ieee80211.h
@@ -850,18 +850,18 @@ enum ieee80211_state {
 #define IP_FMT "%pI4"
 #define IP_ARG(x) (x)
 
-extern __inline int is_multicast_mac_addr(const u8 *addr)
+static inline int is_multicast_mac_addr(const u8 *addr)
 {
         return ((addr[0] != 0xff) && (0x01 & addr[0]));
 }
 
-extern __inline int is_broadcast_mac_addr(const u8 *addr)
+static inline int is_broadcast_mac_addr(const u8 *addr)
 {
         return ((addr[0] == 0xff) && (addr[1] == 0xff) && (addr[2] == 0xff) &&   \
                 (addr[3] == 0xff) && (addr[4] == 0xff) && (addr[5] == 0xff));
 }
 
-extern __inline int is_zero_mac_addr(const u8 *addr)
+static inline int is_zero_mac_addr(const u8 *addr)
 {
         return ((addr[0] == 0x00) && (addr[1] == 0x00) && (addr[2] == 0x00) &&   \
                 (addr[3] == 0x00) && (addr[4] == 0x00) && (addr[5] == 0x00));
diff --git a/drivers/staging/rtl8723bs/os_dep/sdio_intf.c b/drivers/staging/rtl8723bs/os_dep/sdio_intf.c
index 7c03b69b8ed3..6d02904de63f 100644
--- a/drivers/staging/rtl8723bs/os_dep/sdio_intf.c
+++ b/drivers/staging/rtl8723bs/os_dep/sdio_intf.c
@@ -22,7 +22,7 @@ static const struct sdio_device_id sdio_ids[] =
         { SDIO_DEVICE(0x024c, 0xb723), },
         { /* end: all zeroes */                         },
 };
-static const struct acpi_device_id acpi_ids[] __used = {
+static const struct acpi_device_id acpi_ids[] = {
         {"OBDA8723", 0x0000},
         {}
 };
diff --git a/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_2835_arm.c b/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_2835_arm.c
index 338b6e952515..dd4898861b83 100644
--- a/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_2835_arm.c
+++ b/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_2835_arm.c
@@ -407,10 +407,8 @@ create_pagelist(char __user *buf, size_t count, unsigned short type)
         /* Allocate enough storage to hold the page pointers and the page
          * list
          */
-        pagelist = dma_zalloc_coherent(g_dev,
-                                       pagelist_size,
-                                       &dma_addr,
-                                       GFP_KERNEL);
+        pagelist = dma_alloc_coherent(g_dev, pagelist_size, &dma_addr,
+                                      GFP_KERNEL);
 
         vchiq_log_trace(vchiq_arm_log_level, "%s - %pK", __func__, pagelist);
 
diff --git a/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_core.c b/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_core.c
index 9e17ec651bde..53f5a1cb4636 100644
--- a/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_core.c
+++ b/drivers/staging/vc04_services/interface/vchiq_arm/vchiq_core.c
@@ -446,6 +446,7 @@ remote_event_wait(wait_queue_head_t *wq, struct remote_event *event)
 static inline void
 remote_event_signal_local(wait_queue_head_t *wq, struct remote_event *event)
 {
+        event->fired = 1;
         event->armed = 0;
         wake_up_all(wq);
 }
diff --git a/drivers/staging/vt6655/device_main.c b/drivers/staging/vt6655/device_main.c
index 1ab0e8562d40..c9097e7367d8 100644
--- a/drivers/staging/vt6655/device_main.c
+++ b/drivers/staging/vt6655/device_main.c
@@ -440,12 +440,9 @@ static bool device_init_rings(struct vnt_private *priv)
         void *vir_pool;
 
         /*allocate all RD/TD rings a single pool*/
-        vir_pool = dma_zalloc_coherent(&priv->pcid->dev,
-                                       priv->opts.rx_descs0 * sizeof(struct vnt_rx_desc) +
-                                       priv->opts.rx_descs1 * sizeof(struct vnt_rx_desc) +
-                                       priv->opts.tx_descs[0] * sizeof(struct vnt_tx_desc) +
-                                       priv->opts.tx_descs[1] * sizeof(struct vnt_tx_desc),
-                                       &priv->pool_dma, GFP_ATOMIC);
+        vir_pool = dma_alloc_coherent(&priv->pcid->dev,
+                                      priv->opts.rx_descs0 * sizeof(struct vnt_rx_desc) + priv->opts.rx_descs1 * sizeof(struct vnt_rx_desc) + priv->opts.tx_descs[0] * sizeof(struct vnt_tx_desc) + priv->opts.tx_descs[1] * sizeof(struct vnt_tx_desc),
+                                      &priv->pool_dma, GFP_ATOMIC);
         if (!vir_pool) {
                 dev_err(&priv->pcid->dev, "allocate desc dma memory failed\n");
                 return false;
@@ -459,13 +456,9 @@ static bool device_init_rings(struct vnt_private *priv)
         priv->rd1_pool_dma = priv->rd0_pool_dma +
                 priv->opts.rx_descs0 * sizeof(struct vnt_rx_desc);
 
-        priv->tx0_bufs = dma_zalloc_coherent(&priv->pcid->dev,
-                                             priv->opts.tx_descs[0] * PKT_BUF_SZ +
-                                             priv->opts.tx_descs[1] * PKT_BUF_SZ +
-                                             CB_BEACON_BUF_SIZE +
-                                             CB_MAX_BUF_SIZE,
-                                             &priv->tx_bufs_dma0,
-                                             GFP_ATOMIC);
+        priv->tx0_bufs = dma_alloc_coherent(&priv->pcid->dev,
+                                            priv->opts.tx_descs[0] * PKT_BUF_SZ + priv->opts.tx_descs[1] * PKT_BUF_SZ + CB_BEACON_BUF_SIZE + CB_MAX_BUF_SIZE,
+                                            &priv->tx_bufs_dma0, GFP_ATOMIC);
         if (!priv->tx0_bufs) {
                 dev_err(&priv->pcid->dev, "allocate buf dma memory failed\n");
 
diff --git a/drivers/staging/wilc1000/host_interface.c b/drivers/staging/wilc1000/host_interface.c
index 70c854d939ce..3d0badc34825 100644
--- a/drivers/staging/wilc1000/host_interface.c
+++ b/drivers/staging/wilc1000/host_interface.c
@@ -36,7 +36,7 @@ struct wilc_op_mode {
 struct wilc_reg_frame {
         bool reg;
         u8 reg_id;
-        __le32 frame_type;
+        __le16 frame_type;
 } __packed;
 
 struct wilc_drv_handler {
@@ -1744,7 +1744,6 @@ int wilc_add_rx_gtk(struct wilc_vif *vif, const u8 *rx_gtk, u8 gtk_key_len,
                 result = wilc_send_config_pkt(vif, WILC_SET_CFG, wid_list,
                                               ARRAY_SIZE(wid_list),
                                               wilc_get_vif_idx(vif));
-                kfree(gtk_key);
         } else if (mode == WILC_STATION_MODE) {
                 struct wid wid;
 
@@ -1754,9 +1753,9 @@ int wilc_add_rx_gtk(struct wilc_vif *vif, const u8 *rx_gtk, u8 gtk_key_len,
                 wid.val = (u8 *)gtk_key;
                 result = wilc_send_config_pkt(vif, WILC_SET_CFG, &wid, 1,
                                               wilc_get_vif_idx(vif));
-                kfree(gtk_key);
         }
 
+        kfree(gtk_key);
         return result;
 }
 
diff --git a/drivers/staging/wilc1000/wilc_wlan.c b/drivers/staging/wilc1000/wilc_wlan.c
index 3c5e9e030cad..489e5a5038f8 100644
--- a/drivers/staging/wilc1000/wilc_wlan.c
+++ b/drivers/staging/wilc1000/wilc_wlan.c
@@ -1252,21 +1252,22 @@ static u32 init_chip(struct net_device *dev)
                 ret = wilc->hif_func->hif_read_reg(wilc, 0x1118, &reg);
                 if (!ret) {
                         netdev_err(dev, "fail read reg 0x1118\n");
-                        return ret;
+                        goto release;
                 }
                 reg |= BIT(0);
                 ret = wilc->hif_func->hif_write_reg(wilc, 0x1118, reg);
                 if (!ret) {
                         netdev_err(dev, "fail write reg 0x1118\n");
-                        return ret;
+                        goto release;
                 }
                 ret = wilc->hif_func->hif_write_reg(wilc, 0xc0000, 0x71);
                 if (!ret) {
                         netdev_err(dev, "fail write reg 0xc0000\n");
-                        return ret;
+                        goto release;
                 }
         }
 
+release:
         release_bus(wilc, WILC_BUS_RELEASE_ONLY);
 
         return ret;
diff --git a/drivers/target/iscsi/iscsi_target.c b/drivers/target/iscsi/iscsi_target.c
index 984941e036c8..bd15a564fe24 100644
--- a/drivers/target/iscsi/iscsi_target.c
+++ b/drivers/target/iscsi/iscsi_target.c
@@ -714,7 +714,7 @@ static int __init iscsi_target_init_module(void)
                         sizeof(struct iscsi_queue_req),
                         __alignof__(struct iscsi_queue_req), 0, NULL);
         if (!lio_qr_cache) {
-                pr_err("nable to kmem_cache_create() for"
+                pr_err("Unable to kmem_cache_create() for"
                                 " lio_qr_cache\n");
                 goto bitmap_out;
         }
diff --git a/drivers/target/target_core_user.c b/drivers/target/target_core_user.c
index 1e6d24943565..5831e0eecea1 100644
--- a/drivers/target/target_core_user.c
+++ b/drivers/target/target_core_user.c
@@ -148,7 +148,7 @@ struct tcmu_dev {
         size_t ring_size;
 
         struct mutex cmdr_lock;
-        struct list_head cmdr_queue;
+        struct list_head qfull_queue;
 
         uint32_t dbi_max;
         uint32_t dbi_thresh;
@@ -159,6 +159,7 @@ struct tcmu_dev {
 
         struct timer_list cmd_timer;
         unsigned int cmd_time_out;
+        struct list_head inflight_queue;
 
         struct timer_list qfull_timer;
         int qfull_time_out;
@@ -179,7 +180,7 @@ struct tcmu_dev {
 struct tcmu_cmd {
         struct se_cmd *se_cmd;
         struct tcmu_dev *tcmu_dev;
-        struct list_head cmdr_queue_entry;
+        struct list_head queue_entry;
 
         uint16_t cmd_id;
 
@@ -192,6 +193,7 @@ struct tcmu_cmd {
         unsigned long deadline;
 
 #define TCMU_CMD_BIT_EXPIRED 0
+#define TCMU_CMD_BIT_INFLIGHT 1
         unsigned long flags;
 };
 /*
@@ -586,7 +588,7 @@ static struct tcmu_cmd *tcmu_alloc_cmd(struct se_cmd *se_cmd)
         if (!tcmu_cmd)
                 return NULL;
 
-        INIT_LIST_HEAD(&tcmu_cmd->cmdr_queue_entry);
+        INIT_LIST_HEAD(&tcmu_cmd->queue_entry);
         tcmu_cmd->se_cmd = se_cmd;
         tcmu_cmd->tcmu_dev = udev;
 
@@ -915,11 +917,13 @@ setup_timer:
                 return 0;
 
         tcmu_cmd->deadline = round_jiffies_up(jiffies + msecs_to_jiffies(tmo));
-        mod_timer(timer, tcmu_cmd->deadline);
+        if (!timer_pending(timer))
+                mod_timer(timer, tcmu_cmd->deadline);
+
         return 0;
 }
 
-static int add_to_cmdr_queue(struct tcmu_cmd *tcmu_cmd)
+static int add_to_qfull_queue(struct tcmu_cmd *tcmu_cmd)
 {
         struct tcmu_dev *udev = tcmu_cmd->tcmu_dev;
         unsigned int tmo;
@@ -942,7 +946,7 @@ static int add_to_cmdr_queue(struct tcmu_cmd *tcmu_cmd)
         if (ret)
                 return ret;
 
-        list_add_tail(&tcmu_cmd->cmdr_queue_entry, &udev->cmdr_queue);
+        list_add_tail(&tcmu_cmd->queue_entry, &udev->qfull_queue);
         pr_debug("adding cmd %u on dev %s to ring space wait queue\n",
                  tcmu_cmd->cmd_id, udev->name);
         return 0;
@@ -999,7 +1003,7 @@ static int queue_cmd_ring(struct tcmu_cmd *tcmu_cmd, sense_reason_t *scsi_err)
         base_command_size = tcmu_cmd_get_base_cmd_size(tcmu_cmd->dbi_cnt);
         command_size = tcmu_cmd_get_cmd_size(tcmu_cmd, base_command_size);
 
-        if (!list_empty(&udev->cmdr_queue))
+        if (!list_empty(&udev->qfull_queue))
                 goto queue;
 
         mb = udev->mb_addr;
@@ -1096,13 +1100,16 @@ static int queue_cmd_ring(struct tcmu_cmd *tcmu_cmd, sense_reason_t *scsi_err)
         UPDATE_HEAD(mb->cmd_head, command_size, udev->cmdr_size);
         tcmu_flush_dcache_range(mb, sizeof(*mb));
 
+        list_add_tail(&tcmu_cmd->queue_entry, &udev->inflight_queue);
+        set_bit(TCMU_CMD_BIT_INFLIGHT, &tcmu_cmd->flags);
+
         /* TODO: only if FLUSH and FUA? */
         uio_event_notify(&udev->uio_info);
 
         return 0;
 
 queue:
-        if (add_to_cmdr_queue(tcmu_cmd)) {
+        if (add_to_qfull_queue(tcmu_cmd)) {
                 *scsi_err = TCM_OUT_OF_RESOURCES;
                 return -1;
         }
@@ -1145,6 +1152,8 @@ static void tcmu_handle_completion(struct tcmu_cmd *cmd, struct tcmu_cmd_entry *
         if (test_bit(TCMU_CMD_BIT_EXPIRED, &cmd->flags))
                 goto out;
 
+        list_del_init(&cmd->queue_entry);
+
         tcmu_cmd_reset_dbi_cur(cmd);
 
         if (entry->hdr.uflags & TCMU_UFLAG_UNKNOWN_OP) {
@@ -1194,9 +1203,29 @@ out:
         tcmu_free_cmd(cmd);
 }
 
+static void tcmu_set_next_deadline(struct list_head *queue,
+                                   struct timer_list *timer)
+{
+        struct tcmu_cmd *tcmu_cmd, *tmp_cmd;
+        unsigned long deadline = 0;
+
+        list_for_each_entry_safe(tcmu_cmd, tmp_cmd, queue, queue_entry) {
+                if (!time_after(jiffies, tcmu_cmd->deadline)) {
+                        deadline = tcmu_cmd->deadline;
+                        break;
+                }
+        }
+
+        if (deadline)
+                mod_timer(timer, deadline);
+        else
+                del_timer(timer);
+}
+
 static unsigned int tcmu_handle_completions(struct tcmu_dev *udev)
 {
         struct tcmu_mailbox *mb;
+        struct tcmu_cmd *cmd;
         int handled = 0;
 
         if (test_bit(TCMU_DEV_BIT_BROKEN, &udev->flags)) {
@@ -1210,7 +1239,6 @@ static unsigned int tcmu_handle_completions(struct tcmu_dev *udev)
         while (udev->cmdr_last_cleaned != READ_ONCE(mb->cmd_tail)) {
 
                 struct tcmu_cmd_entry *entry = (void *) mb + CMDR_OFF + udev->cmdr_last_cleaned;
-                struct tcmu_cmd *cmd;
 
                 tcmu_flush_dcache_range(entry, sizeof(*entry));
 
@@ -1243,7 +1271,7 @@ static unsigned int tcmu_handle_completions(struct tcmu_dev *udev)
                 /* no more pending commands */
                 del_timer(&udev->cmd_timer);
 
-                if (list_empty(&udev->cmdr_queue)) {
+                if (list_empty(&udev->qfull_queue)) {
                         /*
                          * no more pending or waiting commands so try to
                          * reclaim blocks if needed.
@@ -1252,6 +1280,8 @@ static unsigned int tcmu_handle_completions(struct tcmu_dev *udev)
                             tcmu_global_max_blocks)
                                 schedule_delayed_work(&tcmu_unmap_work, 0);
                 }
+        } else if (udev->cmd_time_out) {
+                tcmu_set_next_deadline(&udev->inflight_queue, &udev->cmd_timer);
         }
 
         return handled;
@@ -1271,7 +1301,7 @@ static int tcmu_check_expired_cmd(int id, void *p, void *data)
         if (!time_after(jiffies, cmd->deadline))
                 return 0;
 
-        is_running = list_empty(&cmd->cmdr_queue_entry);
+        is_running = test_bit(TCMU_CMD_BIT_INFLIGHT, &cmd->flags);
         se_cmd = cmd->se_cmd;
 
         if (is_running) {
@@ -1287,9 +1317,9 @@ static int tcmu_check_expired_cmd(int id, void *p, void *data)
                  * target_complete_cmd will translate this to LUN COMM FAILURE
                  */
                 scsi_status = SAM_STAT_CHECK_CONDITION;
+                list_del_init(&cmd->queue_entry);
         } else {
-                list_del_init(&cmd->cmdr_queue_entry);
-
+                list_del_init(&cmd->queue_entry);
                 idr_remove(&udev->commands, id);
                 tcmu_free_cmd(cmd);
                 scsi_status = SAM_STAT_TASK_SET_FULL;
@@ -1372,7 +1402,8 @@ static struct se_device *tcmu_alloc_device(struct se_hba *hba, const char *name)
 
         INIT_LIST_HEAD(&udev->node);
         INIT_LIST_HEAD(&udev->timedout_entry);
-        INIT_LIST_HEAD(&udev->cmdr_queue);
+        INIT_LIST_HEAD(&udev->qfull_queue);
+        INIT_LIST_HEAD(&udev->inflight_queue);
         idr_init(&udev->commands);
 
         timer_setup(&udev->qfull_timer, tcmu_qfull_timedout, 0);
@@ -1383,7 +1414,7 @@ static struct se_device *tcmu_alloc_device(struct se_hba *hba, const char *name)
         return &udev->se_dev;
 }
 
-static bool run_cmdr_queue(struct tcmu_dev *udev, bool fail)
+static bool run_qfull_queue(struct tcmu_dev *udev, bool fail)
 {
         struct tcmu_cmd *tcmu_cmd, *tmp_cmd;
         LIST_HEAD(cmds);
@@ -1391,15 +1422,15 @@ static bool run_cmdr_queue(struct tcmu_dev *udev, bool fail)
         sense_reason_t scsi_ret;
         int ret;
 
-        if (list_empty(&udev->cmdr_queue))
+        if (list_empty(&udev->qfull_queue))
                 return true;
 
         pr_debug("running %s's cmdr queue forcefail %d\n", udev->name, fail);
 
-        list_splice_init(&udev->cmdr_queue, &cmds);
+        list_splice_init(&udev->qfull_queue, &cmds);
 
-        list_for_each_entry_safe(tcmu_cmd, tmp_cmd, &cmds, cmdr_queue_entry) {
-                list_del_init(&tcmu_cmd->cmdr_queue_entry);
+        list_for_each_entry_safe(tcmu_cmd, tmp_cmd, &cmds, queue_entry) {
+                list_del_init(&tcmu_cmd->queue_entry);
 
                 pr_debug("removing cmd %u on dev %s from queue\n",
                          tcmu_cmd->cmd_id, udev->name);
@@ -1437,14 +1468,13 @@ static bool run_cmdr_queue(struct tcmu_dev *udev, bool fail)
                          * cmd was requeued, so just put all cmds back in
                          * the queue
                          */
-                        list_splice_tail(&cmds, &udev->cmdr_queue);
+                        list_splice_tail(&cmds, &udev->qfull_queue);
                         drained = false;
-                        goto done;
+                        break;
                 }
         }
-        if (list_empty(&udev->cmdr_queue))
-                del_timer(&udev->qfull_timer);
-done:
+
+        tcmu_set_next_deadline(&udev->qfull_queue, &udev->qfull_timer);
         return drained;
 }
 
@@ -1454,7 +1484,7 @@ static int tcmu_irqcontrol(struct uio_info *info, s32 irq_on)
 
         mutex_lock(&udev->cmdr_lock);
         tcmu_handle_completions(udev);
-        run_cmdr_queue(udev, false);
+        run_qfull_queue(udev, false);
         mutex_unlock(&udev->cmdr_lock);
 
         return 0;
@@ -1982,7 +2012,7 @@ static void tcmu_block_dev(struct tcmu_dev *udev)
         /* complete IO that has executed successfully */
         tcmu_handle_completions(udev);
         /* fail IO waiting to be queued */
-        run_cmdr_queue(udev, true);
+        run_qfull_queue(udev, true);
 
 unlock:
         mutex_unlock(&udev->cmdr_lock);
@@ -1997,7 +2027,7 @@ static void tcmu_reset_ring(struct tcmu_dev *udev, u8 err_level)
         mutex_lock(&udev->cmdr_lock);
 
         idr_for_each_entry(&udev->commands, cmd, i) {
-                if (!list_empty(&cmd->cmdr_queue_entry))
+                if (!test_bit(TCMU_CMD_BIT_INFLIGHT, &cmd->flags))
                         continue;
 
                 pr_debug("removing cmd %u on dev %s from ring (is expired %d)\n",
@@ -2006,6 +2036,7 @@ static void tcmu_reset_ring(struct tcmu_dev *udev, u8 err_level)
 
                 idr_remove(&udev->commands, i);
                 if (!test_bit(TCMU_CMD_BIT_EXPIRED, &cmd->flags)) {
+                        list_del_init(&cmd->queue_entry);
                         if (err_level == 1) {
                                 /*
                                  * Userspace was not able to start the
@@ -2666,6 +2697,10 @@ static void check_timedout_devices(void)
 
                 mutex_lock(&udev->cmdr_lock);
                 idr_for_each(&udev->commands, tcmu_check_expired_cmd, NULL);
+
+                tcmu_set_next_deadline(&udev->inflight_queue, &udev->cmd_timer);
+                tcmu_set_next_deadline(&udev->qfull_queue, &udev->qfull_timer);
+
                 mutex_unlock(&udev->cmdr_lock);
 
                 spin_lock_bh(&timed_out_udevs_lock);
diff --git a/drivers/thermal/intel/int340x_thermal/Kconfig b/drivers/thermal/intel/int340x_thermal/Kconfig
index 0582bd12a239..0ca908d12750 100644
--- a/drivers/thermal/intel/int340x_thermal/Kconfig
+++ b/drivers/thermal/intel/int340x_thermal/Kconfig
@@ -4,7 +4,7 @@
 
 config INT340X_THERMAL
         tristate "ACPI INT340X thermal drivers"
-        depends on X86 && ACPI
+        depends on X86 && ACPI && PCI
         select THERMAL_GOV_USER_SPACE
         select ACPI_THERMAL_REL
         select ACPI_FAN
diff --git a/drivers/thermal/intel/int340x_thermal/processor_thermal_device.c b/drivers/thermal/intel/int340x_thermal/processor_thermal_device.c
index 284cf2c5a8fd..8e1cf4d789be 100644
--- a/drivers/thermal/intel/int340x_thermal/processor_thermal_device.c
+++ b/drivers/thermal/intel/int340x_thermal/processor_thermal_device.c
@@ -84,7 +84,12 @@ static ssize_t power_limit_##index##_##suffix##_show(struct device *dev, \
         struct pci_dev *pci_dev; \
         struct platform_device *pdev; \
         struct proc_thermal_device *proc_dev; \
-\
+        \
+        if (proc_thermal_emum_mode == PROC_THERMAL_NONE) { \
+                dev_warn(dev, "Attempted to get power limit before device was initialized!\n"); \
+                return 0; \
+        } \
+        \
         if (proc_thermal_emum_mode == PROC_THERMAL_PLATFORM_DEV) { \
                 pdev = to_platform_device(dev); \
                 proc_dev = platform_get_drvdata(pdev); \
@@ -298,11 +303,6 @@ static int proc_thermal_add(struct device *dev,
         *priv = proc_priv;
 
         ret = proc_thermal_read_ppcc(proc_priv);
-        if (!ret) {
-                ret = sysfs_create_group(&dev->kobj,
-                                         &power_limit_attribute_group);
-
-        }
         if (ret)
                 return ret;
 
@@ -316,8 +316,7 @@ static int proc_thermal_add(struct device *dev,
 
         proc_priv->int340x_zone = int340x_thermal_zone_add(adev, ops);
         if (IS_ERR(proc_priv->int340x_zone)) {
-                ret = PTR_ERR(proc_priv->int340x_zone);
-                goto remove_group;
+                return PTR_ERR(proc_priv->int340x_zone);
         } else
                 ret = 0;
 
@@ -331,9 +330,6 @@ static int proc_thermal_add(struct device *dev,
 
 remove_zone:
         int340x_thermal_zone_remove(proc_priv->int340x_zone);
-remove_group:
-        sysfs_remove_group(&proc_priv->dev->kobj,
-                           &power_limit_attribute_group);
 
         return ret;
 }
@@ -364,7 +360,10 @@ static int int3401_add(struct platform_device *pdev)
         platform_set_drvdata(pdev, proc_priv);
         proc_thermal_emum_mode = PROC_THERMAL_PLATFORM_DEV;
 
-        return 0;
+        dev_info(&pdev->dev, "Creating sysfs group for PROC_THERMAL_PLATFORM_DEV\n");
+
+        return sysfs_create_group(&pdev->dev.kobj,
+                                         &power_limit_attribute_group);
 }
 
 static int int3401_remove(struct platform_device *pdev)
@@ -423,7 +422,7 @@ static int  proc_thermal_pci_probe(struct pci_dev *pdev,
                 proc_priv->soc_dts = intel_soc_dts_iosf_init(
                                         INTEL_SOC_DTS_INTERRUPT_MSI, 2, 0);
 
-                if (proc_priv->soc_dts && pdev->irq) {
+                if (!IS_ERR(proc_priv->soc_dts) && pdev->irq) {
                         ret = pci_enable_msi(pdev);
                         if (!ret) {
                                 ret = request_threaded_irq(pdev->irq, NULL,
@@ -441,7 +440,10 @@ static int  proc_thermal_pci_probe(struct pci_dev *pdev,
                         dev_err(&pdev->dev, "No auxiliary DTSs enabled\n");
         }
 
-        return 0;
+        dev_info(&pdev->dev, "Creating sysfs group for PROC_THERMAL_PCI\n");
+
+        return sysfs_create_group(&pdev->dev.kobj,
+                                         &power_limit_attribute_group);
 }
 
 static void  proc_thermal_pci_remove(struct pci_dev *pdev)
diff --git a/drivers/tty/n_hdlc.c b/drivers/tty/n_hdlc.c
index 4164414d4c64..8bdf42bc8fc8 100644
--- a/drivers/tty/n_hdlc.c
+++ b/drivers/tty/n_hdlc.c
@@ -597,6 +597,7 @@ static ssize_t n_hdlc_tty_read(struct tty_struct *tty, struct file *file,
                                 /* too large for caller's buffer */
                                 ret = -EOVERFLOW;
                         } else {
+                                __set_current_state(TASK_RUNNING);
                                 if (copy_to_user(buf, rbuf->buf, rbuf->count))
                                         ret = -EFAULT;
                                 else
diff --git a/drivers/tty/serial/8250/8250_core.c b/drivers/tty/serial/8250/8250_core.c
index 189ab1212d9a..e441221e04b9 100644
--- a/drivers/tty/serial/8250/8250_core.c
+++ b/drivers/tty/serial/8250/8250_core.c
@@ -1070,15 +1070,16 @@ int serial8250_register_8250_port(struct uart_8250_port *up)
 
                         ret = 0;
                 }
-        }
 
-        /* Initialise interrupt backoff work if required */
-        if (up->overrun_backoff_time_ms > 0) {
-                uart->overrun_backoff_time_ms = up->overrun_backoff_time_ms;
-                INIT_DELAYED_WORK(&uart->overrun_backoff,
-                                  serial_8250_overrun_backoff_work);
-        } else {
-                uart->overrun_backoff_time_ms = 0;
+                /* Initialise interrupt backoff work if required */
+                if (up->overrun_backoff_time_ms > 0) {
+                        uart->overrun_backoff_time_ms =
+                                up->overrun_backoff_time_ms;
+                        INIT_DELAYED_WORK(&uart->overrun_backoff,
+                                        serial_8250_overrun_backoff_work);
+                } else {
+                        uart->overrun_backoff_time_ms = 0;
+                }
         }
 
         mutex_unlock(&serial_mutex);
diff --git a/drivers/tty/serial/Kconfig b/drivers/tty/serial/Kconfig
index 67b9bf3b500e..089a6f285d5e 100644
--- a/drivers/tty/serial/Kconfig
+++ b/drivers/tty/serial/Kconfig
@@ -85,6 +85,18 @@ config SERIAL_EARLYCON_ARM_SEMIHOST
           with "earlycon=smh" on the kernel command line. The console is
           enabled when early_param is processed.
 
+config SERIAL_EARLYCON_RISCV_SBI
+        bool "Early console using RISC-V SBI"
+        depends on RISCV
+        select SERIAL_CORE
+        select SERIAL_CORE_CONSOLE
+        select SERIAL_EARLYCON
+        help
+          Support for early debug console using RISC-V SBI. This enables
+          the console before standard serial driver is probed. This is enabled
+          with "earlycon=sbi" on the kernel command line. The console is
+          enabled when early_param is processed.
+
 config SERIAL_SB1250_DUART
         tristate "BCM1xxx on-chip DUART serial support"
         depends on SIBYTE_SB1xxx_SOC=y
diff --git a/drivers/tty/serial/Makefile b/drivers/tty/serial/Makefile
index 8c303736b7e8..1511e8a9f856 100644
--- a/drivers/tty/serial/Makefile
+++ b/drivers/tty/serial/Makefile
@@ -7,6 +7,7 @@ obj-$(CONFIG_SERIAL_CORE) += serial_core.o
 
 obj-$(CONFIG_SERIAL_EARLYCON) += earlycon.o
 obj-$(CONFIG_SERIAL_EARLYCON_ARM_SEMIHOST) += earlycon-arm-semihost.o
+obj-$(CONFIG_SERIAL_EARLYCON_RISCV_SBI) += earlycon-riscv-sbi.o
 
 # These Sparc drivers have to appear before others such as 8250
 # which share ttySx minor node space.  Otherwise console device
diff --git a/drivers/tty/serial/earlycon-riscv-sbi.c b/drivers/tty/serial/earlycon-riscv-sbi.c
new file mode 100644
index 000000000000..e1a551aae336
--- /dev/null
+++ b/drivers/tty/serial/earlycon-riscv-sbi.c
@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * RISC-V SBI based earlycon
+ *
+ * Copyright (C) 2018 Anup Patel <anup@brainfault.org>
+ */
+#include <linux/kernel.h>
+#include <linux/console.h>
+#include <linux/init.h>
+#include <linux/serial_core.h>
+#include <asm/sbi.h>
+
+static void sbi_console_write(struct console *con,
+                              const char *s, unsigned int n)
+{
+        int i;
+
+        for (i = 0; i < n; ++i)
+                sbi_console_putchar(s[i]);
+}
+
+static int __init early_sbi_setup(struct earlycon_device *device,
+                                  const char *opt)
+{
+        device->con->write = sbi_console_write;
+        return 0;
+}
+EARLYCON_DECLARE(sbi, early_sbi_setup);
diff --git a/drivers/tty/serial/fsl_lpuart.c b/drivers/tty/serial/fsl_lpuart.c
index 241a48e5052c..debdd1b9e01a 100644
--- a/drivers/tty/serial/fsl_lpuart.c
+++ b/drivers/tty/serial/fsl_lpuart.c
@@ -1697,7 +1697,7 @@ lpuart32_set_termios(struct uart_port *port, struct ktermios *termios,
         }
 
         /* ask the core to calculate the divisor */
-        baud = uart_get_baud_rate(port, termios, old, 50, port->uartclk / 16);
+        baud = uart_get_baud_rate(port, termios, old, 50, port->uartclk / 4);
 
         spin_lock_irqsave(&sport->port.lock, flags);
 
diff --git a/drivers/tty/serial/lantiq.c b/drivers/tty/serial/lantiq.c
index e052b69ceb98..9de9f0f239a1 100644
--- a/drivers/tty/serial/lantiq.c
+++ b/drivers/tty/serial/lantiq.c
@@ -114,9 +114,9 @@ struct ltq_uart_port {
 
 static inline void asc_update_bits(u32 clear, u32 set, void __iomem *reg)
 {
-        u32 tmp = readl(reg);
+        u32 tmp = __raw_readl(reg);
 
-        writel((tmp & ~clear) | set, reg);
+        __raw_writel((tmp & ~clear) | set, reg);
 }
 
 static inline struct
@@ -144,7 +144,7 @@ lqasc_start_tx(struct uart_port *port)
 static void
 lqasc_stop_rx(struct uart_port *port)
 {
-        writel(ASCWHBSTATE_CLRREN, port->membase + LTQ_ASC_WHBSTATE);
+        __raw_writel(ASCWHBSTATE_CLRREN, port->membase + LTQ_ASC_WHBSTATE);
 }
 
 static int
@@ -153,11 +153,12 @@ lqasc_rx_chars(struct uart_port *port)
         struct tty_port *tport = &port->state->port;
         unsigned int ch = 0, rsr = 0, fifocnt;
 
-        fifocnt = readl(port->membase + LTQ_ASC_FSTAT) & ASCFSTAT_RXFFLMASK;
+        fifocnt = __raw_readl(port->membase + LTQ_ASC_FSTAT) &
+                  ASCFSTAT_RXFFLMASK;
         while (fifocnt--) {
                 u8 flag = TTY_NORMAL;
                 ch = readb(port->membase + LTQ_ASC_RBUF);
-                rsr = (readl(port->membase + LTQ_ASC_STATE)
+                rsr = (__raw_readl(port->membase + LTQ_ASC_STATE)
                         & ASCSTATE_ANY) | UART_DUMMY_UER_RX;
                 tty_flip_buffer_push(tport);
                 port->icount.rx++;
@@ -217,7 +218,7 @@ lqasc_tx_chars(struct uart_port *port)
                 return;
         }
 
-        while (((readl(port->membase + LTQ_ASC_FSTAT) &
+        while (((__raw_readl(port->membase + LTQ_ASC_FSTAT) &
                 ASCFSTAT_TXFREEMASK) >> ASCFSTAT_TXFREEOFF) != 0) {
                 if (port->x_char) {
                         writeb(port->x_char, port->membase + LTQ_ASC_TBUF);
@@ -245,7 +246,7 @@ lqasc_tx_int(int irq, void *_port)
         unsigned long flags;
         struct uart_port *port = (struct uart_port *)_port;
         spin_lock_irqsave(&ltq_asc_lock, flags);
-        writel(ASC_IRNCR_TIR, port->membase + LTQ_ASC_IRNCR);
+        __raw_writel(ASC_IRNCR_TIR, port->membase + LTQ_ASC_IRNCR);
         spin_unlock_irqrestore(&ltq_asc_lock, flags);
         lqasc_start_tx(port);
         return IRQ_HANDLED;
@@ -270,7 +271,7 @@ lqasc_rx_int(int irq, void *_port)
         unsigned long flags;
         struct uart_port *port = (struct uart_port *)_port;
         spin_lock_irqsave(&ltq_asc_lock, flags);
-        writel(ASC_IRNCR_RIR, port->membase + LTQ_ASC_IRNCR);
+        __raw_writel(ASC_IRNCR_RIR, port->membase + LTQ_ASC_IRNCR);
         lqasc_rx_chars(port);
         spin_unlock_irqrestore(&ltq_asc_lock, flags);
         return IRQ_HANDLED;
@@ -280,7 +281,8 @@ static unsigned int
 lqasc_tx_empty(struct uart_port *port)
 {
         int status;
-        status = readl(port->membase + LTQ_ASC_FSTAT) & ASCFSTAT_TXFFLMASK;
+        status = __raw_readl(port->membase + LTQ_ASC_FSTAT) &
+                 ASCFSTAT_TXFFLMASK;
         return status ? 0 : TIOCSER_TEMT;
 }
 
@@ -313,12 +315,12 @@ lqasc_startup(struct uart_port *port)
         asc_update_bits(ASCCLC_DISS | ASCCLC_RMCMASK, (1 << ASCCLC_RMCOFFSET),
                 port->membase + LTQ_ASC_CLC);
 
-        writel(0, port->membase + LTQ_ASC_PISEL);
-        writel(
+        __raw_writel(0, port->membase + LTQ_ASC_PISEL);
+        __raw_writel(
                 ((TXFIFO_FL << ASCTXFCON_TXFITLOFF) & ASCTXFCON_TXFITLMASK) |
                 ASCTXFCON_TXFEN | ASCTXFCON_TXFFLU,
                 port->membase + LTQ_ASC_TXFCON);
-        writel(
+        __raw_writel(
                 ((RXFIFO_FL << ASCRXFCON_RXFITLOFF) & ASCRXFCON_RXFITLMASK)
                 | ASCRXFCON_RXFEN | ASCRXFCON_RXFFLU,
                 port->membase + LTQ_ASC_RXFCON);
@@ -350,7 +352,7 @@ lqasc_startup(struct uart_port *port)
                 goto err2;
         }
 
-        writel(ASC_IRNREN_RX | ASC_IRNREN_ERR | ASC_IRNREN_TX,
+        __raw_writel(ASC_IRNREN_RX | ASC_IRNREN_ERR | ASC_IRNREN_TX,
                 port->membase + LTQ_ASC_IRNREN);
         return 0;
 
@@ -369,7 +371,7 @@ lqasc_shutdown(struct uart_port *port)
         free_irq(ltq_port->rx_irq, port);
         free_irq(ltq_port->err_irq, port);
 
-        writel(0, port->membase + LTQ_ASC_CON);
+        __raw_writel(0, port->membase + LTQ_ASC_CON);
         asc_update_bits(ASCRXFCON_RXFEN, ASCRXFCON_RXFFLU,
                 port->membase + LTQ_ASC_RXFCON);
         asc_update_bits(ASCTXFCON_TXFEN, ASCTXFCON_TXFFLU,
@@ -461,13 +463,13 @@ lqasc_set_termios(struct uart_port *port,
         asc_update_bits(ASCCON_BRS, 0, port->membase + LTQ_ASC_CON);
 
         /* now we can write the new baudrate into the register */
-        writel(divisor, port->membase + LTQ_ASC_BG);
+        __raw_writel(divisor, port->membase + LTQ_ASC_BG);
 
         /* turn the baudrate generator back on */
         asc_update_bits(0, ASCCON_R, port->membase + LTQ_ASC_CON);
 
         /* enable rx */
-        writel(ASCWHBSTATE_SETREN, port->membase + LTQ_ASC_WHBSTATE);
+        __raw_writel(ASCWHBSTATE_SETREN, port->membase + LTQ_ASC_WHBSTATE);
 
         spin_unlock_irqrestore(&ltq_asc_lock, flags);
 
@@ -578,7 +580,7 @@ lqasc_console_putchar(struct uart_port *port, int ch)
                 return;
 
         do {
-                fifofree = (readl(port->membase + LTQ_ASC_FSTAT)
+                fifofree = (__raw_readl(port->membase + LTQ_ASC_FSTAT)
                         & ASCFSTAT_TXFREEMASK) >> ASCFSTAT_TXFREEOFF;
         } while (fifofree == 0);
         writeb(ch, port->membase + LTQ_ASC_TBUF);
diff --git a/drivers/tty/serial/qcom_geni_serial.c b/drivers/tty/serial/qcom_geni_serial.c
index a72d6d9fb983..38016609c7fa 100644
--- a/drivers/tty/serial/qcom_geni_serial.c
+++ b/drivers/tty/serial/qcom_geni_serial.c
@@ -225,7 +225,7 @@ static unsigned int qcom_geni_serial_get_mctrl(struct uart_port *uport)
         unsigned int mctrl = TIOCM_DSR | TIOCM_CAR;
         u32 geni_ios;
 
-        if (uart_console(uport) || !uart_cts_enabled(uport)) {
+        if (uart_console(uport)) {
                 mctrl |= TIOCM_CTS;
         } else {
                 geni_ios = readl_relaxed(uport->membase + SE_GENI_IOS);
@@ -241,7 +241,7 @@ static void qcom_geni_serial_set_mctrl(struct uart_port *uport,
 {
         u32 uart_manual_rfr = 0;
 
-        if (uart_console(uport) || !uart_cts_enabled(uport))
+        if (uart_console(uport))
                 return;
 
         if (!(mctrl & TIOCM_RTS))
diff --git a/drivers/tty/serial/serial_core.c b/drivers/tty/serial/serial_core.c
index d4cca5bdaf1c..5c01bb6d1c24 100644
--- a/drivers/tty/serial/serial_core.c
+++ b/drivers/tty/serial/serial_core.c
@@ -550,10 +550,12 @@ static int uart_put_char(struct tty_struct *tty, unsigned char c)
         int ret = 0;
 
         circ = &state->xmit;
-        if (!circ->buf)
+        port = uart_port_lock(state, flags);
+        if (!circ->buf) {
+                uart_port_unlock(port, flags);
                 return 0;
+        }
 
-        port = uart_port_lock(state, flags);
         if (port && uart_circ_chars_free(circ) != 0) {
                 circ->buf[circ->head] = c;
                 circ->head = (circ->head + 1) & (UART_XMIT_SIZE - 1);
@@ -586,11 +588,13 @@ static int uart_write(struct tty_struct *tty,
                 return -EL3HLT;
         }
 
+        port = uart_port_lock(state, flags);
         circ = &state->xmit;
-        if (!circ->buf)
+        if (!circ->buf) {
+                uart_port_unlock(port, flags);
                 return 0;
+        }
 
-        port = uart_port_lock(state, flags);
         while (port) {
                 c = CIRC_SPACE_TO_END(circ->head, circ->tail, UART_XMIT_SIZE);
                 if (count < c)
diff --git a/drivers/tty/tty_io.c b/drivers/tty/tty_io.c
index bfe9ad85b362..21ffcce16927 100644
--- a/drivers/tty/tty_io.c
+++ b/drivers/tty/tty_io.c
@@ -1256,7 +1256,8 @@ static void tty_driver_remove_tty(struct tty_driver *driver, struct tty_struct *
 static int tty_reopen(struct tty_struct *tty)
 {
         struct tty_driver *driver = tty->driver;
-        int retval;
+        struct tty_ldisc *ld;
+        int retval = 0;
 
         if (driver->type == TTY_DRIVER_TYPE_PTY &&
             driver->subtype == PTY_TYPE_MASTER)
@@ -1268,13 +1269,18 @@ static int tty_reopen(struct tty_struct *tty)
         if (test_bit(TTY_EXCLUSIVE, &tty->flags) && !capable(CAP_SYS_ADMIN))
                 return -EBUSY;
 
-        retval = tty_ldisc_lock(tty, 5 * HZ);
-        if (retval)
-                return retval;
+        ld = tty_ldisc_ref_wait(tty);
+        if (ld) {
+                tty_ldisc_deref(ld);
+        } else {
+                retval = tty_ldisc_lock(tty, 5 * HZ);
+                if (retval)
+                        return retval;
 
-        if (!tty->ldisc)
-                retval = tty_ldisc_reinit(tty, tty->termios.c_line);
-        tty_ldisc_unlock(tty);
+                if (!tty->ldisc)
+                        retval = tty_ldisc_reinit(tty, tty->termios.c_line);
+                tty_ldisc_unlock(tty);
+        }
 
         if (retval == 0)
                 tty->count++;
@@ -2183,7 +2189,8 @@ static int tiocsti(struct tty_struct *tty, char __user *p)
         ld = tty_ldisc_ref_wait(tty);
         if (!ld)
                 return -EIO;
-        ld->ops->receive_buf(tty, &ch, &mbz, 1);
+        if (ld->ops->receive_buf)
+                ld->ops->receive_buf(tty, &ch, &mbz, 1);
         tty_ldisc_deref(ld);
         return 0;
 }
diff --git a/drivers/tty/vt/vt.c b/drivers/tty/vt/vt.c
index 41ec8e5010f3..bba75560d11e 100644
--- a/drivers/tty/vt/vt.c
+++ b/drivers/tty/vt/vt.c
@@ -1272,6 +1272,7 @@ static int vc_do_resize(struct tty_struct *tty, struct vc_data *vc,
         if (con_is_visible(vc))
                 update_screen(vc);
         vt_event_post(VT_EVENT_RESIZE, vc->vc_num, vc->vc_num);
+        notify_update(vc);
         return err;
 }
 
@@ -2764,8 +2765,8 @@ rescan_last_byte:
         con_flush(vc, draw_from, draw_to, &draw_x);
         vc_uniscr_debug_check(vc);
         console_conditional_schedule();
-        console_unlock();
         notify_update(vc);
+        console_unlock();
         return n;
 }
 
@@ -2884,8 +2885,7 @@ static void vt_console_print(struct console *co, const char *b, unsigned count)
         unsigned char c;
         static DEFINE_SPINLOCK(printing_lock);
         const ushort *start;
-        ushort cnt = 0;
-        ushort myx;
+        ushort start_x, cnt;
         int kmsg_console;
 
         /* console busy or not yet initialized */
@@ -2898,10 +2898,6 @@ static void vt_console_print(struct console *co, const char *b, unsigned count)
         if (kmsg_console && vc_cons_allocated(kmsg_console - 1))
                 vc = vc_cons[kmsg_console - 1].d;
 
-        /* read `x' only after setting currcons properly (otherwise
-           the `x' macro will read the x of the foreground console). */
-        myx = vc->vc_x;
-
         if (!vc_cons_allocated(fg_console)) {
                 /* impossible */
                 /* printk("vt_console_print: tty %d not allocated ??\n", currcons+1); */
@@ -2916,53 +2912,41 @@ static void vt_console_print(struct console *co, const char *b, unsigned count)
                 hide_cursor(vc);
 
         start = (ushort *)vc->vc_pos;
-
-        /* Contrived structure to try to emulate original need_wrap behaviour
-         * Problems caused when we have need_wrap set on '\n' character */
+        start_x = vc->vc_x;
+        cnt = 0;
         while (count--) {
                 c = *b++;
                 if (c == 10 || c == 13 || c == 8 || vc->vc_need_wrap) {
-                        if (cnt > 0) {
-                                if (con_is_visible(vc))
-                                        vc->vc_sw->con_putcs(vc, start, cnt, vc->vc_y, vc->vc_x);
-                                vc->vc_x += cnt;
-                                if (vc->vc_need_wrap)
-                                        vc->vc_x--;
-                                cnt = 0;
-                        }
+                        if (cnt && con_is_visible(vc))
+                                vc->vc_sw->con_putcs(vc, start, cnt, vc->vc_y, start_x);
+                        cnt = 0;
                         if (c == 8) {           /* backspace */
                                 bs(vc);
                                 start = (ushort *)vc->vc_pos;
-                                myx = vc->vc_x;
+                                start_x = vc->vc_x;
                                 continue;
                         }
                         if (c != 13)
                                 lf(vc);
                         cr(vc);
                         start = (ushort *)vc->vc_pos;
-                        myx = vc->vc_x;
+                        start_x = vc->vc_x;
                         if (c == 10 || c == 13)
                                 continue;
                 }
+                vc_uniscr_putc(vc, c);
                 scr_writew((vc->vc_attr << 8) + c, (unsigned short *)vc->vc_pos);
                 notify_write(vc, c);
                 cnt++;
-                if (myx == vc->vc_cols - 1) {
-                        vc->vc_need_wrap = 1;
-                        continue;
-                }
-                vc->vc_pos += 2;
-                myx++;
-        }
-        if (cnt > 0) {
-                if (con_is_visible(vc))
-                        vc->vc_sw->con_putcs(vc, start, cnt, vc->vc_y, vc->vc_x);
-                vc->vc_x += cnt;
-                if (vc->vc_x == vc->vc_cols) {
-                        vc->vc_x--;
+                if (vc->vc_x == vc->vc_cols - 1) {
                         vc->vc_need_wrap = 1;
+                } else {
+                        vc->vc_pos += 2;
+                        vc->vc_x++;
                 }
         }
+        if (cnt && con_is_visible(vc))
+                vc->vc_sw->con_putcs(vc, start, cnt, vc->vc_y, start_x);
         set_cursor(vc);
         notify_update(vc);
 
diff --git a/drivers/usb/chipidea/ci_hdrc_imx.c b/drivers/usb/chipidea/ci_hdrc_imx.c
index e81de9ca8729..9b45aa422e69 100644
--- a/drivers/usb/chipidea/ci_hdrc_imx.c
+++ b/drivers/usb/chipidea/ci_hdrc_imx.c
@@ -316,7 +316,8 @@ static int ci_hdrc_imx_probe(struct platform_device *pdev)
         if (IS_ERR(data->usbmisc_data))
                 return PTR_ERR(data->usbmisc_data);
 
-        if (of_usb_get_phy_mode(dev->of_node) == USBPHY_INTERFACE_MODE_HSIC) {
+        if ((of_usb_get_phy_mode(dev->of_node) == USBPHY_INTERFACE_MODE_HSIC)
+                && data->usbmisc_data) {
                 pdata.flags |= CI_HDRC_IMX_IS_HSIC;
                 data->usbmisc_data->hsic = 1;
                 data->pinctrl = devm_pinctrl_get(dev);
diff --git a/drivers/usb/class/cdc-acm.c b/drivers/usb/class/cdc-acm.c
index ed8c62b2d9d1..739f8960811a 100644
--- a/drivers/usb/class/cdc-acm.c
+++ b/drivers/usb/class/cdc-acm.c
@@ -1865,6 +1865,13 @@ static const struct usb_device_id acm_ids[] = {
         .driver_info = IGNORE_DEVICE,
         },
 
+        { USB_DEVICE(0x1bc7, 0x0021), /* Telit 3G ACM only composition */
+        .driver_info = SEND_ZERO_PACKET,
+        },
+        { USB_DEVICE(0x1bc7, 0x0023), /* Telit 3G ACM + ECM composition */
+        .driver_info = SEND_ZERO_PACKET,
+        },
+
         /* control interfaces without any protocol set */
         { USB_INTERFACE_INFO(USB_CLASS_COMM, USB_CDC_SUBCLASS_ACM,
                 USB_CDC_PROTO_NONE) },
diff --git a/drivers/usb/core/generic.c b/drivers/usb/core/generic.c
index 356b05c82dbc..f713cecc1f41 100644
--- a/drivers/usb/core/generic.c
+++ b/drivers/usb/core/generic.c
@@ -143,9 +143,12 @@ int usb_choose_configuration(struct usb_device *udev)
                         continue;
                 }
 
-                if (i > 0 && desc && is_audio(desc) && is_uac3_config(desc)) {
-                        best = c;
-                        break;
+                if (i > 0 && desc && is_audio(desc)) {
+                        if (is_uac3_config(desc)) {
+                                best = c;
+                                break;
+                        }
+                        continue;
                 }
 
                 /* From the remaining configs, choose the first one whose
diff --git a/drivers/usb/core/ledtrig-usbport.c b/drivers/usb/core/ledtrig-usbport.c
index dc7f7fd71684..c12ac56606c3 100644
--- a/drivers/usb/core/ledtrig-usbport.c
+++ b/drivers/usb/core/ledtrig-usbport.c
@@ -119,11 +119,6 @@ static const struct attribute_group ports_group = {
         .attrs = ports_attrs,
 };
 
-static const struct attribute_group *ports_groups[] = {
-        &ports_group,
-        NULL
-};
-
 /***************************************
  * Adding & removing ports
  ***************************************/
@@ -307,6 +302,7 @@ static int usbport_trig_notify(struct notifier_block *nb, unsigned long action,
 static int usbport_trig_activate(struct led_classdev *led_cdev)
 {
         struct usbport_trig_data *usbport_data;
+        int err;
 
         usbport_data = kzalloc(sizeof(*usbport_data), GFP_KERNEL);
         if (!usbport_data)
@@ -315,6 +311,9 @@ static int usbport_trig_activate(struct led_classdev *led_cdev)
 
         /* List of ports */
         INIT_LIST_HEAD(&usbport_data->ports);
+        err = sysfs_create_group(&led_cdev->dev->kobj, &ports_group);
+        if (err)
+                goto err_free;
         usb_for_each_dev(usbport_data, usbport_trig_add_usb_dev_ports);
         usbport_trig_update_count(usbport_data);
 
@@ -322,8 +321,11 @@ static int usbport_trig_activate(struct led_classdev *led_cdev)
         usbport_data->nb.notifier_call = usbport_trig_notify;
         led_set_trigger_data(led_cdev, usbport_data);
         usb_register_notify(&usbport_data->nb);
-
         return 0;
+
+err_free:
+        kfree(usbport_data);
+        return err;
 }
 
 static void usbport_trig_deactivate(struct led_classdev *led_cdev)
@@ -335,6 +337,8 @@ static void usbport_trig_deactivate(struct led_classdev *led_cdev)
                 usbport_trig_remove_port(usbport_data, port);
         }
 
+        sysfs_remove_group(&led_cdev->dev->kobj, &ports_group);
+
         usb_unregister_notify(&usbport_data->nb);
 
         kfree(usbport_data);
@@ -344,7 +348,6 @@ static struct led_trigger usbport_led_trigger = {
         .name     = "usbport",
         .activate = usbport_trig_activate,
         .deactivate = usbport_trig_deactivate,
-        .groups = ports_groups,
 };
 
 static int __init usbport_trig_init(void)
diff --git a/drivers/usb/core/quirks.c b/drivers/usb/core/quirks.c
index 514c5214ddb2..8bc35d53408b 100644
--- a/drivers/usb/core/quirks.c
+++ b/drivers/usb/core/quirks.c
@@ -394,7 +394,8 @@ static const struct usb_device_id usb_quirk_list[] = {
         { USB_DEVICE(0x1a40, 0x0101), .driver_info = USB_QUIRK_HUB_SLOW_RESET },
 
         /* Corsair K70 RGB */
-        { USB_DEVICE(0x1b1c, 0x1b13), .driver_info = USB_QUIRK_DELAY_INIT },
+        { USB_DEVICE(0x1b1c, 0x1b13), .driver_info = USB_QUIRK_DELAY_INIT |
+          USB_QUIRK_DELAY_CTRL_MSG },
 
         /* Corsair Strafe */
         { USB_DEVICE(0x1b1c, 0x1b15), .driver_info = USB_QUIRK_DELAY_INIT |
diff --git a/drivers/usb/dwc2/gadget.c b/drivers/usb/dwc2/gadget.c
index 68ad75a7460d..55ef3cc2701b 100644
--- a/drivers/usb/dwc2/gadget.c
+++ b/drivers/usb/dwc2/gadget.c
@@ -261,7 +261,7 @@ static void dwc2_gadget_wkup_alert_handler(struct dwc2_hsotg *hsotg)
 
         if (gintsts2 & GINTSTS2_WKUP_ALERT_INT) {
                 dev_dbg(hsotg->dev, "%s: Wkup_Alert_Int\n", __func__);
-                dwc2_clear_bit(hsotg, GINTSTS2, GINTSTS2_WKUP_ALERT_INT);
+                dwc2_set_bit(hsotg, GINTSTS2, GINTSTS2_WKUP_ALERT_INT);
                 dwc2_set_bit(hsotg, DCTL, DCTL_RMTWKUPSIG);
         }
 }
diff --git a/drivers/usb/dwc3/gadget.c b/drivers/usb/dwc3/gadget.c
index 07bd31bb2f8a..bed2ff42780b 100644
--- a/drivers/usb/dwc3/gadget.c
+++ b/drivers/usb/dwc3/gadget.c
@@ -177,6 +177,7 @@ static void dwc3_gadget_del_and_unmap_request(struct dwc3_ep *dep,
         req->started = false;
         list_del(&req->list);
         req->remaining = 0;
+        req->needs_extra_trb = false;
 
         if (req->request.status == -EINPROGRESS)
                 req->request.status = status;
@@ -1984,6 +1985,7 @@ static int __dwc3_gadget_start(struct dwc3 *dwc)
 
         /* begin to receive SETUP packets */
         dwc->ep0state = EP0_SETUP_PHASE;
+        dwc->link_state = DWC3_LINK_STATE_SS_DIS;
         dwc3_ep0_out_start(dwc);
 
         dwc3_gadget_enable_irq(dwc);
@@ -3379,6 +3381,8 @@ int dwc3_gadget_suspend(struct dwc3 *dwc)
         dwc3_disconnect_gadget(dwc);
         __dwc3_gadget_stop(dwc);
 
+        synchronize_irq(dwc->irq_gadget);
+
         return 0;
 }
 
diff --git a/drivers/usb/gadget/function/f_sourcesink.c b/drivers/usb/gadget/function/f_sourcesink.c
index 9cdef108fb1b..ed68a4860b7d 100644
--- a/drivers/usb/gadget/function/f_sourcesink.c
+++ b/drivers/usb/gadget/function/f_sourcesink.c
@@ -838,7 +838,7 @@ static struct usb_function *source_sink_alloc_func(
 
         ss = kzalloc(sizeof(*ss), GFP_KERNEL);
         if (!ss)
-                return NULL;
+                return ERR_PTR(-ENOMEM);
 
         ss_opts =  container_of(fi, struct f_ss_opts, func_inst);
 
diff --git a/drivers/usb/gadget/udc/bdc/bdc_core.c b/drivers/usb/gadget/udc/bdc/bdc_core.c
index 01b44e159623..ccbd1d34eb2a 100644
--- a/drivers/usb/gadget/udc/bdc/bdc_core.c
+++ b/drivers/usb/gadget/udc/bdc/bdc_core.c
@@ -172,8 +172,9 @@ static int scratchpad_setup(struct bdc *bdc)
         /* Refer to BDC spec, Table 4 for description of SPB */
         sp_buff_size = 1 << (sp_buff_size + 5);
         dev_dbg(bdc->dev, "Allocating %d bytes for scratchpad\n", sp_buff_size);
-        bdc->scratchpad.buff  =  dma_zalloc_coherent(bdc->dev, sp_buff_size,
-                                        &bdc->scratchpad.sp_dma, GFP_KERNEL);
+        bdc->scratchpad.buff  =  dma_alloc_coherent(bdc->dev, sp_buff_size,
+                                                    &bdc->scratchpad.sp_dma,
+                                                    GFP_KERNEL);
 
         if (!bdc->scratchpad.buff)
                 goto fail;
@@ -202,11 +203,9 @@ static int setup_srr(struct bdc *bdc, int interrupter)
         bdc_writel(bdc->regs, BDC_SRRINT(0), BDC_SRR_RWS | BDC_SRR_RST);
         bdc->srr.dqp_index = 0;
         /* allocate the status report descriptors */
-        bdc->srr.sr_bds = dma_zalloc_coherent(
-                                        bdc->dev,
-                                        NUM_SR_ENTRIES * sizeof(struct bdc_bd),
-                                        &bdc->srr.dma_addr,
-                                        GFP_KERNEL);
+        bdc->srr.sr_bds = dma_alloc_coherent(bdc->dev,
+                                             NUM_SR_ENTRIES * sizeof(struct bdc_bd),
+                                             &bdc->srr.dma_addr, GFP_KERNEL);
         if (!bdc->srr.sr_bds)
                 return -ENOMEM;
 
diff --git a/drivers/usb/host/ehci-mv.c b/drivers/usb/host/ehci-mv.c
index f26109eafdbf..66ec1fdf9fe7 100644
--- a/drivers/usb/host/ehci-mv.c
+++ b/drivers/usb/host/ehci-mv.c
@@ -302,3 +302,4 @@ MODULE_AUTHOR("Chao Xie <chao.xie@marvell.com>");
 MODULE_AUTHOR("Neil Zhang <zhangwm@marvell.com>");
 MODULE_ALIAS("mv-ehci");
 MODULE_LICENSE("GPL");
+MODULE_DEVICE_TABLE(of, ehci_mv_dt_ids);
diff --git a/drivers/usb/host/uhci-hcd.c b/drivers/usb/host/uhci-hcd.c
index 6218bfe54f52..98deb5f64268 100644
--- a/drivers/usb/host/uhci-hcd.c
+++ b/drivers/usb/host/uhci-hcd.c
@@ -596,9 +596,9 @@ static int uhci_start(struct usb_hcd *hcd)
                                            &uhci_debug_operations);
 #endif
 
-        uhci->frame = dma_zalloc_coherent(uhci_dev(uhci),
-                        UHCI_NUMFRAMES * sizeof(*uhci->frame),
-                        &uhci->frame_dma_handle, GFP_KERNEL);
+        uhci->frame = dma_alloc_coherent(uhci_dev(uhci),
+                                         UHCI_NUMFRAMES * sizeof(*uhci->frame),
+                                         &uhci->frame_dma_handle, GFP_KERNEL);
         if (!uhci->frame) {
                 dev_err(uhci_dev(uhci),
                         "unable to allocate consistent memory for frame list\n");
diff --git a/drivers/usb/host/xhci-mem.c b/drivers/usb/host/xhci-mem.c
index 36a3eb8849f1..8067f178fa84 100644
--- a/drivers/usb/host/xhci-mem.c
+++ b/drivers/usb/host/xhci-mem.c
@@ -1672,8 +1672,8 @@ static int scratchpad_alloc(struct xhci_hcd *xhci, gfp_t flags)
         xhci->dcbaa->dev_context_ptrs[0] = cpu_to_le64(xhci->scratchpad->sp_dma);
         for (i = 0; i < num_sp; i++) {
                 dma_addr_t dma;
-                void *buf = dma_zalloc_coherent(dev, xhci->page_size, &dma,
-                                flags);
+                void *buf = dma_alloc_coherent(dev, xhci->page_size, &dma,
+                                               flags);
                 if (!buf)
                         goto fail_sp4;
 
@@ -1799,8 +1799,8 @@ int xhci_alloc_erst(struct xhci_hcd *xhci,
         struct xhci_erst_entry *entry;
 
         size = sizeof(struct xhci_erst_entry) * evt_ring->num_segs;
-        erst->entries = dma_zalloc_coherent(xhci_to_hcd(xhci)->self.sysdev,
-                                            size, &erst->erst_dma_addr, flags);
+        erst->entries = dma_alloc_coherent(xhci_to_hcd(xhci)->self.sysdev,
+                                           size, &erst->erst_dma_addr, flags);
         if (!erst->entries)
                 return -ENOMEM;
 
diff --git a/drivers/usb/serial/ftdi_sio.c b/drivers/usb/serial/ftdi_sio.c
index 1ab2a6191013..77ef4c481f3c 100644
--- a/drivers/usb/serial/ftdi_sio.c
+++ b/drivers/usb/serial/ftdi_sio.c
@@ -1783,6 +1783,10 @@ static int ftdi_set_bitmode(struct usb_serial_port *port, u8 mode)
         int result;
         u16 val;
 
+        result = usb_autopm_get_interface(serial->interface);
+        if (result)
+                return result;
+
         val = (mode << 8) | (priv->gpio_output << 4) | priv->gpio_value;
         result = usb_control_msg(serial->dev,
                                  usb_sndctrlpipe(serial->dev, 0),
@@ -1795,6 +1799,8 @@ static int ftdi_set_bitmode(struct usb_serial_port *port, u8 mode)
                         val, result);
         }
 
+        usb_autopm_put_interface(serial->interface);
+
         return result;
 }
 
@@ -1846,9 +1852,15 @@ static int ftdi_read_cbus_pins(struct usb_serial_port *port)
         unsigned char *buf;
         int result;
 
+        result = usb_autopm_get_interface(serial->interface);
+        if (result)
+                return result;
+
         buf = kmalloc(1, GFP_KERNEL);
-        if (!buf)
+        if (!buf) {
+                usb_autopm_put_interface(serial->interface);
                 return -ENOMEM;
+        }
 
         result = usb_control_msg(serial->dev,
                                  usb_rcvctrlpipe(serial->dev, 0),
@@ -1863,6 +1875,7 @@ static int ftdi_read_cbus_pins(struct usb_serial_port *port)
         }
 
         kfree(buf);
+        usb_autopm_put_interface(serial->interface);
 
         return result;
 }
diff --git a/drivers/usb/serial/keyspan_usa26msg.h b/drivers/usb/serial/keyspan_usa26msg.h
index 09e21e84fc4e..a68f1fb25b8a 100644
--- a/drivers/usb/serial/keyspan_usa26msg.h
+++ b/drivers/usb/serial/keyspan_usa26msg.h
@@ -1,3 +1,4 @@
+/* SPDX-License-Identifier: BSD-3-Clause */
 /*
         usa26msg.h
 
diff --git a/drivers/usb/serial/keyspan_usa28msg.h b/drivers/usb/serial/keyspan_usa28msg.h
index dee454c4609a..a19f3fe5d98d 100644
--- a/drivers/usb/serial/keyspan_usa28msg.h
+++ b/drivers/usb/serial/keyspan_usa28msg.h
@@ -1,3 +1,4 @@
+/* SPDX-License-Identifier: BSD-3-Clause */
 /*
         usa28msg.h
 
diff --git a/drivers/usb/serial/keyspan_usa49msg.h b/drivers/usb/serial/keyspan_usa49msg.h
index 163b2dea2ec5..8c3970fdd868 100644
--- a/drivers/usb/serial/keyspan_usa49msg.h
+++ b/drivers/usb/serial/keyspan_usa49msg.h
@@ -1,3 +1,4 @@
+/* SPDX-License-Identifier: BSD-3-Clause */
 /*
         usa49msg.h
 
diff --git a/drivers/usb/serial/keyspan_usa67msg.h b/drivers/usb/serial/keyspan_usa67msg.h
index 20fa3e2f7187..dcf502fdbb44 100644
--- a/drivers/usb/serial/keyspan_usa67msg.h
+++ b/drivers/usb/serial/keyspan_usa67msg.h
@@ -1,3 +1,4 @@
+/* SPDX-License-Identifier: BSD-3-Clause */
 /*
         usa67msg.h
 
diff --git a/drivers/usb/serial/keyspan_usa90msg.h b/drivers/usb/serial/keyspan_usa90msg.h
index 86708ecd8735..c4ca0f631d20 100644
--- a/drivers/usb/serial/keyspan_usa90msg.h
+++ b/drivers/usb/serial/keyspan_usa90msg.h
@@ -1,3 +1,4 @@
+/* SPDX-License-Identifier: BSD-3-Clause */
 /*
         usa90msg.h
 
diff --git a/drivers/usb/serial/pl2303.c b/drivers/usb/serial/pl2303.c
index 98e7a5df0f6d..bb3f9aa4a909 100644
--- a/drivers/usb/serial/pl2303.c
+++ b/drivers/usb/serial/pl2303.c
@@ -46,6 +46,7 @@ static const struct usb_device_id id_table[] = {
         { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_HCR331) },
         { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_MOTOROLA) },
         { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_ZTEK) },
+        { USB_DEVICE(PL2303_VENDOR_ID, PL2303_PRODUCT_ID_TB) },
         { USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID) },
         { USB_DEVICE(IODATA_VENDOR_ID, IODATA_PRODUCT_ID_RSAQ5) },
         { USB_DEVICE(ATEN_VENDOR_ID, ATEN_PRODUCT_ID),
diff --git a/drivers/usb/serial/pl2303.h b/drivers/usb/serial/pl2303.h
index 4e2554d55362..559941ca884d 100644
--- a/drivers/usb/serial/pl2303.h
+++ b/drivers/usb/serial/pl2303.h
@@ -8,6 +8,7 @@
 
 #define PL2303_VENDOR_ID        0x067b
 #define PL2303_PRODUCT_ID       0x2303
+#define PL2303_PRODUCT_ID_TB            0x2304
 #define PL2303_PRODUCT_ID_RSAQ2         0x04bb
 #define PL2303_PRODUCT_ID_DCU11         0x1234
 #define PL2303_PRODUCT_ID_PHAROS        0xaaa0
@@ -20,6 +21,7 @@
 #define PL2303_PRODUCT_ID_MOTOROLA      0x0307
 #define PL2303_PRODUCT_ID_ZTEK          0xe1f1
 
+
 #define ATEN_VENDOR_ID          0x0557
 #define ATEN_VENDOR_ID2         0x0547
 #define ATEN_PRODUCT_ID         0x2008
diff --git a/drivers/usb/serial/usb-serial-simple.c b/drivers/usb/serial/usb-serial-simple.c
index 4d0273508043..edbbb13d6de6 100644
--- a/drivers/usb/serial/usb-serial-simple.c
+++ b/drivers/usb/serial/usb-serial-simple.c
@@ -85,7 +85,8 @@ DEVICE(moto_modem, MOTO_IDS);
 /* Motorola Tetra driver */
 #define MOTOROLA_TETRA_IDS()                    \
         { USB_DEVICE(0x0cad, 0x9011) }, /* Motorola Solutions TETRA PEI */ \
-        { USB_DEVICE(0x0cad, 0x9012) }  /* MTP6550 */
+        { USB_DEVICE(0x0cad, 0x9012) }, /* MTP6550 */ \
+        { USB_DEVICE(0x0cad, 0x9016) }  /* TPG2200 */
 DEVICE(motorola_tetra, MOTOROLA_TETRA_IDS);
 
 /* Novatel Wireless GPS driver */
diff --git a/drivers/usb/storage/scsiglue.c b/drivers/usb/storage/scsiglue.c
index fde2e71a6ade..a73ea495d5a7 100644
--- a/drivers/usb/storage/scsiglue.c
+++ b/drivers/usb/storage/scsiglue.c
@@ -235,8 +235,12 @@ static int slave_configure(struct scsi_device *sdev)
                 if (!(us->fflags & US_FL_NEEDS_CAP16))
                         sdev->try_rc_10_first = 1;
 
-                /* assume SPC3 or latter devices support sense size > 18 */
-                if (sdev->scsi_level > SCSI_SPC_2)
+                /*
+                 * assume SPC3 or latter devices support sense size > 18
+                 * unless US_FL_BAD_SENSE quirk is specified.
+                 */
+                if (sdev->scsi_level > SCSI_SPC_2 &&
+                    !(us->fflags & US_FL_BAD_SENSE))
                         us->fflags |= US_FL_SANE_SENSE;
 
                 /*
diff --git a/drivers/usb/storage/unusual_devs.h b/drivers/usb/storage/unusual_devs.h
index f7f83b21dc74..ea0d27a94afe 100644
--- a/drivers/usb/storage/unusual_devs.h
+++ b/drivers/usb/storage/unusual_devs.h
@@ -1266,6 +1266,18 @@ UNUSUAL_DEV( 0x090c, 0x1132, 0x0000, 0xffff,
                 US_FL_FIX_CAPACITY ),
 
 /*
+ * Reported by Icenowy Zheng <icenowy@aosc.io>
+ * The SMI SM3350 USB-UFS bridge controller will enter a wrong state
+ * that do not process read/write command if a long sense is requested,
+ * so force to use 18-byte sense.
+ */
+UNUSUAL_DEV(  0x090c, 0x3350, 0x0000, 0xffff,
+                "SMI",
+                "SM3350 UFS-to-USB-Mass-Storage bridge",
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
+                US_FL_BAD_SENSE ),
+
+/*
  * Reported by Paul Hartman <paul.hartman+linux@gmail.com>
  * This card reader returns "Illegal Request, Logical Block Address
  * Out of Range" for the first READ(10) after a new card is inserted.
diff --git a/drivers/usb/usbip/README b/drivers/usb/usbip/README
deleted file mode 100644
index 41a2cf2e77a6..000000000000
--- a/drivers/usb/usbip/README
+++ /dev/null
@@ -1,7 +0,0 @@
-TODO:
-        - more discussion about the protocol
-        - testing
-        - review of the userspace interface
-        - document the protocol
-
-Please send patches for this code to Greg Kroah-Hartman <greg@kroah.com>
diff --git a/drivers/vfio/pci/trace.h b/drivers/vfio/pci/trace.h
index 228ccdb8d1c8..b2aa986ab9ed 100644
--- a/drivers/vfio/pci/trace.h
+++ b/drivers/vfio/pci/trace.h
@@ -1,13 +1,9 @@
-/* SPDX-License-Identifier: GPL-2.0+ */
+/* SPDX-License-Identifier: GPL-2.0-only */
 /*
  * VFIO PCI mmap/mmap_fault tracepoints
  *
  * Copyright (C) 2018 IBM Corp.  All rights reserved.
  *     Author: Alexey Kardashevskiy <aik@ozlabs.ru>
- *
- * 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.
  */
 
 #undef TRACE_SYSTEM
@@ -94,7 +90,7 @@ TRACE_EVENT(vfio_pci_npu2_mmap,
 #endif /* _TRACE_VFIO_PCI_H */
 
 #undef TRACE_INCLUDE_PATH
-#define TRACE_INCLUDE_PATH .
+#define TRACE_INCLUDE_PATH ../../drivers/vfio/pci
 #undef TRACE_INCLUDE_FILE
 #define TRACE_INCLUDE_FILE trace
 
diff --git a/drivers/vfio/pci/vfio_pci_nvlink2.c b/drivers/vfio/pci/vfio_pci_nvlink2.c
index 054a2cf9dd8e..32f695ffe128 100644
--- a/drivers/vfio/pci/vfio_pci_nvlink2.c
+++ b/drivers/vfio/pci/vfio_pci_nvlink2.c
@@ -1,14 +1,10 @@
-// SPDX-License-Identifier: GPL-2.0+
+// SPDX-License-Identifier: GPL-2.0-only
 /*
  * VFIO PCI NVIDIA Whitherspoon GPU support a.k.a. NVLink2.
  *
  * Copyright (C) 2018 IBM Corp.  All rights reserved.
  *     Author: Alexey Kardashevskiy <aik@ozlabs.ru>
  *
- * 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.
- *
  * Register an on-GPU RAM region for cacheable access.
  *
  * Derived from original vfio_pci_igd.c:
@@ -178,11 +174,11 @@ static int vfio_pci_nvgpu_add_capability(struct vfio_pci_device *vdev,
                 struct vfio_pci_region *region, struct vfio_info_cap *caps)
 {
         struct vfio_pci_nvgpu_data *data = region->data;
-        struct vfio_region_info_cap_nvlink2_ssatgt cap = { 0 };
-
-        cap.header.id = VFIO_REGION_INFO_CAP_NVLINK2_SSATGT;
-        cap.header.version = 1;
-        cap.tgt = data->gpu_tgt;
+        struct vfio_region_info_cap_nvlink2_ssatgt cap = {
+                .header.id = VFIO_REGION_INFO_CAP_NVLINK2_SSATGT,
+                .header.version = 1,
+                .tgt = data->gpu_tgt
+        };
 
         return vfio_info_add_capability(caps, &cap.header, sizeof(cap));
 }
@@ -365,18 +361,18 @@ static int vfio_pci_npu2_add_capability(struct vfio_pci_device *vdev,
                 struct vfio_pci_region *region, struct vfio_info_cap *caps)
 {
         struct vfio_pci_npu2_data *data = region->data;
-        struct vfio_region_info_cap_nvlink2_ssatgt captgt = { 0 };
-        struct vfio_region_info_cap_nvlink2_lnkspd capspd = { 0 };
+        struct vfio_region_info_cap_nvlink2_ssatgt captgt = {
+                .header.id = VFIO_REGION_INFO_CAP_NVLINK2_SSATGT,
+                .header.version = 1,
+                .tgt = data->gpu_tgt
+        };
+        struct vfio_region_info_cap_nvlink2_lnkspd capspd = {
+                .header.id = VFIO_REGION_INFO_CAP_NVLINK2_LNKSPD,
+                .header.version = 1,
+                .link_speed = data->link_speed
+        };
         int ret;
 
-        captgt.header.id = VFIO_REGION_INFO_CAP_NVLINK2_SSATGT;
-        captgt.header.version = 1;
-        captgt.tgt = data->gpu_tgt;
-
-        capspd.header.id = VFIO_REGION_INFO_CAP_NVLINK2_LNKSPD;
-        capspd.header.version = 1;
-        capspd.link_speed = data->link_speed;
-
         ret = vfio_info_add_capability(caps, &captgt.header, sizeof(captgt));
         if (ret)
                 return ret;
diff --git a/drivers/vfio/vfio_iommu_type1.c b/drivers/vfio/vfio_iommu_type1.c
index 7651cfb14836..73652e21efec 100644
--- a/drivers/vfio/vfio_iommu_type1.c
+++ b/drivers/vfio/vfio_iommu_type1.c
@@ -878,7 +878,7 @@ static int vfio_dma_do_unmap(struct vfio_iommu *iommu,
                 return -EINVAL;
         if (!unmap->size || unmap->size & mask)
                 return -EINVAL;
-        if (unmap->iova + unmap->size < unmap->iova ||
+        if (unmap->iova + unmap->size - 1 < unmap->iova ||
             unmap->size > SIZE_MAX)
                 return -EINVAL;
 
diff --git a/drivers/vhost/net.c b/drivers/vhost/net.c
index 36f3d0f49e60..bca86bf7189f 100644
--- a/drivers/vhost/net.c
+++ b/drivers/vhost/net.c
@@ -1236,7 +1236,8 @@ static void handle_rx(struct vhost_net *net)
                 if (nvq->done_idx > VHOST_NET_BATCH)
                         vhost_net_signal_used(nvq);
                 if (unlikely(vq_log))
-                        vhost_log_write(vq, vq_log, log, vhost_len);
+                        vhost_log_write(vq, vq_log, log, vhost_len,
+                                        vq->iov, in);
                 total_len += vhost_len;
                 if (unlikely(vhost_exceeds_weight(++recv_pkts, total_len))) {
                         vhost_poll_queue(&vq->poll);
diff --git a/drivers/vhost/scsi.c b/drivers/vhost/scsi.c
index 8e10ab436d1f..344684f3e2e4 100644
--- a/drivers/vhost/scsi.c
+++ b/drivers/vhost/scsi.c
@@ -1127,16 +1127,18 @@ vhost_scsi_send_tmf_reject(struct vhost_scsi *vs,
                            struct vhost_virtqueue *vq,
                            struct vhost_scsi_ctx *vc)
 {
-        struct virtio_scsi_ctrl_tmf_resp __user *resp;
         struct virtio_scsi_ctrl_tmf_resp rsp;
+        struct iov_iter iov_iter;
         int ret;
 
         pr_debug("%s\n", __func__);
         memset(&rsp, 0, sizeof(rsp));
         rsp.response = VIRTIO_SCSI_S_FUNCTION_REJECTED;
-        resp = vq->iov[vc->out].iov_base;
-        ret = __copy_to_user(resp, &rsp, sizeof(rsp));
-        if (!ret)
+
+        iov_iter_init(&iov_iter, READ, &vq->iov[vc->out], vc->in, sizeof(rsp));
+
+        ret = copy_to_iter(&rsp, sizeof(rsp), &iov_iter);
+        if (likely(ret == sizeof(rsp)))
                 vhost_add_used_and_signal(&vs->dev, vq, vc->head, 0);
         else
                 pr_err("Faulted on virtio_scsi_ctrl_tmf_resp\n");
@@ -1147,16 +1149,18 @@ vhost_scsi_send_an_resp(struct vhost_scsi *vs,
                         struct vhost_virtqueue *vq,
                         struct vhost_scsi_ctx *vc)
 {
-        struct virtio_scsi_ctrl_an_resp __user *resp;
         struct virtio_scsi_ctrl_an_resp rsp;
+        struct iov_iter iov_iter;
         int ret;
 
         pr_debug("%s\n", __func__);
         memset(&rsp, 0, sizeof(rsp));   /* event_actual = 0 */
         rsp.response = VIRTIO_SCSI_S_OK;
-        resp = vq->iov[vc->out].iov_base;
-        ret = __copy_to_user(resp, &rsp, sizeof(rsp));
-        if (!ret)
+
+        iov_iter_init(&iov_iter, READ, &vq->iov[vc->out], vc->in, sizeof(rsp));
+
+        ret = copy_to_iter(&rsp, sizeof(rsp), &iov_iter);
+        if (likely(ret == sizeof(rsp)))
                 vhost_add_used_and_signal(&vs->dev, vq, vc->head, 0);
         else
                 pr_err("Faulted on virtio_scsi_ctrl_an_resp\n");
diff --git a/drivers/vhost/vhost.c b/drivers/vhost/vhost.c
index 9f7942cbcbb2..15a216cdd507 100644
--- a/drivers/vhost/vhost.c
+++ b/drivers/vhost/vhost.c
@@ -1034,8 +1034,10 @@ ssize_t vhost_chr_write_iter(struct vhost_dev *dev,
         int type, ret;
 
         ret = copy_from_iter(&type, sizeof(type), from);
-        if (ret != sizeof(type))
+        if (ret != sizeof(type)) {
+                ret = -EINVAL;
                 goto done;
+        }
 
         switch (type) {
         case VHOST_IOTLB_MSG:
@@ -1054,8 +1056,10 @@ ssize_t vhost_chr_write_iter(struct vhost_dev *dev,
 
         iov_iter_advance(from, offset);
         ret = copy_from_iter(&msg, sizeof(msg), from);
-        if (ret != sizeof(msg))
+        if (ret != sizeof(msg)) {
+                ret = -EINVAL;
                 goto done;
+        }
         if (vhost_process_iotlb_msg(dev, &msg)) {
                 ret = -EFAULT;
                 goto done;
@@ -1733,13 +1737,87 @@ static int log_write(void __user *log_base,
         return r;
 }
 
+static int log_write_hva(struct vhost_virtqueue *vq, u64 hva, u64 len)
+{
+        struct vhost_umem *umem = vq->umem;
+        struct vhost_umem_node *u;
+        u64 start, end, l, min;
+        int r;
+        bool hit = false;
+
+        while (len) {
+                min = len;
+                /* More than one GPAs can be mapped into a single HVA. So
+                 * iterate all possible umems here to be safe.
+                 */
+                list_for_each_entry(u, &umem->umem_list, link) {
+                        if (u->userspace_addr > hva - 1 + len ||
+                            u->userspace_addr - 1 + u->size < hva)
+                                continue;
+                        start = max(u->userspace_addr, hva);
+                        end = min(u->userspace_addr - 1 + u->size,
+                                  hva - 1 + len);
+                        l = end - start + 1;
+                        r = log_write(vq->log_base,
+                                      u->start + start - u->userspace_addr,
+                                      l);
+                        if (r < 0)
+                                return r;
+                        hit = true;
+                        min = min(l, min);
+                }
+
+                if (!hit)
+                        return -EFAULT;
+
+                len -= min;
+                hva += min;
+        }
+
+        return 0;
+}
+
+static int log_used(struct vhost_virtqueue *vq, u64 used_offset, u64 len)
+{
+        struct iovec iov[64];
+        int i, ret;
+
+        if (!vq->iotlb)
+                return log_write(vq->log_base, vq->log_addr + used_offset, len);
+
+        ret = translate_desc(vq, (uintptr_t)vq->used + used_offset,
+                             len, iov, 64, VHOST_ACCESS_WO);
+        if (ret)
+                return ret;
+
+        for (i = 0; i < ret; i++) {
+                ret = log_write_hva(vq, (uintptr_t)iov[i].iov_base,
+                                    iov[i].iov_len);
+                if (ret)
+                        return ret;
+        }
+
+        return 0;
+}
+
 int vhost_log_write(struct vhost_virtqueue *vq, struct vhost_log *log,
-                    unsigned int log_num, u64 len)
+                    unsigned int log_num, u64 len, struct iovec *iov, int count)
 {
         int i, r;
 
         /* Make sure data written is seen before log. */
         smp_wmb();
+
+        if (vq->iotlb) {
+                for (i = 0; i < count; i++) {
+                        r = log_write_hva(vq, (uintptr_t)iov[i].iov_base,
+                                          iov[i].iov_len);
+                        if (r < 0)
+                                return r;
+                }
+                return 0;
+        }
+
         for (i = 0; i < log_num; ++i) {
                 u64 l = min(log[i].len, len);
                 r = log_write(vq->log_base, log[i].addr, l);
@@ -1769,9 +1847,8 @@ static int vhost_update_used_flags(struct vhost_virtqueue *vq)
                 smp_wmb();
                 /* Log used flag write. */
                 used = &vq->used->flags;
-                log_write(vq->log_base, vq->log_addr +
-                          (used - (void __user *)vq->used),
-                          sizeof vq->used->flags);
+                log_used(vq, (used - (void __user *)vq->used),
+                         sizeof vq->used->flags);
                 if (vq->log_ctx)
                         eventfd_signal(vq->log_ctx, 1);
         }
@@ -1789,9 +1866,8 @@ static int vhost_update_avail_event(struct vhost_virtqueue *vq, u16 avail_event)
                 smp_wmb();
                 /* Log avail event write */
                 used = vhost_avail_event(vq);
-                log_write(vq->log_base, vq->log_addr +
-                          (used - (void __user *)vq->used),
-                          sizeof *vhost_avail_event(vq));
+                log_used(vq, (used - (void __user *)vq->used),
+                         sizeof *vhost_avail_event(vq));
                 if (vq->log_ctx)
                         eventfd_signal(vq->log_ctx, 1);
         }
@@ -2191,10 +2267,8 @@ static int __vhost_add_used_n(struct vhost_virtqueue *vq,
                 /* Make sure data is seen before log. */
                 smp_wmb();
                 /* Log used ring entry write. */
-                log_write(vq->log_base,
-                          vq->log_addr +
-                           ((void __user *)used - (void __user *)vq->used),
-                          count * sizeof *used);
+                log_used(vq, ((void __user *)used - (void __user *)vq->used),
+                         count * sizeof *used);
         }
         old = vq->last_used_idx;
         new = (vq->last_used_idx += count);
@@ -2236,9 +2310,8 @@ int vhost_add_used_n(struct vhost_virtqueue *vq, struct vring_used_elem *heads,
                 /* Make sure used idx is seen before log. */
                 smp_wmb();
                 /* Log used index update. */
-                log_write(vq->log_base,
-                          vq->log_addr + offsetof(struct vring_used, idx),
-                          sizeof vq->used->idx);
+                log_used(vq, offsetof(struct vring_used, idx),
+                         sizeof vq->used->idx);
                 if (vq->log_ctx)
                         eventfd_signal(vq->log_ctx, 1);
         }
diff --git a/drivers/vhost/vhost.h b/drivers/vhost/vhost.h
index 466ef7542291..1b675dad5e05 100644
--- a/drivers/vhost/vhost.h
+++ b/drivers/vhost/vhost.h
@@ -205,7 +205,8 @@ bool vhost_vq_avail_empty(struct vhost_dev *, struct vhost_virtqueue *);
 bool vhost_enable_notify(struct vhost_dev *, struct vhost_virtqueue *);
 
 int vhost_log_write(struct vhost_virtqueue *vq, struct vhost_log *log,
-                    unsigned int log_num, u64 len);
+                    unsigned int log_num, u64 len,
+                    struct iovec *iov, int count);
 int vq_iotlb_prefetch(struct vhost_virtqueue *vq);
 
 struct vhost_msg_node *vhost_new_msg(struct vhost_virtqueue *vq, int type);
diff --git a/drivers/vhost/vsock.c b/drivers/vhost/vsock.c
index bc42d38ae031..3fbc068eaa9b 100644
--- a/drivers/vhost/vsock.c
+++ b/drivers/vhost/vsock.c
@@ -642,7 +642,7 @@ static int vhost_vsock_set_cid(struct vhost_vsock *vsock, u64 guest_cid)
                 hash_del_rcu(&vsock->hash);
 
         vsock->guest_cid = guest_cid;
-        hash_add_rcu(vhost_vsock_hash, &vsock->hash, guest_cid);
+        hash_add_rcu(vhost_vsock_hash, &vsock->hash, vsock->guest_cid);
         mutex_unlock(&vhost_vsock_mutex);
 
         return 0;
diff --git a/drivers/video/backlight/88pm860x_bl.c b/drivers/video/backlight/88pm860x_bl.c
index 6d8dc2c77520..51e0c4be08df 100644
--- a/drivers/video/backlight/88pm860x_bl.c
+++ b/drivers/video/backlight/88pm860x_bl.c
@@ -174,7 +174,7 @@ static int pm860x_backlight_dt_init(struct platform_device *pdev,
                 return -ENODEV;
         }
         for_each_child_of_node(nproot, np) {
-                if (!of_node_cmp(np->name, name)) {
+                if (of_node_name_eq(np, name)) {
                         of_property_read_u32(np, "marvell,88pm860x-iset",
                                              &iset);
                         data->iset = PM8606_WLED_CURRENT(iset);
diff --git a/drivers/video/backlight/pwm_bl.c b/drivers/video/backlight/pwm_bl.c
index f9ef0673a083..feb90764a811 100644
--- a/drivers/video/backlight/pwm_bl.c
+++ b/drivers/video/backlight/pwm_bl.c
@@ -30,6 +30,7 @@ struct pwm_bl_data {
         struct device           *dev;
         unsigned int            lth_brightness;
         unsigned int            *levels;
+        bool                    enabled;
         struct regulator        *power_supply;
         struct gpio_desc        *enable_gpio;
         unsigned int            scale;
@@ -50,7 +51,7 @@ static void pwm_backlight_power_on(struct pwm_bl_data *pb)
         int err;
 
         pwm_get_state(pb->pwm, &state);
-        if (state.enabled)
+        if (pb->enabled)
                 return;
 
         err = regulator_enable(pb->power_supply);
@@ -65,6 +66,8 @@ static void pwm_backlight_power_on(struct pwm_bl_data *pb)
 
         if (pb->enable_gpio)
                 gpiod_set_value_cansleep(pb->enable_gpio, 1);
+
+        pb->enabled = true;
 }
 
 static void pwm_backlight_power_off(struct pwm_bl_data *pb)
@@ -72,7 +75,7 @@ static void pwm_backlight_power_off(struct pwm_bl_data *pb)
         struct pwm_state state;
 
         pwm_get_state(pb->pwm, &state);
-        if (!state.enabled)
+        if (!pb->enabled)
                 return;
 
         if (pb->enable_gpio)
@@ -86,6 +89,7 @@ static void pwm_backlight_power_off(struct pwm_bl_data *pb)
         pwm_apply_state(pb->pwm, &state);
 
         regulator_disable(pb->power_supply);
+        pb->enabled = false;
 }
 
 static int compute_duty_cycle(struct pwm_bl_data *pb, int brightness)
@@ -269,6 +273,16 @@ static int pwm_backlight_parse_dt(struct device *dev,
         memset(data, 0, sizeof(*data));
 
         /*
+         * These values are optional and set as 0 by default, the out values
+         * are modified only if a valid u32 value can be decoded.
+         */
+        of_property_read_u32(node, "post-pwm-on-delay-ms",
+                             &data->post_pwm_on_delay);
+        of_property_read_u32(node, "pwm-off-delay-ms", &data->pwm_off_delay);
+
+        data->enable_gpio = -EINVAL;
+
+        /*
          * Determine the number of brightness levels, if this property is not
          * set a default table of brightness levels will be used.
          */
@@ -380,15 +394,6 @@ static int pwm_backlight_parse_dt(struct device *dev,
                 data->max_brightness--;
         }
 
-        /*
-         * These values are optional and set as 0 by default, the out values
-         * are modified only if a valid u32 value can be decoded.
-         */
-        of_property_read_u32(node, "post-pwm-on-delay-ms",
-                             &data->post_pwm_on_delay);
-        of_property_read_u32(node, "pwm-off-delay-ms", &data->pwm_off_delay);
-
-        data->enable_gpio = -EINVAL;
         return 0;
 }
 
@@ -483,6 +488,7 @@ static int pwm_backlight_probe(struct platform_device *pdev)
         pb->check_fb = data->check_fb;
         pb->exit = data->exit;
         pb->dev = &pdev->dev;
+        pb->enabled = false;
         pb->post_pwm_on_delay = data->post_pwm_on_delay;
         pb->pwm_off_delay = data->pwm_off_delay;
 
diff --git a/drivers/video/console/vgacon.c b/drivers/video/console/vgacon.c
index 09731b2f6815..c6b3bdbbdbc9 100644
--- a/drivers/video/console/vgacon.c
+++ b/drivers/video/console/vgacon.c
@@ -271,6 +271,7 @@ static void vgacon_scrollback_update(struct vc_data *c, int t, int count)
 
 static void vgacon_restore_screen(struct vc_data *c)
 {
+        c->vc_origin = c->vc_visible_origin;
         vgacon_scrollback_cur->save = 0;
 
         if (!vga_is_gfx && !vgacon_scrollback_cur->restore) {
@@ -287,8 +288,7 @@ static void vgacon_scrolldelta(struct vc_data *c, int lines)
         int start, end, count, soff;
 
         if (!lines) {
-                c->vc_visible_origin = c->vc_origin;
-                vga_set_mem_top(c);
+                vgacon_restore_screen(c);
                 return;
         }
 
@@ -298,6 +298,7 @@ static void vgacon_scrolldelta(struct vc_data *c, int lines)
         if (!vgacon_scrollback_cur->save) {
                 vgacon_cursor(c, CM_ERASE);
                 vgacon_save_screen(c);
+                c->vc_origin = (unsigned long)c->vc_screenbuf;
                 vgacon_scrollback_cur->save = 1;
         }
 
@@ -335,7 +336,7 @@ static void vgacon_scrolldelta(struct vc_data *c, int lines)
                 int copysize;
 
                 int diff = c->vc_rows - count;
-                void *d = (void *) c->vc_origin;
+                void *d = (void *) c->vc_visible_origin;
                 void *s = (void *) c->vc_screenbuf;
 
                 count *= c->vc_size_row;
diff --git a/drivers/video/fbdev/core/fbcon.c b/drivers/video/fbdev/core/fbcon.c
index 8976190b6c1f..bfa1360ec750 100644
--- a/drivers/video/fbdev/core/fbcon.c
+++ b/drivers/video/fbdev/core/fbcon.c
@@ -510,6 +510,13 @@ static int __init fb_console_setup(char *this_opt)
                         continue;
                 }
 #endif
+
+                if (!strncmp(options, "logo-pos:", 9)) {
+                        options += 9;
+                        if (!strcmp(options, "center"))
+                                fb_center_logo = true;
+                        continue;
+                }
         }
         return 1;
 }
diff --git a/drivers/video/fbdev/core/fbmem.c b/drivers/video/fbdev/core/fbmem.c
index 558ed2ed3124..cb43a2258c51 100644
--- a/drivers/video/fbdev/core/fbmem.c
+++ b/drivers/video/fbdev/core/fbmem.c
@@ -53,6 +53,9 @@ EXPORT_SYMBOL(registered_fb);
 int num_registered_fb __read_mostly;
 EXPORT_SYMBOL(num_registered_fb);
 
+bool fb_center_logo __read_mostly;
+EXPORT_SYMBOL(fb_center_logo);
+
 static struct fb_info *get_fb_info(unsigned int idx)
 {
         struct fb_info *fb_info;
@@ -506,8 +509,7 @@ static int fb_show_logo_line(struct fb_info *info, int rotate,
                 fb_set_logo(info, logo, logo_new, fb_logo.depth);
         }
 
-#ifdef CONFIG_FB_LOGO_CENTER
-        {
+        if (fb_center_logo) {
                 int xres = info->var.xres;
                 int yres = info->var.yres;
 
@@ -520,11 +522,11 @@ static int fb_show_logo_line(struct fb_info *info, int rotate,
                         --n;
                 image.dx = (xres - n * (logo->width + 8) - 8) / 2;
                 image.dy = y ?: (yres - logo->height) / 2;
+        } else {
+                image.dx = 0;
+                image.dy = y;
         }
-#else
-        image.dx = 0;
-        image.dy = y;
-#endif
+
         image.width = logo->width;
         image.height = logo->height;
 
@@ -684,9 +686,8 @@ int fb_prepare_logo(struct fb_info *info, int rotate)
         }
 
         height = fb_logo.logo->height;
-#ifdef CONFIG_FB_LOGO_CENTER
-        height += (yres - fb_logo.logo->height) / 2;
-#endif
+        if (fb_center_logo)
+                height += (yres - fb_logo.logo->height) / 2;
 
         return fb_prepare_extra_logos(info, height, yres);
 }
diff --git a/drivers/video/fbdev/da8xx-fb.c b/drivers/video/fbdev/da8xx-fb.c
index a74096c53cb5..43f2a4816860 100644
--- a/drivers/video/fbdev/da8xx-fb.c
+++ b/drivers/video/fbdev/da8xx-fb.c
@@ -1446,9 +1446,9 @@ static int fb_probe(struct platform_device *device)
                 da8xx_fb_fix.line_length - 1;
 
         /* allocate palette buffer */
-        par->v_palette_base = dma_zalloc_coherent(NULL, PALETTE_SIZE,
-                                                  &par->p_palette_base,
-                                                  GFP_KERNEL | GFP_DMA);
+        par->v_palette_base = dma_alloc_coherent(NULL, PALETTE_SIZE,
+                                                 &par->p_palette_base,
+                                                 GFP_KERNEL | GFP_DMA);
         if (!par->v_palette_base) {
                 dev_err(&device->dev,
                         "GLCD: kmalloc for palette buffer failed\n");
diff --git a/drivers/video/fbdev/offb.c b/drivers/video/fbdev/offb.c
index 31f769d67195..057d3cdef92e 100644
--- a/drivers/video/fbdev/offb.c
+++ b/drivers/video/fbdev/offb.c
@@ -318,28 +318,28 @@ static void __iomem *offb_map_reg(struct device_node *np, int index,
 }
 
 static void offb_init_palette_hacks(struct fb_info *info, struct device_node *dp,
-                                    const char *name, unsigned long address)
+                                    unsigned long address)
 {
         struct offb_par *par = (struct offb_par *) info->par;
 
-        if (dp && !strncmp(name, "ATY,Rage128", 11)) {
+        if (of_node_name_prefix(dp, "ATY,Rage128")) {
                 par->cmap_adr = offb_map_reg(dp, 2, 0, 0x1fff);
                 if (par->cmap_adr)
                         par->cmap_type = cmap_r128;
-        } else if (dp && (!strncmp(name, "ATY,RageM3pA", 12)
-                          || !strncmp(name, "ATY,RageM3p12A", 14))) {
+        } else if (of_node_name_prefix(dp, "ATY,RageM3pA") ||
+                   of_node_name_prefix(dp, "ATY,RageM3p12A")) {
                 par->cmap_adr = offb_map_reg(dp, 2, 0, 0x1fff);
                 if (par->cmap_adr)
                         par->cmap_type = cmap_M3A;
-        } else if (dp && !strncmp(name, "ATY,RageM3pB", 12)) {
+        } else if (of_node_name_prefix(dp, "ATY,RageM3pB")) {
                 par->cmap_adr = offb_map_reg(dp, 2, 0, 0x1fff);
                 if (par->cmap_adr)
                         par->cmap_type = cmap_M3B;
-        } else if (dp && !strncmp(name, "ATY,Rage6", 9)) {
+        } else if (of_node_name_prefix(dp, "ATY,Rage6")) {
                 par->cmap_adr = offb_map_reg(dp, 1, 0, 0x1fff);
                 if (par->cmap_adr)
                         par->cmap_type = cmap_radeon;
-        } else if (!strncmp(name, "ATY,", 4)) {
+        } else if (of_node_name_prefix(dp, "ATY,")) {
                 unsigned long base = address & 0xff000000UL;
                 par->cmap_adr =
                         ioremap(base + 0x7ff000, 0x1000) + 0xcc0;
@@ -350,7 +350,7 @@ static void offb_init_palette_hacks(struct fb_info *info, struct device_node *dp
                 par->cmap_adr = offb_map_reg(dp, 0, 0x6000, 0x1000);
                 if (par->cmap_adr)
                         par->cmap_type = cmap_gxt2000;
-        } else if (dp && !strncmp(name, "vga,Display-", 12)) {
+        } else if (of_node_name_prefix(dp, "vga,Display-")) {
                 /* Look for AVIVO initialized by SLOF */
                 struct device_node *pciparent = of_get_parent(dp);
                 const u32 *vid, *did;
@@ -438,7 +438,7 @@ static void __init offb_init_fb(const char *name,
 
         par->cmap_type = cmap_unknown;
         if (depth == 8)
-                offb_init_palette_hacks(info, dp, name, address);
+                offb_init_palette_hacks(info, dp, address);
         else
                 fix->visual = FB_VISUAL_TRUECOLOR;
 
diff --git a/drivers/video/fbdev/omap2/omapfb/omapfb-ioctl.c b/drivers/video/fbdev/omap2/omapfb/omapfb-ioctl.c
index 53f93616c671..8e23160ec59f 100644
--- a/drivers/video/fbdev/omap2/omapfb/omapfb-ioctl.c
+++ b/drivers/video/fbdev/omap2/omapfb/omapfb-ioctl.c
@@ -609,6 +609,8 @@ int omapfb_ioctl(struct fb_info *fbi, unsigned int cmd, unsigned long arg)
 
         int r = 0;
 
+        memset(&p, 0, sizeof(p));
+
         switch (cmd) {
         case OMAPFB_SYNC_GFX:
                 DBG("ioctl SYNC_GFX\n");
diff --git a/drivers/video/logo/Kconfig b/drivers/video/logo/Kconfig
index 1e972c4e88b1..d1f6196c8b9a 100644
--- a/drivers/video/logo/Kconfig
+++ b/drivers/video/logo/Kconfig
@@ -10,15 +10,6 @@ menuconfig LOGO
 
 if LOGO
 
-config FB_LOGO_CENTER
-        bool "Center the logo"
-        depends on FB=y
-        help
-          When this option is selected, the bootup logo is centered both
-          horizontally and vertically. If more than one logo is displayed
-          due to multiple CPUs, the collected line of logos is centered
-          as a whole.
-
 config FB_LOGO_EXTRA
         bool
         depends on FB=y
diff --git a/drivers/virtio/virtio_balloon.c b/drivers/virtio/virtio_balloon.c
index 728ecd1eea30..fb12fe205f86 100644
--- a/drivers/virtio/virtio_balloon.c
+++ b/drivers/virtio/virtio_balloon.c
@@ -61,6 +61,10 @@ enum virtio_balloon_vq {
         VIRTIO_BALLOON_VQ_MAX
 };
 
+enum virtio_balloon_config_read {
+        VIRTIO_BALLOON_CONFIG_READ_CMD_ID = 0,
+};
+
 struct virtio_balloon {
         struct virtio_device *vdev;
         struct virtqueue *inflate_vq, *deflate_vq, *stats_vq, *free_page_vq;
@@ -77,14 +81,20 @@ struct virtio_balloon {
         /* Prevent updating balloon when it is being canceled. */
         spinlock_t stop_update_lock;
         bool stop_update;
+        /* Bitmap to indicate if reading the related config fields are needed */
+        unsigned long config_read_bitmap;
 
         /* The list of allocated free pages, waiting to be given back to mm */
         struct list_head free_page_list;
         spinlock_t free_page_list_lock;
         /* The number of free page blocks on the above list */
         unsigned long num_free_page_blocks;
-        /* The cmd id received from host */
-        u32 cmd_id_received;
+        /*
+         * The cmd id received from host.
+         * Read it via virtio_balloon_cmd_id_received to get the latest value
+         * sent from host.
+         */
+        u32 cmd_id_received_cache;
         /* The cmd id that is actively in use */
         __virtio32 cmd_id_active;
         /* Buffer to store the stop sign */
@@ -390,37 +400,31 @@ static unsigned long return_free_pages_to_mm(struct virtio_balloon *vb,
         return num_returned;
 }
 
+static void virtio_balloon_queue_free_page_work(struct virtio_balloon *vb)
+{
+        if (!virtio_has_feature(vb->vdev, VIRTIO_BALLOON_F_FREE_PAGE_HINT))
+                return;
+
+        /* No need to queue the work if the bit was already set. */
+        if (test_and_set_bit(VIRTIO_BALLOON_CONFIG_READ_CMD_ID,
+                             &vb->config_read_bitmap))
+                return;
+
+        queue_work(vb->balloon_wq, &vb->report_free_page_work);
+}
+
 static void virtballoon_changed(struct virtio_device *vdev)
 {
         struct virtio_balloon *vb = vdev->priv;
         unsigned long flags;
-        s64 diff = towards_target(vb);
-
-        if (diff) {
-                spin_lock_irqsave(&vb->stop_update_lock, flags);
-                if (!vb->stop_update)
-                        queue_work(system_freezable_wq,
-                                   &vb->update_balloon_size_work);
-                spin_unlock_irqrestore(&vb->stop_update_lock, flags);
-        }
 
-        if (virtio_has_feature(vdev, VIRTIO_BALLOON_F_FREE_PAGE_HINT)) {
-                virtio_cread(vdev, struct virtio_balloon_config,
-                             free_page_report_cmd_id, &vb->cmd_id_received);
-                if (vb->cmd_id_received == VIRTIO_BALLOON_CMD_ID_DONE) {
-                        /* Pass ULONG_MAX to give back all the free pages */
-                        return_free_pages_to_mm(vb, ULONG_MAX);
-                } else if (vb->cmd_id_received != VIRTIO_BALLOON_CMD_ID_STOP &&
-                           vb->cmd_id_received !=
-                           virtio32_to_cpu(vdev, vb->cmd_id_active)) {
-                        spin_lock_irqsave(&vb->stop_update_lock, flags);
-                        if (!vb->stop_update) {
-                                queue_work(vb->balloon_wq,
-                                           &vb->report_free_page_work);
-                        }
-                        spin_unlock_irqrestore(&vb->stop_update_lock, flags);
-                }
+        spin_lock_irqsave(&vb->stop_update_lock, flags);
+        if (!vb->stop_update) {
+                queue_work(system_freezable_wq,
+                           &vb->update_balloon_size_work);
+                virtio_balloon_queue_free_page_work(vb);
         }
+        spin_unlock_irqrestore(&vb->stop_update_lock, flags);
 }
 
 static void update_balloon_size(struct virtio_balloon *vb)
@@ -527,6 +531,17 @@ static int init_vqs(struct virtio_balloon *vb)
         return 0;
 }
 
+static u32 virtio_balloon_cmd_id_received(struct virtio_balloon *vb)
+{
+        if (test_and_clear_bit(VIRTIO_BALLOON_CONFIG_READ_CMD_ID,
+                               &vb->config_read_bitmap))
+                virtio_cread(vb->vdev, struct virtio_balloon_config,
+                             free_page_report_cmd_id,
+                             &vb->cmd_id_received_cache);
+
+        return vb->cmd_id_received_cache;
+}
+
 static int send_cmd_id_start(struct virtio_balloon *vb)
 {
         struct scatterlist sg;
@@ -537,7 +552,8 @@ static int send_cmd_id_start(struct virtio_balloon *vb)
         while (virtqueue_get_buf(vq, &unused))
                 ;
 
-        vb->cmd_id_active = cpu_to_virtio32(vb->vdev, vb->cmd_id_received);
+        vb->cmd_id_active = virtio32_to_cpu(vb->vdev,
+                                        virtio_balloon_cmd_id_received(vb));
         sg_init_one(&sg, &vb->cmd_id_active, sizeof(vb->cmd_id_active));
         err = virtqueue_add_outbuf(vq, &sg, 1, &vb->cmd_id_active, GFP_KERNEL);
         if (!err)
@@ -620,7 +636,8 @@ static int send_free_pages(struct virtio_balloon *vb)
                  * stop the reporting.
                  */
                 cmd_id_active = virtio32_to_cpu(vb->vdev, vb->cmd_id_active);
-                if (cmd_id_active != vb->cmd_id_received)
+                if (unlikely(cmd_id_active !=
+                             virtio_balloon_cmd_id_received(vb)))
                         break;
 
                 /*
@@ -637,11 +654,9 @@ static int send_free_pages(struct virtio_balloon *vb)
         return 0;
 }
 
-static void report_free_page_func(struct work_struct *work)
+static void virtio_balloon_report_free_page(struct virtio_balloon *vb)
 {
         int err;
-        struct virtio_balloon *vb = container_of(work, struct virtio_balloon,
-                                                 report_free_page_work);
         struct device *dev = &vb->vdev->dev;
 
         /* Start by sending the received cmd id to host with an outbuf. */
@@ -659,6 +674,23 @@ static void report_free_page_func(struct work_struct *work)
                 dev_err(dev, "Failed to send a stop id, err = %d\n", err);
 }
 
+static void report_free_page_func(struct work_struct *work)
+{
+        struct virtio_balloon *vb = container_of(work, struct virtio_balloon,
+                                                 report_free_page_work);
+        u32 cmd_id_received;
+
+        cmd_id_received = virtio_balloon_cmd_id_received(vb);
+        if (cmd_id_received == VIRTIO_BALLOON_CMD_ID_DONE) {
+                /* Pass ULONG_MAX to give back all the free pages */
+                return_free_pages_to_mm(vb, ULONG_MAX);
+        } else if (cmd_id_received != VIRTIO_BALLOON_CMD_ID_STOP &&
+                   cmd_id_received !=
+                   virtio32_to_cpu(vb->vdev, vb->cmd_id_active)) {
+                virtio_balloon_report_free_page(vb);
+        }
+}
+
 #ifdef CONFIG_BALLOON_COMPACTION
 /*
  * virtballoon_migratepage - perform the balloon page migration on behalf of
@@ -885,7 +917,7 @@ static int virtballoon_probe(struct virtio_device *vdev)
                         goto out_del_vqs;
                 }
                 INIT_WORK(&vb->report_free_page_work, report_free_page_func);
-                vb->cmd_id_received = VIRTIO_BALLOON_CMD_ID_STOP;
+                vb->cmd_id_received_cache = VIRTIO_BALLOON_CMD_ID_STOP;
                 vb->cmd_id_active = cpu_to_virtio32(vb->vdev,
                                                   VIRTIO_BALLOON_CMD_ID_STOP);
                 vb->cmd_id_stop = cpu_to_virtio32(vb->vdev,
diff --git a/drivers/virtio/virtio_mmio.c b/drivers/virtio/virtio_mmio.c
index 4cd9ea5c75be..d9dd0f789279 100644
--- a/drivers/virtio/virtio_mmio.c
+++ b/drivers/virtio/virtio_mmio.c
@@ -468,7 +468,7 @@ static int vm_find_vqs(struct virtio_device *vdev, unsigned nvqs,
 {
         struct virtio_mmio_device *vm_dev = to_virtio_mmio_device(vdev);
         unsigned int irq = platform_get_irq(vm_dev->pdev, 0);
-        int i, err;
+        int i, err, queue_idx = 0;
 
         err = request_irq(irq, vm_interrupt, IRQF_SHARED,
                         dev_name(&vdev->dev), vm_dev);
@@ -476,7 +476,12 @@ static int vm_find_vqs(struct virtio_device *vdev, unsigned nvqs,
                 return err;
 
         for (i = 0; i < nvqs; ++i) {
-                vqs[i] = vm_setup_vq(vdev, i, callbacks[i], names[i],
+                if (!names[i]) {
+                        vqs[i] = NULL;
+                        continue;
+                }
+
+                vqs[i] = vm_setup_vq(vdev, queue_idx++, callbacks[i], names[i],
                                      ctx ? ctx[i] : false);
                 if (IS_ERR(vqs[i])) {
                         vm_del_vqs(vdev);
diff --git a/drivers/virtio/virtio_pci_common.c b/drivers/virtio/virtio_pci_common.c
index 465a6f5142cc..d0584c040c60 100644
--- a/drivers/virtio/virtio_pci_common.c
+++ b/drivers/virtio/virtio_pci_common.c
@@ -285,7 +285,7 @@ static int vp_find_vqs_msix(struct virtio_device *vdev, unsigned nvqs,
 {
         struct virtio_pci_device *vp_dev = to_vp_device(vdev);
         u16 msix_vec;
-        int i, err, nvectors, allocated_vectors;
+        int i, err, nvectors, allocated_vectors, queue_idx = 0;
 
         vp_dev->vqs = kcalloc(nvqs, sizeof(*vp_dev->vqs), GFP_KERNEL);
         if (!vp_dev->vqs)
@@ -321,7 +321,7 @@ static int vp_find_vqs_msix(struct virtio_device *vdev, unsigned nvqs,
                         msix_vec = allocated_vectors++;
                 else
                         msix_vec = VP_MSIX_VQ_VECTOR;
-                vqs[i] = vp_setup_vq(vdev, i, callbacks[i], names[i],
+                vqs[i] = vp_setup_vq(vdev, queue_idx++, callbacks[i], names[i],
                                      ctx ? ctx[i] : false,
                                      msix_vec);
                 if (IS_ERR(vqs[i])) {
@@ -356,7 +356,7 @@ static int vp_find_vqs_intx(struct virtio_device *vdev, unsigned nvqs,
                 const char * const names[], const bool *ctx)
 {
         struct virtio_pci_device *vp_dev = to_vp_device(vdev);
-        int i, err;
+        int i, err, queue_idx = 0;
 
         vp_dev->vqs = kcalloc(nvqs, sizeof(*vp_dev->vqs), GFP_KERNEL);
         if (!vp_dev->vqs)
@@ -374,7 +374,7 @@ static int vp_find_vqs_intx(struct virtio_device *vdev, unsigned nvqs,
                         vqs[i] = NULL;
                         continue;
                 }
-                vqs[i] = vp_setup_vq(vdev, i, callbacks[i], names[i],
+                vqs[i] = vp_setup_vq(vdev, queue_idx++, callbacks[i], names[i],
                                      ctx ? ctx[i] : false,
                                      VIRTIO_MSI_NO_VECTOR);
                 if (IS_ERR(vqs[i])) {
diff --git a/drivers/watchdog/mt7621_wdt.c b/drivers/watchdog/mt7621_wdt.c
index 5c4a764717c4..81208cd3f4ec 100644
--- a/drivers/watchdog/mt7621_wdt.c
+++ b/drivers/watchdog/mt7621_wdt.c
@@ -17,6 +17,7 @@
 #include <linux/watchdog.h>
 #include <linux/moduleparam.h>
 #include <linux/platform_device.h>
+#include <linux/mod_devicetable.h>
 
 #include <asm/mach-ralink/ralink_regs.h>
 
diff --git a/drivers/watchdog/rt2880_wdt.c b/drivers/watchdog/rt2880_wdt.c
index 98967f0a7d10..db7c57d82cfd 100644
--- a/drivers/watchdog/rt2880_wdt.c
+++ b/drivers/watchdog/rt2880_wdt.c
@@ -18,6 +18,7 @@
 #include <linux/watchdog.h>
 #include <linux/moduleparam.h>
 #include <linux/platform_device.h>
+#include <linux/mod_devicetable.h>
 
 #include <asm/mach-ralink/ralink_regs.h>
 
diff --git a/drivers/watchdog/tqmx86_wdt.c b/drivers/watchdog/tqmx86_wdt.c
index 0d3a0fbbd7a5..52941207a12a 100644
--- a/drivers/watchdog/tqmx86_wdt.c
+++ b/drivers/watchdog/tqmx86_wdt.c
@@ -79,13 +79,13 @@ static int tqmx86_wdt_probe(struct platform_device *pdev)
                 return -ENOMEM;
 
         res = platform_get_resource(pdev, IORESOURCE_IO, 0);
-        if (IS_ERR(res))
-                return PTR_ERR(res);
+        if (!res)
+                return -ENODEV;
 
         priv->io_base = devm_ioport_map(&pdev->dev, res->start,
                                         resource_size(res));
-        if (IS_ERR(priv->io_base))
-                return PTR_ERR(priv->io_base);
+        if (!priv->io_base)
+                return -ENOMEM;
 
         watchdog_set_drvdata(&priv->wdd, priv);
 
diff --git a/drivers/xen/events/events_base.c b/drivers/xen/events/events_base.c
index 93194f3e7540..117e76b2f939 100644
--- a/drivers/xen/events/events_base.c
+++ b/drivers/xen/events/events_base.c
@@ -1650,7 +1650,7 @@ void xen_callback_vector(void)
                         xen_have_vector_callback = 0;
                         return;
                 }
-                pr_info("Xen HVM callback vector for event delivery is enabled\n");
+                pr_info_once("Xen HVM callback vector for event delivery is enabled\n");
                 alloc_intr_gate(HYPERVISOR_CALLBACK_VECTOR,
                                 xen_hvm_callback_vector);
         }
diff --git a/drivers/xen/pvcalls-back.c b/drivers/xen/pvcalls-back.c
index 2e5d845b5091..7aa64d1b119c 100644
--- a/drivers/xen/pvcalls-back.c
+++ b/drivers/xen/pvcalls-back.c
@@ -160,9 +160,10 @@ static void pvcalls_conn_back_read(void *opaque)
 
         /* write the data, then modify the indexes */
         virt_wmb();
-        if (ret < 0)
+        if (ret < 0) {
+                atomic_set(&map->read, 0);
                 intf->in_error = ret;
-        else
+        } else
                 intf->in_prod = prod + ret;
         /* update the indexes, then notify the other end */
         virt_wmb();
@@ -282,13 +283,11 @@ static int pvcalls_back_socket(struct xenbus_device *dev,
 static void pvcalls_sk_state_change(struct sock *sock)
 {
         struct sock_mapping *map = sock->sk_user_data;
-        struct pvcalls_data_intf *intf;
 
         if (map == NULL)
                 return;
 
-        intf = map->ring;
-        intf->in_error = -ENOTCONN;
+        atomic_inc(&map->read);
         notify_remote_via_irq(map->irq);
 }
 
diff --git a/drivers/xen/pvcalls-front.c b/drivers/xen/pvcalls-front.c
index 77224d8f3e6f..8a249c95c193 100644
--- a/drivers/xen/pvcalls-front.c
+++ b/drivers/xen/pvcalls-front.c
@@ -31,6 +31,12 @@
 #define PVCALLS_NR_RSP_PER_RING __CONST_RING_SIZE(xen_pvcalls, XEN_PAGE_SIZE)
 #define PVCALLS_FRONT_MAX_SPIN 5000
 
+static struct proto pvcalls_proto = {
+        .name   = "PVCalls",
+        .owner  = THIS_MODULE,
+        .obj_size = sizeof(struct sock),
+};
+
 struct pvcalls_bedata {
         struct xen_pvcalls_front_ring ring;
         grant_ref_t ref;
@@ -335,6 +341,42 @@ int pvcalls_front_socket(struct socket *sock)
         return ret;
 }
 
+static void free_active_ring(struct sock_mapping *map)
+{
+        if (!map->active.ring)
+                return;
+
+        free_pages((unsigned long)map->active.data.in,
+                        map->active.ring->ring_order);
+        free_page((unsigned long)map->active.ring);
+}
+
+static int alloc_active_ring(struct sock_mapping *map)
+{
+        void *bytes;
+
+        map->active.ring = (struct pvcalls_data_intf *)
+                get_zeroed_page(GFP_KERNEL);
+        if (!map->active.ring)
+                goto out;
+
+        map->active.ring->ring_order = PVCALLS_RING_ORDER;
+        bytes = (void *)__get_free_pages(GFP_KERNEL | __GFP_ZERO,
+                                        PVCALLS_RING_ORDER);
+        if (!bytes)
+                goto out;
+
+        map->active.data.in = bytes;
+        map->active.data.out = bytes +
+                XEN_FLEX_RING_SIZE(PVCALLS_RING_ORDER);
+
+        return 0;
+
+out:
+        free_active_ring(map);
+        return -ENOMEM;
+}
+
 static int create_active(struct sock_mapping *map, int *evtchn)
 {
         void *bytes;
@@ -343,15 +385,7 @@ static int create_active(struct sock_mapping *map, int *evtchn)
         *evtchn = -1;
         init_waitqueue_head(&map->active.inflight_conn_req);
 
-        map->active.ring = (struct pvcalls_data_intf *)
-                __get_free_page(GFP_KERNEL | __GFP_ZERO);
-        if (map->active.ring == NULL)
-                goto out_error;
-        map->active.ring->ring_order = PVCALLS_RING_ORDER;
-        bytes = (void *)__get_free_pages(GFP_KERNEL | __GFP_ZERO,
-                                        PVCALLS_RING_ORDER);
-        if (bytes == NULL)
-                goto out_error;
+        bytes = map->active.data.in;
         for (i = 0; i < (1 << PVCALLS_RING_ORDER); i++)
                 map->active.ring->ref[i] = gnttab_grant_foreign_access(
                         pvcalls_front_dev->otherend_id,
@@ -361,10 +395,6 @@ static int create_active(struct sock_mapping *map, int *evtchn)
                 pvcalls_front_dev->otherend_id,
                 pfn_to_gfn(virt_to_pfn((void *)map->active.ring)), 0);
 
-        map->active.data.in = bytes;
-        map->active.data.out = bytes +
-                XEN_FLEX_RING_SIZE(PVCALLS_RING_ORDER);
-
         ret = xenbus_alloc_evtchn(pvcalls_front_dev, evtchn);
         if (ret)
                 goto out_error;
@@ -385,8 +415,6 @@ static int create_active(struct sock_mapping *map, int *evtchn)
 out_error:
         if (*evtchn >= 0)
                 xenbus_free_evtchn(pvcalls_front_dev, *evtchn);
-        free_pages((unsigned long)map->active.data.in, PVCALLS_RING_ORDER);
-        free_page((unsigned long)map->active.ring);
         return ret;
 }
 
@@ -406,17 +434,24 @@ int pvcalls_front_connect(struct socket *sock, struct sockaddr *addr,
                 return PTR_ERR(map);
 
         bedata = dev_get_drvdata(&pvcalls_front_dev->dev);
+        ret = alloc_active_ring(map);
+        if (ret < 0) {
+                pvcalls_exit_sock(sock);
+                return ret;
+        }
 
         spin_lock(&bedata->socket_lock);
         ret = get_request(bedata, &req_id);
         if (ret < 0) {
                 spin_unlock(&bedata->socket_lock);
+                free_active_ring(map);
                 pvcalls_exit_sock(sock);
                 return ret;
         }
         ret = create_active(map, &evtchn);
         if (ret < 0) {
                 spin_unlock(&bedata->socket_lock);
+                free_active_ring(map);
                 pvcalls_exit_sock(sock);
                 return ret;
         }
@@ -469,8 +504,10 @@ static int __write_ring(struct pvcalls_data_intf *intf,
         virt_mb();
 
         size = pvcalls_queued(prod, cons, array_size);
-        if (size >= array_size)
+        if (size > array_size)
                 return -EINVAL;
+        if (size == array_size)
+                return 0;
         if (len > array_size - size)
                 len = array_size - size;
 
@@ -560,15 +597,13 @@ static int __read_ring(struct pvcalls_data_intf *intf,
         error = intf->in_error;
         /* get pointers before reading from the ring */
         virt_rmb();
-        if (error < 0)
-                return error;
 
         size = pvcalls_queued(prod, cons, array_size);
         masked_prod = pvcalls_mask(prod, array_size);
         masked_cons = pvcalls_mask(cons, array_size);
 
         if (size == 0)
-                return 0;
+                return error ?: size;
 
         if (len > size)
                 len = size;
@@ -780,25 +815,36 @@ int pvcalls_front_accept(struct socket *sock, struct socket *newsock, int flags)
                 }
         }
 
-        spin_lock(&bedata->socket_lock);
-        ret = get_request(bedata, &req_id);
-        if (ret < 0) {
+        map2 = kzalloc(sizeof(*map2), GFP_KERNEL);
+        if (map2 == NULL) {
                 clear_bit(PVCALLS_FLAG_ACCEPT_INFLIGHT,
                           (void *)&map->passive.flags);
-                spin_unlock(&bedata->socket_lock);
+                pvcalls_exit_sock(sock);
+                return -ENOMEM;
+        }
+        ret = alloc_active_ring(map2);
+        if (ret < 0) {
+                clear_bit(PVCALLS_FLAG_ACCEPT_INFLIGHT,
+                                (void *)&map->passive.flags);
+                kfree(map2);
                 pvcalls_exit_sock(sock);
                 return ret;
         }
-        map2 = kzalloc(sizeof(*map2), GFP_ATOMIC);
-        if (map2 == NULL) {
+        spin_lock(&bedata->socket_lock);
+        ret = get_request(bedata, &req_id);
+        if (ret < 0) {
                 clear_bit(PVCALLS_FLAG_ACCEPT_INFLIGHT,
                           (void *)&map->passive.flags);
                 spin_unlock(&bedata->socket_lock);
+                free_active_ring(map2);
+                kfree(map2);
                 pvcalls_exit_sock(sock);
-                return -ENOMEM;
+                return ret;
         }
+
         ret = create_active(map2, &evtchn);
         if (ret < 0) {
+                free_active_ring(map2);
                 kfree(map2);
                 clear_bit(PVCALLS_FLAG_ACCEPT_INFLIGHT,
                           (void *)&map->passive.flags);
@@ -839,7 +885,7 @@ int pvcalls_front_accept(struct socket *sock, struct socket *newsock, int flags)
 
 received:
         map2->sock = newsock;
-        newsock->sk = kzalloc(sizeof(*newsock->sk), GFP_KERNEL);
+        newsock->sk = sk_alloc(sock_net(sock->sk), PF_INET, GFP_KERNEL, &pvcalls_proto, false);
         if (!newsock->sk) {
                 bedata->rsp[req_id].req_id = PVCALLS_INVALID_ID;
                 map->passive.inflight_req_id = PVCALLS_INVALID_ID;
@@ -1032,8 +1078,8 @@ int pvcalls_front_release(struct socket *sock)
                 spin_lock(&bedata->socket_lock);
                 list_del(&map->list);
                 spin_unlock(&bedata->socket_lock);
-                if (READ_ONCE(map->passive.inflight_req_id) !=
-                    PVCALLS_INVALID_ID) {
+                if (READ_ONCE(map->passive.inflight_req_id) != PVCALLS_INVALID_ID &&
+                        READ_ONCE(map->passive.inflight_req_id) != 0) {
                         pvcalls_front_free_map(bedata,
                                                map->passive.accept_map);
                 }
diff --git a/drivers/xen/swiotlb-xen.c b/drivers/xen/swiotlb-xen.c
index 989cf872b98c..bb7888429be6 100644
--- a/drivers/xen/swiotlb-xen.c
+++ b/drivers/xen/swiotlb-xen.c
@@ -645,7 +645,7 @@ xen_swiotlb_dma_mmap(struct device *dev, struct vm_area_struct *vma,
                      void *cpu_addr, dma_addr_t dma_addr, size_t size,
                      unsigned long attrs)
 {
-#if defined(CONFIG_ARM) || defined(CONFIG_ARM64)
+#ifdef CONFIG_ARM
         if (xen_get_dma_ops(dev)->mmap)
                 return xen_get_dma_ops(dev)->mmap(dev, vma, cpu_addr,
                                                     dma_addr, size, attrs);
@@ -662,7 +662,7 @@ xen_swiotlb_get_sgtable(struct device *dev, struct sg_table *sgt,
                         void *cpu_addr, dma_addr_t handle, size_t size,
                         unsigned long attrs)
 {
-#if defined(CONFIG_ARM) || defined(CONFIG_ARM64)
+#ifdef CONFIG_ARM
         if (xen_get_dma_ops(dev)->get_sgtable) {
 #if 0
         /*