615 files changed, 7715 insertions, 3742 deletions

diff --git a/drivers/acpi/acpi_processor.c b/drivers/acpi/acpi_processor.c
index b5e54f2da53d..0d92d0f915e9 100644
--- a/drivers/acpi/acpi_processor.c
+++ b/drivers/acpi/acpi_processor.c
@@ -491,6 +491,58 @@ static void acpi_processor_remove(struct acpi_device *device)
 }
 #endif /* CONFIG_ACPI_HOTPLUG_CPU */
 
+#ifdef CONFIG_X86
+static bool acpi_hwp_native_thermal_lvt_set;
+static acpi_status __init acpi_hwp_native_thermal_lvt_osc(acpi_handle handle,
+                                                          u32 lvl,
+                                                          void *context,
+                                                          void **rv)
+{
+        u8 sb_uuid_str[] = "4077A616-290C-47BE-9EBD-D87058713953";
+        u32 capbuf[2];
+        struct acpi_osc_context osc_context = {
+                .uuid_str = sb_uuid_str,
+                .rev = 1,
+                .cap.length = 8,
+                .cap.pointer = capbuf,
+        };
+
+        if (acpi_hwp_native_thermal_lvt_set)
+                return AE_CTRL_TERMINATE;
+
+        capbuf[0] = 0x0000;
+        capbuf[1] = 0x1000; /* set bit 12 */
+
+        if (ACPI_SUCCESS(acpi_run_osc(handle, &osc_context))) {
+                if (osc_context.ret.pointer && osc_context.ret.length > 1) {
+                        u32 *capbuf_ret = osc_context.ret.pointer;
+
+                        if (capbuf_ret[1] & 0x1000) {
+                                acpi_handle_info(handle,
+                                        "_OSC native thermal LVT Acked\n");
+                                acpi_hwp_native_thermal_lvt_set = true;
+                        }
+                }
+                kfree(osc_context.ret.pointer);
+        }
+
+        return AE_OK;
+}
+
+void __init acpi_early_processor_osc(void)
+{
+        if (boot_cpu_has(X86_FEATURE_HWP)) {
+                acpi_walk_namespace(ACPI_TYPE_PROCESSOR, ACPI_ROOT_OBJECT,
+                                    ACPI_UINT32_MAX,
+                                    acpi_hwp_native_thermal_lvt_osc,
+                                    NULL, NULL, NULL);
+                acpi_get_devices(ACPI_PROCESSOR_DEVICE_HID,
+                                 acpi_hwp_native_thermal_lvt_osc,
+                                 NULL, NULL);
+        }
+}
+#endif
+
 /*
  * The following ACPI IDs are known to be suitable for representing as
  * processor devices.
diff --git a/drivers/acpi/acpica/dsmethod.c b/drivers/acpi/acpica/dsmethod.c
index 1982310e6d83..da198b864107 100644
--- a/drivers/acpi/acpica/dsmethod.c
+++ b/drivers/acpi/acpica/dsmethod.c
@@ -428,6 +428,9 @@ acpi_ds_begin_method_execution(struct acpi_namespace_node *method_node,
                                 obj_desc->method.mutex->mutex.
                                     original_sync_level =
                                     obj_desc->method.mutex->mutex.sync_level;
+
+                                obj_desc->method.mutex->mutex.thread_id =
+                                    acpi_os_get_thread_id();
                         }
                 }
 
diff --git a/drivers/acpi/bus.c b/drivers/acpi/bus.c
index 0e8567846f1a..c068c829b453 100644
--- a/drivers/acpi/bus.c
+++ b/drivers/acpi/bus.c
@@ -1019,6 +1019,9 @@ static int __init acpi_bus_init(void)
                 goto error1;
         }
 
+        /* Set capability bits for _OSC under processor scope */
+        acpi_early_processor_osc();
+
         /*
          * _OSC method may exist in module level code,
          * so it must be run after ACPI_FULL_INITIALIZATION
diff --git a/drivers/acpi/internal.h b/drivers/acpi/internal.h
index a37508ef66c1..7c188472d9c2 100644
--- a/drivers/acpi/internal.h
+++ b/drivers/acpi/internal.h
@@ -145,6 +145,12 @@ void acpi_early_processor_set_pdc(void);
 static inline void acpi_early_processor_set_pdc(void) {}
 #endif
 
+#ifdef CONFIG_X86
+void acpi_early_processor_osc(void);
+#else
+static inline void acpi_early_processor_osc(void) {}
+#endif
+
 /* --------------------------------------------------------------------------
                                   Embedded Controller
    -------------------------------------------------------------------------- */
diff --git a/drivers/acpi/nfit.c b/drivers/acpi/nfit.c
index d0f35e63640b..63cc9dbe4f3b 100644
--- a/drivers/acpi/nfit.c
+++ b/drivers/acpi/nfit.c
@@ -287,8 +287,11 @@ static int acpi_nfit_ctl(struct nvdimm_bus_descriptor *nd_desc,
                                         offset);
                         rc = -ENXIO;
                 }
-        } else
+        } else {
                 rc = 0;
+                if (cmd_rc)
+                        *cmd_rc = xlat_status(buf, cmd);
+        }
 
  out:
         ACPI_FREE(out_obj);
diff --git a/drivers/ata/Kconfig b/drivers/ata/Kconfig
index 5083f85efea7..cfa936a32513 100644
--- a/drivers/ata/Kconfig
+++ b/drivers/ata/Kconfig
@@ -202,6 +202,14 @@ config SATA_FSL
 
           If unsure, say N.
 
+config SATA_AHCI_SEATTLE
+        tristate "AMD Seattle 6.0Gbps AHCI SATA host controller support"
+        depends on ARCH_SEATTLE
+        help
+         This option enables support for AMD Seattle SATA host controller.
+
+         If unsure, say N
+
 config SATA_INIC162X
         tristate "Initio 162x SATA support (Very Experimental)"
         depends on PCI
diff --git a/drivers/ata/Makefile b/drivers/ata/Makefile
index 18579521464e..0b2afb7e5f35 100644
--- a/drivers/ata/Makefile
+++ b/drivers/ata/Makefile
@@ -4,6 +4,7 @@ obj-$(CONFIG_ATA)		+= libata.o
 # non-SFF interface
 obj-$(CONFIG_SATA_AHCI)         += ahci.o libahci.o
 obj-$(CONFIG_SATA_ACARD_AHCI)   += acard-ahci.o libahci.o
+obj-$(CONFIG_SATA_AHCI_SEATTLE) += ahci_seattle.o libahci.o libahci_platform.o
 obj-$(CONFIG_SATA_AHCI_PLATFORM) += ahci_platform.o libahci.o libahci_platform.o
 obj-$(CONFIG_SATA_FSL)          += sata_fsl.o
 obj-$(CONFIG_SATA_INIC162X)     += sata_inic162x.o
diff --git a/drivers/ata/ahci_platform.c b/drivers/ata/ahci_platform.c
index 40442332bfa7..62a04c8fb5c9 100644
--- a/drivers/ata/ahci_platform.c
+++ b/drivers/ata/ahci_platform.c
@@ -51,6 +51,9 @@ static int ahci_probe(struct platform_device *pdev)
         if (rc)
                 return rc;
 
+        of_property_read_u32(dev->of_node,
+                             "ports-implemented", &hpriv->force_port_map);
+
         if (of_device_is_compatible(dev->of_node, "hisilicon,hisi-ahci"))
                 hpriv->flags |= AHCI_HFLAG_NO_FBS | AHCI_HFLAG_NO_NCQ;
 
diff --git a/drivers/ata/ahci_seattle.c b/drivers/ata/ahci_seattle.c
new file mode 100644
index 000000000000..6e702ab57220
--- /dev/null
+++ b/drivers/ata/ahci_seattle.c
@@ -0,0 +1,210 @@
+/*
+ * AMD Seattle AHCI SATA driver
+ *
+ * Copyright (c) 2015, Advanced Micro Devices
+ * Author: Brijesh Singh <brijesh.singh@amd.com>
+ *
+ * based on the AHCI SATA platform driver by Jeff Garzik and Anton Vorontsov
+ *
+ * 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.
+ *
+ * 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.
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/pm.h>
+#include <linux/device.h>
+#include <linux/of_device.h>
+#include <linux/platform_device.h>
+#include <linux/libata.h>
+#include <linux/ahci_platform.h>
+#include <linux/acpi.h>
+#include <linux/pci_ids.h>
+#include "ahci.h"
+
+/* SGPIO Control Register definition
+ *
+ * Bit          Type            Description
+ * 31           RW              OD7.2 (activity)
+ * 30           RW              OD7.1 (locate)
+ * 29           RW              OD7.0 (fault)
+ * 28...8       RW              OD6.2...OD0.0 (3bits per port, 1 bit per LED)
+ * 7            RO              SGPIO feature flag
+ * 6:4          RO              Reserved
+ * 3:0          RO              Number of ports (0 means no port supported)
+ */
+#define ACTIVITY_BIT_POS(x)             (8 + (3 * x))
+#define LOCATE_BIT_POS(x)               (ACTIVITY_BIT_POS(x) + 1)
+#define FAULT_BIT_POS(x)                (LOCATE_BIT_POS(x) + 1)
+
+#define ACTIVITY_MASK                   0x00010000
+#define LOCATE_MASK                     0x00080000
+#define FAULT_MASK                      0x00400000
+
+#define DRV_NAME "ahci-seattle"
+
+static ssize_t seattle_transmit_led_message(struct ata_port *ap, u32 state,
+                                            ssize_t size);
+
+struct seattle_plat_data {
+        void __iomem *sgpio_ctrl;
+};
+
+static struct ata_port_operations ahci_port_ops = {
+        .inherits               = &ahci_ops,
+};
+
+static const struct ata_port_info ahci_port_info = {
+        .flags          = AHCI_FLAG_COMMON,
+        .pio_mask       = ATA_PIO4,
+        .udma_mask      = ATA_UDMA6,
+        .port_ops       = &ahci_port_ops,
+};
+
+static struct ata_port_operations ahci_seattle_ops = {
+        .inherits               = &ahci_ops,
+        .transmit_led_message   = seattle_transmit_led_message,
+};
+
+static const struct ata_port_info ahci_port_seattle_info = {
+        .flags          = AHCI_FLAG_COMMON | ATA_FLAG_EM | ATA_FLAG_SW_ACTIVITY,
+        .link_flags     = ATA_LFLAG_SW_ACTIVITY,
+        .pio_mask       = ATA_PIO4,
+        .udma_mask      = ATA_UDMA6,
+        .port_ops       = &ahci_seattle_ops,
+};
+
+static struct scsi_host_template ahci_platform_sht = {
+        AHCI_SHT(DRV_NAME),
+};
+
+static ssize_t seattle_transmit_led_message(struct ata_port *ap, u32 state,
+                                            ssize_t size)
+{
+        struct ahci_host_priv *hpriv = ap->host->private_data;
+        struct ahci_port_priv *pp = ap->private_data;
+        struct seattle_plat_data *plat_data = hpriv->plat_data;
+        unsigned long flags;
+        int pmp;
+        struct ahci_em_priv *emp;
+        u32 val;
+
+        /* get the slot number from the message */
+        pmp = (state & EM_MSG_LED_PMP_SLOT) >> 8;
+        if (pmp >= EM_MAX_SLOTS)
+                return -EINVAL;
+        emp = &pp->em_priv[pmp];
+
+        val = ioread32(plat_data->sgpio_ctrl);
+        if (state & ACTIVITY_MASK)
+                val |= 1 << ACTIVITY_BIT_POS((ap->port_no));
+        else
+                val &= ~(1 << ACTIVITY_BIT_POS((ap->port_no)));
+
+        if (state & LOCATE_MASK)
+                val |= 1 << LOCATE_BIT_POS((ap->port_no));
+        else
+                val &= ~(1 << LOCATE_BIT_POS((ap->port_no)));
+
+        if (state & FAULT_MASK)
+                val |= 1 << FAULT_BIT_POS((ap->port_no));
+        else
+                val &= ~(1 << FAULT_BIT_POS((ap->port_no)));
+
+        iowrite32(val, plat_data->sgpio_ctrl);
+
+        spin_lock_irqsave(ap->lock, flags);
+
+        /* save off new led state for port/slot */
+        emp->led_state = state;
+
+        spin_unlock_irqrestore(ap->lock, flags);
+
+        return size;
+}
+
+static const struct ata_port_info *ahci_seattle_get_port_info(
+                struct platform_device *pdev, struct ahci_host_priv *hpriv)
+{
+        struct device *dev = &pdev->dev;
+        struct seattle_plat_data *plat_data;
+        u32 val;
+
+        plat_data = devm_kzalloc(dev, sizeof(*plat_data), GFP_KERNEL);
+        if (IS_ERR(plat_data))
+                return &ahci_port_info;
+
+        plat_data->sgpio_ctrl = devm_ioremap_resource(dev,
+                              platform_get_resource(pdev, IORESOURCE_MEM, 1));
+        if (IS_ERR(plat_data->sgpio_ctrl))
+                return &ahci_port_info;
+
+        val = ioread32(plat_data->sgpio_ctrl);
+
+        if (!(val & 0xf))
+                return &ahci_port_info;
+
+        hpriv->em_loc = 0;
+        hpriv->em_buf_sz = 4;
+        hpriv->em_msg_type = EM_MSG_TYPE_LED;
+        hpriv->plat_data = plat_data;
+
+        dev_info(dev, "SGPIO LED control is enabled.\n");
+        return &ahci_port_seattle_info;
+}
+
+static int ahci_seattle_probe(struct platform_device *pdev)
+{
+        int rc;
+        struct ahci_host_priv *hpriv;
+
+        hpriv = ahci_platform_get_resources(pdev);
+        if (IS_ERR(hpriv))
+                return PTR_ERR(hpriv);
+
+        rc = ahci_platform_enable_resources(hpriv);
+        if (rc)
+                return rc;
+
+        rc = ahci_platform_init_host(pdev, hpriv,
+                                     ahci_seattle_get_port_info(pdev, hpriv),
+                                     &ahci_platform_sht);
+        if (rc)
+                goto disable_resources;
+
+        return 0;
+disable_resources:
+        ahci_platform_disable_resources(hpriv);
+        return rc;
+}
+
+static SIMPLE_DEV_PM_OPS(ahci_pm_ops, ahci_platform_suspend,
+                         ahci_platform_resume);
+
+static const struct acpi_device_id ahci_acpi_match[] = {
+        { "AMDI0600", 0 },
+        {}
+};
+MODULE_DEVICE_TABLE(acpi, ahci_acpi_match);
+
+static struct platform_driver ahci_seattle_driver = {
+        .probe = ahci_seattle_probe,
+        .remove = ata_platform_remove_one,
+        .driver = {
+                .name = DRV_NAME,
+                .acpi_match_table = ahci_acpi_match,
+                .pm = &ahci_pm_ops,
+        },
+};
+module_platform_driver(ahci_seattle_driver);
+
+MODULE_DESCRIPTION("Seattle AHCI SATA platform driver");
+MODULE_AUTHOR("Brijesh Singh <brijesh.singh@amd.com>");
+MODULE_LICENSE("GPL");
+MODULE_ALIAS("platform:" DRV_NAME);
diff --git a/drivers/ata/libahci.c b/drivers/ata/libahci.c
index 3982054060b8..a5d7c1c2a05e 100644
--- a/drivers/ata/libahci.c
+++ b/drivers/ata/libahci.c
@@ -507,6 +507,7 @@ void ahci_save_initial_config(struct device *dev, struct ahci_host_priv *hpriv)
                 dev_info(dev, "forcing port_map 0x%x -> 0x%x\n",
                          port_map, hpriv->force_port_map);
                 port_map = hpriv->force_port_map;
+                hpriv->saved_port_map = port_map;
         }
 
         if (hpriv->mask_port_map) {
diff --git a/drivers/base/power/opp/core.c b/drivers/base/power/opp/core.c
index 433b60092972..d8f4cc22856c 100644
--- a/drivers/base/power/opp/core.c
+++ b/drivers/base/power/opp/core.c
@@ -259,9 +259,6 @@ unsigned long dev_pm_opp_get_max_volt_latency(struct device *dev)
         reg = opp_table->regulator;
         if (IS_ERR(reg)) {
                 /* Regulator may not be required for device */
-                if (reg)
-                        dev_err(dev, "%s: Invalid regulator (%ld)\n", __func__,
-                                PTR_ERR(reg));
                 rcu_read_unlock();
                 return 0;
         }
diff --git a/drivers/base/power/wakeup.c b/drivers/base/power/wakeup.c
index a1e0b9ab847a..5fb7718f256c 100644
--- a/drivers/base/power/wakeup.c
+++ b/drivers/base/power/wakeup.c
@@ -246,6 +246,8 @@ static int device_wakeup_attach(struct device *dev, struct wakeup_source *ws)
                 return -EEXIST;
         }
         dev->power.wakeup = ws;
+        if (dev->power.wakeirq)
+                device_wakeup_attach_irq(dev, dev->power.wakeirq);
         spin_unlock_irq(&dev->power.lock);
         return 0;
 }
diff --git a/drivers/base/property.c b/drivers/base/property.c
index 9b1a65debd49..7f692accdc90 100644
--- a/drivers/base/property.c
+++ b/drivers/base/property.c
@@ -21,7 +21,7 @@
 
 static inline bool is_pset_node(struct fwnode_handle *fwnode)
 {
-        return fwnode && fwnode->type == FWNODE_PDATA;
+        return !IS_ERR_OR_NULL(fwnode) && fwnode->type == FWNODE_PDATA;
 }
 
 static inline struct property_set *to_pset_node(struct fwnode_handle *fwnode)
diff --git a/drivers/bcma/main.c b/drivers/bcma/main.c
index 786be8fed39e..1f635471f318 100644
--- a/drivers/bcma/main.c
+++ b/drivers/bcma/main.c
@@ -136,7 +136,6 @@ static bool bcma_is_core_needed_early(u16 core_id)
         return false;
 }
 
-#if defined(CONFIG_OF) && defined(CONFIG_OF_ADDRESS)
 static struct device_node *bcma_of_find_child_device(struct platform_device *parent,
                                                      struct bcma_device *core)
 {
@@ -184,7 +183,7 @@ static unsigned int bcma_of_get_irq(struct platform_device *parent,
         struct of_phandle_args out_irq;
         int ret;
 
-        if (!parent || !parent->dev.of_node)
+        if (!IS_ENABLED(CONFIG_OF_IRQ) || !parent || !parent->dev.of_node)
                 return 0;
 
         ret = bcma_of_irq_parse(parent, core, &out_irq, num);
@@ -202,23 +201,15 @@ static void bcma_of_fill_device(struct platform_device *parent,
 {
         struct device_node *node;
 
+        if (!IS_ENABLED(CONFIG_OF_IRQ))
+                return;
+
         node = bcma_of_find_child_device(parent, core);
         if (node)
                 core->dev.of_node = node;
 
         core->irq = bcma_of_get_irq(parent, core, 0);
 }
-#else
-static void bcma_of_fill_device(struct platform_device *parent,
-                                struct bcma_device *core)
-{
-}
-static inline unsigned int bcma_of_get_irq(struct platform_device *parent,
-                                           struct bcma_device *core, int num)
-{
-        return 0;
-}
-#endif /* CONFIG_OF */
 
 unsigned int bcma_core_irq(struct bcma_device *core, int num)
 {
diff --git a/drivers/block/aoe/aoeblk.c b/drivers/block/aoe/aoeblk.c
index dd73e1ff1759..ec9d8610b25f 100644
--- a/drivers/block/aoe/aoeblk.c
+++ b/drivers/block/aoe/aoeblk.c
@@ -397,7 +397,7 @@ aoeblk_gdalloc(void *vp)
         WARN_ON(d->flags & DEVFL_UP);
         blk_queue_max_hw_sectors(q, BLK_DEF_MAX_SECTORS);
         q->backing_dev_info.name = "aoe";
-        q->backing_dev_info.ra_pages = READ_AHEAD / PAGE_CACHE_SIZE;
+        q->backing_dev_info.ra_pages = READ_AHEAD / PAGE_SIZE;
         d->bufpool = mp;
         d->blkq = gd->queue = q;
         q->queuedata = d;
diff --git a/drivers/block/brd.c b/drivers/block/brd.c
index f7ecc287d733..51a071e32221 100644
--- a/drivers/block/brd.c
+++ b/drivers/block/brd.c
@@ -374,7 +374,7 @@ static int brd_rw_page(struct block_device *bdev, sector_t sector,
                        struct page *page, int rw)
 {
         struct brd_device *brd = bdev->bd_disk->private_data;
-        int err = brd_do_bvec(brd, page, PAGE_CACHE_SIZE, 0, rw, sector);
+        int err = brd_do_bvec(brd, page, PAGE_SIZE, 0, rw, sector);
         page_endio(page, rw & WRITE, err);
         return err;
 }
diff --git a/drivers/block/drbd/drbd_int.h b/drivers/block/drbd/drbd_int.h
index c227fd4cad75..7a1cf7eaa71d 100644
--- a/drivers/block/drbd/drbd_int.h
+++ b/drivers/block/drbd/drbd_int.h
@@ -1327,8 +1327,8 @@ struct bm_extent {
 #endif
 #endif
 
-/* BIO_MAX_SIZE is 256 * PAGE_CACHE_SIZE,
- * so for typical PAGE_CACHE_SIZE of 4k, that is (1<<20) Byte.
+/* BIO_MAX_SIZE is 256 * PAGE_SIZE,
+ * so for typical PAGE_SIZE of 4k, that is (1<<20) Byte.
  * Since we may live in a mixed-platform cluster,
  * we limit us to a platform agnostic constant here for now.
  * A followup commit may allow even bigger BIO sizes,
diff --git a/drivers/block/drbd/drbd_nl.c b/drivers/block/drbd/drbd_nl.c
index 226eb0c9f0fb..1fd1dccebb6b 100644
--- a/drivers/block/drbd/drbd_nl.c
+++ b/drivers/block/drbd/drbd_nl.c
@@ -1178,7 +1178,7 @@ static void drbd_setup_queue_param(struct drbd_device *device, struct drbd_backi
         blk_queue_max_hw_sectors(q, max_hw_sectors);
         /* This is the workaround for "bio would need to, but cannot, be split" */
         blk_queue_max_segments(q, max_segments ? max_segments : BLK_MAX_SEGMENTS);
-        blk_queue_segment_boundary(q, PAGE_CACHE_SIZE-1);
+        blk_queue_segment_boundary(q, PAGE_SIZE-1);
 
         if (b) {
                 struct drbd_connection *connection = first_peer_device(device)->connection;
diff --git a/drivers/block/loop.c b/drivers/block/loop.c
index 423f4ca7d712..80cf8add46ff 100644
--- a/drivers/block/loop.c
+++ b/drivers/block/loop.c
@@ -488,6 +488,12 @@ static int lo_rw_aio(struct loop_device *lo, struct loop_cmd *cmd,
         bvec = __bvec_iter_bvec(bio->bi_io_vec, bio->bi_iter);
         iov_iter_bvec(&iter, ITER_BVEC | rw, bvec,
                       bio_segments(bio), blk_rq_bytes(cmd->rq));
+        /*
+         * This bio may be started from the middle of the 'bvec'
+         * because of bio splitting, so offset from the bvec must
+         * be passed to iov iterator
+         */
+        iter.iov_offset = bio->bi_iter.bi_bvec_done;
 
         cmd->iocb.ki_pos = pos;
         cmd->iocb.ki_filp = file;
diff --git a/drivers/block/rbd.c b/drivers/block/rbd.c
index 9c6234428607..0ede6d7e2568 100644
--- a/drivers/block/rbd.c
+++ b/drivers/block/rbd.c
@@ -538,7 +538,6 @@ static int _rbd_dev_v2_snap_size(struct rbd_device *rbd_dev, u64 snap_id,
                                 u8 *order, u64 *snap_size);
 static int _rbd_dev_v2_snap_features(struct rbd_device *rbd_dev, u64 snap_id,
                 u64 *snap_features);
-static u64 rbd_snap_id_by_name(struct rbd_device *rbd_dev, const char *name);
 
 static int rbd_open(struct block_device *bdev, fmode_t mode)
 {
@@ -1953,7 +1952,7 @@ static struct ceph_osd_request *rbd_osd_req_create(
 
         osdc = &rbd_dev->rbd_client->client->osdc;
         osd_req = ceph_osdc_alloc_request(osdc, snapc, num_ops, false,
-                                          GFP_ATOMIC);
+                                          GFP_NOIO);
         if (!osd_req)
                 return NULL;    /* ENOMEM */
 
@@ -2002,7 +2001,7 @@ rbd_osd_req_create_copyup(struct rbd_obj_request *obj_request)
         rbd_dev = img_request->rbd_dev;
         osdc = &rbd_dev->rbd_client->client->osdc;
         osd_req = ceph_osdc_alloc_request(osdc, snapc, num_osd_ops,
-                                                false, GFP_ATOMIC);
+                                                false, GFP_NOIO);
         if (!osd_req)
                 return NULL;    /* ENOMEM */
 
@@ -2504,7 +2503,7 @@ static int rbd_img_request_fill(struct rbd_img_request *img_request,
                                         bio_chain_clone_range(&bio_list,
                                                                 &bio_offset,
                                                                 clone_size,
-                                                                GFP_ATOMIC);
+                                                                GFP_NOIO);
                         if (!obj_request->bio_list)
                                 goto out_unwind;
                 } else if (type == OBJ_REQUEST_PAGES) {
@@ -3127,9 +3126,6 @@ static void rbd_watch_cb(u64 ver, u64 notify_id, u8 opcode, void *data)
         struct rbd_device *rbd_dev = (struct rbd_device *)data;
         int ret;
 
-        if (!rbd_dev)
-                return;
-
         dout("%s: \"%s\" notify_id %llu opcode %u\n", __func__,
                 rbd_dev->header_name, (unsigned long long)notify_id,
                 (unsigned int)opcode);
@@ -3263,6 +3259,9 @@ static void rbd_dev_header_unwatch_sync(struct rbd_device *rbd_dev)
 
         ceph_osdc_cancel_event(rbd_dev->watch_event);
         rbd_dev->watch_event = NULL;
+
+        dout("%s flushing notifies\n", __func__);
+        ceph_osdc_flush_notifies(&rbd_dev->rbd_client->client->osdc);
 }
 
 /*
@@ -3642,21 +3641,14 @@ static void rbd_exists_validate(struct rbd_device *rbd_dev)
 static void rbd_dev_update_size(struct rbd_device *rbd_dev)
 {
         sector_t size;
-        bool removing;
 
         /*
-         * Don't hold the lock while doing disk operations,
-         * or lock ordering will conflict with the bdev mutex via:
-         * rbd_add() -> blkdev_get() -> rbd_open()
+         * If EXISTS is not set, rbd_dev->disk may be NULL, so don't
+         * try to update its size.  If REMOVING is set, updating size
+         * is just useless work since the device can't be opened.
          */
-        spin_lock_irq(&rbd_dev->lock);
-        removing = test_bit(RBD_DEV_FLAG_REMOVING, &rbd_dev->flags);
-        spin_unlock_irq(&rbd_dev->lock);
-        /*
-         * If the device is being removed, rbd_dev->disk has
-         * been destroyed, so don't try to update its size
-         */
-        if (!removing) {
+        if (test_bit(RBD_DEV_FLAG_EXISTS, &rbd_dev->flags) &&
+            !test_bit(RBD_DEV_FLAG_REMOVING, &rbd_dev->flags)) {
                 size = (sector_t)rbd_dev->mapping.size / SECTOR_SIZE;
                 dout("setting size to %llu sectors", (unsigned long long)size);
                 set_capacity(rbd_dev->disk, size);
@@ -4191,7 +4183,7 @@ static int _rbd_dev_v2_snap_features(struct rbd_device *rbd_dev, u64 snap_id,
                 __le64 features;
                 __le64 incompat;
         } __attribute__ ((packed)) features_buf = { 0 };
-        u64 incompat;
+        u64 unsup;
         int ret;
 
         ret = rbd_obj_method_sync(rbd_dev, rbd_dev->header_name,
@@ -4204,9 +4196,12 @@ static int _rbd_dev_v2_snap_features(struct rbd_device *rbd_dev, u64 snap_id,
         if (ret < sizeof (features_buf))
                 return -ERANGE;
 
-        incompat = le64_to_cpu(features_buf.incompat);
-        if (incompat & ~RBD_FEATURES_SUPPORTED)
+        unsup = le64_to_cpu(features_buf.incompat) & ~RBD_FEATURES_SUPPORTED;
+        if (unsup) {
+                rbd_warn(rbd_dev, "image uses unsupported features: 0x%llx",
+                         unsup);
                 return -ENXIO;
+        }
 
         *snap_features = le64_to_cpu(features_buf.features);
 
@@ -5187,6 +5182,10 @@ out_err:
         return ret;
 }
 
+/*
+ * rbd_dev->header_rwsem must be locked for write and will be unlocked
+ * upon return.
+ */
 static int rbd_dev_device_setup(struct rbd_device *rbd_dev)
 {
         int ret;
@@ -5195,7 +5194,7 @@ static int rbd_dev_device_setup(struct rbd_device *rbd_dev)
 
         ret = rbd_dev_id_get(rbd_dev);
         if (ret)
-                return ret;
+                goto err_out_unlock;
 
         BUILD_BUG_ON(DEV_NAME_LEN
                         < sizeof (RBD_DRV_NAME) + MAX_INT_FORMAT_WIDTH);
@@ -5236,8 +5235,9 @@ static int rbd_dev_device_setup(struct rbd_device *rbd_dev)
         /* Everything's ready.  Announce the disk to the world. */
 
         set_bit(RBD_DEV_FLAG_EXISTS, &rbd_dev->flags);
-        add_disk(rbd_dev->disk);
+        up_write(&rbd_dev->header_rwsem);
 
+        add_disk(rbd_dev->disk);
         pr_info("%s: added with size 0x%llx\n", rbd_dev->disk->disk_name,
                 (unsigned long long) rbd_dev->mapping.size);
 
@@ -5252,6 +5252,8 @@ err_out_blkdev:
                 unregister_blkdev(rbd_dev->major, rbd_dev->name);
 err_out_id:
         rbd_dev_id_put(rbd_dev);
+err_out_unlock:
+        up_write(&rbd_dev->header_rwsem);
         return ret;
 }
 
@@ -5442,6 +5444,7 @@ static ssize_t do_rbd_add(struct bus_type *bus,
         spec = NULL;            /* rbd_dev now owns this */
         rbd_opts = NULL;        /* rbd_dev now owns this */
 
+        down_write(&rbd_dev->header_rwsem);
         rc = rbd_dev_image_probe(rbd_dev, 0);
         if (rc < 0)
                 goto err_out_rbd_dev;
@@ -5471,6 +5474,7 @@ out:
         return rc;
 
 err_out_rbd_dev:
+        up_write(&rbd_dev->header_rwsem);
         rbd_dev_destroy(rbd_dev);
 err_out_client:
         rbd_put_client(rbdc);
@@ -5577,12 +5581,6 @@ static ssize_t do_rbd_remove(struct bus_type *bus,
                 return ret;
 
         rbd_dev_header_unwatch_sync(rbd_dev);
-        /*
-         * flush remaining watch callbacks - these must be complete
-         * before the osd_client is shutdown
-         */
-        dout("%s: flushing notifies", __func__);
-        ceph_osdc_flush_notifies(&rbd_dev->rbd_client->client->osdc);
 
         /*
          * Don't free anything from rbd_dev->disk until after all
diff --git a/drivers/bus/mvebu-mbus.c b/drivers/bus/mvebu-mbus.c
index c2e52864bb03..ce54a0160faa 100644
--- a/drivers/bus/mvebu-mbus.c
+++ b/drivers/bus/mvebu-mbus.c
@@ -972,7 +972,7 @@ int mvebu_mbus_get_dram_win_info(phys_addr_t phyaddr, u8 *target, u8 *attr)
                 }
         }
 
-        pr_err("invalid dram address 0x%x\n", phyaddr);
+        pr_err("invalid dram address %pa\n", &phyaddr);
         return -EINVAL;
 }
 EXPORT_SYMBOL_GPL(mvebu_mbus_get_dram_win_info);
diff --git a/drivers/bus/uniphier-system-bus.c b/drivers/bus/uniphier-system-bus.c
index 834a2aeaf27a..350b7309c26d 100644
--- a/drivers/bus/uniphier-system-bus.c
+++ b/drivers/bus/uniphier-system-bus.c
@@ -108,7 +108,7 @@ static int uniphier_system_bus_check_overlap(
 
         for (i = 0; i < ARRAY_SIZE(priv->bank); i++) {
                 for (j = i + 1; j < ARRAY_SIZE(priv->bank); j++) {
-                        if (priv->bank[i].end > priv->bank[j].base ||
+                        if (priv->bank[i].end > priv->bank[j].base &&
                             priv->bank[i].base < priv->bank[j].end) {
                                 dev_err(priv->dev,
                                         "region overlap between bank%d and bank%d\n",
diff --git a/drivers/char/hw_random/bcm63xx-rng.c b/drivers/char/hw_random/bcm63xx-rng.c
index ca9c40309757..5132c9cde50d 100644
--- a/drivers/char/hw_random/bcm63xx-rng.c
+++ b/drivers/char/hw_random/bcm63xx-rng.c
@@ -12,6 +12,7 @@
 #include <linux/clk.h>
 #include <linux/platform_device.h>
 #include <linux/hw_random.h>
+#include <linux/of.h>
 
 #define RNG_CTRL                        0x00
 #define RNG_EN                          (1 << 0)
diff --git a/drivers/clk/imx/clk-imx6q.c b/drivers/clk/imx/clk-imx6q.c
index 02e18182fcb5..2beb396fe652 100644
--- a/drivers/clk/imx/clk-imx6q.c
+++ b/drivers/clk/imx/clk-imx6q.c
@@ -394,7 +394,7 @@ static void __init imx6q_clocks_init(struct device_node *ccm_node)
                 clk[IMX6QDL_CLK_LDB_DI1_DIV_3_5] = imx_clk_fixed_factor("ldb_di1_div_3_5", "ldb_di1", 2, 7);
         } else {
                 clk[IMX6QDL_CLK_ECSPI_ROOT] = imx_clk_divider("ecspi_root", "pll3_60m", base + 0x38, 19, 6);
-                clk[IMX6QDL_CLK_CAN_ROOT] = imx_clk_divider("can_root", "pll3_60", base + 0x20, 2, 6);
+                clk[IMX6QDL_CLK_CAN_ROOT] = imx_clk_divider("can_root", "pll3_60m", base + 0x20, 2, 6);
                 clk[IMX6QDL_CLK_IPG_PER] = imx_clk_fixup_divider("ipg_per", "ipg", base + 0x1c, 0, 6, imx_cscmr1_fixup);
                 clk[IMX6QDL_CLK_UART_SERIAL_PODF] = imx_clk_divider("uart_serial_podf", "pll3_80m",          base + 0x24, 0,  6);
                 clk[IMX6QDL_CLK_LDB_DI0_DIV_3_5] = imx_clk_fixed_factor("ldb_di0_div_3_5", "ldb_di0_sel", 2, 7);
diff --git a/drivers/clk/mediatek/reset.c b/drivers/clk/mediatek/reset.c
index 9e9fe4b19ac4..309049d41f1b 100644
--- a/drivers/clk/mediatek/reset.c
+++ b/drivers/clk/mediatek/reset.c
@@ -57,7 +57,7 @@ static int mtk_reset(struct reset_controller_dev *rcdev,
         return mtk_reset_deassert(rcdev, id);
 }
 
-static struct reset_control_ops mtk_reset_ops = {
+static const struct reset_control_ops mtk_reset_ops = {
         .assert = mtk_reset_assert,
         .deassert = mtk_reset_deassert,
         .reset = mtk_reset,
diff --git a/drivers/clk/mmp/reset.c b/drivers/clk/mmp/reset.c
index b54da1fe73f0..b4e4d6aa2631 100644
--- a/drivers/clk/mmp/reset.c
+++ b/drivers/clk/mmp/reset.c
@@ -74,7 +74,7 @@ static int mmp_clk_reset_deassert(struct reset_controller_dev *rcdev,
         return 0;
 }
 
-static struct reset_control_ops mmp_clk_reset_ops = {
+static const struct reset_control_ops mmp_clk_reset_ops = {
         .assert         = mmp_clk_reset_assert,
         .deassert       = mmp_clk_reset_deassert,
 };
diff --git a/drivers/clk/qcom/gcc-ipq4019.c b/drivers/clk/qcom/gcc-ipq4019.c
index 5428efb9fbf5..3cd1af0af0d9 100644
--- a/drivers/clk/qcom/gcc-ipq4019.c
+++ b/drivers/clk/qcom/gcc-ipq4019.c
@@ -129,20 +129,10 @@ static const char * const gcc_xo_ddr_500_200[] = {
 };
 
 #define F(f, s, h, m, n) { (f), (s), (2 * (h) - 1), (m), (n) }
-#define P_XO 0
-#define FE_PLL_200 1
-#define FE_PLL_500 2
-#define DDRC_PLL_666  3
-
-#define DDRC_PLL_666_SDCC  1
-#define FE_PLL_125_DLY 1
-
-#define FE_PLL_WCSS2G 1
-#define FE_PLL_WCSS5G 1
 
 static const struct freq_tbl ftbl_gcc_audio_pwm_clk[] = {
         F(48000000, P_XO, 1, 0, 0),
-        F(200000000, FE_PLL_200, 1, 0, 0),
+        F(200000000, P_FEPLL200, 1, 0, 0),
         { }
 };
 
@@ -334,15 +324,15 @@ static struct clk_branch gcc_blsp1_qup2_spi_apps_clk = {
 };
 
 static const struct freq_tbl ftbl_gcc_blsp1_uart1_2_apps_clk[] = {
-        F(1843200, FE_PLL_200, 1, 144, 15625),
-        F(3686400, FE_PLL_200, 1, 288, 15625),
-        F(7372800, FE_PLL_200, 1, 576, 15625),
-        F(14745600, FE_PLL_200, 1, 1152, 15625),
-        F(16000000, FE_PLL_200, 1, 2, 25),
+        F(1843200, P_FEPLL200, 1, 144, 15625),
+        F(3686400, P_FEPLL200, 1, 288, 15625),
+        F(7372800, P_FEPLL200, 1, 576, 15625),
+        F(14745600, P_FEPLL200, 1, 1152, 15625),
+        F(16000000, P_FEPLL200, 1, 2, 25),
         F(24000000, P_XO, 1, 1, 2),
-        F(32000000, FE_PLL_200, 1, 4, 25),
-        F(40000000, FE_PLL_200, 1, 1, 5),
-        F(46400000, FE_PLL_200, 1, 29, 125),
+        F(32000000, P_FEPLL200, 1, 4, 25),
+        F(40000000, P_FEPLL200, 1, 1, 5),
+        F(46400000, P_FEPLL200, 1, 29, 125),
         F(48000000, P_XO, 1, 0, 0),
         { }
 };
@@ -410,9 +400,9 @@ static struct clk_branch gcc_blsp1_uart2_apps_clk = {
 };
 
 static const struct freq_tbl ftbl_gcc_gp_clk[] = {
-        F(1250000,  FE_PLL_200, 1, 16, 0),
-        F(2500000,  FE_PLL_200, 1,  8, 0),
-        F(5000000,  FE_PLL_200, 1,  4, 0),
+        F(1250000,  P_FEPLL200, 1, 16, 0),
+        F(2500000,  P_FEPLL200, 1,  8, 0),
+        F(5000000,  P_FEPLL200, 1,  4, 0),
         { }
 };
 
@@ -512,11 +502,11 @@ static struct clk_branch gcc_gp3_clk = {
 static const struct freq_tbl ftbl_gcc_sdcc1_apps_clk[] = {
         F(144000,    P_XO,                      1,  3, 240),
         F(400000,    P_XO,                      1,  1, 0),
-        F(20000000,  FE_PLL_500,                1,  1, 25),
-        F(25000000,  FE_PLL_500,                1,  1, 20),
-        F(50000000,  FE_PLL_500,                1,  1, 10),
-        F(100000000, FE_PLL_500,                1,  1, 5),
-        F(193000000, DDRC_PLL_666_SDCC,         1,  0, 0),
+        F(20000000,  P_FEPLL500,                1,  1, 25),
+        F(25000000,  P_FEPLL500,                1,  1, 20),
+        F(50000000,  P_FEPLL500,                1,  1, 10),
+        F(100000000, P_FEPLL500,                1,  1, 5),
+        F(193000000, P_DDRPLL,          1,  0, 0),
         { }
 };
 
@@ -536,9 +526,9 @@ static struct clk_rcg2  sdcc1_apps_clk_src = {
 
 static const struct freq_tbl ftbl_gcc_apps_clk[] = {
         F(48000000, P_XO,          1, 0, 0),
-        F(200000000, FE_PLL_200,   1, 0, 0),
-        F(500000000, FE_PLL_500,   1, 0, 0),
-        F(626000000, DDRC_PLL_666, 1, 0, 0),
+        F(200000000, P_FEPLL200,   1, 0, 0),
+        F(500000000, P_FEPLL500,   1, 0, 0),
+        F(626000000, P_DDRPLLAPSS, 1, 0, 0),
         { }
 };
 
@@ -557,7 +547,7 @@ static struct clk_rcg2 apps_clk_src = {
 
 static const struct freq_tbl ftbl_gcc_apps_ahb_clk[] = {
         F(48000000, P_XO,          1, 0, 0),
-        F(100000000, FE_PLL_200,   2, 0, 0),
+        F(100000000, P_FEPLL200,   2, 0, 0),
         { }
 };
 
@@ -940,7 +930,7 @@ static struct clk_branch gcc_usb2_mock_utmi_clk = {
 };
 
 static const struct freq_tbl ftbl_gcc_usb30_mock_utmi_clk[] = {
-        F(2000000, FE_PLL_200, 10, 0, 0),
+        F(2000000, P_FEPLL200, 10, 0, 0),
         { }
 };
 
@@ -1007,7 +997,7 @@ static struct clk_branch gcc_usb3_mock_utmi_clk = {
 };
 
 static const struct freq_tbl ftbl_gcc_fephy_dly_clk[] = {
-        F(125000000, FE_PLL_125_DLY, 1, 0, 0),
+        F(125000000, P_FEPLL125DLY, 1, 0, 0),
         { }
 };
 
@@ -1027,7 +1017,7 @@ static struct clk_rcg2 fephy_125m_dly_clk_src = {
 
 static const struct freq_tbl ftbl_gcc_wcss2g_clk[] = {
         F(48000000, P_XO, 1, 0, 0),
-        F(250000000, FE_PLL_WCSS2G, 1, 0, 0),
+        F(250000000, P_FEPLLWCSS2G, 1, 0, 0),
         { }
 };
 
@@ -1097,7 +1087,7 @@ static struct clk_branch gcc_wcss2g_rtc_clk = {
 
 static const struct freq_tbl ftbl_gcc_wcss5g_clk[] = {
         F(48000000, P_XO, 1, 0, 0),
-        F(250000000, FE_PLL_WCSS5G, 1, 0, 0),
+        F(250000000, P_FEPLLWCSS5G, 1, 0, 0),
         { }
 };
 
@@ -1325,6 +1315,16 @@ MODULE_DEVICE_TABLE(of, gcc_ipq4019_match_table);
 
 static int gcc_ipq4019_probe(struct platform_device *pdev)
 {
+        struct device *dev = &pdev->dev;
+
+        clk_register_fixed_rate(dev, "fepll125", "xo", 0, 200000000);
+        clk_register_fixed_rate(dev, "fepll125dly", "xo", 0, 200000000);
+        clk_register_fixed_rate(dev, "fepllwcss2g", "xo", 0, 200000000);
+        clk_register_fixed_rate(dev, "fepllwcss5g", "xo", 0, 200000000);
+        clk_register_fixed_rate(dev, "fepll200", "xo", 0, 200000000);
+        clk_register_fixed_rate(dev, "fepll500", "xo", 0, 200000000);
+        clk_register_fixed_rate(dev, "ddrpllapss", "xo", 0, 666000000);
+
         return qcom_cc_probe(pdev, &gcc_ipq4019_desc);
 }
 
diff --git a/drivers/clk/qcom/reset.c b/drivers/clk/qcom/reset.c
index 6c977d3a8590..0324d8daab9b 100644
--- a/drivers/clk/qcom/reset.c
+++ b/drivers/clk/qcom/reset.c
@@ -55,7 +55,7 @@ qcom_reset_deassert(struct reset_controller_dev *rcdev, unsigned long id)
         return regmap_update_bits(rst->regmap, map->reg, mask, 0);
 }
 
-struct reset_control_ops qcom_reset_ops = {
+const struct reset_control_ops qcom_reset_ops = {
         .reset = qcom_reset,
         .assert = qcom_reset_assert,
         .deassert = qcom_reset_deassert,
diff --git a/drivers/clk/qcom/reset.h b/drivers/clk/qcom/reset.h
index 0e11e2130f97..cda877927d43 100644
--- a/drivers/clk/qcom/reset.h
+++ b/drivers/clk/qcom/reset.h
@@ -32,6 +32,6 @@ struct qcom_reset_controller {
 #define to_qcom_reset_controller(r) \
         container_of(r, struct qcom_reset_controller, rcdev);
 
-extern struct reset_control_ops qcom_reset_ops;
+extern const struct reset_control_ops qcom_reset_ops;
 
 #endif
diff --git a/drivers/clk/rockchip/softrst.c b/drivers/clk/rockchip/softrst.c
index 552f7bb15bc5..21218987bbc3 100644
--- a/drivers/clk/rockchip/softrst.c
+++ b/drivers/clk/rockchip/softrst.c
@@ -81,7 +81,7 @@ static int rockchip_softrst_deassert(struct reset_controller_dev *rcdev,
         return 0;
 }
 
-static struct reset_control_ops rockchip_softrst_ops = {
+static const struct reset_control_ops rockchip_softrst_ops = {
         .assert         = rockchip_softrst_assert,
         .deassert       = rockchip_softrst_deassert,
 };
diff --git a/drivers/clk/sirf/clk-atlas7.c b/drivers/clk/sirf/clk-atlas7.c
index 957aae63e7cc..d0c6c9a2d06a 100644
--- a/drivers/clk/sirf/clk-atlas7.c
+++ b/drivers/clk/sirf/clk-atlas7.c
@@ -1423,7 +1423,7 @@ static int atlas7_reset_module(struct reset_controller_dev *rcdev,
         return 0;
 }
 
-static struct reset_control_ops atlas7_rst_ops = {
+static const struct reset_control_ops atlas7_rst_ops = {
         .reset = atlas7_reset_module,
 };
 
diff --git a/drivers/clk/sunxi/clk-a10-ve.c b/drivers/clk/sunxi/clk-a10-ve.c
index 044c1717b762..d9ea22ec4e25 100644
--- a/drivers/clk/sunxi/clk-a10-ve.c
+++ b/drivers/clk/sunxi/clk-a10-ve.c
@@ -85,7 +85,7 @@ static int sunxi_ve_of_xlate(struct reset_controller_dev *rcdev,
         return 0;
 }
 
-static struct reset_control_ops sunxi_ve_reset_ops = {
+static const struct reset_control_ops sunxi_ve_reset_ops = {
         .assert         = sunxi_ve_reset_assert,
         .deassert       = sunxi_ve_reset_deassert,
 };
diff --git a/drivers/clk/sunxi/clk-sun9i-mmc.c b/drivers/clk/sunxi/clk-sun9i-mmc.c
index a9b176139aca..028dd832a39f 100644
--- a/drivers/clk/sunxi/clk-sun9i-mmc.c
+++ b/drivers/clk/sunxi/clk-sun9i-mmc.c
@@ -83,7 +83,7 @@ static int sun9i_mmc_reset_deassert(struct reset_controller_dev *rcdev,
         return 0;
 }
 
-static struct reset_control_ops sun9i_mmc_reset_ops = {
+static const struct reset_control_ops sun9i_mmc_reset_ops = {
         .assert         = sun9i_mmc_reset_assert,
         .deassert       = sun9i_mmc_reset_deassert,
 };
diff --git a/drivers/clk/sunxi/clk-usb.c b/drivers/clk/sunxi/clk-usb.c
index 5432b1c198a4..fe0c3d169377 100644
--- a/drivers/clk/sunxi/clk-usb.c
+++ b/drivers/clk/sunxi/clk-usb.c
@@ -76,7 +76,7 @@ static int sunxi_usb_reset_deassert(struct reset_controller_dev *rcdev,
         return 0;
 }
 
-static struct reset_control_ops sunxi_usb_reset_ops = {
+static const struct reset_control_ops sunxi_usb_reset_ops = {
         .assert         = sunxi_usb_reset_assert,
         .deassert       = sunxi_usb_reset_deassert,
 };
diff --git a/drivers/clk/tegra/clk.c b/drivers/clk/tegra/clk.c
index 2a3a4fe803d6..f60fe2e344ca 100644
--- a/drivers/clk/tegra/clk.c
+++ b/drivers/clk/tegra/clk.c
@@ -271,7 +271,7 @@ void __init tegra_init_from_table(struct tegra_clk_init_table *tbl,
         }
 }
 
-static struct reset_control_ops rst_ops = {
+static const struct reset_control_ops rst_ops = {
         .assert = tegra_clk_rst_assert,
         .deassert = tegra_clk_rst_deassert,
 };
diff --git a/drivers/clocksource/tango_xtal.c b/drivers/clocksource/tango_xtal.c
index 2bcecafdeaea..c407c47a3232 100644
--- a/drivers/clocksource/tango_xtal.c
+++ b/drivers/clocksource/tango_xtal.c
@@ -42,7 +42,7 @@ static void __init tango_clocksource_init(struct device_node *np)
 
         ret = clocksource_mmio_init(xtal_in_cnt, "tango-xtal", xtal_freq, 350,
                                     32, clocksource_mmio_readl_up);
-        if (!ret) {
+        if (ret) {
                 pr_err("%s: registration failed\n", np->full_name);
                 return;
         }
diff --git a/drivers/cpufreq/cpufreq-dt.c b/drivers/cpufreq/cpufreq-dt.c
index f951f911786e..5f8dbe640a20 100644
--- a/drivers/cpufreq/cpufreq-dt.c
+++ b/drivers/cpufreq/cpufreq-dt.c
@@ -4,9 +4,6 @@
  * Copyright (C) 2014 Linaro.
  * Viresh Kumar <viresh.kumar@linaro.org>
  *
- * The OPP code in function set_target() is reused from
- * drivers/cpufreq/omap-cpufreq.c
- *
  * 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.
diff --git a/drivers/cpufreq/cpufreq.c b/drivers/cpufreq/cpufreq.c
index b87596b591b3..c4acfc5273b3 100644
--- a/drivers/cpufreq/cpufreq.c
+++ b/drivers/cpufreq/cpufreq.c
@@ -1491,6 +1491,9 @@ static unsigned int cpufreq_update_current_freq(struct cpufreq_policy *policy)
 {
         unsigned int new_freq;
 
+        if (cpufreq_suspended)
+                return 0;
+
         new_freq = cpufreq_driver->get(policy->cpu);
         if (!new_freq)
                 return 0;
@@ -1554,21 +1557,25 @@ void cpufreq_suspend(void)
         if (!cpufreq_driver)
                 return;
 
-        if (!has_target())
+        if (!has_target() && !cpufreq_driver->suspend)
                 goto suspend;
 
         pr_debug("%s: Suspending Governors\n", __func__);
 
         for_each_active_policy(policy) {
-                down_write(&policy->rwsem);
-                ret = cpufreq_governor(policy, CPUFREQ_GOV_STOP);
-                up_write(&policy->rwsem);
+                if (has_target()) {
+                        down_write(&policy->rwsem);
+                        ret = cpufreq_governor(policy, CPUFREQ_GOV_STOP);
+                        up_write(&policy->rwsem);
 
-                if (ret)
-                        pr_err("%s: Failed to stop governor for policy: %p\n",
-                                __func__, policy);
-                else if (cpufreq_driver->suspend
-                    && cpufreq_driver->suspend(policy))
+                        if (ret) {
+                                pr_err("%s: Failed to stop governor for policy: %p\n",
+                                        __func__, policy);
+                                continue;
+                        }
+                }
+
+                if (cpufreq_driver->suspend && cpufreq_driver->suspend(policy))
                         pr_err("%s: Failed to suspend driver: %p\n", __func__,
                                 policy);
         }
@@ -1593,7 +1600,7 @@ void cpufreq_resume(void)
 
         cpufreq_suspended = false;
 
-        if (!has_target())
+        if (!has_target() && !cpufreq_driver->resume)
                 return;
 
         pr_debug("%s: Resuming Governors\n", __func__);
@@ -1602,7 +1609,7 @@ void cpufreq_resume(void)
                 if (cpufreq_driver->resume && cpufreq_driver->resume(policy)) {
                         pr_err("%s: Failed to resume driver: %p\n", __func__,
                                 policy);
-                } else {
+                } else if (has_target()) {
                         down_write(&policy->rwsem);
                         ret = cpufreq_start_governor(policy);
                         up_write(&policy->rwsem);
diff --git a/drivers/cpufreq/cpufreq_governor.c b/drivers/cpufreq/cpufreq_governor.c
index 10a5cfeae8c5..5f1147fa9239 100644
--- a/drivers/cpufreq/cpufreq_governor.c
+++ b/drivers/cpufreq/cpufreq_governor.c
@@ -193,12 +193,8 @@ unsigned int dbs_update(struct cpufreq_policy *policy)
                 wall_time = cur_wall_time - j_cdbs->prev_cpu_wall;
                 j_cdbs->prev_cpu_wall = cur_wall_time;
 
-                if (cur_idle_time <= j_cdbs->prev_cpu_idle) {
-                        idle_time = 0;
-                } else {
-                        idle_time = cur_idle_time - j_cdbs->prev_cpu_idle;
-                        j_cdbs->prev_cpu_idle = cur_idle_time;
-                }
+                idle_time = cur_idle_time - j_cdbs->prev_cpu_idle;
+                j_cdbs->prev_cpu_idle = cur_idle_time;
 
                 if (ignore_nice) {
                         u64 cur_nice = kcpustat_cpu(j).cpustat[CPUTIME_NICE];
diff --git a/drivers/cpufreq/intel_pstate.c b/drivers/cpufreq/intel_pstate.c
index 4b644526fd59..b230ebaae66c 100644
--- a/drivers/cpufreq/intel_pstate.c
+++ b/drivers/cpufreq/intel_pstate.c
@@ -64,6 +64,25 @@ static inline int ceiling_fp(int32_t x)
         return ret;
 }
 
+/**
+ * struct sample -      Store performance sample
+ * @core_pct_busy:      Ratio of APERF/MPERF in percent, which is actual
+ *                      performance during last sample period
+ * @busy_scaled:        Scaled busy value which is used to calculate next
+ *                      P state. This can be different than core_pct_busy
+ *                      to account for cpu idle period
+ * @aperf:              Difference of actual performance frequency clock count
+ *                      read from APERF MSR between last and current sample
+ * @mperf:              Difference of maximum performance frequency clock count
+ *                      read from MPERF MSR between last and current sample
+ * @tsc:                Difference of time stamp counter between last and
+ *                      current sample
+ * @freq:               Effective frequency calculated from APERF/MPERF
+ * @time:               Current time from scheduler
+ *
+ * This structure is used in the cpudata structure to store performance sample
+ * data for choosing next P State.
+ */
 struct sample {
         int32_t core_pct_busy;
         int32_t busy_scaled;
@@ -74,6 +93,20 @@ struct sample {
         u64 time;
 };
 
+/**
+ * struct pstate_data - Store P state data
+ * @current_pstate:     Current requested P state
+ * @min_pstate:         Min P state possible for this platform
+ * @max_pstate:         Max P state possible for this platform
+ * @max_pstate_physical:This is physical Max P state for a processor
+ *                      This can be higher than the max_pstate which can
+ *                      be limited by platform thermal design power limits
+ * @scaling:            Scaling factor to  convert frequency to cpufreq
+ *                      frequency units
+ * @turbo_pstate:       Max Turbo P state possible for this platform
+ *
+ * Stores the per cpu model P state limits and current P state.
+ */
 struct pstate_data {
         int     current_pstate;
         int     min_pstate;
@@ -83,6 +116,19 @@ struct pstate_data {
         int     turbo_pstate;
 };
 
+/**
+ * struct vid_data -    Stores voltage information data
+ * @min:                VID data for this platform corresponding to
+ *                      the lowest P state
+ * @max:                VID data corresponding to the highest P State.
+ * @turbo:              VID data for turbo P state
+ * @ratio:              Ratio of (vid max - vid min) /
+ *                      (max P state - Min P State)
+ *
+ * Stores the voltage data for DVFS (Dynamic Voltage and Frequency Scaling)
+ * This data is used in Atom platforms, where in addition to target P state,
+ * the voltage data needs to be specified to select next P State.
+ */
 struct vid_data {
         int min;
         int max;
@@ -90,6 +136,18 @@ struct vid_data {
         int32_t ratio;
 };
 
+/**
+ * struct _pid -        Stores PID data
+ * @setpoint:           Target set point for busyness or performance
+ * @integral:           Storage for accumulated error values
+ * @p_gain:             PID proportional gain
+ * @i_gain:             PID integral gain
+ * @d_gain:             PID derivative gain
+ * @deadband:           PID deadband
+ * @last_err:           Last error storage for integral part of PID calculation
+ *
+ * Stores PID coefficients and last error for PID controller.
+ */
 struct _pid {
         int setpoint;
         int32_t integral;
@@ -100,6 +158,23 @@ struct _pid {
         int32_t last_err;
 };
 
+/**
+ * struct cpudata -     Per CPU instance data storage
+ * @cpu:                CPU number for this instance data
+ * @update_util:        CPUFreq utility callback information
+ * @pstate:             Stores P state limits for this CPU
+ * @vid:                Stores VID limits for this CPU
+ * @pid:                Stores PID parameters for this CPU
+ * @last_sample_time:   Last Sample time
+ * @prev_aperf:         Last APERF value read from APERF MSR
+ * @prev_mperf:         Last MPERF value read from MPERF MSR
+ * @prev_tsc:           Last timestamp counter (TSC) value
+ * @prev_cummulative_iowait: IO Wait time difference from last and
+ *                      current sample
+ * @sample:             Storage for storing last Sample data
+ *
+ * This structure stores per CPU instance data for all CPUs.
+ */
 struct cpudata {
         int cpu;
 
@@ -118,6 +193,19 @@ struct cpudata {
 };
 
 static struct cpudata **all_cpu_data;
+
+/**
+ * struct pid_adjust_policy - Stores static PID configuration data
+ * @sample_rate_ms:     PID calculation sample rate in ms
+ * @sample_rate_ns:     Sample rate calculation in ns
+ * @deadband:           PID deadband
+ * @setpoint:           PID Setpoint
+ * @p_gain_pct:         PID proportional gain
+ * @i_gain_pct:         PID integral gain
+ * @d_gain_pct:         PID derivative gain
+ *
+ * Stores per CPU model static PID configuration data.
+ */
 struct pstate_adjust_policy {
         int sample_rate_ms;
         s64 sample_rate_ns;
@@ -128,6 +216,20 @@ struct pstate_adjust_policy {
         int i_gain_pct;
 };
 
+/**
+ * struct pstate_funcs - Per CPU model specific callbacks
+ * @get_max:            Callback to get maximum non turbo effective P state
+ * @get_max_physical:   Callback to get maximum non turbo physical P state
+ * @get_min:            Callback to get minimum P state
+ * @get_turbo:          Callback to get turbo P state
+ * @get_scaling:        Callback to get frequency scaling factor
+ * @get_val:            Callback to convert P state to actual MSR write value
+ * @get_vid:            Callback to get VID data for Atom platforms
+ * @get_target_pstate:  Callback to a function to calculate next P state to use
+ *
+ * Core and Atom CPU models have different way to get P State limits. This
+ * structure is used to store those callbacks.
+ */
 struct pstate_funcs {
         int (*get_max)(void);
         int (*get_max_physical)(void);
@@ -139,6 +241,11 @@ struct pstate_funcs {
         int32_t (*get_target_pstate)(struct cpudata *);
 };
 
+/**
+ * struct cpu_defaults- Per CPU model default config data
+ * @pid_policy: PID config data
+ * @funcs:              Callback function data
+ */
 struct cpu_defaults {
         struct pstate_adjust_policy pid_policy;
         struct pstate_funcs funcs;
@@ -151,6 +258,34 @@ static struct pstate_adjust_policy pid_params;
 static struct pstate_funcs pstate_funcs;
 static int hwp_active;
 
+
+/**
+ * struct perf_limits - Store user and policy limits
+ * @no_turbo:           User requested turbo state from intel_pstate sysfs
+ * @turbo_disabled:     Platform turbo status either from msr
+ *                      MSR_IA32_MISC_ENABLE or when maximum available pstate
+ *                      matches the maximum turbo pstate
+ * @max_perf_pct:       Effective maximum performance limit in percentage, this
+ *                      is minimum of either limits enforced by cpufreq policy
+ *                      or limits from user set limits via intel_pstate sysfs
+ * @min_perf_pct:       Effective minimum performance limit in percentage, this
+ *                      is maximum of either limits enforced by cpufreq policy
+ *                      or limits from user set limits via intel_pstate sysfs
+ * @max_perf:           This is a scaled value between 0 to 255 for max_perf_pct
+ *                      This value is used to limit max pstate
+ * @min_perf:           This is a scaled value between 0 to 255 for min_perf_pct
+ *                      This value is used to limit min pstate
+ * @max_policy_pct:     The maximum performance in percentage enforced by
+ *                      cpufreq setpolicy interface
+ * @max_sysfs_pct:      The maximum performance in percentage enforced by
+ *                      intel pstate sysfs interface
+ * @min_policy_pct:     The minimum performance in percentage enforced by
+ *                      cpufreq setpolicy interface
+ * @min_sysfs_pct:      The minimum performance in percentage enforced by
+ *                      intel pstate sysfs interface
+ *
+ * Storage for user and policy defined limits.
+ */
 struct perf_limits {
         int no_turbo;
         int turbo_disabled;
@@ -318,6 +453,14 @@ static void intel_pstate_hwp_set(const struct cpumask *cpumask)
         }
 }
 
+static int intel_pstate_hwp_set_policy(struct cpufreq_policy *policy)
+{
+        if (hwp_active)
+                intel_pstate_hwp_set(policy->cpus);
+
+        return 0;
+}
+
 static void intel_pstate_hwp_set_online_cpus(void)
 {
         get_online_cpus();
@@ -678,6 +821,11 @@ static int core_get_max_pstate(void)
                         if (err)
                                 goto skip_tar;
 
+                        /* For level 1 and 2, bits[23:16] contain the ratio */
+                        if (tdp_ctrl)
+                                tdp_ratio >>= 16;
+
+                        tdp_ratio &= 0xff; /* ratios are only 8 bits long */
                         if (tdp_ratio - 1 == tar) {
                                 max_pstate = tar;
                                 pr_debug("max_pstate=TAC %x\n", max_pstate);
@@ -910,13 +1058,21 @@ static inline bool intel_pstate_sample(struct cpudata *cpu, u64 time)
         cpu->prev_aperf = aperf;
         cpu->prev_mperf = mperf;
         cpu->prev_tsc = tsc;
-        return true;
+        /*
+         * First time this function is invoked in a given cycle, all of the
+         * previous sample data fields are equal to zero or stale and they must
+         * be populated with meaningful numbers for things to work, so assume
+         * that sample.time will always be reset before setting the utilization
+         * update hook and make the caller skip the sample then.
+         */
+        return !!cpu->last_sample_time;
 }
 
 static inline int32_t get_avg_frequency(struct cpudata *cpu)
 {
-        return div64_u64(cpu->pstate.max_pstate_physical * cpu->sample.aperf *
-                cpu->pstate.scaling, cpu->sample.mperf);
+        return fp_toint(mul_fp(cpu->sample.core_pct_busy,
+                               int_tofp(cpu->pstate.max_pstate_physical *
+                                                cpu->pstate.scaling / 100)));
 }
 
 static inline int32_t get_target_pstate_use_cpu_load(struct cpudata *cpu)
@@ -959,8 +1115,6 @@ static inline int32_t get_target_pstate_use_performance(struct cpudata *cpu)
         int32_t core_busy, max_pstate, current_pstate, sample_ratio;
         u64 duration_ns;
 
-        intel_pstate_calc_busy(cpu);
-
         /*
          * core_busy is the ratio of actual performance to max
          * max_pstate is the max non turbo pstate available
@@ -984,11 +1138,14 @@ static inline int32_t get_target_pstate_use_performance(struct cpudata *cpu)
          * enough period of time to adjust our busyness.
          */
         duration_ns = cpu->sample.time - cpu->last_sample_time;
-        if ((s64)duration_ns > pid_params.sample_rate_ns * 3
-            && cpu->last_sample_time > 0) {
+        if ((s64)duration_ns > pid_params.sample_rate_ns * 3) {
                 sample_ratio = div_fp(int_tofp(pid_params.sample_rate_ns),
                                       int_tofp(duration_ns));
                 core_busy = mul_fp(core_busy, sample_ratio);
+        } else {
+                sample_ratio = div_fp(100 * cpu->sample.mperf, cpu->sample.tsc);
+                if (sample_ratio < int_tofp(1))
+                        core_busy = 0;
         }
 
         cpu->sample.busy_scaled = core_busy;
@@ -1041,8 +1198,11 @@ static void intel_pstate_update_util(struct update_util_data *data, u64 time,
         if ((s64)delta_ns >= pid_params.sample_rate_ns) {
                 bool sample_taken = intel_pstate_sample(cpu, time);
 
-                if (sample_taken && !hwp_active)
-                        intel_pstate_adjust_busy_pstate(cpu);
+                if (sample_taken) {
+                        intel_pstate_calc_busy(cpu);
+                        if (!hwp_active)
+                                intel_pstate_adjust_busy_pstate(cpu);
+                }
         }
 }
 
@@ -1100,10 +1260,8 @@ static int intel_pstate_init_cpu(unsigned int cpunum)
         intel_pstate_get_cpu_pstates(cpu);
 
         intel_pstate_busy_pid_reset(cpu);
-        intel_pstate_sample(cpu, 0);
 
         cpu->update_util.func = intel_pstate_update_util;
-        cpufreq_set_update_util_data(cpunum, &cpu->update_util);
 
         pr_debug("intel_pstate: controlling: cpu %d\n", cpunum);
 
@@ -1122,22 +1280,54 @@ static unsigned int intel_pstate_get(unsigned int cpu_num)
         return get_avg_frequency(cpu);
 }
 
+static void intel_pstate_set_update_util_hook(unsigned int cpu_num)
+{
+        struct cpudata *cpu = all_cpu_data[cpu_num];
+
+        /* Prevent intel_pstate_update_util() from using stale data. */
+        cpu->sample.time = 0;
+        cpufreq_set_update_util_data(cpu_num, &cpu->update_util);
+}
+
+static void intel_pstate_clear_update_util_hook(unsigned int cpu)
+{
+        cpufreq_set_update_util_data(cpu, NULL);
+        synchronize_sched();
+}
+
+static void intel_pstate_set_performance_limits(struct perf_limits *limits)
+{
+        limits->no_turbo = 0;
+        limits->turbo_disabled = 0;
+        limits->max_perf_pct = 100;
+        limits->max_perf = int_tofp(1);
+        limits->min_perf_pct = 100;
+        limits->min_perf = int_tofp(1);
+        limits->max_policy_pct = 100;
+        limits->max_sysfs_pct = 100;
+        limits->min_policy_pct = 0;
+        limits->min_sysfs_pct = 0;
+}
+
 static int intel_pstate_set_policy(struct cpufreq_policy *policy)
 {
         if (!policy->cpuinfo.max_freq)
                 return -ENODEV;
 
-        if (policy->policy == CPUFREQ_POLICY_PERFORMANCE &&
-            policy->max >= policy->cpuinfo.max_freq) {
-                pr_debug("intel_pstate: set performance\n");
+        intel_pstate_clear_update_util_hook(policy->cpu);
+
+        if (policy->policy == CPUFREQ_POLICY_PERFORMANCE) {
                 limits = &performance_limits;
-                if (hwp_active)
-                        intel_pstate_hwp_set(policy->cpus);
-                return 0;
+                if (policy->max >= policy->cpuinfo.max_freq) {
+                        pr_debug("intel_pstate: set performance\n");
+                        intel_pstate_set_performance_limits(limits);
+                        goto out;
+                }
+        } else {
+                pr_debug("intel_pstate: set powersave\n");
+                limits = &powersave_limits;
         }
 
-        pr_debug("intel_pstate: set powersave\n");
-        limits = &powersave_limits;
         limits->min_policy_pct = (policy->min * 100) / policy->cpuinfo.max_freq;
         limits->min_policy_pct = clamp_t(int, limits->min_policy_pct, 0 , 100);
         limits->max_policy_pct = DIV_ROUND_UP(policy->max * 100,
@@ -1163,8 +1353,10 @@ static int intel_pstate_set_policy(struct cpufreq_policy *policy)
         limits->max_perf = div_fp(int_tofp(limits->max_perf_pct),
                                   int_tofp(100));
 
-        if (hwp_active)
-                intel_pstate_hwp_set(policy->cpus);
+ out:
+        intel_pstate_set_update_util_hook(policy->cpu);
+
+        intel_pstate_hwp_set_policy(policy);
 
         return 0;
 }
@@ -1187,8 +1379,7 @@ static void intel_pstate_stop_cpu(struct cpufreq_policy *policy)
 
         pr_debug("intel_pstate: CPU %d exiting\n", cpu_num);
 
-        cpufreq_set_update_util_data(cpu_num, NULL);
-        synchronize_sched();
+        intel_pstate_clear_update_util_hook(cpu_num);
 
         if (hwp_active)
                 return;
@@ -1229,6 +1420,7 @@ static struct cpufreq_driver intel_pstate_driver = {
         .flags          = CPUFREQ_CONST_LOOPS,
         .verify         = intel_pstate_verify_policy,
         .setpolicy      = intel_pstate_set_policy,
+        .resume         = intel_pstate_hwp_set_policy,
         .get            = intel_pstate_get,
         .init           = intel_pstate_cpu_init,
         .stop_cpu       = intel_pstate_stop_cpu,
@@ -1455,8 +1647,7 @@ out:
         get_online_cpus();
         for_each_online_cpu(cpu) {
                 if (all_cpu_data[cpu]) {
-                        cpufreq_set_update_util_data(cpu, NULL);
-                        synchronize_sched();
+                        intel_pstate_clear_update_util_hook(cpu);
                         kfree(all_cpu_data[cpu]);
                 }
         }
diff --git a/drivers/cpufreq/sti-cpufreq.c b/drivers/cpufreq/sti-cpufreq.c
index a9c659f58974..04042038ec4b 100644
--- a/drivers/cpufreq/sti-cpufreq.c
+++ b/drivers/cpufreq/sti-cpufreq.c
@@ -259,6 +259,10 @@ static int sti_cpufreq_init(void)
 {
         int ret;
 
+        if ((!of_machine_is_compatible("st,stih407")) &&
+                (!of_machine_is_compatible("st,stih410")))
+                return -ENODEV;
+
         ddata.cpu = get_cpu_device(0);
         if (!ddata.cpu) {
                 dev_err(ddata.cpu, "Failed to get device for CPU0\n");
diff --git a/drivers/cpuidle/cpuidle-arm.c b/drivers/cpuidle/cpuidle-arm.c
index 545069d5fdfb..e342565e8715 100644
--- a/drivers/cpuidle/cpuidle-arm.c
+++ b/drivers/cpuidle/cpuidle-arm.c
@@ -50,7 +50,7 @@ static int arm_enter_idle_state(struct cpuidle_device *dev,
                  * call the CPU ops suspend protocol with idle index as a
                  * parameter.
                  */
-                arm_cpuidle_suspend(idx);
+                ret = arm_cpuidle_suspend(idx);
 
                 cpu_pm_exit();
         }
diff --git a/drivers/crypto/ccp/ccp-crypto-aes-cmac.c b/drivers/crypto/ccp/ccp-crypto-aes-cmac.c
index 3d9acc53d247..60fc0fa26fd3 100644
--- a/drivers/crypto/ccp/ccp-crypto-aes-cmac.c
+++ b/drivers/crypto/ccp/ccp-crypto-aes-cmac.c
@@ -225,6 +225,9 @@ static int ccp_aes_cmac_export(struct ahash_request *req, void *out)
         struct ccp_aes_cmac_req_ctx *rctx = ahash_request_ctx(req);
         struct ccp_aes_cmac_exp_ctx state;
 
+        /* Don't let anything leak to 'out' */
+        memset(&state, 0, sizeof(state));
+
         state.null_msg = rctx->null_msg;
         memcpy(state.iv, rctx->iv, sizeof(state.iv));
         state.buf_count = rctx->buf_count;
diff --git a/drivers/crypto/ccp/ccp-crypto-sha.c b/drivers/crypto/ccp/ccp-crypto-sha.c
index b5ad72897dc2..8f36af62fe95 100644
--- a/drivers/crypto/ccp/ccp-crypto-sha.c
+++ b/drivers/crypto/ccp/ccp-crypto-sha.c
@@ -212,6 +212,9 @@ static int ccp_sha_export(struct ahash_request *req, void *out)
         struct ccp_sha_req_ctx *rctx = ahash_request_ctx(req);
         struct ccp_sha_exp_ctx state;
 
+        /* Don't let anything leak to 'out' */
+        memset(&state, 0, sizeof(state));
+
         state.type = rctx->type;
         state.msg_bits = rctx->msg_bits;
         state.first = rctx->first;
diff --git a/drivers/crypto/talitos.c b/drivers/crypto/talitos.c
index a0d4a08313ae..aae05547b924 100644
--- a/drivers/crypto/talitos.c
+++ b/drivers/crypto/talitos.c
@@ -63,6 +63,14 @@ static void to_talitos_ptr(struct talitos_ptr *ptr, dma_addr_t dma_addr,
                 ptr->eptr = upper_32_bits(dma_addr);
 }
 
+static void copy_talitos_ptr(struct talitos_ptr *dst_ptr,
+                             struct talitos_ptr *src_ptr, bool is_sec1)
+{
+        dst_ptr->ptr = src_ptr->ptr;
+        if (!is_sec1)
+                dst_ptr->eptr = src_ptr->eptr;
+}
+
 static void to_talitos_ptr_len(struct talitos_ptr *ptr, unsigned int len,
                                bool is_sec1)
 {
@@ -1083,21 +1091,20 @@ static int ipsec_esp(struct talitos_edesc *edesc, struct aead_request *areq,
         sg_count = dma_map_sg(dev, areq->src, edesc->src_nents ?: 1,
                               (areq->src == areq->dst) ? DMA_BIDIRECTIONAL
                                                            : DMA_TO_DEVICE);
-
         /* hmac data */
         desc->ptr[1].len = cpu_to_be16(areq->assoclen);
         if (sg_count > 1 &&
             (ret = sg_to_link_tbl_offset(areq->src, sg_count, 0,
                                          areq->assoclen,
                                          &edesc->link_tbl[tbl_off])) > 1) {
-                tbl_off += ret;
-
                 to_talitos_ptr(&desc->ptr[1], edesc->dma_link_tbl + tbl_off *
                                sizeof(struct talitos_ptr), 0);
                 desc->ptr[1].j_extent = DESC_PTR_LNKTBL_JUMP;
 
                 dma_sync_single_for_device(dev, edesc->dma_link_tbl,
                                            edesc->dma_len, DMA_BIDIRECTIONAL);
+
+                tbl_off += ret;
         } else {
                 to_talitos_ptr(&desc->ptr[1], sg_dma_address(areq->src), 0);
                 desc->ptr[1].j_extent = 0;
@@ -1126,11 +1133,13 @@ static int ipsec_esp(struct talitos_edesc *edesc, struct aead_request *areq,
         if (edesc->desc.hdr & DESC_HDR_MODE1_MDEU_CICV)
                 sg_link_tbl_len += authsize;
 
-        if (sg_count > 1 &&
-            (ret = sg_to_link_tbl_offset(areq->src, sg_count, areq->assoclen,
-                                         sg_link_tbl_len,
-                                         &edesc->link_tbl[tbl_off])) > 1) {
-                tbl_off += ret;
+        if (sg_count == 1) {
+                to_talitos_ptr(&desc->ptr[4], sg_dma_address(areq->src) +
+                               areq->assoclen, 0);
+        } else if ((ret = sg_to_link_tbl_offset(areq->src, sg_count,
+                                                areq->assoclen, sg_link_tbl_len,
+                                                &edesc->link_tbl[tbl_off])) >
+                   1) {
                 desc->ptr[4].j_extent |= DESC_PTR_LNKTBL_JUMP;
                 to_talitos_ptr(&desc->ptr[4], edesc->dma_link_tbl +
                                               tbl_off *
@@ -1138,8 +1147,10 @@ static int ipsec_esp(struct talitos_edesc *edesc, struct aead_request *areq,
                 dma_sync_single_for_device(dev, edesc->dma_link_tbl,
                                            edesc->dma_len,
                                            DMA_BIDIRECTIONAL);
-        } else
-                to_talitos_ptr(&desc->ptr[4], sg_dma_address(areq->src), 0);
+                tbl_off += ret;
+        } else {
+                copy_talitos_ptr(&desc->ptr[4], &edesc->link_tbl[tbl_off], 0);
+        }
 
         /* cipher out */
         desc->ptr[5].len = cpu_to_be16(cryptlen);
@@ -1151,11 +1162,13 @@ static int ipsec_esp(struct talitos_edesc *edesc, struct aead_request *areq,
 
         edesc->icv_ool = false;
 
-        if (sg_count > 1 &&
-            (sg_count = sg_to_link_tbl_offset(areq->dst, sg_count,
+        if (sg_count == 1) {
+                to_talitos_ptr(&desc->ptr[5], sg_dma_address(areq->dst) +
+                               areq->assoclen, 0);
+        } else if ((sg_count =
+                        sg_to_link_tbl_offset(areq->dst, sg_count,
                                               areq->assoclen, cryptlen,
-                                              &edesc->link_tbl[tbl_off])) >
-            1) {
+                                              &edesc->link_tbl[tbl_off])) > 1) {
                 struct talitos_ptr *tbl_ptr = &edesc->link_tbl[tbl_off];
 
                 to_talitos_ptr(&desc->ptr[5], edesc->dma_link_tbl +
@@ -1178,8 +1191,9 @@ static int ipsec_esp(struct talitos_edesc *edesc, struct aead_request *areq,
                                            edesc->dma_len, DMA_BIDIRECTIONAL);
 
                 edesc->icv_ool = true;
-        } else
-                to_talitos_ptr(&desc->ptr[5], sg_dma_address(areq->dst), 0);
+        } else {
+                copy_talitos_ptr(&desc->ptr[5], &edesc->link_tbl[tbl_off], 0);
+        }
 
         /* iv out */
         map_single_talitos_ptr(dev, &desc->ptr[6], ivsize, ctx->iv,
@@ -2629,21 +2643,11 @@ struct talitos_crypto_alg {
         struct talitos_alg_template algt;
 };
 
-static int talitos_cra_init(struct crypto_tfm *tfm)
+static int talitos_init_common(struct talitos_ctx *ctx,
+                               struct talitos_crypto_alg *talitos_alg)
 {
-        struct crypto_alg *alg = tfm->__crt_alg;
-        struct talitos_crypto_alg *talitos_alg;
-        struct talitos_ctx *ctx = crypto_tfm_ctx(tfm);
         struct talitos_private *priv;
 
-        if ((alg->cra_flags & CRYPTO_ALG_TYPE_MASK) == CRYPTO_ALG_TYPE_AHASH)
-                talitos_alg = container_of(__crypto_ahash_alg(alg),
-                                           struct talitos_crypto_alg,
-                                           algt.alg.hash);
-        else
-                talitos_alg = container_of(alg, struct talitos_crypto_alg,
-                                           algt.alg.crypto);
-
         /* update context with ptr to dev */
         ctx->dev = talitos_alg->dev;
 
@@ -2661,10 +2665,33 @@ static int talitos_cra_init(struct crypto_tfm *tfm)
         return 0;
 }
 
+static int talitos_cra_init(struct crypto_tfm *tfm)
+{
+        struct crypto_alg *alg = tfm->__crt_alg;
+        struct talitos_crypto_alg *talitos_alg;
+        struct talitos_ctx *ctx = crypto_tfm_ctx(tfm);
+
+        if ((alg->cra_flags & CRYPTO_ALG_TYPE_MASK) == CRYPTO_ALG_TYPE_AHASH)
+                talitos_alg = container_of(__crypto_ahash_alg(alg),
+                                           struct talitos_crypto_alg,
+                                           algt.alg.hash);
+        else
+                talitos_alg = container_of(alg, struct talitos_crypto_alg,
+                                           algt.alg.crypto);
+
+        return talitos_init_common(ctx, talitos_alg);
+}
+
 static int talitos_cra_init_aead(struct crypto_aead *tfm)
 {
-        talitos_cra_init(crypto_aead_tfm(tfm));
-        return 0;
+        struct aead_alg *alg = crypto_aead_alg(tfm);
+        struct talitos_crypto_alg *talitos_alg;
+        struct talitos_ctx *ctx = crypto_aead_ctx(tfm);
+
+        talitos_alg = container_of(alg, struct talitos_crypto_alg,
+                                   algt.alg.aead);
+
+        return talitos_init_common(ctx, talitos_alg);
 }
 
 static int talitos_cra_init_ahash(struct crypto_tfm *tfm)
diff --git a/drivers/dma/dw/core.c b/drivers/dma/dw/core.c
index 5ad0ec1f0e29..97199b3c25a2 100644
--- a/drivers/dma/dw/core.c
+++ b/drivers/dma/dw/core.c
@@ -130,26 +130,14 @@ static void dwc_desc_put(struct dw_dma_chan *dwc, struct dw_desc *desc)
 static void dwc_initialize(struct dw_dma_chan *dwc)
 {
         struct dw_dma *dw = to_dw_dma(dwc->chan.device);
-        struct dw_dma_slave *dws = dwc->chan.private;
         u32 cfghi = DWC_CFGH_FIFO_MODE;
         u32 cfglo = DWC_CFGL_CH_PRIOR(dwc->priority);
 
         if (dwc->initialized == true)
                 return;
 
-        if (dws) {
-                /*
-                 * We need controller-specific data to set up slave
-                 * transfers.
-                 */
-                BUG_ON(!dws->dma_dev || dws->dma_dev != dw->dma.dev);
-
-                cfghi |= DWC_CFGH_DST_PER(dws->dst_id);
-                cfghi |= DWC_CFGH_SRC_PER(dws->src_id);
-        } else {
-                cfghi |= DWC_CFGH_DST_PER(dwc->dst_id);
-                cfghi |= DWC_CFGH_SRC_PER(dwc->src_id);
-        }
+        cfghi |= DWC_CFGH_DST_PER(dwc->dst_id);
+        cfghi |= DWC_CFGH_SRC_PER(dwc->src_id);
 
         channel_writel(dwc, CFG_LO, cfglo);
         channel_writel(dwc, CFG_HI, cfghi);
@@ -941,7 +929,7 @@ bool dw_dma_filter(struct dma_chan *chan, void *param)
         struct dw_dma_chan *dwc = to_dw_dma_chan(chan);
         struct dw_dma_slave *dws = param;
 
-        if (!dws || dws->dma_dev != chan->device->dev)
+        if (dws->dma_dev != chan->device->dev)
                 return false;
 
         /* We have to copy data since dws can be temporary storage */
@@ -1165,6 +1153,14 @@ static int dwc_alloc_chan_resources(struct dma_chan *chan)
          * doesn't mean what you think it means), and status writeback.
          */
 
+        /*
+         * We need controller-specific data to set up slave transfers.
+         */
+        if (chan->private && !dw_dma_filter(chan, chan->private)) {
+                dev_warn(chan2dev(chan), "Wrong controller-specific data\n");
+                return -EINVAL;
+        }
+
         /* Enable controller here if needed */
         if (!dw->in_use)
                 dw_dma_on(dw);
@@ -1226,6 +1222,14 @@ static void dwc_free_chan_resources(struct dma_chan *chan)
         spin_lock_irqsave(&dwc->lock, flags);
         list_splice_init(&dwc->free_list, &list);
         dwc->descs_allocated = 0;
+
+        /* Clear custom channel configuration */
+        dwc->src_id = 0;
+        dwc->dst_id = 0;
+
+        dwc->src_master = 0;
+        dwc->dst_master = 0;
+
         dwc->initialized = false;
 
         /* Disable interrupts */
diff --git a/drivers/dma/edma.c b/drivers/dma/edma.c
index ee3463e774f8..04070baab78a 100644
--- a/drivers/dma/edma.c
+++ b/drivers/dma/edma.c
@@ -1238,6 +1238,7 @@ static struct dma_async_tx_descriptor *edma_prep_dma_cyclic(
         struct edma_desc *edesc;
         dma_addr_t src_addr, dst_addr;
         enum dma_slave_buswidth dev_width;
+        bool use_intermediate = false;
         u32 burst;
         int i, ret, nslots;
 
@@ -1279,8 +1280,21 @@ static struct dma_async_tx_descriptor *edma_prep_dma_cyclic(
          * but the synchronization is difficult to achieve with Cyclic and
          * cannot be guaranteed, so we error out early.
          */
-        if (nslots > MAX_NR_SG)
-                return NULL;
+        if (nslots > MAX_NR_SG) {
+                /*
+                 * If the burst and period sizes are the same, we can put
+                 * the full buffer into a single period and activate
+                 * intermediate interrupts. This will produce interrupts
+                 * after each burst, which is also after each desired period.
+                 */
+                if (burst == period_len) {
+                        period_len = buf_len;
+                        nslots = 2;
+                        use_intermediate = true;
+                } else {
+                        return NULL;
+                }
+        }
 
         edesc = kzalloc(sizeof(*edesc) + nslots * sizeof(edesc->pset[0]),
                         GFP_ATOMIC);
@@ -1358,8 +1372,13 @@ static struct dma_async_tx_descriptor *edma_prep_dma_cyclic(
                 /*
                  * Enable period interrupt only if it is requested
                  */
-                if (tx_flags & DMA_PREP_INTERRUPT)
+                if (tx_flags & DMA_PREP_INTERRUPT) {
                         edesc->pset[i].param.opt |= TCINTEN;
+
+                        /* Also enable intermediate interrupts if necessary */
+                        if (use_intermediate)
+                                edesc->pset[i].param.opt |= ITCINTEN;
+                }
         }
 
         /* Place the cyclic channel to highest priority queue */
@@ -1570,32 +1589,6 @@ static irqreturn_t dma_ccerr_handler(int irq, void *data)
         return IRQ_HANDLED;
 }
 
-static void edma_tc_set_pm_state(struct edma_tc *tc, bool enable)
-{
-        struct platform_device *tc_pdev;
-        int ret;
-
-        if (!IS_ENABLED(CONFIG_OF) || !tc)
-                return;
-
-        tc_pdev = of_find_device_by_node(tc->node);
-        if (!tc_pdev) {
-                pr_err("%s: TPTC device is not found\n", __func__);
-                return;
-        }
-        if (!pm_runtime_enabled(&tc_pdev->dev))
-                pm_runtime_enable(&tc_pdev->dev);
-
-        if (enable)
-                ret = pm_runtime_get_sync(&tc_pdev->dev);
-        else
-                ret = pm_runtime_put_sync(&tc_pdev->dev);
-
-        if (ret < 0)
-                pr_err("%s: pm_runtime_%s_sync() failed for %s\n", __func__,
-                       enable ? "get" : "put", dev_name(&tc_pdev->dev));
-}
-
 /* Alloc channel resources */
 static int edma_alloc_chan_resources(struct dma_chan *chan)
 {
@@ -1632,8 +1625,6 @@ static int edma_alloc_chan_resources(struct dma_chan *chan)
                 EDMA_CHAN_SLOT(echan->ch_num), chan->chan_id,
                 echan->hw_triggered ? "HW" : "SW");
 
-        edma_tc_set_pm_state(echan->tc, true);
-
         return 0;
 
 err_slot:
@@ -1670,7 +1661,6 @@ static void edma_free_chan_resources(struct dma_chan *chan)
                 echan->alloced = false;
         }
 
-        edma_tc_set_pm_state(echan->tc, false);
         echan->tc = NULL;
         echan->hw_triggered = false;
 
@@ -2417,10 +2407,8 @@ static int edma_pm_suspend(struct device *dev)
         int i;
 
         for (i = 0; i < ecc->num_channels; i++) {
-                if (echan[i].alloced) {
+                if (echan[i].alloced)
                         edma_setup_interrupt(&echan[i], false);
-                        edma_tc_set_pm_state(echan[i].tc, false);
-                }
         }
 
         return 0;
@@ -2450,8 +2438,6 @@ static int edma_pm_resume(struct device *dev)
 
                         /* Set up channel -> slot mapping for the entry slot */
                         edma_set_chmap(&echan[i], echan[i].slot[0]);
-
-                        edma_tc_set_pm_state(echan[i].tc, true);
                 }
         }
 
@@ -2475,7 +2461,8 @@ static struct platform_driver edma_driver = {
 
 static int edma_tptc_probe(struct platform_device *pdev)
 {
-        return 0;
+        pm_runtime_enable(&pdev->dev);
+        return pm_runtime_get_sync(&pdev->dev);
 }
 
 static struct platform_driver edma_tptc_driver = {
diff --git a/drivers/dma/hsu/hsu.c b/drivers/dma/hsu/hsu.c
index eef145edb936..ee510515ce18 100644
--- a/drivers/dma/hsu/hsu.c
+++ b/drivers/dma/hsu/hsu.c
@@ -64,10 +64,10 @@ static void hsu_dma_chan_start(struct hsu_dma_chan *hsuc)
 
         if (hsuc->direction == DMA_MEM_TO_DEV) {
                 bsr = config->dst_maxburst;
-                mtsr = config->dst_addr_width;
+                mtsr = config->src_addr_width;
         } else if (hsuc->direction == DMA_DEV_TO_MEM) {
                 bsr = config->src_maxburst;
-                mtsr = config->src_addr_width;
+                mtsr = config->dst_addr_width;
         }
 
         hsu_chan_disable(hsuc);
@@ -135,7 +135,7 @@ static u32 hsu_dma_chan_get_sr(struct hsu_dma_chan *hsuc)
         sr = hsu_chan_readl(hsuc, HSU_CH_SR);
         spin_unlock_irqrestore(&hsuc->vchan.lock, flags);
 
-        return sr;
+        return sr & ~(HSU_CH_SR_DESCE_ANY | HSU_CH_SR_CDESC_ANY);
 }
 
 irqreturn_t hsu_dma_irq(struct hsu_dma_chip *chip, unsigned short nr)
@@ -254,10 +254,13 @@ static void hsu_dma_issue_pending(struct dma_chan *chan)
 static size_t hsu_dma_active_desc_size(struct hsu_dma_chan *hsuc)
 {
         struct hsu_dma_desc *desc = hsuc->desc;
-        size_t bytes = desc->length;
+        size_t bytes = 0;
         int i;
 
-        i = desc->active % HSU_DMA_CHAN_NR_DESC;
+        for (i = desc->active; i < desc->nents; i++)
+                bytes += desc->sg[i].len;
+
+        i = HSU_DMA_CHAN_NR_DESC - 1;
         do {
                 bytes += hsu_chan_readl(hsuc, HSU_CH_DxTSR(i));
         } while (--i >= 0);
diff --git a/drivers/dma/hsu/hsu.h b/drivers/dma/hsu/hsu.h
index 578a8ee8cd05..6b070c22b1df 100644
--- a/drivers/dma/hsu/hsu.h
+++ b/drivers/dma/hsu/hsu.h
@@ -41,6 +41,9 @@
 #define HSU_CH_SR_DESCTO(x)     BIT(8 + (x))
 #define HSU_CH_SR_DESCTO_ANY    (BIT(11) | BIT(10) | BIT(9) | BIT(8))
 #define HSU_CH_SR_CHE           BIT(15)
+#define HSU_CH_SR_DESCE(x)      BIT(16 + (x))
+#define HSU_CH_SR_DESCE_ANY     (BIT(19) | BIT(18) | BIT(17) | BIT(16))
+#define HSU_CH_SR_CDESC_ANY     (BIT(31) | BIT(30))
 
 /* Bits in HSU_CH_CR */
 #define HSU_CH_CR_CHA           BIT(0)
diff --git a/drivers/dma/omap-dma.c b/drivers/dma/omap-dma.c
index 43bd5aee7ffe..1e984e18c126 100644
--- a/drivers/dma/omap-dma.c
+++ b/drivers/dma/omap-dma.c
@@ -48,6 +48,7 @@ struct omap_chan {
         unsigned dma_sig;
         bool cyclic;
         bool paused;
+        bool running;
 
         int dma_ch;
         struct omap_desc *desc;
@@ -294,6 +295,8 @@ static void omap_dma_start(struct omap_chan *c, struct omap_desc *d)
 
         /* Enable channel */
         omap_dma_chan_write(c, CCR, d->ccr | CCR_ENABLE);
+
+        c->running = true;
 }
 
 static void omap_dma_stop(struct omap_chan *c)
@@ -355,6 +358,8 @@ static void omap_dma_stop(struct omap_chan *c)
 
                 omap_dma_chan_write(c, CLNK_CTRL, val);
         }
+
+        c->running = false;
 }
 
 static void omap_dma_start_sg(struct omap_chan *c, struct omap_desc *d,
@@ -673,15 +678,20 @@ static enum dma_status omap_dma_tx_status(struct dma_chan *chan,
         struct omap_chan *c = to_omap_dma_chan(chan);
         struct virt_dma_desc *vd;
         enum dma_status ret;
-        uint32_t ccr;
         unsigned long flags;
 
-        ccr = omap_dma_chan_read(c, CCR);
-        /* The channel is no longer active, handle the completion right away */
-        if (!(ccr & CCR_ENABLE))
-                omap_dma_callback(c->dma_ch, 0, c);
-
         ret = dma_cookie_status(chan, cookie, txstate);
+
+        if (!c->paused && c->running) {
+                uint32_t ccr = omap_dma_chan_read(c, CCR);
+                /*
+                 * The channel is no longer active, set the return value
+                 * accordingly
+                 */
+                if (!(ccr & CCR_ENABLE))
+                        ret = DMA_COMPLETE;
+        }
+
         if (ret == DMA_COMPLETE || !txstate)
                 return ret;
 
@@ -945,9 +955,7 @@ static struct dma_async_tx_descriptor *omap_dma_prep_dma_memcpy(
         d->ccr = c->ccr;
         d->ccr |= CCR_DST_AMODE_POSTINC | CCR_SRC_AMODE_POSTINC;
 
-        d->cicr = CICR_DROP_IE;
-        if (tx_flags & DMA_PREP_INTERRUPT)
-                d->cicr |= CICR_FRAME_IE;
+        d->cicr = CICR_DROP_IE | CICR_FRAME_IE;
 
         d->csdp = data_type;
 
diff --git a/drivers/dma/xilinx/xilinx_vdma.c b/drivers/dma/xilinx/xilinx_vdma.c
index 0ee0321868d3..ef67f278e076 100644
--- a/drivers/dma/xilinx/xilinx_vdma.c
+++ b/drivers/dma/xilinx/xilinx_vdma.c
@@ -1236,7 +1236,7 @@ static struct dma_chan *of_dma_xilinx_xlate(struct of_phandle_args *dma_spec,
         struct xilinx_vdma_device *xdev = ofdma->of_dma_data;
         int chan_id = dma_spec->args[0];
 
-        if (chan_id >= XILINX_VDMA_MAX_CHANS_PER_DEVICE)
+        if (chan_id >= XILINX_VDMA_MAX_CHANS_PER_DEVICE || !xdev->chan[chan_id])
                 return NULL;
 
         return dma_get_slave_channel(&xdev->chan[chan_id]->common);
diff --git a/drivers/edac/i7core_edac.c b/drivers/edac/i7core_edac.c
index 01087a38da22..792bdae2b91d 100644
--- a/drivers/edac/i7core_edac.c
+++ b/drivers/edac/i7core_edac.c
@@ -1866,7 +1866,7 @@ static int i7core_mce_check_error(struct notifier_block *nb, unsigned long val,
 
         i7_dev = get_i7core_dev(mce->socketid);
         if (!i7_dev)
-                return NOTIFY_BAD;
+                return NOTIFY_DONE;
 
         mci = i7_dev->mci;
         pvt = mci->pvt_info;
diff --git a/drivers/edac/sb_edac.c b/drivers/edac/sb_edac.c
index 93f0d4120289..8bf745d2da7e 100644
--- a/drivers/edac/sb_edac.c
+++ b/drivers/edac/sb_edac.c
@@ -362,6 +362,7 @@ struct sbridge_pvt {
 
         /* Memory type detection */
         bool                    is_mirrored, is_lockstep, is_close_pg;
+        bool                    is_chan_hash;
 
         /* Fifo double buffers */
         struct mce              mce_entry[MCE_LOG_LEN];
@@ -1060,6 +1061,20 @@ static inline u8 sad_pkg_ha(u8 pkg)
         return (pkg >> 2) & 0x1;
 }
 
+static int haswell_chan_hash(int idx, u64 addr)
+{
+        int i;
+
+        /*
+         * XOR even bits from 12:26 to bit0 of idx,
+         *     odd bits from 13:27 to bit1
+         */
+        for (i = 12; i < 28; i += 2)
+                idx ^= (addr >> i) & 3;
+
+        return idx;
+}
+
 /****************************************************************************
                         Memory check routines
  ****************************************************************************/
@@ -1616,6 +1631,10 @@ static int get_dimm_config(struct mem_ctl_info *mci)
                 KNL_MAX_CHANNELS : NUM_CHANNELS;
         u64 knl_mc_sizes[KNL_MAX_CHANNELS];
 
+        if (pvt->info.type == HASWELL || pvt->info.type == BROADWELL) {
+                pci_read_config_dword(pvt->pci_ha0, HASWELL_HASYSDEFEATURE2, &reg);
+                pvt->is_chan_hash = GET_BITFIELD(reg, 21, 21);
+        }
         if (pvt->info.type == HASWELL || pvt->info.type == BROADWELL ||
                         pvt->info.type == KNIGHTS_LANDING)
                 pci_read_config_dword(pvt->pci_sad1, SAD_TARGET, &reg);
@@ -2118,12 +2137,15 @@ static int get_memory_error_data(struct mem_ctl_info *mci,
         }
 
         ch_way = TAD_CH(reg) + 1;
-        sck_way = 1 << TAD_SOCK(reg);
+        sck_way = TAD_SOCK(reg);
 
         if (ch_way == 3)
                 idx = addr >> 6;
-        else
+        else {
                 idx = (addr >> (6 + sck_way + shiftup)) & 0x3;
+                if (pvt->is_chan_hash)
+                        idx = haswell_chan_hash(idx, addr);
+        }
         idx = idx % ch_way;
 
         /*
@@ -2157,7 +2179,7 @@ static int get_memory_error_data(struct mem_ctl_info *mci,
                 switch(ch_way) {
                 case 2:
                 case 4:
-                        sck_xch = 1 << sck_way * (ch_way >> 1);
+                        sck_xch = (1 << sck_way) * (ch_way >> 1);
                         break;
                 default:
                         sprintf(msg, "Invalid mirror set. Can't decode addr");
@@ -2193,7 +2215,7 @@ static int get_memory_error_data(struct mem_ctl_info *mci,
 
         ch_addr = addr - offset;
         ch_addr >>= (6 + shiftup);
-        ch_addr /= ch_way * sck_way;
+        ch_addr /= sck_xch;
         ch_addr <<= (6 + shiftup);
         ch_addr |= addr & ((1 << (6 + shiftup)) - 1);
 
@@ -3146,7 +3168,7 @@ static int sbridge_mce_check_error(struct notifier_block *nb, unsigned long val,
 
         mci = get_mci_for_node_id(mce->socketid);
         if (!mci)
-                return NOTIFY_BAD;
+                return NOTIFY_DONE;
         pvt = mci->pvt_info;
 
         /*
diff --git a/drivers/extcon/extcon-palmas.c b/drivers/extcon/extcon-palmas.c
index 841a4b586395..8b3226dca1d9 100644
--- a/drivers/extcon/extcon-palmas.c
+++ b/drivers/extcon/extcon-palmas.c
@@ -348,8 +348,7 @@ static int palmas_usb_probe(struct platform_device *pdev)
                                                 palmas_vbus_irq_handler,
                                                 IRQF_TRIGGER_FALLING |
                                                 IRQF_TRIGGER_RISING |
-                                                IRQF_ONESHOT |
-                                                IRQF_EARLY_RESUME,
+                                                IRQF_ONESHOT,
                                                 "palmas_usb_vbus",
                                                 palmas_usb);
                 if (status < 0) {
diff --git a/drivers/firmware/efi/arm-init.c b/drivers/firmware/efi/arm-init.c
index aa1f743152a2..8714f8c271ba 100644
--- a/drivers/firmware/efi/arm-init.c
+++ b/drivers/firmware/efi/arm-init.c
@@ -203,7 +203,19 @@ void __init efi_init(void)
 
         reserve_regions();
         early_memunmap(memmap.map, params.mmap_size);
-        memblock_mark_nomap(params.mmap & PAGE_MASK,
-                            PAGE_ALIGN(params.mmap_size +
-                                       (params.mmap & ~PAGE_MASK)));
+
+        if (IS_ENABLED(CONFIG_ARM)) {
+                /*
+                 * ARM currently does not allow ioremap_cache() to be called on
+                 * memory regions that are covered by struct page. So remove the
+                 * UEFI memory map from the linear mapping.
+                 */
+                memblock_mark_nomap(params.mmap & PAGE_MASK,
+                                    PAGE_ALIGN(params.mmap_size +
+                                               (params.mmap & ~PAGE_MASK)));
+        } else {
+                memblock_reserve(params.mmap & PAGE_MASK,
+                                 PAGE_ALIGN(params.mmap_size +
+                                            (params.mmap & ~PAGE_MASK)));
+        }
 }
diff --git a/drivers/firmware/efi/vars.c b/drivers/firmware/efi/vars.c
index 0ac594c0a234..34b741940494 100644
--- a/drivers/firmware/efi/vars.c
+++ b/drivers/firmware/efi/vars.c
@@ -202,29 +202,44 @@ static const struct variable_validate variable_validate[] = {
         { NULL_GUID, "", NULL },
 };
 
+/*
+ * Check if @var_name matches the pattern given in @match_name.
+ *
+ * @var_name: an array of @len non-NUL characters.
+ * @match_name: a NUL-terminated pattern string, optionally ending in "*". A
+ *              final "*" character matches any trailing characters @var_name,
+ *              including the case when there are none left in @var_name.
+ * @match: on output, the number of non-wildcard characters in @match_name
+ *         that @var_name matches, regardless of the return value.
+ * @return: whether @var_name fully matches @match_name.
+ */
 static bool
 variable_matches(const char *var_name, size_t len, const char *match_name,
                  int *match)
 {
         for (*match = 0; ; (*match)++) {
                 char c = match_name[*match];
-                char u = var_name[*match];
 
-                /* Wildcard in the matching name means we've matched */
-                if (c == '*')
+                switch (c) {
+                case '*':
+                        /* Wildcard in @match_name means we've matched. */
                         return true;
 
-                /* Case sensitive match */
-                if (!c && *match == len)
-                        return true;
+                case '\0':
+                        /* @match_name has ended. Has @var_name too? */
+                        return (*match == len);
 
-                if (c != u)
+                default:
+                        /*
+                         * We've reached a non-wildcard char in @match_name.
+                         * Continue only if there's an identical character in
+                         * @var_name.
+                         */
+                        if (*match < len && c == var_name[*match])
+                                continue;
                         return false;
-
-                if (!c)
-                        return true;
+                }
         }
-        return true;
 }
 
 bool
diff --git a/drivers/firmware/psci.c b/drivers/firmware/psci.c
index 11bfee8b79a9..b5d05807e6ec 100644
--- a/drivers/firmware/psci.c
+++ b/drivers/firmware/psci.c
@@ -360,7 +360,7 @@ static struct cpuidle_ops psci_cpuidle_ops __initdata = {
         .init = psci_dt_cpu_init_idle,
 };
 
-CPUIDLE_METHOD_OF_DECLARE(psci, "arm,psci", &psci_cpuidle_ops);
+CPUIDLE_METHOD_OF_DECLARE(psci, "psci", &psci_cpuidle_ops);
 #endif
 #endif
 
diff --git a/drivers/firmware/qemu_fw_cfg.c b/drivers/firmware/qemu_fw_cfg.c
index fedbff55a7f3..1b95475b6aef 100644
--- a/drivers/firmware/qemu_fw_cfg.c
+++ b/drivers/firmware/qemu_fw_cfg.c
@@ -77,12 +77,28 @@ static inline u16 fw_cfg_sel_endianness(u16 key)
 static inline void fw_cfg_read_blob(u16 key,
                                     void *buf, loff_t pos, size_t count)
 {
+        u32 glk = -1U;
+        acpi_status status;
+
+        /* If we have ACPI, ensure mutual exclusion against any potential
+         * device access by the firmware, e.g. via AML methods:
+         */
+        status = acpi_acquire_global_lock(ACPI_WAIT_FOREVER, &glk);
+        if (ACPI_FAILURE(status) && status != AE_NOT_CONFIGURED) {
+                /* Should never get here */
+                WARN(1, "fw_cfg_read_blob: Failed to lock ACPI!\n");
+                memset(buf, 0, count);
+                return;
+        }
+
         mutex_lock(&fw_cfg_dev_lock);
         iowrite16(fw_cfg_sel_endianness(key), fw_cfg_reg_ctrl);
         while (pos-- > 0)
                 ioread8(fw_cfg_reg_data);
         ioread8_rep(fw_cfg_reg_data, buf, count);
         mutex_unlock(&fw_cfg_dev_lock);
+
+        acpi_release_global_lock(glk);
 }
 
 /* clean up fw_cfg device i/o */
@@ -727,12 +743,18 @@ device_param_cb(mmio, &fw_cfg_cmdline_param_ops, NULL, S_IRUSR);
 
 static int __init fw_cfg_sysfs_init(void)
 {
+        int ret;
+
         /* create /sys/firmware/qemu_fw_cfg/ top level directory */
         fw_cfg_top_ko = kobject_create_and_add("qemu_fw_cfg", firmware_kobj);
         if (!fw_cfg_top_ko)
                 return -ENOMEM;
 
-        return platform_driver_register(&fw_cfg_sysfs_driver);
+        ret = platform_driver_register(&fw_cfg_sysfs_driver);
+        if (ret)
+                fw_cfg_kobj_cleanup(fw_cfg_top_ko);
+
+        return ret;
 }
 
 static void __exit fw_cfg_sysfs_exit(void)
diff --git a/drivers/gpio/gpio-menz127.c b/drivers/gpio/gpio-menz127.c
index a68e199d579d..c5c9599a3a71 100644
--- a/drivers/gpio/gpio-menz127.c
+++ b/drivers/gpio/gpio-menz127.c
@@ -37,7 +37,6 @@ struct men_z127_gpio {
         void __iomem *reg_base;
         struct mcb_device *mdev;
         struct resource *mem;
-        spinlock_t lock;
 };
 
 static int men_z127_debounce(struct gpio_chip *gc, unsigned gpio,
@@ -69,7 +68,7 @@ static int men_z127_debounce(struct gpio_chip *gc, unsigned gpio,
                 debounce /= 50;
         }
 
-        spin_lock(&priv->lock);
+        spin_lock(&gc->bgpio_lock);
 
         db_en = readl(priv->reg_base + MEN_Z127_DBER);
 
@@ -84,7 +83,7 @@ static int men_z127_debounce(struct gpio_chip *gc, unsigned gpio,
         writel(db_en, priv->reg_base + MEN_Z127_DBER);
         writel(db_cnt, priv->reg_base + GPIO_TO_DBCNT_REG(gpio));
 
-        spin_unlock(&priv->lock);
+        spin_unlock(&gc->bgpio_lock);
 
         return 0;
 }
@@ -97,7 +96,7 @@ static int men_z127_request(struct gpio_chip *gc, unsigned gpio_pin)
         if (gpio_pin >= gc->ngpio)
                 return -EINVAL;
 
-        spin_lock(&priv->lock);
+        spin_lock(&gc->bgpio_lock);
         od_en = readl(priv->reg_base + MEN_Z127_ODER);
 
         if (gpiochip_line_is_open_drain(gc, gpio_pin))
@@ -106,7 +105,7 @@ static int men_z127_request(struct gpio_chip *gc, unsigned gpio_pin)
                 od_en &= ~BIT(gpio_pin);
 
         writel(od_en, priv->reg_base + MEN_Z127_ODER);
-        spin_unlock(&priv->lock);
+        spin_unlock(&gc->bgpio_lock);
 
         return 0;
 }
diff --git a/drivers/gpio/gpio-pca953x.c b/drivers/gpio/gpio-pca953x.c
index d0d3065a7557..e66084c295fb 100644
--- a/drivers/gpio/gpio-pca953x.c
+++ b/drivers/gpio/gpio-pca953x.c
@@ -18,6 +18,7 @@
 #include <linux/i2c.h>
 #include <linux/platform_data/pca953x.h>
 #include <linux/slab.h>
+#include <asm/unaligned.h>
 #include <linux/of_platform.h>
 #include <linux/acpi.h>
 
@@ -159,7 +160,7 @@ static int pca953x_write_regs(struct pca953x_chip *chip, int reg, u8 *val)
                 switch (chip->chip_type) {
                 case PCA953X_TYPE:
                         ret = i2c_smbus_write_word_data(chip->client,
-                                                        reg << 1, (u16) *val);
+                            reg << 1, cpu_to_le16(get_unaligned((u16 *)val)));
                         break;
                 case PCA957X_TYPE:
                         ret = i2c_smbus_write_byte_data(chip->client, reg << 1,
diff --git a/drivers/gpio/gpio-pxa.c b/drivers/gpio/gpio-pxa.c
index b2b7b78664b8..76ac906b4d78 100644
--- a/drivers/gpio/gpio-pxa.c
+++ b/drivers/gpio/gpio-pxa.c
@@ -283,8 +283,8 @@ static int pxa_gpio_direction_output(struct gpio_chip *chip,
         writel_relaxed(mask, base + (value ? GPSR_OFFSET : GPCR_OFFSET));
 
         ret = pinctrl_gpio_direction_output(chip->base + offset);
-        if (!ret)
-                return 0;
+        if (ret)
+                return ret;
 
         spin_lock_irqsave(&gpio_lock, flags);
 
diff --git a/drivers/gpio/gpio-rcar.c b/drivers/gpio/gpio-rcar.c
index d9ab0cd1d205..4d9a315cfd43 100644
--- a/drivers/gpio/gpio-rcar.c
+++ b/drivers/gpio/gpio-rcar.c
@@ -196,44 +196,6 @@ static int gpio_rcar_irq_set_wake(struct irq_data *d, unsigned int on)
         return 0;
 }
 
-static void gpio_rcar_irq_bus_lock(struct irq_data *d)
-{
-        struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct gpio_rcar_priv *p = gpiochip_get_data(gc);
-
-        pm_runtime_get_sync(&p->pdev->dev);
-}
-
-static void gpio_rcar_irq_bus_sync_unlock(struct irq_data *d)
-{
-        struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct gpio_rcar_priv *p = gpiochip_get_data(gc);
-
-        pm_runtime_put(&p->pdev->dev);
-}
-
-
-static int gpio_rcar_irq_request_resources(struct irq_data *d)
-{
-        struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct gpio_rcar_priv *p = gpiochip_get_data(gc);
-        int error;
-
-        error = pm_runtime_get_sync(&p->pdev->dev);
-        if (error < 0)
-                return error;
-
-        return 0;
-}
-
-static void gpio_rcar_irq_release_resources(struct irq_data *d)
-{
-        struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
-        struct gpio_rcar_priv *p = gpiochip_get_data(gc);
-
-        pm_runtime_put(&p->pdev->dev);
-}
-
 static irqreturn_t gpio_rcar_irq_handler(int irq, void *dev_id)
 {
         struct gpio_rcar_priv *p = dev_id;
@@ -280,32 +242,18 @@ static void gpio_rcar_config_general_input_output_mode(struct gpio_chip *chip,
 
 static int gpio_rcar_request(struct gpio_chip *chip, unsigned offset)
 {
-        struct gpio_rcar_priv *p = gpiochip_get_data(chip);
-        int error;
-
-        error = pm_runtime_get_sync(&p->pdev->dev);
-        if (error < 0)
-                return error;
-
-        error = pinctrl_request_gpio(chip->base + offset);
-        if (error)
-                pm_runtime_put(&p->pdev->dev);
-
-        return error;
+        return pinctrl_request_gpio(chip->base + offset);
 }
 
 static void gpio_rcar_free(struct gpio_chip *chip, unsigned offset)
 {
-        struct gpio_rcar_priv *p = gpiochip_get_data(chip);
-
         pinctrl_free_gpio(chip->base + offset);
 
-        /* Set the GPIO as an input to ensure that the next GPIO request won't
+        /*
+         * Set the GPIO as an input to ensure that the next GPIO request won't
          * drive the GPIO pin as an output.
          */
         gpio_rcar_config_general_input_output_mode(chip, offset, false);
-
-        pm_runtime_put(&p->pdev->dev);
 }
 
 static int gpio_rcar_direction_input(struct gpio_chip *chip, unsigned offset)
@@ -452,6 +400,7 @@ static int gpio_rcar_probe(struct platform_device *pdev)
         }
 
         pm_runtime_enable(dev);
+        pm_runtime_get_sync(dev);
 
         io = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         irq = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
@@ -488,10 +437,6 @@ static int gpio_rcar_probe(struct platform_device *pdev)
         irq_chip->irq_unmask = gpio_rcar_irq_enable;
         irq_chip->irq_set_type = gpio_rcar_irq_set_type;
         irq_chip->irq_set_wake = gpio_rcar_irq_set_wake;
-        irq_chip->irq_bus_lock = gpio_rcar_irq_bus_lock;
-        irq_chip->irq_bus_sync_unlock = gpio_rcar_irq_bus_sync_unlock;
-        irq_chip->irq_request_resources = gpio_rcar_irq_request_resources;
-        irq_chip->irq_release_resources = gpio_rcar_irq_release_resources;
         irq_chip->flags = IRQCHIP_SET_TYPE_MASKED | IRQCHIP_MASK_ON_SUSPEND;
 
         ret = gpiochip_add_data(gpio_chip, p);
@@ -522,6 +467,7 @@ static int gpio_rcar_probe(struct platform_device *pdev)
 err1:
         gpiochip_remove(gpio_chip);
 err0:
+        pm_runtime_put(dev);
         pm_runtime_disable(dev);
         return ret;
 }
@@ -532,6 +478,7 @@ static int gpio_rcar_remove(struct platform_device *pdev)
 
         gpiochip_remove(&p->gpio_chip);
 
+        pm_runtime_put(&pdev->dev);
         pm_runtime_disable(&pdev->dev);
         return 0;
 }
diff --git a/drivers/gpio/gpio-xgene.c b/drivers/gpio/gpio-xgene.c
index c0aa387664bf..0dc916191689 100644
--- a/drivers/gpio/gpio-xgene.c
+++ b/drivers/gpio/gpio-xgene.c
@@ -173,6 +173,11 @@ static int xgene_gpio_probe(struct platform_device *pdev)
         }
 
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
+        if (!res) {
+                err = -EINVAL;
+                goto err;
+        }
+
         gpio->base = devm_ioremap_nocache(&pdev->dev, res->start,
                                                         resource_size(res));
         if (!gpio->base) {
diff --git a/drivers/gpio/gpiolib-acpi.c b/drivers/gpio/gpiolib-acpi.c
index 682070d20f00..2dc52585e3f2 100644
--- a/drivers/gpio/gpiolib-acpi.c
+++ b/drivers/gpio/gpiolib-acpi.c
@@ -977,7 +977,7 @@ bool acpi_can_fallback_to_crs(struct acpi_device *adev, const char *con_id)
                 lookup = kmalloc(sizeof(*lookup), GFP_KERNEL);
                 if (lookup) {
                         lookup->adev = adev;
-                        lookup->con_id = con_id;
+                        lookup->con_id = kstrdup(con_id, GFP_KERNEL);
                         list_add_tail(&lookup->node, &acpi_crs_lookup_list);
                 }
         }
diff --git a/drivers/gpio/gpiolib.c b/drivers/gpio/gpiolib.c
index 72065532c1c7..b747c76fd2b1 100644
--- a/drivers/gpio/gpiolib.c
+++ b/drivers/gpio/gpiolib.c
@@ -68,6 +68,7 @@ LIST_HEAD(gpio_devices);
 static void gpiochip_free_hogs(struct gpio_chip *chip);
 static void gpiochip_irqchip_remove(struct gpio_chip *gpiochip);
 
+static bool gpiolib_initialized;
 
 static inline void desc_set_label(struct gpio_desc *d, const char *label)
 {
@@ -440,9 +441,63 @@ static void gpiodevice_release(struct device *dev)
         cdev_del(&gdev->chrdev);
         list_del(&gdev->list);
         ida_simple_remove(&gpio_ida, gdev->id);
+        kfree(gdev->label);
+        kfree(gdev->descs);
         kfree(gdev);
 }
 
+static int gpiochip_setup_dev(struct gpio_device *gdev)
+{
+        int status;
+
+        cdev_init(&gdev->chrdev, &gpio_fileops);
+        gdev->chrdev.owner = THIS_MODULE;
+        gdev->chrdev.kobj.parent = &gdev->dev.kobj;
+        gdev->dev.devt = MKDEV(MAJOR(gpio_devt), gdev->id);
+        status = cdev_add(&gdev->chrdev, gdev->dev.devt, 1);
+        if (status < 0)
+                chip_warn(gdev->chip, "failed to add char device %d:%d\n",
+                          MAJOR(gpio_devt), gdev->id);
+        else
+                chip_dbg(gdev->chip, "added GPIO chardev (%d:%d)\n",
+                         MAJOR(gpio_devt), gdev->id);
+        status = device_add(&gdev->dev);
+        if (status)
+                goto err_remove_chardev;
+
+        status = gpiochip_sysfs_register(gdev);
+        if (status)
+                goto err_remove_device;
+
+        /* From this point, the .release() function cleans up gpio_device */
+        gdev->dev.release = gpiodevice_release;
+        get_device(&gdev->dev);
+        pr_debug("%s: registered GPIOs %d to %d on device: %s (%s)\n",
+                 __func__, gdev->base, gdev->base + gdev->ngpio - 1,
+                 dev_name(&gdev->dev), gdev->chip->label ? : "generic");
+
+        return 0;
+
+err_remove_device:
+        device_del(&gdev->dev);
+err_remove_chardev:
+        cdev_del(&gdev->chrdev);
+        return status;
+}
+
+static void gpiochip_setup_devs(void)
+{
+        struct gpio_device *gdev;
+        int err;
+
+        list_for_each_entry(gdev, &gpio_devices, list) {
+                err = gpiochip_setup_dev(gdev);
+                if (err)
+                        pr_err("%s: Failed to initialize gpio device (%d)\n",
+                               dev_name(&gdev->dev), err);
+        }
+}
+
 /**
  * gpiochip_add_data() - register a gpio_chip
  * @chip: the chip to register, with chip->base initialized
@@ -457,6 +512,9 @@ static void gpiodevice_release(struct device *dev)
  * the gpio framework's arch_initcall().  Otherwise sysfs initialization
  * for GPIOs will fail rudely.
  *
+ * gpiochip_add_data() must only be called after gpiolib initialization,
+ * ie after core_initcall().
+ *
  * If chip->base is negative, this requests dynamic assignment of
  * a range of valid GPIOs.
  */
@@ -504,8 +562,7 @@ int gpiochip_add_data(struct gpio_chip *chip, void *data)
         else
                 gdev->owner = THIS_MODULE;
 
-        gdev->descs = devm_kcalloc(&gdev->dev, chip->ngpio,
-                                   sizeof(gdev->descs[0]), GFP_KERNEL);
+        gdev->descs = kcalloc(chip->ngpio, sizeof(gdev->descs[0]), GFP_KERNEL);
         if (!gdev->descs) {
                 status = -ENOMEM;
                 goto err_free_gdev;
@@ -514,16 +571,16 @@ int gpiochip_add_data(struct gpio_chip *chip, void *data)
         if (chip->ngpio == 0) {
                 chip_err(chip, "tried to insert a GPIO chip with zero lines\n");
                 status = -EINVAL;
-                goto err_free_gdev;
+                goto err_free_descs;
         }
 
         if (chip->label)
-                gdev->label = devm_kstrdup(&gdev->dev, chip->label, GFP_KERNEL);
+                gdev->label = kstrdup(chip->label, GFP_KERNEL);
         else
-                gdev->label = devm_kstrdup(&gdev->dev, "unknown", GFP_KERNEL);
+                gdev->label = kstrdup("unknown", GFP_KERNEL);
         if (!gdev->label) {
                 status = -ENOMEM;
-                goto err_free_gdev;
+                goto err_free_descs;
         }
 
         gdev->ngpio = chip->ngpio;
@@ -543,7 +600,7 @@ int gpiochip_add_data(struct gpio_chip *chip, void *data)
                 if (base < 0) {
                         status = base;
                         spin_unlock_irqrestore(&gpio_lock, flags);
-                        goto err_free_gdev;
+                        goto err_free_label;
                 }
                 /*
                  * TODO: it should not be necessary to reflect the assigned
@@ -558,7 +615,7 @@ int gpiochip_add_data(struct gpio_chip *chip, void *data)
         status = gpiodev_add_to_list(gdev);
         if (status) {
                 spin_unlock_irqrestore(&gpio_lock, flags);
-                goto err_free_gdev;
+                goto err_free_label;
         }
 
         for (i = 0; i < chip->ngpio; i++) {
@@ -596,39 +653,16 @@ int gpiochip_add_data(struct gpio_chip *chip, void *data)
          * we get a device node entry in sysfs under
          * /sys/bus/gpio/devices/gpiochipN/dev that can be used for
          * coldplug of device nodes and other udev business.
+         * We can do this only if gpiolib has been initialized.
+         * Otherwise, defer until later.
          */
-        cdev_init(&gdev->chrdev, &gpio_fileops);
-        gdev->chrdev.owner = THIS_MODULE;
-        gdev->chrdev.kobj.parent = &gdev->dev.kobj;
-        gdev->dev.devt = MKDEV(MAJOR(gpio_devt), gdev->id);
-        status = cdev_add(&gdev->chrdev, gdev->dev.devt, 1);
-        if (status < 0)
-                chip_warn(chip, "failed to add char device %d:%d\n",
-                          MAJOR(gpio_devt), gdev->id);
-        else
-                chip_dbg(chip, "added GPIO chardev (%d:%d)\n",
-                         MAJOR(gpio_devt), gdev->id);
-        status = device_add(&gdev->dev);
-        if (status)
-                goto err_remove_chardev;
-
-        status = gpiochip_sysfs_register(gdev);
-        if (status)
-                goto err_remove_device;
-
-        /* From this point, the .release() function cleans up gpio_device */
-        gdev->dev.release = gpiodevice_release;
-        get_device(&gdev->dev);
-        pr_debug("%s: registered GPIOs %d to %d on device: %s (%s)\n",
-                 __func__, gdev->base, gdev->base + gdev->ngpio - 1,
-                 dev_name(&gdev->dev), chip->label ? : "generic");
-
+        if (gpiolib_initialized) {
+                status = gpiochip_setup_dev(gdev);
+                if (status)
+                        goto err_remove_chip;
+        }
         return 0;
 
-err_remove_device:
-        device_del(&gdev->dev);
-err_remove_chardev:
-        cdev_del(&gdev->chrdev);
 err_remove_chip:
         acpi_gpiochip_remove(chip);
         gpiochip_free_hogs(chip);
@@ -637,6 +671,10 @@ err_remove_from_list:
         spin_lock_irqsave(&gpio_lock, flags);
         list_del(&gdev->list);
         spin_unlock_irqrestore(&gpio_lock, flags);
+err_free_label:
+        kfree(gdev->label);
+err_free_descs:
+        kfree(gdev->descs);
 err_free_gdev:
         ida_simple_remove(&gpio_ida, gdev->id);
         /* failures here can mean systems won't boot... */
@@ -2231,9 +2269,11 @@ static struct gpio_desc *of_find_gpio(struct device *dev, const char *con_id,
         return desc;
 }
 
-static struct gpio_desc *acpi_find_gpio(struct device *dev, const char *con_id,
+static struct gpio_desc *acpi_find_gpio(struct device *dev,
+                                        const char *con_id,
                                         unsigned int idx,
-                                        enum gpio_lookup_flags *flags)
+                                        enum gpiod_flags flags,
+                                        enum gpio_lookup_flags *lookupflags)
 {
         struct acpi_device *adev = ACPI_COMPANION(dev);
         struct acpi_gpio_info info;
@@ -2264,10 +2304,16 @@ static struct gpio_desc *acpi_find_gpio(struct device *dev, const char *con_id,
                 desc = acpi_get_gpiod_by_index(adev, NULL, idx, &info);
                 if (IS_ERR(desc))
                         return desc;
+
+                if ((flags == GPIOD_OUT_LOW || flags == GPIOD_OUT_HIGH) &&
+                    info.gpioint) {
+                        dev_dbg(dev, "refusing GpioInt() entry when doing GPIOD_OUT_* lookup\n");
+                        return ERR_PTR(-ENOENT);
+                }
         }
 
         if (info.polarity == GPIO_ACTIVE_LOW)
-                *flags |= GPIO_ACTIVE_LOW;
+                *lookupflags |= GPIO_ACTIVE_LOW;
 
         return desc;
 }
@@ -2530,7 +2576,7 @@ struct gpio_desc *__must_check gpiod_get_index(struct device *dev,
                         desc = of_find_gpio(dev, con_id, idx, &lookupflags);
                 } else if (ACPI_COMPANION(dev)) {
                         dev_dbg(dev, "using ACPI for GPIO lookup\n");
-                        desc = acpi_find_gpio(dev, con_id, idx, &lookupflags);
+                        desc = acpi_find_gpio(dev, con_id, idx, flags, &lookupflags);
                 }
         }
 
@@ -2829,6 +2875,9 @@ static int __init gpiolib_dev_init(void)
         if (ret < 0) {
                 pr_err("gpiolib: failed to allocate char dev region\n");
                 bus_unregister(&gpio_bus_type);
+        } else {
+                gpiolib_initialized = true;
+                gpiochip_setup_devs();
         }
         return ret;
 }
diff --git a/drivers/gpu/drm/amd/acp/Kconfig b/drivers/gpu/drm/amd/acp/Kconfig
index 0f734ee05274..ca77ec10147c 100644
--- a/drivers/gpu/drm/amd/acp/Kconfig
+++ b/drivers/gpu/drm/amd/acp/Kconfig
@@ -1,10 +1,14 @@
-menu "ACP Configuration"
+menu "ACP (Audio CoProcessor) Configuration"
 
 config DRM_AMD_ACP
-       bool "Enable ACP IP support"
+       bool "Enable AMD Audio CoProcessor IP support"
        select MFD_CORE
        select PM_GENERIC_DOMAINS if PM
        help
         Choose this option to enable ACP IP support for AMD SOCs.
+        This adds the ACP (Audio CoProcessor) IP driver and wires
+        it up into the amdgpu driver.  The ACP block provides the DMA
+        engine for the i2s-based ALSA driver. It is required for audio
+        on APUs which utilize an i2s codec.
 
 endmenu
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu.h b/drivers/gpu/drm/amd/amdgpu/amdgpu.h
index c4a21c6428f5..1bcbade479dc 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu.h
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu.h
@@ -1591,6 +1591,8 @@ struct amdgpu_uvd {
         struct amdgpu_bo        *vcpu_bo;
         void                    *cpu_addr;
         uint64_t                gpu_addr;
+        unsigned                fw_version;
+        void                    *saved_bo;
         atomic_t                handles[AMDGPU_MAX_UVD_HANDLES];
         struct drm_file         *filp[AMDGPU_MAX_UVD_HANDLES];
         struct delayed_work     idle_work;
@@ -2033,6 +2035,7 @@ struct amdgpu_device {
 
         /* tracking pinned memory */
         u64 vram_pin_size;
+        u64 invisible_pin_size;
         u64 gart_pin_size;
 
         /* amdkfd interface */
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_acp.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_acp.c
index d6b0bff510aa..b7b583c42ea8 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_acp.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_acp.c
@@ -425,6 +425,10 @@ static int acp_resume(void *handle)
         struct acp_pm_domain *apd;
         struct amdgpu_device *adev = (struct amdgpu_device *)handle;
 
+        /* return early if no ACP */
+        if (!adev->acp.acp_genpd)
+                return 0;
+
         /* SMU block will power on ACP irrespective of ACP runtime status.
          * Power off explicitly based on genpd ACP runtime status so that ACP
          * hw and ACP-genpd status are in sync.
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_atpx_handler.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_atpx_handler.c
index 0020a0ea43ff..35a1248aaa77 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_atpx_handler.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_atpx_handler.c
@@ -63,10 +63,6 @@ bool amdgpu_has_atpx(void) {
         return amdgpu_atpx_priv.atpx_detected;
 }
 
-bool amdgpu_has_atpx_dgpu_power_cntl(void) {
-        return amdgpu_atpx_priv.atpx.functions.power_cntl;
-}
-
 /**
  * amdgpu_atpx_call - call an ATPX method
  *
@@ -146,6 +142,13 @@ static void amdgpu_atpx_parse_functions(struct amdgpu_atpx_functions *f, u32 mas
  */
 static int amdgpu_atpx_validate(struct amdgpu_atpx *atpx)
 {
+        /* make sure required functions are enabled */
+        /* dGPU power control is required */
+        if (atpx->functions.power_cntl == false) {
+                printk("ATPX dGPU power cntl not present, forcing\n");
+                atpx->functions.power_cntl = true;
+        }
+
         if (atpx->functions.px_params) {
                 union acpi_object *info;
                 struct atpx_px_params output;
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_cgs.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_cgs.c
index 7a4b101e10c6..6043dc7c3a94 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_cgs.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_cgs.c
@@ -816,10 +816,13 @@ static int amdgpu_cgs_get_active_displays_info(void *cgs_device,
         struct drm_device *ddev = adev->ddev;
         struct drm_crtc *crtc;
         uint32_t line_time_us, vblank_lines;
+        struct cgs_mode_info *mode_info;
 
         if (info == NULL)
                 return -EINVAL;
 
+        mode_info = info->mode_info;
+
         if (adev->mode_info.num_crtc && adev->mode_info.mode_config_initialized) {
                 list_for_each_entry(crtc,
                                 &ddev->mode_config.crtc_list, head) {
@@ -828,7 +831,7 @@ static int amdgpu_cgs_get_active_displays_info(void *cgs_device,
                                 info->active_display_mask |= (1 << amdgpu_crtc->crtc_id);
                                 info->display_count++;
                         }
-                        if (info->mode_info != NULL &&
+                        if (mode_info != NULL &&
                                 crtc->enabled && amdgpu_crtc->enabled &&
                                 amdgpu_crtc->hw_mode.clock) {
                                 line_time_us = (amdgpu_crtc->hw_mode.crtc_htotal * 1000) /
@@ -836,10 +839,10 @@ static int amdgpu_cgs_get_active_displays_info(void *cgs_device,
                                 vblank_lines = amdgpu_crtc->hw_mode.crtc_vblank_end -
                                                         amdgpu_crtc->hw_mode.crtc_vdisplay +
                                                         (amdgpu_crtc->v_border * 2);
-                                info->mode_info->vblank_time_us = vblank_lines * line_time_us;
-                                info->mode_info->refresh_rate = drm_mode_vrefresh(&amdgpu_crtc->hw_mode);
-                                info->mode_info->ref_clock = adev->clock.spll.reference_freq;
-                                info->mode_info++;
+                                mode_info->vblank_time_us = vblank_lines * line_time_us;
+                                mode_info->refresh_rate = drm_mode_vrefresh(&amdgpu_crtc->hw_mode);
+                                mode_info->ref_clock = adev->clock.spll.reference_freq;
+                                mode_info = NULL;
                         }
                 }
         }
@@ -847,6 +850,16 @@ static int amdgpu_cgs_get_active_displays_info(void *cgs_device,
         return 0;
 }
 
+
+static int amdgpu_cgs_notify_dpm_enabled(void *cgs_device, bool enabled)
+{
+        CGS_FUNC_ADEV;
+
+        adev->pm.dpm_enabled = enabled;
+
+        return 0;
+}
+
 /** \brief evaluate acpi namespace object, handle or pathname must be valid
  *  \param cgs_device
  *  \param info input/output arguments for the control method
@@ -1097,6 +1110,7 @@ static const struct cgs_ops amdgpu_cgs_ops = {
         amdgpu_cgs_set_powergating_state,
         amdgpu_cgs_set_clockgating_state,
         amdgpu_cgs_get_active_displays_info,
+        amdgpu_cgs_notify_dpm_enabled,
         amdgpu_cgs_call_acpi_method,
         amdgpu_cgs_query_system_info,
 };
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c
index 612117478b57..2139da773da6 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_device.c
@@ -62,12 +62,6 @@ static const char *amdgpu_asic_name[] = {
         "LAST",
 };
 
-#if defined(CONFIG_VGA_SWITCHEROO)
-bool amdgpu_has_atpx_dgpu_power_cntl(void);
-#else
-static inline bool amdgpu_has_atpx_dgpu_power_cntl(void) { return false; }
-#endif
-
 bool amdgpu_device_is_px(struct drm_device *dev)
 {
         struct amdgpu_device *adev = dev->dev_private;
@@ -1485,7 +1479,7 @@ int amdgpu_device_init(struct amdgpu_device *adev,
 
         if (amdgpu_runtime_pm == 1)
                 runtime = true;
-        if (amdgpu_device_is_px(ddev) && amdgpu_has_atpx_dgpu_power_cntl())
+        if (amdgpu_device_is_px(ddev))
                 runtime = true;
         vga_switcheroo_register_client(adev->pdev, &amdgpu_switcheroo_ops, runtime);
         if (runtime)
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_display.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_display.c
index f0ed974bd4e0..3fb405b3a614 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_display.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_display.c
@@ -57,7 +57,7 @@ static bool amdgpu_flip_handle_fence(struct amdgpu_flip_work *work,
         if (!fence_add_callback(fence, &work->cb, amdgpu_flip_callback))
                 return true;
 
-        fence_put(*f);
+        fence_put(fence);
         return false;
 }
 
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_fence.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_fence.c
index 4303b447efe8..d81f1f4883a6 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_fence.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_fence.c
@@ -121,7 +121,7 @@ int amdgpu_fence_emit(struct amdgpu_ring *ring, struct fence **f)
 {
         struct amdgpu_device *adev = ring->adev;
         struct amdgpu_fence *fence;
-        struct fence **ptr;
+        struct fence *old, **ptr;
         uint32_t seq;
 
         fence = kmem_cache_alloc(amdgpu_fence_slab, GFP_KERNEL);
@@ -141,7 +141,11 @@ int amdgpu_fence_emit(struct amdgpu_ring *ring, struct fence **f)
         /* This function can't be called concurrently anyway, otherwise
          * emitting the fence would mess up the hardware ring buffer.
          */
-        BUG_ON(rcu_dereference_protected(*ptr, 1));
+        old = rcu_dereference_protected(*ptr, 1);
+        if (old && !fence_is_signaled(old)) {
+                DRM_INFO("rcu slot is busy\n");
+                fence_wait(old, false);
+        }
 
         rcu_assign_pointer(*ptr, fence_get(&fence->base));
 
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_irq.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_irq.c
index f594cfaa97e5..762cfdb85147 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_irq.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_irq.c
@@ -219,6 +219,8 @@ int amdgpu_irq_init(struct amdgpu_device *adev)
         if (r) {
                 return r;
         }
+        adev->ddev->vblank_disable_allowed = true;
+
         /* enable msi */
         adev->irq.msi_enabled = false;
 
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_kms.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_kms.c
index 7805a8706af7..b04337de65d1 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_kms.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_kms.c
@@ -303,7 +303,7 @@ static int amdgpu_info_ioctl(struct drm_device *dev, void *data, struct drm_file
                         fw_info.feature = adev->vce.fb_version;
                         break;
                 case AMDGPU_INFO_FW_UVD:
-                        fw_info.ver = 0;
+                        fw_info.ver = adev->uvd.fw_version;
                         fw_info.feature = 0;
                         break;
                 case AMDGPU_INFO_FW_GMC:
@@ -382,8 +382,9 @@ static int amdgpu_info_ioctl(struct drm_device *dev, void *data, struct drm_file
                 struct drm_amdgpu_info_vram_gtt vram_gtt;
 
                 vram_gtt.vram_size = adev->mc.real_vram_size;
+                vram_gtt.vram_size -= adev->vram_pin_size;
                 vram_gtt.vram_cpu_accessible_size = adev->mc.visible_vram_size;
-                vram_gtt.vram_cpu_accessible_size -= adev->vram_pin_size;
+                vram_gtt.vram_cpu_accessible_size -= (adev->vram_pin_size - adev->invisible_pin_size);
                 vram_gtt.gtt_size  = adev->mc.gtt_size;
                 vram_gtt.gtt_size -= adev->gart_pin_size;
                 return copy_to_user(out, &vram_gtt,
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_mode.h b/drivers/gpu/drm/amd/amdgpu/amdgpu_mode.h
index 8d432e6901af..81bd964d3dfc 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_mode.h
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_mode.h
@@ -53,7 +53,7 @@ struct amdgpu_hpd;
 
 #define AMDGPU_MAX_HPD_PINS 6
 #define AMDGPU_MAX_CRTCS 6
-#define AMDGPU_MAX_AFMT_BLOCKS 7
+#define AMDGPU_MAX_AFMT_BLOCKS 9
 
 enum amdgpu_rmx_type {
         RMX_OFF,
@@ -309,8 +309,8 @@ struct amdgpu_mode_info {
         struct atom_context *atom_context;
         struct card_info *atom_card_info;
         bool mode_config_initialized;
-        struct amdgpu_crtc *crtcs[6];
-        struct amdgpu_afmt *afmt[7];
+        struct amdgpu_crtc *crtcs[AMDGPU_MAX_CRTCS];
+        struct amdgpu_afmt *afmt[AMDGPU_MAX_AFMT_BLOCKS];
         /* DVI-I properties */
         struct drm_property *coherent_mode_property;
         /* DAC enable load detect */
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_object.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_object.c
index 151a2d42c639..7ecea83ce453 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_object.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_object.c
@@ -424,9 +424,11 @@ int amdgpu_bo_pin_restricted(struct amdgpu_bo *bo, u32 domain,
                 bo->pin_count = 1;
                 if (gpu_addr != NULL)
                         *gpu_addr = amdgpu_bo_gpu_offset(bo);
-                if (domain == AMDGPU_GEM_DOMAIN_VRAM)
+                if (domain == AMDGPU_GEM_DOMAIN_VRAM) {
                         bo->adev->vram_pin_size += amdgpu_bo_size(bo);
-                else
+                        if (bo->flags & AMDGPU_GEM_CREATE_NO_CPU_ACCESS)
+                                bo->adev->invisible_pin_size += amdgpu_bo_size(bo);
+                } else
                         bo->adev->gart_pin_size += amdgpu_bo_size(bo);
         } else {
                 dev_err(bo->adev->dev, "%p pin failed\n", bo);
@@ -456,9 +458,11 @@ int amdgpu_bo_unpin(struct amdgpu_bo *bo)
         }
         r = ttm_bo_validate(&bo->tbo, &bo->placement, false, false);
         if (likely(r == 0)) {
-                if (bo->tbo.mem.mem_type == TTM_PL_VRAM)
+                if (bo->tbo.mem.mem_type == TTM_PL_VRAM) {
                         bo->adev->vram_pin_size -= amdgpu_bo_size(bo);
-                else
+                        if (bo->flags & AMDGPU_GEM_CREATE_NO_CPU_ACCESS)
+                                bo->adev->invisible_pin_size -= amdgpu_bo_size(bo);
+                } else
                         bo->adev->gart_pin_size -= amdgpu_bo_size(bo);
         } else {
                 dev_err(bo->adev->dev, "%p validate failed for unpin\n", bo);
@@ -476,6 +480,17 @@ int amdgpu_bo_evict_vram(struct amdgpu_device *adev)
         return ttm_bo_evict_mm(&adev->mman.bdev, TTM_PL_VRAM);
 }
 
+static const char *amdgpu_vram_names[] = {
+        "UNKNOWN",
+        "GDDR1",
+        "DDR2",
+        "GDDR3",
+        "GDDR4",
+        "GDDR5",
+        "HBM",
+        "DDR3"
+};
+
 int amdgpu_bo_init(struct amdgpu_device *adev)
 {
         /* Add an MTRR for the VRAM */
@@ -484,8 +499,8 @@ int amdgpu_bo_init(struct amdgpu_device *adev)
         DRM_INFO("Detected VRAM RAM=%lluM, BAR=%lluM\n",
                 adev->mc.mc_vram_size >> 20,
                 (unsigned long long)adev->mc.aper_size >> 20);
-        DRM_INFO("RAM width %dbits DDR\n",
-                        adev->mc.vram_width);
+        DRM_INFO("RAM width %dbits %s\n",
+                 adev->mc.vram_width, amdgpu_vram_names[adev->mc.vram_type]);
         return amdgpu_ttm_init(adev);
 }
 
@@ -526,6 +541,7 @@ int amdgpu_bo_set_metadata (struct amdgpu_bo *bo, void *metadata,
         if (!metadata_size) {
                 if (bo->metadata_size) {
                         kfree(bo->metadata);
+                        bo->metadata = NULL;
                         bo->metadata_size = 0;
                 }
                 return 0;
@@ -608,6 +624,10 @@ int amdgpu_bo_fault_reserve_notify(struct ttm_buffer_object *bo)
         if ((offset + size) <= adev->mc.visible_vram_size)
                 return 0;
 
+        /* Can't move a pinned BO to visible VRAM */
+        if (abo->pin_count > 0)
+                return -EINVAL;
+
         /* hurrah the memory is not visible ! */
         amdgpu_ttm_placement_from_domain(abo, AMDGPU_GEM_DOMAIN_VRAM);
         lpfn =  adev->mc.visible_vram_size >> PAGE_SHIFT;
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_powerplay.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_powerplay.c
index 3cb6d6c413c7..e9c6ae6ed2f7 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_powerplay.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_powerplay.c
@@ -143,7 +143,7 @@ static int amdgpu_pp_late_init(void *handle)
                                         adev->powerplay.pp_handle);
 
 #ifdef CONFIG_DRM_AMD_POWERPLAY
-        if (adev->pp_enabled) {
+        if (adev->pp_enabled && adev->pm.dpm_enabled) {
                 amdgpu_pm_sysfs_init(adev);
                 amdgpu_dpm_dispatch_task(adev, AMD_PP_EVENT_COMPLETE_INIT, NULL, NULL);
         }
@@ -161,12 +161,8 @@ static int amdgpu_pp_sw_init(void *handle)
                                         adev->powerplay.pp_handle);
 
 #ifdef CONFIG_DRM_AMD_POWERPLAY
-        if (adev->pp_enabled) {
-                if (amdgpu_dpm == 0)
-                        adev->pm.dpm_enabled = false;
-                else
-                        adev->pm.dpm_enabled = true;
-        }
+        if (adev->pp_enabled)
+                adev->pm.dpm_enabled = true;
 #endif
 
         return ret;
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c
index ab34190859a8..11af4492b4be 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_ttm.c
@@ -223,6 +223,8 @@ static int amdgpu_verify_access(struct ttm_buffer_object *bo, struct file *filp)
 {
         struct amdgpu_bo *rbo = container_of(bo, struct amdgpu_bo, tbo);
 
+        if (amdgpu_ttm_tt_get_usermm(bo->ttm))
+                return -EPERM;
         return drm_vma_node_verify_access(&rbo->gem_base.vma_node, filp);
 }
 
@@ -384,9 +386,15 @@ static int amdgpu_bo_move(struct ttm_buffer_object *bo,
                         struct ttm_mem_reg *new_mem)
 {
         struct amdgpu_device *adev;
+        struct amdgpu_bo *abo;
         struct ttm_mem_reg *old_mem = &bo->mem;
         int r;
 
+        /* Can't move a pinned BO */
+        abo = container_of(bo, struct amdgpu_bo, tbo);
+        if (WARN_ON_ONCE(abo->pin_count > 0))
+                return -EINVAL;
+
         adev = amdgpu_get_adev(bo->bdev);
         if (old_mem->mem_type == TTM_PL_SYSTEM && bo->ttm == NULL) {
                 amdgpu_move_null(bo, new_mem);
@@ -616,7 +624,7 @@ static void amdgpu_ttm_tt_unpin_userptr(struct ttm_tt *ttm)
                         set_page_dirty(page);
 
                 mark_page_accessed(page);
-                page_cache_release(page);
+                put_page(page);
         }
 
         sg_free_table(ttm->sg);
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_uvd.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_uvd.c
index c1a581044417..871018c634e0 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_uvd.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_uvd.c
@@ -158,6 +158,9 @@ int amdgpu_uvd_sw_init(struct amdgpu_device *adev)
         DRM_INFO("Found UVD firmware Version: %hu.%hu Family ID: %hu\n",
                 version_major, version_minor, family_id);
 
+        adev->uvd.fw_version = ((version_major << 24) | (version_minor << 16) |
+                                (family_id << 8));
+
         bo_size = AMDGPU_GPU_PAGE_ALIGN(le32_to_cpu(hdr->ucode_size_bytes) + 8)
                  +  AMDGPU_UVD_STACK_SIZE + AMDGPU_UVD_HEAP_SIZE;
         r = amdgpu_bo_create(adev, bo_size, PAGE_SIZE, true,
@@ -241,32 +244,30 @@ int amdgpu_uvd_sw_fini(struct amdgpu_device *adev)
 
 int amdgpu_uvd_suspend(struct amdgpu_device *adev)
 {
-        struct amdgpu_ring *ring = &adev->uvd.ring;
-        int i, r;
+        unsigned size;
+        void *ptr;
+        int i;
 
         if (adev->uvd.vcpu_bo == NULL)
                 return 0;
 
-        for (i = 0; i < AMDGPU_MAX_UVD_HANDLES; ++i) {
-                uint32_t handle = atomic_read(&adev->uvd.handles[i]);
-                if (handle != 0) {
-                        struct fence *fence;
+        for (i = 0; i < AMDGPU_MAX_UVD_HANDLES; ++i)
+                if (atomic_read(&adev->uvd.handles[i]))
+                        break;
 
-                        amdgpu_uvd_note_usage(adev);
+        if (i == AMDGPU_MAX_UVD_HANDLES)
+                return 0;
 
-                        r = amdgpu_uvd_get_destroy_msg(ring, handle, false, &fence);
-                        if (r) {
-                                DRM_ERROR("Error destroying UVD (%d)!\n", r);
-                                continue;
-                        }
+        cancel_delayed_work_sync(&adev->uvd.idle_work);
 
-                        fence_wait(fence, false);
-                        fence_put(fence);
+        size = amdgpu_bo_size(adev->uvd.vcpu_bo);
+        ptr = adev->uvd.cpu_addr;
 
-                        adev->uvd.filp[i] = NULL;
-                        atomic_set(&adev->uvd.handles[i], 0);
-                }
-        }
+        adev->uvd.saved_bo = kmalloc(size, GFP_KERNEL);
+        if (!adev->uvd.saved_bo)
+                return -ENOMEM;
+
+        memcpy(adev->uvd.saved_bo, ptr, size);
 
         return 0;
 }
@@ -275,23 +276,29 @@ int amdgpu_uvd_resume(struct amdgpu_device *adev)
 {
         unsigned size;
         void *ptr;
-        const struct common_firmware_header *hdr;
-        unsigned offset;
 
         if (adev->uvd.vcpu_bo == NULL)
                 return -EINVAL;
 
-        hdr = (const struct common_firmware_header *)adev->uvd.fw->data;
-        offset = le32_to_cpu(hdr->ucode_array_offset_bytes);
-        memcpy(adev->uvd.cpu_addr, (adev->uvd.fw->data) + offset,
-                (adev->uvd.fw->size) - offset);
-
         size = amdgpu_bo_size(adev->uvd.vcpu_bo);
-        size -= le32_to_cpu(hdr->ucode_size_bytes);
         ptr = adev->uvd.cpu_addr;
-        ptr += le32_to_cpu(hdr->ucode_size_bytes);
 
-        memset(ptr, 0, size);
+        if (adev->uvd.saved_bo != NULL) {
+                memcpy(ptr, adev->uvd.saved_bo, size);
+                kfree(adev->uvd.saved_bo);
+                adev->uvd.saved_bo = NULL;
+        } else {
+                const struct common_firmware_header *hdr;
+                unsigned offset;
+
+                hdr = (const struct common_firmware_header *)adev->uvd.fw->data;
+                offset = le32_to_cpu(hdr->ucode_array_offset_bytes);
+                memcpy(adev->uvd.cpu_addr, (adev->uvd.fw->data) + offset,
+                        (adev->uvd.fw->size) - offset);
+                size -= le32_to_cpu(hdr->ucode_size_bytes);
+                ptr += le32_to_cpu(hdr->ucode_size_bytes);
+                memset(ptr, 0, size);
+        }
 
         return 0;
 }
diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_vce.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_vce.c
index 4bec0c108cea..481a64fa9b47 100644
--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_vce.c
+++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_vce.c
@@ -234,6 +234,7 @@ int amdgpu_vce_suspend(struct amdgpu_device *adev)
         if (i == AMDGPU_MAX_VCE_HANDLES)
                 return 0;
 
+        cancel_delayed_work_sync(&adev->vce.idle_work);
         /* TODO: suspending running encoding sessions isn't supported */
         return -EINVAL;
 }
diff --git a/drivers/gpu/drm/amd/amdgpu/atombios_encoders.c b/drivers/gpu/drm/amd/amdgpu/atombios_encoders.c
index 1e0bba29e167..1cd6de575305 100644
--- a/drivers/gpu/drm/amd/amdgpu/atombios_encoders.c
+++ b/drivers/gpu/drm/amd/amdgpu/atombios_encoders.c
@@ -298,6 +298,10 @@ bool amdgpu_atombios_encoder_mode_fixup(struct drm_encoder *encoder,
             && (mode->crtc_vsync_start < (mode->crtc_vdisplay + 2)))
                 adjusted_mode->crtc_vsync_start = adjusted_mode->crtc_vdisplay + 2;
 
+        /* vertical FP must be at least 1 */
+        if (mode->crtc_vsync_start == mode->crtc_vdisplay)
+                adjusted_mode->crtc_vsync_start++;
+
         /* get the native mode for scaling */
         if (amdgpu_encoder->active_device & (ATOM_DEVICE_LCD_SUPPORT))
                 amdgpu_panel_mode_fixup(encoder, adjusted_mode);
diff --git a/drivers/gpu/drm/amd/amdgpu/gmc_v7_0.c b/drivers/gpu/drm/amd/amdgpu/gmc_v7_0.c
index 82ce7d943884..a4a2e6cc61bb 100644
--- a/drivers/gpu/drm/amd/amdgpu/gmc_v7_0.c
+++ b/drivers/gpu/drm/amd/amdgpu/gmc_v7_0.c
@@ -903,14 +903,6 @@ static int gmc_v7_0_early_init(void *handle)
         gmc_v7_0_set_gart_funcs(adev);
         gmc_v7_0_set_irq_funcs(adev);
 
-        if (adev->flags & AMD_IS_APU) {
-                adev->mc.vram_type = AMDGPU_VRAM_TYPE_UNKNOWN;
-        } else {
-                u32 tmp = RREG32(mmMC_SEQ_MISC0);
-                tmp &= MC_SEQ_MISC0__MT__MASK;
-                adev->mc.vram_type = gmc_v7_0_convert_vram_type(tmp);
-        }
-
         return 0;
 }
 
@@ -918,7 +910,10 @@ static int gmc_v7_0_late_init(void *handle)
 {
         struct amdgpu_device *adev = (struct amdgpu_device *)handle;
 
-        return amdgpu_irq_get(adev, &adev->mc.vm_fault, 0);
+        if (amdgpu_vm_fault_stop != AMDGPU_VM_FAULT_STOP_ALWAYS)
+                return amdgpu_irq_get(adev, &adev->mc.vm_fault, 0);
+        else
+                return 0;
 }
 
 static int gmc_v7_0_sw_init(void *handle)
@@ -927,6 +922,14 @@ static int gmc_v7_0_sw_init(void *handle)
         int dma_bits;
         struct amdgpu_device *adev = (struct amdgpu_device *)handle;
 
+        if (adev->flags & AMD_IS_APU) {
+                adev->mc.vram_type = AMDGPU_VRAM_TYPE_UNKNOWN;
+        } else {
+                u32 tmp = RREG32(mmMC_SEQ_MISC0);
+                tmp &= MC_SEQ_MISC0__MT__MASK;
+                adev->mc.vram_type = gmc_v7_0_convert_vram_type(tmp);
+        }
+
         r = amdgpu_irq_add_id(adev, 146, &adev->mc.vm_fault);
         if (r)
                 return r;
diff --git a/drivers/gpu/drm/amd/amdgpu/gmc_v8_0.c b/drivers/gpu/drm/amd/amdgpu/gmc_v8_0.c
index 29bd7b57dc91..7a9db2c72c89 100644
--- a/drivers/gpu/drm/amd/amdgpu/gmc_v8_0.c
+++ b/drivers/gpu/drm/amd/amdgpu/gmc_v8_0.c
@@ -863,14 +863,6 @@ static int gmc_v8_0_early_init(void *handle)
         gmc_v8_0_set_gart_funcs(adev);
         gmc_v8_0_set_irq_funcs(adev);
 
-        if (adev->flags & AMD_IS_APU) {
-                adev->mc.vram_type = AMDGPU_VRAM_TYPE_UNKNOWN;
-        } else {
-                u32 tmp = RREG32(mmMC_SEQ_MISC0);
-                tmp &= MC_SEQ_MISC0__MT__MASK;
-                adev->mc.vram_type = gmc_v8_0_convert_vram_type(tmp);
-        }
-
         return 0;
 }
 
@@ -878,15 +870,33 @@ static int gmc_v8_0_late_init(void *handle)
 {
         struct amdgpu_device *adev = (struct amdgpu_device *)handle;
 
-        return amdgpu_irq_get(adev, &adev->mc.vm_fault, 0);
+        if (amdgpu_vm_fault_stop != AMDGPU_VM_FAULT_STOP_ALWAYS)
+                return amdgpu_irq_get(adev, &adev->mc.vm_fault, 0);
+        else
+                return 0;
 }
 
+#define mmMC_SEQ_MISC0_FIJI 0xA71
+
 static int gmc_v8_0_sw_init(void *handle)
 {
         int r;
         int dma_bits;
         struct amdgpu_device *adev = (struct amdgpu_device *)handle;
 
+        if (adev->flags & AMD_IS_APU) {
+                adev->mc.vram_type = AMDGPU_VRAM_TYPE_UNKNOWN;
+        } else {
+                u32 tmp;
+
+                if (adev->asic_type == CHIP_FIJI)
+                        tmp = RREG32(mmMC_SEQ_MISC0_FIJI);
+                else
+                        tmp = RREG32(mmMC_SEQ_MISC0);
+                tmp &= MC_SEQ_MISC0__MT__MASK;
+                adev->mc.vram_type = gmc_v8_0_convert_vram_type(tmp);
+        }
+
         r = amdgpu_irq_add_id(adev, 146, &adev->mc.vm_fault);
         if (r)
                 return r;
diff --git a/drivers/gpu/drm/amd/amdgpu/tonga_ih.c b/drivers/gpu/drm/amd/amdgpu/tonga_ih.c
index b6f7d7bff929..0f14199cf716 100644
--- a/drivers/gpu/drm/amd/amdgpu/tonga_ih.c
+++ b/drivers/gpu/drm/amd/amdgpu/tonga_ih.c
@@ -307,7 +307,7 @@ static int tonga_ih_sw_fini(void *handle)
 
         amdgpu_irq_fini(adev);
         amdgpu_ih_ring_fini(adev);
-        amdgpu_irq_add_domain(adev);
+        amdgpu_irq_remove_domain(adev);
 
         return 0;
 }
diff --git a/drivers/gpu/drm/amd/amdgpu/uvd_v4_2.c b/drivers/gpu/drm/amd/amdgpu/uvd_v4_2.c
index c606ccb38d8b..cb463753115b 100644
--- a/drivers/gpu/drm/amd/amdgpu/uvd_v4_2.c
+++ b/drivers/gpu/drm/amd/amdgpu/uvd_v4_2.c
@@ -224,11 +224,11 @@ static int uvd_v4_2_suspend(void *handle)
         int r;
         struct amdgpu_device *adev = (struct amdgpu_device *)handle;
 
-        r = amdgpu_uvd_suspend(adev);
+        r = uvd_v4_2_hw_fini(adev);
         if (r)
                 return r;
 
-        r = uvd_v4_2_hw_fini(adev);
+        r = amdgpu_uvd_suspend(adev);
         if (r)
                 return r;
 
diff --git a/drivers/gpu/drm/amd/amdgpu/uvd_v5_0.c b/drivers/gpu/drm/amd/amdgpu/uvd_v5_0.c
index e3c852d9d79a..16476d80f475 100644
--- a/drivers/gpu/drm/amd/amdgpu/uvd_v5_0.c
+++ b/drivers/gpu/drm/amd/amdgpu/uvd_v5_0.c
@@ -220,11 +220,11 @@ static int uvd_v5_0_suspend(void *handle)
         int r;
         struct amdgpu_device *adev = (struct amdgpu_device *)handle;
 
-        r = amdgpu_uvd_suspend(adev);
+        r = uvd_v5_0_hw_fini(adev);
         if (r)
                 return r;
 
-        r = uvd_v5_0_hw_fini(adev);
+        r = amdgpu_uvd_suspend(adev);
         if (r)
                 return r;
 
diff --git a/drivers/gpu/drm/amd/amdgpu/uvd_v6_0.c b/drivers/gpu/drm/amd/amdgpu/uvd_v6_0.c
index 3375e614ac67..d49379145ef2 100644
--- a/drivers/gpu/drm/amd/amdgpu/uvd_v6_0.c
+++ b/drivers/gpu/drm/amd/amdgpu/uvd_v6_0.c
@@ -214,15 +214,16 @@ static int uvd_v6_0_suspend(void *handle)
         int r;
         struct amdgpu_device *adev = (struct amdgpu_device *)handle;
 
+        r = uvd_v6_0_hw_fini(adev);
+        if (r)
+                return r;
+
         /* Skip this for APU for now */
         if (!(adev->flags & AMD_IS_APU)) {
                 r = amdgpu_uvd_suspend(adev);
                 if (r)
                         return r;
         }
-        r = uvd_v6_0_hw_fini(adev);
-        if (r)
-                return r;
 
         return r;
 }
diff --git a/drivers/gpu/drm/amd/include/cgs_common.h b/drivers/gpu/drm/amd/include/cgs_common.h
index aec38fc3834f..ab84d4947247 100644
--- a/drivers/gpu/drm/amd/include/cgs_common.h
+++ b/drivers/gpu/drm/amd/include/cgs_common.h
@@ -589,6 +589,8 @@ typedef int(*cgs_get_active_displays_info)(
                                         void *cgs_device,
                                         struct cgs_display_info *info);
 
+typedef int (*cgs_notify_dpm_enabled)(void *cgs_device, bool enabled);
+
 typedef int (*cgs_call_acpi_method)(void *cgs_device,
                                         uint32_t acpi_method,
                                         uint32_t acpi_function,
@@ -644,6 +646,8 @@ struct cgs_ops {
         cgs_set_clockgating_state set_clockgating_state;
         /* display manager */
         cgs_get_active_displays_info get_active_displays_info;
+        /* notify dpm enabled */
+        cgs_notify_dpm_enabled notify_dpm_enabled;
         /* ACPI */
         cgs_call_acpi_method call_acpi_method;
         /* get system info */
@@ -734,8 +738,12 @@ struct cgs_device
         CGS_CALL(set_powergating_state, dev, block_type, state)
 #define cgs_set_clockgating_state(dev, block_type, state)       \
         CGS_CALL(set_clockgating_state, dev, block_type, state)
+#define cgs_notify_dpm_enabled(dev, enabled)    \
+        CGS_CALL(notify_dpm_enabled, dev, enabled)
+
 #define cgs_get_active_displays_info(dev, info) \
         CGS_CALL(get_active_displays_info, dev, info)
+
 #define cgs_call_acpi_method(dev, acpi_method, acpi_function, pintput, poutput, output_count, input_size, output_size)  \
         CGS_CALL(call_acpi_method, dev, acpi_method, acpi_function, pintput, poutput, output_count, input_size, output_size)
 #define cgs_query_system_info(dev, sys_info)    \
diff --git a/drivers/gpu/drm/amd/powerplay/eventmgr/eventactionchains.c b/drivers/gpu/drm/amd/powerplay/eventmgr/eventactionchains.c
index 6b52c78cb404..56856a2864d1 100644
--- a/drivers/gpu/drm/amd/powerplay/eventmgr/eventactionchains.c
+++ b/drivers/gpu/drm/amd/powerplay/eventmgr/eventactionchains.c
@@ -137,14 +137,14 @@ static const pem_event_action *resume_event[] = {
         reset_display_configCounter_tasks,
         update_dal_configuration_tasks,
         vari_bright_resume_tasks,
-        block_adjust_power_state_tasks,
         setup_asic_tasks,
         enable_stutter_mode_tasks, /*must do this in boot state and before SMC is started */
         enable_dynamic_state_management_tasks,
         enable_clock_power_gatings_tasks,
         enable_disable_bapm_tasks,
         initialize_thermal_controller_tasks,
-        reset_boot_state_tasks,
+        get_2d_performance_state_tasks,
+        set_performance_state_tasks,
         adjust_power_state_tasks,
         enable_disable_fps_tasks,
         notify_hw_power_source_tasks,
diff --git a/drivers/gpu/drm/amd/powerplay/hwmgr/fiji_hwmgr.c b/drivers/gpu/drm/amd/powerplay/hwmgr/fiji_hwmgr.c
index 51dedf84623c..89f31bc5b68b 100644
--- a/drivers/gpu/drm/amd/powerplay/hwmgr/fiji_hwmgr.c
+++ b/drivers/gpu/drm/amd/powerplay/hwmgr/fiji_hwmgr.c
@@ -2389,6 +2389,7 @@ static int fiji_populate_smc_vce_level(struct pp_hwmgr *hwmgr,
 
         for(count = 0; count < table->VceLevelCount; count++) {
                 table->VceLevel[count].Frequency = mm_table->entries[count].eclk;
+                table->VceLevel[count].MinVoltage = 0;
                 table->VceLevel[count].MinVoltage |=
                                 (mm_table->entries[count].vddc * VOLTAGE_SCALE) << VDDC_SHIFT;
                 table->VceLevel[count].MinVoltage |=
@@ -2465,6 +2466,7 @@ static int fiji_populate_smc_samu_level(struct pp_hwmgr *hwmgr,
 
         for (count = 0; count < table->SamuLevelCount; count++) {
                 /* not sure whether we need evclk or not */
+                table->SamuLevel[count].MinVoltage = 0;
                 table->SamuLevel[count].Frequency = mm_table->entries[count].samclock;
                 table->SamuLevel[count].MinVoltage |= (mm_table->entries[count].vddc *
                                 VOLTAGE_SCALE) << VDDC_SHIFT;
@@ -2562,6 +2564,7 @@ static int fiji_populate_smc_uvd_level(struct pp_hwmgr *hwmgr,
         table->UvdBootLevel = 0;
 
         for (count = 0; count < table->UvdLevelCount; count++) {
+                table->UvdLevel[count].MinVoltage = 0;
                 table->UvdLevel[count].VclkFrequency = mm_table->entries[count].vclk;
                 table->UvdLevel[count].DclkFrequency = mm_table->entries[count].dclk;
                 table->UvdLevel[count].MinVoltage |= (mm_table->entries[count].vddc *
@@ -2900,6 +2903,8 @@ static int fiji_init_smc_table(struct pp_hwmgr *hwmgr)
         if(FIJI_VOLTAGE_CONTROL_NONE != data->voltage_control)
                 fiji_populate_smc_voltage_tables(hwmgr, table);
 
+        table->SystemFlags = 0;
+
         if (phm_cap_enabled(hwmgr->platform_descriptor.platformCaps,
                         PHM_PlatformCaps_AutomaticDCTransition))
                 table->SystemFlags |= PPSMC_SYSTEMFLAG_GPIO_DC;
@@ -2997,6 +3002,7 @@ static int fiji_init_smc_table(struct pp_hwmgr *hwmgr)
         table->MemoryThermThrottleEnable = 1;
         table->PCIeBootLinkLevel = 0;      /* 0:Gen1 1:Gen2 2:Gen3*/
         table->PCIeGenInterval = 1;
+        table->VRConfig = 0;
 
         result = fiji_populate_vr_config(hwmgr, table);
         PP_ASSERT_WITH_CODE(0 == result,
@@ -5195,6 +5201,67 @@ static int fiji_print_clock_levels(struct pp_hwmgr *hwmgr,
         return size;
 }
 
+static inline bool fiji_are_power_levels_equal(const struct fiji_performance_level *pl1,
+                                                           const struct fiji_performance_level *pl2)
+{
+        return ((pl1->memory_clock == pl2->memory_clock) &&
+                  (pl1->engine_clock == pl2->engine_clock) &&
+                  (pl1->pcie_gen == pl2->pcie_gen) &&
+                  (pl1->pcie_lane == pl2->pcie_lane));
+}
+
+int fiji_check_states_equal(struct pp_hwmgr *hwmgr, const struct pp_hw_power_state *pstate1, const struct pp_hw_power_state *pstate2, bool *equal)
+{
+        const struct fiji_power_state *psa = cast_const_phw_fiji_power_state(pstate1);
+        const struct fiji_power_state *psb = cast_const_phw_fiji_power_state(pstate2);
+        int i;
+
+        if (equal == NULL || psa == NULL || psb == NULL)
+                return -EINVAL;
+
+        /* If the two states don't even have the same number of performance levels they cannot be the same state. */
+        if (psa->performance_level_count != psb->performance_level_count) {
+                *equal = false;
+                return 0;
+        }
+
+        for (i = 0; i < psa->performance_level_count; i++) {
+                if (!fiji_are_power_levels_equal(&(psa->performance_levels[i]), &(psb->performance_levels[i]))) {
+                        /* If we have found even one performance level pair that is different the states are different. */
+                        *equal = false;
+                        return 0;
+                }
+        }
+
+        /* If all performance levels are the same try to use the UVD clocks to break the tie.*/
+        *equal = ((psa->uvd_clks.vclk == psb->uvd_clks.vclk) && (psa->uvd_clks.dclk == psb->uvd_clks.dclk));
+        *equal &= ((psa->vce_clks.evclk == psb->vce_clks.evclk) && (psa->vce_clks.ecclk == psb->vce_clks.ecclk));
+        *equal &= (psa->sclk_threshold == psb->sclk_threshold);
+        *equal &= (psa->acp_clk == psb->acp_clk);
+
+        return 0;
+}
+
+bool fiji_check_smc_update_required_for_display_configuration(struct pp_hwmgr *hwmgr)
+{
+        struct fiji_hwmgr *data = (struct fiji_hwmgr *)(hwmgr->backend);
+        bool is_update_required = false;
+        struct cgs_display_info info = {0,0,NULL};
+
+        cgs_get_active_displays_info(hwmgr->device, &info);
+
+        if (data->display_timing.num_existing_displays != info.display_count)
+                is_update_required = true;
+/* TO DO NEED TO GET DEEP SLEEP CLOCK FROM DAL
+        if (phm_cap_enabled(hwmgr->hwmgr->platform_descriptor.platformCaps, PHM_PlatformCaps_SclkDeepSleep)) {
+                cgs_get_min_clock_settings(hwmgr->device, &min_clocks);
+                if(min_clocks.engineClockInSR != data->display_timing.minClockInSR)
+                        is_update_required = true;
+*/
+        return is_update_required;
+}
+
+
 static const struct pp_hwmgr_func fiji_hwmgr_funcs = {
         .backend_init = &fiji_hwmgr_backend_init,
         .backend_fini = &tonga_hwmgr_backend_fini,
@@ -5230,6 +5297,8 @@ static const struct pp_hwmgr_func fiji_hwmgr_funcs = {
         .register_internal_thermal_interrupt = fiji_register_internal_thermal_interrupt,
         .set_fan_control_mode = fiji_set_fan_control_mode,
         .get_fan_control_mode = fiji_get_fan_control_mode,
+        .check_states_equal = fiji_check_states_equal,
+        .check_smc_update_required_for_display_configuration = fiji_check_smc_update_required_for_display_configuration,
         .get_pp_table = fiji_get_pp_table,
         .set_pp_table = fiji_set_pp_table,
         .force_clock_level = fiji_force_clock_level,
diff --git a/drivers/gpu/drm/amd/powerplay/hwmgr/hardwaremanager.c b/drivers/gpu/drm/amd/powerplay/hwmgr/hardwaremanager.c
index be31bed2538a..fa208ada6892 100644
--- a/drivers/gpu/drm/amd/powerplay/hwmgr/hardwaremanager.c
+++ b/drivers/gpu/drm/amd/powerplay/hwmgr/hardwaremanager.c
@@ -58,6 +58,9 @@ void phm_init_dynamic_caps(struct pp_hwmgr *hwmgr)
 
         phm_cap_unset(hwmgr->platform_descriptor.platformCaps, PHM_PlatformCaps_VpuRecoveryInProgress);
 
+        phm_cap_set(hwmgr->platform_descriptor.platformCaps, PHM_PlatformCaps_UVDDPM);
+        phm_cap_set(hwmgr->platform_descriptor.platformCaps, PHM_PlatformCaps_VCEDPM);
+
         if (acpi_atcs_functions_supported(hwmgr->device, ATCS_FUNCTION_PCIE_PERFORMANCE_REQUEST) &&
                 acpi_atcs_functions_supported(hwmgr->device, ATCS_FUNCTION_PCIE_DEVICE_READY_NOTIFICATION))
                 phm_cap_set(hwmgr->platform_descriptor.platformCaps, PHM_PlatformCaps_PCIEPerformanceRequest);
@@ -130,18 +133,25 @@ int phm_set_power_state(struct pp_hwmgr *hwmgr,
 
 int phm_enable_dynamic_state_management(struct pp_hwmgr *hwmgr)
 {
+        int ret = 1;
+        bool enabled;
         PHM_FUNC_CHECK(hwmgr);
 
         if (phm_cap_enabled(hwmgr->platform_descriptor.platformCaps,
                 PHM_PlatformCaps_TablelessHardwareInterface)) {
                 if (NULL != hwmgr->hwmgr_func->dynamic_state_management_enable)
-                        return hwmgr->hwmgr_func->dynamic_state_management_enable(hwmgr);
+                        ret = hwmgr->hwmgr_func->dynamic_state_management_enable(hwmgr);
         } else {
-                return phm_dispatch_table(hwmgr,
+                ret = phm_dispatch_table(hwmgr,
                                 &(hwmgr->enable_dynamic_state_management),
                                 NULL, NULL);
         }
-        return 0;
+
+        enabled = ret == 0 ? true : false;
+
+        cgs_notify_dpm_enabled(hwmgr->device, enabled);
+
+        return ret;
 }
 
 int phm_force_dpm_levels(struct pp_hwmgr *hwmgr, enum amd_dpm_forced_level level)
diff --git a/drivers/gpu/drm/arm/hdlcd_drv.c b/drivers/gpu/drm/arm/hdlcd_drv.c
index 56b829f97699..3ac1ae4d8caf 100644
--- a/drivers/gpu/drm/arm/hdlcd_drv.c
+++ b/drivers/gpu/drm/arm/hdlcd_drv.c
@@ -57,14 +57,13 @@ static int hdlcd_load(struct drm_device *drm, unsigned long flags)
                 DRM_ERROR("failed to map control registers area\n");
                 ret = PTR_ERR(hdlcd->mmio);
                 hdlcd->mmio = NULL;
-                goto fail;
+                return ret;
         }
 
         version = hdlcd_read(hdlcd, HDLCD_REG_VERSION);
         if ((version & HDLCD_PRODUCT_MASK) != HDLCD_PRODUCT_ID) {
                 DRM_ERROR("unknown product id: 0x%x\n", version);
-                ret = -EINVAL;
-                goto fail;
+                return -EINVAL;
         }
         DRM_INFO("found ARM HDLCD version r%dp%d\n",
                 (version & HDLCD_VERSION_MAJOR_MASK) >> 8,
@@ -73,7 +72,7 @@ static int hdlcd_load(struct drm_device *drm, unsigned long flags)
         /* Get the optional framebuffer memory resource */
         ret = of_reserved_mem_device_init(drm->dev);
         if (ret && ret != -ENODEV)
-                goto fail;
+                return ret;
 
         ret = dma_set_mask_and_coherent(drm->dev, DMA_BIT_MASK(32));
         if (ret)
@@ -101,8 +100,6 @@ irq_fail:
         drm_crtc_cleanup(&hdlcd->crtc);
 setup_fail:
         of_reserved_mem_device_release(drm->dev);
-fail:
-        devm_clk_put(drm->dev, hdlcd->clk);
 
         return ret;
 }
@@ -412,7 +409,6 @@ err_unload:
         pm_runtime_put_sync(drm->dev);
         pm_runtime_disable(drm->dev);
         of_reserved_mem_device_release(drm->dev);
-        devm_clk_put(dev, hdlcd->clk);
 err_free:
         drm_dev_unref(drm);
 
@@ -436,10 +432,6 @@ static void hdlcd_drm_unbind(struct device *dev)
         pm_runtime_put_sync(drm->dev);
         pm_runtime_disable(drm->dev);
         of_reserved_mem_device_release(drm->dev);
-        if (!IS_ERR(hdlcd->clk)) {
-                devm_clk_put(drm->dev, hdlcd->clk);
-                hdlcd->clk = NULL;
-        }
         drm_mode_config_cleanup(drm);
         drm_dev_unregister(drm);
         drm_dev_unref(drm);
diff --git a/drivers/gpu/drm/armada/armada_gem.c b/drivers/gpu/drm/armada/armada_gem.c
index 6e731db31aa4..aca7f9cc6109 100644
--- a/drivers/gpu/drm/armada/armada_gem.c
+++ b/drivers/gpu/drm/armada/armada_gem.c
@@ -481,7 +481,7 @@ armada_gem_prime_map_dma_buf(struct dma_buf_attachment *attach,
 
  release:
         for_each_sg(sgt->sgl, sg, num, i)
-                page_cache_release(sg_page(sg));
+                put_page(sg_page(sg));
  free_table:
         sg_free_table(sgt);
  free_sgt:
@@ -502,7 +502,7 @@ static void armada_gem_prime_unmap_dma_buf(struct dma_buf_attachment *attach,
         if (dobj->obj.filp) {
                 struct scatterlist *sg;
                 for_each_sg(sgt->sgl, sg, sgt->nents, i)
-                        page_cache_release(sg_page(sg));
+                        put_page(sg_page(sg));
         }
 
         sg_free_table(sgt);
diff --git a/drivers/gpu/drm/drm_dp_helper.c b/drivers/gpu/drm/drm_dp_helper.c
index 7d58f594cffe..df64ed1c0139 100644
--- a/drivers/gpu/drm/drm_dp_helper.c
+++ b/drivers/gpu/drm/drm_dp_helper.c
@@ -179,7 +179,7 @@ static int drm_dp_dpcd_access(struct drm_dp_aux *aux, u8 request,
 {
         struct drm_dp_aux_msg msg;
         unsigned int retry;
-        int err;
+        int err = 0;
 
         memset(&msg, 0, sizeof(msg));
         msg.address = offset;
@@ -187,6 +187,8 @@ static int drm_dp_dpcd_access(struct drm_dp_aux *aux, u8 request,
         msg.buffer = buffer;
         msg.size = size;
 
+        mutex_lock(&aux->hw_mutex);
+
         /*
          * The specification doesn't give any recommendation on how often to
          * retry native transactions. We used to retry 7 times like for
@@ -195,25 +197,24 @@ static int drm_dp_dpcd_access(struct drm_dp_aux *aux, u8 request,
          */
         for (retry = 0; retry < 32; retry++) {
 
-                mutex_lock(&aux->hw_mutex);
                 err = aux->transfer(aux, &msg);
-                mutex_unlock(&aux->hw_mutex);
                 if (err < 0) {
                         if (err == -EBUSY)
                                 continue;
 
-                        return err;
+                        goto unlock;
                 }
 
 
                 switch (msg.reply & DP_AUX_NATIVE_REPLY_MASK) {
                 case DP_AUX_NATIVE_REPLY_ACK:
                         if (err < size)
-                                return -EPROTO;
-                        return err;
+                                err = -EPROTO;
+                        goto unlock;
 
                 case DP_AUX_NATIVE_REPLY_NACK:
-                        return -EIO;
+                        err = -EIO;
+                        goto unlock;
 
                 case DP_AUX_NATIVE_REPLY_DEFER:
                         usleep_range(AUX_RETRY_INTERVAL, AUX_RETRY_INTERVAL + 100);
@@ -222,7 +223,11 @@ static int drm_dp_dpcd_access(struct drm_dp_aux *aux, u8 request,
         }
 
         DRM_DEBUG_KMS("too many retries, giving up\n");
-        return -EIO;
+        err = -EIO;
+
+unlock:
+        mutex_unlock(&aux->hw_mutex);
+        return err;
 }
 
 /**
@@ -544,9 +549,7 @@ static int drm_dp_i2c_do_msg(struct drm_dp_aux *aux, struct drm_dp_aux_msg *msg)
         int max_retries = max(7, drm_dp_i2c_retry_count(msg, dp_aux_i2c_speed_khz));
 
         for (retry = 0, defer_i2c = 0; retry < (max_retries + defer_i2c); retry++) {
-                mutex_lock(&aux->hw_mutex);
                 ret = aux->transfer(aux, msg);
-                mutex_unlock(&aux->hw_mutex);
                 if (ret < 0) {
                         if (ret == -EBUSY)
                                 continue;
@@ -685,6 +688,8 @@ static int drm_dp_i2c_xfer(struct i2c_adapter *adapter, struct i2c_msg *msgs,
 
         memset(&msg, 0, sizeof(msg));
 
+        mutex_lock(&aux->hw_mutex);
+
         for (i = 0; i < num; i++) {
                 msg.address = msgs[i].addr;
                 drm_dp_i2c_msg_set_request(&msg, &msgs[i]);
@@ -739,6 +744,8 @@ static int drm_dp_i2c_xfer(struct i2c_adapter *adapter, struct i2c_msg *msgs,
         msg.size = 0;
         (void)drm_dp_i2c_do_msg(aux, &msg);
 
+        mutex_unlock(&aux->hw_mutex);
+
         return err;
 }
 
diff --git a/drivers/gpu/drm/drm_dp_mst_topology.c b/drivers/gpu/drm/drm_dp_mst_topology.c
index 27fbd79d0daf..71ea0521ea96 100644
--- a/drivers/gpu/drm/drm_dp_mst_topology.c
+++ b/drivers/gpu/drm/drm_dp_mst_topology.c
@@ -1672,13 +1672,19 @@ static int drm_dp_payload_send_msg(struct drm_dp_mst_topology_mgr *mgr,
         u8 sinks[DRM_DP_MAX_SDP_STREAMS];
         int i;
 
+        port = drm_dp_get_validated_port_ref(mgr, port);
+        if (!port)
+                return -EINVAL;
+
         port_num = port->port_num;
         mstb = drm_dp_get_validated_mstb_ref(mgr, port->parent);
         if (!mstb) {
                 mstb = drm_dp_get_last_connected_port_and_mstb(mgr, port->parent, &port_num);
 
-                if (!mstb)
+                if (!mstb) {
+                        drm_dp_put_port(port);
                         return -EINVAL;
+                }
         }
 
         txmsg = kzalloc(sizeof(*txmsg), GFP_KERNEL);
@@ -1707,6 +1713,7 @@ static int drm_dp_payload_send_msg(struct drm_dp_mst_topology_mgr *mgr,
         kfree(txmsg);
 fail_put:
         drm_dp_put_mst_branch_device(mstb);
+        drm_dp_put_port(port);
         return ret;
 }
 
@@ -1789,6 +1796,11 @@ int drm_dp_update_payload_part1(struct drm_dp_mst_topology_mgr *mgr)
                 req_payload.start_slot = cur_slots;
                 if (mgr->proposed_vcpis[i]) {
                         port = container_of(mgr->proposed_vcpis[i], struct drm_dp_mst_port, vcpi);
+                        port = drm_dp_get_validated_port_ref(mgr, port);
+                        if (!port) {
+                                mutex_unlock(&mgr->payload_lock);
+                                return -EINVAL;
+                        }
                         req_payload.num_slots = mgr->proposed_vcpis[i]->num_slots;
                         req_payload.vcpi = mgr->proposed_vcpis[i]->vcpi;
                 } else {
@@ -1816,6 +1828,9 @@ int drm_dp_update_payload_part1(struct drm_dp_mst_topology_mgr *mgr)
                         mgr->payloads[i].payload_state = req_payload.payload_state;
                 }
                 cur_slots += req_payload.num_slots;
+
+                if (port)
+                        drm_dp_put_port(port);
         }
 
         for (i = 0; i < mgr->max_payloads; i++) {
@@ -2121,6 +2136,8 @@ int drm_dp_mst_topology_mgr_resume(struct drm_dp_mst_topology_mgr *mgr)
 
         if (mgr->mst_primary) {
                 int sret;
+                u8 guid[16];
+
                 sret = drm_dp_dpcd_read(mgr->aux, DP_DPCD_REV, mgr->dpcd, DP_RECEIVER_CAP_SIZE);
                 if (sret != DP_RECEIVER_CAP_SIZE) {
                         DRM_DEBUG_KMS("dpcd read failed - undocked during suspend?\n");
@@ -2135,6 +2152,16 @@ int drm_dp_mst_topology_mgr_resume(struct drm_dp_mst_topology_mgr *mgr)
                         ret = -1;
                         goto out_unlock;
                 }
+
+                /* Some hubs forget their guids after they resume */
+                sret = drm_dp_dpcd_read(mgr->aux, DP_GUID, guid, 16);
+                if (sret != 16) {
+                        DRM_DEBUG_KMS("dpcd read failed - undocked during suspend?\n");
+                        ret = -1;
+                        goto out_unlock;
+                }
+                drm_dp_check_mstb_guid(mgr->mst_primary, guid);
+
                 ret = 0;
         } else
                 ret = -1;
diff --git a/drivers/gpu/drm/drm_edid.c b/drivers/gpu/drm/drm_edid.c
index 414d7f61aa05..558ef9fc39e6 100644
--- a/drivers/gpu/drm/drm_edid.c
+++ b/drivers/gpu/drm/drm_edid.c
@@ -205,7 +205,7 @@ static const struct drm_display_mode drm_dmt_modes[] = {
                    DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) },
         /* 0x0f - 1024x768@43Hz, interlace */
         { DRM_MODE("1024x768i", DRM_MODE_TYPE_DRIVER, 44900, 1024, 1032,
-                   1208, 1264, 0, 768, 768, 772, 817, 0,
+                   1208, 1264, 0, 768, 768, 776, 817, 0,
                    DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC |
                    DRM_MODE_FLAG_INTERLACE) },
         /* 0x10 - 1024x768@60Hz */
@@ -522,12 +522,12 @@ static const struct drm_display_mode edid_est_modes[] = {
                    720, 840, 0, 480, 481, 484, 500, 0,
                    DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC) }, /* 640x480@75Hz */
         { DRM_MODE("640x480", DRM_MODE_TYPE_DRIVER, 31500, 640, 664,
-                   704,  832, 0, 480, 489, 491, 520, 0,
+                   704,  832, 0, 480, 489, 492, 520, 0,
                    DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC) }, /* 640x480@72Hz */
         { DRM_MODE("640x480", DRM_MODE_TYPE_DRIVER, 30240, 640, 704,
                    768,  864, 0, 480, 483, 486, 525, 0,
                    DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC) }, /* 640x480@67Hz */
-        { DRM_MODE("640x480", DRM_MODE_TYPE_DRIVER, 25200, 640, 656,
+        { DRM_MODE("640x480", DRM_MODE_TYPE_DRIVER, 25175, 640, 656,
                    752, 800, 0, 480, 490, 492, 525, 0,
                    DRM_MODE_FLAG_NHSYNC | DRM_MODE_FLAG_NVSYNC) }, /* 640x480@60Hz */
         { DRM_MODE("720x400", DRM_MODE_TYPE_DRIVER, 35500, 720, 738,
@@ -539,7 +539,7 @@ static const struct drm_display_mode edid_est_modes[] = {
         { DRM_MODE("1280x1024", DRM_MODE_TYPE_DRIVER, 135000, 1280, 1296,
                    1440, 1688, 0, 1024, 1025, 1028, 1066, 0,
                    DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) }, /* 1280x1024@75Hz */
-        { DRM_MODE("1024x768", DRM_MODE_TYPE_DRIVER, 78800, 1024, 1040,
+        { DRM_MODE("1024x768", DRM_MODE_TYPE_DRIVER, 78750, 1024, 1040,
                    1136, 1312, 0,  768, 769, 772, 800, 0,
                    DRM_MODE_FLAG_PHSYNC | DRM_MODE_FLAG_PVSYNC) }, /* 1024x768@75Hz */
         { DRM_MODE("1024x768", DRM_MODE_TYPE_DRIVER, 75000, 1024, 1048,
@@ -2241,7 +2241,7 @@ drm_est3_modes(struct drm_connector *connector, struct detailed_timing *timing)
 {
         int i, j, m, modes = 0;
         struct drm_display_mode *mode;
-        u8 *est = ((u8 *)timing) + 5;
+        u8 *est = ((u8 *)timing) + 6;
 
         for (i = 0; i < 6; i++) {
                 for (j = 7; j >= 0; j--) {
diff --git a/drivers/gpu/drm/drm_gem.c b/drivers/gpu/drm/drm_gem.c
index 2e8c77e71e1f..da0c5320789f 100644
--- a/drivers/gpu/drm/drm_gem.c
+++ b/drivers/gpu/drm/drm_gem.c
@@ -534,7 +534,7 @@ struct page **drm_gem_get_pages(struct drm_gem_object *obj)
 
 fail:
         while (i--)
-                page_cache_release(pages[i]);
+                put_page(pages[i]);
 
         drm_free_large(pages);
         return ERR_CAST(p);
@@ -569,7 +569,7 @@ void drm_gem_put_pages(struct drm_gem_object *obj, struct page **pages,
                         mark_page_accessed(pages[i]);
 
                 /* Undo the reference we took when populating the table */
-                page_cache_release(pages[i]);
+                put_page(pages[i]);
         }
 
         drm_free_large(pages);
diff --git a/drivers/gpu/drm/etnaviv/etnaviv_gpu.c b/drivers/gpu/drm/etnaviv/etnaviv_gpu.c
index 09198d0b5814..306dde18a94a 100644
--- a/drivers/gpu/drm/etnaviv/etnaviv_gpu.c
+++ b/drivers/gpu/drm/etnaviv/etnaviv_gpu.c
@@ -572,6 +572,24 @@ int etnaviv_gpu_init(struct etnaviv_gpu *gpu)
                 goto fail;
         }
 
+        /*
+         * Set the GPU linear window to be at the end of the DMA window, where
+         * the CMA area is likely to reside. This ensures that we are able to
+         * map the command buffers while having the linear window overlap as
+         * much RAM as possible, so we can optimize mappings for other buffers.
+         *
+         * For 3D cores only do this if MC2.0 is present, as with MC1.0 it leads
+         * to different views of the memory on the individual engines.
+         */
+        if (!(gpu->identity.features & chipFeatures_PIPE_3D) ||
+            (gpu->identity.minor_features0 & chipMinorFeatures0_MC20)) {
+                u32 dma_mask = (u32)dma_get_required_mask(gpu->dev);
+                if (dma_mask < PHYS_OFFSET + SZ_2G)
+                        gpu->memory_base = PHYS_OFFSET;
+                else
+                        gpu->memory_base = dma_mask - SZ_2G + 1;
+        }
+
         ret = etnaviv_hw_reset(gpu);
         if (ret)
                 goto fail;
@@ -1566,7 +1584,6 @@ static int etnaviv_gpu_platform_probe(struct platform_device *pdev)
 {
         struct device *dev = &pdev->dev;
         struct etnaviv_gpu *gpu;
-        u32 dma_mask;
         int err = 0;
 
         gpu = devm_kzalloc(dev, sizeof(*gpu), GFP_KERNEL);
@@ -1576,18 +1593,6 @@ static int etnaviv_gpu_platform_probe(struct platform_device *pdev)
         gpu->dev = &pdev->dev;
         mutex_init(&gpu->lock);
 
-        /*
-         * Set the GPU linear window to be at the end of the DMA window, where
-         * the CMA area is likely to reside. This ensures that we are able to
-         * map the command buffers while having the linear window overlap as
-         * much RAM as possible, so we can optimize mappings for other buffers.
-         */
-        dma_mask = (u32)dma_get_required_mask(dev);
-        if (dma_mask < PHYS_OFFSET + SZ_2G)
-                gpu->memory_base = PHYS_OFFSET;
-        else
-                gpu->memory_base = dma_mask - SZ_2G + 1;
-
         /* Map registers: */
         gpu->mmio = etnaviv_ioremap(pdev, NULL, dev_name(gpu->dev));
         if (IS_ERR(gpu->mmio))
diff --git a/drivers/gpu/drm/exynos/Kconfig b/drivers/gpu/drm/exynos/Kconfig
index f17d39279596..baddf33fb475 100644
--- a/drivers/gpu/drm/exynos/Kconfig
+++ b/drivers/gpu/drm/exynos/Kconfig
@@ -94,7 +94,7 @@ comment "Sub-drivers"
 
 config DRM_EXYNOS_G2D
         bool "G2D"
-        depends on !VIDEO_SAMSUNG_S5P_G2D
+        depends on VIDEO_SAMSUNG_S5P_G2D=n
         select FRAME_VECTOR
         help
           Choose this option if you want to use Exynos G2D for DRM.
diff --git a/drivers/gpu/drm/exynos/Makefile b/drivers/gpu/drm/exynos/Makefile
index 968b31c522b2..23d2f958739b 100644
--- a/drivers/gpu/drm/exynos/Makefile
+++ b/drivers/gpu/drm/exynos/Makefile
@@ -2,10 +2,10 @@
 # Makefile for the drm device driver.  This driver provides support for the
 # Direct Rendering Infrastructure (DRI) in XFree86 4.1.0 and higher.
 
-exynosdrm-y := exynos_drm_drv.o exynos_drm_crtc.o exynos_drm_fbdev.o \
-                exynos_drm_fb.o exynos_drm_gem.o exynos_drm_core.o \
-                exynos_drm_plane.o
+exynosdrm-y := exynos_drm_drv.o exynos_drm_crtc.o exynos_drm_fb.o \
+                exynos_drm_gem.o exynos_drm_core.o exynos_drm_plane.o
 
+exynosdrm-$(CONFIG_DRM_FBDEV_EMULATION) += exynos_drm_fbdev.o
 exynosdrm-$(CONFIG_DRM_EXYNOS_IOMMU) += exynos_drm_iommu.o
 exynosdrm-$(CONFIG_DRM_EXYNOS_FIMD)     += exynos_drm_fimd.o
 exynosdrm-$(CONFIG_DRM_EXYNOS5433_DECON)        += exynos5433_drm_decon.o
diff --git a/drivers/gpu/drm/exynos/exynos_drm_core.c b/drivers/gpu/drm/exynos/exynos_drm_core.c
index 7f55ba6771c6..011211e4167d 100644
--- a/drivers/gpu/drm/exynos/exynos_drm_core.c
+++ b/drivers/gpu/drm/exynos/exynos_drm_core.c
@@ -101,7 +101,7 @@ int exynos_drm_subdrv_open(struct drm_device *dev, struct drm_file *file)
         return 0;
 
 err:
-        list_for_each_entry_reverse(subdrv, &subdrv->list, list) {
+        list_for_each_entry_continue_reverse(subdrv, &exynos_drm_subdrv_list, list) {
                 if (subdrv->close)
                         subdrv->close(dev, subdrv->dev, file);
         }
diff --git a/drivers/gpu/drm/exynos/exynos_drm_fb.c b/drivers/gpu/drm/exynos/exynos_drm_fb.c
index d614194644c8..81cc5537cf25 100644
--- a/drivers/gpu/drm/exynos/exynos_drm_fb.c
+++ b/drivers/gpu/drm/exynos/exynos_drm_fb.c
@@ -199,17 +199,6 @@ dma_addr_t exynos_drm_fb_dma_addr(struct drm_framebuffer *fb, int index)
         return exynos_fb->dma_addr[index];
 }
 
-static void exynos_drm_output_poll_changed(struct drm_device *dev)
-{
-        struct exynos_drm_private *private = dev->dev_private;
-        struct drm_fb_helper *fb_helper = private->fb_helper;
-
-        if (fb_helper)
-                drm_fb_helper_hotplug_event(fb_helper);
-        else
-                exynos_drm_fbdev_init(dev);
-}
-
 static const struct drm_mode_config_funcs exynos_drm_mode_config_funcs = {
         .fb_create = exynos_user_fb_create,
         .output_poll_changed = exynos_drm_output_poll_changed,
diff --git a/drivers/gpu/drm/exynos/exynos_drm_fbdev.c b/drivers/gpu/drm/exynos/exynos_drm_fbdev.c
index 4ae860c44f1d..72d7c0b7c216 100644
--- a/drivers/gpu/drm/exynos/exynos_drm_fbdev.c
+++ b/drivers/gpu/drm/exynos/exynos_drm_fbdev.c
@@ -317,3 +317,14 @@ void exynos_drm_fbdev_restore_mode(struct drm_device *dev)
 
         drm_fb_helper_restore_fbdev_mode_unlocked(private->fb_helper);
 }
+
+void exynos_drm_output_poll_changed(struct drm_device *dev)
+{
+        struct exynos_drm_private *private = dev->dev_private;
+        struct drm_fb_helper *fb_helper = private->fb_helper;
+
+        if (fb_helper)
+                drm_fb_helper_hotplug_event(fb_helper);
+        else
+                exynos_drm_fbdev_init(dev);
+}
diff --git a/drivers/gpu/drm/exynos/exynos_drm_fbdev.h b/drivers/gpu/drm/exynos/exynos_drm_fbdev.h
index e16d7f0ae192..330eef87f718 100644
--- a/drivers/gpu/drm/exynos/exynos_drm_fbdev.h
+++ b/drivers/gpu/drm/exynos/exynos_drm_fbdev.h
@@ -15,9 +15,30 @@
 #ifndef _EXYNOS_DRM_FBDEV_H_
 #define _EXYNOS_DRM_FBDEV_H_
 
+#ifdef CONFIG_DRM_FBDEV_EMULATION
+
 int exynos_drm_fbdev_init(struct drm_device *dev);
-int exynos_drm_fbdev_reinit(struct drm_device *dev);
 void exynos_drm_fbdev_fini(struct drm_device *dev);
 void exynos_drm_fbdev_restore_mode(struct drm_device *dev);
+void exynos_drm_output_poll_changed(struct drm_device *dev);
+
+#else
+
+static inline int exynos_drm_fbdev_init(struct drm_device *dev)
+{
+        return 0;
+}
+
+static inline void exynos_drm_fbdev_fini(struct drm_device *dev)
+{
+}
+
+static inline void exynos_drm_fbdev_restore_mode(struct drm_device *dev)
+{
+}
+
+#define exynos_drm_output_poll_changed (NULL)
+
+#endif
 
 #endif
diff --git a/drivers/gpu/drm/exynos/exynos_drm_fimd.c b/drivers/gpu/drm/exynos/exynos_drm_fimd.c
index 51d484ae9f49..018449f8d557 100644
--- a/drivers/gpu/drm/exynos/exynos_drm_fimd.c
+++ b/drivers/gpu/drm/exynos/exynos_drm_fimd.c
@@ -888,7 +888,7 @@ static void fimd_dp_clock_enable(struct exynos_drm_crtc *crtc, bool enable)
          * clock. On these SoCs the bootloader may enable it but any
          * power domain off/on will reset it to disable state.
          */
-        if (ctx->driver_data != &exynos5_fimd_driver_data ||
+        if (ctx->driver_data != &exynos5_fimd_driver_data &&
             ctx->driver_data != &exynos5420_fimd_driver_data)
                 return;
 
diff --git a/drivers/gpu/drm/exynos/exynos_drm_mic.c b/drivers/gpu/drm/exynos/exynos_drm_mic.c
index 9869d70e9e54..a0def0be6d65 100644
--- a/drivers/gpu/drm/exynos/exynos_drm_mic.c
+++ b/drivers/gpu/drm/exynos/exynos_drm_mic.c
@@ -129,7 +129,7 @@ static void mic_set_path(struct exynos_mic *mic, bool enable)
         } else
                 val &= ~(MIC0_RGB_MUX | MIC0_I80_MUX | MIC0_ON_MUX);
 
-        regmap_write(mic->sysreg, DSD_CFG_MUX, val);
+        ret = regmap_write(mic->sysreg, DSD_CFG_MUX, val);
         if (ret)
                 DRM_ERROR("mic: Failed to read system register\n");
 }
@@ -457,6 +457,7 @@ static int exynos_mic_probe(struct platform_device *pdev)
                                                         "samsung,disp-syscon");
         if (IS_ERR(mic->sysreg)) {
                 DRM_ERROR("mic: Failed to get system register.\n");
+                ret = PTR_ERR(mic->sysreg);
                 goto err;
         }
 
diff --git a/drivers/gpu/drm/exynos/exynos_drm_plane.c b/drivers/gpu/drm/exynos/exynos_drm_plane.c
index d86227236f55..50185ac347b2 100644
--- a/drivers/gpu/drm/exynos/exynos_drm_plane.c
+++ b/drivers/gpu/drm/exynos/exynos_drm_plane.c
@@ -11,9 +11,10 @@
 
 #include <drm/drmP.h>
 
-#include <drm/exynos_drm.h>
-#include <drm/drm_plane_helper.h>
+#include <drm/drm_atomic.h>
 #include <drm/drm_atomic_helper.h>
+#include <drm/drm_plane_helper.h>
+#include <drm/exynos_drm.h>
 #include "exynos_drm_drv.h"
 #include "exynos_drm_crtc.h"
 #include "exynos_drm_fb.h"
@@ -57,11 +58,12 @@ static int exynos_plane_get_size(int start, unsigned length, unsigned last)
 }
 
 static void exynos_plane_mode_set(struct exynos_drm_plane_state *exynos_state)
-
 {
         struct drm_plane_state *state = &exynos_state->base;
-        struct drm_crtc *crtc = exynos_state->base.crtc;
-        struct drm_display_mode *mode = &crtc->state->adjusted_mode;
+        struct drm_crtc *crtc = state->crtc;
+        struct drm_crtc_state *crtc_state =
+                        drm_atomic_get_existing_crtc_state(state->state, crtc);
+        struct drm_display_mode *mode = &crtc_state->adjusted_mode;
         int crtc_x, crtc_y;
         unsigned int crtc_w, crtc_h;
         unsigned int src_x, src_y;
diff --git a/drivers/gpu/drm/gma500/cdv_intel_dp.c b/drivers/gpu/drm/gma500/cdv_intel_dp.c
index 7bb1f1aff932..c52f9adf5e04 100644
--- a/drivers/gpu/drm/gma500/cdv_intel_dp.c
+++ b/drivers/gpu/drm/gma500/cdv_intel_dp.c
@@ -220,7 +220,7 @@ i2c_dp_aux_prepare_bus(struct i2c_adapter *adapter)
  * FIXME: This is the old dp aux helper, gma500 is the last driver that needs to
  * be ported over to the new helper code in drm_dp_helper.c like i915 or radeon.
  */
-static int __deprecated
+static int
 i2c_dp_aux_add_bus(struct i2c_adapter *adapter)
 {
         int error;
diff --git a/drivers/gpu/drm/i915/i915_drv.c b/drivers/gpu/drm/i915/i915_drv.c
index 20e82008b8b6..6d2fb3f4ac62 100644
--- a/drivers/gpu/drm/i915/i915_drv.c
+++ b/drivers/gpu/drm/i915/i915_drv.c
@@ -758,10 +758,10 @@ static int i915_drm_resume(struct drm_device *dev)
                 dev_priv->display.hpd_irq_setup(dev);
         spin_unlock_irq(&dev_priv->irq_lock);
 
-        intel_display_resume(dev);
-
         intel_dp_mst_resume(dev);
 
+        intel_display_resume(dev);
+
         /*
          * ... but also need to make sure that hotplug processing
          * doesn't cause havoc. Like in the driver load code we don't
@@ -792,7 +792,7 @@ static int i915_drm_resume(struct drm_device *dev)
 static int i915_drm_resume_early(struct drm_device *dev)
 {
         struct drm_i915_private *dev_priv = dev->dev_private;
-        int ret = 0;
+        int ret;
 
         /*
          * We have a resume ordering issue with the snd-hda driver also
@@ -803,6 +803,36 @@ static int i915_drm_resume_early(struct drm_device *dev)
          * FIXME: This should be solved with a special hdmi sink device or
          * similar so that power domains can be employed.
          */
+
+        /*
+         * Note that we need to set the power state explicitly, since we
+         * powered off the device during freeze and the PCI core won't power
+         * it back up for us during thaw. Powering off the device during
+         * freeze is not a hard requirement though, and during the
+         * suspend/resume phases the PCI core makes sure we get here with the
+         * device powered on. So in case we change our freeze logic and keep
+         * the device powered we can also remove the following set power state
+         * call.
+         */
+        ret = pci_set_power_state(dev->pdev, PCI_D0);
+        if (ret) {
+                DRM_ERROR("failed to set PCI D0 power state (%d)\n", ret);
+                goto out;
+        }
+
+        /*
+         * Note that pci_enable_device() first enables any parent bridge
+         * device and only then sets the power state for this device. The
+         * bridge enabling is a nop though, since bridge devices are resumed
+         * first. The order of enabling power and enabling the device is
+         * imposed by the PCI core as described above, so here we preserve the
+         * same order for the freeze/thaw phases.
+         *
+         * TODO: eventually we should remove pci_disable_device() /
+         * pci_enable_enable_device() from suspend/resume. Due to how they
+         * depend on the device enable refcount we can't anyway depend on them
+         * disabling/enabling the device.
+         */
         if (pci_enable_device(dev->pdev)) {
                 ret = -EIO;
                 goto out;
diff --git a/drivers/gpu/drm/i915/i915_drv.h b/drivers/gpu/drm/i915/i915_drv.h
index 10480939159c..daba7ebb9699 100644
--- a/drivers/gpu/drm/i915/i915_drv.h
+++ b/drivers/gpu/drm/i915/i915_drv.h
@@ -2634,8 +2634,9 @@ struct drm_i915_cmd_table {
 
 /* WaRsDisableCoarsePowerGating:skl,bxt */
 #define NEEDS_WaRsDisableCoarsePowerGating(dev) (IS_BXT_REVID(dev, 0, BXT_REVID_A1) || \
-                                                 ((IS_SKL_GT3(dev) || IS_SKL_GT4(dev)) && \
-                                                  IS_SKL_REVID(dev, 0, SKL_REVID_F0)))
+                                                 IS_SKL_GT3(dev) || \
+                                                 IS_SKL_GT4(dev))
+
 /*
  * dp aux and gmbus irq on gen4 seems to be able to generate legacy interrupts
  * even when in MSI mode. This results in spurious interrupt warnings if the
diff --git a/drivers/gpu/drm/i915/i915_gem.c b/drivers/gpu/drm/i915/i915_gem.c
index 3d31d3ac589e..dabc08987b5e 100644
--- a/drivers/gpu/drm/i915/i915_gem.c
+++ b/drivers/gpu/drm/i915/i915_gem.c
@@ -177,7 +177,7 @@ i915_gem_object_get_pages_phys(struct drm_i915_gem_object *obj)
                 drm_clflush_virt_range(vaddr, PAGE_SIZE);
                 kunmap_atomic(src);
 
-                page_cache_release(page);
+                put_page(page);
                 vaddr += PAGE_SIZE;
         }
 
@@ -243,7 +243,7 @@ i915_gem_object_put_pages_phys(struct drm_i915_gem_object *obj)
                         set_page_dirty(page);
                         if (obj->madv == I915_MADV_WILLNEED)
                                 mark_page_accessed(page);
-                        page_cache_release(page);
+                        put_page(page);
                         vaddr += PAGE_SIZE;
                 }
                 obj->dirty = 0;
@@ -2206,7 +2206,7 @@ i915_gem_object_put_pages_gtt(struct drm_i915_gem_object *obj)
                 if (obj->madv == I915_MADV_WILLNEED)
                         mark_page_accessed(page);
 
-                page_cache_release(page);
+                put_page(page);
         }
         obj->dirty = 0;
 
@@ -2346,7 +2346,7 @@ i915_gem_object_get_pages_gtt(struct drm_i915_gem_object *obj)
 err_pages:
         sg_mark_end(sg);
         for_each_sg_page(st->sgl, &sg_iter, st->nents, 0)
-                page_cache_release(sg_page_iter_page(&sg_iter));
+                put_page(sg_page_iter_page(&sg_iter));
         sg_free_table(st);
         kfree(st);
 
diff --git a/drivers/gpu/drm/i915/i915_gem_userptr.c b/drivers/gpu/drm/i915/i915_gem_userptr.c
index 6be40f3ba2c7..4d30b60defda 100644
--- a/drivers/gpu/drm/i915/i915_gem_userptr.c
+++ b/drivers/gpu/drm/i915/i915_gem_userptr.c
@@ -501,19 +501,24 @@ __i915_gem_userptr_get_pages_worker(struct work_struct *_work)
         if (pvec != NULL) {
                 struct mm_struct *mm = obj->userptr.mm->mm;
 
-                down_read(&mm->mmap_sem);
-                while (pinned < npages) {
-                        ret = get_user_pages_remote(work->task, mm,
-                                        obj->userptr.ptr + pinned * PAGE_SIZE,
-                                        npages - pinned,
-                                        !obj->userptr.read_only, 0,
-                                        pvec + pinned, NULL);
-                        if (ret < 0)
-                                break;
-
-                        pinned += ret;
+                ret = -EFAULT;
+                if (atomic_inc_not_zero(&mm->mm_users)) {
+                        down_read(&mm->mmap_sem);
+                        while (pinned < npages) {
+                                ret = get_user_pages_remote
+                                        (work->task, mm,
+                                         obj->userptr.ptr + pinned * PAGE_SIZE,
+                                         npages - pinned,
+                                         !obj->userptr.read_only, 0,
+                                         pvec + pinned, NULL);
+                                if (ret < 0)
+                                        break;
+
+                                pinned += ret;
+                        }
+                        up_read(&mm->mmap_sem);
+                        mmput(mm);
                 }
-                up_read(&mm->mmap_sem);
         }
 
         mutex_lock(&dev->struct_mutex);
@@ -683,7 +688,7 @@ i915_gem_userptr_put_pages(struct drm_i915_gem_object *obj)
                         set_page_dirty(page);
 
                 mark_page_accessed(page);
-                page_cache_release(page);
+                put_page(page);
         }
         obj->dirty = 0;
 
diff --git a/drivers/gpu/drm/i915/i915_irq.c b/drivers/gpu/drm/i915/i915_irq.c
index d1a46ef5ab3f..1c212205d0e7 100644
--- a/drivers/gpu/drm/i915/i915_irq.c
+++ b/drivers/gpu/drm/i915/i915_irq.c
@@ -1829,7 +1829,7 @@ static irqreturn_t cherryview_irq_handler(int irq, void *arg)
         /* IRQs are synced during runtime_suspend, we don't require a wakeref */
         disable_rpm_wakeref_asserts(dev_priv);
 
-        for (;;) {
+        do {
                 master_ctl = I915_READ(GEN8_MASTER_IRQ) & ~GEN8_MASTER_IRQ_CONTROL;
                 iir = I915_READ(VLV_IIR);
 
@@ -1857,7 +1857,7 @@ static irqreturn_t cherryview_irq_handler(int irq, void *arg)
 
                 I915_WRITE(GEN8_MASTER_IRQ, DE_MASTER_IRQ_CONTROL);
                 POSTING_READ(GEN8_MASTER_IRQ);
-        }
+        } while (0);
 
         enable_rpm_wakeref_asserts(dev_priv);
 
diff --git a/drivers/gpu/drm/i915/i915_reg.h b/drivers/gpu/drm/i915/i915_reg.h
index f76cbf3e5d1e..fffdac801d3b 100644
--- a/drivers/gpu/drm/i915/i915_reg.h
+++ b/drivers/gpu/drm/i915/i915_reg.h
@@ -2907,7 +2907,14 @@ enum skl_disp_power_wells {
 #define GEN6_RP_STATE_CAP       _MMIO(MCHBAR_MIRROR_BASE_SNB + 0x5998)
 #define BXT_RP_STATE_CAP        _MMIO(0x138170)
 
-#define INTERVAL_1_28_US(us)    (((us) * 100) >> 7)
+/*
+ * Make these a multiple of magic 25 to avoid SNB (eg. Dell XPS
+ * 8300) freezing up around GPU hangs. Looks as if even
+ * scheduling/timer interrupts start misbehaving if the RPS
+ * EI/thresholds are "bad", leading to a very sluggish or even
+ * frozen machine.
+ */
+#define INTERVAL_1_28_US(us)    roundup(((us) * 100) >> 7, 25)
 #define INTERVAL_1_33_US(us)    (((us) * 3)   >> 2)
 #define INTERVAL_0_833_US(us)   (((us) * 6) / 5)
 #define GT_INTERVAL_FROM_US(dev_priv, us) (IS_GEN9(dev_priv) ? \
diff --git a/drivers/gpu/drm/i915/intel_ddi.c b/drivers/gpu/drm/i915/intel_ddi.c
index 62de9f4bce09..3b57bf06abe8 100644
--- a/drivers/gpu/drm/i915/intel_ddi.c
+++ b/drivers/gpu/drm/i915/intel_ddi.c
@@ -443,9 +443,17 @@ void intel_prepare_ddi_buffer(struct intel_encoder *encoder)
         } else if (IS_BROADWELL(dev_priv)) {
                 ddi_translations_fdi = bdw_ddi_translations_fdi;
                 ddi_translations_dp = bdw_ddi_translations_dp;
-                ddi_translations_edp = bdw_ddi_translations_edp;
+
+                if (dev_priv->edp_low_vswing) {
+                        ddi_translations_edp = bdw_ddi_translations_edp;
+                        n_edp_entries = ARRAY_SIZE(bdw_ddi_translations_edp);
+                } else {
+                        ddi_translations_edp = bdw_ddi_translations_dp;
+                        n_edp_entries = ARRAY_SIZE(bdw_ddi_translations_dp);
+                }
+
                 ddi_translations_hdmi = bdw_ddi_translations_hdmi;
-                n_edp_entries = ARRAY_SIZE(bdw_ddi_translations_edp);
+
                 n_dp_entries = ARRAY_SIZE(bdw_ddi_translations_dp);
                 n_hdmi_entries = ARRAY_SIZE(bdw_ddi_translations_hdmi);
                 hdmi_default_entry = 7;
@@ -3201,12 +3209,6 @@ void intel_ddi_get_config(struct intel_encoder *encoder,
         intel_ddi_clock_get(encoder, pipe_config);
 }
 
-static void intel_ddi_destroy(struct drm_encoder *encoder)
-{
-        /* HDMI has nothing special to destroy, so we can go with this. */
-        intel_dp_encoder_destroy(encoder);
-}
-
 static bool intel_ddi_compute_config(struct intel_encoder *encoder,
                                      struct intel_crtc_state *pipe_config)
 {
@@ -3225,7 +3227,8 @@ static bool intel_ddi_compute_config(struct intel_encoder *encoder,
 }
 
 static const struct drm_encoder_funcs intel_ddi_funcs = {
-        .destroy = intel_ddi_destroy,
+        .reset = intel_dp_encoder_reset,
+        .destroy = intel_dp_encoder_destroy,
 };
 
 static struct intel_connector *
@@ -3324,6 +3327,7 @@ void intel_ddi_init(struct drm_device *dev, enum port port)
         intel_encoder->post_disable = intel_ddi_post_disable;
         intel_encoder->get_hw_state = intel_ddi_get_hw_state;
         intel_encoder->get_config = intel_ddi_get_config;
+        intel_encoder->suspend = intel_dp_encoder_suspend;
 
         intel_dig_port->port = port;
         intel_dig_port->saved_port_bits = I915_READ(DDI_BUF_CTL(port)) &
diff --git a/drivers/gpu/drm/i915/intel_display.c b/drivers/gpu/drm/i915/intel_display.c
index 6e0d8283daa6..182f84937345 100644
--- a/drivers/gpu/drm/i915/intel_display.c
+++ b/drivers/gpu/drm/i915/intel_display.c
@@ -13351,6 +13351,9 @@ static int intel_atomic_prepare_commit(struct drm_device *dev,
         }
 
         for_each_crtc_in_state(state, crtc, crtc_state, i) {
+                if (state->legacy_cursor_update)
+                        continue;
+
                 ret = intel_crtc_wait_for_pending_flips(crtc);
                 if (ret)
                         return ret;
diff --git a/drivers/gpu/drm/i915/intel_dp.c b/drivers/gpu/drm/i915/intel_dp.c
index f069a82deb57..412a34c39522 100644
--- a/drivers/gpu/drm/i915/intel_dp.c
+++ b/drivers/gpu/drm/i915/intel_dp.c
@@ -4898,7 +4898,7 @@ void intel_dp_encoder_destroy(struct drm_encoder *encoder)
         kfree(intel_dig_port);
 }
 
-static void intel_dp_encoder_suspend(struct intel_encoder *intel_encoder)
+void intel_dp_encoder_suspend(struct intel_encoder *intel_encoder)
 {
         struct intel_dp *intel_dp = enc_to_intel_dp(&intel_encoder->base);
 
@@ -4940,7 +4940,7 @@ static void intel_edp_panel_vdd_sanitize(struct intel_dp *intel_dp)
         edp_panel_vdd_schedule_off(intel_dp);
 }
 
-static void intel_dp_encoder_reset(struct drm_encoder *encoder)
+void intel_dp_encoder_reset(struct drm_encoder *encoder)
 {
         struct intel_dp *intel_dp;
 
diff --git a/drivers/gpu/drm/i915/intel_dp_mst.c b/drivers/gpu/drm/i915/intel_dp_mst.c
index a2bd698fe2f7..937e77228466 100644
--- a/drivers/gpu/drm/i915/intel_dp_mst.c
+++ b/drivers/gpu/drm/i915/intel_dp_mst.c
@@ -506,6 +506,8 @@ static void intel_dp_destroy_mst_connector(struct drm_dp_mst_topology_mgr *mgr,
         struct intel_connector *intel_connector = to_intel_connector(connector);
         struct drm_device *dev = connector->dev;
 
+        intel_connector->unregister(intel_connector);
+
         /* need to nuke the connector */
         drm_modeset_lock_all(dev);
         if (connector->state->crtc) {
@@ -519,11 +521,7 @@ static void intel_dp_destroy_mst_connector(struct drm_dp_mst_topology_mgr *mgr,
 
                 WARN(ret, "Disabling mst crtc failed with %i\n", ret);
         }
-        drm_modeset_unlock_all(dev);
 
-        intel_connector->unregister(intel_connector);
-
-        drm_modeset_lock_all(dev);
         intel_connector_remove_from_fbdev(intel_connector);
         drm_connector_cleanup(connector);
         drm_modeset_unlock_all(dev);
diff --git a/drivers/gpu/drm/i915/intel_drv.h b/drivers/gpu/drm/i915/intel_drv.h
index 4c027d69fac9..7d3af3a72abe 100644
--- a/drivers/gpu/drm/i915/intel_drv.h
+++ b/drivers/gpu/drm/i915/intel_drv.h
@@ -1238,6 +1238,8 @@ void intel_dp_set_link_params(struct intel_dp *intel_dp,
 void intel_dp_start_link_train(struct intel_dp *intel_dp);
 void intel_dp_stop_link_train(struct intel_dp *intel_dp);
 void intel_dp_sink_dpms(struct intel_dp *intel_dp, int mode);
+void intel_dp_encoder_reset(struct drm_encoder *encoder);
+void intel_dp_encoder_suspend(struct intel_encoder *intel_encoder);
 void intel_dp_encoder_destroy(struct drm_encoder *encoder);
 int intel_dp_sink_crc(struct intel_dp *intel_dp, u8 *crc);
 bool intel_dp_compute_config(struct intel_encoder *encoder,
diff --git a/drivers/gpu/drm/i915/intel_hdmi.c b/drivers/gpu/drm/i915/intel_hdmi.c
index a0d8daed2470..1ab6f687f640 100644
--- a/drivers/gpu/drm/i915/intel_hdmi.c
+++ b/drivers/gpu/drm/i915/intel_hdmi.c
@@ -1415,8 +1415,16 @@ intel_hdmi_detect(struct drm_connector *connector, bool force)
                                 hdmi_to_dig_port(intel_hdmi));
         }
 
-        if (!live_status)
-                DRM_DEBUG_KMS("Live status not up!");
+        if (!live_status) {
+                DRM_DEBUG_KMS("HDMI live status down\n");
+                /*
+                 * Live status register is not reliable on all intel platforms.
+                 * So consider live_status only for certain platforms, for
+                 * others, read EDID to determine presence of sink.
+                 */
+                if (INTEL_INFO(dev_priv)->gen < 7 || IS_IVYBRIDGE(dev_priv))
+                        live_status = true;
+        }
 
         intel_hdmi_unset_edid(connector);
 
diff --git a/drivers/gpu/drm/i915/intel_lrc.c b/drivers/gpu/drm/i915/intel_lrc.c
index 6a978ce80244..5c6080fd0968 100644
--- a/drivers/gpu/drm/i915/intel_lrc.c
+++ b/drivers/gpu/drm/i915/intel_lrc.c
@@ -841,11 +841,11 @@ static int logical_ring_prepare(struct drm_i915_gem_request *req, int bytes)
                 if (unlikely(total_bytes > remain_usable)) {
                         /*
                          * The base request will fit but the reserved space
-                         * falls off the end. So only need to to wait for the
-                         * reserved size after flushing out the remainder.
+                         * falls off the end. So don't need an immediate wrap
+                         * and only need to effectively wait for the reserved
+                         * size space from the start of ringbuffer.
                          */
                         wait_bytes = remain_actual + ringbuf->reserved_size;
-                        need_wrap = true;
                 } else if (total_bytes > ringbuf->space) {
                         /* No wrapping required, just waiting. */
                         wait_bytes = total_bytes;
@@ -1913,15 +1913,18 @@ static int gen8_emit_request_render(struct drm_i915_gem_request *request)
         struct intel_ringbuffer *ringbuf = request->ringbuf;
         int ret;
 
-        ret = intel_logical_ring_begin(request, 6 + WA_TAIL_DWORDS);
+        ret = intel_logical_ring_begin(request, 8 + WA_TAIL_DWORDS);
         if (ret)
                 return ret;
 
+        /* We're using qword write, seqno should be aligned to 8 bytes. */
+        BUILD_BUG_ON(I915_GEM_HWS_INDEX & 1);
+
         /* w/a for post sync ops following a GPGPU operation we
          * need a prior CS_STALL, which is emitted by the flush
          * following the batch.
          */
-        intel_logical_ring_emit(ringbuf, GFX_OP_PIPE_CONTROL(5));
+        intel_logical_ring_emit(ringbuf, GFX_OP_PIPE_CONTROL(6));
         intel_logical_ring_emit(ringbuf,
                                 (PIPE_CONTROL_GLOBAL_GTT_IVB |
                                  PIPE_CONTROL_CS_STALL |
@@ -1929,7 +1932,10 @@ static int gen8_emit_request_render(struct drm_i915_gem_request *request)
         intel_logical_ring_emit(ringbuf, hws_seqno_address(request->ring));
         intel_logical_ring_emit(ringbuf, 0);
         intel_logical_ring_emit(ringbuf, i915_gem_request_get_seqno(request));
+        /* We're thrashing one dword of HWS. */
+        intel_logical_ring_emit(ringbuf, 0);
         intel_logical_ring_emit(ringbuf, MI_USER_INTERRUPT);
+        intel_logical_ring_emit(ringbuf, MI_NOOP);
         return intel_logical_ring_advance_and_submit(request);
 }
 
diff --git a/drivers/gpu/drm/i915/intel_lvds.c b/drivers/gpu/drm/i915/intel_lvds.c
index 30a8403a8f4f..cd9fe609aefb 100644
--- a/drivers/gpu/drm/i915/intel_lvds.c
+++ b/drivers/gpu/drm/i915/intel_lvds.c
@@ -478,11 +478,8 @@ static int intel_lid_notify(struct notifier_block *nb, unsigned long val,
          * and as part of the cleanup in the hw state restore we also redisable
          * the vga plane.
          */
-        if (!HAS_PCH_SPLIT(dev)) {
-                drm_modeset_lock_all(dev);
+        if (!HAS_PCH_SPLIT(dev))
                 intel_display_resume(dev);
-                drm_modeset_unlock_all(dev);
-        }
 
         dev_priv->modeset_restore = MODESET_DONE;
 
diff --git a/drivers/gpu/drm/i915/intel_pm.c b/drivers/gpu/drm/i915/intel_pm.c
index 347d4df49a9b..8ed3cf34f82d 100644
--- a/drivers/gpu/drm/i915/intel_pm.c
+++ b/drivers/gpu/drm/i915/intel_pm.c
@@ -2876,25 +2876,28 @@ skl_plane_relative_data_rate(const struct intel_crtc_state *cstate,
                              const struct drm_plane_state *pstate,
                              int y)
 {
-        struct intel_crtc *intel_crtc = to_intel_crtc(cstate->base.crtc);
+        struct intel_plane_state *intel_pstate = to_intel_plane_state(pstate);
         struct drm_framebuffer *fb = pstate->fb;
+        uint32_t width = 0, height = 0;
+
+        width = drm_rect_width(&intel_pstate->src) >> 16;
+        height = drm_rect_height(&intel_pstate->src) >> 16;
+
+        if (intel_rotation_90_or_270(pstate->rotation))
+                swap(width, height);
 
         /* for planar format */
         if (fb->pixel_format == DRM_FORMAT_NV12) {
                 if (y)  /* y-plane data rate */
-                        return intel_crtc->config->pipe_src_w *
-                                intel_crtc->config->pipe_src_h *
+                        return width * height *
                                 drm_format_plane_cpp(fb->pixel_format, 0);
                 else    /* uv-plane data rate */
-                        return (intel_crtc->config->pipe_src_w/2) *
-                                (intel_crtc->config->pipe_src_h/2) *
+                        return (width / 2) * (height / 2) *
                                 drm_format_plane_cpp(fb->pixel_format, 1);
         }
 
         /* for packed formats */
-        return intel_crtc->config->pipe_src_w *
-                intel_crtc->config->pipe_src_h *
-                drm_format_plane_cpp(fb->pixel_format, 0);
+        return width * height * drm_format_plane_cpp(fb->pixel_format, 0);
 }
 
 /*
@@ -2973,8 +2976,9 @@ skl_allocate_pipe_ddb(struct intel_crtc_state *cstate,
                 struct drm_framebuffer *fb = plane->state->fb;
                 int id = skl_wm_plane_id(intel_plane);
 
-                if (fb == NULL)
+                if (!to_intel_plane_state(plane->state)->visible)
                         continue;
+
                 if (plane->type == DRM_PLANE_TYPE_CURSOR)
                         continue;
 
@@ -3000,7 +3004,7 @@ skl_allocate_pipe_ddb(struct intel_crtc_state *cstate,
                 uint16_t plane_blocks, y_plane_blocks = 0;
                 int id = skl_wm_plane_id(intel_plane);
 
-                if (pstate->fb == NULL)
+                if (!to_intel_plane_state(pstate)->visible)
                         continue;
                 if (plane->type == DRM_PLANE_TYPE_CURSOR)
                         continue;
@@ -3123,26 +3127,36 @@ static bool skl_compute_plane_wm(const struct drm_i915_private *dev_priv,
 {
         struct drm_plane *plane = &intel_plane->base;
         struct drm_framebuffer *fb = plane->state->fb;
+        struct intel_plane_state *intel_pstate =
+                                        to_intel_plane_state(plane->state);
         uint32_t latency = dev_priv->wm.skl_latency[level];
         uint32_t method1, method2;
         uint32_t plane_bytes_per_line, plane_blocks_per_line;
         uint32_t res_blocks, res_lines;
         uint32_t selected_result;
         uint8_t cpp;
+        uint32_t width = 0, height = 0;
 
-        if (latency == 0 || !cstate->base.active || !fb)
+        if (latency == 0 || !cstate->base.active || !intel_pstate->visible)
                 return false;
 
+        width = drm_rect_width(&intel_pstate->src) >> 16;
+        height = drm_rect_height(&intel_pstate->src) >> 16;
+
+        if (intel_rotation_90_or_270(plane->state->rotation))
+                swap(width, height);
+
         cpp = drm_format_plane_cpp(fb->pixel_format, 0);
         method1 = skl_wm_method1(skl_pipe_pixel_rate(cstate),
                                  cpp, latency);
         method2 = skl_wm_method2(skl_pipe_pixel_rate(cstate),
                                  cstate->base.adjusted_mode.crtc_htotal,
-                                 cstate->pipe_src_w,
-                                 cpp, fb->modifier[0],
+                                 width,
+                                 cpp,
+                                 fb->modifier[0],
                                  latency);
 
-        plane_bytes_per_line = cstate->pipe_src_w * cpp;
+        plane_bytes_per_line = width * cpp;
         plane_blocks_per_line = DIV_ROUND_UP(plane_bytes_per_line, 512);
 
         if (fb->modifier[0] == I915_FORMAT_MOD_Y_TILED ||
diff --git a/drivers/gpu/drm/i915/intel_ringbuffer.c b/drivers/gpu/drm/i915/intel_ringbuffer.c
index 45ce45a5e122..9121646d7c4d 100644
--- a/drivers/gpu/drm/i915/intel_ringbuffer.c
+++ b/drivers/gpu/drm/i915/intel_ringbuffer.c
@@ -968,7 +968,7 @@ static int gen9_init_workarounds(struct intel_engine_cs *ring)
 
         /* WaForceContextSaveRestoreNonCoherent:skl,bxt */
         tmp = HDC_FORCE_CONTEXT_SAVE_RESTORE_NON_COHERENT;
-        if (IS_SKL_REVID(dev, SKL_REVID_F0, SKL_REVID_F0) ||
+        if (IS_SKL_REVID(dev, SKL_REVID_F0, REVID_FOREVER) ||
             IS_BXT_REVID(dev, BXT_REVID_B0, REVID_FOREVER))
                 tmp |= HDC_FORCE_CSR_NON_COHERENT_OVR_DISABLE;
         WA_SET_BIT_MASKED(HDC_CHICKEN0, tmp);
@@ -1085,7 +1085,8 @@ static int skl_init_workarounds(struct intel_engine_cs *ring)
                 WA_SET_BIT_MASKED(HIZ_CHICKEN,
                                   BDW_HIZ_POWER_COMPILER_CLOCK_GATING_DISABLE);
 
-        if (IS_SKL_REVID(dev, 0, SKL_REVID_F0)) {
+        /* This is tied to WaForceContextSaveRestoreNonCoherent */
+        if (IS_SKL_REVID(dev, 0, REVID_FOREVER)) {
                 /*
                  *Use Force Non-Coherent whenever executing a 3D context. This
                  * is a workaround for a possible hang in the unlikely event
@@ -2090,10 +2091,12 @@ int intel_pin_and_map_ringbuffer_obj(struct drm_device *dev,
 {
         struct drm_i915_private *dev_priv = to_i915(dev);
         struct drm_i915_gem_object *obj = ringbuf->obj;
+        /* Ring wraparound at offset 0 sometimes hangs. No idea why. */
+        unsigned flags = PIN_OFFSET_BIAS | 4096;
         int ret;
 
         if (HAS_LLC(dev_priv) && !obj->stolen) {
-                ret = i915_gem_obj_ggtt_pin(obj, PAGE_SIZE, 0);
+                ret = i915_gem_obj_ggtt_pin(obj, PAGE_SIZE, flags);
                 if (ret)
                         return ret;
 
@@ -2109,7 +2112,8 @@ int intel_pin_and_map_ringbuffer_obj(struct drm_device *dev,
                         return -ENOMEM;
                 }
         } else {
-                ret = i915_gem_obj_ggtt_pin(obj, PAGE_SIZE, PIN_MAPPABLE);
+                ret = i915_gem_obj_ggtt_pin(obj, PAGE_SIZE,
+                                            flags | PIN_MAPPABLE);
                 if (ret)
                         return ret;
 
@@ -2454,11 +2458,11 @@ static int __intel_ring_prepare(struct intel_engine_cs *ring, int bytes)
                 if (unlikely(total_bytes > remain_usable)) {
                         /*
                          * The base request will fit but the reserved space
-                         * falls off the end. So only need to to wait for the
-                         * reserved size after flushing out the remainder.
+                         * falls off the end. So don't need an immediate wrap
+                         * and only need to effectively wait for the reserved
+                         * size space from the start of ringbuffer.
                          */
                         wait_bytes = remain_actual + ringbuf->reserved_size;
-                        need_wrap = true;
                 } else if (total_bytes > ringbuf->space) {
                         /* No wrapping required, just waiting. */
                         wait_bytes = total_bytes;
diff --git a/drivers/gpu/drm/i915/intel_uncore.c b/drivers/gpu/drm/i915/intel_uncore.c
index 436d8f2b8682..68b6f69aa682 100644
--- a/drivers/gpu/drm/i915/intel_uncore.c
+++ b/drivers/gpu/drm/i915/intel_uncore.c
@@ -1189,7 +1189,11 @@ static void intel_uncore_fw_domains_init(struct drm_device *dev)
         } else if (IS_HASWELL(dev) || IS_BROADWELL(dev)) {
                 dev_priv->uncore.funcs.force_wake_get =
                         fw_domains_get_with_thread_status;
-                dev_priv->uncore.funcs.force_wake_put = fw_domains_put;
+                if (IS_HASWELL(dev))
+                        dev_priv->uncore.funcs.force_wake_put =
+                                fw_domains_put_with_fifo;
+                else
+                        dev_priv->uncore.funcs.force_wake_put = fw_domains_put;
                 fw_domain_init(dev_priv, FW_DOMAIN_ID_RENDER,
                                FORCEWAKE_MT, FORCEWAKE_ACK_HSW);
         } else if (IS_IVYBRIDGE(dev)) {
diff --git a/drivers/gpu/drm/imx/dw_hdmi-imx.c b/drivers/gpu/drm/imx/dw_hdmi-imx.c
index 2a95d10e9d92..a24631fdf4ad 100644
--- a/drivers/gpu/drm/imx/dw_hdmi-imx.c
+++ b/drivers/gpu/drm/imx/dw_hdmi-imx.c
@@ -225,8 +225,6 @@ static int dw_hdmi_imx_bind(struct device *dev, struct device *master,
         if (!iores)
                 return -ENXIO;
 
-        platform_set_drvdata(pdev, hdmi);
-
         encoder->possible_crtcs = drm_of_find_possible_crtcs(drm, dev->of_node);
         /*
          * If we failed to find the CRTC(s) which this encoder is
@@ -245,7 +243,16 @@ static int dw_hdmi_imx_bind(struct device *dev, struct device *master,
         drm_encoder_init(drm, encoder, &dw_hdmi_imx_encoder_funcs,
                          DRM_MODE_ENCODER_TMDS, NULL);
 
-        return dw_hdmi_bind(dev, master, data, encoder, iores, irq, plat_data);
+        ret = dw_hdmi_bind(dev, master, data, encoder, iores, irq, plat_data);
+
+        /*
+         * If dw_hdmi_bind() fails we'll never call dw_hdmi_unbind(),
+         * which would have called the encoder cleanup.  Do it manually.
+         */
+        if (ret)
+                drm_encoder_cleanup(encoder);
+
+        return ret;
 }
 
 static void dw_hdmi_imx_unbind(struct device *dev, struct device *master,
diff --git a/drivers/gpu/drm/imx/imx-drm-core.c b/drivers/gpu/drm/imx/imx-drm-core.c
index 9876e0f0c3e1..e26dcdec2aba 100644
--- a/drivers/gpu/drm/imx/imx-drm-core.c
+++ b/drivers/gpu/drm/imx/imx-drm-core.c
@@ -326,7 +326,6 @@ int imx_drm_add_crtc(struct drm_device *drm, struct drm_crtc *crtc,
 {
         struct imx_drm_device *imxdrm = drm->dev_private;
         struct imx_drm_crtc *imx_drm_crtc;
-        int ret;
 
         /*
          * The vblank arrays are dimensioned by MAX_CRTC - we can't
@@ -351,10 +350,6 @@ int imx_drm_add_crtc(struct drm_device *drm, struct drm_crtc *crtc,
 
         *new_crtc = imx_drm_crtc;
 
-        ret = drm_mode_crtc_set_gamma_size(imx_drm_crtc->crtc, 256);
-        if (ret)
-                goto err_register;
-
         drm_crtc_helper_add(crtc,
                         imx_drm_crtc->imx_drm_helper_funcs.crtc_helper_funcs);
 
@@ -362,11 +357,6 @@ int imx_drm_add_crtc(struct drm_device *drm, struct drm_crtc *crtc,
                         imx_drm_crtc->imx_drm_helper_funcs.crtc_funcs, NULL);
 
         return 0;
-
-err_register:
-        imxdrm->crtc[--imxdrm->pipes] = NULL;
-        kfree(imx_drm_crtc);
-        return ret;
 }
 EXPORT_SYMBOL_GPL(imx_drm_add_crtc);
 
diff --git a/drivers/gpu/drm/imx/ipuv3-plane.c b/drivers/gpu/drm/imx/ipuv3-plane.c
index 588827844f30..681ec6eb77d9 100644
--- a/drivers/gpu/drm/imx/ipuv3-plane.c
+++ b/drivers/gpu/drm/imx/ipuv3-plane.c
@@ -72,22 +72,101 @@ static inline int calc_bandwidth(int width, int height, unsigned int vref)
 int ipu_plane_set_base(struct ipu_plane *ipu_plane, struct drm_framebuffer *fb,
                        int x, int y)
 {
-        struct drm_gem_cma_object *cma_obj;
-        unsigned long eba;
-        int active;
-
-        cma_obj = drm_fb_cma_get_gem_obj(fb, 0);
-        if (!cma_obj) {
-                DRM_DEBUG_KMS("entry is null.\n");
-                return -EFAULT;
+        struct drm_gem_cma_object *cma_obj[3];
+        unsigned long eba, ubo, vbo;
+        int active, i;
+
+        for (i = 0; i < drm_format_num_planes(fb->pixel_format); i++) {
+                cma_obj[i] = drm_fb_cma_get_gem_obj(fb, i);
+                if (!cma_obj[i]) {
+                        DRM_DEBUG_KMS("plane %d entry is null.\n", i);
+                        return -EFAULT;
+                }
         }
 
-        dev_dbg(ipu_plane->base.dev->dev, "phys = %pad, x = %d, y = %d",
-                &cma_obj->paddr, x, y);
-
-        eba = cma_obj->paddr + fb->offsets[0] +
+        eba = cma_obj[0]->paddr + fb->offsets[0] +
               fb->pitches[0] * y + (fb->bits_per_pixel >> 3) * x;
 
+        if (eba & 0x7) {
+                DRM_DEBUG_KMS("base address must be a multiple of 8.\n");
+                return -EINVAL;
+        }
+
+        if (fb->pitches[0] < 1 || fb->pitches[0] > 16384) {
+                DRM_DEBUG_KMS("pitches out of range.\n");
+                return -EINVAL;
+        }
+
+        if (ipu_plane->enabled && fb->pitches[0] != ipu_plane->stride[0]) {
+                DRM_DEBUG_KMS("pitches must not change while plane is enabled.\n");
+                return -EINVAL;
+        }
+
+        ipu_plane->stride[0] = fb->pitches[0];
+
+        switch (fb->pixel_format) {
+        case DRM_FORMAT_YUV420:
+        case DRM_FORMAT_YVU420:
+                /*
+                 * Multiplanar formats have to meet the following restrictions:
+                 * - The (up to) three plane addresses are EBA, EBA+UBO, EBA+VBO
+                 * - EBA, UBO and VBO are a multiple of 8
+                 * - UBO and VBO are unsigned and not larger than 0xfffff8
+                 * - Only EBA may be changed while scanout is active
+                 * - The strides of U and V planes must be identical.
+                 */
+                ubo = cma_obj[1]->paddr + fb->offsets[1] +
+                      fb->pitches[1] * y / 2 + x / 2 - eba;
+                vbo = cma_obj[2]->paddr + fb->offsets[2] +
+                      fb->pitches[2] * y / 2 + x / 2 - eba;
+
+                if ((ubo & 0x7) || (vbo & 0x7)) {
+                        DRM_DEBUG_KMS("U/V buffer offsets must be a multiple of 8.\n");
+                        return -EINVAL;
+                }
+
+                if ((ubo > 0xfffff8) || (vbo > 0xfffff8)) {
+                        DRM_DEBUG_KMS("U/V buffer offsets must be positive and not larger than 0xfffff8.\n");
+                        return -EINVAL;
+                }
+
+                if (ipu_plane->enabled && ((ipu_plane->u_offset != ubo) ||
+                                           (ipu_plane->v_offset != vbo))) {
+                        DRM_DEBUG_KMS("U/V buffer offsets must not change while plane is enabled.\n");
+                        return -EINVAL;
+                }
+
+                if (fb->pitches[1] != fb->pitches[2]) {
+                        DRM_DEBUG_KMS("U/V pitches must be identical.\n");
+                        return -EINVAL;
+                }
+
+                if (fb->pitches[1] < 1 || fb->pitches[1] > 16384) {
+                        DRM_DEBUG_KMS("U/V pitches out of range.\n");
+                        return -EINVAL;
+                }
+
+                if (ipu_plane->enabled &&
+                    (ipu_plane->stride[1] != fb->pitches[1])) {
+                        DRM_DEBUG_KMS("U/V pitches must not change while plane is enabled.\n");
+                        return -EINVAL;
+                }
+
+                ipu_plane->u_offset = ubo;
+                ipu_plane->v_offset = vbo;
+                ipu_plane->stride[1] = fb->pitches[1];
+
+                dev_dbg(ipu_plane->base.dev->dev,
+                        "phys = %pad %pad %pad, x = %d, y = %d",
+                        &cma_obj[0]->paddr, &cma_obj[1]->paddr,
+                        &cma_obj[2]->paddr, x, y);
+                break;
+        default:
+                dev_dbg(ipu_plane->base.dev->dev, "phys = %pad, x = %d, y = %d",
+                        &cma_obj[0]->paddr, x, y);
+                break;
+        }
+
         if (ipu_plane->enabled) {
                 active = ipu_idmac_get_current_buffer(ipu_plane->ipu_ch);
                 ipu_cpmem_set_buffer(ipu_plane->ipu_ch, !active, eba);
@@ -201,12 +280,6 @@ int ipu_plane_mode_set(struct ipu_plane *ipu_plane, struct drm_crtc *crtc,
                 }
         }
 
-        ret = ipu_dmfc_init_channel(ipu_plane->dmfc, crtc_w);
-        if (ret) {
-                dev_err(dev, "initializing dmfc channel failed with %d\n", ret);
-                return ret;
-        }
-
         ret = ipu_dmfc_alloc_bandwidth(ipu_plane->dmfc,
                         calc_bandwidth(crtc_w, crtc_h,
                                        calc_vref(mode)), 64);
@@ -215,6 +288,8 @@ int ipu_plane_mode_set(struct ipu_plane *ipu_plane, struct drm_crtc *crtc,
                 return ret;
         }
 
+        ipu_dmfc_config_wait4eot(ipu_plane->dmfc, crtc_w);
+
         ipu_cpmem_zero(ipu_plane->ipu_ch);
         ipu_cpmem_set_resolution(ipu_plane->ipu_ch, src_w, src_h);
         ret = ipu_cpmem_set_fmt(ipu_plane->ipu_ch, fb->pixel_format);
@@ -233,6 +308,18 @@ int ipu_plane_mode_set(struct ipu_plane *ipu_plane, struct drm_crtc *crtc,
         if (interlaced)
                 ipu_cpmem_interlaced_scan(ipu_plane->ipu_ch, fb->pitches[0]);
 
+        if (fb->pixel_format == DRM_FORMAT_YUV420) {
+                ipu_cpmem_set_yuv_planar_full(ipu_plane->ipu_ch,
+                                              ipu_plane->stride[1],
+                                              ipu_plane->u_offset,
+                                              ipu_plane->v_offset);
+        } else if (fb->pixel_format == DRM_FORMAT_YVU420) {
+                ipu_cpmem_set_yuv_planar_full(ipu_plane->ipu_ch,
+                                              ipu_plane->stride[1],
+                                              ipu_plane->v_offset,
+                                              ipu_plane->u_offset);
+        }
+
         ipu_plane->w = src_w;
         ipu_plane->h = src_h;
 
diff --git a/drivers/gpu/drm/imx/ipuv3-plane.h b/drivers/gpu/drm/imx/ipuv3-plane.h
index 3a443b413c60..4448fd4ad4eb 100644
--- a/drivers/gpu/drm/imx/ipuv3-plane.h
+++ b/drivers/gpu/drm/imx/ipuv3-plane.h
@@ -29,6 +29,10 @@ struct ipu_plane {
         int                     w;
         int                     h;
 
+        unsigned int            u_offset;
+        unsigned int            v_offset;
+        unsigned int            stride[2];
+
         bool                    enabled;
 };
 
diff --git a/drivers/gpu/drm/msm/hdmi/hdmi.h b/drivers/gpu/drm/msm/hdmi/hdmi.h
index b04a64664673..65428cf233ce 100644
--- a/drivers/gpu/drm/msm/hdmi/hdmi.h
+++ b/drivers/gpu/drm/msm/hdmi/hdmi.h
@@ -196,7 +196,7 @@ void __exit msm_hdmi_phy_driver_unregister(void);
 int msm_hdmi_pll_8960_init(struct platform_device *pdev);
 int msm_hdmi_pll_8996_init(struct platform_device *pdev);
 #else
-static inline int msm_hdmi_pll_8960_init(struct platform_device *pdev);
+static inline int msm_hdmi_pll_8960_init(struct platform_device *pdev)
 {
         return -ENODEV;
 }
diff --git a/drivers/gpu/drm/msm/msm_drv.c b/drivers/gpu/drm/msm/msm_drv.c
index d52910e2c26c..c03b96709179 100644
--- a/drivers/gpu/drm/msm/msm_drv.c
+++ b/drivers/gpu/drm/msm/msm_drv.c
@@ -467,9 +467,6 @@ static void msm_preclose(struct drm_device *dev, struct drm_file *file)
         struct msm_file_private *ctx = file->driver_priv;
         struct msm_kms *kms = priv->kms;
 
-        if (kms)
-                kms->funcs->preclose(kms, file);
-
         mutex_lock(&dev->struct_mutex);
         if (ctx == priv->lastctx)
                 priv->lastctx = NULL;
diff --git a/drivers/gpu/drm/msm/msm_kms.h b/drivers/gpu/drm/msm/msm_kms.h
index 9bcabaada179..e32222c3d44f 100644
--- a/drivers/gpu/drm/msm/msm_kms.h
+++ b/drivers/gpu/drm/msm/msm_kms.h
@@ -55,7 +55,6 @@ struct msm_kms_funcs {
                         struct drm_encoder *slave_encoder,
                         bool is_cmd_mode);
         /* cleanup: */
-        void (*preclose)(struct msm_kms *kms, struct drm_file *file);
         void (*destroy)(struct msm_kms *kms);
 };
 
diff --git a/drivers/gpu/drm/nouveau/include/nvkm/core/tegra.h b/drivers/gpu/drm/nouveau/include/nvkm/core/tegra.h
index 16641cec18a2..b5370cb56e3c 100644
--- a/drivers/gpu/drm/nouveau/include/nvkm/core/tegra.h
+++ b/drivers/gpu/drm/nouveau/include/nvkm/core/tegra.h
@@ -11,6 +11,7 @@ struct nvkm_device_tegra {
 
         struct reset_control *rst;
         struct clk *clk;
+        struct clk *clk_ref;
         struct clk *clk_pwr;
 
         struct regulator *vdd;
@@ -36,6 +37,10 @@ struct nvkm_device_tegra_func {
          * bypassed). A value of 0 means an IOMMU is never used.
          */
         u8 iommu_bit;
+        /*
+         * Whether the chip requires a reference clock
+         */
+        bool require_ref_clk;
 };
 
 int nvkm_device_tegra_new(const struct nvkm_device_tegra_func *,
diff --git a/drivers/gpu/drm/nouveau/nouveau_connector.c b/drivers/gpu/drm/nouveau/nouveau_connector.c
index ae96ebc490fb..e81aefe5ffa7 100644
--- a/drivers/gpu/drm/nouveau/nouveau_connector.c
+++ b/drivers/gpu/drm/nouveau/nouveau_connector.c
@@ -1276,18 +1276,18 @@ nouveau_connector_create(struct drm_device *dev, int index)
                 break;
         default:
                 if (disp->dithering_mode) {
+                        nv_connector->dithering_mode = DITHERING_MODE_AUTO;
                         drm_object_attach_property(&connector->base,
                                                    disp->dithering_mode,
                                                    nv_connector->
                                                    dithering_mode);
-                        nv_connector->dithering_mode = DITHERING_MODE_AUTO;
                 }
                 if (disp->dithering_depth) {
+                        nv_connector->dithering_depth = DITHERING_DEPTH_AUTO;
                         drm_object_attach_property(&connector->base,
                                                    disp->dithering_depth,
                                                    nv_connector->
                                                    dithering_depth);
-                        nv_connector->dithering_depth = DITHERING_DEPTH_AUTO;
                 }
                 break;
         }
diff --git a/drivers/gpu/drm/nouveau/nouveau_platform.c b/drivers/gpu/drm/nouveau/nouveau_platform.c
index 2dfe58af12e4..4c4cc2260257 100644
--- a/drivers/gpu/drm/nouveau/nouveau_platform.c
+++ b/drivers/gpu/drm/nouveau/nouveau_platform.c
@@ -55,6 +55,11 @@ static const struct nvkm_device_tegra_func gk20a_platform_data = {
         .iommu_bit = 34,
 };
 
+static const struct nvkm_device_tegra_func gm20b_platform_data = {
+        .iommu_bit = 34,
+        .require_ref_clk = true,
+};
+
 static const struct of_device_id nouveau_platform_match[] = {
         {
                 .compatible = "nvidia,gk20a",
@@ -62,7 +67,7 @@ static const struct of_device_id nouveau_platform_match[] = {
         },
         {
                 .compatible = "nvidia,gm20b",
-                .data = &gk20a_platform_data,
+                .data = &gm20b_platform_data,
         },
         { }
 };
diff --git a/drivers/gpu/drm/nouveau/nvkm/engine/device/tegra.c b/drivers/gpu/drm/nouveau/nvkm/engine/device/tegra.c
index 9afa5f3e3c1c..ec12efb4689a 100644
--- a/drivers/gpu/drm/nouveau/nvkm/engine/device/tegra.c
+++ b/drivers/gpu/drm/nouveau/nvkm/engine/device/tegra.c
@@ -35,6 +35,11 @@ nvkm_device_tegra_power_up(struct nvkm_device_tegra *tdev)
         ret = clk_prepare_enable(tdev->clk);
         if (ret)
                 goto err_clk;
+        if (tdev->clk_ref) {
+                ret = clk_prepare_enable(tdev->clk_ref);
+                if (ret)
+                        goto err_clk_ref;
+        }
         ret = clk_prepare_enable(tdev->clk_pwr);
         if (ret)
                 goto err_clk_pwr;
@@ -57,6 +62,9 @@ nvkm_device_tegra_power_up(struct nvkm_device_tegra *tdev)
 err_clamp:
         clk_disable_unprepare(tdev->clk_pwr);
 err_clk_pwr:
+        if (tdev->clk_ref)
+                clk_disable_unprepare(tdev->clk_ref);
+err_clk_ref:
         clk_disable_unprepare(tdev->clk);
 err_clk:
         regulator_disable(tdev->vdd);
@@ -71,6 +79,8 @@ nvkm_device_tegra_power_down(struct nvkm_device_tegra *tdev)
         udelay(10);
 
         clk_disable_unprepare(tdev->clk_pwr);
+        if (tdev->clk_ref)
+                clk_disable_unprepare(tdev->clk_ref);
         clk_disable_unprepare(tdev->clk);
         udelay(10);
 
@@ -274,6 +284,13 @@ nvkm_device_tegra_new(const struct nvkm_device_tegra_func *func,
                 goto free;
         }
 
+        if (func->require_ref_clk)
+                tdev->clk_ref = devm_clk_get(&pdev->dev, "ref");
+        if (IS_ERR(tdev->clk_ref)) {
+                ret = PTR_ERR(tdev->clk_ref);
+                goto free;
+        }
+
         tdev->clk_pwr = devm_clk_get(&pdev->dev, "pwr");
         if (IS_ERR(tdev->clk_pwr)) {
                 ret = PTR_ERR(tdev->clk_pwr);
diff --git a/drivers/gpu/drm/nouveau/nvkm/engine/gr/gf100.c b/drivers/gpu/drm/nouveau/nvkm/engine/gr/gf100.c
index c56a886229f1..b2de290da16f 100644
--- a/drivers/gpu/drm/nouveau/nvkm/engine/gr/gf100.c
+++ b/drivers/gpu/drm/nouveau/nvkm/engine/gr/gf100.c
@@ -1832,6 +1832,8 @@ gf100_gr_init(struct gf100_gr *gr)
 
         gf100_gr_mmio(gr, gr->func->mmio);
 
+        nvkm_mask(device, TPC_UNIT(0, 0, 0x05c), 0x00000001, 0x00000001);
+
         memcpy(tpcnr, gr->tpc_nr, sizeof(gr->tpc_nr));
         for (i = 0, gpc = -1; i < gr->tpc_total; i++) {
                 do {
diff --git a/drivers/gpu/drm/qxl/qxl_display.c b/drivers/gpu/drm/qxl/qxl_display.c
index 43e5f503d1c5..030409a3ee4e 100644
--- a/drivers/gpu/drm/qxl/qxl_display.c
+++ b/drivers/gpu/drm/qxl/qxl_display.c
@@ -375,10 +375,15 @@ static int qxl_crtc_cursor_set2(struct drm_crtc *crtc,
 
         qxl_bo_kunmap(user_bo);
 
+        qcrtc->cur_x += qcrtc->hot_spot_x - hot_x;
+        qcrtc->cur_y += qcrtc->hot_spot_y - hot_y;
+        qcrtc->hot_spot_x = hot_x;
+        qcrtc->hot_spot_y = hot_y;
+
         cmd = (struct qxl_cursor_cmd *)qxl_release_map(qdev, release);
         cmd->type = QXL_CURSOR_SET;
-        cmd->u.set.position.x = qcrtc->cur_x;
-        cmd->u.set.position.y = qcrtc->cur_y;
+        cmd->u.set.position.x = qcrtc->cur_x + qcrtc->hot_spot_x;
+        cmd->u.set.position.y = qcrtc->cur_y + qcrtc->hot_spot_y;
 
         cmd->u.set.shape = qxl_bo_physical_address(qdev, cursor_bo, 0);
 
@@ -441,8 +446,8 @@ static int qxl_crtc_cursor_move(struct drm_crtc *crtc,
 
         cmd = (struct qxl_cursor_cmd *)qxl_release_map(qdev, release);
         cmd->type = QXL_CURSOR_MOVE;
-        cmd->u.position.x = qcrtc->cur_x;
-        cmd->u.position.y = qcrtc->cur_y;
+        cmd->u.position.x = qcrtc->cur_x + qcrtc->hot_spot_x;
+        cmd->u.position.y = qcrtc->cur_y + qcrtc->hot_spot_y;
         qxl_release_unmap(qdev, release, &cmd->release_info);
 
         qxl_push_cursor_ring_release(qdev, release, QXL_CMD_CURSOR, false);
diff --git a/drivers/gpu/drm/qxl/qxl_drv.h b/drivers/gpu/drm/qxl/qxl_drv.h
index 6e6b9b1519b8..3f3897eb458c 100644
--- a/drivers/gpu/drm/qxl/qxl_drv.h
+++ b/drivers/gpu/drm/qxl/qxl_drv.h
@@ -135,6 +135,8 @@ struct qxl_crtc {
         int index;
         int cur_x;
         int cur_y;
+        int hot_spot_x;
+        int hot_spot_y;
 };
 
 struct qxl_output {
diff --git a/drivers/gpu/drm/radeon/atombios_crtc.c b/drivers/gpu/drm/radeon/atombios_crtc.c
index cf61e0856f4a..b80b08f71cb4 100644
--- a/drivers/gpu/drm/radeon/atombios_crtc.c
+++ b/drivers/gpu/drm/radeon/atombios_crtc.c
@@ -275,13 +275,15 @@ void atombios_crtc_dpms(struct drm_crtc *crtc, int mode)
                 if (ASIC_IS_DCE3(rdev) && !ASIC_IS_DCE6(rdev))
                         atombios_enable_crtc_memreq(crtc, ATOM_ENABLE);
                 atombios_blank_crtc(crtc, ATOM_DISABLE);
-                drm_vblank_on(dev, radeon_crtc->crtc_id);
+                if (dev->num_crtcs > radeon_crtc->crtc_id)
+                        drm_vblank_on(dev, radeon_crtc->crtc_id);
                 radeon_crtc_load_lut(crtc);
                 break;
         case DRM_MODE_DPMS_STANDBY:
         case DRM_MODE_DPMS_SUSPEND:
         case DRM_MODE_DPMS_OFF:
-                drm_vblank_off(dev, radeon_crtc->crtc_id);
+                if (dev->num_crtcs > radeon_crtc->crtc_id)
+                        drm_vblank_off(dev, radeon_crtc->crtc_id);
                 if (radeon_crtc->enabled)
                         atombios_blank_crtc(crtc, ATOM_ENABLE);
                 if (ASIC_IS_DCE3(rdev) && !ASIC_IS_DCE6(rdev))
diff --git a/drivers/gpu/drm/radeon/atombios_encoders.c b/drivers/gpu/drm/radeon/atombios_encoders.c
index edd05cdb0cd8..587cae4e73c9 100644
--- a/drivers/gpu/drm/radeon/atombios_encoders.c
+++ b/drivers/gpu/drm/radeon/atombios_encoders.c
@@ -310,6 +310,10 @@ static bool radeon_atom_mode_fixup(struct drm_encoder *encoder,
             && (mode->crtc_vsync_start < (mode->crtc_vdisplay + 2)))
                 adjusted_mode->crtc_vsync_start = adjusted_mode->crtc_vdisplay + 2;
 
+        /* vertical FP must be at least 1 */
+        if (mode->crtc_vsync_start == mode->crtc_vdisplay)
+                adjusted_mode->crtc_vsync_start++;
+
         /* get the native mode for scaling */
         if (radeon_encoder->active_device & (ATOM_DEVICE_LCD_SUPPORT)) {
                 radeon_panel_mode_fixup(encoder, adjusted_mode);
diff --git a/drivers/gpu/drm/radeon/evergreen.c b/drivers/gpu/drm/radeon/evergreen.c
index 76c4bdf21b20..34f7a29d9366 100644
--- a/drivers/gpu/drm/radeon/evergreen.c
+++ b/drivers/gpu/drm/radeon/evergreen.c
@@ -2608,10 +2608,152 @@ static void evergreen_agp_enable(struct radeon_device *rdev)
         WREG32(VM_CONTEXT1_CNTL, 0);
 }
 
+static const unsigned ni_dig_offsets[] =
+{
+        NI_DIG0_REGISTER_OFFSET,
+        NI_DIG1_REGISTER_OFFSET,
+        NI_DIG2_REGISTER_OFFSET,
+        NI_DIG3_REGISTER_OFFSET,
+        NI_DIG4_REGISTER_OFFSET,
+        NI_DIG5_REGISTER_OFFSET
+};
+
+static const unsigned ni_tx_offsets[] =
+{
+        NI_DCIO_UNIPHY0_UNIPHY_TX_CONTROL1,
+        NI_DCIO_UNIPHY1_UNIPHY_TX_CONTROL1,
+        NI_DCIO_UNIPHY2_UNIPHY_TX_CONTROL1,
+        NI_DCIO_UNIPHY3_UNIPHY_TX_CONTROL1,
+        NI_DCIO_UNIPHY4_UNIPHY_TX_CONTROL1,
+        NI_DCIO_UNIPHY5_UNIPHY_TX_CONTROL1
+};
+
+static const unsigned evergreen_dp_offsets[] =
+{
+        EVERGREEN_DP0_REGISTER_OFFSET,
+        EVERGREEN_DP1_REGISTER_OFFSET,
+        EVERGREEN_DP2_REGISTER_OFFSET,
+        EVERGREEN_DP3_REGISTER_OFFSET,
+        EVERGREEN_DP4_REGISTER_OFFSET,
+        EVERGREEN_DP5_REGISTER_OFFSET
+};
+
+
+/*
+ * Assumption is that EVERGREEN_CRTC_MASTER_EN enable for requested crtc
+ * We go from crtc to connector and it is not relible  since it
+ * should be an opposite direction .If crtc is enable then
+ * find the dig_fe which selects this crtc and insure that it enable.
+ * if such dig_fe is found then find dig_be which selects found dig_be and
+ * insure that it enable and in DP_SST mode.
+ * if UNIPHY_PLL_CONTROL1.enable then we should disconnect timing
+ * from dp symbols clocks .
+ */
+static bool evergreen_is_dp_sst_stream_enabled(struct radeon_device *rdev,
+                                               unsigned crtc_id, unsigned *ret_dig_fe)
+{
+        unsigned i;
+        unsigned dig_fe;
+        unsigned dig_be;
+        unsigned dig_en_be;
+        unsigned uniphy_pll;
+        unsigned digs_fe_selected;
+        unsigned dig_be_mode;
+        unsigned dig_fe_mask;
+        bool is_enabled = false;
+        bool found_crtc = false;
+
+        /* loop through all running dig_fe to find selected crtc */
+        for (i = 0; i < ARRAY_SIZE(ni_dig_offsets); i++) {
+                dig_fe = RREG32(NI_DIG_FE_CNTL + ni_dig_offsets[i]);
+                if (dig_fe & NI_DIG_FE_CNTL_SYMCLK_FE_ON &&
+                    crtc_id == NI_DIG_FE_CNTL_SOURCE_SELECT(dig_fe)) {
+                        /* found running pipe */
+                        found_crtc = true;
+                        dig_fe_mask = 1 << i;
+                        dig_fe = i;
+                        break;
+                }
+        }
+
+        if (found_crtc) {
+                /* loop through all running dig_be to find selected dig_fe */
+                for (i = 0; i < ARRAY_SIZE(ni_dig_offsets); i++) {
+                        dig_be = RREG32(NI_DIG_BE_CNTL + ni_dig_offsets[i]);
+                        /* if dig_fe_selected by dig_be? */
+                        digs_fe_selected = NI_DIG_BE_CNTL_FE_SOURCE_SELECT(dig_be);
+                        dig_be_mode = NI_DIG_FE_CNTL_MODE(dig_be);
+                        if (dig_fe_mask &  digs_fe_selected &&
+                            /* if dig_be in sst mode? */
+                            dig_be_mode == NI_DIG_BE_DPSST) {
+                                dig_en_be = RREG32(NI_DIG_BE_EN_CNTL +
+                                                   ni_dig_offsets[i]);
+                                uniphy_pll = RREG32(NI_DCIO_UNIPHY0_PLL_CONTROL1 +
+                                                    ni_tx_offsets[i]);
+                                /* dig_be enable and tx is running */
+                                if (dig_en_be & NI_DIG_BE_EN_CNTL_ENABLE &&
+                                    dig_en_be & NI_DIG_BE_EN_CNTL_SYMBCLK_ON &&
+                                    uniphy_pll & NI_DCIO_UNIPHY0_PLL_CONTROL1_ENABLE) {
+                                        is_enabled = true;
+                                        *ret_dig_fe = dig_fe;
+                                        break;
+                                }
+                        }
+                }
+        }
+
+        return is_enabled;
+}
+
+/*
+ * Blank dig when in dp sst mode
+ * Dig ignores crtc timing
+ */
+static void evergreen_blank_dp_output(struct radeon_device *rdev,
+                                      unsigned dig_fe)
+{
+        unsigned stream_ctrl;
+        unsigned fifo_ctrl;
+        unsigned counter = 0;
+
+        if (dig_fe >= ARRAY_SIZE(evergreen_dp_offsets)) {
+                DRM_ERROR("invalid dig_fe %d\n", dig_fe);
+                return;
+        }
+
+        stream_ctrl = RREG32(EVERGREEN_DP_VID_STREAM_CNTL +
+                             evergreen_dp_offsets[dig_fe]);
+        if (!(stream_ctrl & EVERGREEN_DP_VID_STREAM_CNTL_ENABLE)) {
+                DRM_ERROR("dig %d , should be enable\n", dig_fe);
+                return;
+        }
+
+        stream_ctrl &=~EVERGREEN_DP_VID_STREAM_CNTL_ENABLE;
+        WREG32(EVERGREEN_DP_VID_STREAM_CNTL +
+               evergreen_dp_offsets[dig_fe], stream_ctrl);
+
+        stream_ctrl = RREG32(EVERGREEN_DP_VID_STREAM_CNTL +
+                             evergreen_dp_offsets[dig_fe]);
+        while (counter < 32 && stream_ctrl & EVERGREEN_DP_VID_STREAM_STATUS) {
+                msleep(1);
+                counter++;
+                stream_ctrl = RREG32(EVERGREEN_DP_VID_STREAM_CNTL +
+                                     evergreen_dp_offsets[dig_fe]);
+        }
+        if (counter >= 32 )
+                DRM_ERROR("counter exceeds %d\n", counter);
+
+        fifo_ctrl = RREG32(EVERGREEN_DP_STEER_FIFO + evergreen_dp_offsets[dig_fe]);
+        fifo_ctrl |= EVERGREEN_DP_STEER_FIFO_RESET;
+        WREG32(EVERGREEN_DP_STEER_FIFO + evergreen_dp_offsets[dig_fe], fifo_ctrl);
+
+}
+
 void evergreen_mc_stop(struct radeon_device *rdev, struct evergreen_mc_save *save)
 {
         u32 crtc_enabled, tmp, frame_count, blackout;
         int i, j;
+        unsigned dig_fe;
 
         if (!ASIC_IS_NODCE(rdev)) {
                 save->vga_render_control = RREG32(VGA_RENDER_CONTROL);
@@ -2651,7 +2793,17 @@ void evergreen_mc_stop(struct radeon_device *rdev, struct evergreen_mc_save *sav
                                         break;
                                 udelay(1);
                         }
-
+                        /*we should disable dig if it drives dp sst*/
+                        /*but we are in radeon_device_init and the topology is unknown*/
+                        /*and it is available after radeon_modeset_init*/
+                        /*the following method radeon_atom_encoder_dpms_dig*/
+                        /*does the job if we initialize it properly*/
+                        /*for now we do it this manually*/
+                        /**/
+                        if (ASIC_IS_DCE5(rdev) &&
+                            evergreen_is_dp_sst_stream_enabled(rdev, i ,&dig_fe))
+                                evergreen_blank_dp_output(rdev, dig_fe);
+                        /*we could remove 6 lines below*/
                         /* XXX this is a hack to avoid strange behavior with EFI on certain systems */
                         WREG32(EVERGREEN_CRTC_UPDATE_LOCK + crtc_offsets[i], 1);
                         tmp = RREG32(EVERGREEN_CRTC_CONTROL + crtc_offsets[i]);
diff --git a/drivers/gpu/drm/radeon/evergreen_reg.h b/drivers/gpu/drm/radeon/evergreen_reg.h
index aa939dfed3a3..b436badf9efa 100644
--- a/drivers/gpu/drm/radeon/evergreen_reg.h
+++ b/drivers/gpu/drm/radeon/evergreen_reg.h
@@ -250,8 +250,43 @@
 
 /* HDMI blocks at 0x7030, 0x7c30, 0x10830, 0x11430, 0x12030, 0x12c30 */
 #define EVERGREEN_HDMI_BASE                             0x7030
+/*DIG block*/
+#define NI_DIG0_REGISTER_OFFSET                 (0x7000  - 0x7000)
+#define NI_DIG1_REGISTER_OFFSET                 (0x7C00  - 0x7000)
+#define NI_DIG2_REGISTER_OFFSET                 (0x10800 - 0x7000)
+#define NI_DIG3_REGISTER_OFFSET                 (0x11400 - 0x7000)
+#define NI_DIG4_REGISTER_OFFSET                 (0x12000 - 0x7000)
+#define NI_DIG5_REGISTER_OFFSET                 (0x12C00 - 0x7000)
+
+
+#define NI_DIG_FE_CNTL                               0x7000
+#       define NI_DIG_FE_CNTL_SOURCE_SELECT(x)        ((x) & 0x3)
+#       define NI_DIG_FE_CNTL_SYMCLK_FE_ON            (1<<24)
+
+
+#define NI_DIG_BE_CNTL                    0x7140
+#       define NI_DIG_BE_CNTL_FE_SOURCE_SELECT(x)     (((x) >> 8 ) & 0x3F)
+#       define NI_DIG_FE_CNTL_MODE(x)                 (((x) >> 16) & 0x7 )
+
+#define NI_DIG_BE_EN_CNTL                              0x7144
+#       define NI_DIG_BE_EN_CNTL_ENABLE               (1 << 0)
+#       define NI_DIG_BE_EN_CNTL_SYMBCLK_ON           (1 << 8)
+#       define NI_DIG_BE_DPSST 0
 
 /* Display Port block */
+#define EVERGREEN_DP0_REGISTER_OFFSET                 (0x730C  - 0x730C)
+#define EVERGREEN_DP1_REGISTER_OFFSET                 (0x7F0C  - 0x730C)
+#define EVERGREEN_DP2_REGISTER_OFFSET                 (0x10B0C - 0x730C)
+#define EVERGREEN_DP3_REGISTER_OFFSET                 (0x1170C - 0x730C)
+#define EVERGREEN_DP4_REGISTER_OFFSET                 (0x1230C - 0x730C)
+#define EVERGREEN_DP5_REGISTER_OFFSET                 (0x12F0C - 0x730C)
+
+
+#define EVERGREEN_DP_VID_STREAM_CNTL                    0x730C
+#       define EVERGREEN_DP_VID_STREAM_CNTL_ENABLE     (1 << 0)
+#       define EVERGREEN_DP_VID_STREAM_STATUS          (1 <<16)
+#define EVERGREEN_DP_STEER_FIFO                         0x7310
+#       define EVERGREEN_DP_STEER_FIFO_RESET           (1 << 0)
 #define EVERGREEN_DP_SEC_CNTL                           0x7280
 #       define EVERGREEN_DP_SEC_STREAM_ENABLE           (1 << 0)
 #       define EVERGREEN_DP_SEC_ASP_ENABLE              (1 << 4)
@@ -266,4 +301,15 @@
 #       define EVERGREEN_DP_SEC_N_BASE_MULTIPLE(x)      (((x) & 0xf) << 24)
 #       define EVERGREEN_DP_SEC_SS_EN                   (1 << 28)
 
+/*DCIO_UNIPHY block*/
+#define NI_DCIO_UNIPHY0_UNIPHY_TX_CONTROL1            (0x6600  -0x6600)
+#define NI_DCIO_UNIPHY1_UNIPHY_TX_CONTROL1            (0x6640  -0x6600)
+#define NI_DCIO_UNIPHY2_UNIPHY_TX_CONTROL1            (0x6680 - 0x6600)
+#define NI_DCIO_UNIPHY3_UNIPHY_TX_CONTROL1            (0x66C0 - 0x6600)
+#define NI_DCIO_UNIPHY4_UNIPHY_TX_CONTROL1            (0x6700 - 0x6600)
+#define NI_DCIO_UNIPHY5_UNIPHY_TX_CONTROL1            (0x6740 - 0x6600)
+
+#define NI_DCIO_UNIPHY0_PLL_CONTROL1                   0x6618
+#       define NI_DCIO_UNIPHY0_PLL_CONTROL1_ENABLE     (1 << 0)
+
 #endif
diff --git a/drivers/gpu/drm/radeon/ni_reg.h b/drivers/gpu/drm/radeon/ni_reg.h
index da310a70c0f0..827ccc87cbc3 100644
--- a/drivers/gpu/drm/radeon/ni_reg.h
+++ b/drivers/gpu/drm/radeon/ni_reg.h
@@ -109,6 +109,8 @@
 #define NI_DP_MSE_SAT2                                 0x7398
 
 #define NI_DP_MSE_SAT_UPDATE                           0x739c
+#       define NI_DP_MSE_SAT_UPDATE_MASK               0x3
+#       define NI_DP_MSE_16_MTP_KEEPOUT                0x100
 
 #define NI_DIG_BE_CNTL                                 0x7140
 #       define NI_DIG_FE_SOURCE_SELECT(x)              (((x) & 0x7f) << 8)
diff --git a/drivers/gpu/drm/radeon/radeon_atpx_handler.c b/drivers/gpu/drm/radeon/radeon_atpx_handler.c
index fd8c4d317e60..95f4fea89302 100644
--- a/drivers/gpu/drm/radeon/radeon_atpx_handler.c
+++ b/drivers/gpu/drm/radeon/radeon_atpx_handler.c
@@ -62,10 +62,6 @@ bool radeon_has_atpx(void) {
         return radeon_atpx_priv.atpx_detected;
 }
 
-bool radeon_has_atpx_dgpu_power_cntl(void) {
-        return radeon_atpx_priv.atpx.functions.power_cntl;
-}
-
 /**
  * radeon_atpx_call - call an ATPX method
  *
@@ -145,6 +141,13 @@ static void radeon_atpx_parse_functions(struct radeon_atpx_functions *f, u32 mas
  */
 static int radeon_atpx_validate(struct radeon_atpx *atpx)
 {
+        /* make sure required functions are enabled */
+        /* dGPU power control is required */
+        if (atpx->functions.power_cntl == false) {
+                printk("ATPX dGPU power cntl not present, forcing\n");
+                atpx->functions.power_cntl = true;
+        }
+
         if (atpx->functions.px_params) {
                 union acpi_object *info;
                 struct atpx_px_params output;
diff --git a/drivers/gpu/drm/radeon/radeon_connectors.c b/drivers/gpu/drm/radeon/radeon_connectors.c
index cfcc099c537d..81a63d7f5cd9 100644
--- a/drivers/gpu/drm/radeon/radeon_connectors.c
+++ b/drivers/gpu/drm/radeon/radeon_connectors.c
@@ -2002,10 +2002,12 @@ radeon_add_atom_connector(struct drm_device *dev,
                                                    rdev->mode_info.dither_property,
                                                    RADEON_FMT_DITHER_DISABLE);
 
-                        if (radeon_audio != 0)
+                        if (radeon_audio != 0) {
                                 drm_object_attach_property(&radeon_connector->base.base,
                                                            rdev->mode_info.audio_property,
                                                            RADEON_AUDIO_AUTO);
+                                radeon_connector->audio = RADEON_AUDIO_AUTO;
+                        }
                         if (ASIC_IS_DCE5(rdev))
                                 drm_object_attach_property(&radeon_connector->base.base,
                                                            rdev->mode_info.output_csc_property,
@@ -2130,6 +2132,7 @@ radeon_add_atom_connector(struct drm_device *dev,
                                 drm_object_attach_property(&radeon_connector->base.base,
                                                            rdev->mode_info.audio_property,
                                                            RADEON_AUDIO_AUTO);
+                                radeon_connector->audio = RADEON_AUDIO_AUTO;
                         }
                         if (connector_type == DRM_MODE_CONNECTOR_DVII) {
                                 radeon_connector->dac_load_detect = true;
@@ -2185,6 +2188,7 @@ radeon_add_atom_connector(struct drm_device *dev,
                                 drm_object_attach_property(&radeon_connector->base.base,
                                                            rdev->mode_info.audio_property,
                                                            RADEON_AUDIO_AUTO);
+                                radeon_connector->audio = RADEON_AUDIO_AUTO;
                         }
                         if (ASIC_IS_DCE5(rdev))
                                 drm_object_attach_property(&radeon_connector->base.base,
@@ -2237,6 +2241,7 @@ radeon_add_atom_connector(struct drm_device *dev,
                                 drm_object_attach_property(&radeon_connector->base.base,
                                                            rdev->mode_info.audio_property,
                                                            RADEON_AUDIO_AUTO);
+                                radeon_connector->audio = RADEON_AUDIO_AUTO;
                         }
                         if (ASIC_IS_DCE5(rdev))
                                 drm_object_attach_property(&radeon_connector->base.base,
diff --git a/drivers/gpu/drm/radeon/radeon_device.c b/drivers/gpu/drm/radeon/radeon_device.c
index 4fd1a961012d..d0826fb0434c 100644
--- a/drivers/gpu/drm/radeon/radeon_device.c
+++ b/drivers/gpu/drm/radeon/radeon_device.c
@@ -103,12 +103,6 @@ static const char radeon_family_name[][16] = {
         "LAST",
 };
 
-#if defined(CONFIG_VGA_SWITCHEROO)
-bool radeon_has_atpx_dgpu_power_cntl(void);
-#else
-static inline bool radeon_has_atpx_dgpu_power_cntl(void) { return false; }
-#endif
-
 #define RADEON_PX_QUIRK_DISABLE_PX  (1 << 0)
 #define RADEON_PX_QUIRK_LONG_WAKEUP (1 << 1)
 
@@ -1305,9 +1299,9 @@ int radeon_device_init(struct radeon_device *rdev,
         }
         rdev->fence_context = fence_context_alloc(RADEON_NUM_RINGS);
 
-        DRM_INFO("initializing kernel modesetting (%s 0x%04X:0x%04X 0x%04X:0x%04X).\n",
-                radeon_family_name[rdev->family], pdev->vendor, pdev->device,
-                pdev->subsystem_vendor, pdev->subsystem_device);
+        DRM_INFO("initializing kernel modesetting (%s 0x%04X:0x%04X 0x%04X:0x%04X 0x%02X).\n",
+                 radeon_family_name[rdev->family], pdev->vendor, pdev->device,
+                 pdev->subsystem_vendor, pdev->subsystem_device, pdev->revision);
 
         /* mutex initialization are all done here so we
          * can recall function without having locking issues */
@@ -1439,7 +1433,7 @@ int radeon_device_init(struct radeon_device *rdev,
          * ignore it */
         vga_client_register(rdev->pdev, rdev, NULL, radeon_vga_set_decode);
 
-        if ((rdev->flags & RADEON_IS_PX) && radeon_has_atpx_dgpu_power_cntl())
+        if (rdev->flags & RADEON_IS_PX)
                 runtime = true;
         vga_switcheroo_register_client(rdev->pdev, &radeon_switcheroo_ops, runtime);
         if (runtime)
diff --git a/drivers/gpu/drm/radeon/radeon_dp_mst.c b/drivers/gpu/drm/radeon/radeon_dp_mst.c
index 43cffb526b0c..de504ea29c06 100644
--- a/drivers/gpu/drm/radeon/radeon_dp_mst.c
+++ b/drivers/gpu/drm/radeon/radeon_dp_mst.c
@@ -89,8 +89,16 @@ static int radeon_dp_mst_set_stream_attrib(struct radeon_encoder *primary,
         WREG32(NI_DP_MSE_SAT_UPDATE + primary->offset, 1);
 
         do {
+                unsigned value1, value2;
+                udelay(10);
                 temp = RREG32(NI_DP_MSE_SAT_UPDATE + primary->offset);
-        } while ((temp & 0x1) && retries++ < 10000);
+
+                value1 = temp & NI_DP_MSE_SAT_UPDATE_MASK;
+                value2 = temp & NI_DP_MSE_16_MTP_KEEPOUT;
+
+                if (!value1 && !value2)
+                        break;
+        } while (retries++ < 50);
 
         if (retries == 10000)
                 DRM_ERROR("timed out waitin for SAT update %d\n", primary->offset);
@@ -150,7 +158,7 @@ static int radeon_dp_mst_update_stream_attribs(struct radeon_connector *mst_conn
         return 0;
 }
 
-static int radeon_dp_mst_set_vcp_size(struct radeon_encoder *mst, uint32_t x, uint32_t y)
+static int radeon_dp_mst_set_vcp_size(struct radeon_encoder *mst, s64 avg_time_slots_per_mtp)
 {
         struct drm_device *dev = mst->base.dev;
         struct radeon_device *rdev = dev->dev_private;
@@ -158,6 +166,8 @@ static int radeon_dp_mst_set_vcp_size(struct radeon_encoder *mst, uint32_t x, ui
         uint32_t val, temp;
         uint32_t offset = radeon_atom_set_enc_offset(mst_enc->fe);
         int retries = 0;
+        uint32_t x = drm_fixp2int(avg_time_slots_per_mtp);
+        uint32_t y = drm_fixp2int_ceil((avg_time_slots_per_mtp - x) << 26);
 
         val = NI_DP_MSE_RATE_X(x) | NI_DP_MSE_RATE_Y(y);
 
@@ -165,6 +175,7 @@ static int radeon_dp_mst_set_vcp_size(struct radeon_encoder *mst, uint32_t x, ui
 
         do {
                 temp = RREG32(NI_DP_MSE_RATE_UPDATE + offset);
+                udelay(10);
         } while ((temp & 0x1) && (retries++ < 10000));
 
         if (retries >= 10000)
@@ -246,14 +257,8 @@ radeon_dp_mst_connector_destroy(struct drm_connector *connector)
         kfree(radeon_connector);
 }
 
-static int radeon_connector_dpms(struct drm_connector *connector, int mode)
-{
-        DRM_DEBUG_KMS("\n");
-        return 0;
-}
-
 static const struct drm_connector_funcs radeon_dp_mst_connector_funcs = {
-        .dpms = radeon_connector_dpms,
+        .dpms = drm_helper_connector_dpms,
         .detect = radeon_dp_mst_detect,
         .fill_modes = drm_helper_probe_single_connector_modes,
         .destroy = radeon_dp_mst_connector_destroy,
@@ -394,7 +399,7 @@ radeon_mst_encoder_dpms(struct drm_encoder *encoder, int mode)
         struct drm_crtc *crtc;
         struct radeon_crtc *radeon_crtc;
         int ret, slots;
-
+        s64 fixed_pbn, fixed_pbn_per_slot, avg_time_slots_per_mtp;
         if (!ASIC_IS_DCE5(rdev)) {
                 DRM_ERROR("got mst dpms on non-DCE5\n");
                 return;
@@ -456,7 +461,11 @@ radeon_mst_encoder_dpms(struct drm_encoder *encoder, int mode)
 
                 mst_enc->enc_active = true;
                 radeon_dp_mst_update_stream_attribs(radeon_connector->mst_port, primary);
-                radeon_dp_mst_set_vcp_size(radeon_encoder, slots, 0);
+
+                fixed_pbn = drm_int2fixp(mst_enc->pbn);
+                fixed_pbn_per_slot = drm_int2fixp(radeon_connector->mst_port->mst_mgr.pbn_div);
+                avg_time_slots_per_mtp = drm_fixp_div(fixed_pbn, fixed_pbn_per_slot);
+                radeon_dp_mst_set_vcp_size(radeon_encoder, avg_time_slots_per_mtp);
 
                 atombios_dig_encoder_setup2(&primary->base, ATOM_ENCODER_CMD_DP_VIDEO_ON, 0,
                                             mst_enc->fe);
diff --git a/drivers/gpu/drm/radeon/radeon_irq_kms.c b/drivers/gpu/drm/radeon/radeon_irq_kms.c
index 979f3bf65f2c..1e9304d1c88f 100644
--- a/drivers/gpu/drm/radeon/radeon_irq_kms.c
+++ b/drivers/gpu/drm/radeon/radeon_irq_kms.c
@@ -291,6 +291,8 @@ int radeon_irq_kms_init(struct radeon_device *rdev)
         if (r) {
                 return r;
         }
+        rdev->ddev->vblank_disable_allowed = true;
+
         /* enable msi */
         rdev->msi_enabled = 0;
 
diff --git a/drivers/gpu/drm/radeon/radeon_legacy_crtc.c b/drivers/gpu/drm/radeon/radeon_legacy_crtc.c
index 24152dfef199..478d4099b0d0 100644
--- a/drivers/gpu/drm/radeon/radeon_legacy_crtc.c
+++ b/drivers/gpu/drm/radeon/radeon_legacy_crtc.c
@@ -331,13 +331,15 @@ static void radeon_crtc_dpms(struct drm_crtc *crtc, int mode)
                                                                          RADEON_CRTC_DISP_REQ_EN_B));
                         WREG32_P(RADEON_CRTC_EXT_CNTL, crtc_ext_cntl, ~(mask | crtc_ext_cntl));
                 }
-                drm_vblank_on(dev, radeon_crtc->crtc_id);
+                if (dev->num_crtcs > radeon_crtc->crtc_id)
+                        drm_vblank_on(dev, radeon_crtc->crtc_id);
                 radeon_crtc_load_lut(crtc);
                 break;
         case DRM_MODE_DPMS_STANDBY:
         case DRM_MODE_DPMS_SUSPEND:
         case DRM_MODE_DPMS_OFF:
-                drm_vblank_off(dev, radeon_crtc->crtc_id);
+                if (dev->num_crtcs > radeon_crtc->crtc_id)
+                        drm_vblank_off(dev, radeon_crtc->crtc_id);
                 if (radeon_crtc->crtc_id)
                         WREG32_P(RADEON_CRTC2_GEN_CNTL, mask, ~(RADEON_CRTC2_EN | mask));
                 else {
diff --git a/drivers/gpu/drm/radeon/radeon_object.c b/drivers/gpu/drm/radeon/radeon_object.c
index dd46c38676db..2d901bf28a94 100644
--- a/drivers/gpu/drm/radeon/radeon_object.c
+++ b/drivers/gpu/drm/radeon/radeon_object.c
@@ -799,6 +799,10 @@ int radeon_bo_fault_reserve_notify(struct ttm_buffer_object *bo)
         if ((offset + size) <= rdev->mc.visible_vram_size)
                 return 0;
 
+        /* Can't move a pinned BO to visible VRAM */
+        if (rbo->pin_count > 0)
+                return -EINVAL;
+
         /* hurrah the memory is not visible ! */
         radeon_ttm_placement_from_domain(rbo, RADEON_GEM_DOMAIN_VRAM);
         lpfn =  rdev->mc.visible_vram_size >> PAGE_SHIFT;
diff --git a/drivers/gpu/drm/radeon/radeon_ttm.c b/drivers/gpu/drm/radeon/radeon_ttm.c
index 6d8c32377c6f..90f739478a1b 100644
--- a/drivers/gpu/drm/radeon/radeon_ttm.c
+++ b/drivers/gpu/drm/radeon/radeon_ttm.c
@@ -235,6 +235,8 @@ static int radeon_verify_access(struct ttm_buffer_object *bo, struct file *filp)
 {
         struct radeon_bo *rbo = container_of(bo, struct radeon_bo, tbo);
 
+        if (radeon_ttm_tt_has_userptr(bo->ttm))
+                return -EPERM;
         return drm_vma_node_verify_access(&rbo->gem_base.vma_node, filp);
 }
 
@@ -397,9 +399,15 @@ static int radeon_bo_move(struct ttm_buffer_object *bo,
                         struct ttm_mem_reg *new_mem)
 {
         struct radeon_device *rdev;
+        struct radeon_bo *rbo;
         struct ttm_mem_reg *old_mem = &bo->mem;
         int r;
 
+        /* Can't move a pinned BO */
+        rbo = container_of(bo, struct radeon_bo, tbo);
+        if (WARN_ON_ONCE(rbo->pin_count > 0))
+                return -EINVAL;
+
         rdev = radeon_get_rdev(bo->bdev);
         if (old_mem->mem_type == TTM_PL_SYSTEM && bo->ttm == NULL) {
                 radeon_move_null(bo, new_mem);
@@ -609,7 +617,7 @@ static void radeon_ttm_tt_unpin_userptr(struct ttm_tt *ttm)
                         set_page_dirty(page);
 
                 mark_page_accessed(page);
-                page_cache_release(page);
+                put_page(page);
         }
 
         sg_free_table(ttm->sg);
diff --git a/drivers/gpu/drm/radeon/si_dpm.c b/drivers/gpu/drm/radeon/si_dpm.c
index cb75ab72098a..e6abc09b67e3 100644
--- a/drivers/gpu/drm/radeon/si_dpm.c
+++ b/drivers/gpu/drm/radeon/si_dpm.c
@@ -2926,9 +2926,12 @@ static struct si_dpm_quirk si_dpm_quirk_list[] = {
         /* PITCAIRN - https://bugs.freedesktop.org/show_bug.cgi?id=76490 */
         { PCI_VENDOR_ID_ATI, 0x6810, 0x1462, 0x3036, 0, 120000 },
         { PCI_VENDOR_ID_ATI, 0x6811, 0x174b, 0xe271, 0, 120000 },
+        { PCI_VENDOR_ID_ATI, 0x6811, 0x174b, 0x2015, 0, 120000 },
         { PCI_VENDOR_ID_ATI, 0x6810, 0x174b, 0xe271, 85000, 90000 },
         { PCI_VENDOR_ID_ATI, 0x6811, 0x1462, 0x2015, 0, 120000 },
         { PCI_VENDOR_ID_ATI, 0x6811, 0x1043, 0x2015, 0, 120000 },
+        { PCI_VENDOR_ID_ATI, 0x6811, 0x148c, 0x2015, 0, 120000 },
+        { PCI_VENDOR_ID_ATI, 0x6810, 0x1682, 0x9275, 0, 120000 },
         { 0, 0, 0, 0 },
 };
 
@@ -3008,6 +3011,10 @@ static void si_apply_state_adjust_rules(struct radeon_device *rdev,
                 }
                 ++p;
         }
+        /* limit mclk on all R7 370 parts for stability */
+        if (rdev->pdev->device == 0x6811 &&
+            rdev->pdev->revision == 0x81)
+                max_mclk = 120000;
 
         if (rps->vce_active) {
                 rps->evclk = rdev->pm.dpm.vce_states[rdev->pm.dpm.vce_level].evclk;
diff --git a/drivers/gpu/drm/rockchip/dw_hdmi-rockchip.c b/drivers/gpu/drm/rockchip/dw_hdmi-rockchip.c
index 3d3cf2f8891e..d5cfef75fc80 100644
--- a/drivers/gpu/drm/rockchip/dw_hdmi-rockchip.c
+++ b/drivers/gpu/drm/rockchip/dw_hdmi-rockchip.c
@@ -271,8 +271,6 @@ static int dw_hdmi_rockchip_bind(struct device *dev, struct device *master,
         if (!iores)
                 return -ENXIO;
 
-        platform_set_drvdata(pdev, hdmi);
-
         encoder->possible_crtcs = drm_of_find_possible_crtcs(drm, dev->of_node);
         /*
          * If we failed to find the CRTC(s) which this encoder is
@@ -293,7 +291,16 @@ static int dw_hdmi_rockchip_bind(struct device *dev, struct device *master,
         drm_encoder_init(drm, encoder, &dw_hdmi_rockchip_encoder_funcs,
                          DRM_MODE_ENCODER_TMDS, NULL);
 
-        return dw_hdmi_bind(dev, master, data, encoder, iores, irq, plat_data);
+        ret = dw_hdmi_bind(dev, master, data, encoder, iores, irq, plat_data);
+
+        /*
+         * If dw_hdmi_bind() fails we'll never call dw_hdmi_unbind(),
+         * which would have called the encoder cleanup.  Do it manually.
+         */
+        if (ret)
+                drm_encoder_cleanup(encoder);
+
+        return ret;
 }
 
 static void dw_hdmi_rockchip_unbind(struct device *dev, struct device *master,
diff --git a/drivers/gpu/drm/rockchip/rockchip_drm_drv.c b/drivers/gpu/drm/rockchip/rockchip_drm_drv.c
index 896da09e49ee..f556a8f4fde6 100644
--- a/drivers/gpu/drm/rockchip/rockchip_drm_drv.c
+++ b/drivers/gpu/drm/rockchip/rockchip_drm_drv.c
@@ -251,6 +251,27 @@ static int rockchip_drm_unload(struct drm_device *drm_dev)
         return 0;
 }
 
+static void rockchip_drm_crtc_cancel_pending_vblank(struct drm_crtc *crtc,
+                                                    struct drm_file *file_priv)
+{
+        struct rockchip_drm_private *priv = crtc->dev->dev_private;
+        int pipe = drm_crtc_index(crtc);
+
+        if (pipe < ROCKCHIP_MAX_CRTC &&
+            priv->crtc_funcs[pipe] &&
+            priv->crtc_funcs[pipe]->cancel_pending_vblank)
+                priv->crtc_funcs[pipe]->cancel_pending_vblank(crtc, file_priv);
+}
+
+static void rockchip_drm_preclose(struct drm_device *dev,
+                                  struct drm_file *file_priv)
+{
+        struct drm_crtc *crtc;
+
+        list_for_each_entry(crtc, &dev->mode_config.crtc_list, head)
+                rockchip_drm_crtc_cancel_pending_vblank(crtc, file_priv);
+}
+
 void rockchip_drm_lastclose(struct drm_device *dev)
 {
         struct rockchip_drm_private *priv = dev->dev_private;
@@ -281,6 +302,7 @@ static struct drm_driver rockchip_drm_driver = {
                                   DRIVER_PRIME | DRIVER_ATOMIC,
         .load                   = rockchip_drm_load,
         .unload                 = rockchip_drm_unload,
+        .preclose               = rockchip_drm_preclose,
         .lastclose              = rockchip_drm_lastclose,
         .get_vblank_counter     = drm_vblank_no_hw_counter,
         .enable_vblank          = rockchip_drm_crtc_enable_vblank,
diff --git a/drivers/gpu/drm/rockchip/rockchip_drm_drv.h b/drivers/gpu/drm/rockchip/rockchip_drm_drv.h
index 3529f692edb8..00d17d71aa4c 100644
--- a/drivers/gpu/drm/rockchip/rockchip_drm_drv.h
+++ b/drivers/gpu/drm/rockchip/rockchip_drm_drv.h
@@ -40,6 +40,7 @@ struct rockchip_crtc_funcs {
         int (*enable_vblank)(struct drm_crtc *crtc);
         void (*disable_vblank)(struct drm_crtc *crtc);
         void (*wait_for_update)(struct drm_crtc *crtc);
+        void (*cancel_pending_vblank)(struct drm_crtc *crtc, struct drm_file *file_priv);
 };
 
 struct rockchip_atomic_commit {
diff --git a/drivers/gpu/drm/rockchip/rockchip_drm_vop.c b/drivers/gpu/drm/rockchip/rockchip_drm_vop.c
index fd370548d7d7..a619f120f801 100644
--- a/drivers/gpu/drm/rockchip/rockchip_drm_vop.c
+++ b/drivers/gpu/drm/rockchip/rockchip_drm_vop.c
@@ -499,10 +499,25 @@ err_disable_hclk:
 static void vop_crtc_disable(struct drm_crtc *crtc)
 {
         struct vop *vop = to_vop(crtc);
+        int i;
 
         if (!vop->is_enabled)
                 return;
 
+        /*
+         * We need to make sure that all windows are disabled before we
+         * disable that crtc. Otherwise we might try to scan from a destroyed
+         * buffer later.
+         */
+        for (i = 0; i < vop->data->win_size; i++) {
+                struct vop_win *vop_win = &vop->win[i];
+                const struct vop_win_data *win = vop_win->data;
+
+                spin_lock(&vop->reg_lock);
+                VOP_WIN_SET(vop, win, enable, 0);
+                spin_unlock(&vop->reg_lock);
+        }
+
         drm_crtc_vblank_off(crtc);
 
         /*
@@ -549,6 +564,7 @@ static int vop_plane_atomic_check(struct drm_plane *plane,
                            struct drm_plane_state *state)
 {
         struct drm_crtc *crtc = state->crtc;
+        struct drm_crtc_state *crtc_state;
         struct drm_framebuffer *fb = state->fb;
         struct vop_win *vop_win = to_vop_win(plane);
         struct vop_plane_state *vop_plane_state = to_vop_plane_state(state);
@@ -563,12 +579,13 @@ static int vop_plane_atomic_check(struct drm_plane *plane,
         int max_scale = win->phy->scl ? FRAC_16_16(8, 1) :
                                         DRM_PLANE_HELPER_NO_SCALING;
 
-        crtc = crtc ? crtc : plane->state->crtc;
-        /*
-         * Both crtc or plane->state->crtc can be null.
-         */
         if (!crtc || !fb)
                 goto out_disable;
+
+        crtc_state = drm_atomic_get_existing_crtc_state(state->state, crtc);
+        if (WARN_ON(!crtc_state))
+                return -EINVAL;
+
         src->x1 = state->src_x;
         src->y1 = state->src_y;
         src->x2 = state->src_x + state->src_w;
@@ -580,8 +597,8 @@ static int vop_plane_atomic_check(struct drm_plane *plane,
 
         clip.x1 = 0;
         clip.y1 = 0;
-        clip.x2 = crtc->mode.hdisplay;
-        clip.y2 = crtc->mode.vdisplay;
+        clip.x2 = crtc_state->adjusted_mode.hdisplay;
+        clip.y2 = crtc_state->adjusted_mode.vdisplay;
 
         ret = drm_plane_helper_check_update(plane, crtc, state->fb,
                                             src, dest, &clip,
@@ -873,10 +890,30 @@ static void vop_crtc_wait_for_update(struct drm_crtc *crtc)
         WARN_ON(!wait_for_completion_timeout(&vop->wait_update_complete, 100));
 }
 
+static void vop_crtc_cancel_pending_vblank(struct drm_crtc *crtc,
+                                           struct drm_file *file_priv)
+{
+        struct drm_device *drm = crtc->dev;
+        struct vop *vop = to_vop(crtc);
+        struct drm_pending_vblank_event *e;
+        unsigned long flags;
+
+        spin_lock_irqsave(&drm->event_lock, flags);
+        e = vop->event;
+        if (e && e->base.file_priv == file_priv) {
+                vop->event = NULL;
+
+                e->base.destroy(&e->base);
+                file_priv->event_space += sizeof(e->event);
+        }
+        spin_unlock_irqrestore(&drm->event_lock, flags);
+}
+
 static const struct rockchip_crtc_funcs private_crtc_funcs = {
         .enable_vblank = vop_crtc_enable_vblank,
         .disable_vblank = vop_crtc_disable_vblank,
         .wait_for_update = vop_crtc_wait_for_update,
+        .cancel_pending_vblank = vop_crtc_cancel_pending_vblank,
 };
 
 static bool vop_crtc_mode_fixup(struct drm_crtc *crtc,
@@ -885,9 +922,6 @@ static bool vop_crtc_mode_fixup(struct drm_crtc *crtc,
 {
         struct vop *vop = to_vop(crtc);
 
-        if (adjusted_mode->htotal == 0 || adjusted_mode->vtotal == 0)
-                return false;
-
         adjusted_mode->clock =
                 clk_round_rate(vop->dclk, mode->clock * 1000) / 1000;
 
@@ -1108,7 +1142,7 @@ static int vop_create_crtc(struct vop *vop)
         const struct vop_data *vop_data = vop->data;
         struct device *dev = vop->dev;
         struct drm_device *drm_dev = vop->drm_dev;
-        struct drm_plane *primary = NULL, *cursor = NULL, *plane;
+        struct drm_plane *primary = NULL, *cursor = NULL, *plane, *tmp;
         struct drm_crtc *crtc = &vop->crtc;
         struct device_node *port;
         int ret;
@@ -1148,7 +1182,7 @@ static int vop_create_crtc(struct vop *vop)
         ret = drm_crtc_init_with_planes(drm_dev, crtc, primary, cursor,
                                         &vop_crtc_funcs, NULL);
         if (ret)
-                return ret;
+                goto err_cleanup_planes;
 
         drm_crtc_helper_add(crtc, &vop_crtc_helper_funcs);
 
@@ -1181,6 +1215,7 @@ static int vop_create_crtc(struct vop *vop)
         if (!port) {
                 DRM_ERROR("no port node found in %s\n",
                           dev->of_node->full_name);
+                ret = -ENOENT;
                 goto err_cleanup_crtc;
         }
 
@@ -1194,7 +1229,8 @@ static int vop_create_crtc(struct vop *vop)
 err_cleanup_crtc:
         drm_crtc_cleanup(crtc);
 err_cleanup_planes:
-        list_for_each_entry(plane, &drm_dev->mode_config.plane_list, head)
+        list_for_each_entry_safe(plane, tmp, &drm_dev->mode_config.plane_list,
+                                 head)
                 drm_plane_cleanup(plane);
         return ret;
 }
@@ -1202,9 +1238,28 @@ err_cleanup_planes:
 static void vop_destroy_crtc(struct vop *vop)
 {
         struct drm_crtc *crtc = &vop->crtc;
+        struct drm_device *drm_dev = vop->drm_dev;
+        struct drm_plane *plane, *tmp;
 
         rockchip_unregister_crtc_funcs(crtc);
         of_node_put(crtc->port);
+
+        /*
+         * We need to cleanup the planes now.  Why?
+         *
+         * The planes are "&vop->win[i].base".  That means the memory is
+         * all part of the big "struct vop" chunk of memory.  That memory
+         * was devm allocated and associated with this component.  We need to
+         * free it ourselves before vop_unbind() finishes.
+         */
+        list_for_each_entry_safe(plane, tmp, &drm_dev->mode_config.plane_list,
+                                 head)
+                vop_plane_destroy(plane);
+
+        /*
+         * Destroy CRTC after vop_plane_destroy() since vop_disable_plane()
+         * references the CRTC.
+         */
         drm_crtc_cleanup(crtc);
 }
 
diff --git a/drivers/gpu/drm/ttm/ttm_bo.c b/drivers/gpu/drm/ttm/ttm_bo.c
index 4cbf26555093..e3daafa1be13 100644
--- a/drivers/gpu/drm/ttm/ttm_bo.c
+++ b/drivers/gpu/drm/ttm/ttm_bo.c
@@ -230,22 +230,13 @@ EXPORT_SYMBOL(ttm_bo_del_sub_from_lru);
 
 void ttm_bo_move_to_lru_tail(struct ttm_buffer_object *bo)
 {
-        struct ttm_bo_device *bdev = bo->bdev;
-        struct ttm_mem_type_manager *man;
+        int put_count = 0;
 
         lockdep_assert_held(&bo->resv->lock.base);
 
-        if (bo->mem.placement & TTM_PL_FLAG_NO_EVICT) {
-                list_del_init(&bo->swap);
-                list_del_init(&bo->lru);
-
-        } else {
-                if (bo->ttm && !(bo->ttm->page_flags & TTM_PAGE_FLAG_SG))
-                        list_move_tail(&bo->swap, &bo->glob->swap_lru);
-
-                man = &bdev->man[bo->mem.mem_type];
-                list_move_tail(&bo->lru, &man->lru);
-        }
+        put_count = ttm_bo_del_from_lru(bo);
+        ttm_bo_list_ref_sub(bo, put_count, true);
+        ttm_bo_add_to_lru(bo);
 }
 EXPORT_SYMBOL(ttm_bo_move_to_lru_tail);
 
diff --git a/drivers/gpu/drm/ttm/ttm_tt.c b/drivers/gpu/drm/ttm/ttm_tt.c
index 4e19d0f9cc30..077ae9b2865d 100644
--- a/drivers/gpu/drm/ttm/ttm_tt.c
+++ b/drivers/gpu/drm/ttm/ttm_tt.c
@@ -311,7 +311,7 @@ int ttm_tt_swapin(struct ttm_tt *ttm)
                         goto out_err;
 
                 copy_highpage(to_page, from_page);
-                page_cache_release(from_page);
+                put_page(from_page);
         }
 
         if (!(ttm->page_flags & TTM_PAGE_FLAG_PERSISTENT_SWAP))
@@ -361,7 +361,7 @@ int ttm_tt_swapout(struct ttm_tt *ttm, struct file *persistent_swap_storage)
                 copy_highpage(to_page, from_page);
                 set_page_dirty(to_page);
                 mark_page_accessed(to_page);
-                page_cache_release(to_page);
+                put_page(to_page);
         }
 
         ttm_tt_unpopulate(ttm);
diff --git a/drivers/gpu/drm/udl/udl_fb.c b/drivers/gpu/drm/udl/udl_fb.c
index 33239a2b264a..fd1eb9d03f0b 100644
--- a/drivers/gpu/drm/udl/udl_fb.c
+++ b/drivers/gpu/drm/udl/udl_fb.c
@@ -536,7 +536,7 @@ static int udlfb_create(struct drm_fb_helper *helper,
 out_destroy_fbi:
         drm_fb_helper_release_fbi(helper);
 out_gfree:
-        drm_gem_object_unreference(&ufbdev->ufb.obj->base);
+        drm_gem_object_unreference_unlocked(&ufbdev->ufb.obj->base);
 out:
         return ret;
 }
diff --git a/drivers/gpu/drm/udl/udl_gem.c b/drivers/gpu/drm/udl/udl_gem.c
index 2a0a784ab6ee..d7528e0d8442 100644
--- a/drivers/gpu/drm/udl/udl_gem.c
+++ b/drivers/gpu/drm/udl/udl_gem.c
@@ -52,7 +52,7 @@ udl_gem_create(struct drm_file *file,
                 return ret;
         }
 
-        drm_gem_object_unreference(&obj->base);
+        drm_gem_object_unreference_unlocked(&obj->base);
         *handle_p = handle;
         return 0;
 }
diff --git a/drivers/gpu/drm/via/via_dmablit.c b/drivers/gpu/drm/via/via_dmablit.c
index e797dfc07ae3..7e2a12c4fed2 100644
--- a/drivers/gpu/drm/via/via_dmablit.c
+++ b/drivers/gpu/drm/via/via_dmablit.c
@@ -188,7 +188,7 @@ via_free_sg_info(struct pci_dev *pdev, drm_via_sg_info_t *vsg)
                         if (NULL != (page = vsg->pages[i])) {
                                 if (!PageReserved(page) && (DMA_FROM_DEVICE == vsg->direction))
                                         SetPageDirty(page);
-                                page_cache_release(page);
+                                put_page(page);
                         }
                 }
         case dr_via_pages_alloc:
diff --git a/drivers/gpu/drm/virtio/virtgpu_display.c b/drivers/gpu/drm/virtio/virtgpu_display.c
index 4854dac87e24..5fd1fd06effc 100644
--- a/drivers/gpu/drm/virtio/virtgpu_display.c
+++ b/drivers/gpu/drm/virtio/virtgpu_display.c
@@ -267,11 +267,23 @@ static int virtio_gpu_crtc_atomic_check(struct drm_crtc *crtc,
         return 0;
 }
 
+static void virtio_gpu_crtc_atomic_flush(struct drm_crtc *crtc,
+                                         struct drm_crtc_state *old_state)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&crtc->dev->event_lock, flags);
+        if (crtc->state->event)
+                drm_crtc_send_vblank_event(crtc, crtc->state->event);
+        spin_unlock_irqrestore(&crtc->dev->event_lock, flags);
+}
+
 static const struct drm_crtc_helper_funcs virtio_gpu_crtc_helper_funcs = {
         .enable        = virtio_gpu_crtc_enable,
         .disable       = virtio_gpu_crtc_disable,
         .mode_set_nofb = virtio_gpu_crtc_mode_set_nofb,
         .atomic_check  = virtio_gpu_crtc_atomic_check,
+        .atomic_flush  = virtio_gpu_crtc_atomic_flush,
 };
 
 static void virtio_gpu_enc_mode_set(struct drm_encoder *encoder,
diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_execbuf.c b/drivers/gpu/drm/vmwgfx/vmwgfx_execbuf.c
index 723ba16c6084..1a1a87cbf109 100644
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_execbuf.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_execbuf.c
@@ -3293,19 +3293,19 @@ static const struct vmw_cmd_entry vmw_cmd_entries[SVGA_3D_CMD_MAX] = {
                     &vmw_cmd_dx_cid_check, true, false, true),
         VMW_CMD_DEF(SVGA_3D_CMD_DX_DEFINE_QUERY, &vmw_cmd_dx_define_query,
                     true, false, true),
-        VMW_CMD_DEF(SVGA_3D_CMD_DX_DESTROY_QUERY, &vmw_cmd_ok,
+        VMW_CMD_DEF(SVGA_3D_CMD_DX_DESTROY_QUERY, &vmw_cmd_dx_cid_check,
                     true, false, true),
         VMW_CMD_DEF(SVGA_3D_CMD_DX_BIND_QUERY, &vmw_cmd_dx_bind_query,
                     true, false, true),
         VMW_CMD_DEF(SVGA_3D_CMD_DX_SET_QUERY_OFFSET,
-                    &vmw_cmd_ok, true, false, true),
-        VMW_CMD_DEF(SVGA_3D_CMD_DX_BEGIN_QUERY, &vmw_cmd_ok,
+                    &vmw_cmd_dx_cid_check, true, false, true),
+        VMW_CMD_DEF(SVGA_3D_CMD_DX_BEGIN_QUERY, &vmw_cmd_dx_cid_check,
                     true, false, true),
-        VMW_CMD_DEF(SVGA_3D_CMD_DX_END_QUERY, &vmw_cmd_ok,
+        VMW_CMD_DEF(SVGA_3D_CMD_DX_END_QUERY, &vmw_cmd_dx_cid_check,
                     true, false, true),
         VMW_CMD_DEF(SVGA_3D_CMD_DX_READBACK_QUERY, &vmw_cmd_invalid,
                     true, false, true),
-        VMW_CMD_DEF(SVGA_3D_CMD_DX_SET_PREDICATION, &vmw_cmd_invalid,
+        VMW_CMD_DEF(SVGA_3D_CMD_DX_SET_PREDICATION, &vmw_cmd_dx_cid_check,
                     true, false, true),
         VMW_CMD_DEF(SVGA_3D_CMD_DX_SET_VIEWPORTS, &vmw_cmd_dx_cid_check,
                     true, false, true),
diff --git a/drivers/gpu/drm/vmwgfx/vmwgfx_fb.c b/drivers/gpu/drm/vmwgfx/vmwgfx_fb.c
index 3b1faf7862a5..679a4cb98ee3 100644
--- a/drivers/gpu/drm/vmwgfx/vmwgfx_fb.c
+++ b/drivers/gpu/drm/vmwgfx/vmwgfx_fb.c
@@ -573,9 +573,9 @@ static int vmw_fb_set_par(struct fb_info *info)
                 mode = old_mode;
                 old_mode = NULL;
         } else if (!vmw_kms_validate_mode_vram(vmw_priv,
-                                               mode->hdisplay *
-                                               (var->bits_per_pixel + 7) / 8,
-                                               mode->vdisplay)) {
+                                        mode->hdisplay *
+                                        DIV_ROUND_UP(var->bits_per_pixel, 8),
+                                        mode->vdisplay)) {
                 drm_mode_destroy(vmw_priv->dev, mode);
                 return -EINVAL;
         }
diff --git a/drivers/gpu/ipu-v3/ipu-common.c b/drivers/gpu/ipu-v3/ipu-common.c
index e00db3f510dd..abb98c77bad2 100644
--- a/drivers/gpu/ipu-v3/ipu-common.c
+++ b/drivers/gpu/ipu-v3/ipu-common.c
@@ -1068,7 +1068,6 @@ static int ipu_add_client_devices(struct ipu_soc *ipu, unsigned long ipu_base)
                         goto err_register;
                 }
 
-                pdev->dev.of_node = of_node;
                 pdev->dev.parent = dev;
 
                 ret = platform_device_add_data(pdev, &reg->pdata,
@@ -1079,6 +1078,12 @@ static int ipu_add_client_devices(struct ipu_soc *ipu, unsigned long ipu_base)
                         platform_device_put(pdev);
                         goto err_register;
                 }
+
+                /*
+                 * Set of_node only after calling platform_device_add. Otherwise
+                 * the platform:imx-ipuv3-crtc modalias won't be used.
+                 */
+                pdev->dev.of_node = of_node;
         }
 
         return 0;
diff --git a/drivers/gpu/ipu-v3/ipu-cpmem.c b/drivers/gpu/ipu-v3/ipu-cpmem.c
index 883a314cd83a..6494a4d28171 100644
--- a/drivers/gpu/ipu-v3/ipu-cpmem.c
+++ b/drivers/gpu/ipu-v3/ipu-cpmem.c
@@ -395,60 +395,48 @@ void ipu_cpmem_set_yuv_interleaved(struct ipuv3_channel *ch, u32 pixel_format)
 EXPORT_SYMBOL_GPL(ipu_cpmem_set_yuv_interleaved);
 
 void ipu_cpmem_set_yuv_planar_full(struct ipuv3_channel *ch,
-                                   u32 pixel_format, int stride,
-                                   int u_offset, int v_offset)
+                                   unsigned int uv_stride,
+                                   unsigned int u_offset, unsigned int v_offset)
 {
-        switch (pixel_format) {
-        case V4L2_PIX_FMT_YUV420:
-        case V4L2_PIX_FMT_YUV422P:
-                ipu_ch_param_write_field(ch, IPU_FIELD_SLUV, (stride / 2) - 1);
-                ipu_ch_param_write_field(ch, IPU_FIELD_UBO, u_offset / 8);
-                ipu_ch_param_write_field(ch, IPU_FIELD_VBO, v_offset / 8);
-                break;
-        case V4L2_PIX_FMT_YVU420:
-                ipu_ch_param_write_field(ch, IPU_FIELD_SLUV, (stride / 2) - 1);
-                ipu_ch_param_write_field(ch, IPU_FIELD_UBO, v_offset / 8);
-                ipu_ch_param_write_field(ch, IPU_FIELD_VBO, u_offset / 8);
-                break;
-        case V4L2_PIX_FMT_NV12:
-        case V4L2_PIX_FMT_NV16:
-                ipu_ch_param_write_field(ch, IPU_FIELD_SLUV, stride - 1);
-                ipu_ch_param_write_field(ch, IPU_FIELD_UBO, u_offset / 8);
-                ipu_ch_param_write_field(ch, IPU_FIELD_VBO, u_offset / 8);
-                break;
-        }
+        ipu_ch_param_write_field(ch, IPU_FIELD_SLUV, uv_stride - 1);
+        ipu_ch_param_write_field(ch, IPU_FIELD_UBO, u_offset / 8);
+        ipu_ch_param_write_field(ch, IPU_FIELD_VBO, v_offset / 8);
 }
 EXPORT_SYMBOL_GPL(ipu_cpmem_set_yuv_planar_full);
 
 void ipu_cpmem_set_yuv_planar(struct ipuv3_channel *ch,
                               u32 pixel_format, int stride, int height)
 {
-        int u_offset, v_offset;
+        int fourcc, u_offset, v_offset;
         int uv_stride = 0;
 
-        switch (pixel_format) {
-        case V4L2_PIX_FMT_YUV420:
-        case V4L2_PIX_FMT_YVU420:
+        fourcc = v4l2_pix_fmt_to_drm_fourcc(pixel_format);
+        switch (fourcc) {
+        case DRM_FORMAT_YUV420:
                 uv_stride = stride / 2;
                 u_offset = stride * height;
                 v_offset = u_offset + (uv_stride * height / 2);
-                ipu_cpmem_set_yuv_planar_full(ch, pixel_format, stride,
-                                              u_offset, v_offset);
                 break;
-        case V4L2_PIX_FMT_YUV422P:
+        case DRM_FORMAT_YVU420:
+                uv_stride = stride / 2;
+                v_offset = stride * height;
+                u_offset = v_offset + (uv_stride * height / 2);
+                break;
+        case DRM_FORMAT_YUV422:
                 uv_stride = stride / 2;
                 u_offset = stride * height;
                 v_offset = u_offset + (uv_stride * height);
-                ipu_cpmem_set_yuv_planar_full(ch, pixel_format, stride,
-                                              u_offset, v_offset);
                 break;
-        case V4L2_PIX_FMT_NV12:
-        case V4L2_PIX_FMT_NV16:
+        case DRM_FORMAT_NV12:
+        case DRM_FORMAT_NV16:
+                uv_stride = stride;
                 u_offset = stride * height;
-                ipu_cpmem_set_yuv_planar_full(ch, pixel_format, stride,
-                                              u_offset, 0);
+                v_offset = 0;
                 break;
+        default:
+                return;
         }
+        ipu_cpmem_set_yuv_planar_full(ch, uv_stride, u_offset, v_offset);
 }
 EXPORT_SYMBOL_GPL(ipu_cpmem_set_yuv_planar);
 
@@ -684,17 +672,25 @@ int ipu_cpmem_set_image(struct ipuv3_channel *ch, struct ipu_image *image)
 
         switch (pix->pixelformat) {
         case V4L2_PIX_FMT_YUV420:
-        case V4L2_PIX_FMT_YVU420:
                 offset = Y_OFFSET(pix, image->rect.left, image->rect.top);
                 u_offset = U_OFFSET(pix, image->rect.left,
                                     image->rect.top) - offset;
                 v_offset = V_OFFSET(pix, image->rect.left,
                                     image->rect.top) - offset;
 
-                ipu_cpmem_set_yuv_planar_full(ch, pix->pixelformat,
-                                              pix->bytesperline,
+                ipu_cpmem_set_yuv_planar_full(ch, pix->bytesperline / 2,
                                               u_offset, v_offset);
                 break;
+        case V4L2_PIX_FMT_YVU420:
+                offset = Y_OFFSET(pix, image->rect.left, image->rect.top);
+                u_offset = U_OFFSET(pix, image->rect.left,
+                                    image->rect.top) - offset;
+                v_offset = V_OFFSET(pix, image->rect.left,
+                                    image->rect.top) - offset;
+
+                ipu_cpmem_set_yuv_planar_full(ch, pix->bytesperline / 2,
+                                              v_offset, u_offset);
+                break;
         case V4L2_PIX_FMT_YUV422P:
                 offset = Y_OFFSET(pix, image->rect.left, image->rect.top);
                 u_offset = U2_OFFSET(pix, image->rect.left,
@@ -702,8 +698,7 @@ int ipu_cpmem_set_image(struct ipuv3_channel *ch, struct ipu_image *image)
                 v_offset = V2_OFFSET(pix, image->rect.left,
                                      image->rect.top) - offset;
 
-                ipu_cpmem_set_yuv_planar_full(ch, pix->pixelformat,
-                                              pix->bytesperline,
+                ipu_cpmem_set_yuv_planar_full(ch, pix->bytesperline / 2,
                                               u_offset, v_offset);
                 break;
         case V4L2_PIX_FMT_NV12:
@@ -712,8 +707,7 @@ int ipu_cpmem_set_image(struct ipuv3_channel *ch, struct ipu_image *image)
                                      image->rect.top) - offset;
                 v_offset = 0;
 
-                ipu_cpmem_set_yuv_planar_full(ch, pix->pixelformat,
-                                              pix->bytesperline,
+                ipu_cpmem_set_yuv_planar_full(ch, pix->bytesperline,
                                               u_offset, v_offset);
                 break;
         case V4L2_PIX_FMT_NV16:
@@ -722,8 +716,7 @@ int ipu_cpmem_set_image(struct ipuv3_channel *ch, struct ipu_image *image)
                                       image->rect.top) - offset;
                 v_offset = 0;
 
-                ipu_cpmem_set_yuv_planar_full(ch, pix->pixelformat,
-                                              pix->bytesperline,
+                ipu_cpmem_set_yuv_planar_full(ch, pix->bytesperline,
                                               u_offset, v_offset);
                 break;
         case V4L2_PIX_FMT_UYVY:
diff --git a/drivers/gpu/ipu-v3/ipu-dmfc.c b/drivers/gpu/ipu-v3/ipu-dmfc.c
index 042c3958e2a0..837b1ec22800 100644
--- a/drivers/gpu/ipu-v3/ipu-dmfc.c
+++ b/drivers/gpu/ipu-v3/ipu-dmfc.c
@@ -350,11 +350,13 @@ out:
 }
 EXPORT_SYMBOL_GPL(ipu_dmfc_alloc_bandwidth);
 
-int ipu_dmfc_init_channel(struct dmfc_channel *dmfc, int width)
+void ipu_dmfc_config_wait4eot(struct dmfc_channel *dmfc, int width)
 {
         struct ipu_dmfc_priv *priv = dmfc->priv;
         u32 dmfc_gen1;
 
+        mutex_lock(&priv->mutex);
+
         dmfc_gen1 = readl(priv->base + DMFC_GENERAL1);
 
         if ((dmfc->slots * 64 * 4) / width > dmfc->data->max_fifo_lines)
@@ -364,9 +366,9 @@ int ipu_dmfc_init_channel(struct dmfc_channel *dmfc, int width)
 
         writel(dmfc_gen1, priv->base + DMFC_GENERAL1);
 
-        return 0;
+        mutex_unlock(&priv->mutex);
 }
-EXPORT_SYMBOL_GPL(ipu_dmfc_init_channel);
+EXPORT_SYMBOL_GPL(ipu_dmfc_config_wait4eot);
 
 struct dmfc_channel *ipu_dmfc_get(struct ipu_soc *ipu, int ipu_channel)
 {
diff --git a/drivers/hid/hid-core.c b/drivers/hid/hid-core.c
index bdb8cc89cacc..4f9c5c6deaed 100644
--- a/drivers/hid/hid-core.c
+++ b/drivers/hid/hid-core.c
@@ -1979,6 +1979,9 @@ static const struct hid_device_id hid_have_special_driver[] = {
         { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_TYPE_COVER_PRO_3_2) },
         { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_TYPE_COVER_PRO_3_JP) },
         { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_TYPE_COVER_3) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_DIGITAL_MEDIA_7K) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_DIGITAL_MEDIA_600) },
+        { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_DIGITAL_MEDIA_3KV1) },
         { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_POWER_COVER) },
         { HID_USB_DEVICE(USB_VENDOR_ID_MONTEREY, USB_DEVICE_ID_GENIUS_KB29E) },
         { HID_USB_DEVICE(USB_VENDOR_ID_MSI, USB_DEVICE_ID_MSI_GT683R_LED_PANEL) },
diff --git a/drivers/hid/hid-ids.h b/drivers/hid/hid-ids.h
index 5c0e43ed5c53..0238f0169e48 100644
--- a/drivers/hid/hid-ids.h
+++ b/drivers/hid/hid-ids.h
@@ -259,6 +259,7 @@
 #define USB_DEVICE_ID_CORSAIR_K90       0x1b02
 
 #define USB_VENDOR_ID_CREATIVELABS      0x041e
+#define USB_DEVICE_ID_CREATIVE_SB_OMNI_SURROUND_51      0x322c
 #define USB_DEVICE_ID_PRODIKEYS_PCMIDI  0x2801
 
 #define USB_VENDOR_ID_CVTOUCH           0x1ff7
@@ -676,6 +677,7 @@
 #define USB_DEVICE_ID_SIDEWINDER_GV     0x003b
 #define USB_DEVICE_ID_MS_OFFICE_KB      0x0048
 #define USB_DEVICE_ID_WIRELESS_OPTICAL_DESKTOP_3_0 0x009d
+#define USB_DEVICE_ID_MS_DIGITAL_MEDIA_7K 0x00b4
 #define USB_DEVICE_ID_MS_NE4K           0x00db
 #define USB_DEVICE_ID_MS_NE4K_JP        0x00dc
 #define USB_DEVICE_ID_MS_LK6K           0x00f9
@@ -683,6 +685,8 @@
 #define USB_DEVICE_ID_MS_PRESENTER_8K_USB       0x0713
 #define USB_DEVICE_ID_MS_NE7K           0x071d
 #define USB_DEVICE_ID_MS_DIGITAL_MEDIA_3K       0x0730
+#define USB_DEVICE_ID_MS_DIGITAL_MEDIA_3KV1 0x0732
+#define USB_DEVICE_ID_MS_DIGITAL_MEDIA_600  0x0750
 #define USB_DEVICE_ID_MS_COMFORT_MOUSE_4500     0x076c
 #define USB_DEVICE_ID_MS_COMFORT_KEYBOARD 0x00e3
 #define USB_DEVICE_ID_MS_SURFACE_PRO_2   0x0799
diff --git a/drivers/hid/hid-lenovo.c b/drivers/hid/hid-lenovo.c
index 0125e356bd8d..1ac4ff4d57a6 100644
--- a/drivers/hid/hid-lenovo.c
+++ b/drivers/hid/hid-lenovo.c
@@ -184,21 +184,31 @@ static int lenovo_send_cmd_cptkbd(struct hid_device *hdev,
                         unsigned char byte2, unsigned char byte3)
 {
         int ret;
-        unsigned char buf[] = {0x18, byte2, byte3};
+        unsigned char *buf;
+
+        buf = kzalloc(3, GFP_KERNEL);
+        if (!buf)
+                return -ENOMEM;
+
+        buf[0] = 0x18;
+        buf[1] = byte2;
+        buf[2] = byte3;
 
         switch (hdev->product) {
         case USB_DEVICE_ID_LENOVO_CUSBKBD:
-                ret = hid_hw_raw_request(hdev, 0x13, buf, sizeof(buf),
+                ret = hid_hw_raw_request(hdev, 0x13, buf, 3,
                                         HID_FEATURE_REPORT, HID_REQ_SET_REPORT);
                 break;
         case USB_DEVICE_ID_LENOVO_CBTKBD:
-                ret = hid_hw_output_report(hdev, buf, sizeof(buf));
+                ret = hid_hw_output_report(hdev, buf, 3);
                 break;
         default:
                 ret = -EINVAL;
                 break;
         }
 
+        kfree(buf);
+
         return ret < 0 ? ret : 0; /* BT returns 0, USB returns sizeof(buf) */
 }
 
diff --git a/drivers/hid/hid-microsoft.c b/drivers/hid/hid-microsoft.c
index 75cd3bc59c54..e924d555536c 100644
--- a/drivers/hid/hid-microsoft.c
+++ b/drivers/hid/hid-microsoft.c
@@ -272,6 +272,12 @@ static const struct hid_device_id ms_devices[] = {
                 .driver_data = MS_PRESENTER },
         { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_DIGITAL_MEDIA_3K),
                 .driver_data = MS_ERGONOMY | MS_RDESC_3K },
+        { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_DIGITAL_MEDIA_7K),
+                .driver_data = MS_ERGONOMY },
+        { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_DIGITAL_MEDIA_600),
+                .driver_data = MS_ERGONOMY },
+        { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_DIGITAL_MEDIA_3KV1),
+                .driver_data = MS_ERGONOMY },
         { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_WIRELESS_OPTICAL_DESKTOP_3_0),
                 .driver_data = MS_NOGET },
         { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_COMFORT_MOUSE_4500),
diff --git a/drivers/hid/hid-multitouch.c b/drivers/hid/hid-multitouch.c
index 25d3c4330bf6..c741f5e50a66 100644
--- a/drivers/hid/hid-multitouch.c
+++ b/drivers/hid/hid-multitouch.c
@@ -1169,6 +1169,7 @@ static void mt_release_contacts(struct hid_device *hid)
                                                            MT_TOOL_FINGER,
                                                            false);
                         }
+                        input_mt_sync_frame(input_dev);
                         input_sync(input_dev);
                 }
         }
diff --git a/drivers/hid/hid-wiimote-modules.c b/drivers/hid/hid-wiimote-modules.c
index 4390eee2ce84..c830ed39348f 100644
--- a/drivers/hid/hid-wiimote-modules.c
+++ b/drivers/hid/hid-wiimote-modules.c
@@ -2049,9 +2049,11 @@ static void wiimod_mp_in_mp(struct wiimote_data *wdata, const __u8 *ext)
          *   -----+------------------------------+-----+-----+
          * The single bits Yaw, Roll, Pitch in the lower right corner specify
          * whether the wiimote is rotating fast (0) or slow (1). Speed for slow
-         * roation is 440 deg/s and for fast rotation 2000 deg/s. To get a
-         * linear scale we multiply by 2000/440 = ~4.5454 which is 18 for fast
-         * and 9 for slow.
+         * roation is 8192/440 units / deg/s and for fast rotation 8192/2000
+         * units / deg/s. To get a linear scale for fast rotation we multiply
+         * by 2000/440 = ~4.5454 and scale both fast and slow by 9 to match the
+         * previous scale reported by this driver.
+         * This leaves a linear scale with 8192*9/440 (~167.564) units / deg/s.
          * If the wiimote is not rotating the sensor reports 2^13 = 8192.
          * Ext specifies whether an extension is connected to the motionp.
          * which is parsed by wiimote-core.
@@ -2070,15 +2072,15 @@ static void wiimod_mp_in_mp(struct wiimote_data *wdata, const __u8 *ext)
         z -= 8192;
 
         if (!(ext[3] & 0x02))
-                x *= 18;
+                x = (x * 2000 * 9) / 440;
         else
                 x *= 9;
         if (!(ext[4] & 0x02))
-                y *= 18;
+                y = (y * 2000 * 9) / 440;
         else
                 y *= 9;
         if (!(ext[3] & 0x01))
-                z *= 18;
+                z = (z * 2000 * 9) / 440;
         else
                 z *= 9;
 
diff --git a/drivers/hid/usbhid/hid-core.c b/drivers/hid/usbhid/hid-core.c
index ad71160b9ea4..ae83af649a60 100644
--- a/drivers/hid/usbhid/hid-core.c
+++ b/drivers/hid/usbhid/hid-core.c
@@ -951,14 +951,6 @@ static int usbhid_output_report(struct hid_device *hid, __u8 *buf, size_t count)
         return ret;
 }
 
-static void usbhid_restart_queues(struct usbhid_device *usbhid)
-{
-        if (usbhid->urbout && !test_bit(HID_OUT_RUNNING, &usbhid->iofl))
-                usbhid_restart_out_queue(usbhid);
-        if (!test_bit(HID_CTRL_RUNNING, &usbhid->iofl))
-                usbhid_restart_ctrl_queue(usbhid);
-}
-
 static void hid_free_buffers(struct usb_device *dev, struct hid_device *hid)
 {
         struct usbhid_device *usbhid = hid->driver_data;
@@ -1404,6 +1396,37 @@ static void hid_cease_io(struct usbhid_device *usbhid)
         usb_kill_urb(usbhid->urbout);
 }
 
+static void hid_restart_io(struct hid_device *hid)
+{
+        struct usbhid_device *usbhid = hid->driver_data;
+        int clear_halt = test_bit(HID_CLEAR_HALT, &usbhid->iofl);
+        int reset_pending = test_bit(HID_RESET_PENDING, &usbhid->iofl);
+
+        spin_lock_irq(&usbhid->lock);
+        clear_bit(HID_SUSPENDED, &usbhid->iofl);
+        usbhid_mark_busy(usbhid);
+
+        if (clear_halt || reset_pending)
+                schedule_work(&usbhid->reset_work);
+        usbhid->retry_delay = 0;
+        spin_unlock_irq(&usbhid->lock);
+
+        if (reset_pending || !test_bit(HID_STARTED, &usbhid->iofl))
+                return;
+
+        if (!clear_halt) {
+                if (hid_start_in(hid) < 0)
+                        hid_io_error(hid);
+        }
+
+        spin_lock_irq(&usbhid->lock);
+        if (usbhid->urbout && !test_bit(HID_OUT_RUNNING, &usbhid->iofl))
+                usbhid_restart_out_queue(usbhid);
+        if (!test_bit(HID_CTRL_RUNNING, &usbhid->iofl))
+                usbhid_restart_ctrl_queue(usbhid);
+        spin_unlock_irq(&usbhid->lock);
+}
+
 /* Treat USB reset pretty much the same as suspend/resume */
 static int hid_pre_reset(struct usb_interface *intf)
 {
@@ -1453,14 +1476,14 @@ static int hid_post_reset(struct usb_interface *intf)
                 return 1;
         }
 
+        /* No need to do another reset or clear a halted endpoint */
         spin_lock_irq(&usbhid->lock);
         clear_bit(HID_RESET_PENDING, &usbhid->iofl);
+        clear_bit(HID_CLEAR_HALT, &usbhid->iofl);
         spin_unlock_irq(&usbhid->lock);
         hid_set_idle(dev, intf->cur_altsetting->desc.bInterfaceNumber, 0, 0);
-        status = hid_start_in(hid);
-        if (status < 0)
-                hid_io_error(hid);
-        usbhid_restart_queues(usbhid);
+
+        hid_restart_io(hid);
 
         return 0;
 }
@@ -1483,25 +1506,9 @@ void usbhid_put_power(struct hid_device *hid)
 #ifdef CONFIG_PM
 static int hid_resume_common(struct hid_device *hid, bool driver_suspended)
 {
-        struct usbhid_device *usbhid = hid->driver_data;
-        int status;
-
-        spin_lock_irq(&usbhid->lock);
-        clear_bit(HID_SUSPENDED, &usbhid->iofl);
-        usbhid_mark_busy(usbhid);
-
-        if (test_bit(HID_CLEAR_HALT, &usbhid->iofl) ||
-                        test_bit(HID_RESET_PENDING, &usbhid->iofl))
-                schedule_work(&usbhid->reset_work);
-        usbhid->retry_delay = 0;
-
-        usbhid_restart_queues(usbhid);
-        spin_unlock_irq(&usbhid->lock);
-
-        status = hid_start_in(hid);
-        if (status < 0)
-                hid_io_error(hid);
+        int status = 0;
 
+        hid_restart_io(hid);
         if (driver_suspended && hid->driver && hid->driver->resume)
                 status = hid->driver->resume(hid);
         return status;
@@ -1570,12 +1577,8 @@ static int hid_suspend(struct usb_interface *intf, pm_message_t message)
 static int hid_resume(struct usb_interface *intf)
 {
         struct hid_device *hid = usb_get_intfdata (intf);
-        struct usbhid_device *usbhid = hid->driver_data;
         int status;
 
-        if (!test_bit(HID_STARTED, &usbhid->iofl))
-                return 0;
-
         status = hid_resume_common(hid, true);
         dev_dbg(&intf->dev, "resume status %d\n", status);
         return 0;
@@ -1584,10 +1587,8 @@ static int hid_resume(struct usb_interface *intf)
 static int hid_reset_resume(struct usb_interface *intf)
 {
         struct hid_device *hid = usb_get_intfdata(intf);
-        struct usbhid_device *usbhid = hid->driver_data;
         int status;
 
-        clear_bit(HID_SUSPENDED, &usbhid->iofl);
         status = hid_post_reset(intf);
         if (status >= 0 && hid->driver && hid->driver->reset_resume) {
                 int ret = hid->driver->reset_resume(hid);
diff --git a/drivers/hid/usbhid/hid-quirks.c b/drivers/hid/usbhid/hid-quirks.c
index ed2f68edc8f1..53fc856d6867 100644
--- a/drivers/hid/usbhid/hid-quirks.c
+++ b/drivers/hid/usbhid/hid-quirks.c
@@ -71,6 +71,7 @@ static const struct hid_blacklist {
         { USB_VENDOR_ID_CH, USB_DEVICE_ID_CH_3AXIS_5BUTTON_STICK, HID_QUIRK_NOGET },
         { USB_VENDOR_ID_CH, USB_DEVICE_ID_CH_AXIS_295, HID_QUIRK_NOGET },
         { USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_CHICONY_PIXART_USB_OPTICAL_MOUSE, HID_QUIRK_ALWAYS_POLL },
+        { USB_VENDOR_ID_CREATIVELABS, USB_DEVICE_ID_CREATIVE_SB_OMNI_SURROUND_51, HID_QUIRK_NOGET },
         { USB_VENDOR_ID_DMI, USB_DEVICE_ID_DMI_ENC, HID_QUIRK_NOGET },
         { USB_VENDOR_ID_DRAGONRISE, USB_DEVICE_ID_DRAGONRISE_WIIU, HID_QUIRK_MULTI_INPUT },
         { USB_VENDOR_ID_ELAN, HID_ANY_ID, HID_QUIRK_ALWAYS_POLL },
diff --git a/drivers/hid/wacom_sys.c b/drivers/hid/wacom_sys.c
index 68a560957871..ccf1883318c3 100644
--- a/drivers/hid/wacom_sys.c
+++ b/drivers/hid/wacom_sys.c
@@ -152,6 +152,25 @@ static void wacom_feature_mapping(struct hid_device *hdev,
                 hid_data->inputmode = field->report->id;
                 hid_data->inputmode_index = usage->usage_index;
                 break;
+
+        case HID_UP_DIGITIZER:
+                if (field->report->id == 0x0B &&
+                    (field->application == WACOM_G9_DIGITIZER ||
+                     field->application == WACOM_G11_DIGITIZER)) {
+                        wacom->wacom_wac.mode_report = field->report->id;
+                        wacom->wacom_wac.mode_value = 0;
+                }
+                break;
+
+        case WACOM_G9_PAGE:
+        case WACOM_G11_PAGE:
+                if (field->report->id == 0x03 &&
+                    (field->application == WACOM_G9_TOUCHSCREEN ||
+                     field->application == WACOM_G11_TOUCHSCREEN)) {
+                        wacom->wacom_wac.mode_report = field->report->id;
+                        wacom->wacom_wac.mode_value = 0;
+                }
+                break;
         }
 }
 
@@ -322,26 +341,41 @@ static int wacom_hid_set_device_mode(struct hid_device *hdev)
         return 0;
 }
 
-static int wacom_set_device_mode(struct hid_device *hdev, int report_id,
-                int length, int mode)
+static int wacom_set_device_mode(struct hid_device *hdev,
+                                 struct wacom_wac *wacom_wac)
 {
-        unsigned char *rep_data;
+        u8 *rep_data;
+        struct hid_report *r;
+        struct hid_report_enum *re;
+        int length;
         int error = -ENOMEM, limit = 0;
 
-        rep_data = kzalloc(length, GFP_KERNEL);
+        if (wacom_wac->mode_report < 0)
+                return 0;
+
+        re = &(hdev->report_enum[HID_FEATURE_REPORT]);
+        r = re->report_id_hash[wacom_wac->mode_report];
+        if (!r)
+                return -EINVAL;
+
+        rep_data = hid_alloc_report_buf(r, GFP_KERNEL);
         if (!rep_data)
-                return error;
+                return -ENOMEM;
+
+        length = hid_report_len(r);
 
         do {
-                rep_data[0] = report_id;
-                rep_data[1] = mode;
+                rep_data[0] = wacom_wac->mode_report;
+                rep_data[1] = wacom_wac->mode_value;
 
                 error = wacom_set_report(hdev, HID_FEATURE_REPORT, rep_data,
                                          length, 1);
                 if (error >= 0)
                         error = wacom_get_report(hdev, HID_FEATURE_REPORT,
                                                  rep_data, length, 1);
-        } while (error >= 0 && rep_data[1] != mode && limit++ < WAC_MSG_RETRIES);
+        } while (error >= 0 &&
+                 rep_data[1] != wacom_wac->mode_report &&
+                 limit++ < WAC_MSG_RETRIES);
 
         kfree(rep_data);
 
@@ -411,32 +445,41 @@ static int wacom_bt_query_tablet_data(struct hid_device *hdev, u8 speed,
 static int wacom_query_tablet_data(struct hid_device *hdev,
                 struct wacom_features *features)
 {
+        struct wacom *wacom = hid_get_drvdata(hdev);
+        struct wacom_wac *wacom_wac = &wacom->wacom_wac;
+
         if (hdev->bus == BUS_BLUETOOTH)
                 return wacom_bt_query_tablet_data(hdev, 1, features);
 
-        if (features->type == HID_GENERIC)
-                return wacom_hid_set_device_mode(hdev);
-
-        if (features->device_type & WACOM_DEVICETYPE_TOUCH) {
-                if (features->type > TABLETPC) {
-                        /* MT Tablet PC touch */
-                        return wacom_set_device_mode(hdev, 3, 4, 4);
-                }
-                else if (features->type == WACOM_24HDT) {
-                        return wacom_set_device_mode(hdev, 18, 3, 2);
-                }
-                else if (features->type == WACOM_27QHDT) {
-                        return wacom_set_device_mode(hdev, 131, 3, 2);
-                }
-                else if (features->type == BAMBOO_PAD) {
-                        return wacom_set_device_mode(hdev, 2, 2, 2);
-                }
-        } else if (features->device_type & WACOM_DEVICETYPE_PEN) {
-                if (features->type <= BAMBOO_PT) {
-                        return wacom_set_device_mode(hdev, 2, 2, 2);
+        if (features->type != HID_GENERIC) {
+                if (features->device_type & WACOM_DEVICETYPE_TOUCH) {
+                        if (features->type > TABLETPC) {
+                                /* MT Tablet PC touch */
+                                wacom_wac->mode_report = 3;
+                                wacom_wac->mode_value = 4;
+                        } else if (features->type == WACOM_24HDT) {
+                                wacom_wac->mode_report = 18;
+                                wacom_wac->mode_value = 2;
+                        } else if (features->type == WACOM_27QHDT) {
+                                wacom_wac->mode_report = 131;
+                                wacom_wac->mode_value = 2;
+                        } else if (features->type == BAMBOO_PAD) {
+                                wacom_wac->mode_report = 2;
+                                wacom_wac->mode_value = 2;
+                        }
+                } else if (features->device_type & WACOM_DEVICETYPE_PEN) {
+                        if (features->type <= BAMBOO_PT) {
+                                wacom_wac->mode_report = 2;
+                                wacom_wac->mode_value = 2;
+                        }
                 }
         }
 
+        wacom_set_device_mode(hdev, wacom_wac);
+
+        if (features->type == HID_GENERIC)
+                return wacom_hid_set_device_mode(hdev);
+
         return 0;
 }
 
@@ -1817,6 +1860,9 @@ static int wacom_probe(struct hid_device *hdev,
                 goto fail_type;
         }
 
+        wacom_wac->hid_data.inputmode = -1;
+        wacom_wac->mode_report = -1;
+
         wacom->usbdev = dev;
         wacom->intf = intf;
         mutex_init(&wacom->lock);
diff --git a/drivers/hid/wacom_wac.c b/drivers/hid/wacom_wac.c
index bd198bbd4df0..cf2ba43453fd 100644
--- a/drivers/hid/wacom_wac.c
+++ b/drivers/hid/wacom_wac.c
@@ -684,6 +684,7 @@ static int wacom_intuos_inout(struct wacom_wac *wacom)
 
                 wacom->tool[idx] = wacom_intuos_get_tool_type(wacom->id[idx]);
 
+                wacom->shared->stylus_in_proximity = true;
                 return 1;
         }
 
@@ -2426,6 +2427,17 @@ void wacom_setup_device_quirks(struct wacom *wacom)
         }
 
         /*
+         * Hack for the Bamboo One:
+         * the device presents a PAD/Touch interface as most Bamboos and even
+         * sends ghosts PAD data on it. However, later, we must disable this
+         * ghost interface, and we can not detect it unless we set it here
+         * to WACOM_DEVICETYPE_PAD or WACOM_DEVICETYPE_TOUCH.
+         */
+        if (features->type == BAMBOO_PEN &&
+            features->pktlen == WACOM_PKGLEN_BBTOUCH3)
+                features->device_type |= WACOM_DEVICETYPE_PAD;
+
+        /*
          * Raw Wacom-mode pen and touch events both come from interface
          * 0, whose HID descriptor has an application usage of 0xFF0D
          * (i.e., WACOM_VENDORDEFINED_PEN). We route pen packets back
@@ -3384,6 +3396,10 @@ static const struct wacom_features wacom_features_0x33E =
         { "Wacom Intuos PT M 2", 21600, 13500, 2047, 63,
           INTUOSHT2, WACOM_INTUOS_RES, WACOM_INTUOS_RES, .touch_max = 16,
           .check_for_hid_type = true, .hid_type = HID_TYPE_USBNONE };
+static const struct wacom_features wacom_features_0x343 =
+        { "Wacom DTK1651", 34616, 19559, 1023, 0,
+          DTUS, WACOM_INTUOS_RES, WACOM_INTUOS_RES, 4,
+          WACOM_DTU_OFFSET, WACOM_DTU_OFFSET };
 
 static const struct wacom_features wacom_features_HID_ANY_ID =
         { "Wacom HID", .type = HID_GENERIC };
@@ -3549,6 +3565,7 @@ const struct hid_device_id wacom_ids[] = {
         { USB_DEVICE_WACOM(0x33C) },
         { USB_DEVICE_WACOM(0x33D) },
         { USB_DEVICE_WACOM(0x33E) },
+        { USB_DEVICE_WACOM(0x343) },
         { USB_DEVICE_WACOM(0x4001) },
         { USB_DEVICE_WACOM(0x4004) },
         { USB_DEVICE_WACOM(0x5000) },
diff --git a/drivers/hid/wacom_wac.h b/drivers/hid/wacom_wac.h
index 25baa7f29599..e2084d914c14 100644
--- a/drivers/hid/wacom_wac.h
+++ b/drivers/hid/wacom_wac.h
@@ -84,6 +84,12 @@
 #define WACOM_DEVICETYPE_WL_MONITOR     0x0008
 
 #define WACOM_VENDORDEFINED_PEN         0xff0d0001
+#define WACOM_G9_PAGE                   0xff090000
+#define WACOM_G9_DIGITIZER              (WACOM_G9_PAGE | 0x02)
+#define WACOM_G9_TOUCHSCREEN            (WACOM_G9_PAGE | 0x11)
+#define WACOM_G11_PAGE                  0xff110000
+#define WACOM_G11_DIGITIZER             (WACOM_G11_PAGE | 0x02)
+#define WACOM_G11_TOUCHSCREEN           (WACOM_G11_PAGE | 0x11)
 
 #define WACOM_PEN_FIELD(f)      (((f)->logical == HID_DG_STYLUS) || \
                                  ((f)->physical == HID_DG_STYLUS) || \
@@ -238,6 +244,8 @@ struct wacom_wac {
         int ps_connected;
         u8 bt_features;
         u8 bt_high_speed;
+        int mode_report;
+        int mode_value;
         struct hid_data hid_data;
 };
 
diff --git a/drivers/hv/ring_buffer.c b/drivers/hv/ring_buffer.c
index 5613e2b5cff7..a40a73a7b71d 100644
--- a/drivers/hv/ring_buffer.c
+++ b/drivers/hv/ring_buffer.c
@@ -103,15 +103,29 @@ static bool hv_need_to_signal(u32 old_write, struct hv_ring_buffer_info *rbi)
  *    there is room for the producer to send the pending packet.
  */
 
-static bool hv_need_to_signal_on_read(u32 prev_write_sz,
-                                      struct hv_ring_buffer_info *rbi)
+static bool hv_need_to_signal_on_read(struct hv_ring_buffer_info *rbi)
 {
         u32 cur_write_sz;
         u32 r_size;
-        u32 write_loc = rbi->ring_buffer->write_index;
+        u32 write_loc;
         u32 read_loc = rbi->ring_buffer->read_index;
-        u32 pending_sz = rbi->ring_buffer->pending_send_sz;
+        u32 pending_sz;
 
+        /*
+         * Issue a full memory barrier before making the signaling decision.
+         * Here is the reason for having this barrier:
+         * If the reading of the pend_sz (in this function)
+         * were to be reordered and read before we commit the new read
+         * index (in the calling function)  we could
+         * have a problem. If the host were to set the pending_sz after we
+         * have sampled pending_sz and go to sleep before we commit the
+         * read index, we could miss sending the interrupt. Issue a full
+         * memory barrier to address this.
+         */
+        mb();
+
+        pending_sz = rbi->ring_buffer->pending_send_sz;
+        write_loc = rbi->ring_buffer->write_index;
         /* If the other end is not blocked on write don't bother. */
         if (pending_sz == 0)
                 return false;
@@ -120,7 +134,7 @@ static bool hv_need_to_signal_on_read(u32 prev_write_sz,
         cur_write_sz = write_loc >= read_loc ? r_size - (write_loc - read_loc) :
                         read_loc - write_loc;
 
-        if ((prev_write_sz < pending_sz) && (cur_write_sz >= pending_sz))
+        if (cur_write_sz >= pending_sz)
                 return true;
 
         return false;
@@ -455,7 +469,7 @@ int hv_ringbuffer_read(struct hv_ring_buffer_info *inring_info,
         /* Update the read index */
         hv_set_next_read_location(inring_info, next_read_location);
 
-        *signal = hv_need_to_signal_on_read(bytes_avail_towrite, inring_info);
+        *signal = hv_need_to_signal_on_read(inring_info);
 
         return ret;
 }
diff --git a/drivers/hwmon/max1111.c b/drivers/hwmon/max1111.c
index 36544c4f653c..303d0c9df907 100644
--- a/drivers/hwmon/max1111.c
+++ b/drivers/hwmon/max1111.c
@@ -85,6 +85,9 @@ static struct max1111_data *the_max1111;
 
 int max1111_read_channel(int channel)
 {
+        if (!the_max1111 || !the_max1111->spi)
+                return -ENODEV;
+
         return max1111_read(&the_max1111->spi->dev, channel);
 }
 EXPORT_SYMBOL(max1111_read_channel);
@@ -258,6 +261,9 @@ static int max1111_remove(struct spi_device *spi)
 {
         struct max1111_data *data = spi_get_drvdata(spi);
 
+#ifdef CONFIG_SHARPSL_PM
+        the_max1111 = NULL;
+#endif
         hwmon_device_unregister(data->hwmon_dev);
         sysfs_remove_group(&spi->dev.kobj, &max1110_attr_group);
         sysfs_remove_group(&spi->dev.kobj, &max1111_attr_group);
diff --git a/drivers/i2c/busses/Kconfig b/drivers/i2c/busses/Kconfig
index faa8e6821fea..0967e1a5b3a2 100644
--- a/drivers/i2c/busses/Kconfig
+++ b/drivers/i2c/busses/Kconfig
@@ -975,10 +975,10 @@ config I2C_XLR
 
 config I2C_XLP9XX
         tristate "XLP9XX I2C support"
-        depends on CPU_XLP || COMPILE_TEST
+        depends on CPU_XLP || ARCH_VULCAN || COMPILE_TEST
         help
           This driver enables support for the on-chip I2C interface of
-          the Broadcom XLP9xx/XLP5xx MIPS processors.
+          the Broadcom XLP9xx/XLP5xx MIPS and Vulcan ARM64 processors.
 
           This driver can also be built as a module.  If so, the module will
           be called i2c-xlp9xx.
diff --git a/drivers/i2c/busses/i2c-cpm.c b/drivers/i2c/busses/i2c-cpm.c
index 714bdc837769..b167ab25310a 100644
--- a/drivers/i2c/busses/i2c-cpm.c
+++ b/drivers/i2c/busses/i2c-cpm.c
@@ -116,8 +116,8 @@ struct cpm_i2c {
         cbd_t __iomem *rbase;
         u_char *txbuf[CPM_MAXBD];
         u_char *rxbuf[CPM_MAXBD];
-        u32 txdma[CPM_MAXBD];
-        u32 rxdma[CPM_MAXBD];
+        dma_addr_t txdma[CPM_MAXBD];
+        dma_addr_t rxdma[CPM_MAXBD];
 };
 
 static irqreturn_t cpm_i2c_interrupt(int irq, void *dev_id)
diff --git a/drivers/i2c/busses/i2c-exynos5.c b/drivers/i2c/busses/i2c-exynos5.c
index b29c7500461a..f54ece8fce78 100644
--- a/drivers/i2c/busses/i2c-exynos5.c
+++ b/drivers/i2c/busses/i2c-exynos5.c
@@ -671,7 +671,9 @@ static int exynos5_i2c_xfer(struct i2c_adapter *adap,
                 return -EIO;
         }
 
-        clk_prepare_enable(i2c->clk);
+        ret = clk_enable(i2c->clk);
+        if (ret)
+                return ret;
 
         for (i = 0; i < num; i++, msgs++) {
                 stop = (i == num - 1);
@@ -695,7 +697,7 @@ static int exynos5_i2c_xfer(struct i2c_adapter *adap,
         }
 
  out:
-        clk_disable_unprepare(i2c->clk);
+        clk_disable(i2c->clk);
         return ret;
 }
 
@@ -747,7 +749,9 @@ static int exynos5_i2c_probe(struct platform_device *pdev)
                 return -ENOENT;
         }
 
-        clk_prepare_enable(i2c->clk);
+        ret = clk_prepare_enable(i2c->clk);
+        if (ret)
+                return ret;
 
         mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         i2c->regs = devm_ioremap_resource(&pdev->dev, mem);
@@ -799,6 +803,10 @@ static int exynos5_i2c_probe(struct platform_device *pdev)
 
         platform_set_drvdata(pdev, i2c);
 
+        clk_disable(i2c->clk);
+
+        return 0;
+
  err_clk:
         clk_disable_unprepare(i2c->clk);
         return ret;
@@ -810,6 +818,8 @@ static int exynos5_i2c_remove(struct platform_device *pdev)
 
         i2c_del_adapter(&i2c->adap);
 
+        clk_unprepare(i2c->clk);
+
         return 0;
 }
 
@@ -821,6 +831,8 @@ static int exynos5_i2c_suspend_noirq(struct device *dev)
 
         i2c->suspended = 1;
 
+        clk_unprepare(i2c->clk);
+
         return 0;
 }
 
@@ -830,7 +842,9 @@ static int exynos5_i2c_resume_noirq(struct device *dev)
         struct exynos5_i2c *i2c = platform_get_drvdata(pdev);
         int ret = 0;
 
-        clk_prepare_enable(i2c->clk);
+        ret = clk_prepare_enable(i2c->clk);
+        if (ret)
+                return ret;
 
         ret = exynos5_hsi2c_clock_setup(i2c);
         if (ret) {
@@ -839,7 +853,7 @@ static int exynos5_i2c_resume_noirq(struct device *dev)
         }
 
         exynos5_i2c_init(i2c);
-        clk_disable_unprepare(i2c->clk);
+        clk_disable(i2c->clk);
         i2c->suspended = 0;
 
         return 0;
diff --git a/drivers/i2c/busses/i2c-ismt.c b/drivers/i2c/busses/i2c-ismt.c
index 7ba795b24e75..1c8707710098 100644
--- a/drivers/i2c/busses/i2c-ismt.c
+++ b/drivers/i2c/busses/i2c-ismt.c
@@ -75,6 +75,7 @@
 /* PCI DIDs for the Intel SMBus Message Transport (SMT) Devices */
 #define PCI_DEVICE_ID_INTEL_S1200_SMT0  0x0c59
 #define PCI_DEVICE_ID_INTEL_S1200_SMT1  0x0c5a
+#define PCI_DEVICE_ID_INTEL_DNV_SMT     0x19ac
 #define PCI_DEVICE_ID_INTEL_AVOTON_SMT  0x1f15
 
 #define ISMT_DESC_ENTRIES       2       /* number of descriptor entries */
@@ -180,6 +181,7 @@ struct ismt_priv {
 static const struct pci_device_id ismt_ids[] = {
         { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_S1200_SMT0) },
         { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_S1200_SMT1) },
+        { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_DNV_SMT) },
         { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_AVOTON_SMT) },
         { 0, }
 };
diff --git a/drivers/i2c/busses/i2c-jz4780.c b/drivers/i2c/busses/i2c-jz4780.c
index f325663c27c5..ba14a863b451 100644
--- a/drivers/i2c/busses/i2c-jz4780.c
+++ b/drivers/i2c/busses/i2c-jz4780.c
@@ -771,11 +771,16 @@ static int jz4780_i2c_probe(struct platform_device *pdev)
         ret = of_property_read_u32(pdev->dev.of_node, "clock-frequency",
                                    &clk_freq);
         if (ret) {
-                dev_err(&pdev->dev, "clock-frequency not specified in DT");
+                dev_err(&pdev->dev, "clock-frequency not specified in DT\n");
                 goto err;
         }
 
         i2c->speed = clk_freq / 1000;
+        if (i2c->speed == 0) {
+                ret = -EINVAL;
+                dev_err(&pdev->dev, "clock-frequency minimum is 1000\n");
+                goto err;
+        }
         jz4780_i2c_set_speed(i2c);
 
         dev_info(&pdev->dev, "Bus frequency is %d KHz\n", i2c->speed);
diff --git a/drivers/i2c/busses/i2c-rk3x.c b/drivers/i2c/busses/i2c-rk3x.c
index 9096d17beb5b..3dcc5f3f26cb 100644
--- a/drivers/i2c/busses/i2c-rk3x.c
+++ b/drivers/i2c/busses/i2c-rk3x.c
@@ -855,6 +855,7 @@ static struct rk3x_i2c_soc_data soc_data[3] = {
 static const struct of_device_id rk3x_i2c_match[] = {
         { .compatible = "rockchip,rk3066-i2c", .data = (void *)&soc_data[0] },
         { .compatible = "rockchip,rk3188-i2c", .data = (void *)&soc_data[1] },
+        { .compatible = "rockchip,rk3228-i2c", .data = (void *)&soc_data[2] },
         { .compatible = "rockchip,rk3288-i2c", .data = (void *)&soc_data[2] },
         {},
 };
diff --git a/drivers/i2c/i2c-core.c b/drivers/i2c/i2c-core.c
index 0f2f8484e8ec..e584d88ee337 100644
--- a/drivers/i2c/i2c-core.c
+++ b/drivers/i2c/i2c-core.c
@@ -525,22 +525,16 @@ static int i2c_device_match(struct device *dev, struct device_driver *drv)
         return 0;
 }
 
-
-/* uevent helps with hotplug: modprobe -q $(MODALIAS) */
 static int i2c_device_uevent(struct device *dev, struct kobj_uevent_env *env)
 {
-        struct i2c_client       *client = to_i2c_client(dev);
+        struct i2c_client *client = to_i2c_client(dev);
         int rc;
 
         rc = acpi_device_uevent_modalias(dev, env);
         if (rc != -ENODEV)
                 return rc;
 
-        if (add_uevent_var(env, "MODALIAS=%s%s",
-                           I2C_MODULE_PREFIX, client->name))
-                return -ENOMEM;
-        dev_dbg(dev, "uevent\n");
-        return 0;
+        return add_uevent_var(env, "MODALIAS=%s%s", I2C_MODULE_PREFIX, client->name);
 }
 
 /* i2c bus recovery routines */
diff --git a/drivers/i2c/muxes/i2c-demux-pinctrl.c b/drivers/i2c/muxes/i2c-demux-pinctrl.c
index 7748a0a5ddb9..8de073aed001 100644
--- a/drivers/i2c/muxes/i2c-demux-pinctrl.c
+++ b/drivers/i2c/muxes/i2c-demux-pinctrl.c
@@ -140,22 +140,34 @@ static int i2c_demux_change_master(struct i2c_demux_pinctrl_priv *priv, u32 new_
         return i2c_demux_activate_master(priv, new_chan);
 }
 
-static ssize_t cur_master_show(struct device *dev, struct device_attribute *attr,
-                           char *buf)
+static ssize_t available_masters_show(struct device *dev,
+                                      struct device_attribute *attr,
+                                      char *buf)
 {
         struct i2c_demux_pinctrl_priv *priv = dev_get_drvdata(dev);
         int count = 0, i;
 
         for (i = 0; i < priv->num_chan && count < PAGE_SIZE; i++)
-                count += scnprintf(buf + count, PAGE_SIZE - count, "%c %d - %s\n",
-                                 i == priv->cur_chan ? '*' : ' ', i,
-                                 priv->chan[i].parent_np->full_name);
+                count += scnprintf(buf + count, PAGE_SIZE - count, "%d:%s%c",
+                                   i, priv->chan[i].parent_np->full_name,
+                                   i == priv->num_chan - 1 ? '\n' : ' ');
 
         return count;
 }
+static DEVICE_ATTR_RO(available_masters);
 
-static ssize_t cur_master_store(struct device *dev, struct device_attribute *attr,
-                            const char *buf, size_t count)
+static ssize_t current_master_show(struct device *dev,
+                                   struct device_attribute *attr,
+                                   char *buf)
+{
+        struct i2c_demux_pinctrl_priv *priv = dev_get_drvdata(dev);
+
+        return sprintf(buf, "%d\n", priv->cur_chan);
+}
+
+static ssize_t current_master_store(struct device *dev,
+                                    struct device_attribute *attr,
+                                    const char *buf, size_t count)
 {
         struct i2c_demux_pinctrl_priv *priv = dev_get_drvdata(dev);
         unsigned int val;
@@ -172,7 +184,7 @@ static ssize_t cur_master_store(struct device *dev, struct device_attribute *att
 
         return ret < 0 ? ret : count;
 }
-static DEVICE_ATTR_RW(cur_master);
+static DEVICE_ATTR_RW(current_master);
 
 static int i2c_demux_pinctrl_probe(struct platform_device *pdev)
 {
@@ -218,12 +230,18 @@ static int i2c_demux_pinctrl_probe(struct platform_device *pdev)
         /* switch to first parent as active master */
         i2c_demux_activate_master(priv, 0);
 
-        err = device_create_file(&pdev->dev, &dev_attr_cur_master);
+        err = device_create_file(&pdev->dev, &dev_attr_available_masters);
         if (err)
                 goto err_rollback;
 
+        err = device_create_file(&pdev->dev, &dev_attr_current_master);
+        if (err)
+                goto err_rollback_available;
+
         return 0;
 
+err_rollback_available:
+        device_remove_file(&pdev->dev, &dev_attr_available_masters);
 err_rollback:
         for (j = 0; j < i; j++) {
                 of_node_put(priv->chan[j].parent_np);
@@ -238,7 +256,8 @@ static int i2c_demux_pinctrl_remove(struct platform_device *pdev)
         struct i2c_demux_pinctrl_priv *priv = platform_get_drvdata(pdev);
         int i;
 
-        device_remove_file(&pdev->dev, &dev_attr_cur_master);
+        device_remove_file(&pdev->dev, &dev_attr_current_master);
+        device_remove_file(&pdev->dev, &dev_attr_available_masters);
 
         i2c_demux_deactivate_master(priv);
 
diff --git a/drivers/ide/icside.c b/drivers/ide/icside.c
index 9f0a48e39b8a..80e933b296f6 100644
--- a/drivers/ide/icside.c
+++ b/drivers/ide/icside.c
@@ -451,7 +451,7 @@ err_free:
         return ret;
 }
 
-static const struct ide_port_info icside_v6_port_info __initconst = {
+static const struct ide_port_info icside_v6_port_info = {
         .init_dma               = icside_dma_off_init,
         .port_ops               = &icside_v6_no_dma_port_ops,
         .host_flags             = IDE_HFLAG_SERIALIZE | IDE_HFLAG_MMIO,
diff --git a/drivers/ide/palm_bk3710.c b/drivers/ide/palm_bk3710.c
index 8012e43bf8f6..46427ea01753 100644
--- a/drivers/ide/palm_bk3710.c
+++ b/drivers/ide/palm_bk3710.c
@@ -325,6 +325,8 @@ static int __init palm_bk3710_probe(struct platform_device *pdev)
 
         clk_enable(clk);
         rate = clk_get_rate(clk);
+        if (!rate)
+                return -EINVAL;
 
         /* NOTE:  round *down* to meet minimum timings; we count in clocks */
         ideclk_period = 1000000000UL / rate;
diff --git a/drivers/idle/intel_idle.c b/drivers/idle/intel_idle.c
index ba947df5a8c7..c6935de425fa 100644
--- a/drivers/idle/intel_idle.c
+++ b/drivers/idle/intel_idle.c
@@ -660,6 +660,35 @@ static struct cpuidle_state skl_cstates[] = {
                 .enter = NULL }
 };
 
+static struct cpuidle_state skx_cstates[] = {
+        {
+                .name = "C1-SKX",
+                .desc = "MWAIT 0x00",
+                .flags = MWAIT2flg(0x00),
+                .exit_latency = 2,
+                .target_residency = 2,
+                .enter = &intel_idle,
+                .enter_freeze = intel_idle_freeze, },
+        {
+                .name = "C1E-SKX",
+                .desc = "MWAIT 0x01",
+                .flags = MWAIT2flg(0x01),
+                .exit_latency = 10,
+                .target_residency = 20,
+                .enter = &intel_idle,
+                .enter_freeze = intel_idle_freeze, },
+        {
+                .name = "C6-SKX",
+                .desc = "MWAIT 0x20",
+                .flags = MWAIT2flg(0x20) | CPUIDLE_FLAG_TLB_FLUSHED,
+                .exit_latency = 133,
+                .target_residency = 600,
+                .enter = &intel_idle,
+                .enter_freeze = intel_idle_freeze, },
+        {
+                .enter = NULL }
+};
+
 static struct cpuidle_state atom_cstates[] = {
         {
                 .name = "C1E-ATM",
@@ -818,8 +847,11 @@ static int cpu_hotplug_notify(struct notifier_block *n,
                  * driver in this case
                  */
                 dev = per_cpu_ptr(intel_idle_cpuidle_devices, hotcpu);
-                if (!dev->registered)
-                        intel_idle_cpu_init(hotcpu);
+                if (dev->registered)
+                        break;
+
+                if (intel_idle_cpu_init(hotcpu))
+                        return NOTIFY_BAD;
 
                 break;
         }
@@ -904,6 +936,10 @@ static const struct idle_cpu idle_cpu_skl = {
         .disable_promotion_to_c1e = true,
 };
 
+static const struct idle_cpu idle_cpu_skx = {
+        .state_table = skx_cstates,
+        .disable_promotion_to_c1e = true,
+};
 
 static const struct idle_cpu idle_cpu_avn = {
         .state_table = avn_cstates,
@@ -945,6 +981,9 @@ static const struct x86_cpu_id intel_idle_ids[] __initconst = {
         ICPU(0x56, idle_cpu_bdw),
         ICPU(0x4e, idle_cpu_skl),
         ICPU(0x5e, idle_cpu_skl),
+        ICPU(0x8e, idle_cpu_skl),
+        ICPU(0x9e, idle_cpu_skl),
+        ICPU(0x55, idle_cpu_skx),
         ICPU(0x57, idle_cpu_knl),
         {}
 };
@@ -987,22 +1026,15 @@ static int __init intel_idle_probe(void)
         icpu = (const struct idle_cpu *)id->driver_data;
         cpuidle_state_table = icpu->state_table;
 
-        if (boot_cpu_has(X86_FEATURE_ARAT))     /* Always Reliable APIC Timer */
-                lapic_timer_reliable_states = LAPIC_TIMER_ALWAYS_RELIABLE;
-        else
-                on_each_cpu(__setup_broadcast_timer, (void *)true, 1);
-
         pr_debug(PREFIX "v" INTEL_IDLE_VERSION
                 " model 0x%X\n", boot_cpu_data.x86_model);
 
-        pr_debug(PREFIX "lapic_timer_reliable_states 0x%x\n",
-                lapic_timer_reliable_states);
         return 0;
 }
 
 /*
  * intel_idle_cpuidle_devices_uninit()
- * unregister, free cpuidle_devices
+ * Unregisters the cpuidle devices.
  */
 static void intel_idle_cpuidle_devices_uninit(void)
 {
@@ -1013,9 +1045,6 @@ static void intel_idle_cpuidle_devices_uninit(void)
                 dev = per_cpu_ptr(intel_idle_cpuidle_devices, i);
                 cpuidle_unregister_device(dev);
         }
-
-        free_percpu(intel_idle_cpuidle_devices);
-        return;
 }
 
 /*
@@ -1111,7 +1140,7 @@ static void intel_idle_state_table_update(void)
  * intel_idle_cpuidle_driver_init()
  * allocate, initialize cpuidle_states
  */
-static int __init intel_idle_cpuidle_driver_init(void)
+static void __init intel_idle_cpuidle_driver_init(void)
 {
         int cstate;
         struct cpuidle_driver *drv = &intel_idle_driver;
@@ -1163,18 +1192,10 @@ static int __init intel_idle_cpuidle_driver_init(void)
                 drv->state_count += 1;
         }
 
-        if (icpu->auto_demotion_disable_flags)
-                on_each_cpu(auto_demotion_disable, NULL, 1);
-
         if (icpu->byt_auto_demotion_disable_flag) {
                 wrmsrl(MSR_CC6_DEMOTION_POLICY_CONFIG, 0);
                 wrmsrl(MSR_MC6_DEMOTION_POLICY_CONFIG, 0);
         }
-
-        if (icpu->disable_promotion_to_c1e)     /* each-cpu is redundant */
-                on_each_cpu(c1e_promotion_disable, NULL, 1);
-
-        return 0;
 }
 
 
@@ -1193,7 +1214,6 @@ static int intel_idle_cpu_init(int cpu)
 
         if (cpuidle_register_device(dev)) {
                 pr_debug(PREFIX "cpuidle_register_device %d failed!\n", cpu);
-                intel_idle_cpuidle_devices_uninit();
                 return -EIO;
         }
 
@@ -1218,40 +1238,51 @@ static int __init intel_idle_init(void)
         if (retval)
                 return retval;
 
+        intel_idle_cpuidle_devices = alloc_percpu(struct cpuidle_device);
+        if (intel_idle_cpuidle_devices == NULL)
+                return -ENOMEM;
+
         intel_idle_cpuidle_driver_init();
         retval = cpuidle_register_driver(&intel_idle_driver);
         if (retval) {
                 struct cpuidle_driver *drv = cpuidle_get_driver();
                 printk(KERN_DEBUG PREFIX "intel_idle yielding to %s",
                         drv ? drv->name : "none");
+                free_percpu(intel_idle_cpuidle_devices);
                 return retval;
         }
 
-        intel_idle_cpuidle_devices = alloc_percpu(struct cpuidle_device);
-        if (intel_idle_cpuidle_devices == NULL)
-                return -ENOMEM;
-
         cpu_notifier_register_begin();
 
         for_each_online_cpu(i) {
                 retval = intel_idle_cpu_init(i);
                 if (retval) {
+                        intel_idle_cpuidle_devices_uninit();
                         cpu_notifier_register_done();
                         cpuidle_unregister_driver(&intel_idle_driver);
+                        free_percpu(intel_idle_cpuidle_devices);
                         return retval;
                 }
         }
         __register_cpu_notifier(&cpu_hotplug_notifier);
 
+        if (boot_cpu_has(X86_FEATURE_ARAT))     /* Always Reliable APIC Timer */
+                lapic_timer_reliable_states = LAPIC_TIMER_ALWAYS_RELIABLE;
+        else
+                on_each_cpu(__setup_broadcast_timer, (void *)true, 1);
+
         cpu_notifier_register_done();
 
+        pr_debug(PREFIX "lapic_timer_reliable_states 0x%x\n",
+                lapic_timer_reliable_states);
+
         return 0;
 }
 
 static void __exit intel_idle_exit(void)
 {
-        intel_idle_cpuidle_devices_uninit();
-        cpuidle_unregister_driver(&intel_idle_driver);
+        struct cpuidle_device *dev;
+        int i;
 
         cpu_notifier_register_begin();
 
@@ -1259,9 +1290,15 @@ static void __exit intel_idle_exit(void)
                 on_each_cpu(__setup_broadcast_timer, (void *)false, 1);
         __unregister_cpu_notifier(&cpu_hotplug_notifier);
 
+        for_each_possible_cpu(i) {
+                dev = per_cpu_ptr(intel_idle_cpuidle_devices, i);
+                cpuidle_unregister_device(dev);
+        }
+
         cpu_notifier_register_done();
 
-        return;
+        cpuidle_unregister_driver(&intel_idle_driver);
+        free_percpu(intel_idle_cpuidle_devices);
 }
 
 module_init(intel_idle_init);
diff --git a/drivers/iio/accel/bmc150-accel-core.c b/drivers/iio/accel/bmc150-accel-core.c
index c73331f7782b..2072a31e813b 100644
--- a/drivers/iio/accel/bmc150-accel-core.c
+++ b/drivers/iio/accel/bmc150-accel-core.c
@@ -547,7 +547,7 @@ static int bmc150_accel_get_axis(struct bmc150_accel_data *data,
 {
         int ret;
         int axis = chan->scan_index;
-        unsigned int raw_val;
+        __le16 raw_val;
 
         mutex_lock(&data->mutex);
         ret = bmc150_accel_set_power_state(data, true);
@@ -557,14 +557,14 @@ static int bmc150_accel_get_axis(struct bmc150_accel_data *data,
         }
 
         ret = regmap_bulk_read(data->regmap, BMC150_ACCEL_AXIS_TO_REG(axis),
-                               &raw_val, 2);
+                               &raw_val, sizeof(raw_val));
         if (ret < 0) {
                 dev_err(data->dev, "Error reading axis %d\n", axis);
                 bmc150_accel_set_power_state(data, false);
                 mutex_unlock(&data->mutex);
                 return ret;
         }
-        *val = sign_extend32(raw_val >> chan->scan_type.shift,
+        *val = sign_extend32(le16_to_cpu(raw_val) >> chan->scan_type.shift,
                              chan->scan_type.realbits - 1);
         ret = bmc150_accel_set_power_state(data, false);
         mutex_unlock(&data->mutex);
@@ -988,6 +988,7 @@ static const struct iio_event_spec bmc150_accel_event = {
                 .realbits = (bits),                                     \
                 .storagebits = 16,                                      \
                 .shift = 16 - (bits),                                   \
+                .endianness = IIO_LE,                                   \
         },                                                              \
         .event_spec = &bmc150_accel_event,                              \
         .num_event_specs = 1                                            \
diff --git a/drivers/iio/adc/Kconfig b/drivers/iio/adc/Kconfig
index af4aea7b20f9..82c718c515a0 100644
--- a/drivers/iio/adc/Kconfig
+++ b/drivers/iio/adc/Kconfig
@@ -134,6 +134,7 @@ config AT91_ADC
 config AT91_SAMA5D2_ADC
         tristate "Atmel AT91 SAMA5D2 ADC"
         depends on ARCH_AT91 || COMPILE_TEST
+        depends on HAS_IOMEM
         help
           Say yes here to build support for Atmel SAMA5D2 ADC which is
           available on SAMA5D2 SoC family.
diff --git a/drivers/iio/adc/at91-sama5d2_adc.c b/drivers/iio/adc/at91-sama5d2_adc.c
index dbee13ad33a3..2e154cb51685 100644
--- a/drivers/iio/adc/at91-sama5d2_adc.c
+++ b/drivers/iio/adc/at91-sama5d2_adc.c
@@ -451,6 +451,8 @@ static int at91_adc_probe(struct platform_device *pdev)
         if (ret)
                 goto vref_disable;
 
+        platform_set_drvdata(pdev, indio_dev);
+
         ret = iio_device_register(indio_dev);
         if (ret < 0)
                 goto per_clk_disable_unprepare;
diff --git a/drivers/iio/adc/max1363.c b/drivers/iio/adc/max1363.c
index 929508e5266c..998dc3caad4c 100644
--- a/drivers/iio/adc/max1363.c
+++ b/drivers/iio/adc/max1363.c
@@ -1386,7 +1386,7 @@ static const struct max1363_chip_info max1363_chip_info_tbl[] = {
         },
         [max11644] = {
                 .bits = 12,
-                .int_vref_mv = 2048,
+                .int_vref_mv = 4096,
                 .mode_list = max11644_mode_list,
                 .num_modes = ARRAY_SIZE(max11644_mode_list),
                 .default_mode = s0to1,
@@ -1396,7 +1396,7 @@ static const struct max1363_chip_info max1363_chip_info_tbl[] = {
         },
         [max11645] = {
                 .bits = 12,
-                .int_vref_mv = 4096,
+                .int_vref_mv = 2048,
                 .mode_list = max11644_mode_list,
                 .num_modes = ARRAY_SIZE(max11644_mode_list),
                 .default_mode = s0to1,
@@ -1406,7 +1406,7 @@ static const struct max1363_chip_info max1363_chip_info_tbl[] = {
         },
         [max11646] = {
                 .bits = 10,
-                .int_vref_mv = 2048,
+                .int_vref_mv = 4096,
                 .mode_list = max11644_mode_list,
                 .num_modes = ARRAY_SIZE(max11644_mode_list),
                 .default_mode = s0to1,
@@ -1416,7 +1416,7 @@ static const struct max1363_chip_info max1363_chip_info_tbl[] = {
         },
         [max11647] = {
                 .bits = 10,
-                .int_vref_mv = 4096,
+                .int_vref_mv = 2048,
                 .mode_list = max11644_mode_list,
                 .num_modes = ARRAY_SIZE(max11644_mode_list),
                 .default_mode = s0to1,
@@ -1680,6 +1680,10 @@ static const struct i2c_device_id max1363_id[] = {
         { "max11615", max11615 },
         { "max11616", max11616 },
         { "max11617", max11617 },
+        { "max11644", max11644 },
+        { "max11645", max11645 },
+        { "max11646", max11646 },
+        { "max11647", max11647 },
         {}
 };
 
diff --git a/drivers/iio/gyro/bmg160_core.c b/drivers/iio/gyro/bmg160_core.c
index bbce3b09ac45..4dac567e75b4 100644
--- a/drivers/iio/gyro/bmg160_core.c
+++ b/drivers/iio/gyro/bmg160_core.c
@@ -452,7 +452,7 @@ static int bmg160_get_temp(struct bmg160_data *data, int *val)
 static int bmg160_get_axis(struct bmg160_data *data, int axis, int *val)
 {
         int ret;
-        unsigned int raw_val;
+        __le16 raw_val;
 
         mutex_lock(&data->mutex);
         ret = bmg160_set_power_state(data, true);
@@ -462,7 +462,7 @@ static int bmg160_get_axis(struct bmg160_data *data, int axis, int *val)
         }
 
         ret = regmap_bulk_read(data->regmap, BMG160_AXIS_TO_REG(axis), &raw_val,
-                               2);
+                               sizeof(raw_val));
         if (ret < 0) {
                 dev_err(data->dev, "Error reading axis %d\n", axis);
                 bmg160_set_power_state(data, false);
@@ -470,7 +470,7 @@ static int bmg160_get_axis(struct bmg160_data *data, int axis, int *val)
                 return ret;
         }
 
-        *val = sign_extend32(raw_val, 15);
+        *val = sign_extend32(le16_to_cpu(raw_val), 15);
         ret = bmg160_set_power_state(data, false);
         mutex_unlock(&data->mutex);
         if (ret < 0)
@@ -733,6 +733,7 @@ static const struct iio_event_spec bmg160_event = {
                 .sign = 's',                                            \
                 .realbits = 16,                                 \
                 .storagebits = 16,                                      \
+                .endianness = IIO_LE,                                   \
         },                                                              \
         .event_spec = &bmg160_event,                                    \
         .num_event_specs = 1                                            \
@@ -780,7 +781,7 @@ static irqreturn_t bmg160_trigger_handler(int irq, void *p)
                         mutex_unlock(&data->mutex);
                         goto err;
                 }
-                data->buffer[i++] = ret;
+                data->buffer[i++] = val;
         }
         mutex_unlock(&data->mutex);
 
diff --git a/drivers/iio/health/max30100.c b/drivers/iio/health/max30100.c
index 09db89359544..90ab8a2d2846 100644
--- a/drivers/iio/health/max30100.c
+++ b/drivers/iio/health/max30100.c
@@ -238,12 +238,13 @@ static irqreturn_t max30100_interrupt_handler(int irq, void *private)
 
         mutex_lock(&data->lock);
 
-        while (cnt-- || (cnt = max30100_fifo_count(data) > 0)) {
+        while (cnt || (cnt = max30100_fifo_count(data) > 0)) {
                 ret = max30100_read_measurement(data);
                 if (ret)
                         break;
 
                 iio_push_to_buffers(data->indio_dev, data->buffer);
+                cnt--;
         }
 
         mutex_unlock(&data->lock);
diff --git a/drivers/iio/imu/inv_mpu6050/Kconfig b/drivers/iio/imu/inv_mpu6050/Kconfig
index a7f557af4389..847455a2d6bb 100644
--- a/drivers/iio/imu/inv_mpu6050/Kconfig
+++ b/drivers/iio/imu/inv_mpu6050/Kconfig
@@ -9,9 +9,8 @@ config INV_MPU6050_IIO
 
 config INV_MPU6050_I2C
         tristate "Invensense MPU6050 devices (I2C)"
-        depends on I2C
+        depends on I2C_MUX
         select INV_MPU6050_IIO
-        select I2C_MUX
         select REGMAP_I2C
         help
           This driver supports the Invensense MPU6050 devices.
diff --git a/drivers/iio/imu/inv_mpu6050/inv_mpu_i2c.c b/drivers/iio/imu/inv_mpu6050/inv_mpu_i2c.c
index f581256d9d4c..5ee4e0dc093e 100644
--- a/drivers/iio/imu/inv_mpu6050/inv_mpu_i2c.c
+++ b/drivers/iio/imu/inv_mpu6050/inv_mpu_i2c.c
@@ -104,6 +104,19 @@ static int inv_mpu6050_deselect_bypass(struct i2c_adapter *adap,
         return 0;
 }
 
+static const char *inv_mpu_match_acpi_device(struct device *dev, int *chip_id)
+{
+        const struct acpi_device_id *id;
+
+        id = acpi_match_device(dev->driver->acpi_match_table, dev);
+        if (!id)
+                return NULL;
+
+        *chip_id = (int)id->driver_data;
+
+        return dev_name(dev);
+}
+
 /**
  *  inv_mpu_probe() - probe function.
  *  @client:          i2c client.
@@ -115,14 +128,25 @@ static int inv_mpu_probe(struct i2c_client *client,
                          const struct i2c_device_id *id)
 {
         struct inv_mpu6050_state *st;
-        int result;
-        const char *name = id ? id->name : NULL;
+        int result, chip_type;
         struct regmap *regmap;
+        const char *name;
 
         if (!i2c_check_functionality(client->adapter,
                                      I2C_FUNC_SMBUS_I2C_BLOCK))
                 return -EOPNOTSUPP;
 
+        if (id) {
+                chip_type = (int)id->driver_data;
+                name = id->name;
+        } else if (ACPI_HANDLE(&client->dev)) {
+                name = inv_mpu_match_acpi_device(&client->dev, &chip_type);
+                if (!name)
+                        return -ENODEV;
+        } else {
+                return -ENOSYS;
+        }
+
         regmap = devm_regmap_init_i2c(client, &inv_mpu_regmap_config);
         if (IS_ERR(regmap)) {
                 dev_err(&client->dev, "Failed to register i2c regmap %d\n",
@@ -131,7 +155,7 @@ static int inv_mpu_probe(struct i2c_client *client,
         }
 
         result = inv_mpu_core_probe(regmap, client->irq, name,
-                                    NULL, id->driver_data);
+                                    NULL, chip_type);
         if (result < 0)
                 return result;
 
diff --git a/drivers/iio/imu/inv_mpu6050/inv_mpu_spi.c b/drivers/iio/imu/inv_mpu6050/inv_mpu_spi.c
index dea6c4361de0..7bcb8d839f05 100644
--- a/drivers/iio/imu/inv_mpu6050/inv_mpu_spi.c
+++ b/drivers/iio/imu/inv_mpu6050/inv_mpu_spi.c
@@ -46,6 +46,7 @@ static int inv_mpu_probe(struct spi_device *spi)
         struct regmap *regmap;
         const struct spi_device_id *id = spi_get_device_id(spi);
         const char *name = id ? id->name : NULL;
+        const int chip_type = id ? id->driver_data : 0;
 
         regmap = devm_regmap_init_spi(spi, &inv_mpu_regmap_config);
         if (IS_ERR(regmap)) {
@@ -55,7 +56,7 @@ static int inv_mpu_probe(struct spi_device *spi)
         }
 
         return inv_mpu_core_probe(regmap, spi->irq, name,
-                                  inv_mpu_i2c_disable, id->driver_data);
+                                  inv_mpu_i2c_disable, chip_type);
 }
 
 static int inv_mpu_remove(struct spi_device *spi)
diff --git a/drivers/iio/industrialio-buffer.c b/drivers/iio/industrialio-buffer.c
index b976332d45d3..90462fcf5436 100644
--- a/drivers/iio/industrialio-buffer.c
+++ b/drivers/iio/industrialio-buffer.c
@@ -653,6 +653,7 @@ static int iio_verify_update(struct iio_dev *indio_dev,
         unsigned int modes;
 
         memset(config, 0, sizeof(*config));
+        config->watermark = ~0;
 
         /*
          * If there is just one buffer and we are removing it there is nothing
diff --git a/drivers/iio/light/apds9960.c b/drivers/iio/light/apds9960.c
index f6a07dc32ae4..a6af56ad10e1 100644
--- a/drivers/iio/light/apds9960.c
+++ b/drivers/iio/light/apds9960.c
@@ -769,7 +769,7 @@ static void apds9960_read_gesture_fifo(struct apds9960_data *data)
         mutex_lock(&data->lock);
         data->gesture_mode_running = 1;
 
-        while (cnt-- || (cnt = apds9660_fifo_is_empty(data) > 0)) {
+        while (cnt || (cnt = apds9660_fifo_is_empty(data) > 0)) {
                 ret = regmap_bulk_read(data->regmap, APDS9960_REG_GFIFO_BASE,
                                       &data->buffer, 4);
 
@@ -777,6 +777,7 @@ static void apds9960_read_gesture_fifo(struct apds9960_data *data)
                         goto err_read;
 
                 iio_push_to_buffers(data->indio_dev, data->buffer);
+                cnt--;
         }
 
 err_read:
diff --git a/drivers/iio/magnetometer/ak8975.c b/drivers/iio/magnetometer/ak8975.c
index 9c5c9ef3f1da..0e931a9a1669 100644
--- a/drivers/iio/magnetometer/ak8975.c
+++ b/drivers/iio/magnetometer/ak8975.c
@@ -462,6 +462,8 @@ static int ak8975_setup_irq(struct ak8975_data *data)
         int rc;
         int irq;
 
+        init_waitqueue_head(&data->data_ready_queue);
+        clear_bit(0, &data->flags);
         if (client->irq)
                 irq = client->irq;
         else
@@ -477,8 +479,6 @@ static int ak8975_setup_irq(struct ak8975_data *data)
                 return rc;
         }
 
-        init_waitqueue_head(&data->data_ready_queue);
-        clear_bit(0, &data->flags);
         data->eoc_irq = irq;
 
         return rc;
@@ -732,7 +732,7 @@ static int ak8975_probe(struct i2c_client *client,
         int eoc_gpio;
         int err;
         const char *name = NULL;
-        enum asahi_compass_chipset chipset;
+        enum asahi_compass_chipset chipset = AK_MAX_TYPE;
 
         /* Grab and set up the supplied GPIO. */
         if (client->dev.platform_data)
diff --git a/drivers/iio/magnetometer/st_magn.h b/drivers/iio/magnetometer/st_magn.h
index 06a4d9c35581..9daca4681922 100644
--- a/drivers/iio/magnetometer/st_magn.h
+++ b/drivers/iio/magnetometer/st_magn.h
@@ -44,6 +44,7 @@ static inline int st_magn_allocate_ring(struct iio_dev *indio_dev)
 static inline void st_magn_deallocate_ring(struct iio_dev *indio_dev)
 {
 }
+#define ST_MAGN_TRIGGER_SET_STATE NULL
 #endif /* CONFIG_IIO_BUFFER */
 
 #endif /* ST_MAGN_H */
diff --git a/drivers/infiniband/core/cache.c b/drivers/infiniband/core/cache.c
index cb00d59da456..c2e257d97eff 100644
--- a/drivers/infiniband/core/cache.c
+++ b/drivers/infiniband/core/cache.c
@@ -691,7 +691,8 @@ void ib_cache_gid_set_default_gid(struct ib_device *ib_dev, u8 port,
                               NULL);
 
                 /* Coudn't find default GID location */
-                WARN_ON(ix < 0);
+                if (WARN_ON(ix < 0))
+                        goto release;
 
                 zattr_type.gid_type = gid_type;
 
diff --git a/drivers/infiniband/core/ucm.c b/drivers/infiniband/core/ucm.c
index 4a9aa0433b07..7713ef089c3c 100644
--- a/drivers/infiniband/core/ucm.c
+++ b/drivers/infiniband/core/ucm.c
@@ -48,6 +48,7 @@
 
 #include <asm/uaccess.h>
 
+#include <rdma/ib.h>
 #include <rdma/ib_cm.h>
 #include <rdma/ib_user_cm.h>
 #include <rdma/ib_marshall.h>
@@ -1103,6 +1104,9 @@ static ssize_t ib_ucm_write(struct file *filp, const char __user *buf,
         struct ib_ucm_cmd_hdr hdr;
         ssize_t result;
 
+        if (WARN_ON_ONCE(!ib_safe_file_access(filp)))
+                return -EACCES;
+
         if (len < sizeof(hdr))
                 return -EINVAL;
 
diff --git a/drivers/infiniband/core/ucma.c b/drivers/infiniband/core/ucma.c
index dd3bcceadfde..c0f3826abb30 100644
--- a/drivers/infiniband/core/ucma.c
+++ b/drivers/infiniband/core/ucma.c
@@ -1574,6 +1574,9 @@ static ssize_t ucma_write(struct file *filp, const char __user *buf,
         struct rdma_ucm_cmd_hdr hdr;
         ssize_t ret;
 
+        if (WARN_ON_ONCE(!ib_safe_file_access(filp)))
+                return -EACCES;
+
         if (len < sizeof(hdr))
                 return -EINVAL;
 
diff --git a/drivers/infiniband/core/uverbs_main.c b/drivers/infiniband/core/uverbs_main.c
index 28ba2cc81535..31f422a70623 100644
--- a/drivers/infiniband/core/uverbs_main.c
+++ b/drivers/infiniband/core/uverbs_main.c
@@ -48,6 +48,8 @@
 
 #include <asm/uaccess.h>
 
+#include <rdma/ib.h>
+
 #include "uverbs.h"
 
 MODULE_AUTHOR("Roland Dreier");
@@ -709,6 +711,9 @@ static ssize_t ib_uverbs_write(struct file *filp, const char __user *buf,
         int srcu_key;
         ssize_t ret;
 
+        if (WARN_ON_ONCE(!ib_safe_file_access(filp)))
+                return -EACCES;
+
         if (count < sizeof hdr)
                 return -EINVAL;
 
diff --git a/drivers/infiniband/core/verbs.c b/drivers/infiniband/core/verbs.c
index 15b8adbf39c0..b65b3541e732 100644
--- a/drivers/infiniband/core/verbs.c
+++ b/drivers/infiniband/core/verbs.c
@@ -1860,6 +1860,7 @@ EXPORT_SYMBOL(ib_drain_rq);
 void ib_drain_qp(struct ib_qp *qp)
 {
         ib_drain_sq(qp);
-        ib_drain_rq(qp);
+        if (!qp->srq)
+                ib_drain_rq(qp);
 }
 EXPORT_SYMBOL(ib_drain_qp);
diff --git a/drivers/infiniband/hw/cxgb3/iwch_provider.c b/drivers/infiniband/hw/cxgb3/iwch_provider.c
index 42a7b8952d13..3234a8be16f6 100644
--- a/drivers/infiniband/hw/cxgb3/iwch_provider.c
+++ b/drivers/infiniband/hw/cxgb3/iwch_provider.c
@@ -1390,6 +1390,8 @@ int iwch_register_device(struct iwch_dev *dev)
         dev->ibdev.iwcm->add_ref = iwch_qp_add_ref;
         dev->ibdev.iwcm->rem_ref = iwch_qp_rem_ref;
         dev->ibdev.iwcm->get_qp = iwch_get_qp;
+        memcpy(dev->ibdev.iwcm->ifname, dev->rdev.t3cdev_p->lldev->name,
+               sizeof(dev->ibdev.iwcm->ifname));
 
         ret = ib_register_device(&dev->ibdev, NULL);
         if (ret)
diff --git a/drivers/infiniband/hw/cxgb4/cq.c b/drivers/infiniband/hw/cxgb4/cq.c
index b4eeb783573c..b0b955724458 100644
--- a/drivers/infiniband/hw/cxgb4/cq.c
+++ b/drivers/infiniband/hw/cxgb4/cq.c
@@ -162,7 +162,7 @@ static int create_cq(struct c4iw_rdev *rdev, struct t4_cq *cq,
         cq->bar2_va = c4iw_bar2_addrs(rdev, cq->cqid, T4_BAR2_QTYPE_INGRESS,
                                       &cq->bar2_qid,
                                       user ? &cq->bar2_pa : NULL);
-        if (user && !cq->bar2_va) {
+        if (user && !cq->bar2_pa) {
                 pr_warn(MOD "%s: cqid %u not in BAR2 range.\n",
                         pci_name(rdev->lldi.pdev), cq->cqid);
                 ret = -EINVAL;
diff --git a/drivers/infiniband/hw/cxgb4/provider.c b/drivers/infiniband/hw/cxgb4/provider.c
index 124682dc5709..7574f394fdac 100644
--- a/drivers/infiniband/hw/cxgb4/provider.c
+++ b/drivers/infiniband/hw/cxgb4/provider.c
@@ -580,6 +580,8 @@ int c4iw_register_device(struct c4iw_dev *dev)
         dev->ibdev.iwcm->add_ref = c4iw_qp_add_ref;
         dev->ibdev.iwcm->rem_ref = c4iw_qp_rem_ref;
         dev->ibdev.iwcm->get_qp = c4iw_get_qp;
+        memcpy(dev->ibdev.iwcm->ifname, dev->rdev.lldi.ports[0]->name,
+               sizeof(dev->ibdev.iwcm->ifname));
 
         ret = ib_register_device(&dev->ibdev, NULL);
         if (ret)
diff --git a/drivers/infiniband/hw/cxgb4/qp.c b/drivers/infiniband/hw/cxgb4/qp.c
index e17fb5d5e033..e8993e49b8b3 100644
--- a/drivers/infiniband/hw/cxgb4/qp.c
+++ b/drivers/infiniband/hw/cxgb4/qp.c
@@ -185,6 +185,10 @@ void __iomem *c4iw_bar2_addrs(struct c4iw_rdev *rdev, unsigned int qid,
 
         if (pbar2_pa)
                 *pbar2_pa = (rdev->bar2_pa + bar2_qoffset) & PAGE_MASK;
+
+        if (is_t4(rdev->lldi.adapter_type))
+                return NULL;
+
         return rdev->bar2_kva + bar2_qoffset;
 }
 
@@ -270,7 +274,7 @@ static int create_qp(struct c4iw_rdev *rdev, struct t4_wq *wq,
         /*
          * User mode must have bar2 access.
          */
-        if (user && (!wq->sq.bar2_va || !wq->rq.bar2_va)) {
+        if (user && (!wq->sq.bar2_pa || !wq->rq.bar2_pa)) {
                 pr_warn(MOD "%s: sqid %u or rqid %u not in BAR2 range.\n",
                         pci_name(rdev->lldi.pdev), wq->sq.qid, wq->rq.qid);
                 goto free_dma;
@@ -1895,13 +1899,27 @@ int c4iw_ib_query_qp(struct ib_qp *ibqp, struct ib_qp_attr *attr,
 void c4iw_drain_sq(struct ib_qp *ibqp)
 {
         struct c4iw_qp *qp = to_c4iw_qp(ibqp);
+        unsigned long flag;
+        bool need_to_wait;
 
-        wait_for_completion(&qp->sq_drained);
+        spin_lock_irqsave(&qp->lock, flag);
+        need_to_wait = !t4_sq_empty(&qp->wq);
+        spin_unlock_irqrestore(&qp->lock, flag);
+
+        if (need_to_wait)
+                wait_for_completion(&qp->sq_drained);
 }
 
 void c4iw_drain_rq(struct ib_qp *ibqp)
 {
         struct c4iw_qp *qp = to_c4iw_qp(ibqp);
+        unsigned long flag;
+        bool need_to_wait;
+
+        spin_lock_irqsave(&qp->lock, flag);
+        need_to_wait = !t4_rq_empty(&qp->wq);
+        spin_unlock_irqrestore(&qp->lock, flag);
 
-        wait_for_completion(&qp->rq_drained);
+        if (need_to_wait)
+                wait_for_completion(&qp->rq_drained);
 }
diff --git a/drivers/infiniband/hw/i40iw/i40iw_cm.c b/drivers/infiniband/hw/i40iw/i40iw_cm.c
index 92745d755272..38f917a6c778 100644
--- a/drivers/infiniband/hw/i40iw/i40iw_cm.c
+++ b/drivers/infiniband/hw/i40iw/i40iw_cm.c
@@ -1992,7 +1992,6 @@ static int i40iw_addr_resolve_neigh(struct i40iw_device *iwdev,
 /**
  * i40iw_get_dst_ipv6
  */
-#if IS_ENABLED(CONFIG_IPV6)
 static struct dst_entry *i40iw_get_dst_ipv6(struct sockaddr_in6 *src_addr,
                                             struct sockaddr_in6 *dst_addr)
 {
@@ -2008,7 +2007,6 @@ static struct dst_entry *i40iw_get_dst_ipv6(struct sockaddr_in6 *src_addr,
         dst = ip6_route_output(&init_net, NULL, &fl6);
         return dst;
 }
-#endif
 
 /**
  * i40iw_addr_resolve_neigh_ipv6 - resolve neighbor ipv6 address
@@ -2016,7 +2014,6 @@ static struct dst_entry *i40iw_get_dst_ipv6(struct sockaddr_in6 *src_addr,
  * @dst_ip: remote ip address
  * @arpindex: if there is an arp entry
  */
-#if IS_ENABLED(CONFIG_IPV6)
 static int i40iw_addr_resolve_neigh_ipv6(struct i40iw_device *iwdev,
                                          u32 *src,
                                          u32 *dest,
@@ -2089,7 +2086,6 @@ static int i40iw_addr_resolve_neigh_ipv6(struct i40iw_device *iwdev,
         dst_release(dst);
         return rc;
 }
-#endif
 
 /**
  * i40iw_ipv4_is_loopback - check if loopback
@@ -2190,13 +2186,13 @@ static struct i40iw_cm_node *i40iw_make_cm_node(
                                                             cm_info->loc_addr[0],
                                                             cm_info->rem_addr[0],
                                                             oldarpindex);
-#if IS_ENABLED(CONFIG_IPV6)
-                else
+                else if (IS_ENABLED(CONFIG_IPV6))
                         arpindex = i40iw_addr_resolve_neigh_ipv6(iwdev,
                                                                  cm_info->loc_addr,
                                                                  cm_info->rem_addr,
                                                                  oldarpindex);
-#endif
+                else
+                        arpindex = -EINVAL;
         }
         if (arpindex < 0) {
                 i40iw_pr_err("cm_node arpindex\n");
diff --git a/drivers/infiniband/hw/mlx5/main.c b/drivers/infiniband/hw/mlx5/main.c
index 5acf346e048e..6ad0489cb3c5 100644
--- a/drivers/infiniband/hw/mlx5/main.c
+++ b/drivers/infiniband/hw/mlx5/main.c
@@ -530,7 +530,7 @@ static int mlx5_ib_query_device(struct ib_device *ibdev,
                      sizeof(struct mlx5_wqe_ctrl_seg)) /
                      sizeof(struct mlx5_wqe_data_seg);
         props->max_sge = min(max_rq_sg, max_sq_sg);
-        props->max_sge_rd = props->max_sge;
+        props->max_sge_rd          = MLX5_MAX_SGE_RD;
         props->max_cq              = 1 << MLX5_CAP_GEN(mdev, log_max_cq);
         props->max_cqe = (1 << MLX5_CAP_GEN(mdev, log_max_cq_sz)) - 1;
         props->max_mr              = 1 << MLX5_CAP_GEN(mdev, log_max_mkey);
@@ -671,8 +671,8 @@ static int mlx5_query_hca_port(struct ib_device *ibdev, u8 port,
         struct mlx5_ib_dev *dev = to_mdev(ibdev);
         struct mlx5_core_dev *mdev = dev->mdev;
         struct mlx5_hca_vport_context *rep;
-        int max_mtu;
-        int oper_mtu;
+        u16 max_mtu;
+        u16 oper_mtu;
         int err;
         u8 ib_link_width_oper;
         u8 vl_hw_cap;
diff --git a/drivers/infiniband/hw/mlx5/mlx5_ib.h b/drivers/infiniband/hw/mlx5/mlx5_ib.h
index f16c818ad2e6..b46c25542a7c 100644
--- a/drivers/infiniband/hw/mlx5/mlx5_ib.h
+++ b/drivers/infiniband/hw/mlx5/mlx5_ib.h
@@ -776,15 +776,6 @@ void mlx5_ib_qp_disable_pagefaults(struct mlx5_ib_qp *qp);
 void mlx5_ib_qp_enable_pagefaults(struct mlx5_ib_qp *qp);
 void mlx5_ib_invalidate_range(struct ib_umem *umem, unsigned long start,
                               unsigned long end);
-int mlx5_ib_get_vf_config(struct ib_device *device, int vf,
-                          u8 port, struct ifla_vf_info *info);
-int mlx5_ib_set_vf_link_state(struct ib_device *device, int vf,
-                              u8 port, int state);
-int mlx5_ib_get_vf_stats(struct ib_device *device, int vf,
-                         u8 port, struct ifla_vf_stats *stats);
-int mlx5_ib_set_vf_guid(struct ib_device *device, int vf, u8 port,
-                        u64 guid, int type);
-
 #else /* CONFIG_INFINIBAND_ON_DEMAND_PAGING */
 static inline void mlx5_ib_internal_fill_odp_caps(struct mlx5_ib_dev *dev)
 {
@@ -801,6 +792,15 @@ static inline void mlx5_ib_qp_enable_pagefaults(struct mlx5_ib_qp *qp)  {}
 
 #endif /* CONFIG_INFINIBAND_ON_DEMAND_PAGING */
 
+int mlx5_ib_get_vf_config(struct ib_device *device, int vf,
+                          u8 port, struct ifla_vf_info *info);
+int mlx5_ib_set_vf_link_state(struct ib_device *device, int vf,
+                              u8 port, int state);
+int mlx5_ib_get_vf_stats(struct ib_device *device, int vf,
+                         u8 port, struct ifla_vf_stats *stats);
+int mlx5_ib_set_vf_guid(struct ib_device *device, int vf, u8 port,
+                        u64 guid, int type);
+
 __be16 mlx5_get_roce_udp_sport(struct mlx5_ib_dev *dev, u8 port_num,
                                int index);
 
diff --git a/drivers/infiniband/hw/nes/nes_nic.c b/drivers/infiniband/hw/nes/nes_nic.c
index 3ea9e055fdd3..92914539edc7 100644
--- a/drivers/infiniband/hw/nes/nes_nic.c
+++ b/drivers/infiniband/hw/nes/nes_nic.c
@@ -500,9 +500,6 @@ static int nes_netdev_start_xmit(struct sk_buff *skb, struct net_device *netdev)
          *              skb_shinfo(skb)->nr_frags, skb_is_gso(skb));
          */
 
-        if (!netif_carrier_ok(netdev))
-                return NETDEV_TX_OK;
-
         if (netif_queue_stopped(netdev))
                 return NETDEV_TX_BUSY;
 
diff --git a/drivers/infiniband/hw/qib/qib_file_ops.c b/drivers/infiniband/hw/qib/qib_file_ops.c
index e449e394963f..24f4a782e0f4 100644
--- a/drivers/infiniband/hw/qib/qib_file_ops.c
+++ b/drivers/infiniband/hw/qib/qib_file_ops.c
@@ -45,6 +45,8 @@
 #include <linux/export.h>
 #include <linux/uio.h>
 
+#include <rdma/ib.h>
+
 #include "qib.h"
 #include "qib_common.h"
 #include "qib_user_sdma.h"
@@ -2067,6 +2069,9 @@ static ssize_t qib_write(struct file *fp, const char __user *data,
         ssize_t ret = 0;
         void *dest;
 
+        if (WARN_ON_ONCE(!ib_safe_file_access(fp)))
+                return -EACCES;
+
         if (count < sizeof(cmd.type)) {
                 ret = -EINVAL;
                 goto bail;
diff --git a/drivers/infiniband/sw/rdmavt/qp.c b/drivers/infiniband/sw/rdmavt/qp.c
index bd82a6948dc8..a9e3bcc522c4 100644
--- a/drivers/infiniband/sw/rdmavt/qp.c
+++ b/drivers/infiniband/sw/rdmavt/qp.c
@@ -1637,9 +1637,9 @@ bail:
         spin_unlock_irqrestore(&qp->s_hlock, flags);
         if (nreq) {
                 if (call_send)
-                        rdi->driver_f.schedule_send_no_lock(qp);
-                else
                         rdi->driver_f.do_send(qp);
+                else
+                        rdi->driver_f.schedule_send_no_lock(qp);
         }
         return err;
 }
diff --git a/drivers/infiniband/ulp/iser/iscsi_iser.c b/drivers/infiniband/ulp/iser/iscsi_iser.c
index 80b6bedc172f..64b3d11dcf1e 100644
--- a/drivers/infiniband/ulp/iser/iscsi_iser.c
+++ b/drivers/infiniband/ulp/iser/iscsi_iser.c
@@ -612,6 +612,7 @@ iscsi_iser_session_create(struct iscsi_endpoint *ep,
         struct Scsi_Host *shost;
         struct iser_conn *iser_conn = NULL;
         struct ib_conn *ib_conn;
+        u32 max_fr_sectors;
         u16 max_cmds;
 
         shost = iscsi_host_alloc(&iscsi_iser_sht, 0, 0);
@@ -632,7 +633,6 @@ iscsi_iser_session_create(struct iscsi_endpoint *ep,
                 iser_conn = ep->dd_data;
                 max_cmds = iser_conn->max_cmds;
                 shost->sg_tablesize = iser_conn->scsi_sg_tablesize;
-                shost->max_sectors = iser_conn->scsi_max_sectors;
 
                 mutex_lock(&iser_conn->state_mutex);
                 if (iser_conn->state != ISER_CONN_UP) {
@@ -657,8 +657,6 @@ iscsi_iser_session_create(struct iscsi_endpoint *ep,
                  */
                 shost->sg_tablesize = min_t(unsigned short, shost->sg_tablesize,
                         ib_conn->device->ib_device->attrs.max_fast_reg_page_list_len);
-                shost->max_sectors = min_t(unsigned int,
-                        1024, (shost->sg_tablesize * PAGE_SIZE) >> 9);
 
                 if (iscsi_host_add(shost,
                                    ib_conn->device->ib_device->dma_device)) {
@@ -672,6 +670,15 @@ iscsi_iser_session_create(struct iscsi_endpoint *ep,
                         goto free_host;
         }
 
+        /*
+         * FRs or FMRs can only map up to a (device) page per entry, but if the
+         * first entry is misaligned we'll end up using using two entries
+         * (head and tail) for a single page worth data, so we have to drop
+         * one segment from the calculation.
+         */
+        max_fr_sectors = ((shost->sg_tablesize - 1) * PAGE_SIZE) >> 9;
+        shost->max_sectors = min(iser_max_sectors, max_fr_sectors);
+
         if (cmds_max > max_cmds) {
                 iser_info("cmds_max changed from %u to %u\n",
                           cmds_max, max_cmds);
@@ -989,7 +996,6 @@ static struct scsi_host_template iscsi_iser_sht = {
         .queuecommand           = iscsi_queuecommand,
         .change_queue_depth     = scsi_change_queue_depth,
         .sg_tablesize           = ISCSI_ISER_DEF_SG_TABLESIZE,
-        .max_sectors            = ISER_DEF_MAX_SECTORS,
         .cmd_per_lun            = ISER_DEF_CMD_PER_LUN,
         .eh_abort_handler       = iscsi_eh_abort,
         .eh_device_reset_handler= iscsi_eh_device_reset,
diff --git a/drivers/infiniband/ulp/isert/ib_isert.c b/drivers/infiniband/ulp/isert/ib_isert.c
index 60b30d338a81..411e4464ca23 100644
--- a/drivers/infiniband/ulp/isert/ib_isert.c
+++ b/drivers/infiniband/ulp/isert/ib_isert.c
@@ -63,7 +63,6 @@ isert_rdma_accept(struct isert_conn *isert_conn);
 struct rdma_cm_id *isert_setup_id(struct isert_np *isert_np);
 
 static void isert_release_work(struct work_struct *work);
-static void isert_wait4flush(struct isert_conn *isert_conn);
 static void isert_recv_done(struct ib_cq *cq, struct ib_wc *wc);
 static void isert_send_done(struct ib_cq *cq, struct ib_wc *wc);
 static void isert_login_recv_done(struct ib_cq *cq, struct ib_wc *wc);
@@ -141,7 +140,7 @@ isert_create_qp(struct isert_conn *isert_conn,
         attr.qp_context = isert_conn;
         attr.send_cq = comp->cq;
         attr.recv_cq = comp->cq;
-        attr.cap.max_send_wr = ISERT_QP_MAX_REQ_DTOS;
+        attr.cap.max_send_wr = ISERT_QP_MAX_REQ_DTOS + 1;
         attr.cap.max_recv_wr = ISERT_QP_MAX_RECV_DTOS + 1;
         attr.cap.max_send_sge = device->ib_device->attrs.max_sge;
         isert_conn->max_sge = min(device->ib_device->attrs.max_sge,
@@ -887,7 +886,7 @@ isert_disconnected_handler(struct rdma_cm_id *cma_id,
                 break;
         case ISER_CONN_UP:
                 isert_conn_terminate(isert_conn);
-                isert_wait4flush(isert_conn);
+                ib_drain_qp(isert_conn->qp);
                 isert_handle_unbound_conn(isert_conn);
                 break;
         case ISER_CONN_BOUND:
@@ -3213,36 +3212,6 @@ isert_wait4cmds(struct iscsi_conn *conn)
         }
 }
 
-static void
-isert_beacon_done(struct ib_cq *cq, struct ib_wc *wc)
-{
-        struct isert_conn *isert_conn = wc->qp->qp_context;
-
-        isert_print_wc(wc, "beacon");
-
-        isert_info("conn %p completing wait_comp_err\n", isert_conn);
-        complete(&isert_conn->wait_comp_err);
-}
-
-static void
-isert_wait4flush(struct isert_conn *isert_conn)
-{
-        struct ib_recv_wr *bad_wr;
-        static struct ib_cqe cqe = { .done = isert_beacon_done };
-
-        isert_info("conn %p\n", isert_conn);
-
-        init_completion(&isert_conn->wait_comp_err);
-        isert_conn->beacon.wr_cqe = &cqe;
-        /* post an indication that all flush errors were consumed */
-        if (ib_post_recv(isert_conn->qp, &isert_conn->beacon, &bad_wr)) {
-                isert_err("conn %p failed to post beacon", isert_conn);
-                return;
-        }
-
-        wait_for_completion(&isert_conn->wait_comp_err);
-}
-
 /**
  * isert_put_unsol_pending_cmds() - Drop commands waiting for
  *     unsolicitate dataout
@@ -3288,7 +3257,7 @@ static void isert_wait_conn(struct iscsi_conn *conn)
         isert_conn_terminate(isert_conn);
         mutex_unlock(&isert_conn->mutex);
 
-        isert_wait4flush(isert_conn);
+        ib_drain_qp(isert_conn->qp);
         isert_put_unsol_pending_cmds(conn);
         isert_wait4cmds(conn);
         isert_wait4logout(isert_conn);
@@ -3300,7 +3269,7 @@ static void isert_free_conn(struct iscsi_conn *conn)
 {
         struct isert_conn *isert_conn = conn->context;
 
-        isert_wait4flush(isert_conn);
+        ib_drain_qp(isert_conn->qp);
         isert_put_conn(isert_conn);
 }
 
diff --git a/drivers/infiniband/ulp/isert/ib_isert.h b/drivers/infiniband/ulp/isert/ib_isert.h
index 192788a4820c..147900cbb578 100644
--- a/drivers/infiniband/ulp/isert/ib_isert.h
+++ b/drivers/infiniband/ulp/isert/ib_isert.h
@@ -209,14 +209,12 @@ struct isert_conn {
         struct ib_qp            *qp;
         struct isert_device     *device;
         struct mutex            mutex;
-        struct completion       wait_comp_err;
         struct kref             kref;
         struct list_head        fr_pool;
         int                     fr_pool_size;
         /* lock to protect fastreg pool */
         spinlock_t              pool_lock;
         struct work_struct      release_work;
-        struct ib_recv_wr       beacon;
         bool                    logout_posted;
         bool                    snd_w_inv;
 };
diff --git a/drivers/infiniband/ulp/srpt/ib_srpt.c b/drivers/infiniband/ulp/srpt/ib_srpt.c
index 0bd3cb2f3c67..8b42401d4795 100644
--- a/drivers/infiniband/ulp/srpt/ib_srpt.c
+++ b/drivers/infiniband/ulp/srpt/ib_srpt.c
@@ -1264,26 +1264,40 @@ free_mem:
  */
 static struct srpt_send_ioctx *srpt_get_send_ioctx(struct srpt_rdma_ch *ch)
 {
-        struct se_session *se_sess;
         struct srpt_send_ioctx *ioctx;
-        int tag;
+        unsigned long flags;
 
         BUG_ON(!ch);
-        se_sess = ch->sess;
 
-        tag = percpu_ida_alloc(&se_sess->sess_tag_pool, TASK_RUNNING);
-        if (tag < 0) {
-                pr_err("Unable to obtain tag for srpt_send_ioctx\n");
-                return NULL;
+        ioctx = NULL;
+        spin_lock_irqsave(&ch->spinlock, flags);
+        if (!list_empty(&ch->free_list)) {
+                ioctx = list_first_entry(&ch->free_list,
+                                         struct srpt_send_ioctx, free_list);
+                list_del(&ioctx->free_list);
         }
-        ioctx = &((struct srpt_send_ioctx *)se_sess->sess_cmd_map)[tag];
-        memset(ioctx, 0, sizeof(struct srpt_send_ioctx));
-        ioctx->ch = ch;
+        spin_unlock_irqrestore(&ch->spinlock, flags);
+
+        if (!ioctx)
+                return ioctx;
+
+        BUG_ON(ioctx->ch != ch);
         spin_lock_init(&ioctx->spinlock);
         ioctx->state = SRPT_STATE_NEW;
+        ioctx->n_rbuf = 0;
+        ioctx->rbufs = NULL;
+        ioctx->n_rdma = 0;
+        ioctx->n_rdma_wrs = 0;
+        ioctx->rdma_wrs = NULL;
+        ioctx->mapped_sg_count = 0;
         init_completion(&ioctx->tx_done);
-
-        ioctx->cmd.map_tag = tag;
+        ioctx->queue_status_only = false;
+        /*
+         * transport_init_se_cmd() does not initialize all fields, so do it
+         * here.
+         */
+        memset(&ioctx->cmd, 0, sizeof(ioctx->cmd));
+        memset(&ioctx->sense_data, 0, sizeof(ioctx->sense_data));
 
         return ioctx;
 }
@@ -2021,7 +2035,7 @@ static int srpt_cm_req_recv(struct ib_cm_id *cm_id,
         struct ib_cm_rep_param *rep_param;
         struct srpt_rdma_ch *ch, *tmp_ch;
         u32 it_iu_len;
-        int ret = 0;
+        int i, ret = 0;
         unsigned char *p;
 
         WARN_ON_ONCE(irqs_disabled());
@@ -2143,6 +2157,12 @@ static int srpt_cm_req_recv(struct ib_cm_id *cm_id,
         if (!ch->ioctx_ring)
                 goto free_ch;
 
+        INIT_LIST_HEAD(&ch->free_list);
+        for (i = 0; i < ch->rq_size; i++) {
+                ch->ioctx_ring[i]->ch = ch;
+                list_add_tail(&ch->ioctx_ring[i]->free_list, &ch->free_list);
+        }
+
         ret = srpt_create_ch_ib(ch);
         if (ret) {
                 rej->reason = cpu_to_be32(
@@ -2173,8 +2193,7 @@ static int srpt_cm_req_recv(struct ib_cm_id *cm_id,
         p = &ch->sess_name[0];
 
 try_again:
-        ch->sess = target_alloc_session(&sport->port_tpg_1, ch->rq_size,
-                                        sizeof(struct srpt_send_ioctx),
+        ch->sess = target_alloc_session(&sport->port_tpg_1, 0, 0,
                                         TARGET_PROT_NORMAL, p, ch, NULL);
         if (IS_ERR(ch->sess)) {
                 pr_info("Rejected login because no ACL has been"
@@ -2881,7 +2900,7 @@ static void srpt_release_cmd(struct se_cmd *se_cmd)
         struct srpt_send_ioctx *ioctx = container_of(se_cmd,
                                 struct srpt_send_ioctx, cmd);
         struct srpt_rdma_ch *ch = ioctx->ch;
-        struct se_session *se_sess = ch->sess;
+        unsigned long flags;
 
         WARN_ON(ioctx->state != SRPT_STATE_DONE);
         WARN_ON(ioctx->mapped_sg_count != 0);
@@ -2892,7 +2911,9 @@ static void srpt_release_cmd(struct se_cmd *se_cmd)
                 ioctx->n_rbuf = 0;
         }
 
-        percpu_ida_free(&se_sess->sess_tag_pool, se_cmd->map_tag);
+        spin_lock_irqsave(&ch->spinlock, flags);
+        list_add(&ioctx->free_list, &ch->free_list);
+        spin_unlock_irqrestore(&ch->spinlock, flags);
 }
 
 /**
diff --git a/drivers/infiniband/ulp/srpt/ib_srpt.h b/drivers/infiniband/ulp/srpt/ib_srpt.h
index ca288f019315..af9b8b527340 100644
--- a/drivers/infiniband/ulp/srpt/ib_srpt.h
+++ b/drivers/infiniband/ulp/srpt/ib_srpt.h
@@ -179,6 +179,7 @@ struct srpt_recv_ioctx {
  * struct srpt_send_ioctx - SRPT send I/O context.
  * @ioctx:       See above.
  * @ch:          Channel pointer.
+ * @free_list:   Node in srpt_rdma_ch.free_list.
  * @n_rbuf:      Number of data buffers in the received SRP command.
  * @rbufs:       Pointer to SRP data buffer array.
  * @single_rbuf: SRP data buffer if the command has only a single buffer.
@@ -201,6 +202,7 @@ struct srpt_send_ioctx {
         struct srp_direct_buf   *rbufs;
         struct srp_direct_buf   single_rbuf;
         struct scatterlist      *sg;
+        struct list_head        free_list;
         spinlock_t              spinlock;
         enum srpt_command_state state;
         struct se_cmd           cmd;
diff --git a/drivers/input/joystick/xpad.c b/drivers/input/joystick/xpad.c
index e8a84d12b7ff..1142a93dd90b 100644
--- a/drivers/input/joystick/xpad.c
+++ b/drivers/input/joystick/xpad.c
@@ -153,6 +153,7 @@ static const struct xpad_device {
         { 0x0738, 0x4728, "Mad Catz Street Fighter IV FightPad", MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOX360 },
         { 0x0738, 0x4738, "Mad Catz Wired Xbox 360 Controller (SFIV)", MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOX360 },
         { 0x0738, 0x4740, "Mad Catz Beat Pad", 0, XTYPE_XBOX360 },
+        { 0x0738, 0x4a01, "Mad Catz FightStick TE 2", MAP_TRIGGERS_TO_BUTTONS, XTYPE_XBOXONE },
         { 0x0738, 0x6040, "Mad Catz Beat Pad Pro", MAP_DPAD_TO_BUTTONS, XTYPE_XBOX },
         { 0x0738, 0xb726, "Mad Catz Xbox controller - MW2", 0, XTYPE_XBOX360 },
         { 0x0738, 0xbeef, "Mad Catz JOYTECH NEO SE Advanced GamePad", XTYPE_XBOX360 },
@@ -304,6 +305,7 @@ static struct usb_device_id xpad_table[] = {
         XPAD_XBOX360_VENDOR(0x046d),            /* Logitech X-Box 360 style controllers */
         XPAD_XBOX360_VENDOR(0x0738),            /* Mad Catz X-Box 360 controllers */
         { USB_DEVICE(0x0738, 0x4540) },         /* Mad Catz Beat Pad */
+        XPAD_XBOXONE_VENDOR(0x0738),            /* Mad Catz FightStick TE 2 */
         XPAD_XBOX360_VENDOR(0x0e6f),            /* 0x0e6f X-Box 360 controllers */
         XPAD_XBOX360_VENDOR(0x12ab),            /* X-Box 360 dance pads */
         XPAD_XBOX360_VENDOR(0x1430),            /* RedOctane X-Box 360 controllers */
diff --git a/drivers/input/misc/arizona-haptics.c b/drivers/input/misc/arizona-haptics.c
index d5994a745ffa..982936334537 100644
--- a/drivers/input/misc/arizona-haptics.c
+++ b/drivers/input/misc/arizona-haptics.c
@@ -178,7 +178,6 @@ static int arizona_haptics_probe(struct platform_device *pdev)
         input_set_drvdata(haptics->input_dev, haptics);
 
         haptics->input_dev->name = "arizona:haptics";
-        haptics->input_dev->dev.parent = pdev->dev.parent;
         haptics->input_dev->close = arizona_haptics_close;
         __set_bit(FF_RUMBLE, haptics->input_dev->ffbit);
 
diff --git a/drivers/input/misc/pmic8xxx-pwrkey.c b/drivers/input/misc/pmic8xxx-pwrkey.c
index 3f02e0e03d12..67aab86048ad 100644
--- a/drivers/input/misc/pmic8xxx-pwrkey.c
+++ b/drivers/input/misc/pmic8xxx-pwrkey.c
@@ -353,7 +353,8 @@ static int pmic8xxx_pwrkey_probe(struct platform_device *pdev)
         if (of_property_read_u32(pdev->dev.of_node, "debounce", &kpd_delay))
                 kpd_delay = 15625;
 
-        if (kpd_delay > 62500 || kpd_delay == 0) {
+        /* Valid range of pwr key trigger delay is 1/64 sec to 2 seconds. */
+        if (kpd_delay > USEC_PER_SEC * 2 || kpd_delay < USEC_PER_SEC / 64) {
                 dev_err(&pdev->dev, "invalid power key trigger delay\n");
                 return -EINVAL;
         }
@@ -385,8 +386,8 @@ static int pmic8xxx_pwrkey_probe(struct platform_device *pdev)
         pwr->name = "pmic8xxx_pwrkey";
         pwr->phys = "pmic8xxx_pwrkey/input0";
 
-        delay = (kpd_delay << 10) / USEC_PER_SEC;
-        delay = 1 + ilog2(delay);
+        delay = (kpd_delay << 6) / USEC_PER_SEC;
+        delay = ilog2(delay);
 
         err = regmap_read(regmap, PON_CNTL_1, &pon_cntl);
         if (err < 0) {
diff --git a/drivers/input/misc/twl4030-vibra.c b/drivers/input/misc/twl4030-vibra.c
index 10c4e3d462f1..caa5a62c42fb 100644
--- a/drivers/input/misc/twl4030-vibra.c
+++ b/drivers/input/misc/twl4030-vibra.c
@@ -222,7 +222,6 @@ static int twl4030_vibra_probe(struct platform_device *pdev)
 
         info->input_dev->name = "twl4030:vibrator";
         info->input_dev->id.version = 1;
-        info->input_dev->dev.parent = pdev->dev.parent;
         info->input_dev->close = twl4030_vibra_close;
         __set_bit(FF_RUMBLE, info->input_dev->ffbit);
 
diff --git a/drivers/input/misc/twl6040-vibra.c b/drivers/input/misc/twl6040-vibra.c
index ea63fad48de6..df3581f60628 100644
--- a/drivers/input/misc/twl6040-vibra.c
+++ b/drivers/input/misc/twl6040-vibra.c
@@ -45,7 +45,6 @@
 struct vibra_info {
         struct device *dev;
         struct input_dev *input_dev;
-        struct workqueue_struct *workqueue;
         struct work_struct play_work;
         struct mutex mutex;
         int irq;
@@ -182,6 +181,14 @@ static void vibra_play_work(struct work_struct *work)
 {
         struct vibra_info *info = container_of(work,
                                 struct vibra_info, play_work);
+        int ret;
+
+        /* Do not allow effect, while the routing is set to use audio */
+        ret = twl6040_get_vibralr_status(info->twl6040);
+        if (ret & TWL6040_VIBSEL) {
+                dev_info(info->dev, "Vibra is configured for audio\n");
+                return;
+        }
 
         mutex_lock(&info->mutex);
 
@@ -200,24 +207,12 @@ static int vibra_play(struct input_dev *input, void *data,
                       struct ff_effect *effect)
 {
         struct vibra_info *info = input_get_drvdata(input);
-        int ret;
-
-        /* Do not allow effect, while the routing is set to use audio */
-        ret = twl6040_get_vibralr_status(info->twl6040);
-        if (ret & TWL6040_VIBSEL) {
-                dev_info(&input->dev, "Vibra is configured for audio\n");
-                return -EBUSY;
-        }
 
         info->weak_speed = effect->u.rumble.weak_magnitude;
         info->strong_speed = effect->u.rumble.strong_magnitude;
         info->direction = effect->direction < EFFECT_DIR_180_DEG ? 1 : -1;
 
-        ret = queue_work(info->workqueue, &info->play_work);
-        if (!ret) {
-                dev_info(&input->dev, "work is already on queue\n");
-                return ret;
-        }
+        schedule_work(&info->play_work);
 
         return 0;
 }
@@ -362,7 +357,6 @@ static int twl6040_vibra_probe(struct platform_device *pdev)
 
         info->input_dev->name = "twl6040:vibrator";
         info->input_dev->id.version = 1;
-        info->input_dev->dev.parent = pdev->dev.parent;
         info->input_dev->close = twl6040_vibra_close;
         __set_bit(FF_RUMBLE, info->input_dev->ffbit);
 
diff --git a/drivers/input/tablet/gtco.c b/drivers/input/tablet/gtco.c
index 3a7f3a4a4396..7c18249d6c8e 100644
--- a/drivers/input/tablet/gtco.c
+++ b/drivers/input/tablet/gtco.c
@@ -858,6 +858,14 @@ static int gtco_probe(struct usb_interface *usbinterface,
                 goto err_free_buf;
         }
 
+        /* Sanity check that a device has an endpoint */
+        if (usbinterface->altsetting[0].desc.bNumEndpoints < 1) {
+                dev_err(&usbinterface->dev,
+                        "Invalid number of endpoints\n");
+                error = -EINVAL;
+                goto err_free_urb;
+        }
+
         /*
          * The endpoint is always altsetting 0, we know this since we know
          * this device only has one interrupt endpoint
@@ -879,7 +887,7 @@ static int gtco_probe(struct usb_interface *usbinterface,
          * HID report descriptor
          */
         if (usb_get_extra_descriptor(usbinterface->cur_altsetting,
-                                     HID_DEVICE_TYPE, &hid_desc) != 0){
+                                     HID_DEVICE_TYPE, &hid_desc) != 0) {
                 dev_err(&usbinterface->dev,
                         "Can't retrieve exta USB descriptor to get hid report descriptor length\n");
                 error = -EIO;
diff --git a/drivers/input/touchscreen/atmel_mxt_ts.c b/drivers/input/touchscreen/atmel_mxt_ts.c
index 2160512e861a..5af7907d0af4 100644
--- a/drivers/input/touchscreen/atmel_mxt_ts.c
+++ b/drivers/input/touchscreen/atmel_mxt_ts.c
@@ -1093,6 +1093,19 @@ static int mxt_t6_command(struct mxt_data *data, u16 cmd_offset,
         return 0;
 }
 
+static int mxt_acquire_irq(struct mxt_data *data)
+{
+        int error;
+
+        enable_irq(data->irq);
+
+        error = mxt_process_messages_until_invalid(data);
+        if (error)
+                return error;
+
+        return 0;
+}
+
 static int mxt_soft_reset(struct mxt_data *data)
 {
         struct device *dev = &data->client->dev;
@@ -1111,7 +1124,7 @@ static int mxt_soft_reset(struct mxt_data *data)
         /* Ignore CHG line for 100ms after reset */
         msleep(100);
 
-        enable_irq(data->irq);
+        mxt_acquire_irq(data);
 
         ret = mxt_wait_for_completion(data, &data->reset_completion,
                                       MXT_RESET_TIMEOUT);
@@ -1466,19 +1479,6 @@ release_mem:
         return ret;
 }
 
-static int mxt_acquire_irq(struct mxt_data *data)
-{
-        int error;
-
-        enable_irq(data->irq);
-
-        error = mxt_process_messages_until_invalid(data);
-        if (error)
-                return error;
-
-        return 0;
-}
-
 static int mxt_get_info(struct mxt_data *data)
 {
         struct i2c_client *client = data->client;
diff --git a/drivers/input/touchscreen/zforce_ts.c b/drivers/input/touchscreen/zforce_ts.c
index 9bbadaaf6bc3..7b3845aa5983 100644
--- a/drivers/input/touchscreen/zforce_ts.c
+++ b/drivers/input/touchscreen/zforce_ts.c
@@ -370,8 +370,8 @@ static int zforce_touch_event(struct zforce_ts *ts, u8 *payload)
                         point.coord_x = point.coord_y = 0;
                 }
 
-                point.state = payload[9 * i + 5] & 0x03;
-                point.id = (payload[9 * i + 5] & 0xfc) >> 2;
+                point.state = payload[9 * i + 5] & 0x0f;
+                point.id = (payload[9 * i + 5] & 0xf0) >> 4;
 
                 /* determine touch major, minor and orientation */
                 point.area_major = max(payload[9 * i + 6],
diff --git a/drivers/iommu/amd_iommu.c b/drivers/iommu/amd_iommu.c
index 374c129219ef..5efadad4615b 100644
--- a/drivers/iommu/amd_iommu.c
+++ b/drivers/iommu/amd_iommu.c
@@ -92,6 +92,7 @@ struct iommu_dev_data {
         struct list_head dev_data_list;   /* For global dev_data_list */
         struct protection_domain *domain; /* Domain the device is bound to */
         u16 devid;                        /* PCI Device ID */
+        u16 alias;                        /* Alias Device ID */
         bool iommu_v2;                    /* Device can make use of IOMMUv2 */
         bool passthrough;                 /* Device is identity mapped */
         struct {
@@ -166,6 +167,13 @@ static struct protection_domain *to_pdomain(struct iommu_domain *dom)
         return container_of(dom, struct protection_domain, domain);
 }
 
+static inline u16 get_device_id(struct device *dev)
+{
+        struct pci_dev *pdev = to_pci_dev(dev);
+
+        return PCI_DEVID(pdev->bus->number, pdev->devfn);
+}
+
 static struct iommu_dev_data *alloc_dev_data(u16 devid)
 {
         struct iommu_dev_data *dev_data;
@@ -203,6 +211,68 @@ out_unlock:
         return dev_data;
 }
 
+static int __last_alias(struct pci_dev *pdev, u16 alias, void *data)
+{
+        *(u16 *)data = alias;
+        return 0;
+}
+
+static u16 get_alias(struct device *dev)
+{
+        struct pci_dev *pdev = to_pci_dev(dev);
+        u16 devid, ivrs_alias, pci_alias;
+
+        devid = get_device_id(dev);
+        ivrs_alias = amd_iommu_alias_table[devid];
+        pci_for_each_dma_alias(pdev, __last_alias, &pci_alias);
+
+        if (ivrs_alias == pci_alias)
+                return ivrs_alias;
+
+        /*
+         * DMA alias showdown
+         *
+         * The IVRS is fairly reliable in telling us about aliases, but it
+         * can't know about every screwy device.  If we don't have an IVRS
+         * reported alias, use the PCI reported alias.  In that case we may
+         * still need to initialize the rlookup and dev_table entries if the
+         * alias is to a non-existent device.
+         */
+        if (ivrs_alias == devid) {
+                if (!amd_iommu_rlookup_table[pci_alias]) {
+                        amd_iommu_rlookup_table[pci_alias] =
+                                amd_iommu_rlookup_table[devid];
+                        memcpy(amd_iommu_dev_table[pci_alias].data,
+                               amd_iommu_dev_table[devid].data,
+                               sizeof(amd_iommu_dev_table[pci_alias].data));
+                }
+
+                return pci_alias;
+        }
+
+        pr_info("AMD-Vi: Using IVRS reported alias %02x:%02x.%d "
+                "for device %s[%04x:%04x], kernel reported alias "
+                "%02x:%02x.%d\n", PCI_BUS_NUM(ivrs_alias), PCI_SLOT(ivrs_alias),
+                PCI_FUNC(ivrs_alias), dev_name(dev), pdev->vendor, pdev->device,
+                PCI_BUS_NUM(pci_alias), PCI_SLOT(pci_alias),
+                PCI_FUNC(pci_alias));
+
+        /*
+         * If we don't have a PCI DMA alias and the IVRS alias is on the same
+         * bus, then the IVRS table may know about a quirk that we don't.
+         */
+        if (pci_alias == devid &&
+            PCI_BUS_NUM(ivrs_alias) == pdev->bus->number) {
+                pdev->dev_flags |= PCI_DEV_FLAGS_DMA_ALIAS_DEVFN;
+                pdev->dma_alias_devfn = ivrs_alias & 0xff;
+                pr_info("AMD-Vi: Added PCI DMA alias %02x.%d for %s\n",
+                        PCI_SLOT(ivrs_alias), PCI_FUNC(ivrs_alias),
+                        dev_name(dev));
+        }
+
+        return ivrs_alias;
+}
+
 static struct iommu_dev_data *find_dev_data(u16 devid)
 {
         struct iommu_dev_data *dev_data;
@@ -215,13 +285,6 @@ static struct iommu_dev_data *find_dev_data(u16 devid)
         return dev_data;
 }
 
-static inline u16 get_device_id(struct device *dev)
-{
-        struct pci_dev *pdev = to_pci_dev(dev);
-
-        return PCI_DEVID(pdev->bus->number, pdev->devfn);
-}
-
 static struct iommu_dev_data *get_dev_data(struct device *dev)
 {
         return dev->archdata.iommu;
@@ -349,6 +412,8 @@ static int iommu_init_device(struct device *dev)
         if (!dev_data)
                 return -ENOMEM;
 
+        dev_data->alias = get_alias(dev);
+
         if (pci_iommuv2_capable(pdev)) {
                 struct amd_iommu *iommu;
 
@@ -369,7 +434,7 @@ static void iommu_ignore_device(struct device *dev)
         u16 devid, alias;
 
         devid = get_device_id(dev);
-        alias = amd_iommu_alias_table[devid];
+        alias = get_alias(dev);
 
         memset(&amd_iommu_dev_table[devid], 0, sizeof(struct dev_table_entry));
         memset(&amd_iommu_dev_table[alias], 0, sizeof(struct dev_table_entry));
@@ -1061,7 +1126,7 @@ static int device_flush_dte(struct iommu_dev_data *dev_data)
         int ret;
 
         iommu = amd_iommu_rlookup_table[dev_data->devid];
-        alias = amd_iommu_alias_table[dev_data->devid];
+        alias = dev_data->alias;
 
         ret = iommu_flush_dte(iommu, dev_data->devid);
         if (!ret && alias != dev_data->devid)
@@ -2039,7 +2104,7 @@ static void do_attach(struct iommu_dev_data *dev_data,
         bool ats;
 
         iommu = amd_iommu_rlookup_table[dev_data->devid];
-        alias = amd_iommu_alias_table[dev_data->devid];
+        alias = dev_data->alias;
         ats   = dev_data->ats.enabled;
 
         /* Update data structures */
@@ -2073,7 +2138,7 @@ static void do_detach(struct iommu_dev_data *dev_data)
                 return;
 
         iommu = amd_iommu_rlookup_table[dev_data->devid];
-        alias = amd_iommu_alias_table[dev_data->devid];
+        alias = dev_data->alias;
 
         /* decrease reference counters */
         dev_data->domain->dev_iommu[iommu->index] -= 1;
diff --git a/drivers/iommu/arm-smmu.c b/drivers/iommu/arm-smmu.c
index 2409e3bd3df2..7c39ac4b9c53 100644
--- a/drivers/iommu/arm-smmu.c
+++ b/drivers/iommu/arm-smmu.c
@@ -826,6 +826,12 @@ static int arm_smmu_init_domain_context(struct iommu_domain *domain,
         if (smmu_domain->smmu)
                 goto out_unlock;
 
+        /* We're bypassing these SIDs, so don't allocate an actual context */
+        if (domain->type == IOMMU_DOMAIN_DMA) {
+                smmu_domain->smmu = smmu;
+                goto out_unlock;
+        }
+
         /*
          * Mapping the requested stage onto what we support is surprisingly
          * complicated, mainly because the spec allows S1+S2 SMMUs without
@@ -948,7 +954,7 @@ static void arm_smmu_destroy_domain_context(struct iommu_domain *domain)
         void __iomem *cb_base;
         int irq;
 
-        if (!smmu)
+        if (!smmu || domain->type == IOMMU_DOMAIN_DMA)
                 return;
 
         /*
@@ -1089,18 +1095,20 @@ static int arm_smmu_domain_add_master(struct arm_smmu_domain *smmu_domain,
         struct arm_smmu_device *smmu = smmu_domain->smmu;
         void __iomem *gr0_base = ARM_SMMU_GR0(smmu);
 
-        /* Devices in an IOMMU group may already be configured */
-        ret = arm_smmu_master_configure_smrs(smmu, cfg);
-        if (ret)
-                return ret == -EEXIST ? 0 : ret;
-
         /*
          * FIXME: This won't be needed once we have IOMMU-backed DMA ops
-         * for all devices behind the SMMU.
+         * for all devices behind the SMMU. Note that we need to take
+         * care configuring SMRs for devices both a platform_device and
+         * and a PCI device (i.e. a PCI host controller)
          */
         if (smmu_domain->domain.type == IOMMU_DOMAIN_DMA)
                 return 0;
 
+        /* Devices in an IOMMU group may already be configured */
+        ret = arm_smmu_master_configure_smrs(smmu, cfg);
+        if (ret)
+                return ret == -EEXIST ? 0 : ret;
+
         for (i = 0; i < cfg->num_streamids; ++i) {
                 u32 idx, s2cr;
 
diff --git a/drivers/iommu/dma-iommu.c b/drivers/iommu/dma-iommu.c
index 72d6182666cb..58f2fe687a24 100644
--- a/drivers/iommu/dma-iommu.c
+++ b/drivers/iommu/dma-iommu.c
@@ -403,7 +403,7 @@ static int __finalise_sg(struct device *dev, struct scatterlist *sg, int nents,
                 unsigned int s_length = sg_dma_len(s);
                 unsigned int s_dma_len = s->length;
 
-                s->offset = s_offset;
+                s->offset += s_offset;
                 s->length = s_length;
                 sg_dma_address(s) = dma_addr + s_offset;
                 dma_addr += s_dma_len;
@@ -422,7 +422,7 @@ static void __invalidate_sg(struct scatterlist *sg, int nents)
 
         for_each_sg(sg, s, nents, i) {
                 if (sg_dma_address(s) != DMA_ERROR_CODE)
-                        s->offset = sg_dma_address(s);
+                        s->offset += sg_dma_address(s);
                 if (sg_dma_len(s))
                         s->length = sg_dma_len(s);
                 sg_dma_address(s) = DMA_ERROR_CODE;
diff --git a/drivers/iommu/intel-iommu.c b/drivers/iommu/intel-iommu.c
index a2e1b7f14df2..e1852e845d21 100644
--- a/drivers/iommu/intel-iommu.c
+++ b/drivers/iommu/intel-iommu.c
@@ -2458,7 +2458,7 @@ static struct dmar_domain *get_domain_for_dev(struct device *dev, int gaw)
         }
 
         /* register PCI DMA alias device */
-        if (req_id != dma_alias && dev_is_pci(dev)) {
+        if (dev_is_pci(dev) && req_id != dma_alias) {
                 tmp = dmar_insert_one_dev_info(iommu, PCI_BUS_NUM(dma_alias),
                                                dma_alias & 0xff, NULL, domain);
 
diff --git a/drivers/iommu/iommu.c b/drivers/iommu/iommu.c
index bfd4f7c3b1d8..b9df1411c894 100644
--- a/drivers/iommu/iommu.c
+++ b/drivers/iommu/iommu.c
@@ -848,7 +848,8 @@ struct iommu_group *iommu_group_get_for_dev(struct device *dev)
         if (!group->default_domain) {
                 group->default_domain = __iommu_domain_alloc(dev->bus,
                                                              IOMMU_DOMAIN_DMA);
-                group->domain = group->default_domain;
+                if (!group->domain)
+                        group->domain = group->default_domain;
         }
 
         ret = iommu_group_add_device(group, dev);
diff --git a/drivers/iommu/rockchip-iommu.c b/drivers/iommu/rockchip-iommu.c
index a6f593a0a29e..5710a06c3049 100644
--- a/drivers/iommu/rockchip-iommu.c
+++ b/drivers/iommu/rockchip-iommu.c
@@ -315,8 +315,8 @@ static bool rk_iommu_is_stall_active(struct rk_iommu *iommu)
         int i;
 
         for (i = 0; i < iommu->num_mmu; i++)
-                active &= rk_iommu_read(iommu->bases[i], RK_MMU_STATUS) &
-                                        RK_MMU_STATUS_STALL_ACTIVE;
+                active &= !!(rk_iommu_read(iommu->bases[i], RK_MMU_STATUS) &
+                                           RK_MMU_STATUS_STALL_ACTIVE);
 
         return active;
 }
@@ -327,8 +327,8 @@ static bool rk_iommu_is_paging_enabled(struct rk_iommu *iommu)
         int i;
 
         for (i = 0; i < iommu->num_mmu; i++)
-                enable &= rk_iommu_read(iommu->bases[i], RK_MMU_STATUS) &
-                                        RK_MMU_STATUS_PAGING_ENABLED;
+                enable &= !!(rk_iommu_read(iommu->bases[i], RK_MMU_STATUS) &
+                                           RK_MMU_STATUS_PAGING_ENABLED);
 
         return enable;
 }
diff --git a/drivers/irqchip/irq-mips-gic.c b/drivers/irqchip/irq-mips-gic.c
index 94a30da0cfac..4dffccf532a2 100644
--- a/drivers/irqchip/irq-mips-gic.c
+++ b/drivers/irqchip/irq-mips-gic.c
@@ -467,7 +467,7 @@ static int gic_set_affinity(struct irq_data *d, const struct cpumask *cpumask,
         gic_map_to_vpe(irq, mips_cm_vp_id(cpumask_first(&tmp)));
 
         /* Update the pcpu_masks */
-        for (i = 0; i < gic_vpes; i++)
+        for (i = 0; i < min(gic_vpes, NR_CPUS); i++)
                 clear_bit(irq, pcpu_masks[i].pcpu_mask);
         set_bit(irq, pcpu_masks[cpumask_first(&tmp)].pcpu_mask);
 
@@ -707,7 +707,7 @@ static int gic_shared_irq_domain_map(struct irq_domain *d, unsigned int virq,
         spin_lock_irqsave(&gic_lock, flags);
         gic_map_to_pin(intr, gic_cpu_pin);
         gic_map_to_vpe(intr, vpe);
-        for (i = 0; i < gic_vpes; i++)
+        for (i = 0; i < min(gic_vpes, NR_CPUS); i++)
                 clear_bit(intr, pcpu_masks[i].pcpu_mask);
         set_bit(intr, pcpu_masks[vpe].pcpu_mask);
         spin_unlock_irqrestore(&gic_lock, flags);
diff --git a/drivers/isdn/hisax/isac.c b/drivers/isdn/hisax/isac.c
index 7fdf78f46433..df7e05ca8f9c 100644
--- a/drivers/isdn/hisax/isac.c
+++ b/drivers/isdn/hisax/isac.c
@@ -215,9 +215,11 @@ isac_interrupt(struct IsdnCardState *cs, u_char val)
                         if (count == 0)
                                 count = 32;
                         isac_empty_fifo(cs, count);
-                        if ((count = cs->rcvidx) > 0) {
+                        count = cs->rcvidx;
+                        if (count > 0) {
                                 cs->rcvidx = 0;
-                                if (!(skb = alloc_skb(count, GFP_ATOMIC)))
+                                skb = alloc_skb(count, GFP_ATOMIC);
+                                if (!skb)
                                         printk(KERN_WARNING "HiSax: D receive out of memory\n");
                                 else {
                                         memcpy(skb_put(skb, count), cs->rcvbuf, count);
@@ -251,7 +253,8 @@ isac_interrupt(struct IsdnCardState *cs, u_char val)
                                 cs->tx_skb = NULL;
                         }
                 }
-                if ((cs->tx_skb = skb_dequeue(&cs->sq))) {
+                cs->tx_skb = skb_dequeue(&cs->sq);
+                if (cs->tx_skb) {
                         cs->tx_cnt = 0;
                         isac_fill_fifo(cs);
                 } else
@@ -313,7 +316,8 @@ afterXPR:
 #if ARCOFI_USE
                         if (v1 & 0x08) {
                                 if (!cs->dc.isac.mon_rx) {
-                                        if (!(cs->dc.isac.mon_rx = kmalloc(MAX_MON_FRAME, GFP_ATOMIC))) {
+                                        cs->dc.isac.mon_rx = kmalloc(MAX_MON_FRAME, GFP_ATOMIC);
+                                        if (!cs->dc.isac.mon_rx) {
                                                 if (cs->debug & L1_DEB_WARN)
                                                         debugl1(cs, "ISAC MON RX out of memory!");
                                                 cs->dc.isac.mocr &= 0xf0;
@@ -343,7 +347,8 @@ afterXPR:
                 afterMONR0:
                         if (v1 & 0x80) {
                                 if (!cs->dc.isac.mon_rx) {
-                                        if (!(cs->dc.isac.mon_rx = kmalloc(MAX_MON_FRAME, GFP_ATOMIC))) {
+                                        cs->dc.isac.mon_rx = kmalloc(MAX_MON_FRAME, GFP_ATOMIC);
+                                        if (!cs->dc.isac.mon_rx) {
                                                 if (cs->debug & L1_DEB_WARN)
                                                         debugl1(cs, "ISAC MON RX out of memory!");
                                                 cs->dc.isac.mocr &= 0x0f;
diff --git a/drivers/isdn/mISDN/socket.c b/drivers/isdn/mISDN/socket.c
index 0d29b5a6356d..99e5f9751e8b 100644
--- a/drivers/isdn/mISDN/socket.c
+++ b/drivers/isdn/mISDN/socket.c
@@ -715,6 +715,9 @@ base_sock_bind(struct socket *sock, struct sockaddr *addr, int addr_len)
         if (!maddr || maddr->family != AF_ISDN)
                 return -EINVAL;
 
+        if (addr_len < sizeof(struct sockaddr_mISDN))
+                return -EINVAL;
+
         lock_sock(sk);
 
         if (_pms(sk)->dev) {
diff --git a/drivers/lguest/interrupts_and_traps.c b/drivers/lguest/interrupts_and_traps.c
index eb934b0242e0..67392b6ab845 100644
--- a/drivers/lguest/interrupts_and_traps.c
+++ b/drivers/lguest/interrupts_and_traps.c
@@ -331,7 +331,7 @@ void set_interrupt(struct lg_cpu *cpu, unsigned int irq)
  * Actually now I think of it, it's possible that Ron *is* half the Plan 9
  * userbase.  Oh well.
  */
-static bool could_be_syscall(unsigned int num)
+bool could_be_syscall(unsigned int num)
 {
         /* Normal Linux IA32_SYSCALL_VECTOR or reserved vector? */
         return num == IA32_SYSCALL_VECTOR || num == syscall_vector;
@@ -416,6 +416,10 @@ bool deliver_trap(struct lg_cpu *cpu, unsigned int num)
  *
  * This routine indicates if a particular trap number could be delivered
  * directly.
+ *
+ * Unfortunately, Linux 4.6 started using an interrupt gate instead of a
+ * trap gate for syscalls, so this trick is ineffective.  See Mastery for
+ * how we could do this anyway...
  */
 static bool direct_trap(unsigned int num)
 {
diff --git a/drivers/lguest/lg.h b/drivers/lguest/lg.h
index ac8ad0461e80..69b3814afd2f 100644
--- a/drivers/lguest/lg.h
+++ b/drivers/lguest/lg.h
@@ -167,6 +167,7 @@ void guest_set_clockevent(struct lg_cpu *cpu, unsigned long delta);
 bool send_notify_to_eventfd(struct lg_cpu *cpu);
 void init_clockdev(struct lg_cpu *cpu);
 bool check_syscall_vector(struct lguest *lg);
+bool could_be_syscall(unsigned int num);
 int init_interrupts(void);
 void free_interrupts(void);
 
diff --git a/drivers/lguest/x86/core.c b/drivers/lguest/x86/core.c
index 6a4cd771a2be..adc162c7040d 100644
--- a/drivers/lguest/x86/core.c
+++ b/drivers/lguest/x86/core.c
@@ -429,8 +429,12 @@ void lguest_arch_handle_trap(struct lg_cpu *cpu)
                         return;
                 break;
         case 32 ... 255:
+                /* This might be a syscall. */
+                if (could_be_syscall(cpu->regs->trapnum))
+                        break;
+
                 /*
-                 * These values mean a real interrupt occurred, in which case
+                 * Other values mean a real interrupt occurred, in which case
                  * the Host handler has already been run. We just do a
                  * friendly check if another process should now be run, then
                  * return to run the Guest again.
diff --git a/drivers/mailbox/mailbox-test.c b/drivers/mailbox/mailbox-test.c
index dc11bbf27274..58d04726cdd7 100644
--- a/drivers/mailbox/mailbox-test.c
+++ b/drivers/mailbox/mailbox-test.c
@@ -46,7 +46,6 @@ static ssize_t mbox_test_signal_write(struct file *filp,
                                        size_t count, loff_t *ppos)
 {
         struct mbox_test_device *tdev = filp->private_data;
-        int ret;
 
         if (!tdev->tx_channel) {
                 dev_err(tdev->dev, "Channel cannot do Tx\n");
@@ -60,17 +59,20 @@ static ssize_t mbox_test_signal_write(struct file *filp,
                 return -EINVAL;
         }
 
-        tdev->signal = kzalloc(MBOX_MAX_SIG_LEN, GFP_KERNEL);
-        if (!tdev->signal)
-                return -ENOMEM;
+        /* Only allocate memory if we need to */
+        if (!tdev->signal) {
+                tdev->signal = kzalloc(MBOX_MAX_SIG_LEN, GFP_KERNEL);
+                if (!tdev->signal)
+                        return -ENOMEM;
+        }
 
-        ret = copy_from_user(tdev->signal, userbuf, count);
-        if (ret) {
+        if (copy_from_user(tdev->signal, userbuf, count)) {
                 kfree(tdev->signal);
+                tdev->signal = NULL;
                 return -EFAULT;
         }
 
-        return ret < 0 ? ret : count;
+        return count;
 }
 
 static const struct file_operations mbox_test_signal_ops = {
diff --git a/drivers/mailbox/mailbox-xgene-slimpro.c b/drivers/mailbox/mailbox-xgene-slimpro.c
index bd07f39f0692..dd2afbca51c9 100644
--- a/drivers/mailbox/mailbox-xgene-slimpro.c
+++ b/drivers/mailbox/mailbox-xgene-slimpro.c
@@ -189,8 +189,8 @@ static int slimpro_mbox_probe(struct platform_device *pdev)
         int i;
 
         ctx = devm_kzalloc(&pdev->dev, sizeof(struct slimpro_mbox), GFP_KERNEL);
-        if (IS_ERR(ctx))
-                return PTR_ERR(ctx);
+        if (!ctx)
+                return -ENOMEM;
 
         platform_set_drvdata(pdev, ctx);
 
diff --git a/drivers/mailbox/mailbox.c b/drivers/mailbox/mailbox.c
index 6a4811f85705..4a36632c236f 100644
--- a/drivers/mailbox/mailbox.c
+++ b/drivers/mailbox/mailbox.c
@@ -375,13 +375,13 @@ struct mbox_chan *mbox_request_channel_byname(struct mbox_client *cl,
 
         if (!np) {
                 dev_err(cl->dev, "%s() currently only supports DT\n", __func__);
-                return ERR_PTR(-ENOSYS);
+                return ERR_PTR(-EINVAL);
         }
 
         if (!of_get_property(np, "mbox-names", NULL)) {
                 dev_err(cl->dev,
                         "%s() requires an \"mbox-names\" property\n", __func__);
-                return ERR_PTR(-ENOSYS);
+                return ERR_PTR(-EINVAL);
         }
 
         of_property_for_each_string(np, "mbox-names", prop, mbox_name) {
diff --git a/drivers/mailbox/pcc.c b/drivers/mailbox/pcc.c
index 0ddf638d60f3..043828d541f7 100644
--- a/drivers/mailbox/pcc.c
+++ b/drivers/mailbox/pcc.c
@@ -361,8 +361,6 @@ static int __init acpi_pcc_probe(void)
                 struct acpi_generic_address *db_reg;
                 struct acpi_pcct_hw_reduced *pcct_ss;
                 pcc_mbox_channels[i].con_priv = pcct_entry;
-                pcct_entry = (struct acpi_subtable_header *)
-                        ((unsigned long) pcct_entry + pcct_entry->length);
 
                 /* If doorbell is in system memory cache the virt address */
                 pcct_ss = (struct acpi_pcct_hw_reduced *)pcct_entry;
@@ -370,6 +368,8 @@ static int __init acpi_pcc_probe(void)
                 if (db_reg->space_id == ACPI_ADR_SPACE_SYSTEM_MEMORY)
                         pcc_doorbell_vaddr[i] = acpi_os_ioremap(db_reg->address,
                                                         db_reg->bit_width/8);
+                pcct_entry = (struct acpi_subtable_header *)
+                        ((unsigned long) pcct_entry + pcct_entry->length);
         }
 
         pcc_mbox_ctrl.num_chans = count;
diff --git a/drivers/md/bitmap.c b/drivers/md/bitmap.c
index 7df6b4f1548a..3fe86b54d50b 100644
--- a/drivers/md/bitmap.c
+++ b/drivers/md/bitmap.c
@@ -322,7 +322,7 @@ __clear_page_buffers(struct page *page)
 {
         ClearPagePrivate(page);
         set_page_private(page, 0);
-        page_cache_release(page);
+        put_page(page);
 }
 static void free_buffers(struct page *page)
 {
@@ -1673,6 +1673,9 @@ static void bitmap_free(struct bitmap *bitmap)
         if (!bitmap) /* there was no bitmap */
                 return;
 
+        if (bitmap->sysfs_can_clear)
+                sysfs_put(bitmap->sysfs_can_clear);
+
         if (mddev_is_clustered(bitmap->mddev) && bitmap->mddev->cluster_info &&
                 bitmap->cluster_slot == md_cluster_ops->slot_number(bitmap->mddev))
                 md_cluster_stop(bitmap->mddev);
@@ -1712,15 +1715,13 @@ void bitmap_destroy(struct mddev *mddev)
         if (mddev->thread)
                 mddev->thread->timeout = MAX_SCHEDULE_TIMEOUT;
 
-        if (bitmap->sysfs_can_clear)
-                sysfs_put(bitmap->sysfs_can_clear);
-
         bitmap_free(bitmap);
 }
 
 /*
  * initialize the bitmap structure
  * if this returns an error, bitmap_destroy must be called to do clean up
+ * once mddev->bitmap is set
  */
 struct bitmap *bitmap_create(struct mddev *mddev, int slot)
 {
@@ -1865,8 +1866,10 @@ int bitmap_copy_from_slot(struct mddev *mddev, int slot,
         struct bitmap_counts *counts;
         struct bitmap *bitmap = bitmap_create(mddev, slot);
 
-        if (IS_ERR(bitmap))
+        if (IS_ERR(bitmap)) {
+                bitmap_free(bitmap);
                 return PTR_ERR(bitmap);
+        }
 
         rv = bitmap_init_from_disk(bitmap, 0);
         if (rv)
@@ -2170,14 +2173,14 @@ location_store(struct mddev *mddev, const char *buf, size_t len)
                                 else {
                                         mddev->bitmap = bitmap;
                                         rv = bitmap_load(mddev);
-                                        if (rv) {
-                                                bitmap_destroy(mddev);
+                                        if (rv)
                                                 mddev->bitmap_info.offset = 0;
-                                        }
                                 }
                                 mddev->pers->quiesce(mddev, 0);
-                                if (rv)
+                                if (rv) {
+                                        bitmap_destroy(mddev);
                                         return rv;
+                                }
                         }
                 }
         }
diff --git a/drivers/md/dm-cache-metadata.c b/drivers/md/dm-cache-metadata.c
index 27f2ef300f8b..3970cda10080 100644
--- a/drivers/md/dm-cache-metadata.c
+++ b/drivers/md/dm-cache-metadata.c
@@ -867,39 +867,55 @@ static int blocks_are_unmapped_or_clean(struct dm_cache_metadata *cmd,
         return 0;
 }
 
-#define WRITE_LOCK(cmd) \
-        down_write(&cmd->root_lock); \
-        if (cmd->fail_io || dm_bm_is_read_only(cmd->bm)) { \
-                up_write(&cmd->root_lock); \
-                return -EINVAL; \
+static bool cmd_write_lock(struct dm_cache_metadata *cmd)
+{
+        down_write(&cmd->root_lock);
+        if (cmd->fail_io || dm_bm_is_read_only(cmd->bm)) {
+                up_write(&cmd->root_lock);
+                return false;
         }
+        return true;
+}
 
-#define WRITE_LOCK_VOID(cmd) \
-        down_write(&cmd->root_lock); \
-        if (cmd->fail_io || dm_bm_is_read_only(cmd->bm)) { \
-                up_write(&cmd->root_lock); \
-                return; \
-        }
+#define WRITE_LOCK(cmd)                         \
+        do {                                    \
+                if (!cmd_write_lock((cmd)))     \
+                        return -EINVAL;         \
+        } while(0)
+
+#define WRITE_LOCK_VOID(cmd)                    \
+        do {                                    \
+                if (!cmd_write_lock((cmd)))     \
+                        return;                 \
+        } while(0)
 
 #define WRITE_UNLOCK(cmd) \
-        up_write(&cmd->root_lock)
+        up_write(&(cmd)->root_lock)
 
-#define READ_LOCK(cmd) \
-        down_read(&cmd->root_lock); \
-        if (cmd->fail_io || dm_bm_is_read_only(cmd->bm)) { \
-                up_read(&cmd->root_lock); \
-                return -EINVAL; \
+static bool cmd_read_lock(struct dm_cache_metadata *cmd)
+{
+        down_read(&cmd->root_lock);
+        if (cmd->fail_io) {
+                up_read(&cmd->root_lock);
+                return false;
         }
+        return true;
+}
 
-#define READ_LOCK_VOID(cmd)     \
-        down_read(&cmd->root_lock); \
-        if (cmd->fail_io || dm_bm_is_read_only(cmd->bm)) { \
-                up_read(&cmd->root_lock); \
-                return; \
-        }
+#define READ_LOCK(cmd)                          \
+        do {                                    \
+                if (!cmd_read_lock((cmd)))      \
+                        return -EINVAL;         \
+        } while(0)
+
+#define READ_LOCK_VOID(cmd)                     \
+        do {                                    \
+                if (!cmd_read_lock((cmd)))      \
+                        return;                 \
+        } while(0)
 
 #define READ_UNLOCK(cmd) \
-        up_read(&cmd->root_lock)
+        up_read(&(cmd)->root_lock)
 
 int dm_cache_resize(struct dm_cache_metadata *cmd, dm_cblock_t new_cache_size)
 {
diff --git a/drivers/md/dm.c b/drivers/md/dm.c
index be4905769a45..3d3ac13287a4 100644
--- a/drivers/md/dm.c
+++ b/drivers/md/dm.c
@@ -1662,8 +1662,10 @@ static int __clone_and_map_data_bio(struct clone_info *ci, struct dm_target *ti,
                 tio = alloc_tio(ci, ti, target_bio_nr);
                 tio->len_ptr = len;
                 r = clone_bio(tio, bio, sector, *len);
-                if (r < 0)
+                if (r < 0) {
+                        free_tio(ci->md, tio);
                         break;
+                }
                 __map_bio(tio);
         }
 
diff --git a/drivers/md/md.c b/drivers/md/md.c
index c068f171b4eb..14d3b37944df 100644
--- a/drivers/md/md.c
+++ b/drivers/md/md.c
@@ -284,6 +284,8 @@ static blk_qc_t md_make_request(struct request_queue *q, struct bio *bio)
          * go away inside make_request
          */
         sectors = bio_sectors(bio);
+        /* bio could be mergeable after passing to underlayer */
+        bio->bi_rw &= ~REQ_NOMERGE;
         mddev->pers->make_request(mddev, bio);
 
         cpu = part_stat_lock();
@@ -718,6 +720,7 @@ static void super_written(struct bio *bio)
 
         if (atomic_dec_and_test(&mddev->pending_writes))
                 wake_up(&mddev->sb_wait);
+        rdev_dec_pending(rdev, mddev);
         bio_put(bio);
 }
 
@@ -732,6 +735,8 @@ void md_super_write(struct mddev *mddev, struct md_rdev *rdev,
          */
         struct bio *bio = bio_alloc_mddev(GFP_NOIO, 1, mddev);
 
+        atomic_inc(&rdev->nr_pending);
+
         bio->bi_bdev = rdev->meta_bdev ? rdev->meta_bdev : rdev->bdev;
         bio->bi_iter.bi_sector = sector;
         bio_add_page(bio, page, size, 0);
@@ -6883,7 +6888,7 @@ static int md_ioctl(struct block_device *bdev, fmode_t mode,
 
         case ADD_NEW_DISK:
                 /* We can support ADD_NEW_DISK on read-only arrays
-                 * on if we are re-adding a preexisting device.
+                 * only if we are re-adding a preexisting device.
                  * So require mddev->pers and MD_DISK_SYNC.
                  */
                 if (mddev->pers) {
diff --git a/drivers/md/raid0.c b/drivers/md/raid0.c
index 2ea12c6bf659..34783a3c8b3c 100644
--- a/drivers/md/raid0.c
+++ b/drivers/md/raid0.c
@@ -70,7 +70,6 @@ static void dump_zones(struct mddev *mddev)
                         (unsigned long long)zone_size>>1);
                 zone_start = conf->strip_zone[j].zone_end;
         }
-        printk(KERN_INFO "\n");
 }
 
 static int create_strip_zones(struct mddev *mddev, struct r0conf **private_conf)
@@ -85,6 +84,7 @@ static int create_strip_zones(struct mddev *mddev, struct r0conf **private_conf)
         struct r0conf *conf = kzalloc(sizeof(*conf), GFP_KERNEL);
         unsigned short blksize = 512;
 
+        *private_conf = ERR_PTR(-ENOMEM);
         if (!conf)
                 return -ENOMEM;
         rdev_for_each(rdev1, mddev) {
diff --git a/drivers/md/raid1.c b/drivers/md/raid1.c
index 39fb21e048e6..a7f2b9c9f8a0 100644
--- a/drivers/md/raid1.c
+++ b/drivers/md/raid1.c
@@ -570,7 +570,7 @@ static int read_balance(struct r1conf *conf, struct r1bio *r1_bio, int *max_sect
                         if (best_dist_disk < 0) {
                                 if (is_badblock(rdev, this_sector, sectors,
                                                 &first_bad, &bad_sectors)) {
-                                        if (first_bad < this_sector)
+                                        if (first_bad <= this_sector)
                                                 /* Cannot use this */
                                                 continue;
                                         best_good_sectors = first_bad - this_sector;
diff --git a/drivers/md/raid5.c b/drivers/md/raid5.c
index 8ab8b65e1741..e48c262ce032 100644
--- a/drivers/md/raid5.c
+++ b/drivers/md/raid5.c
@@ -3502,8 +3502,6 @@ returnbi:
                                 dev = &sh->dev[i];
                         } else if (test_bit(R5_Discard, &dev->flags))
                                 discard_pending = 1;
-                        WARN_ON(test_bit(R5_SkipCopy, &dev->flags));
-                        WARN_ON(dev->page != dev->orig_page);
                 }
 
         r5l_stripe_write_finished(sh);
diff --git a/drivers/media/media-device.c b/drivers/media/media-device.c
index 6e43c95629ea..3cfd7af8c5ca 100644
--- a/drivers/media/media-device.c
+++ b/drivers/media/media-device.c
@@ -846,11 +846,11 @@ struct media_device *media_device_find_devres(struct device *dev)
 }
 EXPORT_SYMBOL_GPL(media_device_find_devres);
 
+#if IS_ENABLED(CONFIG_PCI)
 void media_device_pci_init(struct media_device *mdev,
                            struct pci_dev *pci_dev,
                            const char *name)
 {
-#ifdef CONFIG_PCI
         mdev->dev = &pci_dev->dev;
 
         if (name)
@@ -866,16 +866,16 @@ void media_device_pci_init(struct media_device *mdev,
         mdev->driver_version = LINUX_VERSION_CODE;
 
         media_device_init(mdev);
-#endif
 }
 EXPORT_SYMBOL_GPL(media_device_pci_init);
+#endif
 
+#if IS_ENABLED(CONFIG_USB)
 void __media_device_usb_init(struct media_device *mdev,
                              struct usb_device *udev,
                              const char *board_name,
                              const char *driver_name)
 {
-#ifdef CONFIG_USB
         mdev->dev = &udev->dev;
 
         if (driver_name)
@@ -895,9 +895,9 @@ void __media_device_usb_init(struct media_device *mdev,
         mdev->driver_version = LINUX_VERSION_CODE;
 
         media_device_init(mdev);
-#endif
 }
 EXPORT_SYMBOL_GPL(__media_device_usb_init);
+#endif
 
 
 #endif /* CONFIG_MEDIA_CONTROLLER */
diff --git a/drivers/media/platform/exynos4-is/media-dev.c b/drivers/media/platform/exynos4-is/media-dev.c
index feb521f28e14..4f494acd8150 100644
--- a/drivers/media/platform/exynos4-is/media-dev.c
+++ b/drivers/media/platform/exynos4-is/media-dev.c
@@ -1446,22 +1446,13 @@ static int fimc_md_probe(struct platform_device *pdev)
 
         platform_set_drvdata(pdev, fmd);
 
-        /* Protect the media graph while we're registering entities */
-        mutex_lock(&fmd->media_dev.graph_mutex);
-
         ret = fimc_md_register_platform_entities(fmd, dev->of_node);
-        if (ret) {
-                mutex_unlock(&fmd->media_dev.graph_mutex);
+        if (ret)
                 goto err_clk;
-        }
 
         ret = fimc_md_register_sensor_entities(fmd);
-        if (ret) {
-                mutex_unlock(&fmd->media_dev.graph_mutex);
+        if (ret)
                 goto err_m_ent;
-        }
-
-        mutex_unlock(&fmd->media_dev.graph_mutex);
 
         ret = device_create_file(&pdev->dev, &dev_attr_subdev_conf_mode);
         if (ret)
diff --git a/drivers/media/platform/s3c-camif/camif-core.c b/drivers/media/platform/s3c-camif/camif-core.c
index 0b44b9accf50..af237af204e2 100644
--- a/drivers/media/platform/s3c-camif/camif-core.c
+++ b/drivers/media/platform/s3c-camif/camif-core.c
@@ -493,21 +493,17 @@ static int s3c_camif_probe(struct platform_device *pdev)
         if (ret < 0)
                 goto err_sens;
 
-        mutex_lock(&camif->media_dev.graph_mutex);
-
         ret = v4l2_device_register_subdev_nodes(&camif->v4l2_dev);
         if (ret < 0)
-                goto err_unlock;
+                goto err_sens;
 
         ret = camif_register_video_nodes(camif);
         if (ret < 0)
-                goto err_unlock;
+                goto err_sens;
 
         ret = camif_create_media_links(camif);
         if (ret < 0)
-                goto err_unlock;
-
-        mutex_unlock(&camif->media_dev.graph_mutex);
+                goto err_sens;
 
         ret = media_device_register(&camif->media_dev);
         if (ret < 0)
@@ -516,8 +512,6 @@ static int s3c_camif_probe(struct platform_device *pdev)
         pm_runtime_put(dev);
         return 0;
 
-err_unlock:
-        mutex_unlock(&camif->media_dev.graph_mutex);
 err_sens:
         v4l2_device_unregister(&camif->v4l2_dev);
         media_device_unregister(&camif->media_dev);
diff --git a/drivers/media/usb/au0828/au0828-cards.c b/drivers/media/usb/au0828/au0828-cards.c
index ca861aea68a5..6b469e8c4c6e 100644
--- a/drivers/media/usb/au0828/au0828-cards.c
+++ b/drivers/media/usb/au0828/au0828-cards.c
@@ -228,10 +228,6 @@ void au0828_card_analog_fe_setup(struct au0828_dev *dev)
                                 "au8522", 0x8e >> 1, NULL);
                 if (sd == NULL)
                         pr_err("analog subdev registration failed\n");
-#ifdef CONFIG_MEDIA_CONTROLLER
-                if (sd)
-                        dev->decoder = &sd->entity;
-#endif
         }
 
         /* Setup tuners */
diff --git a/drivers/media/usb/au0828/au0828-core.c b/drivers/media/usb/au0828/au0828-core.c
index 5dc82e8c8670..cc22b32776ad 100644
--- a/drivers/media/usb/au0828/au0828-core.c
+++ b/drivers/media/usb/au0828/au0828-core.c
@@ -137,8 +137,14 @@ static void au0828_unregister_media_device(struct au0828_dev *dev)
 #ifdef CONFIG_MEDIA_CONTROLLER
         if (dev->media_dev &&
                 media_devnode_is_registered(&dev->media_dev->devnode)) {
+                /* clear enable_source, disable_source */
+                dev->media_dev->source_priv = NULL;
+                dev->media_dev->enable_source = NULL;
+                dev->media_dev->disable_source = NULL;
+
                 media_device_unregister(dev->media_dev);
                 media_device_cleanup(dev->media_dev);
+                kfree(dev->media_dev);
                 dev->media_dev = NULL;
         }
 #endif
@@ -166,7 +172,7 @@ static void au0828_usb_disconnect(struct usb_interface *interface)
            Set the status so poll routines can check and avoid
            access after disconnect.
         */
-        dev->dev_state = DEV_DISCONNECTED;
+        set_bit(DEV_DISCONNECTED, &dev->dev_state);
 
         au0828_rc_unregister(dev);
         /* Digital TV */
@@ -192,7 +198,7 @@ static int au0828_media_device_init(struct au0828_dev *dev,
 #ifdef CONFIG_MEDIA_CONTROLLER
         struct media_device *mdev;
 
-        mdev = media_device_get_devres(&udev->dev);
+        mdev = kzalloc(sizeof(*mdev), GFP_KERNEL);
         if (!mdev)
                 return -ENOMEM;
 
@@ -456,7 +462,8 @@ static int au0828_media_device_register(struct au0828_dev *dev,
 {
 #ifdef CONFIG_MEDIA_CONTROLLER
         int ret;
-        struct media_entity *entity, *demod = NULL, *tuner = NULL;
+        struct media_entity *entity, *demod = NULL;
+        struct media_link *link;
 
         if (!dev->media_dev)
                 return 0;
@@ -482,26 +489,37 @@ static int au0828_media_device_register(struct au0828_dev *dev,
         }
 
         /*
-         * Find tuner and demod to disable the link between
-         * the two to avoid disable step when tuner is requested
-         * by video or audio. Note that this step can't be done
-         * until dvb graph is created during dvb register.
+         * Find tuner, decoder and demod.
+         *
+         * The tuner and decoder should be cached, as they'll be used by
+         *      au0828_enable_source.
+         *
+         * It also needs to disable the link between tuner and
+         * decoder/demod, to avoid disable step when tuner is requested
+         * by video or audio. Note that this step can't be done until dvb
+         * graph is created during dvb register.
         */
         media_device_for_each_entity(entity, dev->media_dev) {
-                if (entity->function == MEDIA_ENT_F_DTV_DEMOD)
+                switch (entity->function) {
+                case MEDIA_ENT_F_TUNER:
+                        dev->tuner = entity;
+                        break;
+                case MEDIA_ENT_F_ATV_DECODER:
+                        dev->decoder = entity;
+                        break;
+                case MEDIA_ENT_F_DTV_DEMOD:
                         demod = entity;
-                else if (entity->function == MEDIA_ENT_F_TUNER)
-                        tuner = entity;
+                        break;
+                }
         }
-        /* Disable link between tuner and demod */
-        if (tuner && demod) {
-                struct media_link *link;
 
-                list_for_each_entry(link, &demod->links, list) {
-                        if (link->sink->entity == demod &&
-                            link->source->entity == tuner) {
+        /* Disable link between tuner->demod and/or tuner->decoder */
+        if (dev->tuner) {
+                list_for_each_entry(link, &dev->tuner->links, list) {
+                        if (demod && link->sink->entity == demod)
+                                media_entity_setup_link(link, 0);
+                        if (dev->decoder && link->sink->entity == dev->decoder)
                                 media_entity_setup_link(link, 0);
-                        }
                 }
         }
 
diff --git a/drivers/media/usb/au0828/au0828-input.c b/drivers/media/usb/au0828/au0828-input.c
index b0f067971979..3d6687f0407d 100644
--- a/drivers/media/usb/au0828/au0828-input.c
+++ b/drivers/media/usb/au0828/au0828-input.c
@@ -130,7 +130,7 @@ static int au0828_get_key_au8522(struct au0828_rc *ir)
         bool first = true;
 
         /* do nothing if device is disconnected */
-        if (ir->dev->dev_state == DEV_DISCONNECTED)
+        if (test_bit(DEV_DISCONNECTED, &ir->dev->dev_state))
                 return 0;
 
         /* Check IR int */
@@ -260,7 +260,7 @@ static void au0828_rc_stop(struct rc_dev *rc)
         cancel_delayed_work_sync(&ir->work);
 
         /* do nothing if device is disconnected */
-        if (ir->dev->dev_state != DEV_DISCONNECTED) {
+        if (!test_bit(DEV_DISCONNECTED, &ir->dev->dev_state)) {
                 /* Disable IR */
                 au8522_rc_clear(ir, 0xe0, 1 << 4);
         }
diff --git a/drivers/media/usb/au0828/au0828-video.c b/drivers/media/usb/au0828/au0828-video.c
index 13f6dab9ccc2..32d7db96479c 100644
--- a/drivers/media/usb/au0828/au0828-video.c
+++ b/drivers/media/usb/au0828/au0828-video.c
@@ -106,14 +106,13 @@ static inline void print_err_status(struct au0828_dev *dev,
 
 static int check_dev(struct au0828_dev *dev)
 {
-        if (dev->dev_state & DEV_DISCONNECTED) {
+        if (test_bit(DEV_DISCONNECTED, &dev->dev_state)) {
                 pr_info("v4l2 ioctl: device not present\n");
                 return -ENODEV;
         }
 
-        if (dev->dev_state & DEV_MISCONFIGURED) {
-                pr_info("v4l2 ioctl: device is misconfigured; "
-                       "close and open it again\n");
+        if (test_bit(DEV_MISCONFIGURED, &dev->dev_state)) {
+                pr_info("v4l2 ioctl: device is misconfigured; close and open it again\n");
                 return -EIO;
         }
         return 0;
@@ -521,8 +520,8 @@ static inline int au0828_isoc_copy(struct au0828_dev *dev, struct urb *urb)
         if (!dev)
                 return 0;
 
-        if ((dev->dev_state & DEV_DISCONNECTED) ||
-            (dev->dev_state & DEV_MISCONFIGURED))
+        if (test_bit(DEV_DISCONNECTED, &dev->dev_state) ||
+            test_bit(DEV_MISCONFIGURED, &dev->dev_state))
                 return 0;
 
         if (urb->status < 0) {
@@ -824,10 +823,10 @@ static int au0828_stream_interrupt(struct au0828_dev *dev)
         int ret = 0;
 
         dev->stream_state = STREAM_INTERRUPT;
-        if (dev->dev_state == DEV_DISCONNECTED)
+        if (test_bit(DEV_DISCONNECTED, &dev->dev_state))
                 return -ENODEV;
         else if (ret) {
-                dev->dev_state = DEV_MISCONFIGURED;
+                set_bit(DEV_MISCONFIGURED, &dev->dev_state);
                 dprintk(1, "%s device is misconfigured!\n", __func__);
                 return ret;
         }
@@ -1026,7 +1025,7 @@ static int au0828_v4l2_open(struct file *filp)
         int ret;
 
         dprintk(1,
-                "%s called std_set %d dev_state %d stream users %d users %d\n",
+                "%s called std_set %d dev_state %ld stream users %d users %d\n",
                 __func__, dev->std_set_in_tuner_core, dev->dev_state,
                 dev->streaming_users, dev->users);
 
@@ -1045,7 +1044,7 @@ static int au0828_v4l2_open(struct file *filp)
                 au0828_analog_stream_enable(dev);
                 au0828_analog_stream_reset(dev);
                 dev->stream_state = STREAM_OFF;
-                dev->dev_state |= DEV_INITIALIZED;
+                set_bit(DEV_INITIALIZED, &dev->dev_state);
         }
         dev->users++;
         mutex_unlock(&dev->lock);
@@ -1059,7 +1058,7 @@ static int au0828_v4l2_close(struct file *filp)
         struct video_device *vdev = video_devdata(filp);
 
         dprintk(1,
-                "%s called std_set %d dev_state %d stream users %d users %d\n",
+                "%s called std_set %d dev_state %ld stream users %d users %d\n",
                 __func__, dev->std_set_in_tuner_core, dev->dev_state,
                 dev->streaming_users, dev->users);
 
@@ -1075,7 +1074,7 @@ static int au0828_v4l2_close(struct file *filp)
                 del_timer_sync(&dev->vbi_timeout);
         }
 
-        if (dev->dev_state == DEV_DISCONNECTED)
+        if (test_bit(DEV_DISCONNECTED, &dev->dev_state))
                 goto end;
 
         if (dev->users == 1) {
@@ -1135,7 +1134,7 @@ static void au0828_init_tuner(struct au0828_dev *dev)
                 .type = V4L2_TUNER_ANALOG_TV,
         };
 
-        dprintk(1, "%s called std_set %d dev_state %d\n", __func__,
+        dprintk(1, "%s called std_set %d dev_state %ld\n", __func__,
                 dev->std_set_in_tuner_core, dev->dev_state);
 
         if (dev->std_set_in_tuner_core)
@@ -1207,7 +1206,7 @@ static int vidioc_querycap(struct file *file, void  *priv,
         struct video_device *vdev = video_devdata(file);
         struct au0828_dev *dev = video_drvdata(file);
 
-        dprintk(1, "%s called std_set %d dev_state %d\n", __func__,
+        dprintk(1, "%s called std_set %d dev_state %ld\n", __func__,
                 dev->std_set_in_tuner_core, dev->dev_state);
 
         strlcpy(cap->driver, "au0828", sizeof(cap->driver));
@@ -1250,7 +1249,7 @@ static int vidioc_g_fmt_vid_cap(struct file *file, void *priv,
 {
         struct au0828_dev *dev = video_drvdata(file);
 
-        dprintk(1, "%s called std_set %d dev_state %d\n", __func__,
+        dprintk(1, "%s called std_set %d dev_state %ld\n", __func__,
                 dev->std_set_in_tuner_core, dev->dev_state);
 
         f->fmt.pix.width = dev->width;
@@ -1269,7 +1268,7 @@ static int vidioc_try_fmt_vid_cap(struct file *file, void *priv,
 {
         struct au0828_dev *dev = video_drvdata(file);
 
-        dprintk(1, "%s called std_set %d dev_state %d\n", __func__,
+        dprintk(1, "%s called std_set %d dev_state %ld\n", __func__,
                 dev->std_set_in_tuner_core, dev->dev_state);
 
         return au0828_set_format(dev, VIDIOC_TRY_FMT, f);
@@ -1281,7 +1280,7 @@ static int vidioc_s_fmt_vid_cap(struct file *file, void *priv,
         struct au0828_dev *dev = video_drvdata(file);
         int rc;
 
-        dprintk(1, "%s called std_set %d dev_state %d\n", __func__,
+        dprintk(1, "%s called std_set %d dev_state %ld\n", __func__,
                 dev->std_set_in_tuner_core, dev->dev_state);
 
         rc = check_dev(dev);
@@ -1303,7 +1302,7 @@ static int vidioc_s_std(struct file *file, void *priv, v4l2_std_id norm)
 {
         struct au0828_dev *dev = video_drvdata(file);
 
-        dprintk(1, "%s called std_set %d dev_state %d\n", __func__,
+        dprintk(1, "%s called std_set %d dev_state %ld\n", __func__,
                 dev->std_set_in_tuner_core, dev->dev_state);
 
         if (norm == dev->std)
@@ -1335,7 +1334,7 @@ static int vidioc_g_std(struct file *file, void *priv, v4l2_std_id *norm)
 {
         struct au0828_dev *dev = video_drvdata(file);
 
-        dprintk(1, "%s called std_set %d dev_state %d\n", __func__,
+        dprintk(1, "%s called std_set %d dev_state %ld\n", __func__,
                 dev->std_set_in_tuner_core, dev->dev_state);
 
         *norm = dev->std;
@@ -1357,7 +1356,7 @@ static int vidioc_enum_input(struct file *file, void *priv,
                 [AU0828_VMUX_DVB] = "DVB",
         };
 
-        dprintk(1, "%s called std_set %d dev_state %d\n", __func__,
+        dprintk(1, "%s called std_set %d dev_state %ld\n", __func__,
                 dev->std_set_in_tuner_core, dev->dev_state);
 
         tmp = input->index;
@@ -1387,7 +1386,7 @@ static int vidioc_g_input(struct file *file, void *priv, unsigned int *i)
 {
         struct au0828_dev *dev = video_drvdata(file);
 
-        dprintk(1, "%s called std_set %d dev_state %d\n", __func__,
+        dprintk(1, "%s called std_set %d dev_state %ld\n", __func__,
                 dev->std_set_in_tuner_core, dev->dev_state);
 
         *i = dev->ctrl_input;
@@ -1398,7 +1397,7 @@ static void au0828_s_input(struct au0828_dev *dev, int index)
 {
         int i;
 
-        dprintk(1, "%s called std_set %d dev_state %d\n", __func__,
+        dprintk(1, "%s called std_set %d dev_state %ld\n", __func__,
                 dev->std_set_in_tuner_core, dev->dev_state);
 
         switch (AUVI_INPUT(index).type) {
@@ -1496,7 +1495,7 @@ static int vidioc_g_audio(struct file *file, void *priv, struct v4l2_audio *a)
 {
         struct au0828_dev *dev = video_drvdata(file);
 
-        dprintk(1, "%s called std_set %d dev_state %d\n", __func__,
+        dprintk(1, "%s called std_set %d dev_state %ld\n", __func__,
                 dev->std_set_in_tuner_core, dev->dev_state);
 
         a->index = dev->ctrl_ainput;
@@ -1516,7 +1515,7 @@ static int vidioc_s_audio(struct file *file, void *priv, const struct v4l2_audio
         if (a->index != dev->ctrl_ainput)
                 return -EINVAL;
 
-        dprintk(1, "%s called std_set %d dev_state %d\n", __func__,
+        dprintk(1, "%s called std_set %d dev_state %ld\n", __func__,
                 dev->std_set_in_tuner_core, dev->dev_state);
         return 0;
 }
@@ -1534,7 +1533,7 @@ static int vidioc_g_tuner(struct file *file, void *priv, struct v4l2_tuner *t)
         if (ret)
                 return ret;
 
-        dprintk(1, "%s called std_set %d dev_state %d\n", __func__,
+        dprintk(1, "%s called std_set %d dev_state %ld\n", __func__,
                 dev->std_set_in_tuner_core, dev->dev_state);
 
         strcpy(t->name, "Auvitek tuner");
@@ -1554,7 +1553,7 @@ static int vidioc_s_tuner(struct file *file, void *priv,
         if (t->index != 0)
                 return -EINVAL;
 
-        dprintk(1, "%s called std_set %d dev_state %d\n", __func__,
+        dprintk(1, "%s called std_set %d dev_state %ld\n", __func__,
                 dev->std_set_in_tuner_core, dev->dev_state);
 
         au0828_init_tuner(dev);
@@ -1576,7 +1575,7 @@ static int vidioc_g_frequency(struct file *file, void *priv,
 
         if (freq->tuner != 0)
                 return -EINVAL;
-        dprintk(1, "%s called std_set %d dev_state %d\n", __func__,
+        dprintk(1, "%s called std_set %d dev_state %ld\n", __func__,
                 dev->std_set_in_tuner_core, dev->dev_state);
         freq->frequency = dev->ctrl_freq;
         return 0;
@@ -1591,7 +1590,7 @@ static int vidioc_s_frequency(struct file *file, void *priv,
         if (freq->tuner != 0)
                 return -EINVAL;
 
-        dprintk(1, "%s called std_set %d dev_state %d\n", __func__,
+        dprintk(1, "%s called std_set %d dev_state %ld\n", __func__,
                 dev->std_set_in_tuner_core, dev->dev_state);
 
         au0828_init_tuner(dev);
@@ -1617,7 +1616,7 @@ static int vidioc_g_fmt_vbi_cap(struct file *file, void *priv,
 {
         struct au0828_dev *dev = video_drvdata(file);
 
-        dprintk(1, "%s called std_set %d dev_state %d\n", __func__,
+        dprintk(1, "%s called std_set %d dev_state %ld\n", __func__,
                 dev->std_set_in_tuner_core, dev->dev_state);
 
         format->fmt.vbi.samples_per_line = dev->vbi_width;
@@ -1643,7 +1642,7 @@ static int vidioc_cropcap(struct file *file, void *priv,
         if (cc->type != V4L2_BUF_TYPE_VIDEO_CAPTURE)
                 return -EINVAL;
 
-        dprintk(1, "%s called std_set %d dev_state %d\n", __func__,
+        dprintk(1, "%s called std_set %d dev_state %ld\n", __func__,
                 dev->std_set_in_tuner_core, dev->dev_state);
 
         cc->bounds.left = 0;
@@ -1665,7 +1664,7 @@ static int vidioc_g_register(struct file *file, void *priv,
 {
         struct au0828_dev *dev = video_drvdata(file);
 
-        dprintk(1, "%s called std_set %d dev_state %d\n", __func__,
+        dprintk(1, "%s called std_set %d dev_state %ld\n", __func__,
                 dev->std_set_in_tuner_core, dev->dev_state);
 
         reg->val = au0828_read(dev, reg->reg);
@@ -1678,7 +1677,7 @@ static int vidioc_s_register(struct file *file, void *priv,
 {
         struct au0828_dev *dev = video_drvdata(file);
 
-        dprintk(1, "%s called std_set %d dev_state %d\n", __func__,
+        dprintk(1, "%s called std_set %d dev_state %ld\n", __func__,
                 dev->std_set_in_tuner_core, dev->dev_state);
 
         return au0828_writereg(dev, reg->reg, reg->val);
diff --git a/drivers/media/usb/au0828/au0828.h b/drivers/media/usb/au0828/au0828.h
index ff7f8510fb77..87f32846f1c0 100644
--- a/drivers/media/usb/au0828/au0828.h
+++ b/drivers/media/usb/au0828/au0828.h
@@ -21,6 +21,7 @@
 
 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
 
+#include <linux/bitops.h>
 #include <linux/usb.h>
 #include <linux/i2c.h>
 #include <linux/i2c-algo-bit.h>
@@ -121,9 +122,9 @@ enum au0828_stream_state {
 
 /* device state */
 enum au0828_dev_state {
-        DEV_INITIALIZED = 0x01,
-        DEV_DISCONNECTED = 0x02,
-        DEV_MISCONFIGURED = 0x04
+        DEV_INITIALIZED = 0,
+        DEV_DISCONNECTED = 1,
+        DEV_MISCONFIGURED = 2
 };
 
 struct au0828_dev;
@@ -247,7 +248,7 @@ struct au0828_dev {
         int input_type;
         int std_set_in_tuner_core;
         unsigned int ctrl_input;
-        enum au0828_dev_state dev_state;
+        long unsigned int dev_state; /* defined at enum au0828_dev_state */;
         enum au0828_stream_state stream_state;
         wait_queue_head_t open;
 
diff --git a/drivers/media/usb/usbvision/usbvision-video.c b/drivers/media/usb/usbvision/usbvision-video.c
index 12f5ebbd0436..ad2f3d27b266 100644
--- a/drivers/media/usb/usbvision/usbvision-video.c
+++ b/drivers/media/usb/usbvision/usbvision-video.c
@@ -1452,13 +1452,6 @@ static int usbvision_probe(struct usb_interface *intf,
         printk(KERN_INFO "%s: %s found\n", __func__,
                                 usbvision_device_data[model].model_string);
 
-        /*
-         * this is a security check.
-         * an exploit using an incorrect bInterfaceNumber is known
-         */
-        if (ifnum >= USB_MAXINTERFACES || !dev->actconfig->interface[ifnum])
-                return -ENODEV;
-
         if (usbvision_device_data[model].interface >= 0)
                 interface = &dev->actconfig->interface[usbvision_device_data[model].interface]->altsetting[0];
         else if (ifnum < dev->actconfig->desc.bNumInterfaces)
diff --git a/drivers/media/v4l2-core/v4l2-mc.c b/drivers/media/v4l2-core/v4l2-mc.c
index 2a7b79bc90fd..2228cd3a846e 100644
--- a/drivers/media/v4l2-core/v4l2-mc.c
+++ b/drivers/media/v4l2-core/v4l2-mc.c
@@ -34,7 +34,7 @@ int v4l2_mc_create_media_graph(struct media_device *mdev)
 {
         struct media_entity *entity;
         struct media_entity *if_vid = NULL, *if_aud = NULL;
-        struct media_entity *tuner = NULL, *decoder = NULL, *dtv_demod = NULL;
+        struct media_entity *tuner = NULL, *decoder = NULL;
         struct media_entity *io_v4l = NULL, *io_vbi = NULL, *io_swradio = NULL;
         bool is_webcam = false;
         u32 flags;
diff --git a/drivers/media/v4l2-core/videobuf-dma-sg.c b/drivers/media/v4l2-core/videobuf-dma-sg.c
index df4c052c6bd6..f300f060b3f3 100644
--- a/drivers/media/v4l2-core/videobuf-dma-sg.c
+++ b/drivers/media/v4l2-core/videobuf-dma-sg.c
@@ -349,7 +349,7 @@ int videobuf_dma_free(struct videobuf_dmabuf *dma)
 
         if (dma->pages) {
                 for (i = 0; i < dma->nr_pages; i++)
-                        page_cache_release(dma->pages[i]);
+                        put_page(dma->pages[i]);
                 kfree(dma->pages);
                 dma->pages = NULL;
         }
diff --git a/drivers/media/v4l2-core/videobuf2-core.c b/drivers/media/v4l2-core/videobuf2-core.c
index 5d016f496e0e..9fbcb67a9ee6 100644
--- a/drivers/media/v4l2-core/videobuf2-core.c
+++ b/drivers/media/v4l2-core/videobuf2-core.c
@@ -1645,7 +1645,7 @@ static int __vb2_wait_for_done_vb(struct vb2_queue *q, int nonblocking)
  * Will sleep if required for nonblocking == false.
  */
 static int __vb2_get_done_vb(struct vb2_queue *q, struct vb2_buffer **vb,
-                                int nonblocking)
+                             void *pb, int nonblocking)
 {
         unsigned long flags;
         int ret;
@@ -1666,10 +1666,10 @@ static int __vb2_get_done_vb(struct vb2_queue *q, struct vb2_buffer **vb,
         /*
          * Only remove the buffer from done_list if v4l2_buffer can handle all
          * the planes.
-         * Verifying planes is NOT necessary since it already has been checked
-         * before the buffer is queued/prepared. So it can never fail.
          */
-        list_del(&(*vb)->done_entry);
+        ret = call_bufop(q, verify_planes_array, *vb, pb);
+        if (!ret)
+                list_del(&(*vb)->done_entry);
         spin_unlock_irqrestore(&q->done_lock, flags);
 
         return ret;
@@ -1748,7 +1748,7 @@ int vb2_core_dqbuf(struct vb2_queue *q, unsigned int *pindex, void *pb,
         struct vb2_buffer *vb = NULL;
         int ret;
 
-        ret = __vb2_get_done_vb(q, &vb, nonblocking);
+        ret = __vb2_get_done_vb(q, &vb, pb, nonblocking);
         if (ret < 0)
                 return ret;
 
@@ -2298,6 +2298,16 @@ unsigned int vb2_core_poll(struct vb2_queue *q, struct file *file,
                 return POLLERR;
 
         /*
+         * If this quirk is set and QBUF hasn't been called yet then
+         * return POLLERR as well. This only affects capture queues, output
+         * queues will always initialize waiting_for_buffers to false.
+         * This quirk is set by V4L2 for backwards compatibility reasons.
+         */
+        if (q->quirk_poll_must_check_waiting_for_buffers &&
+            q->waiting_for_buffers && (req_events & (POLLIN | POLLRDNORM)))
+                return POLLERR;
+
+        /*
          * For output streams you can call write() as long as there are fewer
          * buffers queued than there are buffers available.
          */
diff --git a/drivers/media/v4l2-core/videobuf2-memops.c b/drivers/media/v4l2-core/videobuf2-memops.c
index dbec5923fcf0..3c3b517f1d1c 100644
--- a/drivers/media/v4l2-core/videobuf2-memops.c
+++ b/drivers/media/v4l2-core/videobuf2-memops.c
@@ -49,7 +49,7 @@ struct frame_vector *vb2_create_framevec(unsigned long start,
         vec = frame_vector_create(nr);
         if (!vec)
                 return ERR_PTR(-ENOMEM);
-        ret = get_vaddr_frames(start, nr, write, 1, vec);
+        ret = get_vaddr_frames(start & PAGE_MASK, nr, write, true, vec);
         if (ret < 0)
                 goto out_destroy;
         /* We accept only complete set of PFNs */
diff --git a/drivers/media/v4l2-core/videobuf2-v4l2.c b/drivers/media/v4l2-core/videobuf2-v4l2.c
index 91f552124050..7f366f1b0377 100644
--- a/drivers/media/v4l2-core/videobuf2-v4l2.c
+++ b/drivers/media/v4l2-core/videobuf2-v4l2.c
@@ -74,6 +74,11 @@ static int __verify_planes_array(struct vb2_buffer *vb, const struct v4l2_buffer
         return 0;
 }
 
+static int __verify_planes_array_core(struct vb2_buffer *vb, const void *pb)
+{
+        return __verify_planes_array(vb, pb);
+}
+
 /**
  * __verify_length() - Verify that the bytesused value for each plane fits in
  * the plane length and that the data offset doesn't exceed the bytesused value.
@@ -437,6 +442,7 @@ static int __fill_vb2_buffer(struct vb2_buffer *vb,
 }
 
 static const struct vb2_buf_ops v4l2_buf_ops = {
+        .verify_planes_array    = __verify_planes_array_core,
         .fill_user_buffer       = __fill_v4l2_buffer,
         .fill_vb2_buffer        = __fill_vb2_buffer,
         .copy_timestamp         = __copy_timestamp,
@@ -765,6 +771,12 @@ int vb2_queue_init(struct vb2_queue *q)
         q->is_output = V4L2_TYPE_IS_OUTPUT(q->type);
         q->copy_timestamp = (q->timestamp_flags & V4L2_BUF_FLAG_TIMESTAMP_MASK)
                         == V4L2_BUF_FLAG_TIMESTAMP_COPY;
+        /*
+         * For compatibility with vb1: if QBUF hasn't been called yet, then
+         * return POLLERR as well. This only affects capture queues, output
+         * queues will always initialize waiting_for_buffers to false.
+         */
+        q->quirk_poll_must_check_waiting_for_buffers = true;
 
         return vb2_core_queue_init(q);
 }
@@ -818,14 +830,6 @@ unsigned int vb2_poll(struct vb2_queue *q, struct file *file, poll_table *wait)
                         poll_wait(file, &fh->wait, wait);
         }
 
-        /*
-         * For compatibility with vb1: if QBUF hasn't been called yet, then
-         * return POLLERR as well. This only affects capture queues, output
-         * queues will always initialize waiting_for_buffers to false.
-         */
-        if (q->waiting_for_buffers && (req_events & (POLLIN | POLLRDNORM)))
-                return POLLERR;
-
         return res | vb2_core_poll(q, file, wait);
 }
 EXPORT_SYMBOL_GPL(vb2_poll);
diff --git a/drivers/misc/cxl/context.c b/drivers/misc/cxl/context.c
index 10370f280500..7edea9c19199 100644
--- a/drivers/misc/cxl/context.c
+++ b/drivers/misc/cxl/context.c
@@ -223,6 +223,13 @@ int __detach_context(struct cxl_context *ctx)
                 cxl_ops->link_ok(ctx->afu->adapter, ctx->afu));
         flush_work(&ctx->fault_work); /* Only needed for dedicated process */
 
+        /*
+         * Wait until no further interrupts are presented by the PSL
+         * for this context.
+         */
+        if (cxl_ops->irq_wait)
+                cxl_ops->irq_wait(ctx);
+
         /* release the reference to the group leader and mm handling pid */
         put_pid(ctx->pid);
         put_pid(ctx->glpid);
diff --git a/drivers/misc/cxl/cxl.h b/drivers/misc/cxl/cxl.h
index 38e21cf7806e..73dc2a33da74 100644
--- a/drivers/misc/cxl/cxl.h
+++ b/drivers/misc/cxl/cxl.h
@@ -274,6 +274,7 @@ static const cxl_p2n_reg_t CXL_PSL_WED_An     = {0x0A0};
 #define CXL_PSL_DSISR_An_PE (1ull << (63-4))  /* PSL Error (implementation specific) */
 #define CXL_PSL_DSISR_An_AE (1ull << (63-5))  /* AFU Error */
 #define CXL_PSL_DSISR_An_OC (1ull << (63-6))  /* OS Context Warning */
+#define CXL_PSL_DSISR_PENDING (CXL_PSL_DSISR_TRANS | CXL_PSL_DSISR_An_PE | CXL_PSL_DSISR_An_AE | CXL_PSL_DSISR_An_OC)
 /* NOTE: Bits 32:63 are undefined if DSISR[DS] = 1 */
 #define CXL_PSL_DSISR_An_M  DSISR_NOHPTE      /* PTE not found */
 #define CXL_PSL_DSISR_An_P  DSISR_PROTFAULT   /* Storage protection violation */
@@ -855,6 +856,7 @@ struct cxl_backend_ops {
                                         u64 dsisr, u64 errstat);
         irqreturn_t (*psl_interrupt)(int irq, void *data);
         int (*ack_irq)(struct cxl_context *ctx, u64 tfc, u64 psl_reset_mask);
+        void (*irq_wait)(struct cxl_context *ctx);
         int (*attach_process)(struct cxl_context *ctx, bool kernel,
                         u64 wed, u64 amr);
         int (*detach_process)(struct cxl_context *ctx);
diff --git a/drivers/misc/cxl/irq.c b/drivers/misc/cxl/irq.c
index be646dc41a2c..8def4553acba 100644
--- a/drivers/misc/cxl/irq.c
+++ b/drivers/misc/cxl/irq.c
@@ -203,7 +203,6 @@ unsigned int cxl_map_irq(struct cxl *adapter, irq_hw_number_t hwirq,
 void cxl_unmap_irq(unsigned int virq, void *cookie)
 {
         free_irq(virq, cookie);
-        irq_dispose_mapping(virq);
 }
 
 int cxl_register_one_irq(struct cxl *adapter,
diff --git a/drivers/misc/cxl/native.c b/drivers/misc/cxl/native.c
index 387fcbdf9793..ecf7557cd657 100644
--- a/drivers/misc/cxl/native.c
+++ b/drivers/misc/cxl/native.c
@@ -14,6 +14,7 @@
 #include <linux/mutex.h>
 #include <linux/mm.h>
 #include <linux/uaccess.h>
+#include <linux/delay.h>
 #include <asm/synch.h>
 #include <misc/cxl-base.h>
 
@@ -797,6 +798,35 @@ static irqreturn_t native_irq_multiplexed(int irq, void *data)
         return fail_psl_irq(afu, &irq_info);
 }
 
+void native_irq_wait(struct cxl_context *ctx)
+{
+        u64 dsisr;
+        int timeout = 1000;
+        int ph;
+
+        /*
+         * Wait until no further interrupts are presented by the PSL
+         * for this context.
+         */
+        while (timeout--) {
+                ph = cxl_p2n_read(ctx->afu, CXL_PSL_PEHandle_An) & 0xffff;
+                if (ph != ctx->pe)
+                        return;
+                dsisr = cxl_p2n_read(ctx->afu, CXL_PSL_DSISR_An);
+                if ((dsisr & CXL_PSL_DSISR_PENDING) == 0)
+                        return;
+                /*
+                 * We are waiting for the workqueue to process our
+                 * irq, so need to let that run here.
+                 */
+                msleep(1);
+        }
+
+        dev_warn(&ctx->afu->dev, "WARNING: waiting on DSI for PE %i"
+                 " DSISR %016llx!\n", ph, dsisr);
+        return;
+}
+
 static irqreturn_t native_slice_irq_err(int irq, void *data)
 {
         struct cxl_afu *afu = data;
@@ -1076,6 +1106,7 @@ const struct cxl_backend_ops cxl_native_ops = {
         .handle_psl_slice_error = native_handle_psl_slice_error,
         .psl_interrupt = NULL,
         .ack_irq = native_ack_irq,
+        .irq_wait = native_irq_wait,
         .attach_process = native_attach_process,
         .detach_process = native_detach_process,
         .support_attributes = native_support_attributes,
diff --git a/drivers/misc/ibmasm/ibmasmfs.c b/drivers/misc/ibmasm/ibmasmfs.c
index e8b933111e0d..9c677f3f3c26 100644
--- a/drivers/misc/ibmasm/ibmasmfs.c
+++ b/drivers/misc/ibmasm/ibmasmfs.c
@@ -116,8 +116,8 @@ static int ibmasmfs_fill_super (struct super_block *sb, void *data, int silent)
 {
         struct inode *root;
 
-        sb->s_blocksize = PAGE_CACHE_SIZE;
-        sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
+        sb->s_blocksize = PAGE_SIZE;
+        sb->s_blocksize_bits = PAGE_SHIFT;
         sb->s_magic = IBMASMFS_MAGIC;
         sb->s_op = &ibmasmfs_s_ops;
         sb->s_time_gran = 1;
diff --git a/drivers/misc/lkdtm.c b/drivers/misc/lkdtm.c
index 5f1a36b8fbb0..0a5cbbe12452 100644
--- a/drivers/misc/lkdtm.c
+++ b/drivers/misc/lkdtm.c
@@ -458,8 +458,10 @@ static void lkdtm_do_action(enum ctype which)
                         break;
 
                 val = kmalloc(len, GFP_KERNEL);
-                if (!val)
+                if (!val) {
+                        kfree(base);
                         break;
+                }
 
                 *val = 0x12345678;
                 base[offset] = *val;
@@ -498,14 +500,17 @@ static void lkdtm_do_action(enum ctype which)
         }
         case CT_READ_BUDDY_AFTER_FREE: {
                 unsigned long p = __get_free_page(GFP_KERNEL);
-                int saw, *val = kmalloc(1024, GFP_KERNEL);
+                int saw, *val;
                 int *base;
 
                 if (!p)
                         break;
 
-                if (!val)
+                val = kmalloc(1024, GFP_KERNEL);
+                if (!val) {
+                        free_page(p);
                         break;
+                }
 
                 base = (int *)p;
 
diff --git a/drivers/misc/mic/vop/vop_vringh.c b/drivers/misc/mic/vop/vop_vringh.c
index e94c7fb6712a..88e45234d527 100644
--- a/drivers/misc/mic/vop/vop_vringh.c
+++ b/drivers/misc/mic/vop/vop_vringh.c
@@ -945,6 +945,11 @@ static long vop_ioctl(struct file *f, unsigned int cmd, unsigned long arg)
                         ret = -EFAULT;
                         goto free_ret;
                 }
+                /* Ensure desc has not changed between the two reads */
+                if (memcmp(&dd, dd_config, sizeof(dd))) {
+                        ret = -EINVAL;
+                        goto free_ret;
+                }
                 mutex_lock(&vdev->vdev_mutex);
                 mutex_lock(&vi->vop_mutex);
                 ret = vop_virtio_add_device(vdev, dd_config);
diff --git a/drivers/misc/vmw_vmci/vmci_queue_pair.c b/drivers/misc/vmw_vmci/vmci_queue_pair.c
index f42d9c4e4561..f84a4275ca29 100644
--- a/drivers/misc/vmw_vmci/vmci_queue_pair.c
+++ b/drivers/misc/vmw_vmci/vmci_queue_pair.c
@@ -728,7 +728,7 @@ static void qp_release_pages(struct page **pages,
                 if (dirty)
                         set_page_dirty(pages[i]);
 
-                page_cache_release(pages[i]);
+                put_page(pages[i]);
                 pages[i] = NULL;
         }
 }
diff --git a/drivers/mmc/card/block.c b/drivers/mmc/card/block.c
index 3bdbe50a363f..8a0147dfed27 100644
--- a/drivers/mmc/card/block.c
+++ b/drivers/mmc/card/block.c
@@ -86,7 +86,6 @@ static int max_devices;
 
 /* TODO: Replace these with struct ida */
 static DECLARE_BITMAP(dev_use, MAX_DEVICES);
-static DECLARE_BITMAP(name_use, MAX_DEVICES);
 
 /*
  * There is one mmc_blk_data per slot.
@@ -105,7 +104,6 @@ struct mmc_blk_data {
         unsigned int    usage;
         unsigned int    read_only;
         unsigned int    part_type;
-        unsigned int    name_idx;
         unsigned int    reset_done;
 #define MMC_BLK_READ            BIT(0)
 #define MMC_BLK_WRITE           BIT(1)
@@ -2202,19 +2200,6 @@ static struct mmc_blk_data *mmc_blk_alloc_req(struct mmc_card *card,
                 goto out;
         }
 
-        /*
-         * !subname implies we are creating main mmc_blk_data that will be
-         * associated with mmc_card with dev_set_drvdata. Due to device
-         * partitions, devidx will not coincide with a per-physical card
-         * index anymore so we keep track of a name index.
-         */
-        if (!subname) {
-                md->name_idx = find_first_zero_bit(name_use, max_devices);
-                __set_bit(md->name_idx, name_use);
-        } else
-                md->name_idx = ((struct mmc_blk_data *)
-                                dev_to_disk(parent)->private_data)->name_idx;
-
         md->area_type = area_type;
 
         /*
@@ -2264,7 +2249,7 @@ static struct mmc_blk_data *mmc_blk_alloc_req(struct mmc_card *card,
          */
 
         snprintf(md->disk->disk_name, sizeof(md->disk->disk_name),
-                 "mmcblk%u%s", md->name_idx, subname ? subname : "");
+                 "mmcblk%u%s", card->host->index, subname ? subname : "");
 
         if (mmc_card_mmc(card))
                 blk_queue_logical_block_size(md->queue.queue,
@@ -2418,7 +2403,6 @@ static void mmc_blk_remove_parts(struct mmc_card *card,
         struct list_head *pos, *q;
         struct mmc_blk_data *part_md;
 
-        __clear_bit(md->name_idx, name_use);
         list_for_each_safe(pos, q, &md->part) {
                 part_md = list_entry(pos, struct mmc_blk_data, part);
                 list_del(pos);
diff --git a/drivers/mmc/core/host.c b/drivers/mmc/core/host.c
index 1d94607611d8..6e4c55a4aab5 100644
--- a/drivers/mmc/core/host.c
+++ b/drivers/mmc/core/host.c
@@ -356,11 +356,11 @@ struct mmc_host *mmc_alloc_host(int extra, struct device *dev)
          * They have to set these according to their abilities.
          */
         host->max_segs = 1;
-        host->max_seg_size = PAGE_CACHE_SIZE;
+        host->max_seg_size = PAGE_SIZE;
 
-        host->max_req_size = PAGE_CACHE_SIZE;
+        host->max_req_size = PAGE_SIZE;
         host->max_blk_size = 512;
-        host->max_blk_count = PAGE_CACHE_SIZE / 512;
+        host->max_blk_count = PAGE_SIZE / 512;
 
         return host;
 }
diff --git a/drivers/mmc/host/Kconfig b/drivers/mmc/host/Kconfig
index 04feea8354cb..e657af0e95fa 100644
--- a/drivers/mmc/host/Kconfig
+++ b/drivers/mmc/host/Kconfig
@@ -97,6 +97,7 @@ config MMC_RICOH_MMC
 config MMC_SDHCI_ACPI
         tristate "SDHCI support for ACPI enumerated SDHCI controllers"
         depends on MMC_SDHCI && ACPI
+        select IOSF_MBI if X86
         help
           This selects support for ACPI enumerated SDHCI controllers,
           identified by ACPI Compatibility ID PNP0D40 or specific
diff --git a/drivers/mmc/host/sdhci-acpi.c b/drivers/mmc/host/sdhci-acpi.c
index 6839e41c6d58..bed6a494f52c 100644
--- a/drivers/mmc/host/sdhci-acpi.c
+++ b/drivers/mmc/host/sdhci-acpi.c
@@ -41,6 +41,11 @@
 #include <linux/mmc/pm.h>
 #include <linux/mmc/slot-gpio.h>
 
+#ifdef CONFIG_X86
+#include <asm/cpu_device_id.h>
+#include <asm/iosf_mbi.h>
+#endif
+
 #include "sdhci.h"
 
 enum {
@@ -116,6 +121,75 @@ static const struct sdhci_acpi_chip sdhci_acpi_chip_int = {
         .ops = &sdhci_acpi_ops_int,
 };
 
+#ifdef CONFIG_X86
+
+static bool sdhci_acpi_byt(void)
+{
+        static const struct x86_cpu_id byt[] = {
+                { X86_VENDOR_INTEL, 6, 0x37 },
+                {}
+        };
+
+        return x86_match_cpu(byt);
+}
+
+#define BYT_IOSF_SCCEP                  0x63
+#define BYT_IOSF_OCP_NETCTRL0           0x1078
+#define BYT_IOSF_OCP_TIMEOUT_BASE       GENMASK(10, 8)
+
+static void sdhci_acpi_byt_setting(struct device *dev)
+{
+        u32 val = 0;
+
+        if (!sdhci_acpi_byt())
+                return;
+
+        if (iosf_mbi_read(BYT_IOSF_SCCEP, MBI_CR_READ, BYT_IOSF_OCP_NETCTRL0,
+                          &val)) {
+                dev_err(dev, "%s read error\n", __func__);
+                return;
+        }
+
+        if (!(val & BYT_IOSF_OCP_TIMEOUT_BASE))
+                return;
+
+        val &= ~BYT_IOSF_OCP_TIMEOUT_BASE;
+
+        if (iosf_mbi_write(BYT_IOSF_SCCEP, MBI_CR_WRITE, BYT_IOSF_OCP_NETCTRL0,
+                           val)) {
+                dev_err(dev, "%s write error\n", __func__);
+                return;
+        }
+
+        dev_dbg(dev, "%s completed\n", __func__);
+}
+
+static bool sdhci_acpi_byt_defer(struct device *dev)
+{
+        if (!sdhci_acpi_byt())
+                return false;
+
+        if (!iosf_mbi_available())
+                return true;
+
+        sdhci_acpi_byt_setting(dev);
+
+        return false;
+}
+
+#else
+
+static inline void sdhci_acpi_byt_setting(struct device *dev)
+{
+}
+
+static inline bool sdhci_acpi_byt_defer(struct device *dev)
+{
+        return false;
+}
+
+#endif
+
 static int bxt_get_cd(struct mmc_host *mmc)
 {
         int gpio_cd = mmc_gpio_get_cd(mmc);
@@ -322,6 +396,9 @@ static int sdhci_acpi_probe(struct platform_device *pdev)
         if (acpi_bus_get_status(device) || !device->status.present)
                 return -ENODEV;
 
+        if (sdhci_acpi_byt_defer(dev))
+                return -EPROBE_DEFER;
+
         hid = acpi_device_hid(device);
         uid = device->pnp.unique_id;
 
@@ -447,6 +524,8 @@ static int sdhci_acpi_resume(struct device *dev)
 {
         struct sdhci_acpi_host *c = dev_get_drvdata(dev);
 
+        sdhci_acpi_byt_setting(&c->pdev->dev);
+
         return sdhci_resume_host(c->host);
 }
 
@@ -470,6 +549,8 @@ static int sdhci_acpi_runtime_resume(struct device *dev)
 {
         struct sdhci_acpi_host *c = dev_get_drvdata(dev);
 
+        sdhci_acpi_byt_setting(&c->pdev->dev);
+
         return sdhci_runtime_resume_host(c->host);
 }
 
diff --git a/drivers/mmc/host/sdhci-pci-core.c b/drivers/mmc/host/sdhci-pci-core.c
index 62aa5d0efcee..79e19017343e 100644
--- a/drivers/mmc/host/sdhci-pci-core.c
+++ b/drivers/mmc/host/sdhci-pci-core.c
@@ -390,6 +390,7 @@ static int byt_sd_probe_slot(struct sdhci_pci_slot *slot)
         slot->cd_idx = 0;
         slot->cd_override_level = true;
         if (slot->chip->pdev->device == PCI_DEVICE_ID_INTEL_BXT_SD ||
+            slot->chip->pdev->device == PCI_DEVICE_ID_INTEL_BXTM_SD ||
             slot->chip->pdev->device == PCI_DEVICE_ID_INTEL_APL_SD)
                 slot->host->mmc_host_ops.get_cd = bxt_get_cd;
 
@@ -1173,6 +1174,30 @@ static const struct pci_device_id pci_ids[] = {
 
         {
                 .vendor         = PCI_VENDOR_ID_INTEL,
+                .device         = PCI_DEVICE_ID_INTEL_BXTM_EMMC,
+                .subvendor      = PCI_ANY_ID,
+                .subdevice      = PCI_ANY_ID,
+                .driver_data    = (kernel_ulong_t)&sdhci_intel_byt_emmc,
+        },
+
+        {
+                .vendor         = PCI_VENDOR_ID_INTEL,
+                .device         = PCI_DEVICE_ID_INTEL_BXTM_SDIO,
+                .subvendor      = PCI_ANY_ID,
+                .subdevice      = PCI_ANY_ID,
+                .driver_data    = (kernel_ulong_t)&sdhci_intel_byt_sdio,
+        },
+
+        {
+                .vendor         = PCI_VENDOR_ID_INTEL,
+                .device         = PCI_DEVICE_ID_INTEL_BXTM_SD,
+                .subvendor      = PCI_ANY_ID,
+                .subdevice      = PCI_ANY_ID,
+                .driver_data    = (kernel_ulong_t)&sdhci_intel_byt_sd,
+        },
+
+        {
+                .vendor         = PCI_VENDOR_ID_INTEL,
                 .device         = PCI_DEVICE_ID_INTEL_APL_EMMC,
                 .subvendor      = PCI_ANY_ID,
                 .subdevice      = PCI_ANY_ID,
diff --git a/drivers/mmc/host/sdhci-pci.h b/drivers/mmc/host/sdhci-pci.h
index d1a0b4db60db..89e7151684a1 100644
--- a/drivers/mmc/host/sdhci-pci.h
+++ b/drivers/mmc/host/sdhci-pci.h
@@ -28,6 +28,9 @@
 #define PCI_DEVICE_ID_INTEL_BXT_SD      0x0aca
 #define PCI_DEVICE_ID_INTEL_BXT_EMMC    0x0acc
 #define PCI_DEVICE_ID_INTEL_BXT_SDIO    0x0ad0
+#define PCI_DEVICE_ID_INTEL_BXTM_SD     0x1aca
+#define PCI_DEVICE_ID_INTEL_BXTM_EMMC   0x1acc
+#define PCI_DEVICE_ID_INTEL_BXTM_SDIO   0x1ad0
 #define PCI_DEVICE_ID_INTEL_APL_SD      0x5aca
 #define PCI_DEVICE_ID_INTEL_APL_EMMC    0x5acc
 #define PCI_DEVICE_ID_INTEL_APL_SDIO    0x5ad0
diff --git a/drivers/mmc/host/sdhci-pxav3.c b/drivers/mmc/host/sdhci-pxav3.c
index aca439d3ca83..30132500aa1c 100644
--- a/drivers/mmc/host/sdhci-pxav3.c
+++ b/drivers/mmc/host/sdhci-pxav3.c
@@ -309,8 +309,30 @@ static void pxav3_set_uhs_signaling(struct sdhci_host *host, unsigned int uhs)
                 __func__, uhs, ctrl_2);
 }
 
+static void pxav3_set_power(struct sdhci_host *host, unsigned char mode,
+                            unsigned short vdd)
+{
+        struct mmc_host *mmc = host->mmc;
+        u8 pwr = host->pwr;
+
+        sdhci_set_power(host, mode, vdd);
+
+        if (host->pwr == pwr)
+                return;
+
+        if (host->pwr == 0)
+                vdd = 0;
+
+        if (!IS_ERR(mmc->supply.vmmc)) {
+                spin_unlock_irq(&host->lock);
+                mmc_regulator_set_ocr(mmc, mmc->supply.vmmc, vdd);
+                spin_lock_irq(&host->lock);
+        }
+}
+
 static const struct sdhci_ops pxav3_sdhci_ops = {
         .set_clock = sdhci_set_clock,
+        .set_power = pxav3_set_power,
         .platform_send_init_74_clocks = pxav3_gen_init_74_clocks,
         .get_max_clock = sdhci_pltfm_clk_get_max_clock,
         .set_bus_width = sdhci_set_bus_width,
diff --git a/drivers/mmc/host/sdhci-tegra.c b/drivers/mmc/host/sdhci-tegra.c
index f8c4762bb48d..bcc0de47fe7e 100644
--- a/drivers/mmc/host/sdhci-tegra.c
+++ b/drivers/mmc/host/sdhci-tegra.c
@@ -382,14 +382,6 @@ static const struct sdhci_tegra_soc_data soc_data_tegra114 = {
         .pdata = &sdhci_tegra114_pdata,
 };
 
-static const struct sdhci_tegra_soc_data soc_data_tegra124 = {
-        .pdata = &sdhci_tegra114_pdata,
-        .nvquirks = NVQUIRK_ENABLE_SDR50 |
-                    NVQUIRK_ENABLE_DDR50 |
-                    NVQUIRK_ENABLE_SDR104 |
-                    NVQUIRK_HAS_PADCALIB,
-};
-
 static const struct sdhci_pltfm_data sdhci_tegra210_pdata = {
         .quirks = SDHCI_QUIRK_BROKEN_TIMEOUT_VAL |
                   SDHCI_QUIRK_DATA_TIMEOUT_USES_SDCLK |
@@ -407,7 +399,7 @@ static const struct sdhci_tegra_soc_data soc_data_tegra210 = {
 
 static const struct of_device_id sdhci_tegra_dt_match[] = {
         { .compatible = "nvidia,tegra210-sdhci", .data = &soc_data_tegra210 },
-        { .compatible = "nvidia,tegra124-sdhci", .data = &soc_data_tegra124 },
+        { .compatible = "nvidia,tegra124-sdhci", .data = &soc_data_tegra114 },
         { .compatible = "nvidia,tegra114-sdhci", .data = &soc_data_tegra114 },
         { .compatible = "nvidia,tegra30-sdhci", .data = &soc_data_tegra30 },
         { .compatible = "nvidia,tegra20-sdhci", .data = &soc_data_tegra20 },
diff --git a/drivers/mmc/host/sdhci.c b/drivers/mmc/host/sdhci.c
index 8670f162dec7..6bd3d1794966 100644
--- a/drivers/mmc/host/sdhci.c
+++ b/drivers/mmc/host/sdhci.c
@@ -1210,10 +1210,24 @@ clock_set:
 }
 EXPORT_SYMBOL_GPL(sdhci_set_clock);
 
-static void sdhci_set_power(struct sdhci_host *host, unsigned char mode,
-                            unsigned short vdd)
+static void sdhci_set_power_reg(struct sdhci_host *host, unsigned char mode,
+                                unsigned short vdd)
 {
         struct mmc_host *mmc = host->mmc;
+
+        spin_unlock_irq(&host->lock);
+        mmc_regulator_set_ocr(mmc, mmc->supply.vmmc, vdd);
+        spin_lock_irq(&host->lock);
+
+        if (mode != MMC_POWER_OFF)
+                sdhci_writeb(host, SDHCI_POWER_ON, SDHCI_POWER_CONTROL);
+        else
+                sdhci_writeb(host, 0, SDHCI_POWER_CONTROL);
+}
+
+void sdhci_set_power(struct sdhci_host *host, unsigned char mode,
+                     unsigned short vdd)
+{
         u8 pwr = 0;
 
         if (mode != MMC_POWER_OFF) {
@@ -1245,7 +1259,6 @@ static void sdhci_set_power(struct sdhci_host *host, unsigned char mode,
                 sdhci_writeb(host, 0, SDHCI_POWER_CONTROL);
                 if (host->quirks2 & SDHCI_QUIRK2_CARD_ON_NEEDS_BUS_ON)
                         sdhci_runtime_pm_bus_off(host);
-                vdd = 0;
         } else {
                 /*
                  * Spec says that we should clear the power reg before setting
@@ -1276,12 +1289,20 @@ static void sdhci_set_power(struct sdhci_host *host, unsigned char mode,
                 if (host->quirks & SDHCI_QUIRK_DELAY_AFTER_POWER)
                         mdelay(10);
         }
+}
+EXPORT_SYMBOL_GPL(sdhci_set_power);
 
-        if (!IS_ERR(mmc->supply.vmmc)) {
-                spin_unlock_irq(&host->lock);
-                mmc_regulator_set_ocr(mmc, mmc->supply.vmmc, vdd);
-                spin_lock_irq(&host->lock);
-        }
+static void __sdhci_set_power(struct sdhci_host *host, unsigned char mode,
+                              unsigned short vdd)
+{
+        struct mmc_host *mmc = host->mmc;
+
+        if (host->ops->set_power)
+                host->ops->set_power(host, mode, vdd);
+        else if (!IS_ERR(mmc->supply.vmmc))
+                sdhci_set_power_reg(host, mode, vdd);
+        else
+                sdhci_set_power(host, mode, vdd);
 }
 
 /*****************************************************************************\
@@ -1431,7 +1452,7 @@ static void sdhci_do_set_ios(struct sdhci_host *host, struct mmc_ios *ios)
                 }
         }
 
-        sdhci_set_power(host, ios->power_mode, ios->vdd);
+        __sdhci_set_power(host, ios->power_mode, ios->vdd);
 
         if (host->ops->platform_send_init_74_clocks)
                 host->ops->platform_send_init_74_clocks(host, ios->power_mode);
diff --git a/drivers/mmc/host/sdhci.h b/drivers/mmc/host/sdhci.h
index 3bd28033dbd9..0f39f4f84d10 100644
--- a/drivers/mmc/host/sdhci.h
+++ b/drivers/mmc/host/sdhci.h
@@ -529,6 +529,8 @@ struct sdhci_ops {
 #endif
 
         void    (*set_clock)(struct sdhci_host *host, unsigned int clock);
+        void    (*set_power)(struct sdhci_host *host, unsigned char mode,
+                             unsigned short vdd);
 
         int             (*enable_dma)(struct sdhci_host *host);
         unsigned int    (*get_max_clock)(struct sdhci_host *host);
@@ -660,6 +662,8 @@ static inline bool sdhci_sdio_irq_enabled(struct sdhci_host *host)
 }
 
 void sdhci_set_clock(struct sdhci_host *host, unsigned int clock);
+void sdhci_set_power(struct sdhci_host *host, unsigned char mode,
+                     unsigned short vdd);
 void sdhci_set_bus_width(struct sdhci_host *host, int width);
 void sdhci_reset(struct sdhci_host *host, u8 mask);
 void sdhci_set_uhs_signaling(struct sdhci_host *host, unsigned timing);
diff --git a/drivers/mmc/host/sh_mmcif.c b/drivers/mmc/host/sh_mmcif.c
index 8d870ce9f944..d9a655f47d41 100644
--- a/drivers/mmc/host/sh_mmcif.c
+++ b/drivers/mmc/host/sh_mmcif.c
@@ -1513,7 +1513,7 @@ static int sh_mmcif_probe(struct platform_device *pdev)
                 mmc->caps |= pd->caps;
         mmc->max_segs = 32;
         mmc->max_blk_size = 512;
-        mmc->max_req_size = PAGE_CACHE_SIZE * mmc->max_segs;
+        mmc->max_req_size = PAGE_SIZE * mmc->max_segs;
         mmc->max_blk_count = mmc->max_req_size / mmc->max_blk_size;
         mmc->max_seg_size = mmc->max_req_size;
 
diff --git a/drivers/mmc/host/sunxi-mmc.c b/drivers/mmc/host/sunxi-mmc.c
index 8372a413848c..7fc8b7aa83f0 100644
--- a/drivers/mmc/host/sunxi-mmc.c
+++ b/drivers/mmc/host/sunxi-mmc.c
@@ -1129,6 +1129,11 @@ static int sunxi_mmc_probe(struct platform_device *pdev)
                                   MMC_CAP_1_8V_DDR |
                                   MMC_CAP_ERASE | MMC_CAP_SDIO_IRQ;
 
+        /* TODO MMC DDR is not working on A80 */
+        if (of_device_is_compatible(pdev->dev.of_node,
+                                    "allwinner,sun9i-a80-mmc"))
+                mmc->caps &= ~MMC_CAP_1_8V_DDR;
+
         ret = mmc_of_parse(mmc);
         if (ret)
                 goto error_free_dma;
diff --git a/drivers/mmc/host/tmio_mmc_dma.c b/drivers/mmc/host/tmio_mmc_dma.c
index 675435873823..7fb0c034dcb6 100644
--- a/drivers/mmc/host/tmio_mmc_dma.c
+++ b/drivers/mmc/host/tmio_mmc_dma.c
@@ -63,7 +63,7 @@ static void tmio_mmc_start_dma_rx(struct tmio_mmc_host *host)
                 }
         }
 
-        if ((!aligned && (host->sg_len > 1 || sg->length > PAGE_CACHE_SIZE ||
+        if ((!aligned && (host->sg_len > 1 || sg->length > PAGE_SIZE ||
                           (align & PAGE_MASK))) || !multiple) {
                 ret = -EINVAL;
                 goto pio;
@@ -133,7 +133,7 @@ static void tmio_mmc_start_dma_tx(struct tmio_mmc_host *host)
                 }
         }
 
-        if ((!aligned && (host->sg_len > 1 || sg->length > PAGE_CACHE_SIZE ||
+        if ((!aligned && (host->sg_len > 1 || sg->length > PAGE_SIZE ||
                           (align & PAGE_MASK))) || !multiple) {
                 ret = -EINVAL;
                 goto pio;
diff --git a/drivers/mmc/host/tmio_mmc_pio.c b/drivers/mmc/host/tmio_mmc_pio.c
index 03f6e74c1906..0521b4662748 100644
--- a/drivers/mmc/host/tmio_mmc_pio.c
+++ b/drivers/mmc/host/tmio_mmc_pio.c
@@ -1125,7 +1125,7 @@ int tmio_mmc_host_probe(struct tmio_mmc_host *_host,
         mmc->caps2 |= pdata->capabilities2;
         mmc->max_segs = 32;
         mmc->max_blk_size = 512;
-        mmc->max_blk_count = (PAGE_CACHE_SIZE / mmc->max_blk_size) *
+        mmc->max_blk_count = (PAGE_SIZE / mmc->max_blk_size) *
                 mmc->max_segs;
         mmc->max_req_size = mmc->max_blk_size * mmc->max_blk_count;
         mmc->max_seg_size = mmc->max_req_size;
diff --git a/drivers/mmc/host/usdhi6rol0.c b/drivers/mmc/host/usdhi6rol0.c
index b2752fe711f2..807c06e203c3 100644
--- a/drivers/mmc/host/usdhi6rol0.c
+++ b/drivers/mmc/host/usdhi6rol0.c
@@ -1789,7 +1789,7 @@ static int usdhi6_probe(struct platform_device *pdev)
         /* Set .max_segs to some random number. Feel free to adjust. */
         mmc->max_segs = 32;
         mmc->max_blk_size = 512;
-        mmc->max_req_size = PAGE_CACHE_SIZE * mmc->max_segs;
+        mmc->max_req_size = PAGE_SIZE * mmc->max_segs;
         mmc->max_blk_count = mmc->max_req_size / mmc->max_blk_size;
         /*
          * Setting .max_seg_size to 1 page would simplify our page-mapping code,
diff --git a/drivers/mtd/devices/block2mtd.c b/drivers/mtd/devices/block2mtd.c
index e2c0057737e6..7c887f111a7d 100644
--- a/drivers/mtd/devices/block2mtd.c
+++ b/drivers/mtd/devices/block2mtd.c
@@ -75,7 +75,7 @@ static int _block2mtd_erase(struct block2mtd_dev *dev, loff_t to, size_t len)
                                 break;
                         }
 
-                page_cache_release(page);
+                put_page(page);
                 pages--;
                 index++;
         }
@@ -124,7 +124,7 @@ static int block2mtd_read(struct mtd_info *mtd, loff_t from, size_t len,
                         return PTR_ERR(page);
 
                 memcpy(buf, page_address(page) + offset, cpylen);
-                page_cache_release(page);
+                put_page(page);
 
                 if (retlen)
                         *retlen += cpylen;
@@ -164,7 +164,7 @@ static int _block2mtd_write(struct block2mtd_dev *dev, const u_char *buf,
                         unlock_page(page);
                         balance_dirty_pages_ratelimited(mapping);
                 }
-                page_cache_release(page);
+                put_page(page);
 
                 if (retlen)
                         *retlen += cpylen;
diff --git a/drivers/mtd/nand/nand_base.c b/drivers/mtd/nand/nand_base.c
index b6facac54fc0..557b8462f55e 100644
--- a/drivers/mtd/nand/nand_base.c
+++ b/drivers/mtd/nand/nand_base.c
@@ -4009,7 +4009,6 @@ static int nand_dt_init(struct nand_chip *chip)
  * This is the first phase of the normal nand_scan() function. It reads the
  * flash ID and sets up MTD fields accordingly.
  *
- * The mtd->owner field must be set to the module of the caller.
  */
 int nand_scan_ident(struct mtd_info *mtd, int maxchips,
                     struct nand_flash_dev *table)
@@ -4429,19 +4428,12 @@ EXPORT_SYMBOL(nand_scan_tail);
  *
  * This fills out all the uninitialized function pointers with the defaults.
  * The flash ID is read and the mtd/chip structures are filled with the
- * appropriate values. The mtd->owner field must be set to the module of the
- * caller.
+ * appropriate values.
  */
 int nand_scan(struct mtd_info *mtd, int maxchips)
 {
         int ret;
 
-        /* Many callers got this wrong, so check for it for a while... */
-        if (!mtd->owner && caller_is_module()) {
-                pr_crit("%s called with NULL mtd->owner!\n", __func__);
-                BUG();
-        }
-
         ret = nand_scan_ident(mtd, maxchips, NULL);
         if (!ret)
                 ret = nand_scan_tail(mtd);
diff --git a/drivers/mtd/nand/nandsim.c b/drivers/mtd/nand/nandsim.c
index 1fd519503bb1..a58169a28741 100644
--- a/drivers/mtd/nand/nandsim.c
+++ b/drivers/mtd/nand/nandsim.c
@@ -1339,7 +1339,7 @@ static void put_pages(struct nandsim *ns)
         int i;
 
         for (i = 0; i < ns->held_cnt; i++)
-                page_cache_release(ns->held_pages[i]);
+                put_page(ns->held_pages[i]);
 }
 
 /* Get page cache pages in advance to provide NOFS memory allocation */
@@ -1349,8 +1349,8 @@ static int get_pages(struct nandsim *ns, struct file *file, size_t count, loff_t
         struct page *page;
         struct address_space *mapping = file->f_mapping;
 
-        start_index = pos >> PAGE_CACHE_SHIFT;
-        end_index = (pos + count - 1) >> PAGE_CACHE_SHIFT;
+        start_index = pos >> PAGE_SHIFT;
+        end_index = (pos + count - 1) >> PAGE_SHIFT;
         if (end_index - start_index + 1 > NS_MAX_HELD_PAGES)
                 return -EINVAL;
         ns->held_cnt = 0;
diff --git a/drivers/net/Kconfig b/drivers/net/Kconfig
index 2a1ba62b7da2..befd67df08e1 100644
--- a/drivers/net/Kconfig
+++ b/drivers/net/Kconfig
@@ -62,9 +62,8 @@ config DUMMY
           this device is consigned into oblivion) with a configurable IP
           address. It is most commonly used in order to make your currently
           inactive SLIP address seem like a real address for local programs.
-          If you use SLIP or PPP, you might want to say Y here. Since this
-          thing often comes in handy, the default is Y. It won't enlarge your
-          kernel either. What a deal. Read about it in the Network
+          If you use SLIP or PPP, you might want to say Y here. It won't
+          enlarge your kernel. What a deal. Read about it in the Network
           Administrator's Guide, available from
           <http://www.tldp.org/docs.html#guide>.
 
@@ -195,6 +194,7 @@ config GENEVE
 
 config MACSEC
         tristate "IEEE 802.1AE MAC-level encryption (MACsec)"
+        select CRYPTO
         select CRYPTO_AES
         select CRYPTO_GCM
         ---help---
diff --git a/drivers/net/dsa/mv88e6xxx.c b/drivers/net/dsa/mv88e6xxx.c
index fa086e09d6b7..5e572b3510b9 100644
--- a/drivers/net/dsa/mv88e6xxx.c
+++ b/drivers/net/dsa/mv88e6xxx.c
@@ -2181,27 +2181,10 @@ int mv88e6xxx_port_bridge_join(struct dsa_switch *ds, int port,
                                struct net_device *bridge)
 {
         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
-        u16 fid;
-        int i, err;
+        int i, err = 0;
 
         mutex_lock(&ps->smi_mutex);
 
-        /* Get or create the bridge FID and assign it to the port */
-        for (i = 0; i < ps->num_ports; ++i)
-                if (ps->ports[i].bridge_dev == bridge)
-                        break;
-
-        if (i < ps->num_ports)
-                err = _mv88e6xxx_port_fid_get(ds, i, &fid);
-        else
-                err = _mv88e6xxx_fid_new(ds, &fid);
-        if (err)
-                goto unlock;
-
-        err = _mv88e6xxx_port_fid_set(ds, port, fid);
-        if (err)
-                goto unlock;
-
         /* Assign the bridge and remap each port's VLANTable */
         ps->ports[port].bridge_dev = bridge;
 
@@ -2213,7 +2196,6 @@ int mv88e6xxx_port_bridge_join(struct dsa_switch *ds, int port,
                 }
         }
 
-unlock:
         mutex_unlock(&ps->smi_mutex);
 
         return err;
@@ -2223,16 +2205,10 @@ void mv88e6xxx_port_bridge_leave(struct dsa_switch *ds, int port)
 {
         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
         struct net_device *bridge = ps->ports[port].bridge_dev;
-        u16 fid;
         int i;
 
         mutex_lock(&ps->smi_mutex);
 
-        /* Give the port a fresh Filtering Information Database */
-        if (_mv88e6xxx_fid_new(ds, &fid) ||
-            _mv88e6xxx_port_fid_set(ds, port, fid))
-                netdev_warn(ds->ports[port], "failed to assign a new FID\n");
-
         /* Unassign the bridge and remap each port's VLANTable */
         ps->ports[port].bridge_dev = NULL;
 
@@ -2264,6 +2240,57 @@ static void mv88e6xxx_bridge_work(struct work_struct *work)
         mutex_unlock(&ps->smi_mutex);
 }
 
+static int _mv88e6xxx_phy_page_write(struct dsa_switch *ds, int port, int page,
+                                     int reg, int val)
+{
+        int ret;
+
+        ret = _mv88e6xxx_phy_write_indirect(ds, port, 0x16, page);
+        if (ret < 0)
+                goto restore_page_0;
+
+        ret = _mv88e6xxx_phy_write_indirect(ds, port, reg, val);
+restore_page_0:
+        _mv88e6xxx_phy_write_indirect(ds, port, 0x16, 0x0);
+
+        return ret;
+}
+
+static int _mv88e6xxx_phy_page_read(struct dsa_switch *ds, int port, int page,
+                                    int reg)
+{
+        int ret;
+
+        ret = _mv88e6xxx_phy_write_indirect(ds, port, 0x16, page);
+        if (ret < 0)
+                goto restore_page_0;
+
+        ret = _mv88e6xxx_phy_read_indirect(ds, port, reg);
+restore_page_0:
+        _mv88e6xxx_phy_write_indirect(ds, port, 0x16, 0x0);
+
+        return ret;
+}
+
+static int mv88e6xxx_power_on_serdes(struct dsa_switch *ds)
+{
+        int ret;
+
+        ret = _mv88e6xxx_phy_page_read(ds, REG_FIBER_SERDES, PAGE_FIBER_SERDES,
+                                       MII_BMCR);
+        if (ret < 0)
+                return ret;
+
+        if (ret & BMCR_PDOWN) {
+                ret &= ~BMCR_PDOWN;
+                ret = _mv88e6xxx_phy_page_write(ds, REG_FIBER_SERDES,
+                                                PAGE_FIBER_SERDES, MII_BMCR,
+                                                ret);
+        }
+
+        return ret;
+}
+
 static int mv88e6xxx_setup_port(struct dsa_switch *ds, int port)
 {
         struct mv88e6xxx_priv_state *ps = ds_to_priv(ds);
@@ -2367,6 +2394,23 @@ static int mv88e6xxx_setup_port(struct dsa_switch *ds, int port)
                         goto abort;
         }
 
+        /* If this port is connected to a SerDes, make sure the SerDes is not
+         * powered down.
+         */
+        if (mv88e6xxx_6352_family(ds)) {
+                ret = _mv88e6xxx_reg_read(ds, REG_PORT(port), PORT_STATUS);
+                if (ret < 0)
+                        goto abort;
+                ret &= PORT_STATUS_CMODE_MASK;
+                if ((ret == PORT_STATUS_CMODE_100BASE_X) ||
+                    (ret == PORT_STATUS_CMODE_1000BASE_X) ||
+                    (ret == PORT_STATUS_CMODE_SGMII)) {
+                        ret = mv88e6xxx_power_on_serdes(ds);
+                        if (ret < 0)
+                                goto abort;
+                }
+        }
+
         /* Port Control 2: don't force a good FCS, set the maximum frame size to
          * 10240 bytes, disable 802.1q tags checking, don't discard tagged or
          * untagged frames on this port, do a destination address lookup on all
@@ -2408,9 +2452,9 @@ static int mv88e6xxx_setup_port(struct dsa_switch *ds, int port)
          * the other bits clear.
          */
         reg = 1 << port;
-        /* Disable learning for DSA and CPU ports */
-        if (dsa_is_cpu_port(ds, port) || dsa_is_dsa_port(ds, port))
-                reg = PORT_ASSOC_VECTOR_LOCKED_PORT;
+        /* Disable learning for CPU port */
+        if (dsa_is_cpu_port(ds, port))
+                reg = 0;
 
         ret = _mv88e6xxx_reg_write(ds, REG_PORT(port), PORT_ASSOC_VECTOR, reg);
         if (ret)
@@ -2490,11 +2534,11 @@ static int mv88e6xxx_setup_port(struct dsa_switch *ds, int port)
         if (ret)
                 goto abort;
 
-        /* Port based VLAN map: give each port its own address
+        /* Port based VLAN map: give each port the same default address
          * database, and allow bidirectional communication between the
          * CPU and DSA port(s), and the other ports.
          */
-        ret = _mv88e6xxx_port_fid_set(ds, port, port + 1);
+        ret = _mv88e6xxx_port_fid_set(ds, port, 0);
         if (ret)
                 goto abort;
 
@@ -2714,13 +2758,9 @@ int mv88e6xxx_phy_page_read(struct dsa_switch *ds, int port, int page, int reg)
         int ret;
 
         mutex_lock(&ps->smi_mutex);
-        ret = _mv88e6xxx_phy_write_indirect(ds, port, 0x16, page);
-        if (ret < 0)
-                goto error;
-        ret = _mv88e6xxx_phy_read_indirect(ds, port, reg);
-error:
-        _mv88e6xxx_phy_write_indirect(ds, port, 0x16, 0x0);
+        ret = _mv88e6xxx_phy_page_read(ds, port, page, reg);
         mutex_unlock(&ps->smi_mutex);
+
         return ret;
 }
 
@@ -2731,14 +2771,9 @@ int mv88e6xxx_phy_page_write(struct dsa_switch *ds, int port, int page,
         int ret;
 
         mutex_lock(&ps->smi_mutex);
-        ret = _mv88e6xxx_phy_write_indirect(ds, port, 0x16, page);
-        if (ret < 0)
-                goto error;
-
-        ret = _mv88e6xxx_phy_write_indirect(ds, port, reg, val);
-error:
-        _mv88e6xxx_phy_write_indirect(ds, port, 0x16, 0x0);
+        ret = _mv88e6xxx_phy_page_write(ds, port, page, reg, val);
         mutex_unlock(&ps->smi_mutex);
+
         return ret;
 }
 
diff --git a/drivers/net/dsa/mv88e6xxx.h b/drivers/net/dsa/mv88e6xxx.h
index 9a038aba48fb..26a424acd10f 100644
--- a/drivers/net/dsa/mv88e6xxx.h
+++ b/drivers/net/dsa/mv88e6xxx.h
@@ -28,6 +28,10 @@
 #define SMI_CMD_OP_45_READ_DATA_INC     ((3 << 10) | SMI_CMD_BUSY)
 #define SMI_DATA                0x01
 
+/* Fiber/SERDES Registers are located at SMI address F, page 1 */
+#define REG_FIBER_SERDES        0x0f
+#define PAGE_FIBER_SERDES       0x01
+
 #define REG_PORT(p)             (0x10 + (p))
 #define PORT_STATUS             0x00
 #define PORT_STATUS_PAUSE_EN    BIT(15)
@@ -45,6 +49,10 @@
 #define PORT_STATUS_MGMII       BIT(6) /* 6185 */
 #define PORT_STATUS_TX_PAUSED   BIT(5)
 #define PORT_STATUS_FLOW_CTRL   BIT(4)
+#define PORT_STATUS_CMODE_MASK  0x0f
+#define PORT_STATUS_CMODE_100BASE_X     0x8
+#define PORT_STATUS_CMODE_1000BASE_X    0x9
+#define PORT_STATUS_CMODE_SGMII         0xa
 #define PORT_PCS_CTRL           0x01
 #define PORT_PCS_CTRL_RGMII_DELAY_RXCLK BIT(15)
 #define PORT_PCS_CTRL_RGMII_DELAY_TXCLK BIT(14)
diff --git a/drivers/net/ethernet/atheros/atlx/atl2.c b/drivers/net/ethernet/atheros/atlx/atl2.c
index 8f76f4558a88..2ff465848b65 100644
--- a/drivers/net/ethernet/atheros/atlx/atl2.c
+++ b/drivers/net/ethernet/atheros/atlx/atl2.c
@@ -1412,7 +1412,7 @@ static int atl2_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
 
         err = -EIO;
 
-        netdev->hw_features = NETIF_F_SG | NETIF_F_HW_VLAN_CTAG_RX;
+        netdev->hw_features = NETIF_F_HW_VLAN_CTAG_RX;
         netdev->features |= (NETIF_F_HW_VLAN_CTAG_TX | NETIF_F_HW_VLAN_CTAG_RX);
 
         /* Init PHY as early as possible due to power saving issue  */
diff --git a/drivers/net/ethernet/broadcom/bgmac.c b/drivers/net/ethernet/broadcom/bgmac.c
index 99b30a952b38..38db2e4d7d54 100644
--- a/drivers/net/ethernet/broadcom/bgmac.c
+++ b/drivers/net/ethernet/broadcom/bgmac.c
@@ -1572,6 +1572,11 @@ static int bgmac_probe(struct bcma_device *core)
                 dev_warn(&core->dev, "Using random MAC: %pM\n", mac);
         }
 
+        /* This (reset &) enable is not preset in specs or reference driver but
+         * Broadcom does it in arch PCI code when enabling fake PCI device.
+         */
+        bcma_core_enable(core, 0);
+
         /* Allocation and references */
         net_dev = alloc_etherdev(sizeof(*bgmac));
         if (!net_dev)
diff --git a/drivers/net/ethernet/broadcom/bgmac.h b/drivers/net/ethernet/broadcom/bgmac.h
index 4fbb093e0d84..9a03c142b742 100644
--- a/drivers/net/ethernet/broadcom/bgmac.h
+++ b/drivers/net/ethernet/broadcom/bgmac.h
@@ -199,9 +199,9 @@
 #define  BGMAC_CMDCFG_TAI                       0x00000200
 #define  BGMAC_CMDCFG_HD                        0x00000400      /* Set if in half duplex mode */
 #define  BGMAC_CMDCFG_HD_SHIFT                  10
-#define  BGMAC_CMDCFG_SR_REV0                   0x00000800      /* Set to reset mode, for other revs */
-#define  BGMAC_CMDCFG_SR_REV4                   0x00002000      /* Set to reset mode, only for core rev 4 */
-#define  BGMAC_CMDCFG_SR(rev)  ((rev == 4) ? BGMAC_CMDCFG_SR_REV4 : BGMAC_CMDCFG_SR_REV0)
+#define  BGMAC_CMDCFG_SR_REV0                   0x00000800      /* Set to reset mode, for core rev 0-3 */
+#define  BGMAC_CMDCFG_SR_REV4                   0x00002000      /* Set to reset mode, for core rev >= 4 */
+#define  BGMAC_CMDCFG_SR(rev)  ((rev >= 4) ? BGMAC_CMDCFG_SR_REV4 : BGMAC_CMDCFG_SR_REV0)
 #define  BGMAC_CMDCFG_ML                        0x00008000      /* Set to activate mac loopback mode */
 #define  BGMAC_CMDCFG_AE                        0x00400000
 #define  BGMAC_CMDCFG_CFE                       0x00800000
diff --git a/drivers/net/ethernet/broadcom/bnxt/bnxt.c b/drivers/net/ethernet/broadcom/bnxt/bnxt.c
index aabbd51db981..72eb29ed0359 100644
--- a/drivers/net/ethernet/broadcom/bnxt/bnxt.c
+++ b/drivers/net/ethernet/broadcom/bnxt/bnxt.c
@@ -581,12 +581,30 @@ static inline int bnxt_alloc_rx_page(struct bnxt *bp,
         struct page *page;
         dma_addr_t mapping;
         u16 sw_prod = rxr->rx_sw_agg_prod;
+        unsigned int offset = 0;
 
-        page = alloc_page(gfp);
-        if (!page)
-                return -ENOMEM;
+        if (PAGE_SIZE > BNXT_RX_PAGE_SIZE) {
+                page = rxr->rx_page;
+                if (!page) {
+                        page = alloc_page(gfp);
+                        if (!page)
+                                return -ENOMEM;
+                        rxr->rx_page = page;
+                        rxr->rx_page_offset = 0;
+                }
+                offset = rxr->rx_page_offset;
+                rxr->rx_page_offset += BNXT_RX_PAGE_SIZE;
+                if (rxr->rx_page_offset == PAGE_SIZE)
+                        rxr->rx_page = NULL;
+                else
+                        get_page(page);
+        } else {
+                page = alloc_page(gfp);
+                if (!page)
+                        return -ENOMEM;
+        }
 
-        mapping = dma_map_page(&pdev->dev, page, 0, PAGE_SIZE,
+        mapping = dma_map_page(&pdev->dev, page, offset, BNXT_RX_PAGE_SIZE,
                                PCI_DMA_FROMDEVICE);
         if (dma_mapping_error(&pdev->dev, mapping)) {
                 __free_page(page);
@@ -601,6 +619,7 @@ static inline int bnxt_alloc_rx_page(struct bnxt *bp,
         rxr->rx_sw_agg_prod = NEXT_RX_AGG(sw_prod);
 
         rx_agg_buf->page = page;
+        rx_agg_buf->offset = offset;
         rx_agg_buf->mapping = mapping;
         rxbd->rx_bd_haddr = cpu_to_le64(mapping);
         rxbd->rx_bd_opaque = sw_prod;
@@ -642,6 +661,7 @@ static void bnxt_reuse_rx_agg_bufs(struct bnxt_napi *bnapi, u16 cp_cons,
                 page = cons_rx_buf->page;
                 cons_rx_buf->page = NULL;
                 prod_rx_buf->page = page;
+                prod_rx_buf->offset = cons_rx_buf->offset;
 
                 prod_rx_buf->mapping = cons_rx_buf->mapping;
 
@@ -709,7 +729,8 @@ static struct sk_buff *bnxt_rx_pages(struct bnxt *bp, struct bnxt_napi *bnapi,
                             RX_AGG_CMP_LEN) >> RX_AGG_CMP_LEN_SHIFT;
 
                 cons_rx_buf = &rxr->rx_agg_ring[cons];
-                skb_fill_page_desc(skb, i, cons_rx_buf->page, 0, frag_len);
+                skb_fill_page_desc(skb, i, cons_rx_buf->page,
+                                   cons_rx_buf->offset, frag_len);
                 __clear_bit(cons, rxr->rx_agg_bmap);
 
                 /* It is possible for bnxt_alloc_rx_page() to allocate
@@ -740,7 +761,7 @@ static struct sk_buff *bnxt_rx_pages(struct bnxt *bp, struct bnxt_napi *bnapi,
                         return NULL;
                 }
 
-                dma_unmap_page(&pdev->dev, mapping, PAGE_SIZE,
+                dma_unmap_page(&pdev->dev, mapping, BNXT_RX_PAGE_SIZE,
                                PCI_DMA_FROMDEVICE);
 
                 skb->data_len += frag_len;
@@ -1584,13 +1605,17 @@ static void bnxt_free_rx_skbs(struct bnxt *bp)
 
                         dma_unmap_page(&pdev->dev,
                                        dma_unmap_addr(rx_agg_buf, mapping),
-                                       PAGE_SIZE, PCI_DMA_FROMDEVICE);
+                                       BNXT_RX_PAGE_SIZE, PCI_DMA_FROMDEVICE);
 
                         rx_agg_buf->page = NULL;
                         __clear_bit(j, rxr->rx_agg_bmap);
 
                         __free_page(page);
                 }
+                if (rxr->rx_page) {
+                        __free_page(rxr->rx_page);
+                        rxr->rx_page = NULL;
+                }
         }
 }
 
@@ -1973,7 +1998,7 @@ static int bnxt_init_one_rx_ring(struct bnxt *bp, int ring_nr)
         if (!(bp->flags & BNXT_FLAG_AGG_RINGS))
                 return 0;
 
-        type = ((u32)PAGE_SIZE << RX_BD_LEN_SHIFT) |
+        type = ((u32)BNXT_RX_PAGE_SIZE << RX_BD_LEN_SHIFT) |
                 RX_BD_TYPE_RX_AGG_BD | RX_BD_FLAGS_SOP;
 
         bnxt_init_rxbd_pages(ring, type);
@@ -2164,7 +2189,7 @@ void bnxt_set_ring_params(struct bnxt *bp)
         bp->rx_agg_nr_pages = 0;
 
         if (bp->flags & BNXT_FLAG_TPA)
-                agg_factor = 4;
+                agg_factor = min_t(u32, 4, 65536 / BNXT_RX_PAGE_SIZE);
 
         bp->flags &= ~BNXT_FLAG_JUMBO;
         if (rx_space > PAGE_SIZE) {
@@ -2653,7 +2678,7 @@ static int bnxt_hwrm_do_send_msg(struct bnxt *bp, void *msg, u32 msg_len,
         /* Write request msg to hwrm channel */
         __iowrite32_copy(bp->bar0, data, msg_len / 4);
 
-        for (i = msg_len; i < HWRM_MAX_REQ_LEN; i += 4)
+        for (i = msg_len; i < BNXT_HWRM_MAX_REQ_LEN; i += 4)
                 writel(0, bp->bar0 + i);
 
         /* currently supports only one outstanding message */
@@ -3020,12 +3045,12 @@ static int bnxt_hwrm_vnic_set_tpa(struct bnxt *bp, u16 vnic_id, u32 tpa_flags)
                 /* Number of segs are log2 units, and first packet is not
                  * included as part of this units.
                  */
-                if (mss <= PAGE_SIZE) {
-                        n = PAGE_SIZE / mss;
+                if (mss <= BNXT_RX_PAGE_SIZE) {
+                        n = BNXT_RX_PAGE_SIZE / mss;
                         nsegs = (MAX_SKB_FRAGS - 1) * n;
                 } else {
-                        n = mss / PAGE_SIZE;
-                        if (mss & (PAGE_SIZE - 1))
+                        n = mss / BNXT_RX_PAGE_SIZE;
+                        if (mss & (BNXT_RX_PAGE_SIZE - 1))
                                 n++;
                         nsegs = (MAX_SKB_FRAGS - n) / n;
                 }
@@ -3391,11 +3416,11 @@ static int bnxt_hwrm_ring_alloc(struct bnxt *bp)
                 struct bnxt_cp_ring_info *cpr = &bnapi->cp_ring;
                 struct bnxt_ring_struct *ring = &cpr->cp_ring_struct;
 
+                cpr->cp_doorbell = bp->bar1 + i * 0x80;
                 rc = hwrm_ring_alloc_send_msg(bp, ring, HWRM_RING_ALLOC_CMPL, i,
                                               INVALID_STATS_CTX_ID);
                 if (rc)
                         goto err_out;
-                cpr->cp_doorbell = bp->bar1 + i * 0x80;
                 BNXT_CP_DB(cpr->cp_doorbell, cpr->cp_raw_cons);
                 bp->grp_info[i].cp_fw_ring_id = ring->fw_ring_id;
         }
@@ -3830,6 +3855,7 @@ static int bnxt_hwrm_ver_get(struct bnxt *bp)
         struct hwrm_ver_get_input req = {0};
         struct hwrm_ver_get_output *resp = bp->hwrm_cmd_resp_addr;
 
+        bp->hwrm_max_req_len = HWRM_MAX_REQ_LEN;
         bnxt_hwrm_cmd_hdr_init(bp, &req, HWRM_VER_GET, -1, -1);
         req.hwrm_intf_maj = HWRM_VERSION_MAJOR;
         req.hwrm_intf_min = HWRM_VERSION_MINOR;
@@ -3855,6 +3881,9 @@ static int bnxt_hwrm_ver_get(struct bnxt *bp)
         if (!bp->hwrm_cmd_timeout)
                 bp->hwrm_cmd_timeout = DFLT_HWRM_CMD_TIMEOUT;
 
+        if (resp->hwrm_intf_maj >= 1)
+                bp->hwrm_max_req_len = le16_to_cpu(resp->max_req_win_len);
+
 hwrm_ver_get_exit:
         mutex_unlock(&bp->hwrm_cmd_lock);
         return rc;
@@ -4305,7 +4334,7 @@ static int bnxt_setup_int_mode(struct bnxt *bp)
         if (bp->flags & BNXT_FLAG_MSIX_CAP)
                 rc = bnxt_setup_msix(bp);
 
-        if (!(bp->flags & BNXT_FLAG_USING_MSIX)) {
+        if (!(bp->flags & BNXT_FLAG_USING_MSIX) && BNXT_PF(bp)) {
                 /* fallback to INTA */
                 rc = bnxt_setup_inta(bp);
         }
@@ -4555,7 +4584,7 @@ bnxt_hwrm_set_pause_common(struct bnxt *bp, struct hwrm_port_phy_cfg_input *req)
                 if (bp->link_info.req_flow_ctrl & BNXT_LINK_PAUSE_RX)
                         req->auto_pause |= PORT_PHY_CFG_REQ_AUTO_PAUSE_RX;
                 if (bp->link_info.req_flow_ctrl & BNXT_LINK_PAUSE_TX)
-                        req->auto_pause |= PORT_PHY_CFG_REQ_AUTO_PAUSE_RX;
+                        req->auto_pause |= PORT_PHY_CFG_REQ_AUTO_PAUSE_TX;
                 req->enables |=
                         cpu_to_le32(PORT_PHY_CFG_REQ_ENABLES_AUTO_PAUSE);
         } else {
diff --git a/drivers/net/ethernet/broadcom/bnxt/bnxt.h b/drivers/net/ethernet/broadcom/bnxt/bnxt.h
index ec04c47172b7..8b823ff558ff 100644
--- a/drivers/net/ethernet/broadcom/bnxt/bnxt.h
+++ b/drivers/net/ethernet/broadcom/bnxt/bnxt.h
@@ -407,6 +407,15 @@ struct rx_tpa_end_cmp_ext {
 
 #define BNXT_PAGE_SIZE  (1 << BNXT_PAGE_SHIFT)
 
+/* The RXBD length is 16-bit so we can only support page sizes < 64K */
+#if (PAGE_SHIFT > 15)
+#define BNXT_RX_PAGE_SHIFT 15
+#else
+#define BNXT_RX_PAGE_SHIFT PAGE_SHIFT
+#endif
+
+#define BNXT_RX_PAGE_SIZE (1 << BNXT_RX_PAGE_SHIFT)
+
 #define BNXT_MIN_PKT_SIZE       45
 
 #define BNXT_NUM_TESTS(bp)      0
@@ -477,6 +486,7 @@ struct rx_tpa_end_cmp_ext {
 #define RING_CMP(idx)           ((idx) & bp->cp_ring_mask)
 #define NEXT_CMP(idx)           RING_CMP(ADV_RAW_CMP(idx, 1))
 
+#define BNXT_HWRM_MAX_REQ_LEN           (bp->hwrm_max_req_len)
 #define DFLT_HWRM_CMD_TIMEOUT           500
 #define HWRM_CMD_TIMEOUT                (bp->hwrm_cmd_timeout)
 #define HWRM_RESET_TIMEOUT              ((HWRM_CMD_TIMEOUT) * 4)
@@ -505,6 +515,7 @@ struct bnxt_sw_rx_bd {
 
 struct bnxt_sw_rx_agg_bd {
         struct page             *page;
+        unsigned int            offset;
         dma_addr_t              mapping;
 };
 
@@ -585,6 +596,9 @@ struct bnxt_rx_ring_info {
         unsigned long           *rx_agg_bmap;
         u16                     rx_agg_bmap_size;
 
+        struct page             *rx_page;
+        unsigned int            rx_page_offset;
+
         dma_addr_t              rx_desc_mapping[MAX_RX_PAGES];
         dma_addr_t              rx_agg_desc_mapping[MAX_RX_AGG_PAGES];
 
@@ -953,6 +967,7 @@ struct bnxt {
         dma_addr_t              hw_tx_port_stats_map;
         int                     hw_port_stats_size;
 
+        u16                     hwrm_max_req_len;
         int                     hwrm_cmd_timeout;
         struct mutex            hwrm_cmd_lock;  /* serialize hwrm messages */
         struct hwrm_ver_get_output      ver_resp;
diff --git a/drivers/net/ethernet/broadcom/bnxt/bnxt_ethtool.c b/drivers/net/ethernet/broadcom/bnxt/bnxt_ethtool.c
index 9ada1662b651..2e472f6dbf2d 100644
--- a/drivers/net/ethernet/broadcom/bnxt/bnxt_ethtool.c
+++ b/drivers/net/ethernet/broadcom/bnxt/bnxt_ethtool.c
@@ -855,10 +855,8 @@ static void bnxt_get_pauseparam(struct net_device *dev,
         if (BNXT_VF(bp))
                 return;
         epause->autoneg = !!(link_info->autoneg & BNXT_AUTONEG_FLOW_CTRL);
-        epause->rx_pause =
-                ((link_info->auto_pause_setting & BNXT_LINK_PAUSE_RX) != 0);
-        epause->tx_pause =
-                ((link_info->auto_pause_setting & BNXT_LINK_PAUSE_TX) != 0);
+        epause->rx_pause = !!(link_info->req_flow_ctrl & BNXT_LINK_PAUSE_RX);
+        epause->tx_pause = !!(link_info->req_flow_ctrl & BNXT_LINK_PAUSE_TX);
 }
 
 static int bnxt_set_pauseparam(struct net_device *dev,
diff --git a/drivers/net/ethernet/broadcom/genet/bcmgenet.c b/drivers/net/ethernet/broadcom/genet/bcmgenet.c
index 6746fd03cb3a..44ad1490b472 100644
--- a/drivers/net/ethernet/broadcom/genet/bcmgenet.c
+++ b/drivers/net/ethernet/broadcom/genet/bcmgenet.c
@@ -878,7 +878,11 @@ static void bcmgenet_get_ethtool_stats(struct net_device *dev,
                 else
                         p = (char *)priv;
                 p += s->stat_offset;
-                data[i] = *(u32 *)p;
+                if (sizeof(unsigned long) != sizeof(u32) &&
+                    s->stat_sizeof == sizeof(unsigned long))
+                        data[i] = *(unsigned long *)p;
+                else
+                        data[i] = *(u32 *)p;
         }
 }
 
@@ -1171,6 +1175,7 @@ static unsigned int __bcmgenet_tx_reclaim(struct net_device *dev,
         struct enet_cb *tx_cb_ptr;
         struct netdev_queue *txq;
         unsigned int pkts_compl = 0;
+        unsigned int bytes_compl = 0;
         unsigned int c_index;
         unsigned int txbds_ready;
         unsigned int txbds_processed = 0;
@@ -1193,16 +1198,13 @@ static unsigned int __bcmgenet_tx_reclaim(struct net_device *dev,
                 tx_cb_ptr = &priv->tx_cbs[ring->clean_ptr];
                 if (tx_cb_ptr->skb) {
                         pkts_compl++;
-                        dev->stats.tx_packets++;
-                        dev->stats.tx_bytes += tx_cb_ptr->skb->len;
+                        bytes_compl += GENET_CB(tx_cb_ptr->skb)->bytes_sent;
                         dma_unmap_single(&dev->dev,
                                          dma_unmap_addr(tx_cb_ptr, dma_addr),
                                          dma_unmap_len(tx_cb_ptr, dma_len),
                                          DMA_TO_DEVICE);
                         bcmgenet_free_cb(tx_cb_ptr);
                 } else if (dma_unmap_addr(tx_cb_ptr, dma_addr)) {
-                        dev->stats.tx_bytes +=
-                                dma_unmap_len(tx_cb_ptr, dma_len);
                         dma_unmap_page(&dev->dev,
                                        dma_unmap_addr(tx_cb_ptr, dma_addr),
                                        dma_unmap_len(tx_cb_ptr, dma_len),
@@ -1220,6 +1222,9 @@ static unsigned int __bcmgenet_tx_reclaim(struct net_device *dev,
         ring->free_bds += txbds_processed;
         ring->c_index = (ring->c_index + txbds_processed) & DMA_C_INDEX_MASK;
 
+        dev->stats.tx_packets += pkts_compl;
+        dev->stats.tx_bytes += bytes_compl;
+
         if (ring->free_bds > (MAX_SKB_FRAGS + 1)) {
                 txq = netdev_get_tx_queue(dev, ring->queue);
                 if (netif_tx_queue_stopped(txq))
@@ -1296,7 +1301,7 @@ static int bcmgenet_xmit_single(struct net_device *dev,
 
         tx_cb_ptr->skb = skb;
 
-        skb_len = skb_headlen(skb) < ETH_ZLEN ? ETH_ZLEN : skb_headlen(skb);
+        skb_len = skb_headlen(skb);
 
         mapping = dma_map_single(kdev, skb->data, skb_len, DMA_TO_DEVICE);
         ret = dma_mapping_error(kdev, mapping);
@@ -1464,6 +1469,11 @@ static netdev_tx_t bcmgenet_xmit(struct sk_buff *skb, struct net_device *dev)
                 goto out;
         }
 
+        /* Retain how many bytes will be sent on the wire, without TSB inserted
+         * by transmit checksum offload
+         */
+        GENET_CB(skb)->bytes_sent = skb->len;
+
         /* set the SKB transmit checksum */
         if (priv->desc_64b_en) {
                 skb = bcmgenet_put_tx_csum(dev, skb);
diff --git a/drivers/net/ethernet/broadcom/genet/bcmgenet.h b/drivers/net/ethernet/broadcom/genet/bcmgenet.h
index 967367557309..1e2dc34d331a 100644
--- a/drivers/net/ethernet/broadcom/genet/bcmgenet.h
+++ b/drivers/net/ethernet/broadcom/genet/bcmgenet.h
@@ -531,6 +531,12 @@ struct bcmgenet_hw_params {
         u32             flags;
 };
 
+struct bcmgenet_skb_cb {
+        unsigned int bytes_sent;        /* bytes on the wire (no TSB) */
+};
+
+#define GENET_CB(skb)   ((struct bcmgenet_skb_cb *)((skb)->cb))
+
 struct bcmgenet_tx_ring {
         spinlock_t      lock;           /* ring lock */
         struct napi_struct napi;        /* NAPI per tx queue */
diff --git a/drivers/net/ethernet/cadence/macb.c b/drivers/net/ethernet/cadence/macb.c
index 6619178ed77b..a63551d0a18a 100644
--- a/drivers/net/ethernet/cadence/macb.c
+++ b/drivers/net/ethernet/cadence/macb.c
@@ -441,7 +441,7 @@ static int macb_mii_init(struct macb *bp)
         snprintf(bp->mii_bus->id, MII_BUS_ID_SIZE, "%s-%x",
                 bp->pdev->name, bp->pdev->id);
         bp->mii_bus->priv = bp;
-        bp->mii_bus->parent = &bp->dev->dev;
+        bp->mii_bus->parent = &bp->pdev->dev;
         pdata = dev_get_platdata(&bp->pdev->dev);
 
         dev_set_drvdata(&bp->dev->dev, bp->mii_bus);
@@ -458,7 +458,8 @@ static int macb_mii_init(struct macb *bp)
                                 struct phy_device *phydev;
 
                                 phydev = mdiobus_scan(bp->mii_bus, i);
-                                if (IS_ERR(phydev)) {
+                                if (IS_ERR(phydev) &&
+                                    PTR_ERR(phydev) != -ENODEV) {
                                         err = PTR_ERR(phydev);
                                         break;
                                 }
@@ -917,7 +918,10 @@ static int macb_rx_frame(struct macb *bp, unsigned int first_frag,
                 unsigned int frag_len = bp->rx_buffer_size;
 
                 if (offset + frag_len > len) {
-                        BUG_ON(frag != last_frag);
+                        if (unlikely(frag != last_frag)) {
+                                dev_kfree_skb_any(skb);
+                                return -1;
+                        }
                         frag_len = len - offset;
                 }
                 skb_copy_to_linear_data_offset(skb, offset,
@@ -945,8 +949,23 @@ static int macb_rx_frame(struct macb *bp, unsigned int first_frag,
         return 0;
 }
 
+static inline void macb_init_rx_ring(struct macb *bp)
+{
+        dma_addr_t addr;
+        int i;
+
+        addr = bp->rx_buffers_dma;
+        for (i = 0; i < RX_RING_SIZE; i++) {
+                bp->rx_ring[i].addr = addr;
+                bp->rx_ring[i].ctrl = 0;
+                addr += bp->rx_buffer_size;
+        }
+        bp->rx_ring[RX_RING_SIZE - 1].addr |= MACB_BIT(RX_WRAP);
+}
+
 static int macb_rx(struct macb *bp, int budget)
 {
+        bool reset_rx_queue = false;
         int received = 0;
         unsigned int tail;
         int first_frag = -1;
@@ -972,10 +991,18 @@ static int macb_rx(struct macb *bp, int budget)
 
                 if (ctrl & MACB_BIT(RX_EOF)) {
                         int dropped;
-                        BUG_ON(first_frag == -1);
+
+                        if (unlikely(first_frag == -1)) {
+                                reset_rx_queue = true;
+                                continue;
+                        }
 
                         dropped = macb_rx_frame(bp, first_frag, tail);
                         first_frag = -1;
+                        if (unlikely(dropped < 0)) {
+                                reset_rx_queue = true;
+                                continue;
+                        }
                         if (!dropped) {
                                 received++;
                                 budget--;
@@ -983,6 +1010,26 @@ static int macb_rx(struct macb *bp, int budget)
                 }
         }
 
+        if (unlikely(reset_rx_queue)) {
+                unsigned long flags;
+                u32 ctrl;
+
+                netdev_err(bp->dev, "RX queue corruption: reset it\n");
+
+                spin_lock_irqsave(&bp->lock, flags);
+
+                ctrl = macb_readl(bp, NCR);
+                macb_writel(bp, NCR, ctrl & ~MACB_BIT(RE));
+
+                macb_init_rx_ring(bp);
+                macb_writel(bp, RBQP, bp->rx_ring_dma);
+
+                macb_writel(bp, NCR, ctrl | MACB_BIT(RE));
+
+                spin_unlock_irqrestore(&bp->lock, flags);
+                return received;
+        }
+
         if (first_frag != -1)
                 bp->rx_tail = first_frag;
         else
@@ -1100,7 +1147,7 @@ static irqreturn_t macb_interrupt(int irq, void *dev_id)
                         macb_writel(bp, NCR, ctrl | MACB_BIT(RE));
 
                         if (bp->caps & MACB_CAPS_ISR_CLEAR_ON_WRITE)
-                                macb_writel(bp, ISR, MACB_BIT(RXUBR));
+                                queue_writel(queue, ISR, MACB_BIT(RXUBR));
                 }
 
                 if (status & MACB_BIT(ISR_ROVR)) {
@@ -1523,15 +1570,8 @@ static void gem_init_rings(struct macb *bp)
 static void macb_init_rings(struct macb *bp)
 {
         int i;
-        dma_addr_t addr;
 
-        addr = bp->rx_buffers_dma;
-        for (i = 0; i < RX_RING_SIZE; i++) {
-                bp->rx_ring[i].addr = addr;
-                bp->rx_ring[i].ctrl = 0;
-                addr += bp->rx_buffer_size;
-        }
-        bp->rx_ring[RX_RING_SIZE - 1].addr |= MACB_BIT(RX_WRAP);
+        macb_init_rx_ring(bp);
 
         for (i = 0; i < TX_RING_SIZE; i++) {
                 bp->queues[0].tx_ring[i].addr = 0;
@@ -2957,9 +2997,10 @@ static int macb_probe(struct platform_device *pdev)
         phy_node =  of_get_next_available_child(np, NULL);
         if (phy_node) {
                 int gpio = of_get_named_gpio(phy_node, "reset-gpios", 0);
-                if (gpio_is_valid(gpio))
+                if (gpio_is_valid(gpio)) {
                         bp->reset_gpio = gpio_to_desc(gpio);
-                gpiod_direction_output(bp->reset_gpio, 1);
+                        gpiod_direction_output(bp->reset_gpio, 1);
+                }
         }
         of_node_put(phy_node);
 
@@ -2979,29 +3020,36 @@ static int macb_probe(struct platform_device *pdev)
         if (err)
                 goto err_out_free_netdev;
 
+        err = macb_mii_init(bp);
+        if (err)
+                goto err_out_free_netdev;
+
+        phydev = bp->phy_dev;
+
+        netif_carrier_off(dev);
+
         err = register_netdev(dev);
         if (err) {
                 dev_err(&pdev->dev, "Cannot register net device, aborting.\n");
-                goto err_out_unregister_netdev;
+                goto err_out_unregister_mdio;
         }
 
-        err = macb_mii_init(bp);
-        if (err)
-                goto err_out_unregister_netdev;
-
-        netif_carrier_off(dev);
+        phy_attached_info(phydev);
 
         netdev_info(dev, "Cadence %s rev 0x%08x at 0x%08lx irq %d (%pM)\n",
                     macb_is_gem(bp) ? "GEM" : "MACB", macb_readl(bp, MID),
                     dev->base_addr, dev->irq, dev->dev_addr);
 
-        phydev = bp->phy_dev;
-        phy_attached_info(phydev);
-
         return 0;
 
-err_out_unregister_netdev:
-        unregister_netdev(dev);
+err_out_unregister_mdio:
+        phy_disconnect(bp->phy_dev);
+        mdiobus_unregister(bp->mii_bus);
+        mdiobus_free(bp->mii_bus);
+
+        /* Shutdown the PHY if there is a GPIO reset */
+        if (bp->reset_gpio)
+                gpiod_set_value(bp->reset_gpio, 0);
 
 err_out_free_netdev:
         free_netdev(dev);
@@ -3029,7 +3077,8 @@ static int macb_remove(struct platform_device *pdev)
                 mdiobus_free(bp->mii_bus);
 
                 /* Shutdown the PHY if there is a GPIO reset */
-                gpiod_set_value(bp->reset_gpio, 0);
+                if (bp->reset_gpio)
+                        gpiod_set_value(bp->reset_gpio, 0);
 
                 unregister_netdev(dev);
                 clk_disable_unprepare(bp->tx_clk);
diff --git a/drivers/net/ethernet/cavium/thunder/thunder_bgx.c b/drivers/net/ethernet/cavium/thunder/thunder_bgx.c
index 967951582e03..d20539a6d162 100644
--- a/drivers/net/ethernet/cavium/thunder/thunder_bgx.c
+++ b/drivers/net/ethernet/cavium/thunder/thunder_bgx.c
@@ -1011,10 +1011,11 @@ static int bgx_init_of_phy(struct bgx *bgx)
                 }
 
                 lmac++;
-                if (lmac == MAX_LMAC_PER_BGX)
+                if (lmac == MAX_LMAC_PER_BGX) {
+                        of_node_put(node);
                         break;
+                }
         }
-        of_node_put(node);
         return 0;
 
 defer:
diff --git a/drivers/net/ethernet/chelsio/cxgb3/cxgb3_main.c b/drivers/net/ethernet/chelsio/cxgb3/cxgb3_main.c
index 60908eab3b3a..43da891fab97 100644
--- a/drivers/net/ethernet/chelsio/cxgb3/cxgb3_main.c
+++ b/drivers/net/ethernet/chelsio/cxgb3/cxgb3_main.c
@@ -576,7 +576,7 @@ static void setup_rss(struct adapter *adap)
         unsigned int nq0 = adap2pinfo(adap, 0)->nqsets;
         unsigned int nq1 = adap->port[1] ? adap2pinfo(adap, 1)->nqsets : 1;
         u8 cpus[SGE_QSETS + 1];
-        u16 rspq_map[RSS_TABLE_SIZE];
+        u16 rspq_map[RSS_TABLE_SIZE + 1];
 
         for (i = 0; i < SGE_QSETS; ++i)
                 cpus[i] = i;
@@ -586,6 +586,7 @@ static void setup_rss(struct adapter *adap)
                 rspq_map[i] = i % nq0;
                 rspq_map[i + RSS_TABLE_SIZE / 2] = (i % nq1) + nq0;
         }
+        rspq_map[RSS_TABLE_SIZE] = 0xffff; /* terminator */
 
         t3_config_rss(adap, F_RQFEEDBACKENABLE | F_TNLLKPEN | F_TNLMAPEN |
                       F_TNLPRTEN | F_TNL2TUPEN | F_TNL4TUPEN |
diff --git a/drivers/net/ethernet/chelsio/cxgb4/cxgb4.h b/drivers/net/ethernet/chelsio/cxgb4/cxgb4.h
index 984a3cc26f86..326d4009525e 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/cxgb4.h
+++ b/drivers/net/ethernet/chelsio/cxgb4/cxgb4.h
@@ -1451,6 +1451,9 @@ int t4_mdio_rd(struct adapter *adap, unsigned int mbox, unsigned int phy_addr,
                unsigned int mmd, unsigned int reg, u16 *valp);
 int t4_mdio_wr(struct adapter *adap, unsigned int mbox, unsigned int phy_addr,
                unsigned int mmd, unsigned int reg, u16 val);
+int t4_iq_stop(struct adapter *adap, unsigned int mbox, unsigned int pf,
+               unsigned int vf, unsigned int iqtype, unsigned int iqid,
+               unsigned int fl0id, unsigned int fl1id);
 int t4_iq_free(struct adapter *adap, unsigned int mbox, unsigned int pf,
                unsigned int vf, unsigned int iqtype, unsigned int iqid,
                unsigned int fl0id, unsigned int fl1id);
diff --git a/drivers/net/ethernet/chelsio/cxgb4/sge.c b/drivers/net/ethernet/chelsio/cxgb4/sge.c
index 13b144bcf725..6278e5a74b74 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/sge.c
+++ b/drivers/net/ethernet/chelsio/cxgb4/sge.c
@@ -2981,14 +2981,28 @@ void t4_free_ofld_rxqs(struct adapter *adap, int n, struct sge_ofld_rxq *q)
 void t4_free_sge_resources(struct adapter *adap)
 {
         int i;
-        struct sge_eth_rxq *eq = adap->sge.ethrxq;
-        struct sge_eth_txq *etq = adap->sge.ethtxq;
+        struct sge_eth_rxq *eq;
+        struct sge_eth_txq *etq;
+
+        /* stop all Rx queues in order to start them draining */
+        for (i = 0; i < adap->sge.ethqsets; i++) {
+                eq = &adap->sge.ethrxq[i];
+                if (eq->rspq.desc)
+                        t4_iq_stop(adap, adap->mbox, adap->pf, 0,
+                                   FW_IQ_TYPE_FL_INT_CAP,
+                                   eq->rspq.cntxt_id,
+                                   eq->fl.size ? eq->fl.cntxt_id : 0xffff,
+                                   0xffff);
+        }
 
         /* clean up Ethernet Tx/Rx queues */
-        for (i = 0; i < adap->sge.ethqsets; i++, eq++, etq++) {
+        for (i = 0; i < adap->sge.ethqsets; i++) {
+                eq = &adap->sge.ethrxq[i];
                 if (eq->rspq.desc)
                         free_rspq_fl(adap, &eq->rspq,
                                      eq->fl.size ? &eq->fl : NULL);
+
+                etq = &adap->sge.ethtxq[i];
                 if (etq->q.desc) {
                         t4_eth_eq_free(adap, adap->mbox, adap->pf, 0,
                                        etq->q.cntxt_id);
diff --git a/drivers/net/ethernet/chelsio/cxgb4/t4_hw.c b/drivers/net/ethernet/chelsio/cxgb4/t4_hw.c
index cc1736bece0f..71586a3e0f61 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/t4_hw.c
+++ b/drivers/net/ethernet/chelsio/cxgb4/t4_hw.c
@@ -2557,6 +2557,7 @@ void t4_get_regs(struct adapter *adap, void *buf, size_t buf_size)
 }
 
 #define EEPROM_STAT_ADDR   0x7bfc
+#define VPD_SIZE           0x800
 #define VPD_BASE           0x400
 #define VPD_BASE_OLD       0
 #define VPD_LEN            1024
@@ -2594,6 +2595,15 @@ int t4_get_raw_vpd_params(struct adapter *adapter, struct vpd_params *p)
         if (!vpd)
                 return -ENOMEM;
 
+        /* We have two VPD data structures stored in the adapter VPD area.
+         * By default, Linux calculates the size of the VPD area by traversing
+         * the first VPD area at offset 0x0, so we need to tell the OS what
+         * our real VPD size is.
+         */
+        ret = pci_set_vpd_size(adapter->pdev, VPD_SIZE);
+        if (ret < 0)
+                goto out;
+
         /* Card information normally starts at VPD_BASE but early cards had
          * it at 0.
          */
@@ -6940,6 +6950,39 @@ int t4_identify_port(struct adapter *adap, unsigned int mbox, unsigned int viid,
 }
 
 /**
+ *      t4_iq_stop - stop an ingress queue and its FLs
+ *      @adap: the adapter
+ *      @mbox: mailbox to use for the FW command
+ *      @pf: the PF owning the queues
+ *      @vf: the VF owning the queues
+ *      @iqtype: the ingress queue type (FW_IQ_TYPE_FL_INT_CAP, etc.)
+ *      @iqid: ingress queue id
+ *      @fl0id: FL0 queue id or 0xffff if no attached FL0
+ *      @fl1id: FL1 queue id or 0xffff if no attached FL1
+ *
+ *      Stops an ingress queue and its associated FLs, if any.  This causes
+ *      any current or future data/messages destined for these queues to be
+ *      tossed.
+ */
+int t4_iq_stop(struct adapter *adap, unsigned int mbox, unsigned int pf,
+               unsigned int vf, unsigned int iqtype, unsigned int iqid,
+               unsigned int fl0id, unsigned int fl1id)
+{
+        struct fw_iq_cmd c;
+
+        memset(&c, 0, sizeof(c));
+        c.op_to_vfn = cpu_to_be32(FW_CMD_OP_V(FW_IQ_CMD) | FW_CMD_REQUEST_F |
+                                  FW_CMD_EXEC_F | FW_IQ_CMD_PFN_V(pf) |
+                                  FW_IQ_CMD_VFN_V(vf));
+        c.alloc_to_len16 = cpu_to_be32(FW_IQ_CMD_IQSTOP_F | FW_LEN16(c));
+        c.type_to_iqandstindex = cpu_to_be32(FW_IQ_CMD_TYPE_V(iqtype));
+        c.iqid = cpu_to_be16(iqid);
+        c.fl0id = cpu_to_be16(fl0id);
+        c.fl1id = cpu_to_be16(fl1id);
+        return t4_wr_mbox(adap, mbox, &c, sizeof(c), NULL);
+}
+
+/**
  *      t4_iq_free - free an ingress queue and its FLs
  *      @adap: the adapter
  *      @mbox: mailbox to use for the FW command
diff --git a/drivers/net/ethernet/chelsio/cxgb4/t4_pci_id_tbl.h b/drivers/net/ethernet/chelsio/cxgb4/t4_pci_id_tbl.h
index 06bc2d2e7a73..a2cdfc1261dc 100644
--- a/drivers/net/ethernet/chelsio/cxgb4/t4_pci_id_tbl.h
+++ b/drivers/net/ethernet/chelsio/cxgb4/t4_pci_id_tbl.h
@@ -166,6 +166,7 @@ CH_PCI_DEVICE_ID_TABLE_DEFINE_BEGIN
         CH_PCI_ID_TABLE_FENTRY(0x5099), /* Custom 2x40G QSFP */
         CH_PCI_ID_TABLE_FENTRY(0x509a), /* Custom T520-CR */
         CH_PCI_ID_TABLE_FENTRY(0x509b), /* Custom T540-CR LOM */
+        CH_PCI_ID_TABLE_FENTRY(0x509c), /* Custom T520-CR*/
 
         /* T6 adapters:
          */
diff --git a/drivers/net/ethernet/freescale/fec_main.c b/drivers/net/ethernet/freescale/fec_main.c
index 37c081583084..08243c2ff4b4 100644
--- a/drivers/net/ethernet/freescale/fec_main.c
+++ b/drivers/net/ethernet/freescale/fec_main.c
@@ -943,8 +943,8 @@ fec_restart(struct net_device *ndev)
                 else
                         val &= ~FEC_RACC_OPTIONS;
                 writel(val, fep->hwp + FEC_RACC);
+                writel(PKT_MAXBUF_SIZE, fep->hwp + FEC_FTRL);
         }
-        writel(PKT_MAXBUF_SIZE, fep->hwp + FEC_FTRL);
 #endif
 
         /*
diff --git a/drivers/net/ethernet/hisilicon/hns/hnae.h b/drivers/net/ethernet/hisilicon/hns/hnae.h
index 37d0cce392be..e8d36aaea223 100644
--- a/drivers/net/ethernet/hisilicon/hns/hnae.h
+++ b/drivers/net/ethernet/hisilicon/hns/hnae.h
@@ -469,7 +469,7 @@ struct hnae_ae_ops {
                                    u32 *tx_usecs, u32 *rx_usecs);
         void (*get_rx_max_coalesced_frames)(struct hnae_handle *handle,
                                             u32 *tx_frames, u32 *rx_frames);
-        void (*set_coalesce_usecs)(struct hnae_handle *handle, u32 timeout);
+        int (*set_coalesce_usecs)(struct hnae_handle *handle, u32 timeout);
         int (*set_coalesce_frames)(struct hnae_handle *handle,
                                    u32 coalesce_frames);
         void (*set_promisc_mode)(struct hnae_handle *handle, u32 en);
diff --git a/drivers/net/ethernet/hisilicon/hns/hns_ae_adapt.c b/drivers/net/ethernet/hisilicon/hns/hns_ae_adapt.c
index 285c893ab135..a1cb461ac45f 100644
--- a/drivers/net/ethernet/hisilicon/hns/hns_ae_adapt.c
+++ b/drivers/net/ethernet/hisilicon/hns/hns_ae_adapt.c
@@ -159,11 +159,6 @@ struct hnae_handle *hns_ae_get_handle(struct hnae_ae_dev *dev,
                 ae_handle->qs[i]->tx_ring.q = ae_handle->qs[i];
 
                 ring_pair_cb->used_by_vf = 1;
-                if (port_idx < DSAF_SERVICE_PORT_NUM_PER_DSAF)
-                        ring_pair_cb->port_id_in_dsa = port_idx;
-                else
-                        ring_pair_cb->port_id_in_dsa = 0;
-
                 ring_pair_cb++;
         }
 
@@ -453,59 +448,46 @@ static int hns_ae_set_pauseparam(struct hnae_handle *handle,
 static void hns_ae_get_coalesce_usecs(struct hnae_handle *handle,
                                       u32 *tx_usecs, u32 *rx_usecs)
 {
-        int port;
-
-        port = hns_ae_map_eport_to_dport(handle->eport_id);
+        struct ring_pair_cb *ring_pair =
+                container_of(handle->qs[0], struct ring_pair_cb, q);
 
-        *tx_usecs = hns_rcb_get_coalesce_usecs(
-                hns_ae_get_dsaf_dev(handle->dev),
-                hns_dsaf_get_comm_idx_by_port(port));
-        *rx_usecs = hns_rcb_get_coalesce_usecs(
-                hns_ae_get_dsaf_dev(handle->dev),
-                hns_dsaf_get_comm_idx_by_port(port));
+        *tx_usecs = hns_rcb_get_coalesce_usecs(ring_pair->rcb_common,
+                                               ring_pair->port_id_in_comm);
+        *rx_usecs = hns_rcb_get_coalesce_usecs(ring_pair->rcb_common,
+                                               ring_pair->port_id_in_comm);
 }
 
 static void hns_ae_get_rx_max_coalesced_frames(struct hnae_handle *handle,
                                                u32 *tx_frames, u32 *rx_frames)
 {
-        int port;
+        struct ring_pair_cb *ring_pair =
+                container_of(handle->qs[0], struct ring_pair_cb, q);
 
-        assert(handle);
-
-        port = hns_ae_map_eport_to_dport(handle->eport_id);
-
-        *tx_frames = hns_rcb_get_coalesced_frames(
-                hns_ae_get_dsaf_dev(handle->dev), port);
-        *rx_frames = hns_rcb_get_coalesced_frames(
-                hns_ae_get_dsaf_dev(handle->dev), port);
+        *tx_frames = hns_rcb_get_coalesced_frames(ring_pair->rcb_common,
+                                                  ring_pair->port_id_in_comm);
+        *rx_frames = hns_rcb_get_coalesced_frames(ring_pair->rcb_common,
+                                                  ring_pair->port_id_in_comm);
 }
 
-static void hns_ae_set_coalesce_usecs(struct hnae_handle *handle,
-                                      u32 timeout)
+static int hns_ae_set_coalesce_usecs(struct hnae_handle *handle,
+                                     u32 timeout)
 {
-        int port;
+        struct ring_pair_cb *ring_pair =
+                container_of(handle->qs[0], struct ring_pair_cb, q);
 
-        assert(handle);
-
-        port = hns_ae_map_eport_to_dport(handle->eport_id);
-
-        hns_rcb_set_coalesce_usecs(hns_ae_get_dsaf_dev(handle->dev),
-                                   port, timeout);
+        return hns_rcb_set_coalesce_usecs(
+                ring_pair->rcb_common, ring_pair->port_id_in_comm, timeout);
 }
 
 static int  hns_ae_set_coalesce_frames(struct hnae_handle *handle,
                                        u32 coalesce_frames)
 {
-        int port;
-        int ret;
+        struct ring_pair_cb *ring_pair =
+                container_of(handle->qs[0], struct ring_pair_cb, q);
 
-        assert(handle);
-
-        port = hns_ae_map_eport_to_dport(handle->eport_id);
-
-        ret = hns_rcb_set_coalesced_frames(hns_ae_get_dsaf_dev(handle->dev),
-                                           port, coalesce_frames);
-        return ret;
+        return hns_rcb_set_coalesced_frames(
+                ring_pair->rcb_common,
+                ring_pair->port_id_in_comm, coalesce_frames);
 }
 
 void hns_ae_update_stats(struct hnae_handle *handle,
diff --git a/drivers/net/ethernet/hisilicon/hns/hns_dsaf_gmac.c b/drivers/net/ethernet/hisilicon/hns/hns_dsaf_gmac.c
index 6e2b76ede075..44abb08de155 100644
--- a/drivers/net/ethernet/hisilicon/hns/hns_dsaf_gmac.c
+++ b/drivers/net/ethernet/hisilicon/hns/hns_dsaf_gmac.c
@@ -664,7 +664,8 @@ static void hns_gmac_get_strings(u32 stringset, u8 *data)
                 return;
 
         for (i = 0; i < ARRAY_SIZE(g_gmac_stats_string); i++) {
-                snprintf(buff, ETH_GSTRING_LEN, g_gmac_stats_string[i].desc);
+                snprintf(buff, ETH_GSTRING_LEN, "%s",
+                         g_gmac_stats_string[i].desc);
                 buff = buff + ETH_GSTRING_LEN;
         }
 }
diff --git a/drivers/net/ethernet/hisilicon/hns/hns_dsaf_main.c b/drivers/net/ethernet/hisilicon/hns/hns_dsaf_main.c
index 5c1ac9ba1bf2..5978a5c8ef35 100644
--- a/drivers/net/ethernet/hisilicon/hns/hns_dsaf_main.c
+++ b/drivers/net/ethernet/hisilicon/hns/hns_dsaf_main.c
@@ -2219,17 +2219,17 @@ void hns_dsaf_get_regs(struct dsaf_device *ddev, u32 port, void *data)
         /* dsaf onode registers */
         for (i = 0; i < DSAF_XOD_NUM; i++) {
                 p[311 + i] = dsaf_read_dev(ddev,
-                                DSAF_XOD_ETS_TSA_TC0_TC3_CFG_0_REG + j * 0x90);
+                                DSAF_XOD_ETS_TSA_TC0_TC3_CFG_0_REG + i * 0x90);
                 p[319 + i] = dsaf_read_dev(ddev,
-                                DSAF_XOD_ETS_TSA_TC4_TC7_CFG_0_REG + j * 0x90);
+                                DSAF_XOD_ETS_TSA_TC4_TC7_CFG_0_REG + i * 0x90);
                 p[327 + i] = dsaf_read_dev(ddev,
-                                DSAF_XOD_ETS_BW_TC0_TC3_CFG_0_REG + j * 0x90);
+                                DSAF_XOD_ETS_BW_TC0_TC3_CFG_0_REG + i * 0x90);
                 p[335 + i] = dsaf_read_dev(ddev,
-                                DSAF_XOD_ETS_BW_TC4_TC7_CFG_0_REG + j * 0x90);
+                                DSAF_XOD_ETS_BW_TC4_TC7_CFG_0_REG + i * 0x90);
                 p[343 + i] = dsaf_read_dev(ddev,
-                                DSAF_XOD_ETS_BW_OFFSET_CFG_0_REG + j * 0x90);
+                                DSAF_XOD_ETS_BW_OFFSET_CFG_0_REG + i * 0x90);
                 p[351 + i] = dsaf_read_dev(ddev,
-                                DSAF_XOD_ETS_TOKEN_CFG_0_REG + j * 0x90);
+                                DSAF_XOD_ETS_TOKEN_CFG_0_REG + i * 0x90);
         }
 
         p[359] = dsaf_read_dev(ddev, DSAF_XOD_PFS_CFG_0_0_REG + port * 0x90);
diff --git a/drivers/net/ethernet/hisilicon/hns/hns_dsaf_misc.c b/drivers/net/ethernet/hisilicon/hns/hns_dsaf_misc.c
index 607c3be42241..e69b02287c44 100644
--- a/drivers/net/ethernet/hisilicon/hns/hns_dsaf_misc.c
+++ b/drivers/net/ethernet/hisilicon/hns/hns_dsaf_misc.c
@@ -244,31 +244,35 @@ void hns_ppe_com_srst(struct ppe_common_cb *ppe_common, u32 val)
  */
 phy_interface_t hns_mac_get_phy_if(struct hns_mac_cb *mac_cb)
 {
-        u32 hilink3_mode;
-        u32 hilink4_mode;
+        u32 mode;
+        u32 reg;
+        u32 shift;
+        bool is_ver1 = AE_IS_VER1(mac_cb->dsaf_dev->dsaf_ver);
         void __iomem *sys_ctl_vaddr = mac_cb->sys_ctl_vaddr;
-        int dev_id = mac_cb->mac_id;
+        int mac_id = mac_cb->mac_id;
         phy_interface_t phy_if = PHY_INTERFACE_MODE_NA;
 
-        hilink3_mode = dsaf_read_reg(sys_ctl_vaddr, HNS_MAC_HILINK3_REG);
-        hilink4_mode = dsaf_read_reg(sys_ctl_vaddr, HNS_MAC_HILINK4_REG);
-        if (dev_id >= 0 && dev_id <= 3) {
-                if (hilink4_mode == 0)
-                        phy_if = PHY_INTERFACE_MODE_SGMII;
-                else
+        if (is_ver1 && (mac_id >= 6 && mac_id <= 7)) {
+                phy_if = PHY_INTERFACE_MODE_SGMII;
+        } else if (mac_id >= 0 && mac_id <= 3) {
+                reg = is_ver1 ? HNS_MAC_HILINK4_REG : HNS_MAC_HILINK4V2_REG;
+                mode = dsaf_read_reg(sys_ctl_vaddr, reg);
+                /* mac_id 0, 1, 2, 3 ---> hilink4 lane 0, 1, 2, 3 */
+                shift = is_ver1 ? 0 : mac_id;
+                if (dsaf_get_bit(mode, shift))
                         phy_if = PHY_INTERFACE_MODE_XGMII;
-        } else if (dev_id >= 4 && dev_id <= 5) {
-                if (hilink3_mode == 0)
-                        phy_if = PHY_INTERFACE_MODE_SGMII;
                 else
+                        phy_if = PHY_INTERFACE_MODE_SGMII;
+        } else if (mac_id >= 4 && mac_id <= 7) {
+                reg = is_ver1 ? HNS_MAC_HILINK3_REG : HNS_MAC_HILINK3V2_REG;
+                mode = dsaf_read_reg(sys_ctl_vaddr, reg);
+                /* mac_id 4, 5, 6, 7 ---> hilink3 lane 2, 3, 0, 1 */
+                shift = is_ver1 ? 0 : mac_id <= 5 ? mac_id - 2 : mac_id - 6;
+                if (dsaf_get_bit(mode, shift))
                         phy_if = PHY_INTERFACE_MODE_XGMII;
-        } else {
-                phy_if = PHY_INTERFACE_MODE_SGMII;
+                else
+                        phy_if = PHY_INTERFACE_MODE_SGMII;
         }
-
-        dev_dbg(mac_cb->dev,
-                "hilink3_mode=%d, hilink4_mode=%d dev_id=%d, phy_if=%d\n",
-                hilink3_mode, hilink4_mode, dev_id, phy_if);
         return phy_if;
 }
 
diff --git a/drivers/net/ethernet/hisilicon/hns/hns_dsaf_rcb.c b/drivers/net/ethernet/hisilicon/hns/hns_dsaf_rcb.c
index 12188807468c..28ee26e5c478 100644
--- a/drivers/net/ethernet/hisilicon/hns/hns_dsaf_rcb.c
+++ b/drivers/net/ethernet/hisilicon/hns/hns_dsaf_rcb.c
@@ -215,9 +215,9 @@ static void hns_rcb_ring_init(struct ring_pair_cb *ring_pair, int ring_type)
                 dsaf_write_dev(q, RCB_RING_RX_RING_BD_LEN_REG,
                                bd_size_type);
                 dsaf_write_dev(q, RCB_RING_RX_RING_BD_NUM_REG,
-                               ring_pair->port_id_in_dsa);
+                               ring_pair->port_id_in_comm);
                 dsaf_write_dev(q, RCB_RING_RX_RING_PKTLINE_REG,
-                               ring_pair->port_id_in_dsa);
+                               ring_pair->port_id_in_comm);
         } else {
                 dsaf_write_dev(q, RCB_RING_TX_RING_BASEADDR_L_REG,
                                (u32)dma);
@@ -227,9 +227,9 @@ static void hns_rcb_ring_init(struct ring_pair_cb *ring_pair, int ring_type)
                 dsaf_write_dev(q, RCB_RING_TX_RING_BD_LEN_REG,
                                bd_size_type);
                 dsaf_write_dev(q, RCB_RING_TX_RING_BD_NUM_REG,
-                               ring_pair->port_id_in_dsa);
+                               ring_pair->port_id_in_comm);
                 dsaf_write_dev(q, RCB_RING_TX_RING_PKTLINE_REG,
-                               ring_pair->port_id_in_dsa);
+                               ring_pair->port_id_in_comm);
         }
 }
 
@@ -256,50 +256,16 @@ static void hns_rcb_set_port_desc_cnt(struct rcb_common_cb *rcb_common,
                        desc_cnt);
 }
 
-/**
- *hns_rcb_set_port_coalesced_frames - set rcb port coalesced frames
- *@rcb_common: rcb_common device
- *@port_idx:port index
- *@coalesced_frames:BD num for coalesced frames
- */
-static int  hns_rcb_set_port_coalesced_frames(struct rcb_common_cb *rcb_common,
-                                              u32 port_idx,
-                                              u32 coalesced_frames)
-{
-        if (coalesced_frames >= rcb_common->desc_num ||
-            coalesced_frames > HNS_RCB_MAX_COALESCED_FRAMES)
-                return -EINVAL;
-
-        dsaf_write_dev(rcb_common, RCB_CFG_PKTLINE_REG + port_idx * 4,
-                       coalesced_frames);
-        return 0;
-}
-
-/**
- *hns_rcb_get_port_coalesced_frames - set rcb port coalesced frames
- *@rcb_common: rcb_common device
- *@port_idx:port index
- * return coaleseced frames value
- */
-static u32 hns_rcb_get_port_coalesced_frames(struct rcb_common_cb *rcb_common,
-                                             u32 port_idx)
+static void hns_rcb_set_port_timeout(
+        struct rcb_common_cb *rcb_common, u32 port_idx, u32 timeout)
 {
-        if (port_idx >= HNS_RCB_SERVICE_NW_ENGINE_NUM)
-                port_idx = 0;
-
-        return dsaf_read_dev(rcb_common,
-                             RCB_CFG_PKTLINE_REG + port_idx * 4);
-}
-
-/**
- *hns_rcb_set_timeout - set rcb port coalesced time_out
- *@rcb_common: rcb_common device
- *@time_out:time for coalesced time_out
- */
-static void hns_rcb_set_timeout(struct rcb_common_cb *rcb_common,
-                                u32 timeout)
-{
-        dsaf_write_dev(rcb_common, RCB_CFG_OVERTIME_REG, timeout);
+        if (AE_IS_VER1(rcb_common->dsaf_dev->dsaf_ver))
+                dsaf_write_dev(rcb_common, RCB_CFG_OVERTIME_REG,
+                               timeout * HNS_RCB_CLK_FREQ_MHZ);
+        else
+                dsaf_write_dev(rcb_common,
+                               RCB_PORT_CFG_OVERTIME_REG + port_idx * 4,
+                               timeout);
 }
 
 static int hns_rcb_common_get_port_num(struct rcb_common_cb *rcb_common)
@@ -361,10 +327,11 @@ int hns_rcb_common_init_hw(struct rcb_common_cb *rcb_common)
 
         for (i = 0; i < port_num; i++) {
                 hns_rcb_set_port_desc_cnt(rcb_common, i, rcb_common->desc_num);
-                (void)hns_rcb_set_port_coalesced_frames(
-                        rcb_common, i, rcb_common->coalesced_frames);
+                (void)hns_rcb_set_coalesced_frames(
+                        rcb_common, i, HNS_RCB_DEF_COALESCED_FRAMES);
+                hns_rcb_set_port_timeout(
+                        rcb_common, i, HNS_RCB_DEF_COALESCED_USECS);
         }
-        hns_rcb_set_timeout(rcb_common, rcb_common->timeout);
 
         dsaf_write_dev(rcb_common, RCB_COM_CFG_ENDIAN_REG,
                        HNS_RCB_COMMON_ENDIAN);
@@ -460,7 +427,8 @@ static void hns_rcb_ring_pair_get_cfg(struct ring_pair_cb *ring_pair_cb)
         hns_rcb_ring_get_cfg(&ring_pair_cb->q, TX_RING);
 }
 
-static int hns_rcb_get_port(struct rcb_common_cb *rcb_common, int ring_idx)
+static int hns_rcb_get_port_in_comm(
+        struct rcb_common_cb *rcb_common, int ring_idx)
 {
         int comm_index = rcb_common->comm_index;
         int port;
@@ -470,7 +438,7 @@ static int hns_rcb_get_port(struct rcb_common_cb *rcb_common, int ring_idx)
                 q_num = (int)rcb_common->max_q_per_vf * rcb_common->max_vfn;
                 port = ring_idx / q_num;
         } else {
-                port = HNS_RCB_SERVICE_NW_ENGINE_NUM + comm_index - 1;
+                port = 0; /* config debug-ports port_id_in_comm to 0*/
         }
 
         return port;
@@ -518,7 +486,8 @@ void hns_rcb_get_cfg(struct rcb_common_cb *rcb_common)
                 ring_pair_cb->index = i;
                 ring_pair_cb->q.io_base =
                         RCB_COMM_BASE_TO_RING_BASE(rcb_common->io_base, i);
-                ring_pair_cb->port_id_in_dsa = hns_rcb_get_port(rcb_common, i);
+                ring_pair_cb->port_id_in_comm =
+                        hns_rcb_get_port_in_comm(rcb_common, i);
                 ring_pair_cb->virq[HNS_RCB_IRQ_IDX_TX] =
                 is_ver1 ? irq_of_parse_and_map(np, base_irq_idx + i * 2) :
                           platform_get_irq(pdev, base_irq_idx + i * 3 + 1);
@@ -534,82 +503,95 @@ void hns_rcb_get_cfg(struct rcb_common_cb *rcb_common)
 /**
  *hns_rcb_get_coalesced_frames - get rcb port coalesced frames
  *@rcb_common: rcb_common device
- *@comm_index:port index
- *return coalesced_frames
+ *@port_idx:port id in comm
+ *
+ *Returns: coalesced_frames
  */
-u32 hns_rcb_get_coalesced_frames(struct dsaf_device *dsaf_dev, int port)
+u32 hns_rcb_get_coalesced_frames(
+        struct rcb_common_cb *rcb_common, u32 port_idx)
 {
-        int comm_index =  hns_dsaf_get_comm_idx_by_port(port);
-        struct rcb_common_cb *rcb_comm = dsaf_dev->rcb_common[comm_index];
-
-        return hns_rcb_get_port_coalesced_frames(rcb_comm, port);
+        return dsaf_read_dev(rcb_common, RCB_CFG_PKTLINE_REG + port_idx * 4);
 }
 
 /**
  *hns_rcb_get_coalesce_usecs - get rcb port coalesced time_out
  *@rcb_common: rcb_common device
- *@comm_index:port index
- *return time_out
+ *@port_idx:port id in comm
+ *
+ *Returns: time_out
  */
-u32 hns_rcb_get_coalesce_usecs(struct dsaf_device *dsaf_dev, int comm_index)
+u32 hns_rcb_get_coalesce_usecs(
+        struct rcb_common_cb *rcb_common, u32 port_idx)
 {
-        struct rcb_common_cb *rcb_comm = dsaf_dev->rcb_common[comm_index];
-
-        return rcb_comm->timeout;
+        if (AE_IS_VER1(rcb_common->dsaf_dev->dsaf_ver))
+                return dsaf_read_dev(rcb_common, RCB_CFG_OVERTIME_REG) /
+                       HNS_RCB_CLK_FREQ_MHZ;
+        else
+                return dsaf_read_dev(rcb_common,
+                                     RCB_PORT_CFG_OVERTIME_REG + port_idx * 4);
 }
 
 /**
  *hns_rcb_set_coalesce_usecs - set rcb port coalesced time_out
  *@rcb_common: rcb_common device
- *@comm_index: comm :index
- *@etx_usecs:tx time for coalesced time_out
- *@rx_usecs:rx time for coalesced time_out
+ *@port_idx:port id in comm
+ *@timeout:tx/rx time for coalesced time_out
+ *
+ * Returns:
+ * Zero for success, or an error code in case of failure
  */
-void hns_rcb_set_coalesce_usecs(struct dsaf_device *dsaf_dev,
-                                int port, u32 timeout)
+int hns_rcb_set_coalesce_usecs(
+        struct rcb_common_cb *rcb_common, u32 port_idx, u32 timeout)
 {
-        int comm_index =  hns_dsaf_get_comm_idx_by_port(port);
-        struct rcb_common_cb *rcb_comm = dsaf_dev->rcb_common[comm_index];
+        u32 old_timeout = hns_rcb_get_coalesce_usecs(rcb_common, port_idx);
 
-        if (rcb_comm->timeout == timeout)
-                return;
+        if (timeout == old_timeout)
+                return 0;
 
-        if (comm_index == HNS_DSAF_COMM_SERVICE_NW_IDX) {
-                dev_err(dsaf_dev->dev,
-                        "error: not support coalesce_usecs setting!\n");
-                return;
+        if (AE_IS_VER1(rcb_common->dsaf_dev->dsaf_ver)) {
+                if (rcb_common->comm_index == HNS_DSAF_COMM_SERVICE_NW_IDX) {
+                        dev_err(rcb_common->dsaf_dev->dev,
+                                "error: not support coalesce_usecs setting!\n");
+                        return -EINVAL;
+                }
         }
-        rcb_comm->timeout = timeout;
-        hns_rcb_set_timeout(rcb_comm, rcb_comm->timeout);
+        if (timeout > HNS_RCB_MAX_COALESCED_USECS) {
+                dev_err(rcb_common->dsaf_dev->dev,
+                        "error: not support coalesce %dus!\n", timeout);
+                return -EINVAL;
+        }
+        hns_rcb_set_port_timeout(rcb_common, port_idx, timeout);
+        return 0;
 }
 
 /**
  *hns_rcb_set_coalesced_frames - set rcb coalesced frames
  *@rcb_common: rcb_common device
- *@tx_frames:tx BD num for coalesced frames
- *@rx_frames:rx BD num for coalesced frames
- *Return 0 on success, negative on failure
+ *@port_idx:port id in comm
+ *@coalesced_frames:tx/rx BD num for coalesced frames
+ *
+ * Returns:
+ * Zero for success, or an error code in case of failure
  */
-int hns_rcb_set_coalesced_frames(struct dsaf_device *dsaf_dev,
-                                 int port, u32 coalesced_frames)
+int hns_rcb_set_coalesced_frames(
+        struct rcb_common_cb *rcb_common, u32 port_idx, u32 coalesced_frames)
 {
-        int comm_index =  hns_dsaf_get_comm_idx_by_port(port);
-        struct rcb_common_cb *rcb_comm = dsaf_dev->rcb_common[comm_index];
-        u32 coalesced_reg_val;
-        int ret;
+        u32 old_waterline = hns_rcb_get_coalesced_frames(rcb_common, port_idx);
 
-        coalesced_reg_val = hns_rcb_get_port_coalesced_frames(rcb_comm, port);
-
-        if (coalesced_reg_val == coalesced_frames)
+        if (coalesced_frames == old_waterline)
                 return 0;
 
-        if (coalesced_frames >= HNS_RCB_MIN_COALESCED_FRAMES) {
-                ret = hns_rcb_set_port_coalesced_frames(rcb_comm, port,
-                                                        coalesced_frames);
-                return ret;
-        } else {
+        if (coalesced_frames >= rcb_common->desc_num ||
+            coalesced_frames > HNS_RCB_MAX_COALESCED_FRAMES ||
+            coalesced_frames < HNS_RCB_MIN_COALESCED_FRAMES) {
+                dev_err(rcb_common->dsaf_dev->dev,
+                        "error: not support coalesce_frames setting!\n");
                 return -EINVAL;
         }
+
+        dsaf_write_dev(rcb_common, RCB_CFG_PKTLINE_REG + port_idx * 4,
+                       coalesced_frames);
+        return 0;
 }
 
 /**
@@ -749,8 +731,6 @@ int hns_rcb_common_get_cfg(struct dsaf_device *dsaf_dev,
         rcb_common->dsaf_dev = dsaf_dev;
 
         rcb_common->desc_num = dsaf_dev->desc_num;
-        rcb_common->coalesced_frames = HNS_RCB_DEF_COALESCED_FRAMES;
-        rcb_common->timeout = HNS_RCB_MAX_TIME_OUT;
 
         hns_rcb_get_queue_mode(dsaf_mode, comm_index, &max_vfn, &max_q_per_vf);
         rcb_common->max_vfn = max_vfn;
@@ -951,6 +931,10 @@ void hns_rcb_get_strings(int stringset, u8 *data, int index)
 void hns_rcb_get_common_regs(struct rcb_common_cb *rcb_com, void *data)
 {
         u32 *regs = data;
+        bool is_ver1 = AE_IS_VER1(rcb_com->dsaf_dev->dsaf_ver);
+        bool is_dbg = (rcb_com->comm_index != HNS_DSAF_COMM_SERVICE_NW_IDX);
+        u32 reg_tmp;
+        u32 reg_num_tmp;
         u32 i = 0;
 
         /*rcb common registers */
@@ -1004,12 +988,16 @@ void hns_rcb_get_common_regs(struct rcb_common_cb *rcb_com, void *data)
                         = dsaf_read_dev(rcb_com, RCB_CFG_PKTLINE_REG + 4 * i);
         }
 
-        regs[70] = dsaf_read_dev(rcb_com, RCB_CFG_OVERTIME_REG);
-        regs[71] = dsaf_read_dev(rcb_com, RCB_CFG_PKTLINE_INT_NUM_REG);
-        regs[72] = dsaf_read_dev(rcb_com, RCB_CFG_OVERTIME_INT_NUM_REG);
+        reg_tmp = is_ver1 ? RCB_CFG_OVERTIME_REG : RCB_PORT_CFG_OVERTIME_REG;
+        reg_num_tmp = (is_ver1 || is_dbg) ? 1 : 6;
+        for (i = 0; i < reg_num_tmp; i++)
+                regs[70 + i] = dsaf_read_dev(rcb_com, reg_tmp);
+
+        regs[76] = dsaf_read_dev(rcb_com, RCB_CFG_PKTLINE_INT_NUM_REG);
+        regs[77] = dsaf_read_dev(rcb_com, RCB_CFG_OVERTIME_INT_NUM_REG);
 
         /* mark end of rcb common regs */
-        for (i = 73; i < 80; i++)
+        for (i = 78; i < 80; i++)
                 regs[i] = 0xcccccccc;
 }
 
diff --git a/drivers/net/ethernet/hisilicon/hns/hns_dsaf_rcb.h b/drivers/net/ethernet/hisilicon/hns/hns_dsaf_rcb.h
index 81fe9f849973..eb61014ad615 100644
--- a/drivers/net/ethernet/hisilicon/hns/hns_dsaf_rcb.h
+++ b/drivers/net/ethernet/hisilicon/hns/hns_dsaf_rcb.h
@@ -38,7 +38,9 @@ struct rcb_common_cb;
 #define HNS_RCB_MAX_COALESCED_FRAMES            1023
 #define HNS_RCB_MIN_COALESCED_FRAMES            1
 #define HNS_RCB_DEF_COALESCED_FRAMES            50
-#define HNS_RCB_MAX_TIME_OUT                    0x500
+#define HNS_RCB_CLK_FREQ_MHZ                    350
+#define HNS_RCB_MAX_COALESCED_USECS             0x3ff
+#define HNS_RCB_DEF_COALESCED_USECS             3
 
 #define HNS_RCB_COMMON_ENDIAN                   1
 
@@ -82,7 +84,7 @@ struct ring_pair_cb {
 
         int virq[HNS_RCB_IRQ_NUM_PER_QUEUE];
 
-        u8 port_id_in_dsa;
+        u8 port_id_in_comm;
         u8 used_by_vf;
 
         struct hns_ring_hw_stats hw_stats;
@@ -97,8 +99,6 @@ struct rcb_common_cb {
 
         u8 comm_index;
         u32 ring_num;
-        u32 coalesced_frames; /* frames  threshold of  rx interrupt   */
-        u32 timeout; /* time threshold of  rx interrupt  */
         u32 desc_num; /*  desc num per queue*/
 
         struct ring_pair_cb ring_pair_cb[0];
@@ -125,13 +125,14 @@ void hns_rcbv2_int_clr_hw(struct hnae_queue *q, u32 flag);
 void hns_rcb_init_hw(struct ring_pair_cb *ring);
 void hns_rcb_reset_ring_hw(struct hnae_queue *q);
 void hns_rcb_wait_fbd_clean(struct hnae_queue **qs, int q_num, u32 flag);
-
-u32 hns_rcb_get_coalesced_frames(struct dsaf_device *dsaf_dev, int comm_index);
-u32 hns_rcb_get_coalesce_usecs(struct dsaf_device *dsaf_dev, int comm_index);
-void hns_rcb_set_coalesce_usecs(struct dsaf_device *dsaf_dev,
-                                int comm_index, u32 timeout);
-int hns_rcb_set_coalesced_frames(struct dsaf_device *dsaf_dev,
-                                 int comm_index, u32 coalesce_frames);
+u32 hns_rcb_get_coalesced_frames(
+        struct rcb_common_cb *rcb_common, u32 port_idx);
+u32 hns_rcb_get_coalesce_usecs(
+        struct rcb_common_cb *rcb_common, u32 port_idx);
+int hns_rcb_set_coalesce_usecs(
+        struct rcb_common_cb *rcb_common, u32 port_idx, u32 timeout);
+int hns_rcb_set_coalesced_frames(
+        struct rcb_common_cb *rcb_common, u32 port_idx, u32 coalesced_frames);
 void hns_rcb_update_stats(struct hnae_queue *queue);
 
 void hns_rcb_get_stats(struct hnae_queue *queue, u64 *data);
diff --git a/drivers/net/ethernet/hisilicon/hns/hns_dsaf_reg.h b/drivers/net/ethernet/hisilicon/hns/hns_dsaf_reg.h
index bf62687e5ea7..7d7204f45e78 100644
--- a/drivers/net/ethernet/hisilicon/hns/hns_dsaf_reg.h
+++ b/drivers/net/ethernet/hisilicon/hns/hns_dsaf_reg.h
@@ -103,6 +103,8 @@
 /*serdes offset**/
 #define HNS_MAC_HILINK3_REG DSAF_SUB_SC_HILINK3_CRG_CTRL0_REG
 #define HNS_MAC_HILINK4_REG DSAF_SUB_SC_HILINK4_CRG_CTRL0_REG
+#define HNS_MAC_HILINK3V2_REG DSAF_SUB_SC_HILINK3_CRG_CTRL1_REG
+#define HNS_MAC_HILINK4V2_REG DSAF_SUB_SC_HILINK4_CRG_CTRL1_REG
 #define HNS_MAC_LANE0_CTLEDFE_REG 0x000BFFCCULL
 #define HNS_MAC_LANE1_CTLEDFE_REG 0x000BFFBCULL
 #define HNS_MAC_LANE2_CTLEDFE_REG 0x000BFFACULL
@@ -404,6 +406,7 @@
 #define RCB_CFG_OVERTIME_REG                    0x9300
 #define RCB_CFG_PKTLINE_INT_NUM_REG             0x9304
 #define RCB_CFG_OVERTIME_INT_NUM_REG            0x9308
+#define RCB_PORT_CFG_OVERTIME_REG               0x9430
 
 #define RCB_RING_RX_RING_BASEADDR_L_REG         0x00000
 #define RCB_RING_RX_RING_BASEADDR_H_REG         0x00004
diff --git a/drivers/net/ethernet/hisilicon/hns/hns_enet.c b/drivers/net/ethernet/hisilicon/hns/hns_enet.c
index 71aa37b4b338..687204b780b0 100644
--- a/drivers/net/ethernet/hisilicon/hns/hns_enet.c
+++ b/drivers/net/ethernet/hisilicon/hns/hns_enet.c
@@ -913,10 +913,7 @@ static int hns_nic_tx_poll_one(struct hns_nic_ring_data *ring_data,
 static void hns_nic_tx_fini_pro(struct hns_nic_ring_data *ring_data)
 {
         struct hnae_ring *ring = ring_data->ring;
-        int head = ring->next_to_clean;
-
-        /* for hardware bug fixed */
-        head = readl_relaxed(ring->io_base + RCB_REG_HEAD);
+        int head = readl_relaxed(ring->io_base + RCB_REG_HEAD);
 
         if (head != ring->next_to_clean) {
                 ring_data->ring->q->handle->dev->ops->toggle_ring_irq(
@@ -959,8 +956,8 @@ static int hns_nic_common_poll(struct napi_struct *napi, int budget)
                 napi_complete(napi);
                 ring_data->ring->q->handle->dev->ops->toggle_ring_irq(
                         ring_data->ring, 0);
-
-                ring_data->fini_process(ring_data);
+                if (ring_data->fini_process)
+                        ring_data->fini_process(ring_data);
                 return 0;
         }
 
@@ -1723,6 +1720,7 @@ static int hns_nic_init_ring_data(struct hns_nic_priv *priv)
 {
         struct hnae_handle *h = priv->ae_handle;
         struct hns_nic_ring_data *rd;
+        bool is_ver1 = AE_IS_VER1(priv->enet_ver);
         int i;
 
         if (h->q_num > NIC_MAX_Q_PER_VF) {
@@ -1740,7 +1738,7 @@ static int hns_nic_init_ring_data(struct hns_nic_priv *priv)
                 rd->queue_index = i;
                 rd->ring = &h->qs[i]->tx_ring;
                 rd->poll_one = hns_nic_tx_poll_one;
-                rd->fini_process = hns_nic_tx_fini_pro;
+                rd->fini_process = is_ver1 ? hns_nic_tx_fini_pro : NULL;
 
                 netif_napi_add(priv->netdev, &rd->napi,
                                hns_nic_common_poll, NIC_TX_CLEAN_MAX_NUM);
@@ -1752,7 +1750,7 @@ static int hns_nic_init_ring_data(struct hns_nic_priv *priv)
                 rd->ring = &h->qs[i - h->q_num]->rx_ring;
                 rd->poll_one = hns_nic_rx_poll_one;
                 rd->ex_process = hns_nic_rx_up_pro;
-                rd->fini_process = hns_nic_rx_fini_pro;
+                rd->fini_process = is_ver1 ? hns_nic_rx_fini_pro : NULL;
 
                 netif_napi_add(priv->netdev, &rd->napi,
                                hns_nic_common_poll, NIC_RX_CLEAN_MAX_NUM);
@@ -1816,7 +1814,7 @@ static int hns_nic_try_get_ae(struct net_device *ndev)
         h = hnae_get_handle(&priv->netdev->dev,
                             priv->ae_node, priv->port_id, NULL);
         if (IS_ERR_OR_NULL(h)) {
-                ret = PTR_ERR(h);
+                ret = -ENODEV;
                 dev_dbg(priv->dev, "has not handle, register notifier!\n");
                 goto out;
         }
diff --git a/drivers/net/ethernet/hisilicon/hns/hns_ethtool.c b/drivers/net/ethernet/hisilicon/hns/hns_ethtool.c
index 9c3ba65988e1..3d746c887873 100644
--- a/drivers/net/ethernet/hisilicon/hns/hns_ethtool.c
+++ b/drivers/net/ethernet/hisilicon/hns/hns_ethtool.c
@@ -794,8 +794,10 @@ static int hns_set_coalesce(struct net_device *net_dev,
             (!ops->set_coalesce_frames))
                 return -ESRCH;
 
-        ops->set_coalesce_usecs(priv->ae_handle,
-                                        ec->rx_coalesce_usecs);
+        ret = ops->set_coalesce_usecs(priv->ae_handle,
+                                      ec->rx_coalesce_usecs);
+        if (ret)
+                return ret;
 
         ret = ops->set_coalesce_frames(
                 priv->ae_handle,
@@ -1013,8 +1015,8 @@ int hns_phy_led_set(struct net_device *netdev, int value)
         struct phy_device *phy_dev = priv->phy;
 
         retval = phy_write(phy_dev, HNS_PHY_PAGE_REG, HNS_PHY_PAGE_LED);
-        retval = phy_write(phy_dev, HNS_LED_FC_REG, value);
-        retval = phy_write(phy_dev, HNS_PHY_PAGE_REG, HNS_PHY_PAGE_COPPER);
+        retval |= phy_write(phy_dev, HNS_LED_FC_REG, value);
+        retval |= phy_write(phy_dev, HNS_PHY_PAGE_REG, HNS_PHY_PAGE_COPPER);
         if (retval) {
                 netdev_err(netdev, "mdiobus_write fail !\n");
                 return retval;
diff --git a/drivers/net/ethernet/intel/e1000/e1000_main.c b/drivers/net/ethernet/intel/e1000/e1000_main.c
index 3fc7bde699ba..ae90d4f12b70 100644
--- a/drivers/net/ethernet/intel/e1000/e1000_main.c
+++ b/drivers/net/ethernet/intel/e1000/e1000_main.c
@@ -3106,7 +3106,7 @@ static int e1000_maybe_stop_tx(struct net_device *netdev,
         return __e1000_maybe_stop_tx(netdev, size);
 }
 
-#define TXD_USE_COUNT(S, X) (((S) >> (X)) + 1)
+#define TXD_USE_COUNT(S, X) (((S) + ((1 << (X)) - 1)) >> (X))
 static netdev_tx_t e1000_xmit_frame(struct sk_buff *skb,
                                     struct net_device *netdev)
 {
@@ -3256,12 +3256,29 @@ static netdev_tx_t e1000_xmit_frame(struct sk_buff *skb,
                              nr_frags, mss);
 
         if (count) {
+                /* The descriptors needed is higher than other Intel drivers
+                 * due to a number of workarounds.  The breakdown is below:
+                 * Data descriptors: MAX_SKB_FRAGS + 1
+                 * Context Descriptor: 1
+                 * Keep head from touching tail: 2
+                 * Workarounds: 3
+                 */
+                int desc_needed = MAX_SKB_FRAGS + 7;
+
                 netdev_sent_queue(netdev, skb->len);
                 skb_tx_timestamp(skb);
 
                 e1000_tx_queue(adapter, tx_ring, tx_flags, count);
+
+                /* 82544 potentially requires twice as many data descriptors
+                 * in order to guarantee buffers don't end on evenly-aligned
+                 * dwords
+                 */
+                if (adapter->pcix_82544)
+                        desc_needed += MAX_SKB_FRAGS + 1;
+
                 /* Make sure there is space in the ring for the next send. */
-                e1000_maybe_stop_tx(netdev, tx_ring, MAX_SKB_FRAGS + 2);
+                e1000_maybe_stop_tx(netdev, tx_ring, desc_needed);
 
                 if (!skb->xmit_more ||
                     netif_xmit_stopped(netdev_get_tx_queue(netdev, 0))) {
diff --git a/drivers/net/ethernet/intel/fm10k/fm10k_pf.c b/drivers/net/ethernet/intel/fm10k/fm10k_pf.c
index 62ccebc5f728..8cf943db5662 100644
--- a/drivers/net/ethernet/intel/fm10k/fm10k_pf.c
+++ b/drivers/net/ethernet/intel/fm10k/fm10k_pf.c
@@ -1223,18 +1223,32 @@ s32 fm10k_iov_msg_mac_vlan_pf(struct fm10k_hw *hw, u32 **results,
                 if (err)
                         return err;
 
-                /* verify upper 16 bits are zero */
-                if (vid >> 16)
-                        return FM10K_ERR_PARAM;
-
                 set = !(vid & FM10K_VLAN_CLEAR);
                 vid &= ~FM10K_VLAN_CLEAR;
 
-                err = fm10k_iov_select_vid(vf_info, (u16)vid);
-                if (err < 0)
-                        return err;
+                /* if the length field has been set, this is a multi-bit
+                 * update request. For multi-bit requests, simply disallow
+                 * them when the pf_vid has been set. In this case, the PF
+                 * should have already cleared the VLAN_TABLE, and if we
+                 * allowed them, it could allow a rogue VF to receive traffic
+                 * on a VLAN it was not assigned. In the single-bit case, we
+                 * need to modify requests for VLAN 0 to use the default PF or
+                 * SW vid when assigned.
+                 */
 
-                vid = err;
+                if (vid >> 16) {
+                        /* prevent multi-bit requests when PF has
+                         * administratively set the VLAN for this VF
+                         */
+                        if (vf_info->pf_vid)
+                                return FM10K_ERR_PARAM;
+                } else {
+                        err = fm10k_iov_select_vid(vf_info, (u16)vid);
+                        if (err < 0)
+                                return err;
+
+                        vid = err;
+                }
 
                 /* update VSI info for VF in regards to VLAN table */
                 err = hw->mac.ops.update_vlan(hw, vid, vf_info->vsi, set);
diff --git a/drivers/net/ethernet/intel/i40e/i40e_main.c b/drivers/net/ethernet/intel/i40e/i40e_main.c
index 67006431726a..344912957cab 100644
--- a/drivers/net/ethernet/intel/i40e/i40e_main.c
+++ b/drivers/net/ethernet/intel/i40e/i40e_main.c
@@ -8559,6 +8559,7 @@ static int i40e_sw_init(struct i40e_pf *pf)
                              I40E_FLAG_OUTER_UDP_CSUM_CAPABLE |
                              I40E_FLAG_WB_ON_ITR_CAPABLE |
                              I40E_FLAG_MULTIPLE_TCP_UDP_RSS_PCTYPE |
+                             I40E_FLAG_NO_PCI_LINK_CHECK |
                              I40E_FLAG_100M_SGMII_CAPABLE |
                              I40E_FLAG_USE_SET_LLDP_MIB |
                              I40E_FLAG_GENEVE_OFFLOAD_CAPABLE;
diff --git a/drivers/net/ethernet/intel/i40e/i40e_txrx.c b/drivers/net/ethernet/intel/i40e/i40e_txrx.c
index 084d0ab316b7..6a49b7ae511c 100644
--- a/drivers/net/ethernet/intel/i40e/i40e_txrx.c
+++ b/drivers/net/ethernet/intel/i40e/i40e_txrx.c
@@ -2594,35 +2594,34 @@ int __i40e_maybe_stop_tx(struct i40e_ring *tx_ring, int size)
 }
 
 /**
- * __i40e_chk_linearize - Check if there are more than 8 fragments per packet
+ * __i40e_chk_linearize - Check if there are more than 8 buffers per packet
  * @skb:      send buffer
  *
- * Note: Our HW can't scatter-gather more than 8 fragments to build
- * a packet on the wire and so we need to figure out the cases where we
- * need to linearize the skb.
+ * Note: Our HW can't DMA more than 8 buffers to build a packet on the wire
+ * and so we need to figure out the cases where we need to linearize the skb.
+ *
+ * For TSO we need to count the TSO header and segment payload separately.
+ * As such we need to check cases where we have 7 fragments or more as we
+ * can potentially require 9 DMA transactions, 1 for the TSO header, 1 for
+ * the segment payload in the first descriptor, and another 7 for the
+ * fragments.
  **/
 bool __i40e_chk_linearize(struct sk_buff *skb)
 {
         const struct skb_frag_struct *frag, *stale;
-        int gso_size, nr_frags, sum;
-
-        /* check to see if TSO is enabled, if so we may get a repreive */
-        gso_size = skb_shinfo(skb)->gso_size;
-        if (unlikely(!gso_size))
-                return true;
+        int nr_frags, sum;
 
-        /* no need to check if number of frags is less than 8 */
+        /* no need to check if number of frags is less than 7 */
         nr_frags = skb_shinfo(skb)->nr_frags;
-        if (nr_frags < I40E_MAX_BUFFER_TXD)
+        if (nr_frags < (I40E_MAX_BUFFER_TXD - 1))
                 return false;
 
         /* We need to walk through the list and validate that each group
          * of 6 fragments totals at least gso_size.  However we don't need
-         * to perform such validation on the first or last 6 since the first
-         * 6 cannot inherit any data from a descriptor before them, and the
-         * last 6 cannot inherit any data from a descriptor after them.
+         * to perform such validation on the last 6 since the last 6 cannot
+         * inherit any data from a descriptor after them.
          */
-        nr_frags -= I40E_MAX_BUFFER_TXD - 1;
+        nr_frags -= I40E_MAX_BUFFER_TXD - 2;
         frag = &skb_shinfo(skb)->frags[0];
 
         /* Initialize size to the negative value of gso_size minus 1.  We
@@ -2631,21 +2630,21 @@ bool __i40e_chk_linearize(struct sk_buff *skb)
          * descriptors for a single transmit as the header and previous
          * fragment are already consuming 2 descriptors.
          */
-        sum = 1 - gso_size;
+        sum = 1 - skb_shinfo(skb)->gso_size;
 
-        /* Add size of frags 1 through 5 to create our initial sum */
-        sum += skb_frag_size(++frag);
-        sum += skb_frag_size(++frag);
-        sum += skb_frag_size(++frag);
-        sum += skb_frag_size(++frag);
-        sum += skb_frag_size(++frag);
+        /* Add size of frags 0 through 4 to create our initial sum */
+        sum += skb_frag_size(frag++);
+        sum += skb_frag_size(frag++);
+        sum += skb_frag_size(frag++);
+        sum += skb_frag_size(frag++);
+        sum += skb_frag_size(frag++);
 
         /* Walk through fragments adding latest fragment, testing it, and
          * then removing stale fragments from the sum.
          */
         stale = &skb_shinfo(skb)->frags[0];
         for (;;) {
-                sum += skb_frag_size(++frag);
+                sum += skb_frag_size(frag++);
 
                 /* if sum is negative we failed to make sufficient progress */
                 if (sum < 0)
@@ -2655,7 +2654,7 @@ bool __i40e_chk_linearize(struct sk_buff *skb)
                 if (!--nr_frags)
                         break;
 
-                sum -= skb_frag_size(++stale);
+                sum -= skb_frag_size(stale++);
         }
 
         return false;
diff --git a/drivers/net/ethernet/intel/i40e/i40e_txrx.h b/drivers/net/ethernet/intel/i40e/i40e_txrx.h
index cdd5dc00aec5..a9bd70537d65 100644
--- a/drivers/net/ethernet/intel/i40e/i40e_txrx.h
+++ b/drivers/net/ethernet/intel/i40e/i40e_txrx.h
@@ -413,10 +413,14 @@ static inline int i40e_maybe_stop_tx(struct i40e_ring *tx_ring, int size)
  **/
 static inline bool i40e_chk_linearize(struct sk_buff *skb, int count)
 {
-        /* we can only support up to 8 data buffers for a single send */
-        if (likely(count <= I40E_MAX_BUFFER_TXD))
+        /* Both TSO and single send will work if count is less than 8 */
+        if (likely(count < I40E_MAX_BUFFER_TXD))
                 return false;
 
-        return __i40e_chk_linearize(skb);
+        if (skb_is_gso(skb))
+                return __i40e_chk_linearize(skb);
+
+        /* we can support up to 8 data buffers for a single send */
+        return count != I40E_MAX_BUFFER_TXD;
 }
 #endif /* _I40E_TXRX_H_ */
diff --git a/drivers/net/ethernet/intel/i40evf/i40e_txrx.c b/drivers/net/ethernet/intel/i40evf/i40e_txrx.c
index ebcc25c05796..cea97daa844c 100644
--- a/drivers/net/ethernet/intel/i40evf/i40e_txrx.c
+++ b/drivers/net/ethernet/intel/i40evf/i40e_txrx.c
@@ -1796,35 +1796,34 @@ static void i40e_create_tx_ctx(struct i40e_ring *tx_ring,
 }
 
 /**
- * __i40evf_chk_linearize - Check if there are more than 8 fragments per packet
+ * __i40evf_chk_linearize - Check if there are more than 8 buffers per packet
  * @skb:      send buffer
  *
- * Note: Our HW can't scatter-gather more than 8 fragments to build
- * a packet on the wire and so we need to figure out the cases where we
- * need to linearize the skb.
+ * Note: Our HW can't DMA more than 8 buffers to build a packet on the wire
+ * and so we need to figure out the cases where we need to linearize the skb.
+ *
+ * For TSO we need to count the TSO header and segment payload separately.
+ * As such we need to check cases where we have 7 fragments or more as we
+ * can potentially require 9 DMA transactions, 1 for the TSO header, 1 for
+ * the segment payload in the first descriptor, and another 7 for the
+ * fragments.
  **/
 bool __i40evf_chk_linearize(struct sk_buff *skb)
 {
         const struct skb_frag_struct *frag, *stale;
-        int gso_size, nr_frags, sum;
-
-        /* check to see if TSO is enabled, if so we may get a repreive */
-        gso_size = skb_shinfo(skb)->gso_size;
-        if (unlikely(!gso_size))
-                return true;
+        int nr_frags, sum;
 
-        /* no need to check if number of frags is less than 8 */
+        /* no need to check if number of frags is less than 7 */
         nr_frags = skb_shinfo(skb)->nr_frags;
-        if (nr_frags < I40E_MAX_BUFFER_TXD)
+        if (nr_frags < (I40E_MAX_BUFFER_TXD - 1))
                 return false;
 
         /* We need to walk through the list and validate that each group
          * of 6 fragments totals at least gso_size.  However we don't need
-         * to perform such validation on the first or last 6 since the first
-         * 6 cannot inherit any data from a descriptor before them, and the
-         * last 6 cannot inherit any data from a descriptor after them.
+         * to perform such validation on the last 6 since the last 6 cannot
+         * inherit any data from a descriptor after them.
          */
-        nr_frags -= I40E_MAX_BUFFER_TXD - 1;
+        nr_frags -= I40E_MAX_BUFFER_TXD - 2;
         frag = &skb_shinfo(skb)->frags[0];
 
         /* Initialize size to the negative value of gso_size minus 1.  We
@@ -1833,21 +1832,21 @@ bool __i40evf_chk_linearize(struct sk_buff *skb)
          * descriptors for a single transmit as the header and previous
          * fragment are already consuming 2 descriptors.
          */
-        sum = 1 - gso_size;
+        sum = 1 - skb_shinfo(skb)->gso_size;
 
-        /* Add size of frags 1 through 5 to create our initial sum */
-        sum += skb_frag_size(++frag);
-        sum += skb_frag_size(++frag);
-        sum += skb_frag_size(++frag);
-        sum += skb_frag_size(++frag);
-        sum += skb_frag_size(++frag);
+        /* Add size of frags 0 through 4 to create our initial sum */
+        sum += skb_frag_size(frag++);
+        sum += skb_frag_size(frag++);
+        sum += skb_frag_size(frag++);
+        sum += skb_frag_size(frag++);
+        sum += skb_frag_size(frag++);
 
         /* Walk through fragments adding latest fragment, testing it, and
          * then removing stale fragments from the sum.
          */
         stale = &skb_shinfo(skb)->frags[0];
         for (;;) {
-                sum += skb_frag_size(++frag);
+                sum += skb_frag_size(frag++);
 
                 /* if sum is negative we failed to make sufficient progress */
                 if (sum < 0)
@@ -1857,7 +1856,7 @@ bool __i40evf_chk_linearize(struct sk_buff *skb)
                 if (!--nr_frags)
                         break;
 
-                sum -= skb_frag_size(++stale);
+                sum -= skb_frag_size(stale++);
         }
 
         return false;
diff --git a/drivers/net/ethernet/intel/i40evf/i40e_txrx.h b/drivers/net/ethernet/intel/i40evf/i40e_txrx.h
index c1dd8c5c9666..0429553fe887 100644
--- a/drivers/net/ethernet/intel/i40evf/i40e_txrx.h
+++ b/drivers/net/ethernet/intel/i40evf/i40e_txrx.h
@@ -395,10 +395,14 @@ static inline int i40e_maybe_stop_tx(struct i40e_ring *tx_ring, int size)
  **/
 static inline bool i40e_chk_linearize(struct sk_buff *skb, int count)
 {
-        /* we can only support up to 8 data buffers for a single send */
-        if (likely(count <= I40E_MAX_BUFFER_TXD))
+        /* Both TSO and single send will work if count is less than 8 */
+        if (likely(count < I40E_MAX_BUFFER_TXD))
                 return false;
 
-        return __i40evf_chk_linearize(skb);
+        if (skb_is_gso(skb))
+                return __i40evf_chk_linearize(skb);
+
+        /* we can support up to 8 data buffers for a single send */
+        return count != I40E_MAX_BUFFER_TXD;
 }
 #endif /* _I40E_TXRX_H_ */
diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe.h b/drivers/net/ethernet/intel/ixgbe/ixgbe.h
index 84fa28ceb200..e4949af7dd6b 100644
--- a/drivers/net/ethernet/intel/ixgbe/ixgbe.h
+++ b/drivers/net/ethernet/intel/ixgbe/ixgbe.h
@@ -661,9 +661,7 @@ struct ixgbe_adapter {
 #define IXGBE_FLAG2_RSS_FIELD_IPV6_UDP          (u32)(1 << 9)
 #define IXGBE_FLAG2_PTP_PPS_ENABLED             (u32)(1 << 10)
 #define IXGBE_FLAG2_PHY_INTERRUPT               (u32)(1 << 11)
-#ifdef CONFIG_IXGBE_VXLAN
 #define IXGBE_FLAG2_VXLAN_REREG_NEEDED          BIT(12)
-#endif
 #define IXGBE_FLAG2_VLAN_PROMISC                BIT(13)
 
         /* Tx fast path data */
@@ -675,6 +673,9 @@ struct ixgbe_adapter {
         int num_rx_queues;
         u16 rx_itr_setting;
 
+        /* Port number used to identify VXLAN traffic */
+        __be16 vxlan_port;
+
         /* TX */
         struct ixgbe_ring *tx_ring[MAX_TX_QUEUES] ____cacheline_aligned_in_smp;
 
@@ -782,9 +783,6 @@ struct ixgbe_adapter {
         u32 timer_event_accumulator;
         u32 vferr_refcount;
         struct ixgbe_mac_addr *mac_table;
-#ifdef CONFIG_IXGBE_VXLAN
-        u16 vxlan_port;
-#endif
         struct kobject *info_kobj;
 #ifdef CONFIG_IXGBE_HWMON
         struct hwmon_buff *ixgbe_hwmon_buff;
@@ -879,6 +877,8 @@ extern const char ixgbe_driver_version[];
 extern char ixgbe_default_device_descr[];
 #endif /* IXGBE_FCOE */
 
+int ixgbe_open(struct net_device *netdev);
+int ixgbe_close(struct net_device *netdev);
 void ixgbe_up(struct ixgbe_adapter *adapter);
 void ixgbe_down(struct ixgbe_adapter *adapter);
 void ixgbe_reinit_locked(struct ixgbe_adapter *adapter);
diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c b/drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c
index 726e0eeee63b..b3530e1e3ce1 100644
--- a/drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c
+++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_ethtool.c
@@ -2053,7 +2053,7 @@ static void ixgbe_diag_test(struct net_device *netdev,
 
                 if (if_running)
                         /* indicate we're in test mode */
-                        dev_close(netdev);
+                        ixgbe_close(netdev);
                 else
                         ixgbe_reset(adapter);
 
@@ -2091,7 +2091,7 @@ skip_loopback:
                 /* clear testing bit and return adapter to previous state */
                 clear_bit(__IXGBE_TESTING, &adapter->state);
                 if (if_running)
-                        dev_open(netdev);
+                        ixgbe_open(netdev);
                 else if (hw->mac.ops.disable_tx_laser)
                         hw->mac.ops.disable_tx_laser(hw);
         } else {
diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c b/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c
index 569cb0757c93..7df3fe29b210 100644
--- a/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c
+++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_main.c
@@ -4531,9 +4531,7 @@ static void ixgbe_clear_vxlan_port(struct ixgbe_adapter *adapter)
         case ixgbe_mac_X550:
         case ixgbe_mac_X550EM_x:
                 IXGBE_WRITE_REG(&adapter->hw, IXGBE_VXLANCTRL, 0);
-#ifdef CONFIG_IXGBE_VXLAN
                 adapter->vxlan_port = 0;
-#endif
                 break;
         default:
                 break;
@@ -5994,7 +5992,7 @@ static int ixgbe_change_mtu(struct net_device *netdev, int new_mtu)
  * handler is registered with the OS, the watchdog timer is started,
  * and the stack is notified that the interface is ready.
  **/
-static int ixgbe_open(struct net_device *netdev)
+int ixgbe_open(struct net_device *netdev)
 {
         struct ixgbe_adapter *adapter = netdev_priv(netdev);
         struct ixgbe_hw *hw = &adapter->hw;
@@ -6096,7 +6094,7 @@ static void ixgbe_close_suspend(struct ixgbe_adapter *adapter)
  * needs to be disabled.  A global MAC reset is issued to stop the
  * hardware, and all transmit and receive resources are freed.
  **/
-static int ixgbe_close(struct net_device *netdev)
+int ixgbe_close(struct net_device *netdev)
 {
         struct ixgbe_adapter *adapter = netdev_priv(netdev);
 
@@ -7560,11 +7558,10 @@ static void ixgbe_atr(struct ixgbe_ring *ring,
                 struct ipv6hdr *ipv6;
         } hdr;
         struct tcphdr *th;
+        unsigned int hlen;
         struct sk_buff *skb;
-#ifdef CONFIG_IXGBE_VXLAN
-        u8 encap = false;
-#endif /* CONFIG_IXGBE_VXLAN */
         __be16 vlan_id;
+        int l4_proto;
 
         /* if ring doesn't have a interrupt vector, cannot perform ATR */
         if (!q_vector)
@@ -7576,62 +7573,50 @@ static void ixgbe_atr(struct ixgbe_ring *ring,
 
         ring->atr_count++;
 
+        /* currently only IPv4/IPv6 with TCP is supported */
+        if ((first->protocol != htons(ETH_P_IP)) &&
+            (first->protocol != htons(ETH_P_IPV6)))
+                return;
+
         /* snag network header to get L4 type and address */
         skb = first->skb;
         hdr.network = skb_network_header(skb);
-        if (!skb->encapsulation) {
-                th = tcp_hdr(skb);
-        } else {
 #ifdef CONFIG_IXGBE_VXLAN
+        if (skb->encapsulation &&
+            first->protocol == htons(ETH_P_IP) &&
+            hdr.ipv4->protocol != IPPROTO_UDP) {
                 struct ixgbe_adapter *adapter = q_vector->adapter;
 
-                if (!adapter->vxlan_port)
-                        return;
-                if (first->protocol != htons(ETH_P_IP) ||
-                    hdr.ipv4->version != IPVERSION ||
-                    hdr.ipv4->protocol != IPPROTO_UDP) {
-                        return;
-                }
-                if (ntohs(udp_hdr(skb)->dest) != adapter->vxlan_port)
-                        return;
-                encap = true;
-                hdr.network = skb_inner_network_header(skb);
-                th = inner_tcp_hdr(skb);
-#else
-                return;
-#endif /* CONFIG_IXGBE_VXLAN */
+                /* verify the port is recognized as VXLAN */
+                if (adapter->vxlan_port &&
+                    udp_hdr(skb)->dest == adapter->vxlan_port)
+                        hdr.network = skb_inner_network_header(skb);
         }
+#endif /* CONFIG_IXGBE_VXLAN */
 
         /* Currently only IPv4/IPv6 with TCP is supported */
         switch (hdr.ipv4->version) {
         case IPVERSION:
-                if (hdr.ipv4->protocol != IPPROTO_TCP)
-                        return;
+                /* access ihl as u8 to avoid unaligned access on ia64 */
+                hlen = (hdr.network[0] & 0x0F) << 2;
+                l4_proto = hdr.ipv4->protocol;
                 break;
         case 6:
-                if (likely((unsigned char *)th - hdr.network ==
-                           sizeof(struct ipv6hdr))) {
-                        if (hdr.ipv6->nexthdr != IPPROTO_TCP)
-                                return;
-                } else {
-                        __be16 frag_off;
-                        u8 l4_hdr;
-
-                        ipv6_skip_exthdr(skb, hdr.network - skb->data +
-                                              sizeof(struct ipv6hdr),
-                                         &l4_hdr, &frag_off);
-                        if (unlikely(frag_off))
-                                return;
-                        if (l4_hdr != IPPROTO_TCP)
-                                return;
-                }
+                hlen = hdr.network - skb->data;
+                l4_proto = ipv6_find_hdr(skb, &hlen, IPPROTO_TCP, NULL, NULL);
+                hlen -= hdr.network - skb->data;
                 break;
         default:
                 return;
         }
 
-        /* skip this packet since it is invalid or the socket is closing */
-        if (!th || th->fin)
+        if (l4_proto != IPPROTO_TCP)
+                return;
+
+        th = (struct tcphdr *)(hdr.network + hlen);
+
+        /* skip this packet since the socket is closing */
+        if (th->fin)
                 return;
 
         /* sample on all syn packets or once every atr sample count */
@@ -7682,10 +7667,8 @@ static void ixgbe_atr(struct ixgbe_ring *ring,
                 break;
         }
 
-#ifdef CONFIG_IXGBE_VXLAN
-        if (encap)
+        if (hdr.network != skb_network_header(skb))
                 input.formatted.flow_type |= IXGBE_ATR_L4TYPE_TUNNEL_MASK;
-#endif /* CONFIG_IXGBE_VXLAN */
 
         /* This assumes the Rx queue and Tx queue are bound to the same CPU */
         ixgbe_fdir_add_signature_filter_82599(&q_vector->adapter->hw,
@@ -8209,10 +8192,17 @@ int ixgbe_setup_tc(struct net_device *dev, u8 tc)
 static int ixgbe_delete_clsu32(struct ixgbe_adapter *adapter,
                                struct tc_cls_u32_offload *cls)
 {
+        u32 uhtid = TC_U32_USERHTID(cls->knode.handle);
+        u32 loc;
         int err;
 
+        if ((uhtid != 0x800) && (uhtid >= IXGBE_MAX_LINK_HANDLE))
+                return -EINVAL;
+
+        loc = cls->knode.handle & 0xfffff;
+
         spin_lock(&adapter->fdir_perfect_lock);
-        err = ixgbe_update_ethtool_fdir_entry(adapter, NULL, cls->knode.handle);
+        err = ixgbe_update_ethtool_fdir_entry(adapter, NULL, loc);
         spin_unlock(&adapter->fdir_perfect_lock);
         return err;
 }
@@ -8221,20 +8211,30 @@ static int ixgbe_configure_clsu32_add_hnode(struct ixgbe_adapter *adapter,
                                             __be16 protocol,
                                             struct tc_cls_u32_offload *cls)
 {
+        u32 uhtid = TC_U32_USERHTID(cls->hnode.handle);
+
+        if (uhtid >= IXGBE_MAX_LINK_HANDLE)
+                return -EINVAL;
+
         /* This ixgbe devices do not support hash tables at the moment
          * so abort when given hash tables.
          */
         if (cls->hnode.divisor > 0)
                 return -EINVAL;
 
-        set_bit(TC_U32_USERHTID(cls->hnode.handle), &adapter->tables);
+        set_bit(uhtid - 1, &adapter->tables);
         return 0;
 }
 
 static int ixgbe_configure_clsu32_del_hnode(struct ixgbe_adapter *adapter,
                                             struct tc_cls_u32_offload *cls)
 {
-        clear_bit(TC_U32_USERHTID(cls->hnode.handle), &adapter->tables);
+        u32 uhtid = TC_U32_USERHTID(cls->hnode.handle);
+
+        if (uhtid >= IXGBE_MAX_LINK_HANDLE)
+                return -EINVAL;
+
+        clear_bit(uhtid - 1, &adapter->tables);
         return 0;
 }
 
@@ -8252,27 +8252,29 @@ static int ixgbe_configure_clsu32(struct ixgbe_adapter *adapter,
 #endif
         int i, err = 0;
         u8 queue;
-        u32 handle;
+        u32 uhtid, link_uhtid;
 
         memset(&mask, 0, sizeof(union ixgbe_atr_input));
-        handle = cls->knode.handle;
+        uhtid = TC_U32_USERHTID(cls->knode.handle);
+        link_uhtid = TC_U32_USERHTID(cls->knode.link_handle);
 
-        /* At the moment cls_u32 jumps to transport layer and skips past
+        /* At the moment cls_u32 jumps to network layer and skips past
          * L2 headers. The canonical method to match L2 frames is to use
          * negative values. However this is error prone at best but really
          * just broken because there is no way to "know" what sort of hdr
-         * is in front of the transport layer. Fix cls_u32 to support L2
+         * is in front of the network layer. Fix cls_u32 to support L2
          * headers when needed.
          */
         if (protocol != htons(ETH_P_IP))
                 return -EINVAL;
 
-        if (cls->knode.link_handle ||
-            cls->knode.link_handle >= IXGBE_MAX_LINK_HANDLE) {
+        if (link_uhtid) {
                 struct ixgbe_nexthdr *nexthdr = ixgbe_ipv4_jumps;
-                u32 uhtid = TC_U32_USERHTID(cls->knode.link_handle);
 
-                if (!test_bit(uhtid, &adapter->tables))
+                if (link_uhtid >= IXGBE_MAX_LINK_HANDLE)
+                        return -EINVAL;
+
+                if (!test_bit(link_uhtid - 1, &adapter->tables))
                         return -EINVAL;
 
                 for (i = 0; nexthdr[i].jump; i++) {
@@ -8288,10 +8290,7 @@ static int ixgbe_configure_clsu32(struct ixgbe_adapter *adapter,
                             nexthdr->mask != cls->knode.sel->keys[0].mask)
                                 return -EINVAL;
 
-                        if (uhtid >= IXGBE_MAX_LINK_HANDLE)
-                                return -EINVAL;
-
-                        adapter->jump_tables[uhtid] = nexthdr->jump;
+                        adapter->jump_tables[link_uhtid] = nexthdr->jump;
                 }
                 return 0;
         }
@@ -8308,13 +8307,13 @@ static int ixgbe_configure_clsu32(struct ixgbe_adapter *adapter,
          * To add support for new nodes update ixgbe_model.h parse structures
          * this function _should_ be generic try not to hardcode values here.
          */
-        if (TC_U32_USERHTID(handle) == 0x800) {
+        if (uhtid == 0x800) {
                 field_ptr = adapter->jump_tables[0];
         } else {
-                if (TC_U32_USERHTID(handle) >= ARRAY_SIZE(adapter->jump_tables))
+                if (uhtid >= IXGBE_MAX_LINK_HANDLE)
                         return -EINVAL;
 
-                field_ptr = adapter->jump_tables[TC_U32_USERHTID(handle)];
+                field_ptr = adapter->jump_tables[uhtid];
         }
 
         if (!field_ptr)
@@ -8332,8 +8331,7 @@ static int ixgbe_configure_clsu32(struct ixgbe_adapter *adapter,
                 int j;
 
                 for (j = 0; field_ptr[j].val; j++) {
-                        if (field_ptr[j].off == off &&
-                            field_ptr[j].mask == m) {
+                        if (field_ptr[j].off == off) {
                                 field_ptr[j].val(input, &mask, val, m);
                                 input->filter.formatted.flow_type |=
                                         field_ptr[j].type;
@@ -8393,8 +8391,8 @@ err_out:
         return -EINVAL;
 }
 
-int __ixgbe_setup_tc(struct net_device *dev, u32 handle, __be16 proto,
-                     struct tc_to_netdev *tc)
+static int __ixgbe_setup_tc(struct net_device *dev, u32 handle, __be16 proto,
+                            struct tc_to_netdev *tc)
 {
         struct ixgbe_adapter *adapter = netdev_priv(dev);
 
@@ -8554,7 +8552,6 @@ static void ixgbe_add_vxlan_port(struct net_device *dev, sa_family_t sa_family,
 {
         struct ixgbe_adapter *adapter = netdev_priv(dev);
         struct ixgbe_hw *hw = &adapter->hw;
-        u16 new_port = ntohs(port);
 
         if (!(adapter->flags & IXGBE_FLAG_VXLAN_OFFLOAD_CAPABLE))
                 return;
@@ -8562,18 +8559,18 @@ static void ixgbe_add_vxlan_port(struct net_device *dev, sa_family_t sa_family,
         if (sa_family == AF_INET6)
                 return;
 
-        if (adapter->vxlan_port == new_port)
+        if (adapter->vxlan_port == port)
                 return;
 
         if (adapter->vxlan_port) {
                 netdev_info(dev,
                             "Hit Max num of VXLAN ports, not adding port %d\n",
-                            new_port);
+                            ntohs(port));
                 return;
         }
 
-        adapter->vxlan_port = new_port;
-        IXGBE_WRITE_REG(hw, IXGBE_VXLANCTRL, new_port);
+        adapter->vxlan_port = port;
+        IXGBE_WRITE_REG(hw, IXGBE_VXLANCTRL, ntohs(port));
 }
 
 /**
@@ -8586,7 +8583,6 @@ static void ixgbe_del_vxlan_port(struct net_device *dev, sa_family_t sa_family,
                                  __be16 port)
 {
         struct ixgbe_adapter *adapter = netdev_priv(dev);
-        u16 new_port = ntohs(port);
 
         if (!(adapter->flags & IXGBE_FLAG_VXLAN_OFFLOAD_CAPABLE))
                 return;
@@ -8594,9 +8590,9 @@ static void ixgbe_del_vxlan_port(struct net_device *dev, sa_family_t sa_family,
         if (sa_family == AF_INET6)
                 return;
 
-        if (adapter->vxlan_port != new_port) {
+        if (adapter->vxlan_port != port) {
                 netdev_info(dev, "Port %d was not found, not deleting\n",
-                            new_port);
+                            ntohs(port));
                 return;
         }
 
@@ -9265,17 +9261,6 @@ skip_sriov:
         netdev->priv_flags |= IFF_UNICAST_FLT;
         netdev->priv_flags |= IFF_SUPP_NOFCS;
 
-#ifdef CONFIG_IXGBE_VXLAN
-        switch (adapter->hw.mac.type) {
-        case ixgbe_mac_X550:
-        case ixgbe_mac_X550EM_x:
-                netdev->hw_enc_features |= NETIF_F_RXCSUM;
-                break;
-        default:
-                break;
-        }
-#endif /* CONFIG_IXGBE_VXLAN */
-
 #ifdef CONFIG_IXGBE_DCB
         netdev->dcbnl_ops = &dcbnl_ops;
 #endif
@@ -9329,6 +9314,8 @@ skip_sriov:
                 goto err_sw_init;
         }
 
+        /* Set hw->mac.addr to permanent MAC address */
+        ether_addr_copy(hw->mac.addr, hw->mac.perm_addr);
         ixgbe_mac_set_default_filter(adapter);
 
         setup_timer(&adapter->service_timer, &ixgbe_service_timer,
diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_model.h b/drivers/net/ethernet/intel/ixgbe/ixgbe_model.h
index ce48872d4782..74c53ad9d268 100644
--- a/drivers/net/ethernet/intel/ixgbe/ixgbe_model.h
+++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_model.h
@@ -32,7 +32,6 @@
 
 struct ixgbe_mat_field {
         unsigned int off;
-        unsigned int mask;
         int (*val)(struct ixgbe_fdir_filter *input,
                    union ixgbe_atr_input *mask,
                    u32 val, u32 m);
@@ -58,35 +57,27 @@ static inline int ixgbe_mat_prgm_dip(struct ixgbe_fdir_filter *input,
 }
 
 static struct ixgbe_mat_field ixgbe_ipv4_fields[] = {
-        { .off = 12, .mask = -1, .val = ixgbe_mat_prgm_sip,
+        { .off = 12, .val = ixgbe_mat_prgm_sip,
           .type = IXGBE_ATR_FLOW_TYPE_IPV4},
-        { .off = 16, .mask = -1, .val = ixgbe_mat_prgm_dip,
+        { .off = 16, .val = ixgbe_mat_prgm_dip,
           .type = IXGBE_ATR_FLOW_TYPE_IPV4},
         { .val = NULL } /* terminal node */
 };
 
-static inline int ixgbe_mat_prgm_sport(struct ixgbe_fdir_filter *input,
+static inline int ixgbe_mat_prgm_ports(struct ixgbe_fdir_filter *input,
                                        union ixgbe_atr_input *mask,
                                        u32 val, u32 m)
 {
         input->filter.formatted.src_port = val & 0xffff;
         mask->formatted.src_port = m & 0xffff;
-        return 0;
-};
+        input->filter.formatted.dst_port = val >> 16;
+        mask->formatted.dst_port = m >> 16;
 
-static inline int ixgbe_mat_prgm_dport(struct ixgbe_fdir_filter *input,
-                                       union ixgbe_atr_input *mask,
-                                       u32 val, u32 m)
-{
-        input->filter.formatted.dst_port = val & 0xffff;
-        mask->formatted.dst_port = m & 0xffff;
         return 0;
 };
 
 static struct ixgbe_mat_field ixgbe_tcp_fields[] = {
-        {.off = 0, .mask = 0xffff, .val = ixgbe_mat_prgm_sport,
-         .type = IXGBE_ATR_FLOW_TYPE_TCPV4},
-        {.off = 2, .mask = 0xffff, .val = ixgbe_mat_prgm_dport,
+        {.off = 0, .val = ixgbe_mat_prgm_ports,
          .type = IXGBE_ATR_FLOW_TYPE_TCPV4},
         { .val = NULL } /* terminal node */
 };
diff --git a/drivers/net/ethernet/intel/ixgbe/ixgbe_x550.c b/drivers/net/ethernet/intel/ixgbe/ixgbe_x550.c
index 87aca3f7c3de..68a9c646498e 100644
--- a/drivers/net/ethernet/intel/ixgbe/ixgbe_x550.c
+++ b/drivers/net/ethernet/intel/ixgbe/ixgbe_x550.c
@@ -355,7 +355,7 @@ static s32 ixgbe_iosf_wait(struct ixgbe_hw *hw, u32 *ctrl)
                 command = IXGBE_READ_REG(hw, IXGBE_SB_IOSF_INDIRECT_CTRL);
                 if (!(command & IXGBE_SB_IOSF_CTRL_BUSY))
                         break;
-                usleep_range(10, 20);
+                udelay(10);
         }
         if (ctrl)
                 *ctrl = command;
diff --git a/drivers/net/ethernet/intel/ixgbevf/ethtool.c b/drivers/net/ethernet/intel/ixgbevf/ethtool.c
index c48aef613b0a..d7aa4b203f40 100644
--- a/drivers/net/ethernet/intel/ixgbevf/ethtool.c
+++ b/drivers/net/ethernet/intel/ixgbevf/ethtool.c
@@ -680,7 +680,7 @@ static void ixgbevf_diag_test(struct net_device *netdev,
 
                 if (if_running)
                         /* indicate we're in test mode */
-                        dev_close(netdev);
+                        ixgbevf_close(netdev);
                 else
                         ixgbevf_reset(adapter);
 
@@ -692,7 +692,7 @@ static void ixgbevf_diag_test(struct net_device *netdev,
 
                 clear_bit(__IXGBEVF_TESTING, &adapter->state);
                 if (if_running)
-                        dev_open(netdev);
+                        ixgbevf_open(netdev);
         } else {
                 hw_dbg(&adapter->hw, "online testing starting\n");
                 /* Online tests */
diff --git a/drivers/net/ethernet/intel/ixgbevf/ixgbevf.h b/drivers/net/ethernet/intel/ixgbevf/ixgbevf.h
index 68ec7daa04fd..991eeae81473 100644
--- a/drivers/net/ethernet/intel/ixgbevf/ixgbevf.h
+++ b/drivers/net/ethernet/intel/ixgbevf/ixgbevf.h
@@ -486,6 +486,8 @@ extern const struct ixgbe_mbx_operations ixgbevf_mbx_ops;
 extern const char ixgbevf_driver_name[];
 extern const char ixgbevf_driver_version[];
 
+int ixgbevf_open(struct net_device *netdev);
+int ixgbevf_close(struct net_device *netdev);
 void ixgbevf_up(struct ixgbevf_adapter *adapter);
 void ixgbevf_down(struct ixgbevf_adapter *adapter);
 void ixgbevf_reinit_locked(struct ixgbevf_adapter *adapter);
diff --git a/drivers/net/ethernet/intel/ixgbevf/ixgbevf_main.c b/drivers/net/ethernet/intel/ixgbevf/ixgbevf_main.c
index 0ea14c0a2e74..b0edae94d73d 100644
--- a/drivers/net/ethernet/intel/ixgbevf/ixgbevf_main.c
+++ b/drivers/net/ethernet/intel/ixgbevf/ixgbevf_main.c
@@ -3122,7 +3122,7 @@ static void ixgbevf_free_all_rx_resources(struct ixgbevf_adapter *adapter)
  * handler is registered with the OS, the watchdog timer is started,
  * and the stack is notified that the interface is ready.
  **/
-static int ixgbevf_open(struct net_device *netdev)
+int ixgbevf_open(struct net_device *netdev)
 {
         struct ixgbevf_adapter *adapter = netdev_priv(netdev);
         struct ixgbe_hw *hw = &adapter->hw;
@@ -3205,7 +3205,7 @@ err_setup_reset:
  * needs to be disabled.  A global MAC reset is issued to stop the
  * hardware, and all transmit and receive resources are freed.
  **/
-static int ixgbevf_close(struct net_device *netdev)
+int ixgbevf_close(struct net_device *netdev)
 {
         struct ixgbevf_adapter *adapter = netdev_priv(netdev);
 
@@ -3692,19 +3692,23 @@ static int ixgbevf_set_mac(struct net_device *netdev, void *p)
         struct ixgbevf_adapter *adapter = netdev_priv(netdev);
         struct ixgbe_hw *hw = &adapter->hw;
         struct sockaddr *addr = p;
+        int err;
 
         if (!is_valid_ether_addr(addr->sa_data))
                 return -EADDRNOTAVAIL;
 
-        ether_addr_copy(netdev->dev_addr, addr->sa_data);
-        ether_addr_copy(hw->mac.addr, addr->sa_data);
-
         spin_lock_bh(&adapter->mbx_lock);
 
-        hw->mac.ops.set_rar(hw, 0, hw->mac.addr, 0);
+        err = hw->mac.ops.set_rar(hw, 0, addr->sa_data, 0);
 
         spin_unlock_bh(&adapter->mbx_lock);
 
+        if (err)
+                return -EPERM;
+
+        ether_addr_copy(hw->mac.addr, addr->sa_data);
+        ether_addr_copy(netdev->dev_addr, addr->sa_data);
+
         return 0;
 }
 
diff --git a/drivers/net/ethernet/intel/ixgbevf/vf.c b/drivers/net/ethernet/intel/ixgbevf/vf.c
index 61a98f4c5746..4d613a4f2a7f 100644
--- a/drivers/net/ethernet/intel/ixgbevf/vf.c
+++ b/drivers/net/ethernet/intel/ixgbevf/vf.c
@@ -408,8 +408,10 @@ static s32 ixgbevf_set_rar_vf(struct ixgbe_hw *hw, u32 index, u8 *addr,
 
         /* if nacked the address was rejected, use "perm_addr" */
         if (!ret_val &&
-            (msgbuf[0] == (IXGBE_VF_SET_MAC_ADDR | IXGBE_VT_MSGTYPE_NACK)))
+            (msgbuf[0] == (IXGBE_VF_SET_MAC_ADDR | IXGBE_VT_MSGTYPE_NACK))) {
                 ixgbevf_get_mac_addr_vf(hw, hw->mac.addr);
+                return IXGBE_ERR_MBX;
+        }
 
         return ret_val;
 }
diff --git a/drivers/net/ethernet/marvell/mvneta.c b/drivers/net/ethernet/marvell/mvneta.c
index 577f7ca7deba..a6d26d351dfc 100644
--- a/drivers/net/ethernet/marvell/mvneta.c
+++ b/drivers/net/ethernet/marvell/mvneta.c
@@ -260,7 +260,6 @@
 
 #define MVNETA_VLAN_TAG_LEN             4
 
-#define MVNETA_CPU_D_CACHE_LINE_SIZE    32
 #define MVNETA_TX_CSUM_DEF_SIZE         1600
 #define MVNETA_TX_CSUM_MAX_SIZE         9800
 #define MVNETA_ACC_MODE_EXT1            1
@@ -300,7 +299,7 @@
 #define MVNETA_RX_PKT_SIZE(mtu) \
         ALIGN((mtu) + MVNETA_MH_SIZE + MVNETA_VLAN_TAG_LEN + \
               ETH_HLEN + ETH_FCS_LEN,                        \
-              MVNETA_CPU_D_CACHE_LINE_SIZE)
+              cache_line_size())
 
 #define IS_TSO_HEADER(txq, addr) \
         ((addr >= txq->tso_hdrs_phys) && \
@@ -2764,9 +2763,6 @@ static int mvneta_rxq_init(struct mvneta_port *pp,
         if (rxq->descs == NULL)
                 return -ENOMEM;
 
-        BUG_ON(rxq->descs !=
-               PTR_ALIGN(rxq->descs, MVNETA_CPU_D_CACHE_LINE_SIZE));
-
         rxq->last_desc = rxq->size - 1;
 
         /* Set Rx descriptors queue starting address */
@@ -2837,10 +2833,6 @@ static int mvneta_txq_init(struct mvneta_port *pp,
         if (txq->descs == NULL)
                 return -ENOMEM;
 
-        /* Make sure descriptor address is cache line size aligned  */
-        BUG_ON(txq->descs !=
-               PTR_ALIGN(txq->descs, MVNETA_CPU_D_CACHE_LINE_SIZE));
-
         txq->last_desc = txq->size - 1;
 
         /* Set maximum bandwidth for enabled TXQs */
@@ -3050,6 +3042,20 @@ static int mvneta_check_mtu_valid(struct net_device *dev, int mtu)
         return mtu;
 }
 
+static void mvneta_percpu_enable(void *arg)
+{
+        struct mvneta_port *pp = arg;
+
+        enable_percpu_irq(pp->dev->irq, IRQ_TYPE_NONE);
+}
+
+static void mvneta_percpu_disable(void *arg)
+{
+        struct mvneta_port *pp = arg;
+
+        disable_percpu_irq(pp->dev->irq);
+}
+
 /* Change the device mtu */
 static int mvneta_change_mtu(struct net_device *dev, int mtu)
 {
@@ -3074,6 +3080,7 @@ static int mvneta_change_mtu(struct net_device *dev, int mtu)
          * reallocation of the queues
          */
         mvneta_stop_dev(pp);
+        on_each_cpu(mvneta_percpu_disable, pp, true);
 
         mvneta_cleanup_txqs(pp);
         mvneta_cleanup_rxqs(pp);
@@ -3097,6 +3104,7 @@ static int mvneta_change_mtu(struct net_device *dev, int mtu)
                 return ret;
         }
 
+        on_each_cpu(mvneta_percpu_enable, pp, true);
         mvneta_start_dev(pp);
         mvneta_port_up(pp);
 
@@ -3250,20 +3258,6 @@ static void mvneta_mdio_remove(struct mvneta_port *pp)
         pp->phy_dev = NULL;
 }
 
-static void mvneta_percpu_enable(void *arg)
-{
-        struct mvneta_port *pp = arg;
-
-        enable_percpu_irq(pp->dev->irq, IRQ_TYPE_NONE);
-}
-
-static void mvneta_percpu_disable(void *arg)
-{
-        struct mvneta_port *pp = arg;
-
-        disable_percpu_irq(pp->dev->irq);
-}
-
 /* Electing a CPU must be done in an atomic way: it should be done
  * after or before the removal/insertion of a CPU and this function is
  * not reentrant.
@@ -3360,8 +3354,7 @@ static int mvneta_percpu_notifier(struct notifier_block *nfb,
                 /* Enable per-CPU interrupts on the CPU that is
                  * brought up.
                  */
-                smp_call_function_single(cpu, mvneta_percpu_enable,
-                                         pp, true);
+                mvneta_percpu_enable(pp);
 
                 /* Enable per-CPU interrupt on the one CPU we care
                  * about.
@@ -3393,8 +3386,7 @@ static int mvneta_percpu_notifier(struct notifier_block *nfb,
                 /* Disable per-CPU interrupts on the CPU that is
                  * brought down.
                  */
-                smp_call_function_single(cpu, mvneta_percpu_disable,
-                                         pp, true);
+                mvneta_percpu_disable(pp);
 
                 break;
         case CPU_DEAD:
diff --git a/drivers/net/ethernet/marvell/mvpp2.c b/drivers/net/ethernet/marvell/mvpp2.c
index c797971aefab..868a957f24bb 100644
--- a/drivers/net/ethernet/marvell/mvpp2.c
+++ b/drivers/net/ethernet/marvell/mvpp2.c
@@ -321,7 +321,6 @@
 /* Lbtd 802.3 type */
 #define MVPP2_IP_LBDT_TYPE              0xfffa
 
-#define MVPP2_CPU_D_CACHE_LINE_SIZE     32
 #define MVPP2_TX_CSUM_MAX_SIZE          9800
 
 /* Timeout constants */
@@ -377,7 +376,7 @@
 
 #define MVPP2_RX_PKT_SIZE(mtu) \
         ALIGN((mtu) + MVPP2_MH_SIZE + MVPP2_VLAN_TAG_LEN + \
-              ETH_HLEN + ETH_FCS_LEN, MVPP2_CPU_D_CACHE_LINE_SIZE)
+              ETH_HLEN + ETH_FCS_LEN, cache_line_size())
 
 #define MVPP2_RX_BUF_SIZE(pkt_size)     ((pkt_size) + NET_SKB_PAD)
 #define MVPP2_RX_TOTAL_SIZE(buf_size)   ((buf_size) + MVPP2_SKB_SHINFO_SIZE)
@@ -4493,10 +4492,6 @@ static int mvpp2_aggr_txq_init(struct platform_device *pdev,
         if (!aggr_txq->descs)
                 return -ENOMEM;
 
-        /* Make sure descriptor address is cache line size aligned  */
-        BUG_ON(aggr_txq->descs !=
-               PTR_ALIGN(aggr_txq->descs, MVPP2_CPU_D_CACHE_LINE_SIZE));
-
         aggr_txq->last_desc = aggr_txq->size - 1;
 
         /* Aggr TXQ no reset WA */
@@ -4526,9 +4521,6 @@ static int mvpp2_rxq_init(struct mvpp2_port *port,
         if (!rxq->descs)
                 return -ENOMEM;
 
-        BUG_ON(rxq->descs !=
-               PTR_ALIGN(rxq->descs, MVPP2_CPU_D_CACHE_LINE_SIZE));
-
         rxq->last_desc = rxq->size - 1;
 
         /* Zero occupied and non-occupied counters - direct access */
@@ -4616,10 +4608,6 @@ static int mvpp2_txq_init(struct mvpp2_port *port,
         if (!txq->descs)
                 return -ENOMEM;
 
-        /* Make sure descriptor address is cache line size aligned  */
-        BUG_ON(txq->descs !=
-               PTR_ALIGN(txq->descs, MVPP2_CPU_D_CACHE_LINE_SIZE));
-
         txq->last_desc = txq->size - 1;
 
         /* Set Tx descriptors queue starting address - indirect access */
@@ -6059,8 +6047,10 @@ static int mvpp2_port_init(struct mvpp2_port *port)
 
                 /* Map physical Rx queue to port's logical Rx queue */
                 rxq = devm_kzalloc(dev, sizeof(*rxq), GFP_KERNEL);
-                if (!rxq)
+                if (!rxq) {
+                        err = -ENOMEM;
                         goto err_free_percpu;
+                }
                 /* Map this Rx queue to a physical queue */
                 rxq->id = port->first_rxq + queue;
                 rxq->port = port->id;
diff --git a/drivers/net/ethernet/marvell/pxa168_eth.c b/drivers/net/ethernet/marvell/pxa168_eth.c
index 7ace07dad6a3..c442f6ad15ff 100644
--- a/drivers/net/ethernet/marvell/pxa168_eth.c
+++ b/drivers/net/ethernet/marvell/pxa168_eth.c
@@ -979,6 +979,8 @@ static int pxa168_init_phy(struct net_device *dev)
                 return 0;
 
         pep->phy = mdiobus_scan(pep->smi_bus, pep->phy_addr);
+        if (IS_ERR(pep->phy))
+                return PTR_ERR(pep->phy);
         if (!pep->phy)
                 return -ENODEV;
 
diff --git a/drivers/net/ethernet/mellanox/mlx4/en_ethtool.c b/drivers/net/ethernet/mellanox/mlx4/en_ethtool.c
index f69584a9b47f..c761194bb323 100644
--- a/drivers/net/ethernet/mellanox/mlx4/en_ethtool.c
+++ b/drivers/net/ethernet/mellanox/mlx4/en_ethtool.c
@@ -337,7 +337,7 @@ static int mlx4_en_get_sset_count(struct net_device *dev, int sset)
         case ETH_SS_STATS:
                 return bitmap_iterator_count(&it) +
                         (priv->tx_ring_num * 2) +
-                        (priv->rx_ring_num * 2);
+                        (priv->rx_ring_num * 3);
         case ETH_SS_TEST:
                 return MLX4_EN_NUM_SELF_TEST - !(priv->mdev->dev->caps.flags
                                         & MLX4_DEV_CAP_FLAG_UC_LOOPBACK) * 2;
@@ -404,6 +404,7 @@ static void mlx4_en_get_ethtool_stats(struct net_device *dev,
         for (i = 0; i < priv->rx_ring_num; i++) {
                 data[index++] = priv->rx_ring[i]->packets;
                 data[index++] = priv->rx_ring[i]->bytes;
+                data[index++] = priv->rx_ring[i]->dropped;
         }
         spin_unlock_bh(&priv->stats_lock);
 
@@ -477,6 +478,8 @@ static void mlx4_en_get_strings(struct net_device *dev,
                                 "rx%d_packets", i);
                         sprintf(data + (index++) * ETH_GSTRING_LEN,
                                 "rx%d_bytes", i);
+                        sprintf(data + (index++) * ETH_GSTRING_LEN,
+                                "rx%d_dropped", i);
                 }
                 break;
         case ETH_SS_PRIV_FLAGS:
diff --git a/drivers/net/ethernet/mellanox/mlx4/en_port.c b/drivers/net/ethernet/mellanox/mlx4/en_port.c
index 3904b5fc0b7c..20b6c2e678b8 100644
--- a/drivers/net/ethernet/mellanox/mlx4/en_port.c
+++ b/drivers/net/ethernet/mellanox/mlx4/en_port.c
@@ -158,6 +158,7 @@ int mlx4_en_DUMP_ETH_STATS(struct mlx4_en_dev *mdev, u8 port, u8 reset)
         u64 in_mod = reset << 8 | port;
         int err;
         int i, counter_index;
+        unsigned long sw_rx_dropped = 0;
 
         mailbox = mlx4_alloc_cmd_mailbox(mdev->dev);
         if (IS_ERR(mailbox))
@@ -180,6 +181,7 @@ int mlx4_en_DUMP_ETH_STATS(struct mlx4_en_dev *mdev, u8 port, u8 reset)
         for (i = 0; i < priv->rx_ring_num; i++) {
                 stats->rx_packets += priv->rx_ring[i]->packets;
                 stats->rx_bytes += priv->rx_ring[i]->bytes;
+                sw_rx_dropped += priv->rx_ring[i]->dropped;
                 priv->port_stats.rx_chksum_good += priv->rx_ring[i]->csum_ok;
                 priv->port_stats.rx_chksum_none += priv->rx_ring[i]->csum_none;
                 priv->port_stats.rx_chksum_complete += priv->rx_ring[i]->csum_complete;
@@ -236,7 +238,8 @@ int mlx4_en_DUMP_ETH_STATS(struct mlx4_en_dev *mdev, u8 port, u8 reset)
                                           &mlx4_en_stats->MCAST_prio_1,
                                           NUM_PRIORITIES);
         stats->collisions = 0;
-        stats->rx_dropped = be32_to_cpu(mlx4_en_stats->RDROP);
+        stats->rx_dropped = be32_to_cpu(mlx4_en_stats->RDROP) +
+                            sw_rx_dropped;
         stats->rx_length_errors = be32_to_cpu(mlx4_en_stats->RdropLength);
         stats->rx_over_errors = 0;
         stats->rx_crc_errors = be32_to_cpu(mlx4_en_stats->RCRC);
diff --git a/drivers/net/ethernet/mellanox/mlx4/en_rx.c b/drivers/net/ethernet/mellanox/mlx4/en_rx.c
index 86bcfe510e4e..b723e3bcab39 100644
--- a/drivers/net/ethernet/mellanox/mlx4/en_rx.c
+++ b/drivers/net/ethernet/mellanox/mlx4/en_rx.c
@@ -61,7 +61,7 @@ static int mlx4_alloc_pages(struct mlx4_en_priv *priv,
                 gfp_t gfp = _gfp;
 
                 if (order)
-                        gfp |= __GFP_COMP | __GFP_NOWARN;
+                        gfp |= __GFP_COMP | __GFP_NOWARN | __GFP_NOMEMALLOC;
                 page = alloc_pages(gfp, order);
                 if (likely(page))
                         break;
@@ -126,7 +126,9 @@ out:
                         dma_unmap_page(priv->ddev, page_alloc[i].dma,
                                 page_alloc[i].page_size, PCI_DMA_FROMDEVICE);
                         page = page_alloc[i].page;
-                        set_page_count(page, 1);
+                        /* Revert changes done by mlx4_alloc_pages */
+                        page_ref_sub(page, page_alloc[i].page_size /
+                                           priv->frag_info[i].frag_stride - 1);
                         put_page(page);
                 }
         }
@@ -176,7 +178,9 @@ out:
                 dma_unmap_page(priv->ddev, page_alloc->dma,
                                page_alloc->page_size, PCI_DMA_FROMDEVICE);
                 page = page_alloc->page;
-                set_page_count(page, 1);
+                /* Revert changes done by mlx4_alloc_pages */
+                page_ref_sub(page, page_alloc->page_size /
+                                   priv->frag_info[i].frag_stride - 1);
                 put_page(page);
                 page_alloc->page = NULL;
         }
@@ -939,7 +943,7 @@ int mlx4_en_process_rx_cq(struct net_device *dev, struct mlx4_en_cq *cq, int bud
                 /* GRO not possible, complete processing here */
                 skb = mlx4_en_rx_skb(priv, rx_desc, frags, length);
                 if (!skb) {
-                        priv->stats.rx_dropped++;
+                        ring->dropped++;
                         goto next;
                 }
 
diff --git a/drivers/net/ethernet/mellanox/mlx4/en_tx.c b/drivers/net/ethernet/mellanox/mlx4/en_tx.c
index c0d7b7296236..a386f047c1af 100644
--- a/drivers/net/ethernet/mellanox/mlx4/en_tx.c
+++ b/drivers/net/ethernet/mellanox/mlx4/en_tx.c
@@ -405,7 +405,6 @@ static bool mlx4_en_process_tx_cq(struct net_device *dev,
         u32 packets = 0;
         u32 bytes = 0;
         int factor = priv->cqe_factor;
-        u64 timestamp = 0;
         int done = 0;
         int budget = priv->tx_work_limit;
         u32 last_nr_txbb;
@@ -445,9 +444,12 @@ static bool mlx4_en_process_tx_cq(struct net_device *dev,
                 new_index = be16_to_cpu(cqe->wqe_index) & size_mask;
 
                 do {
+                        u64 timestamp = 0;
+
                         txbbs_skipped += last_nr_txbb;
                         ring_index = (ring_index + last_nr_txbb) & size_mask;
-                        if (ring->tx_info[ring_index].ts_requested)
+
+                        if (unlikely(ring->tx_info[ring_index].ts_requested))
                                 timestamp = mlx4_en_get_cqe_ts(cqe);
 
                         /* free next descriptor */
diff --git a/drivers/net/ethernet/mellanox/mlx4/main.c b/drivers/net/ethernet/mellanox/mlx4/main.c
index 358f7230da58..12c77a70abdb 100644
--- a/drivers/net/ethernet/mellanox/mlx4/main.c
+++ b/drivers/net/ethernet/mellanox/mlx4/main.c
@@ -3172,6 +3172,34 @@ static int mlx4_check_dev_cap(struct mlx4_dev *dev, struct mlx4_dev_cap *dev_cap
         return 0;
 }
 
+static int mlx4_pci_enable_device(struct mlx4_dev *dev)
+{
+        struct pci_dev *pdev = dev->persist->pdev;
+        int err = 0;
+
+        mutex_lock(&dev->persist->pci_status_mutex);
+        if (dev->persist->pci_status == MLX4_PCI_STATUS_DISABLED) {
+                err = pci_enable_device(pdev);
+                if (!err)
+                        dev->persist->pci_status = MLX4_PCI_STATUS_ENABLED;
+        }
+        mutex_unlock(&dev->persist->pci_status_mutex);
+
+        return err;
+}
+
+static void mlx4_pci_disable_device(struct mlx4_dev *dev)
+{
+        struct pci_dev *pdev = dev->persist->pdev;
+
+        mutex_lock(&dev->persist->pci_status_mutex);
+        if (dev->persist->pci_status == MLX4_PCI_STATUS_ENABLED) {
+                pci_disable_device(pdev);
+                dev->persist->pci_status = MLX4_PCI_STATUS_DISABLED;
+        }
+        mutex_unlock(&dev->persist->pci_status_mutex);
+}
+
 static int mlx4_load_one(struct pci_dev *pdev, int pci_dev_data,
                          int total_vfs, int *nvfs, struct mlx4_priv *priv,
                          int reset_flow)
@@ -3582,7 +3610,7 @@ static int __mlx4_init_one(struct pci_dev *pdev, int pci_dev_data,
 
         pr_info(DRV_NAME ": Initializing %s\n", pci_name(pdev));
 
-        err = pci_enable_device(pdev);
+        err = mlx4_pci_enable_device(&priv->dev);
         if (err) {
                 dev_err(&pdev->dev, "Cannot enable PCI device, aborting\n");
                 return err;
@@ -3715,7 +3743,7 @@ err_release_regions:
         pci_release_regions(pdev);
 
 err_disable_pdev:
-        pci_disable_device(pdev);
+        mlx4_pci_disable_device(&priv->dev);
         pci_set_drvdata(pdev, NULL);
         return err;
 }
@@ -3775,6 +3803,7 @@ static int mlx4_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
         priv->pci_dev_data = id->driver_data;
         mutex_init(&dev->persist->device_state_mutex);
         mutex_init(&dev->persist->interface_state_mutex);
+        mutex_init(&dev->persist->pci_status_mutex);
 
         ret = devlink_register(devlink, &pdev->dev);
         if (ret)
@@ -3923,7 +3952,7 @@ static void mlx4_remove_one(struct pci_dev *pdev)
         }
 
         pci_release_regions(pdev);
-        pci_disable_device(pdev);
+        mlx4_pci_disable_device(dev);
         devlink_unregister(devlink);
         kfree(dev->persist);
         devlink_free(devlink);
@@ -4042,7 +4071,7 @@ static pci_ers_result_t mlx4_pci_err_detected(struct pci_dev *pdev,
         if (state == pci_channel_io_perm_failure)
                 return PCI_ERS_RESULT_DISCONNECT;
 
-        pci_disable_device(pdev);
+        mlx4_pci_disable_device(persist->dev);
         return PCI_ERS_RESULT_NEED_RESET;
 }
 
@@ -4050,45 +4079,53 @@ static pci_ers_result_t mlx4_pci_slot_reset(struct pci_dev *pdev)
 {
         struct mlx4_dev_persistent *persist = pci_get_drvdata(pdev);
         struct mlx4_dev  *dev  = persist->dev;
-        struct mlx4_priv *priv = mlx4_priv(dev);
-        int               ret;
-        int nvfs[MLX4_MAX_PORTS + 1] = {0, 0, 0};
-        int total_vfs;
+        int err;
 
         mlx4_err(dev, "mlx4_pci_slot_reset was called\n");
-        ret = pci_enable_device(pdev);
-        if (ret) {
-                mlx4_err(dev, "Can not re-enable device, ret=%d\n", ret);
+        err = mlx4_pci_enable_device(dev);
+        if (err) {
+                mlx4_err(dev, "Can not re-enable device, err=%d\n", err);
                 return PCI_ERS_RESULT_DISCONNECT;
         }
 
         pci_set_master(pdev);
         pci_restore_state(pdev);
         pci_save_state(pdev);
+        return PCI_ERS_RESULT_RECOVERED;
+}
 
+static void mlx4_pci_resume(struct pci_dev *pdev)
+{
+        struct mlx4_dev_persistent *persist = pci_get_drvdata(pdev);
+        struct mlx4_dev  *dev  = persist->dev;
+        struct mlx4_priv *priv = mlx4_priv(dev);
+        int nvfs[MLX4_MAX_PORTS + 1] = {0, 0, 0};
+        int total_vfs;
+        int err;
+
+        mlx4_err(dev, "%s was called\n", __func__);
         total_vfs = dev->persist->num_vfs;
         memcpy(nvfs, dev->persist->nvfs, sizeof(dev->persist->nvfs));
 
         mutex_lock(&persist->interface_state_mutex);
         if (!(persist->interface_state & MLX4_INTERFACE_STATE_UP)) {
-                ret = mlx4_load_one(pdev, priv->pci_dev_data, total_vfs, nvfs,
+                err = mlx4_load_one(pdev, priv->pci_dev_data, total_vfs, nvfs,
                                     priv, 1);
-                if (ret) {
-                        mlx4_err(dev, "%s: mlx4_load_one failed, ret=%d\n",
-                                 __func__,  ret);
+                if (err) {
+                        mlx4_err(dev, "%s: mlx4_load_one failed, err=%d\n",
+                                 __func__,  err);
                         goto end;
                 }
 
-                ret = restore_current_port_types(dev, dev->persist->
+                err = restore_current_port_types(dev, dev->persist->
                                                  curr_port_type, dev->persist->
                                                  curr_port_poss_type);
-                if (ret)
-                        mlx4_err(dev, "could not restore original port types (%d)\n", ret);
+                if (err)
+                        mlx4_err(dev, "could not restore original port types (%d)\n", err);
         }
 end:
         mutex_unlock(&persist->interface_state_mutex);
 
-        return ret ? PCI_ERS_RESULT_DISCONNECT : PCI_ERS_RESULT_RECOVERED;
 }
 
 static void mlx4_shutdown(struct pci_dev *pdev)
@@ -4105,6 +4142,7 @@ static void mlx4_shutdown(struct pci_dev *pdev)
 static const struct pci_error_handlers mlx4_err_handler = {
         .error_detected = mlx4_pci_err_detected,
         .slot_reset     = mlx4_pci_slot_reset,
+        .resume         = mlx4_pci_resume,
 };
 
 static struct pci_driver mlx4_driver = {
diff --git a/drivers/net/ethernet/mellanox/mlx4/mlx4.h b/drivers/net/ethernet/mellanox/mlx4/mlx4.h
index ef9683101ead..c9d7fc5159f2 100644
--- a/drivers/net/ethernet/mellanox/mlx4/mlx4.h
+++ b/drivers/net/ethernet/mellanox/mlx4/mlx4.h
@@ -586,6 +586,8 @@ struct mlx4_mfunc_master_ctx {
         struct mlx4_master_qp0_state qp0_state[MLX4_MAX_PORTS + 1];
         int                     init_port_ref[MLX4_MAX_PORTS + 1];
         u16                     max_mtu[MLX4_MAX_PORTS + 1];
+        u8                      pptx;
+        u8                      pprx;
         int                     disable_mcast_ref[MLX4_MAX_PORTS + 1];
         struct mlx4_resource_tracker res_tracker;
         struct workqueue_struct *comm_wq;
diff --git a/drivers/net/ethernet/mellanox/mlx4/mlx4_en.h b/drivers/net/ethernet/mellanox/mlx4/mlx4_en.h
index d12ab6a73344..63b1aeae2c03 100644
--- a/drivers/net/ethernet/mellanox/mlx4/mlx4_en.h
+++ b/drivers/net/ethernet/mellanox/mlx4/mlx4_en.h
@@ -323,6 +323,7 @@ struct mlx4_en_rx_ring {
         unsigned long csum_ok;
         unsigned long csum_none;
         unsigned long csum_complete;
+        unsigned long dropped;
         int hwtstamp_rx_filter;
         cpumask_var_t affinity_mask;
 };
diff --git a/drivers/net/ethernet/mellanox/mlx4/port.c b/drivers/net/ethernet/mellanox/mlx4/port.c
index 211c65087997..087b23b320cb 100644
--- a/drivers/net/ethernet/mellanox/mlx4/port.c
+++ b/drivers/net/ethernet/mellanox/mlx4/port.c
@@ -1317,6 +1317,19 @@ static int mlx4_common_set_port(struct mlx4_dev *dev, int slave, u32 in_mod,
                         }
 
                         gen_context->mtu = cpu_to_be16(master->max_mtu[port]);
+                        /* Slave cannot change Global Pause configuration */
+                        if (slave != mlx4_master_func_num(dev) &&
+                            ((gen_context->pptx != master->pptx) ||
+                             (gen_context->pprx != master->pprx))) {
+                                gen_context->pptx = master->pptx;
+                                gen_context->pprx = master->pprx;
+                                mlx4_warn(dev,
+                                          "denying Global Pause change for slave:%d\n",
+                                          slave);
+                        } else {
+                                master->pptx = gen_context->pptx;
+                                master->pprx = gen_context->pprx;
+                        }
                         break;
                 case MLX4_SET_PORT_GID_TABLE:
                         /* change to MULTIPLE entries: number of guest's gids
diff --git a/drivers/net/ethernet/mellanox/mlx5/core/Kconfig b/drivers/net/ethernet/mellanox/mlx5/core/Kconfig
index 1cf722eba607..559d11a443bc 100644
--- a/drivers/net/ethernet/mellanox/mlx5/core/Kconfig
+++ b/drivers/net/ethernet/mellanox/mlx5/core/Kconfig
@@ -14,6 +14,7 @@ config MLX5_CORE_EN
         bool "Mellanox Technologies ConnectX-4 Ethernet support"
         depends on NETDEVICES && ETHERNET && PCI && MLX5_CORE
         select PTP_1588_CLOCK
+        select VXLAN if MLX5_CORE=y
         default n
         ---help---
           Ethernet support in Mellanox Technologies ConnectX-4 NIC.
diff --git a/drivers/net/ethernet/mellanox/mlx5/core/en.h b/drivers/net/ethernet/mellanox/mlx5/core/en.h
index 879e6276c473..3881dce0cc30 100644
--- a/drivers/net/ethernet/mellanox/mlx5/core/en.h
+++ b/drivers/net/ethernet/mellanox/mlx5/core/en.h
@@ -567,6 +567,7 @@ struct mlx5e_priv {
         struct mlx5e_vxlan_db      vxlan;
 
         struct mlx5e_params        params;
+        struct workqueue_struct    *wq;
         struct work_struct         update_carrier_work;
         struct work_struct         set_rx_mode_work;
         struct delayed_work        update_stats_work;
@@ -609,7 +610,7 @@ enum mlx5e_link_mode {
         MLX5E_100GBASE_KR4       = 22,
         MLX5E_100GBASE_LR4       = 23,
         MLX5E_100BASE_TX         = 24,
-        MLX5E_100BASE_T          = 25,
+        MLX5E_1000BASE_T         = 25,
         MLX5E_10GBASE_T          = 26,
         MLX5E_25GBASE_CR         = 27,
         MLX5E_25GBASE_KR         = 28,
diff --git a/drivers/net/ethernet/mellanox/mlx5/core/en_ethtool.c b/drivers/net/ethernet/mellanox/mlx5/core/en_ethtool.c
index 68834b715f6c..3476ab844634 100644
--- a/drivers/net/ethernet/mellanox/mlx5/core/en_ethtool.c
+++ b/drivers/net/ethernet/mellanox/mlx5/core/en_ethtool.c
@@ -138,10 +138,10 @@ static const struct {
         [MLX5E_100BASE_TX]   = {
                 .speed      = 100,
         },
-        [MLX5E_100BASE_T]    = {
-                .supported  = SUPPORTED_100baseT_Full,
-                .advertised = ADVERTISED_100baseT_Full,
-                .speed      = 100,
+        [MLX5E_1000BASE_T]    = {
+                .supported  = SUPPORTED_1000baseT_Full,
+                .advertised = ADVERTISED_1000baseT_Full,
+                .speed      = 1000,
         },
         [MLX5E_10GBASE_T]    = {
                 .supported  = SUPPORTED_10000baseT_Full,
diff --git a/drivers/net/ethernet/mellanox/mlx5/core/en_main.c b/drivers/net/ethernet/mellanox/mlx5/core/en_main.c
index e0adb604f461..d4dfc5ce516a 100644
--- a/drivers/net/ethernet/mellanox/mlx5/core/en_main.c
+++ b/drivers/net/ethernet/mellanox/mlx5/core/en_main.c
@@ -262,9 +262,8 @@ static void mlx5e_update_stats_work(struct work_struct *work)
         mutex_lock(&priv->state_lock);
         if (test_bit(MLX5E_STATE_OPENED, &priv->state)) {
                 mlx5e_update_stats(priv);
-                schedule_delayed_work(dwork,
-                                      msecs_to_jiffies(
-                                              MLX5E_UPDATE_STATS_INTERVAL));
+                queue_delayed_work(priv->wq, dwork,
+                                   msecs_to_jiffies(MLX5E_UPDATE_STATS_INTERVAL));
         }
         mutex_unlock(&priv->state_lock);
 }
@@ -280,7 +279,7 @@ static void mlx5e_async_event(struct mlx5_core_dev *mdev, void *vpriv,
         switch (event) {
         case MLX5_DEV_EVENT_PORT_UP:
         case MLX5_DEV_EVENT_PORT_DOWN:
-                schedule_work(&priv->update_carrier_work);
+                queue_work(priv->wq, &priv->update_carrier_work);
                 break;
 
         default:
@@ -1404,24 +1403,50 @@ static int mlx5e_refresh_tirs_self_loopback_enable(struct mlx5e_priv *priv)
         return 0;
 }
 
-static int mlx5e_set_dev_port_mtu(struct net_device *netdev)
+static int mlx5e_set_mtu(struct mlx5e_priv *priv, u16 mtu)
 {
-        struct mlx5e_priv *priv = netdev_priv(netdev);
         struct mlx5_core_dev *mdev = priv->mdev;
-        int hw_mtu;
+        u16 hw_mtu = MLX5E_SW2HW_MTU(mtu);
         int err;
 
-        err = mlx5_set_port_mtu(mdev, MLX5E_SW2HW_MTU(netdev->mtu), 1);
+        err = mlx5_set_port_mtu(mdev, hw_mtu, 1);
         if (err)
                 return err;
 
-        mlx5_query_port_oper_mtu(mdev, &hw_mtu, 1);
+        /* Update vport context MTU */
+        mlx5_modify_nic_vport_mtu(mdev, hw_mtu);
+        return 0;
+}
+
+static void mlx5e_query_mtu(struct mlx5e_priv *priv, u16 *mtu)
+{
+        struct mlx5_core_dev *mdev = priv->mdev;
+        u16 hw_mtu = 0;
+        int err;
 
-        if (MLX5E_HW2SW_MTU(hw_mtu) != netdev->mtu)
-                netdev_warn(netdev, "%s: Port MTU %d is different than netdev mtu %d\n",
-                            __func__, MLX5E_HW2SW_MTU(hw_mtu), netdev->mtu);
+        err = mlx5_query_nic_vport_mtu(mdev, &hw_mtu);
+        if (err || !hw_mtu) /* fallback to port oper mtu */
+                mlx5_query_port_oper_mtu(mdev, &hw_mtu, 1);
+
+        *mtu = MLX5E_HW2SW_MTU(hw_mtu);
+}
+
+static int mlx5e_set_dev_port_mtu(struct net_device *netdev)
+{
+        struct mlx5e_priv *priv = netdev_priv(netdev);
+        u16 mtu;
+        int err;
 
-        netdev->mtu = MLX5E_HW2SW_MTU(hw_mtu);
+        err = mlx5e_set_mtu(priv, netdev->mtu);
+        if (err)
+                return err;
+
+        mlx5e_query_mtu(priv, &mtu);
+        if (mtu != netdev->mtu)
+                netdev_warn(netdev, "%s: VPort MTU %d is different than netdev mtu %d\n",
+                            __func__, mtu, netdev->mtu);
+
+        netdev->mtu = mtu;
         return 0;
 }
 
@@ -1479,7 +1504,7 @@ int mlx5e_open_locked(struct net_device *netdev)
         mlx5e_update_carrier(priv);
         mlx5e_timestamp_init(priv);
 
-        schedule_delayed_work(&priv->update_stats_work, 0);
+        queue_delayed_work(priv->wq, &priv->update_stats_work, 0);
 
         return 0;
 
@@ -1935,7 +1960,7 @@ static void mlx5e_set_rx_mode(struct net_device *dev)
 {
         struct mlx5e_priv *priv = netdev_priv(dev);
 
-        schedule_work(&priv->set_rx_mode_work);
+        queue_work(priv->wq, &priv->set_rx_mode_work);
 }
 
 static int mlx5e_set_mac(struct net_device *netdev, void *addr)
@@ -1950,7 +1975,7 @@ static int mlx5e_set_mac(struct net_device *netdev, void *addr)
         ether_addr_copy(netdev->dev_addr, saddr->sa_data);
         netif_addr_unlock_bh(netdev);
 
-        schedule_work(&priv->set_rx_mode_work);
+        queue_work(priv->wq, &priv->set_rx_mode_work);
 
         return 0;
 }
@@ -1999,22 +2024,27 @@ static int mlx5e_set_features(struct net_device *netdev,
         return err;
 }
 
+#define MXL5_HW_MIN_MTU 64
+#define MXL5E_MIN_MTU (MXL5_HW_MIN_MTU + ETH_FCS_LEN)
+
 static int mlx5e_change_mtu(struct net_device *netdev, int new_mtu)
 {
         struct mlx5e_priv *priv = netdev_priv(netdev);
         struct mlx5_core_dev *mdev = priv->mdev;
         bool was_opened;
-        int max_mtu;
+        u16 max_mtu;
+        u16 min_mtu;
         int err = 0;
 
         mlx5_query_port_max_mtu(mdev, &max_mtu, 1);
 
         max_mtu = MLX5E_HW2SW_MTU(max_mtu);
+        min_mtu = MLX5E_HW2SW_MTU(MXL5E_MIN_MTU);
 
-        if (new_mtu > max_mtu) {
+        if (new_mtu > max_mtu || new_mtu < min_mtu) {
                 netdev_err(netdev,
-                           "%s: Bad MTU (%d) > (%d) Max\n",
-                           __func__, new_mtu, max_mtu);
+                           "%s: Bad MTU (%d), valid range is: [%d..%d]\n",
+                           __func__, new_mtu, min_mtu, max_mtu);
                 return -EINVAL;
         }
 
@@ -2127,7 +2157,7 @@ static void mlx5e_add_vxlan_port(struct net_device *netdev,
         if (!mlx5e_vxlan_allowed(priv->mdev))
                 return;
 
-        mlx5e_vxlan_add_port(priv, be16_to_cpu(port));
+        mlx5e_vxlan_queue_work(priv, sa_family, be16_to_cpu(port), 1);
 }
 
 static void mlx5e_del_vxlan_port(struct net_device *netdev,
@@ -2138,7 +2168,7 @@ static void mlx5e_del_vxlan_port(struct net_device *netdev,
         if (!mlx5e_vxlan_allowed(priv->mdev))
                 return;
 
-        mlx5e_vxlan_del_port(priv, be16_to_cpu(port));
+        mlx5e_vxlan_queue_work(priv, sa_family, be16_to_cpu(port), 0);
 }
 
 static netdev_features_t mlx5e_vxlan_features_check(struct mlx5e_priv *priv,
@@ -2467,10 +2497,14 @@ static void *mlx5e_create_netdev(struct mlx5_core_dev *mdev)
 
         priv = netdev_priv(netdev);
 
+        priv->wq = create_singlethread_workqueue("mlx5e");
+        if (!priv->wq)
+                goto err_free_netdev;
+
         err = mlx5_alloc_map_uar(mdev, &priv->cq_uar, false);
         if (err) {
                 mlx5_core_err(mdev, "alloc_map uar failed, %d\n", err);
-                goto err_free_netdev;
+                goto err_destroy_wq;
         }
 
         err = mlx5_core_alloc_pd(mdev, &priv->pdn);
@@ -2549,7 +2583,7 @@ static void *mlx5e_create_netdev(struct mlx5_core_dev *mdev)
                 vxlan_get_rx_port(netdev);
 
         mlx5e_enable_async_events(priv);
-        schedule_work(&priv->set_rx_mode_work);
+        queue_work(priv->wq, &priv->set_rx_mode_work);
 
         return priv;
 
@@ -2586,6 +2620,9 @@ err_dealloc_pd:
 err_unmap_free_uar:
         mlx5_unmap_free_uar(mdev, &priv->cq_uar);
 
+err_destroy_wq:
+        destroy_workqueue(priv->wq);
+
 err_free_netdev:
         free_netdev(netdev);
 
@@ -2599,10 +2636,19 @@ static void mlx5e_destroy_netdev(struct mlx5_core_dev *mdev, void *vpriv)
 
         set_bit(MLX5E_STATE_DESTROYING, &priv->state);
 
-        schedule_work(&priv->set_rx_mode_work);
+        queue_work(priv->wq, &priv->set_rx_mode_work);
         mlx5e_disable_async_events(priv);
-        flush_scheduled_work();
-        unregister_netdev(netdev);
+        flush_workqueue(priv->wq);
+        if (test_bit(MLX5_INTERFACE_STATE_SHUTDOWN, &mdev->intf_state)) {
+                netif_device_detach(netdev);
+                mutex_lock(&priv->state_lock);
+                if (test_bit(MLX5E_STATE_OPENED, &priv->state))
+                        mlx5e_close_locked(netdev);
+                mutex_unlock(&priv->state_lock);
+        } else {
+                unregister_netdev(netdev);
+        }
+
         mlx5e_tc_cleanup(priv);
         mlx5e_vxlan_cleanup(priv);
         mlx5e_destroy_flow_tables(priv);
@@ -2615,7 +2661,11 @@ static void mlx5e_destroy_netdev(struct mlx5_core_dev *mdev, void *vpriv)
         mlx5_core_dealloc_transport_domain(priv->mdev, priv->tdn);
         mlx5_core_dealloc_pd(priv->mdev, priv->pdn);
         mlx5_unmap_free_uar(priv->mdev, &priv->cq_uar);
-        free_netdev(netdev);
+        cancel_delayed_work_sync(&priv->update_stats_work);
+        destroy_workqueue(priv->wq);
+
+        if (!test_bit(MLX5_INTERFACE_STATE_SHUTDOWN, &mdev->intf_state))
+                free_netdev(netdev);
 }
 
 static void *mlx5e_get_netdev(void *vpriv)
diff --git a/drivers/net/ethernet/mellanox/mlx5/core/fs_core.c b/drivers/net/ethernet/mellanox/mlx5/core/fs_core.c
index 5121be4675d1..89cce97d46c6 100644
--- a/drivers/net/ethernet/mellanox/mlx5/core/fs_core.c
+++ b/drivers/net/ethernet/mellanox/mlx5/core/fs_core.c
@@ -1065,33 +1065,6 @@ unlock_fg:
         return rule;
 }
 
-static struct mlx5_flow_rule *add_rule_to_auto_fg(struct mlx5_flow_table *ft,
-                                                  u8 match_criteria_enable,
-                                                  u32 *match_criteria,
-                                                  u32 *match_value,
-                                                  u8 action,
-                                                  u32 flow_tag,
-                                                  struct mlx5_flow_destination *dest)
-{
-        struct mlx5_flow_rule *rule;
-        struct mlx5_flow_group *g;
-
-        g = create_autogroup(ft, match_criteria_enable, match_criteria);
-        if (IS_ERR(g))
-                return (void *)g;
-
-        rule = add_rule_fg(g, match_value,
-                           action, flow_tag, dest);
-        if (IS_ERR(rule)) {
-                /* Remove assumes refcount > 0 and autogroup creates a group
-                 * with a refcount = 0.
-                 */
-                tree_get_node(&g->node);
-                tree_remove_node(&g->node);
-        }
-        return rule;
-}
-
 static struct mlx5_flow_rule *
 _mlx5_add_flow_rule(struct mlx5_flow_table *ft,
                     u8 match_criteria_enable,
@@ -1119,8 +1092,23 @@ _mlx5_add_flow_rule(struct mlx5_flow_table *ft,
                                 goto unlock;
                 }
 
-        rule = add_rule_to_auto_fg(ft, match_criteria_enable, match_criteria,
-                                   match_value, action, flow_tag, dest);
+        g = create_autogroup(ft, match_criteria_enable, match_criteria);
+        if (IS_ERR(g)) {
+                rule = (void *)g;
+                goto unlock;
+        }
+
+        rule = add_rule_fg(g, match_value,
+                           action, flow_tag, dest);
+        if (IS_ERR(rule)) {
+                /* Remove assumes refcount > 0 and autogroup creates a group
+                 * with a refcount = 0.
+                 */
+                unlock_ref_node(&ft->node);
+                tree_get_node(&g->node);
+                tree_remove_node(&g->node);
+                return rule;
+        }
 unlock:
         unlock_ref_node(&ft->node);
         return rule;
@@ -1288,7 +1276,7 @@ struct mlx5_flow_namespace *mlx5_get_flow_namespace(struct mlx5_core_dev *dev,
 {
         struct mlx5_flow_root_namespace *root_ns = dev->priv.root_ns;
         int prio;
-        static struct fs_prio *fs_prio;
+        struct fs_prio *fs_prio;
         struct mlx5_flow_namespace *ns;
 
         if (!root_ns)
diff --git a/drivers/net/ethernet/mellanox/mlx5/core/main.c b/drivers/net/ethernet/mellanox/mlx5/core/main.c
index 3f3b2fae4991..6892746fd10d 100644
--- a/drivers/net/ethernet/mellanox/mlx5/core/main.c
+++ b/drivers/net/ethernet/mellanox/mlx5/core/main.c
@@ -966,7 +966,7 @@ static int mlx5_load_one(struct mlx5_core_dev *dev, struct mlx5_priv *priv)
         int err;
 
         mutex_lock(&dev->intf_state_mutex);
-        if (dev->interface_state == MLX5_INTERFACE_STATE_UP) {
+        if (test_bit(MLX5_INTERFACE_STATE_UP, &dev->intf_state)) {
                 dev_warn(&dev->pdev->dev, "%s: interface is up, NOP\n",
                          __func__);
                 goto out;
@@ -1133,7 +1133,8 @@ static int mlx5_load_one(struct mlx5_core_dev *dev, struct mlx5_priv *priv)
         if (err)
                 pr_info("failed request module on %s\n", MLX5_IB_MOD);
 
-        dev->interface_state = MLX5_INTERFACE_STATE_UP;
+        clear_bit(MLX5_INTERFACE_STATE_DOWN, &dev->intf_state);
+        set_bit(MLX5_INTERFACE_STATE_UP, &dev->intf_state);
 out:
         mutex_unlock(&dev->intf_state_mutex);
 
@@ -1207,7 +1208,7 @@ static int mlx5_unload_one(struct mlx5_core_dev *dev, struct mlx5_priv *priv)
         }
 
         mutex_lock(&dev->intf_state_mutex);
-        if (dev->interface_state == MLX5_INTERFACE_STATE_DOWN) {
+        if (test_bit(MLX5_INTERFACE_STATE_DOWN, &dev->intf_state)) {
                 dev_warn(&dev->pdev->dev, "%s: interface is down, NOP\n",
                          __func__);
                 goto out;
@@ -1241,7 +1242,8 @@ static int mlx5_unload_one(struct mlx5_core_dev *dev, struct mlx5_priv *priv)
         mlx5_cmd_cleanup(dev);
 
 out:
-        dev->interface_state = MLX5_INTERFACE_STATE_DOWN;
+        clear_bit(MLX5_INTERFACE_STATE_UP, &dev->intf_state);
+        set_bit(MLX5_INTERFACE_STATE_DOWN, &dev->intf_state);
         mutex_unlock(&dev->intf_state_mutex);
         return err;
 }
@@ -1452,6 +1454,18 @@ static const struct pci_error_handlers mlx5_err_handler = {
         .resume         = mlx5_pci_resume
 };
 
+static void shutdown(struct pci_dev *pdev)
+{
+        struct mlx5_core_dev *dev  = pci_get_drvdata(pdev);
+        struct mlx5_priv *priv = &dev->priv;
+
+        dev_info(&pdev->dev, "Shutdown was called\n");
+        /* Notify mlx5 clients that the kernel is being shut down */
+        set_bit(MLX5_INTERFACE_STATE_SHUTDOWN, &dev->intf_state);
+        mlx5_unload_one(dev, priv);
+        mlx5_pci_disable_device(dev);
+}
+
 static const struct pci_device_id mlx5_core_pci_table[] = {
         { PCI_VDEVICE(MELLANOX, 0x1011) },                      /* Connect-IB */
         { PCI_VDEVICE(MELLANOX, 0x1012), MLX5_PCI_DEV_IS_VF},   /* Connect-IB VF */
@@ -1459,6 +1473,8 @@ static const struct pci_device_id mlx5_core_pci_table[] = {
         { PCI_VDEVICE(MELLANOX, 0x1014), MLX5_PCI_DEV_IS_VF},   /* ConnectX-4 VF */
         { PCI_VDEVICE(MELLANOX, 0x1015) },                      /* ConnectX-4LX */
         { PCI_VDEVICE(MELLANOX, 0x1016), MLX5_PCI_DEV_IS_VF},   /* ConnectX-4LX VF */
+        { PCI_VDEVICE(MELLANOX, 0x1017) },                      /* ConnectX-5 */
+        { PCI_VDEVICE(MELLANOX, 0x1018), MLX5_PCI_DEV_IS_VF},   /* ConnectX-5 VF */
         { 0, }
 };
 
@@ -1469,6 +1485,7 @@ static struct pci_driver mlx5_core_driver = {
         .id_table       = mlx5_core_pci_table,
         .probe          = init_one,
         .remove         = remove_one,
+        .shutdown       = shutdown,
         .err_handler    = &mlx5_err_handler,
         .sriov_configure   = mlx5_core_sriov_configure,
 };
diff --git a/drivers/net/ethernet/mellanox/mlx5/core/port.c b/drivers/net/ethernet/mellanox/mlx5/core/port.c
index ae378c575deb..53cc1e2c693b 100644
--- a/drivers/net/ethernet/mellanox/mlx5/core/port.c
+++ b/drivers/net/ethernet/mellanox/mlx5/core/port.c
@@ -247,8 +247,8 @@ int mlx5_query_port_admin_status(struct mlx5_core_dev *dev,
 }
 EXPORT_SYMBOL_GPL(mlx5_query_port_admin_status);
 
-static void mlx5_query_port_mtu(struct mlx5_core_dev *dev, int *admin_mtu,
-                                int *max_mtu, int *oper_mtu, u8 port)
+static void mlx5_query_port_mtu(struct mlx5_core_dev *dev, u16 *admin_mtu,
+                                u16 *max_mtu, u16 *oper_mtu, u8 port)
 {
         u32 in[MLX5_ST_SZ_DW(pmtu_reg)];
         u32 out[MLX5_ST_SZ_DW(pmtu_reg)];
@@ -268,7 +268,7 @@ static void mlx5_query_port_mtu(struct mlx5_core_dev *dev, int *admin_mtu,
                 *admin_mtu = MLX5_GET(pmtu_reg, out, admin_mtu);
 }
 
-int mlx5_set_port_mtu(struct mlx5_core_dev *dev, int mtu, u8 port)
+int mlx5_set_port_mtu(struct mlx5_core_dev *dev, u16 mtu, u8 port)
 {
         u32 in[MLX5_ST_SZ_DW(pmtu_reg)];
         u32 out[MLX5_ST_SZ_DW(pmtu_reg)];
@@ -283,14 +283,14 @@ int mlx5_set_port_mtu(struct mlx5_core_dev *dev, int mtu, u8 port)
 }
 EXPORT_SYMBOL_GPL(mlx5_set_port_mtu);
 
-void mlx5_query_port_max_mtu(struct mlx5_core_dev *dev, int *max_mtu,
+void mlx5_query_port_max_mtu(struct mlx5_core_dev *dev, u16 *max_mtu,
                              u8 port)
 {
         mlx5_query_port_mtu(dev, NULL, max_mtu, NULL, port);
 }
 EXPORT_SYMBOL_GPL(mlx5_query_port_max_mtu);
 
-void mlx5_query_port_oper_mtu(struct mlx5_core_dev *dev, int *oper_mtu,
+void mlx5_query_port_oper_mtu(struct mlx5_core_dev *dev, u16 *oper_mtu,
                               u8 port)
 {
         mlx5_query_port_mtu(dev, NULL, NULL, oper_mtu, port);
diff --git a/drivers/net/ethernet/mellanox/mlx5/core/uar.c b/drivers/net/ethernet/mellanox/mlx5/core/uar.c
index 8ba080e441a1..5ff8af472bf5 100644
--- a/drivers/net/ethernet/mellanox/mlx5/core/uar.c
+++ b/drivers/net/ethernet/mellanox/mlx5/core/uar.c
@@ -269,8 +269,10 @@ EXPORT_SYMBOL(mlx5_alloc_map_uar);
 
 void mlx5_unmap_free_uar(struct mlx5_core_dev *mdev, struct mlx5_uar *uar)
 {
-        iounmap(uar->map);
-        iounmap(uar->bf_map);
+        if (uar->map)
+                iounmap(uar->map);
+        else
+                iounmap(uar->bf_map);
         mlx5_cmd_free_uar(mdev, uar->index);
 }
 EXPORT_SYMBOL(mlx5_unmap_free_uar);
diff --git a/drivers/net/ethernet/mellanox/mlx5/core/vport.c b/drivers/net/ethernet/mellanox/mlx5/core/vport.c
index bd518405859e..b69dadcfb897 100644
--- a/drivers/net/ethernet/mellanox/mlx5/core/vport.c
+++ b/drivers/net/ethernet/mellanox/mlx5/core/vport.c
@@ -196,6 +196,46 @@ int mlx5_modify_nic_vport_mac_address(struct mlx5_core_dev *mdev,
 }
 EXPORT_SYMBOL_GPL(mlx5_modify_nic_vport_mac_address);
 
+int mlx5_query_nic_vport_mtu(struct mlx5_core_dev *mdev, u16 *mtu)
+{
+        int outlen = MLX5_ST_SZ_BYTES(query_nic_vport_context_out);
+        u32 *out;
+        int err;
+
+        out = mlx5_vzalloc(outlen);
+        if (!out)
+                return -ENOMEM;
+
+        err = mlx5_query_nic_vport_context(mdev, 0, out, outlen);
+        if (!err)
+                *mtu = MLX5_GET(query_nic_vport_context_out, out,
+                                nic_vport_context.mtu);
+
+        kvfree(out);
+        return err;
+}
+EXPORT_SYMBOL_GPL(mlx5_query_nic_vport_mtu);
+
+int mlx5_modify_nic_vport_mtu(struct mlx5_core_dev *mdev, u16 mtu)
+{
+        int inlen = MLX5_ST_SZ_BYTES(modify_nic_vport_context_in);
+        void *in;
+        int err;
+
+        in = mlx5_vzalloc(inlen);
+        if (!in)
+                return -ENOMEM;
+
+        MLX5_SET(modify_nic_vport_context_in, in, field_select.mtu, 1);
+        MLX5_SET(modify_nic_vport_context_in, in, nic_vport_context.mtu, mtu);
+
+        err = mlx5_modify_nic_vport_context(mdev, in, inlen);
+
+        kvfree(in);
+        return err;
+}
+EXPORT_SYMBOL_GPL(mlx5_modify_nic_vport_mtu);
+
 int mlx5_query_nic_vport_mac_list(struct mlx5_core_dev *dev,
                                   u32 vport,
                                   enum mlx5_list_type list_type,
diff --git a/drivers/net/ethernet/mellanox/mlx5/core/vxlan.c b/drivers/net/ethernet/mellanox/mlx5/core/vxlan.c
index 9f10df25f3cd..f2fd1ef16da7 100644
--- a/drivers/net/ethernet/mellanox/mlx5/core/vxlan.c
+++ b/drivers/net/ethernet/mellanox/mlx5/core/vxlan.c
@@ -95,21 +95,22 @@ struct mlx5e_vxlan *mlx5e_vxlan_lookup_port(struct mlx5e_priv *priv, u16 port)
         return vxlan;
 }
 
-int mlx5e_vxlan_add_port(struct mlx5e_priv *priv, u16 port)
+static void mlx5e_vxlan_add_port(struct work_struct *work)
 {
+        struct mlx5e_vxlan_work *vxlan_work =
+                container_of(work, struct mlx5e_vxlan_work, work);
+        struct mlx5e_priv *priv = vxlan_work->priv;
         struct mlx5e_vxlan_db *vxlan_db = &priv->vxlan;
+        u16 port = vxlan_work->port;
         struct mlx5e_vxlan *vxlan;
         int err;
 
-        err = mlx5e_vxlan_core_add_port_cmd(priv->mdev, port);
-        if (err)
-                return err;
+        if (mlx5e_vxlan_core_add_port_cmd(priv->mdev, port))
+                goto free_work;
 
         vxlan = kzalloc(sizeof(*vxlan), GFP_KERNEL);
-        if (!vxlan) {
-                err = -ENOMEM;
+        if (!vxlan)
                 goto err_delete_port;
-        }
 
         vxlan->udp_port = port;
 
@@ -119,13 +120,14 @@ int mlx5e_vxlan_add_port(struct mlx5e_priv *priv, u16 port)
         if (err)
                 goto err_free;
 
-        return 0;
+        goto free_work;
 
 err_free:
         kfree(vxlan);
 err_delete_port:
         mlx5e_vxlan_core_del_port_cmd(priv->mdev, port);
-        return err;
+free_work:
+        kfree(vxlan_work);
 }
 
 static void __mlx5e_vxlan_core_del_port(struct mlx5e_priv *priv, u16 port)
@@ -145,12 +147,36 @@ static void __mlx5e_vxlan_core_del_port(struct mlx5e_priv *priv, u16 port)
         kfree(vxlan);
 }
 
-void mlx5e_vxlan_del_port(struct mlx5e_priv *priv, u16 port)
+static void mlx5e_vxlan_del_port(struct work_struct *work)
 {
-        if (!mlx5e_vxlan_lookup_port(priv, port))
-                return;
+        struct mlx5e_vxlan_work *vxlan_work =
+                container_of(work, struct mlx5e_vxlan_work, work);
+        struct mlx5e_priv *priv = vxlan_work->priv;
+        u16 port = vxlan_work->port;
 
         __mlx5e_vxlan_core_del_port(priv, port);
+
+        kfree(vxlan_work);
+}
+
+void mlx5e_vxlan_queue_work(struct mlx5e_priv *priv, sa_family_t sa_family,
+                            u16 port, int add)
+{
+        struct mlx5e_vxlan_work *vxlan_work;
+
+        vxlan_work = kmalloc(sizeof(*vxlan_work), GFP_ATOMIC);
+        if (!vxlan_work)
+                return;
+
+        if (add)
+                INIT_WORK(&vxlan_work->work, mlx5e_vxlan_add_port);
+        else
+                INIT_WORK(&vxlan_work->work, mlx5e_vxlan_del_port);
+
+        vxlan_work->priv = priv;
+        vxlan_work->port = port;
+        vxlan_work->sa_family = sa_family;
+        queue_work(priv->wq, &vxlan_work->work);
 }
 
 void mlx5e_vxlan_cleanup(struct mlx5e_priv *priv)
diff --git a/drivers/net/ethernet/mellanox/mlx5/core/vxlan.h b/drivers/net/ethernet/mellanox/mlx5/core/vxlan.h
index a01685056ab1..129f3527aa14 100644
--- a/drivers/net/ethernet/mellanox/mlx5/core/vxlan.h
+++ b/drivers/net/ethernet/mellanox/mlx5/core/vxlan.h
@@ -39,6 +39,13 @@ struct mlx5e_vxlan {
         u16 udp_port;
 };
 
+struct mlx5e_vxlan_work {
+        struct work_struct      work;
+        struct mlx5e_priv       *priv;
+        sa_family_t             sa_family;
+        u16                     port;
+};
+
 static inline bool mlx5e_vxlan_allowed(struct mlx5_core_dev *mdev)
 {
         return (MLX5_CAP_ETH(mdev, tunnel_stateless_vxlan) &&
@@ -46,8 +53,8 @@ static inline bool mlx5e_vxlan_allowed(struct mlx5_core_dev *mdev)
 }
 
 void mlx5e_vxlan_init(struct mlx5e_priv *priv);
-int  mlx5e_vxlan_add_port(struct mlx5e_priv *priv, u16 port);
-void mlx5e_vxlan_del_port(struct mlx5e_priv *priv, u16 port);
+void mlx5e_vxlan_queue_work(struct mlx5e_priv *priv, sa_family_t sa_family,
+                            u16 port, int add);
 struct mlx5e_vxlan *mlx5e_vxlan_lookup_port(struct mlx5e_priv *priv, u16 port);
 void mlx5e_vxlan_cleanup(struct mlx5e_priv *priv);
 
diff --git a/drivers/net/ethernet/myricom/myri10ge/myri10ge.c b/drivers/net/ethernet/myricom/myri10ge/myri10ge.c
index 270c9eeb7ab6..6d1a956e3f77 100644
--- a/drivers/net/ethernet/myricom/myri10ge/myri10ge.c
+++ b/drivers/net/ethernet/myricom/myri10ge/myri10ge.c
@@ -2668,9 +2668,9 @@ static int myri10ge_close(struct net_device *dev)
 
         del_timer_sync(&mgp->watchdog_timer);
         mgp->running = MYRI10GE_ETH_STOPPING;
-        local_bh_disable(); /* myri10ge_ss_lock_napi needs bh disabled */
         for (i = 0; i < mgp->num_slices; i++) {
                 napi_disable(&mgp->ss[i].napi);
+                local_bh_disable(); /* myri10ge_ss_lock_napi needs this */
                 /* Lock the slice to prevent the busy_poll handler from
                  * accessing it.  Later when we bring the NIC up, myri10ge_open
                  * resets the slice including this lock.
@@ -2679,8 +2679,8 @@ static int myri10ge_close(struct net_device *dev)
                         pr_info("Slice %d locked\n", i);
                         mdelay(1);
                 }
+                local_bh_enable();
         }
-        local_bh_enable();
         netif_carrier_off(dev);
 
         netif_tx_stop_all_queues(dev);
diff --git a/drivers/net/ethernet/qlogic/qed/qed_int.c b/drivers/net/ethernet/qlogic/qed/qed_int.c
index ffd0accc2ec9..2017b0121f5f 100644
--- a/drivers/net/ethernet/qlogic/qed/qed_int.c
+++ b/drivers/net/ethernet/qlogic/qed/qed_int.c
@@ -2750,7 +2750,7 @@ void qed_int_igu_enable_int(struct qed_hwfn *p_hwfn,
 int qed_int_igu_enable(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt,
                        enum qed_int_mode int_mode)
 {
-        int rc;
+        int rc = 0;
 
         /* Configure AEU signal change to produce attentions */
         qed_wr(p_hwfn, p_ptt, IGU_REG_ATTENTION_ENABLE, 0);
diff --git a/drivers/net/ethernet/qlogic/qede/qede_main.c b/drivers/net/ethernet/qlogic/qede/qede_main.c
index 518af329502d..7869465435fa 100644
--- a/drivers/net/ethernet/qlogic/qede/qede_main.c
+++ b/drivers/net/ethernet/qlogic/qede/qede_main.c
@@ -750,6 +750,12 @@ static bool qede_has_tx_work(struct qede_fastpath *fp)
         return false;
 }
 
+static inline void qede_rx_bd_ring_consume(struct qede_rx_queue *rxq)
+{
+        qed_chain_consume(&rxq->rx_bd_ring);
+        rxq->sw_rx_cons++;
+}
+
 /* This function reuses the buffer(from an offset) from
  * consumer index to producer index in the bd ring
  */
@@ -773,6 +779,21 @@ static inline void qede_reuse_page(struct qede_dev *edev,
         curr_cons->data = NULL;
 }
 
+/* In case of allocation failures reuse buffers
+ * from consumer index to produce buffers for firmware
+ */
+static void qede_recycle_rx_bd_ring(struct qede_rx_queue *rxq,
+                                    struct qede_dev *edev, u8 count)
+{
+        struct sw_rx_data *curr_cons;
+
+        for (; count > 0; count--) {
+                curr_cons = &rxq->sw_rx_ring[rxq->sw_rx_cons & NUM_RX_BDS_MAX];
+                qede_reuse_page(edev, rxq, curr_cons);
+                qede_rx_bd_ring_consume(rxq);
+        }
+}
+
 static inline int qede_realloc_rx_buffer(struct qede_dev *edev,
                                          struct qede_rx_queue *rxq,
                                          struct sw_rx_data *curr_cons)
@@ -781,8 +802,14 @@ static inline int qede_realloc_rx_buffer(struct qede_dev *edev,
         curr_cons->page_offset += rxq->rx_buf_seg_size;
 
         if (curr_cons->page_offset == PAGE_SIZE) {
-                if (unlikely(qede_alloc_rx_buffer(edev, rxq)))
+                if (unlikely(qede_alloc_rx_buffer(edev, rxq))) {
+                        /* Since we failed to allocate new buffer
+                         * current buffer can be used again.
+                         */
+                        curr_cons->page_offset -= rxq->rx_buf_seg_size;
+
                         return -ENOMEM;
+                }
 
                 dma_unmap_page(&edev->pdev->dev, curr_cons->mapping,
                                PAGE_SIZE, DMA_FROM_DEVICE);
@@ -901,7 +928,10 @@ static int qede_fill_frag_skb(struct qede_dev *edev,
                            len_on_bd);
 
         if (unlikely(qede_realloc_rx_buffer(edev, rxq, current_bd))) {
-                tpa_info->agg_state = QEDE_AGG_STATE_ERROR;
+                /* Incr page ref count to reuse on allocation failure
+                 * so that it doesn't get freed while freeing SKB.
+                 */
+                atomic_inc(&current_bd->data->_count);
                 goto out;
         }
 
@@ -915,6 +945,8 @@ static int qede_fill_frag_skb(struct qede_dev *edev,
         return 0;
 
 out:
+        tpa_info->agg_state = QEDE_AGG_STATE_ERROR;
+        qede_recycle_rx_bd_ring(rxq, edev, 1);
         return -ENOMEM;
 }
 
@@ -966,8 +998,9 @@ static void qede_tpa_start(struct qede_dev *edev,
         tpa_info->skb = netdev_alloc_skb(edev->ndev,
                                          le16_to_cpu(cqe->len_on_first_bd));
         if (unlikely(!tpa_info->skb)) {
+                DP_NOTICE(edev, "Failed to allocate SKB for gro\n");
                 tpa_info->agg_state = QEDE_AGG_STATE_ERROR;
-                return;
+                goto cons_buf;
         }
 
         skb_put(tpa_info->skb, le16_to_cpu(cqe->len_on_first_bd));
@@ -990,6 +1023,7 @@ static void qede_tpa_start(struct qede_dev *edev,
         /* This is needed in order to enable forwarding support */
         qede_set_gro_params(edev, tpa_info->skb, cqe);
 
+cons_buf: /* We still need to handle bd_len_list to consume buffers */
         if (likely(cqe->ext_bd_len_list[0]))
                 qede_fill_frag_skb(edev, rxq, cqe->tpa_agg_index,
                                    le16_to_cpu(cqe->ext_bd_len_list[0]));
@@ -1007,7 +1041,6 @@ static void qede_gro_ip_csum(struct sk_buff *skb)
         const struct iphdr *iph = ip_hdr(skb);
         struct tcphdr *th;
 
-        skb_set_network_header(skb, 0);
         skb_set_transport_header(skb, sizeof(struct iphdr));
         th = tcp_hdr(skb);
 
@@ -1022,7 +1055,6 @@ static void qede_gro_ipv6_csum(struct sk_buff *skb)
         struct ipv6hdr *iph = ipv6_hdr(skb);
         struct tcphdr *th;
 
-        skb_set_network_header(skb, 0);
         skb_set_transport_header(skb, sizeof(struct ipv6hdr));
         th = tcp_hdr(skb);
 
@@ -1037,8 +1069,21 @@ static void qede_gro_receive(struct qede_dev *edev,
                              struct sk_buff *skb,
                              u16 vlan_tag)
 {
+        /* FW can send a single MTU sized packet from gro flow
+         * due to aggregation timeout/last segment etc. which
+         * is not expected to be a gro packet. If a skb has zero
+         * frags then simply push it in the stack as non gso skb.
+         */
+        if (unlikely(!skb->data_len)) {
+                skb_shinfo(skb)->gso_type = 0;
+                skb_shinfo(skb)->gso_size = 0;
+                goto send_skb;
+        }
+
 #ifdef CONFIG_INET
         if (skb_shinfo(skb)->gso_size) {
+                skb_set_network_header(skb, 0);
+
                 switch (skb->protocol) {
                 case htons(ETH_P_IP):
                         qede_gro_ip_csum(skb);
@@ -1053,6 +1098,8 @@ static void qede_gro_receive(struct qede_dev *edev,
                 }
         }
 #endif
+
+send_skb:
         skb_record_rx_queue(skb, fp->rss_id);
         qede_skb_receive(edev, fp, skb, vlan_tag);
 }
@@ -1244,17 +1291,17 @@ static int qede_rx_int(struct qede_fastpath *fp, int budget)
                                   "CQE in CONS = %u has error, flags = %x, dropping incoming packet\n",
                                   sw_comp_cons, parse_flag);
                         rxq->rx_hw_errors++;
-                        qede_reuse_page(edev, rxq, sw_rx_data);
-                        goto next_rx;
+                        qede_recycle_rx_bd_ring(rxq, edev, fp_cqe->bd_num);
+                        goto next_cqe;
                 }
 
                 skb = netdev_alloc_skb(edev->ndev, QEDE_RX_HDR_SIZE);
                 if (unlikely(!skb)) {
                         DP_NOTICE(edev,
                                   "Build_skb failed, dropping incoming packet\n");
-                        qede_reuse_page(edev, rxq, sw_rx_data);
+                        qede_recycle_rx_bd_ring(rxq, edev, fp_cqe->bd_num);
                         rxq->rx_alloc_errors++;
-                        goto next_rx;
+                        goto next_cqe;
                 }
 
                 /* Copy data into SKB */
@@ -1288,11 +1335,22 @@ static int qede_rx_int(struct qede_fastpath *fp, int budget)
                         if (unlikely(qede_realloc_rx_buffer(edev, rxq,
                                                             sw_rx_data))) {
                                 DP_ERR(edev, "Failed to allocate rx buffer\n");
+                                /* Incr page ref count to reuse on allocation
+                                 * failure so that it doesn't get freed while
+                                 * freeing SKB.
+                                 */
+
+                                atomic_inc(&sw_rx_data->data->_count);
                                 rxq->rx_alloc_errors++;
+                                qede_recycle_rx_bd_ring(rxq, edev,
+                                                        fp_cqe->bd_num);
+                                dev_kfree_skb_any(skb);
                                 goto next_cqe;
                         }
                 }
 
+                qede_rx_bd_ring_consume(rxq);
+
                 if (fp_cqe->bd_num != 1) {
                         u16 pkt_len = le16_to_cpu(fp_cqe->pkt_len);
                         u8 num_frags;
@@ -1303,18 +1361,27 @@ static int qede_rx_int(struct qede_fastpath *fp, int budget)
                              num_frags--) {
                                 u16 cur_size = pkt_len > rxq->rx_buf_size ?
                                                 rxq->rx_buf_size : pkt_len;
+                                if (unlikely(!cur_size)) {
+                                        DP_ERR(edev,
+                                               "Still got %d BDs for mapping jumbo, but length became 0\n",
+                                               num_frags);
+                                        qede_recycle_rx_bd_ring(rxq, edev,
+                                                                num_frags);
+                                        dev_kfree_skb_any(skb);
+                                        goto next_cqe;
+                                }
 
-                                WARN_ONCE(!cur_size,
-                                          "Still got %d BDs for mapping jumbo, but length became 0\n",
-                                          num_frags);
-
-                                if (unlikely(qede_alloc_rx_buffer(edev, rxq)))
+                                if (unlikely(qede_alloc_rx_buffer(edev, rxq))) {
+                                        qede_recycle_rx_bd_ring(rxq, edev,
+                                                                num_frags);
+                                        dev_kfree_skb_any(skb);
                                         goto next_cqe;
+                                }
 
-                                rxq->sw_rx_cons++;
                                 sw_rx_index = rxq->sw_rx_cons & NUM_RX_BDS_MAX;
                                 sw_rx_data = &rxq->sw_rx_ring[sw_rx_index];
-                                qed_chain_consume(&rxq->rx_bd_ring);
+                                qede_rx_bd_ring_consume(rxq);
+
                                 dma_unmap_page(&edev->pdev->dev,
                                                sw_rx_data->mapping,
                                                PAGE_SIZE, DMA_FROM_DEVICE);
@@ -1330,7 +1397,7 @@ static int qede_rx_int(struct qede_fastpath *fp, int budget)
                                 pkt_len -= cur_size;
                         }
 
-                        if (pkt_len)
+                        if (unlikely(pkt_len))
                                 DP_ERR(edev,
                                        "Mapped all BDs of jumbo, but still have %d bytes\n",
                                        pkt_len);
@@ -1349,10 +1416,6 @@ static int qede_rx_int(struct qede_fastpath *fp, int budget)
                 skb_record_rx_queue(skb, fp->rss_id);
 
                 qede_skb_receive(edev, fp, skb, le16_to_cpu(fp_cqe->vlan_tag));
-
-                qed_chain_consume(&rxq->rx_bd_ring);
-next_rx:
-                rxq->sw_rx_cons++;
 next_rx_only:
                 rx_pkt++;
 
@@ -2257,7 +2320,7 @@ static void qede_free_sge_mem(struct qede_dev *edev,
                 struct qede_agg_info *tpa_info = &rxq->tpa_info[i];
                 struct sw_rx_data *replace_buf = &tpa_info->replace_buf;
 
-                if (replace_buf) {
+                if (replace_buf->data) {
                         dma_unmap_page(&edev->pdev->dev,
                                        dma_unmap_addr(replace_buf, mapping),
                                        PAGE_SIZE, DMA_FROM_DEVICE);
@@ -2377,7 +2440,7 @@ err:
 static int qede_alloc_mem_rxq(struct qede_dev *edev,
                               struct qede_rx_queue *rxq)
 {
-        int i, rc, size, num_allocated;
+        int i, rc, size;
 
         rxq->num_rx_buffers = edev->q_num_rx_buffers;
 
@@ -2394,6 +2457,7 @@ static int qede_alloc_mem_rxq(struct qede_dev *edev,
         rxq->sw_rx_ring = kzalloc(size, GFP_KERNEL);
         if (!rxq->sw_rx_ring) {
                 DP_ERR(edev, "Rx buffers ring allocation failed\n");
+                rc = -ENOMEM;
                 goto err;
         }
 
@@ -2421,26 +2485,16 @@ static int qede_alloc_mem_rxq(struct qede_dev *edev,
         /* Allocate buffers for the Rx ring */
         for (i = 0; i < rxq->num_rx_buffers; i++) {
                 rc = qede_alloc_rx_buffer(edev, rxq);
-                if (rc)
-                        break;
-        }
-        num_allocated = i;
-        if (!num_allocated) {
-                DP_ERR(edev, "Rx buffers allocation failed\n");
-                goto err;
-        } else if (num_allocated < rxq->num_rx_buffers) {
-                DP_NOTICE(edev,
-                          "Allocated less buffers than desired (%d allocated)\n",
-                          num_allocated);
+                if (rc) {
+                        DP_ERR(edev,
+                               "Rx buffers allocation failed at index %d\n", i);
+                        goto err;
+                }
         }
 
-        qede_alloc_sge_mem(edev, rxq);
-
-        return 0;
-
+        rc = qede_alloc_sge_mem(edev, rxq);
 err:
-        qede_free_mem_rxq(edev, rxq);
-        return -ENOMEM;
+        return rc;
 }
 
 static void qede_free_mem_txq(struct qede_dev *edev,
@@ -2523,10 +2577,8 @@ static int qede_alloc_mem_fp(struct qede_dev *edev,
         }
 
         return 0;
-
 err:
-        qede_free_mem_fp(edev, fp);
-        return -ENOMEM;
+        return rc;
 }
 
 static void qede_free_mem_load(struct qede_dev *edev)
@@ -2549,22 +2601,13 @@ static int qede_alloc_mem_load(struct qede_dev *edev)
                 struct qede_fastpath *fp = &edev->fp_array[rss_id];
 
                 rc = qede_alloc_mem_fp(edev, fp);
-                if (rc)
-                        break;
-        }
-
-        if (rss_id != QEDE_RSS_CNT(edev)) {
-                /* Failed allocating memory for all the queues */
-                if (!rss_id) {
+                if (rc) {
                         DP_ERR(edev,
-                               "Failed to allocate memory for the leading queue\n");
-                        rc = -ENOMEM;
-                } else {
-                        DP_NOTICE(edev,
-                                  "Failed to allocate memory for all of RSS queues\n Desired: %d queues, allocated: %d queues\n",
-                                  QEDE_RSS_CNT(edev), rss_id);
+                               "Failed to allocate memory for fastpath - rss id = %d\n",
+                               rss_id);
+                        qede_free_mem_load(edev);
+                        return rc;
                 }
-                edev->num_rss = rss_id;
         }
 
         return 0;
diff --git a/drivers/net/ethernet/qlogic/qlcnic/qlcnic.h b/drivers/net/ethernet/qlogic/qlcnic/qlcnic.h
index 55007f1e6bbc..caf6ddb7ea76 100644
--- a/drivers/net/ethernet/qlogic/qlcnic/qlcnic.h
+++ b/drivers/net/ethernet/qlogic/qlcnic/qlcnic.h
@@ -37,8 +37,8 @@
 
 #define _QLCNIC_LINUX_MAJOR 5
 #define _QLCNIC_LINUX_MINOR 3
-#define _QLCNIC_LINUX_SUBVERSION 63
-#define QLCNIC_LINUX_VERSIONID  "5.3.63"
+#define _QLCNIC_LINUX_SUBVERSION 64
+#define QLCNIC_LINUX_VERSIONID  "5.3.64"
 #define QLCNIC_DRV_IDC_VER  0x01
 #define QLCNIC_DRIVER_VERSION  ((_QLCNIC_LINUX_MAJOR << 16) |\
                  (_QLCNIC_LINUX_MINOR << 8) | (_QLCNIC_LINUX_SUBVERSION))
diff --git a/drivers/net/ethernet/qlogic/qlge/qlge.h b/drivers/net/ethernet/qlogic/qlge/qlge.h
index ef332708e5f2..6d31f92ef2b6 100644
--- a/drivers/net/ethernet/qlogic/qlge/qlge.h
+++ b/drivers/net/ethernet/qlogic/qlge/qlge.h
@@ -18,7 +18,7 @@
  */
 #define DRV_NAME        "qlge"
 #define DRV_STRING      "QLogic 10 Gigabit PCI-E Ethernet Driver "
-#define DRV_VERSION     "1.00.00.34"
+#define DRV_VERSION     "1.00.00.35"
 
 #define WQ_ADDR_ALIGN   0x3     /* 4 byte alignment */
 
diff --git a/drivers/net/ethernet/renesas/ravb_main.c b/drivers/net/ethernet/renesas/ravb_main.c
index 4e1a7dba7c4a..9e2a0bd8f5a8 100644
--- a/drivers/net/ethernet/renesas/ravb_main.c
+++ b/drivers/net/ethernet/renesas/ravb_main.c
@@ -1377,11 +1377,11 @@ static netdev_tx_t ravb_start_xmit(struct sk_buff *skb, struct net_device *ndev)
 
                 /* TAG and timestamp required flag */
                 skb_shinfo(skb)->tx_flags |= SKBTX_IN_PROGRESS;
-                skb_tx_timestamp(skb);
                 desc->tagh_tsr = (ts_skb->tag >> 4) | TX_TSR;
                 desc->ds_tagl |= le16_to_cpu(ts_skb->tag << 12);
         }
 
+        skb_tx_timestamp(skb);
         /* Descriptor type must be set after all the above writes */
         dma_wmb();
         desc->die_dt = DT_FEND;
@@ -1691,6 +1691,9 @@ static int ravb_set_gti(struct net_device *ndev)
         rate = clk_get_rate(clk);
         clk_put(clk);
 
+        if (!rate)
+                return -EINVAL;
+
         inc = 1000000000ULL << 20;
         do_div(inc, rate);
 
diff --git a/drivers/net/ethernet/renesas/sh_eth.c b/drivers/net/ethernet/renesas/sh_eth.c
index 004e2d7560fd..ceea74cc2229 100644
--- a/drivers/net/ethernet/renesas/sh_eth.c
+++ b/drivers/net/ethernet/renesas/sh_eth.c
@@ -2194,17 +2194,13 @@ static int sh_eth_set_ringparam(struct net_device *ndev,
                                    __func__);
                         return ret;
                 }
-                ret = sh_eth_dev_init(ndev, false);
+                ret = sh_eth_dev_init(ndev, true);
                 if (ret < 0) {
                         netdev_err(ndev, "%s: sh_eth_dev_init failed.\n",
                                    __func__);
                         return ret;
                 }
 
-                mdp->irq_enabled = true;
-                sh_eth_write(ndev, mdp->cd->eesipr_value, EESIPR);
-                /* Setting the Rx mode will start the Rx process. */
-                sh_eth_write(ndev, EDRRR_R, EDRRR);
                 netif_device_attach(ndev);
         }
 
diff --git a/drivers/net/ethernet/samsung/sxgbe/sxgbe_platform.c b/drivers/net/ethernet/samsung/sxgbe/sxgbe_platform.c
index b02eed12bfc5..73427e29df2a 100644
--- a/drivers/net/ethernet/samsung/sxgbe/sxgbe_platform.c
+++ b/drivers/net/ethernet/samsung/sxgbe/sxgbe_platform.c
@@ -155,11 +155,11 @@ static int sxgbe_platform_probe(struct platform_device *pdev)
         return 0;
 
 err_rx_irq_unmap:
-        while (--i)
+        while (i--)
                 irq_dispose_mapping(priv->rxq[i]->irq_no);
         i = SXGBE_TX_QUEUES;
 err_tx_irq_unmap:
-        while (--i)
+        while (i--)
                 irq_dispose_mapping(priv->txq[i]->irq_no);
         irq_dispose_mapping(priv->irq);
 err_drv_remove:
diff --git a/drivers/net/ethernet/sfc/ef10.c b/drivers/net/ethernet/sfc/ef10.c
index 98d33d462c6c..1681084cc96f 100644
--- a/drivers/net/ethernet/sfc/ef10.c
+++ b/drivers/net/ethernet/sfc/ef10.c
@@ -1920,6 +1920,10 @@ static int efx_ef10_alloc_rss_context(struct efx_nic *efx, u32 *context,
                 return 0;
         }
 
+        if (nic_data->datapath_caps &
+            1 << MC_CMD_GET_CAPABILITIES_OUT_RX_RSS_LIMITED_LBN)
+                return -EOPNOTSUPP;
+
         MCDI_SET_DWORD(inbuf, RSS_CONTEXT_ALLOC_IN_UPSTREAM_PORT_ID,
                        nic_data->vport_id);
         MCDI_SET_DWORD(inbuf, RSS_CONTEXT_ALLOC_IN_TYPE, alloc_type);
@@ -2923,9 +2927,16 @@ static void efx_ef10_filter_push_prep(struct efx_nic *efx,
                                       bool replacing)
 {
         struct efx_ef10_nic_data *nic_data = efx->nic_data;
+        u32 flags = spec->flags;
 
         memset(inbuf, 0, MC_CMD_FILTER_OP_IN_LEN);
 
+        /* Remove RSS flag if we don't have an RSS context. */
+        if (flags & EFX_FILTER_FLAG_RX_RSS &&
+            spec->rss_context == EFX_FILTER_RSS_CONTEXT_DEFAULT &&
+            nic_data->rx_rss_context == EFX_EF10_RSS_CONTEXT_INVALID)
+                flags &= ~EFX_FILTER_FLAG_RX_RSS;
+
         if (replacing) {
                 MCDI_SET_DWORD(inbuf, FILTER_OP_IN_OP,
                                MC_CMD_FILTER_OP_IN_OP_REPLACE);
@@ -2985,10 +2996,10 @@ static void efx_ef10_filter_push_prep(struct efx_nic *efx,
                        spec->dmaq_id == EFX_FILTER_RX_DMAQ_ID_DROP ?
                        0 : spec->dmaq_id);
         MCDI_SET_DWORD(inbuf, FILTER_OP_IN_RX_MODE,
-                       (spec->flags & EFX_FILTER_FLAG_RX_RSS) ?
+                       (flags & EFX_FILTER_FLAG_RX_RSS) ?
                        MC_CMD_FILTER_OP_IN_RX_MODE_RSS :
                        MC_CMD_FILTER_OP_IN_RX_MODE_SIMPLE);
-        if (spec->flags & EFX_FILTER_FLAG_RX_RSS)
+        if (flags & EFX_FILTER_FLAG_RX_RSS)
                 MCDI_SET_DWORD(inbuf, FILTER_OP_IN_RX_CONTEXT,
                                spec->rss_context !=
                                EFX_FILTER_RSS_CONTEXT_DEFAULT ?
diff --git a/drivers/net/ethernet/stmicro/stmmac/dwmac-socfpga.c b/drivers/net/ethernet/stmicro/stmmac/dwmac-socfpga.c
index f0d797ab74d8..afb90d129cb6 100644
--- a/drivers/net/ethernet/stmicro/stmmac/dwmac-socfpga.c
+++ b/drivers/net/ethernet/stmicro/stmmac/dwmac-socfpga.c
@@ -34,6 +34,9 @@
 #define SYSMGR_EMACGRP_CTRL_PHYSEL_MASK 0x00000003
 #define SYSMGR_EMACGRP_CTRL_PTP_REF_CLK_MASK 0x00000010
 
+#define SYSMGR_FPGAGRP_MODULE_REG  0x00000028
+#define SYSMGR_FPGAGRP_MODULE_EMAC 0x00000004
+
 #define EMAC_SPLITTER_CTRL_REG                  0x0
 #define EMAC_SPLITTER_CTRL_SPEED_MASK           0x3
 #define EMAC_SPLITTER_CTRL_SPEED_10             0x2
@@ -46,7 +49,6 @@ struct socfpga_dwmac {
         u32     reg_shift;
         struct  device *dev;
         struct regmap *sys_mgr_base_addr;
-        struct reset_control *stmmac_rst;
         void __iomem *splitter_base;
         bool f2h_ptp_ref_clk;
 };
@@ -89,15 +91,6 @@ static int socfpga_dwmac_parse_data(struct socfpga_dwmac *dwmac, struct device *
         struct device_node *np_splitter;
         struct resource res_splitter;
 
-        dwmac->stmmac_rst = devm_reset_control_get(dev,
-                                                  STMMAC_RESOURCE_NAME);
-        if (IS_ERR(dwmac->stmmac_rst)) {
-                dev_info(dev, "Could not get reset control!\n");
-                if (PTR_ERR(dwmac->stmmac_rst) == -EPROBE_DEFER)
-                        return -EPROBE_DEFER;
-                dwmac->stmmac_rst = NULL;
-        }
-
         dwmac->interface = of_get_phy_mode(np);
 
         sys_mgr_base_addr = syscon_regmap_lookup_by_phandle(np, "altr,sysmgr-syscon");
@@ -148,7 +141,7 @@ static int socfpga_dwmac_setup(struct socfpga_dwmac *dwmac)
         int phymode = dwmac->interface;
         u32 reg_offset = dwmac->reg_offset;
         u32 reg_shift = dwmac->reg_shift;
-        u32 ctrl, val;
+        u32 ctrl, val, module;
 
         switch (phymode) {
         case PHY_INTERFACE_MODE_RGMII:
@@ -175,39 +168,39 @@ static int socfpga_dwmac_setup(struct socfpga_dwmac *dwmac)
         ctrl &= ~(SYSMGR_EMACGRP_CTRL_PHYSEL_MASK << reg_shift);
         ctrl |= val << reg_shift;
 
-        if (dwmac->f2h_ptp_ref_clk)
+        if (dwmac->f2h_ptp_ref_clk) {
                 ctrl |= SYSMGR_EMACGRP_CTRL_PTP_REF_CLK_MASK << (reg_shift / 2);
-        else
+                regmap_read(sys_mgr_base_addr, SYSMGR_FPGAGRP_MODULE_REG,
+                            &module);
+                module |= (SYSMGR_FPGAGRP_MODULE_EMAC << (reg_shift / 2));
+                regmap_write(sys_mgr_base_addr, SYSMGR_FPGAGRP_MODULE_REG,
+                             module);
+        } else {
                 ctrl &= ~(SYSMGR_EMACGRP_CTRL_PTP_REF_CLK_MASK << (reg_shift / 2));
+        }
 
         regmap_write(sys_mgr_base_addr, reg_offset, ctrl);
-        return 0;
-}
-
-static void socfpga_dwmac_exit(struct platform_device *pdev, void *priv)
-{
-        struct socfpga_dwmac    *dwmac = priv;
 
-        /* On socfpga platform exit, assert and hold reset to the
-         * enet controller - the default state after a hard reset.
-         */
-        if (dwmac->stmmac_rst)
-                reset_control_assert(dwmac->stmmac_rst);
+        return 0;
 }
 
 static int socfpga_dwmac_init(struct platform_device *pdev, void *priv)
 {
-        struct socfpga_dwmac    *dwmac = priv;
+        struct socfpga_dwmac *dwmac = priv;
         struct net_device *ndev = platform_get_drvdata(pdev);
         struct stmmac_priv *stpriv = NULL;
         int ret = 0;
 
-        if (ndev)
-                stpriv = netdev_priv(ndev);
+        if (!ndev)
+                return -EINVAL;
+
+        stpriv = netdev_priv(ndev);
+        if (!stpriv)
+                return -EINVAL;
 
         /* Assert reset to the enet controller before changing the phy mode */
-        if (dwmac->stmmac_rst)
-                reset_control_assert(dwmac->stmmac_rst);
+        if (stpriv->stmmac_rst)
+                reset_control_assert(stpriv->stmmac_rst);
 
         /* Setup the phy mode in the system manager registers according to
          * devicetree configuration
@@ -217,8 +210,8 @@ static int socfpga_dwmac_init(struct platform_device *pdev, void *priv)
         /* Deassert reset for the phy configuration to be sampled by
          * the enet controller, and operation to start in requested mode
          */
-        if (dwmac->stmmac_rst)
-                reset_control_deassert(dwmac->stmmac_rst);
+        if (stpriv->stmmac_rst)
+                reset_control_deassert(stpriv->stmmac_rst);
 
         /* Before the enet controller is suspended, the phy is suspended.
          * This causes the phy clock to be gated. The enet controller is
@@ -235,7 +228,7 @@ static int socfpga_dwmac_init(struct platform_device *pdev, void *priv)
          * control register 0, and can be modified by the phy driver
          * framework.
          */
-        if (stpriv && stpriv->phydev)
+        if (stpriv->phydev)
                 phy_resume(stpriv->phydev);
 
         return ret;
@@ -275,14 +268,13 @@ static int socfpga_dwmac_probe(struct platform_device *pdev)
 
         plat_dat->bsp_priv = dwmac;
         plat_dat->init = socfpga_dwmac_init;
-        plat_dat->exit = socfpga_dwmac_exit;
         plat_dat->fix_mac_speed = socfpga_dwmac_fix_mac_speed;
 
-        ret = socfpga_dwmac_init(pdev, plat_dat->bsp_priv);
-        if (ret)
-                return ret;
+        ret = stmmac_dvr_probe(&pdev->dev, plat_dat, &stmmac_res);
+        if (!ret)
+                ret = socfpga_dwmac_init(pdev, dwmac);
 
-        return stmmac_dvr_probe(&pdev->dev, plat_dat, &stmmac_res);
+        return ret;
 }
 
 static const struct of_device_id socfpga_dwmac_match[] = {
diff --git a/drivers/net/ethernet/stmicro/stmmac/norm_desc.c b/drivers/net/ethernet/stmicro/stmmac/norm_desc.c
index e13228f115f0..011386f6f24d 100644
--- a/drivers/net/ethernet/stmicro/stmmac/norm_desc.c
+++ b/drivers/net/ethernet/stmicro/stmmac/norm_desc.c
@@ -199,11 +199,6 @@ static void ndesc_prepare_tx_desc(struct dma_desc *p, int is_fs, int len,
 {
         unsigned int tdes1 = p->des1;
 
-        if (mode == STMMAC_CHAIN_MODE)
-                norm_set_tx_desc_len_on_chain(p, len);
-        else
-                norm_set_tx_desc_len_on_ring(p, len);
-
         if (is_fs)
                 tdes1 |= TDES1_FIRST_SEGMENT;
         else
@@ -217,10 +212,15 @@ static void ndesc_prepare_tx_desc(struct dma_desc *p, int is_fs, int len,
         if (ls)
                 tdes1 |= TDES1_LAST_SEGMENT;
 
-        if (tx_own)
-                tdes1 |= TDES0_OWN;
-
         p->des1 = tdes1;
+
+        if (mode == STMMAC_CHAIN_MODE)
+                norm_set_tx_desc_len_on_chain(p, len);
+        else
+                norm_set_tx_desc_len_on_ring(p, len);
+
+        if (tx_own)
+                p->des0 |= TDES0_OWN;
 }
 
 static void ndesc_set_tx_ic(struct dma_desc *p)
diff --git a/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c b/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c
index 4c5ce9848ca9..fcbd4be562e2 100644
--- a/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c
+++ b/drivers/net/ethernet/stmicro/stmmac/stmmac_main.c
@@ -278,7 +278,6 @@ static void stmmac_eee_ctrl_timer(unsigned long arg)
  */
 bool stmmac_eee_init(struct stmmac_priv *priv)
 {
-        char *phy_bus_name = priv->plat->phy_bus_name;
         unsigned long flags;
         bool ret = false;
 
@@ -289,10 +288,6 @@ bool stmmac_eee_init(struct stmmac_priv *priv)
             (priv->pcs == STMMAC_PCS_RTBI))
                 goto out;
 
-        /* Never init EEE in case of a switch is attached */
-        if (phy_bus_name && (!strcmp(phy_bus_name, "fixed")))
-                goto out;
-
         /* MAC core supports the EEE feature. */
         if (priv->dma_cap.eee) {
                 int tx_lpi_timer = priv->tx_lpi_timer;
@@ -772,10 +767,16 @@ static void stmmac_adjust_link(struct net_device *dev)
 
         spin_unlock_irqrestore(&priv->lock, flags);
 
-        /* At this stage, it could be needed to setup the EEE or adjust some
-         * MAC related HW registers.
-         */
-        priv->eee_enabled = stmmac_eee_init(priv);
+        if (phydev->is_pseudo_fixed_link)
+                /* Stop PHY layer to call the hook to adjust the link in case
+                 * of a switch is attached to the stmmac driver.
+                 */
+                phydev->irq = PHY_IGNORE_INTERRUPT;
+        else
+                /* At this stage, init the EEE if supported.
+                 * Never called in case of fixed_link.
+                 */
+                priv->eee_enabled = stmmac_eee_init(priv);
 }
 
 /**
@@ -827,12 +828,8 @@ static int stmmac_init_phy(struct net_device *dev)
                 phydev = of_phy_connect(dev, priv->plat->phy_node,
                                         &stmmac_adjust_link, 0, interface);
         } else {
-                if (priv->plat->phy_bus_name)
-                        snprintf(bus_id, MII_BUS_ID_SIZE, "%s-%x",
-                                 priv->plat->phy_bus_name, priv->plat->bus_id);
-                else
-                        snprintf(bus_id, MII_BUS_ID_SIZE, "stmmac-%x",
-                                 priv->plat->bus_id);
+                snprintf(bus_id, MII_BUS_ID_SIZE, "stmmac-%x",
+                         priv->plat->bus_id);
 
                 snprintf(phy_id_fmt, MII_BUS_ID_SIZE + 3, PHY_ID_FMT, bus_id,
                          priv->plat->phy_addr);
@@ -870,11 +867,6 @@ static int stmmac_init_phy(struct net_device *dev)
                 return -ENODEV;
         }
 
-        /* If attached to a switch, there is no reason to poll phy handler */
-        if (priv->plat->phy_bus_name)
-                if (!strcmp(priv->plat->phy_bus_name, "fixed"))
-                        phydev->irq = PHY_IGNORE_INTERRUPT;
-
         pr_debug("stmmac_init_phy:  %s: attached to PHY (UID 0x%x)"
                  " Link = %d\n", dev->name, phydev->phy_id, phydev->link);
 
diff --git a/drivers/net/ethernet/stmicro/stmmac/stmmac_mdio.c b/drivers/net/ethernet/stmicro/stmmac/stmmac_mdio.c
index ea76129dafc2..06704ca6f9ca 100644
--- a/drivers/net/ethernet/stmicro/stmmac/stmmac_mdio.c
+++ b/drivers/net/ethernet/stmicro/stmmac/stmmac_mdio.c
@@ -198,20 +198,12 @@ int stmmac_mdio_register(struct net_device *ndev)
         struct mii_bus *new_bus;
         struct stmmac_priv *priv = netdev_priv(ndev);
         struct stmmac_mdio_bus_data *mdio_bus_data = priv->plat->mdio_bus_data;
-        int addr, found;
         struct device_node *mdio_node = priv->plat->mdio_node;
+        int addr, found;
 
         if (!mdio_bus_data)
                 return 0;
 
-        if (IS_ENABLED(CONFIG_OF)) {
-                if (mdio_node) {
-                        netdev_dbg(ndev, "FOUND MDIO subnode\n");
-                } else {
-                        netdev_warn(ndev, "No MDIO subnode found\n");
-                }
-        }
-
         new_bus = mdiobus_alloc();
         if (new_bus == NULL)
                 return -ENOMEM;
diff --git a/drivers/net/ethernet/stmicro/stmmac/stmmac_platform.c b/drivers/net/ethernet/stmicro/stmmac/stmmac_platform.c
index dcbd2a1601e8..cf37ea558ecc 100644
--- a/drivers/net/ethernet/stmicro/stmmac/stmmac_platform.c
+++ b/drivers/net/ethernet/stmicro/stmmac/stmmac_platform.c
@@ -132,6 +132,69 @@ static struct stmmac_axi *stmmac_axi_setup(struct platform_device *pdev)
 }
 
 /**
+ * stmmac_dt_phy - parse device-tree driver parameters to allocate PHY resources
+ * @plat: driver data platform structure
+ * @np: device tree node
+ * @dev: device pointer
+ * Description:
+ * The mdio bus will be allocated in case of a phy transceiver is on board;
+ * it will be NULL if the fixed-link is configured.
+ * If there is the "snps,dwmac-mdio" sub-node the mdio will be allocated
+ * in any case (for DSA, mdio must be registered even if fixed-link).
+ * The table below sums the supported configurations:
+ *      -------------------------------
+ *      snps,phy-addr   |     Y
+ *      -------------------------------
+ *      phy-handle      |     Y
+ *      -------------------------------
+ *      fixed-link      |     N
+ *      -------------------------------
+ *      snps,dwmac-mdio |
+ *        even if       |     Y
+ *      fixed-link      |
+ *      -------------------------------
+ *
+ * It returns 0 in case of success otherwise -ENODEV.
+ */
+static int stmmac_dt_phy(struct plat_stmmacenet_data *plat,
+                         struct device_node *np, struct device *dev)
+{
+        bool mdio = true;
+
+        /* If phy-handle property is passed from DT, use it as the PHY */
+        plat->phy_node = of_parse_phandle(np, "phy-handle", 0);
+        if (plat->phy_node)
+                dev_dbg(dev, "Found phy-handle subnode\n");
+
+        /* If phy-handle is not specified, check if we have a fixed-phy */
+        if (!plat->phy_node && of_phy_is_fixed_link(np)) {
+                if ((of_phy_register_fixed_link(np) < 0))
+                        return -ENODEV;
+
+                dev_dbg(dev, "Found fixed-link subnode\n");
+                plat->phy_node = of_node_get(np);
+                mdio = false;
+        }
+
+        /* If snps,dwmac-mdio is passed from DT, always register the MDIO */
+        for_each_child_of_node(np, plat->mdio_node) {
+                if (of_device_is_compatible(plat->mdio_node, "snps,dwmac-mdio"))
+                        break;
+        }
+
+        if (plat->mdio_node) {
+                dev_dbg(dev, "Found MDIO subnode\n");
+                mdio = true;
+        }
+
+        if (mdio)
+                plat->mdio_bus_data =
+                        devm_kzalloc(dev, sizeof(struct stmmac_mdio_bus_data),
+                                     GFP_KERNEL);
+        return 0;
+}
+
+/**
  * stmmac_probe_config_dt - parse device-tree driver parameters
  * @pdev: platform_device structure
  * @plat: driver data platform structure
@@ -146,7 +209,6 @@ stmmac_probe_config_dt(struct platform_device *pdev, const char **mac)
         struct device_node *np = pdev->dev.of_node;
         struct plat_stmmacenet_data *plat;
         struct stmmac_dma_cfg *dma_cfg;
-        struct device_node *child_node = NULL;
 
         plat = devm_kzalloc(&pdev->dev, sizeof(*plat), GFP_KERNEL);
         if (!plat)
@@ -166,36 +228,15 @@ stmmac_probe_config_dt(struct platform_device *pdev, const char **mac)
         /* Default to phy auto-detection */
         plat->phy_addr = -1;
 
-        /* If we find a phy-handle property, use it as the PHY */
-        plat->phy_node = of_parse_phandle(np, "phy-handle", 0);
-
-        /* If phy-handle is not specified, check if we have a fixed-phy */
-        if (!plat->phy_node && of_phy_is_fixed_link(np)) {
-                if ((of_phy_register_fixed_link(np) < 0))
-                        return ERR_PTR(-ENODEV);
-
-                plat->phy_node = of_node_get(np);
-        }
-
-        for_each_child_of_node(np, child_node)
-                if (of_device_is_compatible(child_node, "snps,dwmac-mdio")) {
-                        plat->mdio_node = child_node;
-                        break;
-                }
-
         /* "snps,phy-addr" is not a standard property. Mark it as deprecated
          * and warn of its use. Remove this when phy node support is added.
          */
         if (of_property_read_u32(np, "snps,phy-addr", &plat->phy_addr) == 0)
                 dev_warn(&pdev->dev, "snps,phy-addr property is deprecated\n");
 
-        if ((plat->phy_node && !of_phy_is_fixed_link(np)) || !plat->mdio_node)
-                plat->mdio_bus_data = NULL;
-        else
-                plat->mdio_bus_data =
-                        devm_kzalloc(&pdev->dev,
-                                     sizeof(struct stmmac_mdio_bus_data),
-                                     GFP_KERNEL);
+        /* To Configure PHY by using all device-tree supported properties */
+        if (stmmac_dt_phy(plat, np, &pdev->dev))
+                return ERR_PTR(-ENODEV);
 
         of_property_read_u32(np, "tx-fifo-depth", &plat->tx_fifo_size);
 
diff --git a/drivers/net/ethernet/ti/cpsw.c b/drivers/net/ethernet/ti/cpsw.c
index 42fdfd4d9d4f..e2fcdf1eec44 100644
--- a/drivers/net/ethernet/ti/cpsw.c
+++ b/drivers/net/ethernet/ti/cpsw.c
@@ -367,7 +367,6 @@ struct cpsw_priv {
         spinlock_t                      lock;
         struct platform_device          *pdev;
         struct net_device               *ndev;
-        struct device_node              *phy_node;
         struct napi_struct              napi_rx;
         struct napi_struct              napi_tx;
         struct device                   *dev;
@@ -1148,25 +1147,34 @@ static void cpsw_slave_open(struct cpsw_slave *slave, struct cpsw_priv *priv)
                 cpsw_ale_add_mcast(priv->ale, priv->ndev->broadcast,
                                    1 << slave_port, 0, 0, ALE_MCAST_FWD_2);
 
-        if (priv->phy_node)
-                slave->phy = of_phy_connect(priv->ndev, priv->phy_node,
+        if (slave->data->phy_node) {
+                slave->phy = of_phy_connect(priv->ndev, slave->data->phy_node,
                                  &cpsw_adjust_link, 0, slave->data->phy_if);
-        else
+                if (!slave->phy) {
+                        dev_err(priv->dev, "phy \"%s\" not found on slave %d\n",
+                                slave->data->phy_node->full_name,
+                                slave->slave_num);
+                        return;
+                }
+        } else {
                 slave->phy = phy_connect(priv->ndev, slave->data->phy_id,
                                  &cpsw_adjust_link, slave->data->phy_if);
-        if (IS_ERR(slave->phy)) {
-                dev_err(priv->dev, "phy %s not found on slave %d\n",
-                        slave->data->phy_id, slave->slave_num);
-                slave->phy = NULL;
-        } else {
-                phy_attached_info(slave->phy);
+                if (IS_ERR(slave->phy)) {
+                        dev_err(priv->dev,
+                                "phy \"%s\" not found on slave %d, err %ld\n",
+                                slave->data->phy_id, slave->slave_num,
+                                PTR_ERR(slave->phy));
+                        slave->phy = NULL;
+                        return;
+                }
+        }
 
-                phy_start(slave->phy);
+        phy_attached_info(slave->phy);
 
-                /* Configure GMII_SEL register */
-                cpsw_phy_sel(&priv->pdev->dev, slave->phy->interface,
-                             slave->slave_num);
-        }
+        phy_start(slave->phy);
+
+        /* Configure GMII_SEL register */
+        cpsw_phy_sel(&priv->pdev->dev, slave->phy->interface, slave->slave_num);
 }
 
 static inline void cpsw_add_default_vlan(struct cpsw_priv *priv)
@@ -1251,12 +1259,12 @@ static int cpsw_ndo_open(struct net_device *ndev)
         int i, ret;
         u32 reg;
 
+        pm_runtime_get_sync(&priv->pdev->dev);
+
         if (!cpsw_common_res_usage_state(priv))
                 cpsw_intr_disable(priv);
         netif_carrier_off(ndev);
 
-        pm_runtime_get_sync(&priv->pdev->dev);
-
         reg = priv->version;
 
         dev_info(priv->dev, "initializing cpsw version %d.%d (%d)\n",
@@ -1940,12 +1948,11 @@ static void cpsw_slave_init(struct cpsw_slave *slave, struct cpsw_priv *priv,
         slave->port_vlan = data->dual_emac_res_vlan;
 }
 
-static int cpsw_probe_dt(struct cpsw_priv *priv,
+static int cpsw_probe_dt(struct cpsw_platform_data *data,
                          struct platform_device *pdev)
 {
         struct device_node *node = pdev->dev.of_node;
         struct device_node *slave_node;
-        struct cpsw_platform_data *data = &priv->data;
         int i = 0, ret;
         u32 prop;
 
@@ -2033,25 +2040,21 @@ static int cpsw_probe_dt(struct cpsw_priv *priv,
                 if (strcmp(slave_node->name, "slave"))
                         continue;
 
-                priv->phy_node = of_parse_phandle(slave_node, "phy-handle", 0);
+                slave_data->phy_node = of_parse_phandle(slave_node,
+                                                        "phy-handle", 0);
                 parp = of_get_property(slave_node, "phy_id", &lenp);
-                if (of_phy_is_fixed_link(slave_node)) {
-                        struct device_node *phy_node;
-                        struct phy_device *phy_dev;
-
+                if (slave_data->phy_node) {
+                        dev_dbg(&pdev->dev,
+                                "slave[%d] using phy-handle=\"%s\"\n",
+                                i, slave_data->phy_node->full_name);
+                } else if (of_phy_is_fixed_link(slave_node)) {
                         /* In the case of a fixed PHY, the DT node associated
                          * to the PHY is the Ethernet MAC DT node.
                          */
                         ret = of_phy_register_fixed_link(slave_node);
                         if (ret)
                                 return ret;
-                        phy_node = of_node_get(slave_node);
-                        phy_dev = of_phy_find_device(phy_node);
-                        if (!phy_dev)
-                                return -ENODEV;
-                        snprintf(slave_data->phy_id, sizeof(slave_data->phy_id),
-                                 PHY_ID_FMT, phy_dev->mdio.bus->id,
-                                 phy_dev->mdio.addr);
+                        slave_data->phy_node = of_node_get(slave_node);
                 } else if (parp) {
                         u32 phyid;
                         struct device_node *mdio_node;
@@ -2072,7 +2075,9 @@ static int cpsw_probe_dt(struct cpsw_priv *priv,
                         snprintf(slave_data->phy_id, sizeof(slave_data->phy_id),
                                  PHY_ID_FMT, mdio->name, phyid);
                 } else {
-                        dev_err(&pdev->dev, "No slave[%d] phy_id or fixed-link property\n", i);
+                        dev_err(&pdev->dev,
+                                "No slave[%d] phy_id, phy-handle, or fixed-link property\n",
+                                i);
                         goto no_phy_slave;
                 }
                 slave_data->phy_if = of_get_phy_mode(slave_node);
@@ -2275,7 +2280,7 @@ static int cpsw_probe(struct platform_device *pdev)
         /* Select default pin state */
         pinctrl_pm_select_default_state(&pdev->dev);
 
-        if (cpsw_probe_dt(priv, pdev)) {
+        if (cpsw_probe_dt(&priv->data, pdev)) {
                 dev_err(&pdev->dev, "cpsw: platform data missing\n");
                 ret = -ENODEV;
                 goto clean_runtime_disable_ret;
diff --git a/drivers/net/ethernet/ti/cpsw.h b/drivers/net/ethernet/ti/cpsw.h
index 442a7038e660..e50afd1b2eda 100644
--- a/drivers/net/ethernet/ti/cpsw.h
+++ b/drivers/net/ethernet/ti/cpsw.h
@@ -18,6 +18,7 @@
 #include <linux/phy.h>
 
 struct cpsw_slave_data {
+        struct device_node *phy_node;
         char            phy_id[MII_BUS_ID_SIZE];
         int             phy_if;
         u8              mac_addr[ETH_ALEN];
diff --git a/drivers/net/ethernet/ti/davinci_emac.c b/drivers/net/ethernet/ti/davinci_emac.c
index 5d9abedd6b75..f56d66e6ec15 100644
--- a/drivers/net/ethernet/ti/davinci_emac.c
+++ b/drivers/net/ethernet/ti/davinci_emac.c
@@ -1512,7 +1512,10 @@ static int emac_devioctl(struct net_device *ndev, struct ifreq *ifrq, int cmd)
 
         /* TODO: Add phy read and write and private statistics get feature */
 
-        return phy_mii_ioctl(priv->phydev, ifrq, cmd);
+        if (priv->phydev)
+                return phy_mii_ioctl(priv->phydev, ifrq, cmd);
+        else
+                return -EOPNOTSUPP;
 }
 
 static int match_first_device(struct device *dev, void *data)
@@ -1878,8 +1881,6 @@ davinci_emac_of_get_pdata(struct platform_device *pdev, struct emac_priv *priv)
                 pdata->hw_ram_addr = auxdata->hw_ram_addr;
         }
 
-        pdev->dev.platform_data = pdata;
-
         return  pdata;
 }
 
@@ -2101,6 +2102,7 @@ static int davinci_emac_remove(struct platform_device *pdev)
         cpdma_ctlr_destroy(priv->dma);
 
         unregister_netdev(ndev);
+        pm_runtime_disable(&pdev->dev);
         free_netdev(ndev);
 
         return 0;
diff --git a/drivers/net/ethernet/toshiba/ps3_gelic_wireless.c b/drivers/net/ethernet/toshiba/ps3_gelic_wireless.c
index 13214a6492ac..743b18266a7c 100644
--- a/drivers/net/ethernet/toshiba/ps3_gelic_wireless.c
+++ b/drivers/net/ethernet/toshiba/ps3_gelic_wireless.c
@@ -1622,7 +1622,7 @@ static void gelic_wl_scan_complete_event(struct gelic_wl_info *wl)
                         continue;
 
                 /* copy hw scan info */
-                memcpy(target->hwinfo, scan_info, scan_info->size);
+                memcpy(target->hwinfo, scan_info, be16_to_cpu(scan_info->size));
                 target->essid_len = strnlen(scan_info->essid,
                                             sizeof(scan_info->essid));
                 target->rate_len = 0;
diff --git a/drivers/net/macsec.c b/drivers/net/macsec.c
index 84d3e5ca8817..c6385617bfb2 100644
--- a/drivers/net/macsec.c
+++ b/drivers/net/macsec.c
@@ -880,12 +880,12 @@ static struct sk_buff *macsec_decrypt(struct sk_buff *skb,
         macsec_skb_cb(skb)->valid = false;
         skb = skb_share_check(skb, GFP_ATOMIC);
         if (!skb)
-                return NULL;
+                return ERR_PTR(-ENOMEM);
 
         req = aead_request_alloc(rx_sa->key.tfm, GFP_ATOMIC);
         if (!req) {
                 kfree_skb(skb);
-                return NULL;
+                return ERR_PTR(-ENOMEM);
         }
 
         hdr = (struct macsec_eth_header *)skb->data;
@@ -905,7 +905,7 @@ static struct sk_buff *macsec_decrypt(struct sk_buff *skb,
                 skb = skb_unshare(skb, GFP_ATOMIC);
                 if (!skb) {
                         aead_request_free(req);
-                        return NULL;
+                        return ERR_PTR(-ENOMEM);
                 }
         } else {
                 /* integrity only: all headers + data authenticated */
@@ -921,14 +921,14 @@ static struct sk_buff *macsec_decrypt(struct sk_buff *skb,
         dev_hold(dev);
         ret = crypto_aead_decrypt(req);
         if (ret == -EINPROGRESS) {
-                return NULL;
+                return ERR_PTR(ret);
         } else if (ret != 0) {
                 /* decryption/authentication failed
                  * 10.6 if validateFrames is disabled, deliver anyway
                  */
                 if (ret != -EBADMSG) {
                         kfree_skb(skb);
-                        skb = NULL;
+                        skb = ERR_PTR(ret);
                 }
         } else {
                 macsec_skb_cb(skb)->valid = true;
@@ -1146,8 +1146,10 @@ static rx_handler_result_t macsec_handle_frame(struct sk_buff **pskb)
             secy->validate_frames != MACSEC_VALIDATE_DISABLED)
                 skb = macsec_decrypt(skb, dev, rx_sa, sci, secy);
 
-        if (!skb) {
-                macsec_rxsa_put(rx_sa);
+        if (IS_ERR(skb)) {
+                /* the decrypt callback needs the reference */
+                if (PTR_ERR(skb) != -EINPROGRESS)
+                        macsec_rxsa_put(rx_sa);
                 rcu_read_unlock();
                 *pskb = NULL;
                 return RX_HANDLER_CONSUMED;
@@ -1161,7 +1163,8 @@ deliver:
                             macsec_extra_len(macsec_skb_cb(skb)->has_sci));
         macsec_reset_skb(skb, secy->netdev);
 
-        macsec_rxsa_put(rx_sa);
+        if (rx_sa)
+                macsec_rxsa_put(rx_sa);
         count_rx(dev, skb->len);
 
         rcu_read_unlock();
@@ -1622,8 +1625,9 @@ static int macsec_add_rxsa(struct sk_buff *skb, struct genl_info *info)
         }
 
         rx_sa = kmalloc(sizeof(*rx_sa), GFP_KERNEL);
-        if (init_rx_sa(rx_sa, nla_data(tb_sa[MACSEC_SA_ATTR_KEY]), secy->key_len,
-                       secy->icv_len)) {
+        if (!rx_sa || init_rx_sa(rx_sa, nla_data(tb_sa[MACSEC_SA_ATTR_KEY]),
+                                 secy->key_len, secy->icv_len)) {
+                kfree(rx_sa);
                 rtnl_unlock();
                 return -ENOMEM;
         }
@@ -1768,6 +1772,7 @@ static int macsec_add_txsa(struct sk_buff *skb, struct genl_info *info)
         tx_sa = kmalloc(sizeof(*tx_sa), GFP_KERNEL);
         if (!tx_sa || init_tx_sa(tx_sa, nla_data(tb_sa[MACSEC_SA_ATTR_KEY]),
                                  secy->key_len, secy->icv_len)) {
+                kfree(tx_sa);
                 rtnl_unlock();
                 return -ENOMEM;
         }
@@ -2227,7 +2232,8 @@ static int nla_put_secy(struct macsec_secy *secy, struct sk_buff *skb)
                 return 1;
 
         if (nla_put_sci(skb, MACSEC_SECY_ATTR_SCI, secy->sci) ||
-            nla_put_u64(skb, MACSEC_SECY_ATTR_CIPHER_SUITE, DEFAULT_CIPHER_ID) ||
+            nla_put_u64(skb, MACSEC_SECY_ATTR_CIPHER_SUITE,
+                        MACSEC_DEFAULT_CIPHER_ID) ||
             nla_put_u8(skb, MACSEC_SECY_ATTR_ICV_LEN, secy->icv_len) ||
             nla_put_u8(skb, MACSEC_SECY_ATTR_OPER, secy->operational) ||
             nla_put_u8(skb, MACSEC_SECY_ATTR_PROTECT, secy->protect_frames) ||
@@ -2268,7 +2274,7 @@ static int dump_secy(struct macsec_secy *secy, struct net_device *dev,
         if (!hdr)
                 return -EMSGSIZE;
 
-        rtnl_lock();
+        genl_dump_check_consistent(cb, hdr, &macsec_fam);
 
         if (nla_put_u32(skb, MACSEC_ATTR_IFINDEX, dev->ifindex))
                 goto nla_put_failure;
@@ -2429,18 +2435,17 @@ static int dump_secy(struct macsec_secy *secy, struct net_device *dev,
 
         nla_nest_end(skb, rxsc_list);
 
-        rtnl_unlock();
-
         genlmsg_end(skb, hdr);
 
         return 0;
 
 nla_put_failure:
-        rtnl_unlock();
         genlmsg_cancel(skb, hdr);
         return -EMSGSIZE;
 }
 
+static int macsec_generation = 1; /* protected by RTNL */
+
 static int macsec_dump_txsc(struct sk_buff *skb, struct netlink_callback *cb)
 {
         struct net *net = sock_net(skb->sk);
@@ -2450,6 +2455,10 @@ static int macsec_dump_txsc(struct sk_buff *skb, struct netlink_callback *cb)
         dev_idx = cb->args[0];
 
         d = 0;
+        rtnl_lock();
+
+        cb->seq = macsec_generation;
+
         for_each_netdev(net, dev) {
                 struct macsec_secy *secy;
 
@@ -2467,6 +2476,7 @@ next:
         }
 
 done:
+        rtnl_unlock();
         cb->args[0] = d;
         return skb->len;
 }
@@ -2920,10 +2930,14 @@ static void macsec_dellink(struct net_device *dev, struct list_head *head)
         struct net_device *real_dev = macsec->real_dev;
         struct macsec_rxh_data *rxd = macsec_data_rtnl(real_dev);
 
+        macsec_generation++;
+
         unregister_netdevice_queue(dev, head);
         list_del_rcu(&macsec->secys);
-        if (list_empty(&rxd->secys))
+        if (list_empty(&rxd->secys)) {
                 netdev_rx_handler_unregister(real_dev);
+                kfree(rxd);
+        }
 
         macsec_del_dev(macsec);
 }
@@ -2945,8 +2959,10 @@ static int register_macsec_dev(struct net_device *real_dev,
 
                 err = netdev_rx_handler_register(real_dev, macsec_handle_frame,
                                                  rxd);
-                if (err < 0)
+                if (err < 0) {
+                        kfree(rxd);
                         return err;
+                }
         }
 
         list_add_tail_rcu(&macsec->secys, &rxd->secys);
@@ -3066,6 +3082,8 @@ static int macsec_newlink(struct net *net, struct net_device *dev,
         if (err < 0)
                 goto del_dev;
 
+        macsec_generation++;
+
         dev_hold(real_dev);
 
         return 0;
@@ -3079,7 +3097,7 @@ unregister:
 
 static int macsec_validate_attr(struct nlattr *tb[], struct nlattr *data[])
 {
-        u64 csid = DEFAULT_CIPHER_ID;
+        u64 csid = MACSEC_DEFAULT_CIPHER_ID;
         u8 icv_len = DEFAULT_ICV_LEN;
         int flag;
         bool es, scb, sci;
@@ -3094,8 +3112,8 @@ static int macsec_validate_attr(struct nlattr *tb[], struct nlattr *data[])
                 icv_len = nla_get_u8(data[IFLA_MACSEC_ICV_LEN]);
 
         switch (csid) {
-        case DEFAULT_CIPHER_ID:
-        case DEFAULT_CIPHER_ALT:
+        case MACSEC_DEFAULT_CIPHER_ID:
+        case MACSEC_DEFAULT_CIPHER_ALT:
                 if (icv_len < MACSEC_MIN_ICV_LEN ||
                     icv_len > MACSEC_MAX_ICV_LEN)
                         return -EINVAL;
@@ -3129,8 +3147,8 @@ static int macsec_validate_attr(struct nlattr *tb[], struct nlattr *data[])
             nla_get_u8(data[IFLA_MACSEC_VALIDATION]) > MACSEC_VALIDATE_MAX)
                 return -EINVAL;
 
-        if ((data[IFLA_MACSEC_PROTECT] &&
-             nla_get_u8(data[IFLA_MACSEC_PROTECT])) &&
+        if ((data[IFLA_MACSEC_REPLAY_PROTECT] &&
+             nla_get_u8(data[IFLA_MACSEC_REPLAY_PROTECT])) &&
             !data[IFLA_MACSEC_WINDOW])
                 return -EINVAL;
 
@@ -3168,7 +3186,8 @@ static int macsec_fill_info(struct sk_buff *skb,
 
         if (nla_put_sci(skb, IFLA_MACSEC_SCI, secy->sci) ||
             nla_put_u8(skb, IFLA_MACSEC_ICV_LEN, secy->icv_len) ||
-            nla_put_u64(skb, IFLA_MACSEC_CIPHER_SUITE, DEFAULT_CIPHER_ID) ||
+            nla_put_u64(skb, IFLA_MACSEC_CIPHER_SUITE,
+                        MACSEC_DEFAULT_CIPHER_ID) ||
             nla_put_u8(skb, IFLA_MACSEC_ENCODING_SA, tx_sc->encoding_sa) ||
             nla_put_u8(skb, IFLA_MACSEC_ENCRYPT, tx_sc->encrypt) ||
             nla_put_u8(skb, IFLA_MACSEC_PROTECT, secy->protect_frames) ||
diff --git a/drivers/net/phy/at803x.c b/drivers/net/phy/at803x.c
index b3ffaee30858..f279a897a5c7 100644
--- a/drivers/net/phy/at803x.c
+++ b/drivers/net/phy/at803x.c
@@ -359,27 +359,25 @@ static void at803x_link_change_notify(struct phy_device *phydev)
          * in the FIFO. In such cases, the FIFO enters an error mode it
          * cannot recover from by software.
          */
-        if (phydev->drv->phy_id == ATH8030_PHY_ID) {
-                if (phydev->state == PHY_NOLINK) {
-                        if (priv->gpiod_reset && !priv->phy_reset) {
-                                struct at803x_context context;
-
-                                at803x_context_save(phydev, &context);
-
-                                gpiod_set_value(priv->gpiod_reset, 1);
-                                msleep(1);
-                                gpiod_set_value(priv->gpiod_reset, 0);
-                                msleep(1);
-
-                                at803x_context_restore(phydev, &context);
-
-                                phydev_dbg(phydev, "%s(): phy was reset\n",
-                                           __func__);
-                                priv->phy_reset = true;
-                        }
-                } else {
-                        priv->phy_reset = false;
+        if (phydev->state == PHY_NOLINK) {
+                if (priv->gpiod_reset && !priv->phy_reset) {
+                        struct at803x_context context;
+
+                        at803x_context_save(phydev, &context);
+
+                        gpiod_set_value(priv->gpiod_reset, 1);
+                        msleep(1);
+                        gpiod_set_value(priv->gpiod_reset, 0);
+                        msleep(1);
+
+                        at803x_context_restore(phydev, &context);
+
+                        phydev_dbg(phydev, "%s(): phy was reset\n",
+                                   __func__);
+                        priv->phy_reset = true;
                 }
+        } else {
+                priv->phy_reset = false;
         }
 }
 
@@ -391,7 +389,6 @@ static struct phy_driver at803x_driver[] = {
         .phy_id_mask            = 0xffffffef,
         .probe                  = at803x_probe,
         .config_init            = at803x_config_init,
-        .link_change_notify     = at803x_link_change_notify,
         .set_wol                = at803x_set_wol,
         .get_wol                = at803x_get_wol,
         .suspend                = at803x_suspend,
@@ -427,7 +424,6 @@ static struct phy_driver at803x_driver[] = {
         .phy_id_mask            = 0xffffffef,
         .probe                  = at803x_probe,
         .config_init            = at803x_config_init,
-        .link_change_notify     = at803x_link_change_notify,
         .set_wol                = at803x_set_wol,
         .get_wol                = at803x_get_wol,
         .suspend                = at803x_suspend,
diff --git a/drivers/net/phy/bcm7xxx.c b/drivers/net/phy/bcm7xxx.c
index b881a7b1e4f6..9636da0b6efc 100644
--- a/drivers/net/phy/bcm7xxx.c
+++ b/drivers/net/phy/bcm7xxx.c
@@ -339,6 +339,8 @@ static struct phy_driver bcm7xxx_driver[] = {
         BCM7XXX_28NM_GPHY(PHY_ID_BCM7439, "Broadcom BCM7439"),
         BCM7XXX_28NM_GPHY(PHY_ID_BCM7439_2, "Broadcom BCM7439 (2)"),
         BCM7XXX_28NM_GPHY(PHY_ID_BCM7445, "Broadcom BCM7445"),
+        BCM7XXX_40NM_EPHY(PHY_ID_BCM7346, "Broadcom BCM7346"),
+        BCM7XXX_40NM_EPHY(PHY_ID_BCM7362, "Broadcom BCM7362"),
         BCM7XXX_40NM_EPHY(PHY_ID_BCM7425, "Broadcom BCM7425"),
         BCM7XXX_40NM_EPHY(PHY_ID_BCM7429, "Broadcom BCM7429"),
         BCM7XXX_40NM_EPHY(PHY_ID_BCM7435, "Broadcom BCM7435"),
@@ -348,6 +350,8 @@ static struct mdio_device_id __maybe_unused bcm7xxx_tbl[] = {
         { PHY_ID_BCM7250, 0xfffffff0, },
         { PHY_ID_BCM7364, 0xfffffff0, },
         { PHY_ID_BCM7366, 0xfffffff0, },
+        { PHY_ID_BCM7346, 0xfffffff0, },
+        { PHY_ID_BCM7362, 0xfffffff0, },
         { PHY_ID_BCM7425, 0xfffffff0, },
         { PHY_ID_BCM7429, 0xfffffff0, },
         { PHY_ID_BCM7439, 0xfffffff0, },
diff --git a/drivers/net/phy/spi_ks8995.c b/drivers/net/phy/spi_ks8995.c
index b5d50d458728..93ffedfa2994 100644
--- a/drivers/net/phy/spi_ks8995.c
+++ b/drivers/net/phy/spi_ks8995.c
@@ -441,7 +441,7 @@ static int ks8995_probe(struct spi_device *spi)
                 return -ENOMEM;
 
         mutex_init(&ks->lock);
-        ks->spi = spi_dev_get(spi);
+        ks->spi = spi;
         ks->chip = &ks8995_chip[variant];
 
         if (ks->spi->dev.of_node) {
diff --git a/drivers/net/team/team.c b/drivers/net/team/team.c
index 26c64d2782fa..a0f64cba86ba 100644
--- a/drivers/net/team/team.c
+++ b/drivers/net/team/team.c
@@ -1198,6 +1198,9 @@ static int team_port_add(struct team *team, struct net_device *port_dev)
                 goto err_dev_open;
         }
 
+        dev_uc_sync_multiple(port_dev, dev);
+        dev_mc_sync_multiple(port_dev, dev);
+
         err = vlan_vids_add_by_dev(port_dev, dev);
         if (err) {
                 netdev_err(dev, "Failed to add vlan ids to device %s\n",
@@ -1261,6 +1264,8 @@ err_enable_netpoll:
         vlan_vids_del_by_dev(port_dev, dev);
 
 err_vids_add:
+        dev_uc_unsync(port_dev, dev);
+        dev_mc_unsync(port_dev, dev);
         dev_close(port_dev);
 
 err_dev_open:
diff --git a/drivers/net/tun.c b/drivers/net/tun.c
index afdf950617c3..2c9e45f50edb 100644
--- a/drivers/net/tun.c
+++ b/drivers/net/tun.c
@@ -622,7 +622,8 @@ static int tun_attach(struct tun_struct *tun, struct file *file, bool skip_filte
 
         /* Re-attach the filter to persist device */
         if (!skip_filter && (tun->filter_attached == true)) {
-                err = sk_attach_filter(&tun->fprog, tfile->socket.sk);
+                err = __sk_attach_filter(&tun->fprog, tfile->socket.sk,
+                                         lockdep_rtnl_is_held());
                 if (!err)
                         goto out;
         }
@@ -1014,7 +1015,6 @@ static void tun_net_init(struct net_device *dev)
                 /* Zero header length */
                 dev->type = ARPHRD_NONE;
                 dev->flags = IFF_POINTOPOINT | IFF_NOARP | IFF_MULTICAST;
-                dev->tx_queue_len = TUN_READQ_SIZE;  /* We prefer our own queue length */
                 break;
 
         case IFF_TAP:
@@ -1026,7 +1026,6 @@ static void tun_net_init(struct net_device *dev)
 
                 eth_hw_addr_random(dev);
 
-                dev->tx_queue_len = TUN_READQ_SIZE;  /* We prefer our own queue length */
                 break;
         }
 }
@@ -1480,6 +1479,8 @@ static void tun_setup(struct net_device *dev)
 
         dev->ethtool_ops = &tun_ethtool_ops;
         dev->destructor = tun_free_netdev;
+        /* We prefer our own queue length */
+        dev->tx_queue_len = TUN_READQ_SIZE;
 }
 
 /* Trivial set of netlink ops to allow deleting tun or tap
@@ -1822,7 +1823,7 @@ static void tun_detach_filter(struct tun_struct *tun, int n)
 
         for (i = 0; i < n; i++) {
                 tfile = rtnl_dereference(tun->tfiles[i]);
-                sk_detach_filter(tfile->socket.sk);
+                __sk_detach_filter(tfile->socket.sk, lockdep_rtnl_is_held());
         }
 
         tun->filter_attached = false;
@@ -1835,7 +1836,8 @@ static int tun_attach_filter(struct tun_struct *tun)
 
         for (i = 0; i < tun->numqueues; i++) {
                 tfile = rtnl_dereference(tun->tfiles[i]);
-                ret = sk_attach_filter(&tun->fprog, tfile->socket.sk);
+                ret = __sk_attach_filter(&tun->fprog, tfile->socket.sk,
+                                         lockdep_rtnl_is_held());
                 if (ret) {
                         tun_detach_filter(tun, i);
                         return ret;
diff --git a/drivers/net/usb/cdc_mbim.c b/drivers/net/usb/cdc_mbim.c
index bdd83d95ec0a..96a5028621c8 100644
--- a/drivers/net/usb/cdc_mbim.c
+++ b/drivers/net/usb/cdc_mbim.c
@@ -617,8 +617,13 @@ static const struct usb_device_id mbim_devs[] = {
         { USB_VENDOR_AND_INTERFACE_INFO(0x0bdb, USB_CLASS_COMM, USB_CDC_SUBCLASS_MBIM, USB_CDC_PROTO_NONE),
           .driver_info = (unsigned long)&cdc_mbim_info,
         },
-        /* Huawei E3372 fails unless NDP comes after the IP packets */
-        { USB_DEVICE_AND_INTERFACE_INFO(0x12d1, 0x157d, USB_CLASS_COMM, USB_CDC_SUBCLASS_MBIM, USB_CDC_PROTO_NONE),
+
+        /* Some Huawei devices, ME906s-158 (12d1:15c1) and E3372
+         * (12d1:157d), are known to fail unless the NDP is placed
+         * after the IP packets.  Applying the quirk to all Huawei
+         * devices is broader than necessary, but harmless.
+         */
+        { USB_VENDOR_AND_INTERFACE_INFO(0x12d1, USB_CLASS_COMM, USB_CDC_SUBCLASS_MBIM, USB_CDC_PROTO_NONE),
           .driver_info = (unsigned long)&cdc_mbim_info_ndp_to_end,
         },
         /* default entry */
diff --git a/drivers/net/usb/cdc_ncm.c b/drivers/net/usb/cdc_ncm.c
index 86ba30ba35e8..2fb31edab125 100644
--- a/drivers/net/usb/cdc_ncm.c
+++ b/drivers/net/usb/cdc_ncm.c
@@ -1626,6 +1626,13 @@ static const struct usb_device_id cdc_devs[] = {
           .driver_info = (unsigned long) &wwan_info,
         },
 
+        /* Telit LE910 V2 */
+        { USB_DEVICE_AND_INTERFACE_INFO(0x1bc7, 0x0036,
+                USB_CLASS_COMM,
+                USB_CDC_SUBCLASS_NCM, USB_CDC_PROTO_NONE),
+          .driver_info = (unsigned long)&wwan_noarp_info,
+        },
+
         /* DW5812 LTE Verizon Mobile Broadband Card
          * Unlike DW5550 this device requires FLAG_NOARP
          */
diff --git a/drivers/net/usb/lan78xx.c b/drivers/net/usb/lan78xx.c
index f20890ee03f3..f64778ad9753 100644
--- a/drivers/net/usb/lan78xx.c
+++ b/drivers/net/usb/lan78xx.c
@@ -269,6 +269,7 @@ struct skb_data {		/* skb->cb is one of these */
         struct lan78xx_net *dev;
         enum skb_state state;
         size_t length;
+        int num_of_packet;
 };
 
 struct usb_context {
@@ -1803,7 +1804,34 @@ static void lan78xx_remove_mdio(struct lan78xx_net *dev)
 
 static void lan78xx_link_status_change(struct net_device *net)
 {
-        /* nothing to do */
+        struct phy_device *phydev = net->phydev;
+        int ret, temp;
+
+        /* At forced 100 F/H mode, chip may fail to set mode correctly
+         * when cable is switched between long(~50+m) and short one.
+         * As workaround, set to 10 before setting to 100
+         * at forced 100 F/H mode.
+         */
+        if (!phydev->autoneg && (phydev->speed == 100)) {
+                /* disable phy interrupt */
+                temp = phy_read(phydev, LAN88XX_INT_MASK);
+                temp &= ~LAN88XX_INT_MASK_MDINTPIN_EN_;
+                ret = phy_write(phydev, LAN88XX_INT_MASK, temp);
+
+                temp = phy_read(phydev, MII_BMCR);
+                temp &= ~(BMCR_SPEED100 | BMCR_SPEED1000);
+                phy_write(phydev, MII_BMCR, temp); /* set to 10 first */
+                temp |= BMCR_SPEED100;
+                phy_write(phydev, MII_BMCR, temp); /* set to 100 later */
+
+                /* clear pending interrupt generated while workaround */
+                temp = phy_read(phydev, LAN88XX_INT_STS);
+
+                /* enable phy interrupt back */
+                temp = phy_read(phydev, LAN88XX_INT_MASK);
+                temp |= LAN88XX_INT_MASK_MDINTPIN_EN_;
+                ret = phy_write(phydev, LAN88XX_INT_MASK, temp);
+        }
 }
 
 static int lan78xx_phy_init(struct lan78xx_net *dev)
@@ -2464,7 +2492,7 @@ static void tx_complete(struct urb *urb)
         struct lan78xx_net *dev = entry->dev;
 
         if (urb->status == 0) {
-                dev->net->stats.tx_packets++;
+                dev->net->stats.tx_packets += entry->num_of_packet;
                 dev->net->stats.tx_bytes += entry->length;
         } else {
                 dev->net->stats.tx_errors++;
@@ -2681,10 +2709,11 @@ void lan78xx_skb_return(struct lan78xx_net *dev, struct sk_buff *skb)
                 return;
         }
 
-        skb->protocol = eth_type_trans(skb, dev->net);
         dev->net->stats.rx_packets++;
         dev->net->stats.rx_bytes += skb->len;
 
+        skb->protocol = eth_type_trans(skb, dev->net);
+
         netif_dbg(dev, rx_status, dev->net, "< rx, len %zu, type 0x%x\n",
                   skb->len + sizeof(struct ethhdr), skb->protocol);
         memset(skb->cb, 0, sizeof(struct skb_data));
@@ -2934,13 +2963,16 @@ static void lan78xx_tx_bh(struct lan78xx_net *dev)
 
         skb_totallen = 0;
         pkt_cnt = 0;
+        count = 0;
+        length = 0;
         for (skb = tqp->next; pkt_cnt < tqp->qlen; skb = skb->next) {
                 if (skb_is_gso(skb)) {
                         if (pkt_cnt) {
                                 /* handle previous packets first */
                                 break;
                         }
-                        length = skb->len;
+                        count = 1;
+                        length = skb->len - TX_OVERHEAD;
                         skb2 = skb_dequeue(tqp);
                         goto gso_skb;
                 }
@@ -2961,14 +2993,13 @@ static void lan78xx_tx_bh(struct lan78xx_net *dev)
         for (count = pos = 0; count < pkt_cnt; count++) {
                 skb2 = skb_dequeue(tqp);
                 if (skb2) {
+                        length += (skb2->len - TX_OVERHEAD);
                         memcpy(skb->data + pos, skb2->data, skb2->len);
                         pos += roundup(skb2->len, sizeof(u32));
                         dev_kfree_skb(skb2);
                 }
         }
 
-        length = skb_totallen;
-
 gso_skb:
         urb = usb_alloc_urb(0, GFP_ATOMIC);
         if (!urb) {
@@ -2980,6 +3011,7 @@ gso_skb:
         entry->urb = urb;
         entry->dev = dev;
         entry->length = length;
+        entry->num_of_packet = count;
 
         spin_lock_irqsave(&dev->txq.lock, flags);
         ret = usb_autopm_get_interface_async(dev->intf);
diff --git a/drivers/net/usb/pegasus.c b/drivers/net/usb/pegasus.c
index f84080215915..82129eef7774 100644
--- a/drivers/net/usb/pegasus.c
+++ b/drivers/net/usb/pegasus.c
@@ -411,7 +411,7 @@ static int enable_net_traffic(struct net_device *dev, struct usb_device *usb)
         int ret;
 
         read_mii_word(pegasus, pegasus->phy, MII_LPA, &linkpart);
-        data[0] = 0xc9;
+        data[0] = 0xc8; /* TX & RX enable, append status, no CRC */
         data[1] = 0;
         if (linkpart & (ADVERTISE_100FULL | ADVERTISE_10FULL))
                 data[1] |= 0x20;        /* set full duplex */
@@ -497,7 +497,7 @@ static void read_bulk_callback(struct urb *urb)
                 pkt_len = buf[count - 3] << 8;
                 pkt_len += buf[count - 4];
                 pkt_len &= 0xfff;
-                pkt_len -= 8;
+                pkt_len -= 4;
         }
 
         /*
@@ -528,7 +528,7 @@ static void read_bulk_callback(struct urb *urb)
 goon:
         usb_fill_bulk_urb(pegasus->rx_urb, pegasus->usb,
                           usb_rcvbulkpipe(pegasus->usb, 1),
-                          pegasus->rx_skb->data, PEGASUS_MTU + 8,
+                          pegasus->rx_skb->data, PEGASUS_MTU,
                           read_bulk_callback, pegasus);
         rx_status = usb_submit_urb(pegasus->rx_urb, GFP_ATOMIC);
         if (rx_status == -ENODEV)
@@ -569,7 +569,7 @@ static void rx_fixup(unsigned long data)
         }
         usb_fill_bulk_urb(pegasus->rx_urb, pegasus->usb,
                           usb_rcvbulkpipe(pegasus->usb, 1),
-                          pegasus->rx_skb->data, PEGASUS_MTU + 8,
+                          pegasus->rx_skb->data, PEGASUS_MTU,
                           read_bulk_callback, pegasus);
 try_again:
         status = usb_submit_urb(pegasus->rx_urb, GFP_ATOMIC);
@@ -823,7 +823,7 @@ static int pegasus_open(struct net_device *net)
 
         usb_fill_bulk_urb(pegasus->rx_urb, pegasus->usb,
                           usb_rcvbulkpipe(pegasus->usb, 1),
-                          pegasus->rx_skb->data, PEGASUS_MTU + 8,
+                          pegasus->rx_skb->data, PEGASUS_MTU,
                           read_bulk_callback, pegasus);
         if ((res = usb_submit_urb(pegasus->rx_urb, GFP_KERNEL))) {
                 if (res == -ENODEV)
diff --git a/drivers/net/usb/plusb.c b/drivers/net/usb/plusb.c
index 1bfe0fcaccf5..22e1a9a99a7d 100644
--- a/drivers/net/usb/plusb.c
+++ b/drivers/net/usb/plusb.c
@@ -38,7 +38,7 @@
  * HEADS UP:  this handshaking isn't all that robust.  This driver
  * gets confused easily if you unplug one end of the cable then
  * try to connect it again; you'll need to restart both ends. The
- * "naplink" software (used by some PlayStation/2 deveopers) does
+ * "naplink" software (used by some PlayStation/2 developers) does
  * the handshaking much better!   Also, sometimes this hardware
  * seems to get wedged under load.  Prolific docs are weak, and
  * don't identify differences between PL2301 and PL2302, much less
diff --git a/drivers/net/usb/qmi_wwan.c b/drivers/net/usb/qmi_wwan.c
index 7d717c66bcb0..9d1fce8a6e84 100644
--- a/drivers/net/usb/qmi_wwan.c
+++ b/drivers/net/usb/qmi_wwan.c
@@ -844,6 +844,7 @@ static const struct usb_device_id products[] = {
         {QMI_FIXED_INTF(0x19d2, 0x1426, 2)},    /* ZTE MF91 */
         {QMI_FIXED_INTF(0x19d2, 0x1428, 2)},    /* Telewell TW-LTE 4G v2 */
         {QMI_FIXED_INTF(0x19d2, 0x2002, 4)},    /* ZTE (Vodafone) K3765-Z */
+        {QMI_FIXED_INTF(0x2001, 0x7e19, 4)},    /* D-Link DWM-221 B1 */
         {QMI_FIXED_INTF(0x0f3d, 0x68a2, 8)},    /* Sierra Wireless MC7700 */
         {QMI_FIXED_INTF(0x114f, 0x68a2, 8)},    /* Sierra Wireless MC7750 */
         {QMI_FIXED_INTF(0x1199, 0x68a2, 8)},    /* Sierra Wireless MC7710 in QMI mode */
diff --git a/drivers/net/usb/smsc75xx.c b/drivers/net/usb/smsc75xx.c
index 30033dbe6662..c369db99c005 100644
--- a/drivers/net/usb/smsc75xx.c
+++ b/drivers/net/usb/smsc75xx.c
@@ -29,6 +29,7 @@
 #include <linux/crc32.h>
 #include <linux/usb/usbnet.h>
 #include <linux/slab.h>
+#include <linux/of_net.h>
 #include "smsc75xx.h"
 
 #define SMSC_CHIPNAME                   "smsc75xx"
@@ -761,6 +762,15 @@ static int smsc75xx_ioctl(struct net_device *netdev, struct ifreq *rq, int cmd)
 
 static void smsc75xx_init_mac_address(struct usbnet *dev)
 {
+        const u8 *mac_addr;
+
+        /* maybe the boot loader passed the MAC address in devicetree */
+        mac_addr = of_get_mac_address(dev->udev->dev.of_node);
+        if (mac_addr) {
+                memcpy(dev->net->dev_addr, mac_addr, ETH_ALEN);
+                return;
+        }
+
         /* try reading mac address from EEPROM */
         if (smsc75xx_read_eeprom(dev, EEPROM_MAC_OFFSET, ETH_ALEN,
                         dev->net->dev_addr) == 0) {
@@ -772,7 +782,7 @@ static void smsc75xx_init_mac_address(struct usbnet *dev)
                 }
         }
 
-        /* no eeprom, or eeprom values are invalid. generate random MAC */
+        /* no useful static MAC address found. generate a random one */
         eth_hw_addr_random(dev->net);
         netif_dbg(dev, ifup, dev->net, "MAC address set to eth_random_addr\n");
 }
diff --git a/drivers/net/usb/smsc95xx.c b/drivers/net/usb/smsc95xx.c
index 66b3ab9f614e..2edc2bc6d1b9 100644
--- a/drivers/net/usb/smsc95xx.c
+++ b/drivers/net/usb/smsc95xx.c
@@ -29,6 +29,7 @@
 #include <linux/crc32.h>
 #include <linux/usb/usbnet.h>
 #include <linux/slab.h>
+#include <linux/of_net.h>
 #include "smsc95xx.h"
 
 #define SMSC_CHIPNAME                   "smsc95xx"
@@ -765,6 +766,15 @@ static int smsc95xx_ioctl(struct net_device *netdev, struct ifreq *rq, int cmd)
 
 static void smsc95xx_init_mac_address(struct usbnet *dev)
 {
+        const u8 *mac_addr;
+
+        /* maybe the boot loader passed the MAC address in devicetree */
+        mac_addr = of_get_mac_address(dev->udev->dev.of_node);
+        if (mac_addr) {
+                memcpy(dev->net->dev_addr, mac_addr, ETH_ALEN);
+                return;
+        }
+
         /* try reading mac address from EEPROM */
         if (smsc95xx_read_eeprom(dev, EEPROM_MAC_OFFSET, ETH_ALEN,
                         dev->net->dev_addr) == 0) {
@@ -775,7 +785,7 @@ static void smsc95xx_init_mac_address(struct usbnet *dev)
                 }
         }
 
-        /* no eeprom, or eeprom values are invalid. generate random MAC */
+        /* no useful static MAC address found. generate a random one */
         eth_hw_addr_random(dev->net);
         netif_dbg(dev, ifup, dev->net, "MAC address set to eth_random_addr\n");
 }
diff --git a/drivers/net/vmxnet3/vmxnet3_drv.c b/drivers/net/vmxnet3/vmxnet3_drv.c
index b2348f67b00a..db8022ae415b 100644
--- a/drivers/net/vmxnet3/vmxnet3_drv.c
+++ b/drivers/net/vmxnet3/vmxnet3_drv.c
@@ -1152,12 +1152,16 @@ vmxnet3_rx_csum(struct vmxnet3_adapter *adapter,
                 union Vmxnet3_GenericDesc *gdesc)
 {
         if (!gdesc->rcd.cnc && adapter->netdev->features & NETIF_F_RXCSUM) {
-                /* typical case: TCP/UDP over IP and both csums are correct */
-                if ((le32_to_cpu(gdesc->dword[3]) & VMXNET3_RCD_CSUM_OK) ==
-                                                        VMXNET3_RCD_CSUM_OK) {
+                if (gdesc->rcd.v4 &&
+                    (le32_to_cpu(gdesc->dword[3]) &
+                     VMXNET3_RCD_CSUM_OK) == VMXNET3_RCD_CSUM_OK) {
+                        skb->ip_summed = CHECKSUM_UNNECESSARY;
+                        BUG_ON(!(gdesc->rcd.tcp || gdesc->rcd.udp));
+                        BUG_ON(gdesc->rcd.frg);
+                } else if (gdesc->rcd.v6 && (le32_to_cpu(gdesc->dword[3]) &
+                                             (1 << VMXNET3_RCD_TUC_SHIFT))) {
                         skb->ip_summed = CHECKSUM_UNNECESSARY;
                         BUG_ON(!(gdesc->rcd.tcp || gdesc->rcd.udp));
-                        BUG_ON(!(gdesc->rcd.v4  || gdesc->rcd.v6));
                         BUG_ON(gdesc->rcd.frg);
                 } else {
                         if (gdesc->rcd.csum) {
diff --git a/drivers/net/vmxnet3/vmxnet3_int.h b/drivers/net/vmxnet3/vmxnet3_int.h
index 729c344e6774..c4825392d64b 100644
--- a/drivers/net/vmxnet3/vmxnet3_int.h
+++ b/drivers/net/vmxnet3/vmxnet3_int.h
@@ -69,10 +69,10 @@
 /*
  * Version numbers
  */
-#define VMXNET3_DRIVER_VERSION_STRING   "1.4.6.0-k"
+#define VMXNET3_DRIVER_VERSION_STRING   "1.4.7.0-k"
 
 /* a 32-bit int, each byte encode a verion number in VMXNET3_DRIVER_VERSION */
-#define VMXNET3_DRIVER_VERSION_NUM      0x01040600
+#define VMXNET3_DRIVER_VERSION_NUM      0x01040700
 
 #if defined(CONFIG_PCI_MSI)
         /* RSS only makes sense if MSI-X is supported. */
diff --git a/drivers/net/vrf.c b/drivers/net/vrf.c
index 9a9fabb900c1..8a8f1e58b415 100644
--- a/drivers/net/vrf.c
+++ b/drivers/net/vrf.c
@@ -60,41 +60,6 @@ struct pcpu_dstats {
         struct u64_stats_sync   syncp;
 };
 
-static struct dst_entry *vrf_ip_check(struct dst_entry *dst, u32 cookie)
-{
-        return dst;
-}
-
-static int vrf_ip_local_out(struct net *net, struct sock *sk, struct sk_buff *skb)
-{
-        return ip_local_out(net, sk, skb);
-}
-
-static unsigned int vrf_v4_mtu(const struct dst_entry *dst)
-{
-        /* TO-DO: return max ethernet size? */
-        return dst->dev->mtu;
-}
-
-static void vrf_dst_destroy(struct dst_entry *dst)
-{
-        /* our dst lives forever - or until the device is closed */
-}
-
-static unsigned int vrf_default_advmss(const struct dst_entry *dst)
-{
-        return 65535 - 40;
-}
-
-static struct dst_ops vrf_dst_ops = {
-        .family         = AF_INET,
-        .local_out      = vrf_ip_local_out,
-        .check          = vrf_ip_check,
-        .mtu            = vrf_v4_mtu,
-        .destroy        = vrf_dst_destroy,
-        .default_advmss = vrf_default_advmss,
-};
-
 /* neighbor handling is done with actual device; do not want
  * to flip skb->dev for those ndisc packets. This really fails
  * for multiple next protocols (e.g., NEXTHDR_HOP). But it is
@@ -349,46 +314,6 @@ static netdev_tx_t vrf_xmit(struct sk_buff *skb, struct net_device *dev)
 }
 
 #if IS_ENABLED(CONFIG_IPV6)
-static struct dst_entry *vrf_ip6_check(struct dst_entry *dst, u32 cookie)
-{
-        return dst;
-}
-
-static struct dst_ops vrf_dst_ops6 = {
-        .family         = AF_INET6,
-        .local_out      = ip6_local_out,
-        .check          = vrf_ip6_check,
-        .mtu            = vrf_v4_mtu,
-        .destroy        = vrf_dst_destroy,
-        .default_advmss = vrf_default_advmss,
-};
-
-static int init_dst_ops6_kmem_cachep(void)
-{
-        vrf_dst_ops6.kmem_cachep = kmem_cache_create("vrf_ip6_dst_cache",
-                                                     sizeof(struct rt6_info),
-                                                     0,
-                                                     SLAB_HWCACHE_ALIGN,
-                                                     NULL);
-
-        if (!vrf_dst_ops6.kmem_cachep)
-                return -ENOMEM;
-
-        return 0;
-}
-
-static void free_dst_ops6_kmem_cachep(void)
-{
-        kmem_cache_destroy(vrf_dst_ops6.kmem_cachep);
-}
-
-static int vrf_input6(struct sk_buff *skb)
-{
-        skb->dev->stats.rx_errors++;
-        kfree_skb(skb);
-        return 0;
-}
-
 /* modelled after ip6_finish_output2 */
 static int vrf_finish_output6(struct net *net, struct sock *sk,
                               struct sk_buff *skb)
@@ -429,67 +354,34 @@ static int vrf_output6(struct net *net, struct sock *sk, struct sk_buff *skb)
                             !(IP6CB(skb)->flags & IP6SKB_REROUTED));
 }
 
-static void vrf_rt6_destroy(struct net_vrf *vrf)
+static void vrf_rt6_release(struct net_vrf *vrf)
 {
-        dst_destroy(&vrf->rt6->dst);
-        free_percpu(vrf->rt6->rt6i_pcpu);
+        dst_release(&vrf->rt6->dst);
         vrf->rt6 = NULL;
 }
 
 static int vrf_rt6_create(struct net_device *dev)
 {
         struct net_vrf *vrf = netdev_priv(dev);
-        struct dst_entry *dst;
+        struct net *net = dev_net(dev);
         struct rt6_info *rt6;
-        int cpu;
         int rc = -ENOMEM;
 
-        rt6 = dst_alloc(&vrf_dst_ops6, dev, 0,
-                        DST_OBSOLETE_NONE,
-                        (DST_HOST | DST_NOPOLICY | DST_NOXFRM));
+        rt6 = ip6_dst_alloc(net, dev,
+                            DST_HOST | DST_NOPOLICY | DST_NOXFRM | DST_NOCACHE);
         if (!rt6)
                 goto out;
 
-        dst = &rt6->dst;
-
-        rt6->rt6i_pcpu = alloc_percpu_gfp(struct rt6_info *, GFP_KERNEL);
-        if (!rt6->rt6i_pcpu) {
-                dst_destroy(dst);
-                goto out;
-        }
-        for_each_possible_cpu(cpu) {
-                struct rt6_info **p = per_cpu_ptr(rt6->rt6i_pcpu, cpu);
-                *p =  NULL;
-        }
-
-        memset(dst + 1, 0, sizeof(*rt6) - sizeof(*dst));
-
-        INIT_LIST_HEAD(&rt6->rt6i_siblings);
-        INIT_LIST_HEAD(&rt6->rt6i_uncached);
-
-        rt6->dst.input  = vrf_input6;
         rt6->dst.output = vrf_output6;
-
-        rt6->rt6i_table = fib6_get_table(dev_net(dev), vrf->tb_id);
-
-        atomic_set(&rt6->dst.__refcnt, 2);
-
+        rt6->rt6i_table = fib6_get_table(net, vrf->tb_id);
+        dst_hold(&rt6->dst);
         vrf->rt6 = rt6;
         rc = 0;
 out:
         return rc;
 }
 #else
-static int init_dst_ops6_kmem_cachep(void)
-{
-        return 0;
-}
-
-static void free_dst_ops6_kmem_cachep(void)
-{
-}
-
-static void vrf_rt6_destroy(struct net_vrf *vrf)
+static void vrf_rt6_release(struct net_vrf *vrf)
 {
 }
 
@@ -557,11 +449,11 @@ static int vrf_output(struct net *net, struct sock *sk, struct sk_buff *skb)
                             !(IPCB(skb)->flags & IPSKB_REROUTED));
 }
 
-static void vrf_rtable_destroy(struct net_vrf *vrf)
+static void vrf_rtable_release(struct net_vrf *vrf)
 {
         struct dst_entry *dst = (struct dst_entry *)vrf->rth;
 
-        dst_destroy(dst);
+        dst_release(dst);
         vrf->rth = NULL;
 }
 
@@ -570,22 +462,10 @@ static struct rtable *vrf_rtable_create(struct net_device *dev)
         struct net_vrf *vrf = netdev_priv(dev);
         struct rtable *rth;
 
-        rth = dst_alloc(&vrf_dst_ops, dev, 2,
-                        DST_OBSOLETE_NONE,
-                        (DST_HOST | DST_NOPOLICY | DST_NOXFRM));
+        rth = rt_dst_alloc(dev, 0, RTN_UNICAST, 1, 1, 0);
         if (rth) {
                 rth->dst.output = vrf_output;
-                rth->rt_genid   = rt_genid_ipv4(dev_net(dev));
-                rth->rt_flags   = 0;
-                rth->rt_type    = RTN_UNICAST;
-                rth->rt_is_input = 0;
-                rth->rt_iif     = 0;
-                rth->rt_pmtu    = 0;
-                rth->rt_gateway = 0;
-                rth->rt_uses_gateway = 0;
                 rth->rt_table_id = vrf->tb_id;
-                INIT_LIST_HEAD(&rth->rt_uncached);
-                rth->rt_uncached_list = NULL;
         }
 
         return rth;
@@ -673,8 +553,8 @@ static void vrf_dev_uninit(struct net_device *dev)
         struct net_device *port_dev;
         struct list_head *iter;
 
-        vrf_rtable_destroy(vrf);
-        vrf_rt6_destroy(vrf);
+        vrf_rtable_release(vrf);
+        vrf_rt6_release(vrf);
 
         netdev_for_each_lower_dev(dev, port_dev, iter)
                 vrf_del_slave(dev, port_dev);
@@ -704,7 +584,7 @@ static int vrf_dev_init(struct net_device *dev)
         return 0;
 
 out_rth:
-        vrf_rtable_destroy(vrf);
+        vrf_rtable_release(vrf);
 out_stats:
         free_percpu(dev->dstats);
         dev->dstats = NULL;
@@ -737,7 +617,7 @@ static struct rtable *vrf_get_rtable(const struct net_device *dev,
                 struct net_vrf *vrf = netdev_priv(dev);
 
                 rth = vrf->rth;
-                atomic_inc(&rth->dst.__refcnt);
+                dst_hold(&rth->dst);
         }
 
         return rth;
@@ -788,7 +668,7 @@ static struct dst_entry *vrf_get_rt6_dst(const struct net_device *dev,
                 struct net_vrf *vrf = netdev_priv(dev);
 
                 rt = vrf->rt6;
-                atomic_inc(&rt->dst.__refcnt);
+                dst_hold(&rt->dst);
         }
 
         return (struct dst_entry *)rt;
@@ -946,19 +826,6 @@ static int __init vrf_init_module(void)
 {
         int rc;
 
-        vrf_dst_ops.kmem_cachep =
-                kmem_cache_create("vrf_ip_dst_cache",
-                                  sizeof(struct rtable), 0,
-                                  SLAB_HWCACHE_ALIGN,
-                                  NULL);
-
-        if (!vrf_dst_ops.kmem_cachep)
-                return -ENOMEM;
-
-        rc = init_dst_ops6_kmem_cachep();
-        if (rc != 0)
-                goto error2;
-
         register_netdevice_notifier(&vrf_notifier_block);
 
         rc = rtnl_link_register(&vrf_link_ops);
@@ -969,22 +836,10 @@ static int __init vrf_init_module(void)
 
 error:
         unregister_netdevice_notifier(&vrf_notifier_block);
-        free_dst_ops6_kmem_cachep();
-error2:
-        kmem_cache_destroy(vrf_dst_ops.kmem_cachep);
         return rc;
 }
 
-static void __exit vrf_cleanup_module(void)
-{
-        rtnl_link_unregister(&vrf_link_ops);
-        unregister_netdevice_notifier(&vrf_notifier_block);
-        kmem_cache_destroy(vrf_dst_ops.kmem_cachep);
-        free_dst_ops6_kmem_cachep();
-}
-
 module_init(vrf_init_module);
-module_exit(vrf_cleanup_module);
 MODULE_AUTHOR("Shrijeet Mukherjee, David Ahern");
 MODULE_DESCRIPTION("Device driver to instantiate VRF domains");
 MODULE_LICENSE("GPL");
diff --git a/drivers/net/wireless/ath/ath9k/ar5008_phy.c b/drivers/net/wireless/ath/ath9k/ar5008_phy.c
index 8f8793004b9f..1b271b99c49e 100644
--- a/drivers/net/wireless/ath/ath9k/ar5008_phy.c
+++ b/drivers/net/wireless/ath/ath9k/ar5008_phy.c
@@ -274,6 +274,9 @@ void ar5008_hw_cmn_spur_mitigate(struct ath_hw *ah,
         };
         static const int inc[4] = { 0, 100, 0, 0 };
 
+        memset(&mask_m, 0, sizeof(int8_t) * 123);
+        memset(&mask_p, 0, sizeof(int8_t) * 123);
+
         cur_bin = -6000;
         upper = bin + 100;
         lower = bin - 100;
@@ -424,14 +427,9 @@ static void ar5008_hw_spur_mitigate(struct ath_hw *ah,
         int tmp, new;
         int i;
 
-        int8_t mask_m[123];
-        int8_t mask_p[123];
         int cur_bb_spur;
         bool is2GHz = IS_CHAN_2GHZ(chan);
 
-        memset(&mask_m, 0, sizeof(int8_t) * 123);
-        memset(&mask_p, 0, sizeof(int8_t) * 123);
-
         for (i = 0; i < AR_EEPROM_MODAL_SPURS; i++) {
                 cur_bb_spur = ah->eep_ops->get_spur_channel(ah, i, is2GHz);
                 if (AR_NO_SPUR == cur_bb_spur)
diff --git a/drivers/net/wireless/ath/ath9k/ar9002_phy.c b/drivers/net/wireless/ath/ath9k/ar9002_phy.c
index db6624527d99..53d7445a5d12 100644
--- a/drivers/net/wireless/ath/ath9k/ar9002_phy.c
+++ b/drivers/net/wireless/ath/ath9k/ar9002_phy.c
@@ -178,14 +178,9 @@ static void ar9002_hw_spur_mitigate(struct ath_hw *ah,
         int i;
         struct chan_centers centers;
 
-        int8_t mask_m[123];
-        int8_t mask_p[123];
         int cur_bb_spur;
         bool is2GHz = IS_CHAN_2GHZ(chan);
 
-        memset(&mask_m, 0, sizeof(int8_t) * 123);
-        memset(&mask_p, 0, sizeof(int8_t) * 123);
-
         ath9k_hw_get_channel_centers(ah, chan, &centers);
         freq = centers.synth_center;
 
diff --git a/drivers/net/wireless/broadcom/b43/main.c b/drivers/net/wireless/broadcom/b43/main.c
index 72380af9dc52..b0603e796ad8 100644
--- a/drivers/net/wireless/broadcom/b43/main.c
+++ b/drivers/net/wireless/broadcom/b43/main.c
@@ -5680,11 +5680,12 @@ static int b43_bcma_probe(struct bcma_device *core)
         INIT_WORK(&wl->firmware_load, b43_request_firmware);
         schedule_work(&wl->firmware_load);
 
-bcma_out:
         return err;
 
 bcma_err_wireless_exit:
         ieee80211_free_hw(wl->hw);
+bcma_out:
+        kfree(dev);
         return err;
 }
 
@@ -5712,8 +5713,8 @@ static void b43_bcma_remove(struct bcma_device *core)
         b43_rng_exit(wl);
 
         b43_leds_unregister(wl);
-
         ieee80211_free_hw(wl->hw);
+        kfree(wldev->dev);
 }
 
 static struct bcma_driver b43_bcma_driver = {
@@ -5796,6 +5797,7 @@ static void b43_ssb_remove(struct ssb_device *sdev)
 
         b43_leds_unregister(wl);
         b43_wireless_exit(dev, wl);
+        kfree(dev);
 }
 
 static struct ssb_driver b43_ssb_driver = {
diff --git a/drivers/net/wireless/intel/iwlwifi/iwl-8000.c b/drivers/net/wireless/intel/iwlwifi/iwl-8000.c
index 97be104d1203..b5c57eebf995 100644
--- a/drivers/net/wireless/intel/iwlwifi/iwl-8000.c
+++ b/drivers/net/wireless/intel/iwlwifi/iwl-8000.c
@@ -93,7 +93,7 @@
 #define IWL8260_SMEM_OFFSET             0x400000
 #define IWL8260_SMEM_LEN                0x68000
 
-#define IWL8000_FW_PRE "iwlwifi-8000"
+#define IWL8000_FW_PRE "iwlwifi-8000C-"
 #define IWL8000_MODULE_FIRMWARE(api) \
         IWL8000_FW_PRE "-" __stringify(api) ".ucode"
 
diff --git a/drivers/net/wireless/intel/iwlwifi/iwl-drv.c b/drivers/net/wireless/intel/iwlwifi/iwl-drv.c
index f899666acb41..9e45bf9c6071 100644
--- a/drivers/net/wireless/intel/iwlwifi/iwl-drv.c
+++ b/drivers/net/wireless/intel/iwlwifi/iwl-drv.c
@@ -238,19 +238,6 @@ static int iwl_request_firmware(struct iwl_drv *drv, bool first)
         snprintf(drv->firmware_name, sizeof(drv->firmware_name), "%s%s.ucode",
                  name_pre, tag);
 
-        /*
-         * Starting 8000B - FW name format has changed. This overwrites the
-         * previous name and uses the new format.
-         */
-        if (drv->trans->cfg->device_family == IWL_DEVICE_FAMILY_8000) {
-                char rev_step = 'A' + CSR_HW_REV_STEP(drv->trans->hw_rev);
-
-                if (rev_step != 'A')
-                        snprintf(drv->firmware_name,
-                                 sizeof(drv->firmware_name), "%s%c-%s.ucode",
-                                 name_pre, rev_step, tag);
-        }
-
         IWL_DEBUG_INFO(drv, "attempting to load firmware %s'%s'\n",
                        (drv->fw_index == UCODE_EXPERIMENTAL_INDEX)
                                 ? "EXPERIMENTAL " : "",
@@ -1060,11 +1047,18 @@ static int iwl_parse_tlv_firmware(struct iwl_drv *drv,
                 return -EINVAL;
         }
 
-        if (WARN(fw_has_capa(capa, IWL_UCODE_TLV_CAPA_GSCAN_SUPPORT) &&
-                 !gscan_capa,
-                 "GSCAN is supported but capabilities TLV is unavailable\n"))
+        /*
+         * If ucode advertises that it supports GSCAN but GSCAN
+         * capabilities TLV is not present, or if it has an old format,
+         * warn and continue without GSCAN.
+         */
+        if (fw_has_capa(capa, IWL_UCODE_TLV_CAPA_GSCAN_SUPPORT) &&
+            !gscan_capa) {
+                IWL_DEBUG_INFO(drv,
+                               "GSCAN is supported but capabilities TLV is unavailable\n");
                 __clear_bit((__force long)IWL_UCODE_TLV_CAPA_GSCAN_SUPPORT,
                             capa->_capa);
+        }
 
         return 0;
 
diff --git a/drivers/net/wireless/intel/iwlwifi/mvm/fw-dbg.c b/drivers/net/wireless/intel/iwlwifi/mvm/fw-dbg.c
index 4856eac120f6..6938cd37be57 100644
--- a/drivers/net/wireless/intel/iwlwifi/mvm/fw-dbg.c
+++ b/drivers/net/wireless/intel/iwlwifi/mvm/fw-dbg.c
@@ -526,7 +526,8 @@ void iwl_mvm_fw_error_dump(struct iwl_mvm *mvm)
                 file_len += sizeof(*dump_data) + sizeof(*dump_mem) + sram2_len;
 
         /* Make room for fw's virtual image pages, if it exists */
-        if (mvm->fw->img[mvm->cur_ucode].paging_mem_size)
+        if (mvm->fw->img[mvm->cur_ucode].paging_mem_size &&
+            mvm->fw_paging_db[0].fw_paging_block)
                 file_len += mvm->num_of_paging_blk *
                         (sizeof(*dump_data) +
                          sizeof(struct iwl_fw_error_dump_paging) +
@@ -643,7 +644,8 @@ void iwl_mvm_fw_error_dump(struct iwl_mvm *mvm)
         }
 
         /* Dump fw's virtual image */
-        if (mvm->fw->img[mvm->cur_ucode].paging_mem_size) {
+        if (mvm->fw->img[mvm->cur_ucode].paging_mem_size &&
+            mvm->fw_paging_db[0].fw_paging_block) {
                 for (i = 1; i < mvm->num_of_paging_blk + 1; i++) {
                         struct iwl_fw_error_dump_paging *paging;
                         struct page *pages =
diff --git a/drivers/net/wireless/intel/iwlwifi/mvm/fw.c b/drivers/net/wireless/intel/iwlwifi/mvm/fw.c
index 594cd0dc7df9..09d895fafaf2 100644
--- a/drivers/net/wireless/intel/iwlwifi/mvm/fw.c
+++ b/drivers/net/wireless/intel/iwlwifi/mvm/fw.c
@@ -144,9 +144,11 @@ void iwl_free_fw_paging(struct iwl_mvm *mvm)
 
                 __free_pages(mvm->fw_paging_db[i].fw_paging_block,
                              get_order(mvm->fw_paging_db[i].fw_paging_size));
+                mvm->fw_paging_db[i].fw_paging_block = NULL;
         }
         kfree(mvm->trans->paging_download_buf);
         mvm->trans->paging_download_buf = NULL;
+        mvm->trans->paging_db = NULL;
 
         memset(mvm->fw_paging_db, 0, sizeof(mvm->fw_paging_db));
 }
diff --git a/drivers/net/wireless/intel/iwlwifi/mvm/mac80211.c b/drivers/net/wireless/intel/iwlwifi/mvm/mac80211.c
index 76e649c680a1..a50f4df7eae7 100644
--- a/drivers/net/wireless/intel/iwlwifi/mvm/mac80211.c
+++ b/drivers/net/wireless/intel/iwlwifi/mvm/mac80211.c
@@ -1147,6 +1147,8 @@ void __iwl_mvm_mac_stop(struct iwl_mvm *mvm)
         /* the fw is stopped, the aux sta is dead: clean up driver state */
         iwl_mvm_del_aux_sta(mvm);
 
+        iwl_free_fw_paging(mvm);
+
         /*
          * Clear IN_HW_RESTART flag when stopping the hw (as restart_complete()
          * won't be called in this case).
diff --git a/drivers/net/wireless/intel/iwlwifi/mvm/ops.c b/drivers/net/wireless/intel/iwlwifi/mvm/ops.c
index 5e8ab796d5bc..d278399097dc 100644
--- a/drivers/net/wireless/intel/iwlwifi/mvm/ops.c
+++ b/drivers/net/wireless/intel/iwlwifi/mvm/ops.c
@@ -761,8 +761,6 @@ static void iwl_op_mode_mvm_stop(struct iwl_op_mode *op_mode)
         for (i = 0; i < NVM_MAX_NUM_SECTIONS; i++)
                 kfree(mvm->nvm_sections[i].data);
 
-        iwl_free_fw_paging(mvm);
-
         iwl_mvm_tof_clean(mvm);
 
         ieee80211_free_hw(mvm->hw);
diff --git a/drivers/net/wireless/intel/iwlwifi/pcie/drv.c b/drivers/net/wireless/intel/iwlwifi/pcie/drv.c
index 05b968506836..79d7cd7d461e 100644
--- a/drivers/net/wireless/intel/iwlwifi/pcie/drv.c
+++ b/drivers/net/wireless/intel/iwlwifi/pcie/drv.c
@@ -479,8 +479,18 @@ static const struct pci_device_id iwl_hw_card_ids[] = {
         {IWL_PCI_DEVICE(0x24F3, 0x0930, iwl8260_2ac_cfg)},
         {IWL_PCI_DEVICE(0x24F3, 0x0000, iwl8265_2ac_cfg)},
         {IWL_PCI_DEVICE(0x24FD, 0x0010, iwl8265_2ac_cfg)},
+        {IWL_PCI_DEVICE(0x24FD, 0x0110, iwl8265_2ac_cfg)},
+        {IWL_PCI_DEVICE(0x24FD, 0x1110, iwl8265_2ac_cfg)},
+        {IWL_PCI_DEVICE(0x24FD, 0x1010, iwl8265_2ac_cfg)},
+        {IWL_PCI_DEVICE(0x24FD, 0x0050, iwl8265_2ac_cfg)},
+        {IWL_PCI_DEVICE(0x24FD, 0x0150, iwl8265_2ac_cfg)},
+        {IWL_PCI_DEVICE(0x24FD, 0x9010, iwl8265_2ac_cfg)},
+        {IWL_PCI_DEVICE(0x24FD, 0x8110, iwl8265_2ac_cfg)},
+        {IWL_PCI_DEVICE(0x24FD, 0x8050, iwl8265_2ac_cfg)},
         {IWL_PCI_DEVICE(0x24FD, 0x8010, iwl8265_2ac_cfg)},
         {IWL_PCI_DEVICE(0x24FD, 0x0810, iwl8265_2ac_cfg)},
+        {IWL_PCI_DEVICE(0x24FD, 0x9110, iwl8265_2ac_cfg)},
+        {IWL_PCI_DEVICE(0x24FD, 0x8130, iwl8265_2ac_cfg)},
 
 /* 9000 Series */
         {IWL_PCI_DEVICE(0x9DF0, 0x2A10, iwl5165_2ac_cfg)},
diff --git a/drivers/net/wireless/intel/iwlwifi/pcie/trans.c b/drivers/net/wireless/intel/iwlwifi/pcie/trans.c
index eb39c7e09781..b2b79354d5c0 100644
--- a/drivers/net/wireless/intel/iwlwifi/pcie/trans.c
+++ b/drivers/net/wireless/intel/iwlwifi/pcie/trans.c
@@ -732,8 +732,8 @@ static int iwl_pcie_rsa_race_bug_wa(struct iwl_trans *trans)
          */
         val = iwl_read_prph(trans, PREG_AUX_BUS_WPROT_0);
         if (val & (BIT(1) | BIT(17))) {
-                IWL_INFO(trans,
-                         "can't access the RSA semaphore it is write protected\n");
+                IWL_DEBUG_INFO(trans,
+                               "can't access the RSA semaphore it is write protected\n");
                 return 0;
         }
 
diff --git a/drivers/net/wireless/realtek/rtlwifi/rtl8821ae/dm.c b/drivers/net/wireless/realtek/rtlwifi/rtl8821ae/dm.c
index 95dcbff4673b..6a8245c4ea48 100644
--- a/drivers/net/wireless/realtek/rtlwifi/rtl8821ae/dm.c
+++ b/drivers/net/wireless/realtek/rtlwifi/rtl8821ae/dm.c
@@ -2488,9 +2488,9 @@ void rtl8821ae_dm_txpower_tracking_callback_thermalmeter(
                 for (p = RF90_PATH_A; p < MAX_PATH_NUM_8821A; p++)
                         rtldm->swing_idx_ofdm_base[p] = rtldm->swing_idx_ofdm[p];
 
-                        RT_TRACE(rtlpriv, COMP_POWER_TRACKING, DBG_LOUD,
-                                 "pDM_Odm->RFCalibrateInfo.ThermalValue = %d ThermalValue= %d\n",
-                                 rtldm->thermalvalue, thermal_value);
+                RT_TRACE(rtlpriv, COMP_POWER_TRACKING, DBG_LOUD,
+                         "pDM_Odm->RFCalibrateInfo.ThermalValue = %d ThermalValue= %d\n",
+                         rtldm->thermalvalue, thermal_value);
                 /*Record last Power Tracking Thermal Value*/
                 rtldm->thermalvalue = thermal_value;
         }
diff --git a/drivers/nvdimm/btt.c b/drivers/nvdimm/btt.c
index c32cbb593600..f068b6513cd2 100644
--- a/drivers/nvdimm/btt.c
+++ b/drivers/nvdimm/btt.c
@@ -1204,7 +1204,7 @@ static int btt_rw_page(struct block_device *bdev, sector_t sector,
 {
         struct btt *btt = bdev->bd_disk->private_data;
 
-        btt_do_bvec(btt, NULL, page, PAGE_CACHE_SIZE, 0, rw, sector);
+        btt_do_bvec(btt, NULL, page, PAGE_SIZE, 0, rw, sector);
         page_endio(page, rw & WRITE, 0);
         return 0;
 }
diff --git a/drivers/nvdimm/bus.c b/drivers/nvdimm/bus.c
index fc82743aefb6..19f822d7f652 100644
--- a/drivers/nvdimm/bus.c
+++ b/drivers/nvdimm/bus.c
@@ -407,7 +407,7 @@ static const struct nd_cmd_desc __nd_cmd_dimm_descs[] = {
         [ND_CMD_IMPLEMENTED] = { },
         [ND_CMD_SMART] = {
                 .out_num = 2,
-                .out_sizes = { 4, 8, },
+                .out_sizes = { 4, 128, },
         },
         [ND_CMD_SMART_THRESHOLD] = {
                 .out_num = 2,
diff --git a/drivers/nvdimm/core.c b/drivers/nvdimm/core.c
index 79646d0c3277..182a93fe3712 100644
--- a/drivers/nvdimm/core.c
+++ b/drivers/nvdimm/core.c
@@ -417,8 +417,8 @@ static void __add_badblock_range(struct badblocks *bb, u64 ns_offset, u64 len)
                 set_badblock(bb, start_sector, num_sectors);
 }
 
-static void namespace_add_poison(struct list_head *poison_list,
-                struct badblocks *bb, struct resource *res)
+static void badblocks_populate(struct list_head *poison_list,
+                struct badblocks *bb, const struct resource *res)
 {
         struct nd_poison *pl;
 
@@ -460,36 +460,35 @@ static void namespace_add_poison(struct list_head *poison_list,
 }
 
 /**
- * nvdimm_namespace_add_poison() - Convert a list of poison ranges to badblocks
- * @ndns:       the namespace containing poison ranges
- * @bb:         badblocks instance to populate
- * @offset:     offset at the start of the namespace before 'sector 0'
+ * nvdimm_badblocks_populate() - Convert a list of poison ranges to badblocks
+ * @region: parent region of the range to interrogate
+ * @bb: badblocks instance to populate
+ * @res: resource range to consider
  *
- * The poison list generated during NFIT initialization may contain multiple,
- * possibly overlapping ranges in the SPA (System Physical Address) space.
- * Compare each of these ranges to the namespace currently being initialized,
- * and add badblocks to the gendisk for all matching sub-ranges
+ * The poison list generated during bus initialization may contain
+ * multiple, possibly overlapping physical address ranges.  Compare each
+ * of these ranges to the resource range currently being initialized,
+ * and add badblocks entries for all matching sub-ranges
  */
-void nvdimm_namespace_add_poison(struct nd_namespace_common *ndns,
-                struct badblocks *bb, resource_size_t offset)
+void nvdimm_badblocks_populate(struct nd_region *nd_region,
+                struct badblocks *bb, const struct resource *res)
 {
-        struct nd_namespace_io *nsio = to_nd_namespace_io(&ndns->dev);
-        struct nd_region *nd_region = to_nd_region(ndns->dev.parent);
         struct nvdimm_bus *nvdimm_bus;
         struct list_head *poison_list;
-        struct resource res = {
-                .start = nsio->res.start + offset,
-                .end = nsio->res.end,
-        };
 
-        nvdimm_bus = to_nvdimm_bus(nd_region->dev.parent);
+        if (!is_nd_pmem(&nd_region->dev)) {
+                dev_WARN_ONCE(&nd_region->dev, 1,
+                                "%s only valid for pmem regions\n", __func__);
+                return;
+        }
+        nvdimm_bus = walk_to_nvdimm_bus(&nd_region->dev);
         poison_list = &nvdimm_bus->poison_list;
 
         nvdimm_bus_lock(&nvdimm_bus->dev);
-        namespace_add_poison(poison_list, bb, &res);
+        badblocks_populate(poison_list, bb, res);
         nvdimm_bus_unlock(&nvdimm_bus->dev);
 }
-EXPORT_SYMBOL_GPL(nvdimm_namespace_add_poison);
+EXPORT_SYMBOL_GPL(nvdimm_badblocks_populate);
 
 static int add_poison(struct nvdimm_bus *nvdimm_bus, u64 addr, u64 length)
 {
diff --git a/drivers/nvdimm/nd.h b/drivers/nvdimm/nd.h
index 1799bd97a9ce..875c524fafb0 100644
--- a/drivers/nvdimm/nd.h
+++ b/drivers/nvdimm/nd.h
@@ -266,8 +266,8 @@ int nvdimm_namespace_attach_btt(struct nd_namespace_common *ndns);
 int nvdimm_namespace_detach_btt(struct nd_namespace_common *ndns);
 const char *nvdimm_namespace_disk_name(struct nd_namespace_common *ndns,
                 char *name);
-void nvdimm_namespace_add_poison(struct nd_namespace_common *ndns,
-                struct badblocks *bb, resource_size_t offset);
+void nvdimm_badblocks_populate(struct nd_region *nd_region,
+                struct badblocks *bb, const struct resource *res);
 int nd_blk_region_init(struct nd_region *nd_region);
 void __nd_iostat_start(struct bio *bio, unsigned long *start);
 static inline bool nd_iostat_start(struct bio *bio, unsigned long *start)
diff --git a/drivers/nvdimm/pfn_devs.c b/drivers/nvdimm/pfn_devs.c
index 254d3bc13f70..e071e214feba 100644
--- a/drivers/nvdimm/pfn_devs.c
+++ b/drivers/nvdimm/pfn_devs.c
@@ -376,7 +376,7 @@ int nd_pfn_validate(struct nd_pfn *nd_pfn)
         } else {
                 /* from init we validate */
                 if (memcmp(nd_pfn->uuid, pfn_sb->uuid, 16) != 0)
-                        return -EINVAL;
+                        return -ENODEV;
         }
 
         if (nd_pfn->align > nvdimm_namespace_capacity(ndns)) {
diff --git a/drivers/nvdimm/pmem.c b/drivers/nvdimm/pmem.c
index ca5721c306bb..5101f3ab4f29 100644
--- a/drivers/nvdimm/pmem.c
+++ b/drivers/nvdimm/pmem.c
@@ -99,10 +99,24 @@ static int pmem_do_bvec(struct pmem_device *pmem, struct page *page,
                 if (unlikely(bad_pmem))
                         rc = -EIO;
                 else {
-                        memcpy_from_pmem(mem + off, pmem_addr, len);
+                        rc = memcpy_from_pmem(mem + off, pmem_addr, len);
                         flush_dcache_page(page);
                 }
         } else {
+                /*
+                 * Note that we write the data both before and after
+                 * clearing poison.  The write before clear poison
+                 * handles situations where the latest written data is
+                 * preserved and the clear poison operation simply marks
+                 * the address range as valid without changing the data.
+                 * In this case application software can assume that an
+                 * interrupted write will either return the new good
+                 * data or an error.
+                 *
+                 * However, if pmem_clear_poison() leaves the data in an
+                 * indeterminate state we need to perform the write
+                 * after clear poison.
+                 */
                 flush_dcache_page(page);
                 memcpy_to_pmem(pmem_addr, mem + off, len);
                 if (unlikely(bad_pmem)) {
@@ -151,7 +165,7 @@ static int pmem_rw_page(struct block_device *bdev, sector_t sector,
         struct pmem_device *pmem = bdev->bd_disk->private_data;
         int rc;
 
-        rc = pmem_do_bvec(pmem, page, PAGE_CACHE_SIZE, 0, rw, sector);
+        rc = pmem_do_bvec(pmem, page, PAGE_SIZE, 0, rw, sector);
         if (rw & WRITE)
                 wmb_pmem();
 
@@ -244,7 +258,9 @@ static void pmem_detach_disk(struct pmem_device *pmem)
 static int pmem_attach_disk(struct device *dev,
                 struct nd_namespace_common *ndns, struct pmem_device *pmem)
 {
+        struct nd_namespace_io *nsio = to_nd_namespace_io(&ndns->dev);
         int nid = dev_to_node(dev);
+        struct resource bb_res;
         struct gendisk *disk;
 
         blk_queue_make_request(pmem->pmem_queue, pmem_make_request);
@@ -271,8 +287,17 @@ static int pmem_attach_disk(struct device *dev,
         devm_exit_badblocks(dev, &pmem->bb);
         if (devm_init_badblocks(dev, &pmem->bb))
                 return -ENOMEM;
-        nvdimm_namespace_add_poison(ndns, &pmem->bb, pmem->data_offset);
-
+        bb_res.start = nsio->res.start + pmem->data_offset;
+        bb_res.end = nsio->res.end;
+        if (is_nd_pfn(dev)) {
+                struct nd_pfn *nd_pfn = to_nd_pfn(dev);
+                struct nd_pfn_sb *pfn_sb = nd_pfn->pfn_sb;
+
+                bb_res.start += __le32_to_cpu(pfn_sb->start_pad);
+                bb_res.end -= __le32_to_cpu(pfn_sb->end_trunc);
+        }
+        nvdimm_badblocks_populate(to_nd_region(dev->parent), &pmem->bb,
+                        &bb_res);
         disk->bb = &pmem->bb;
         add_disk(disk);
         revalidate_disk(disk);
@@ -295,7 +320,7 @@ static int pmem_rw_bytes(struct nd_namespace_common *ndns,
 
                 if (unlikely(is_bad_pmem(&pmem->bb, offset / 512, sz_align)))
                         return -EIO;
-                memcpy_from_pmem(buf, pmem->virt_addr + offset, size);
+                return memcpy_from_pmem(buf, pmem->virt_addr + offset, size);
         } else {
                 memcpy_to_pmem(pmem->virt_addr + offset, buf, size);
                 wmb_pmem();
@@ -372,10 +397,17 @@ static int nd_pfn_init(struct nd_pfn *nd_pfn)
          */
         start += start_pad;
         npfns = (pmem->size - start_pad - end_trunc - SZ_8K) / SZ_4K;
-        if (nd_pfn->mode == PFN_MODE_PMEM)
-                offset = ALIGN(start + SZ_8K + 64 * npfns, nd_pfn->align)
+        if (nd_pfn->mode == PFN_MODE_PMEM) {
+                unsigned long memmap_size;
+
+                /*
+                 * vmemmap_populate_hugepages() allocates the memmap array in
+                 * HPAGE_SIZE chunks.
+                 */
+                memmap_size = ALIGN(64 * npfns, HPAGE_SIZE);
+                offset = ALIGN(start + SZ_8K + memmap_size, nd_pfn->align)
                         - start;
-        else if (nd_pfn->mode == PFN_MODE_RAM)
+        } else if (nd_pfn->mode == PFN_MODE_RAM)
                 offset = ALIGN(start + SZ_8K, nd_pfn->align) - start;
         else
                 goto err;
@@ -553,7 +585,7 @@ static int nd_pmem_probe(struct device *dev)
         ndns->rw_bytes = pmem_rw_bytes;
         if (devm_init_badblocks(dev, &pmem->bb))
                 return -ENOMEM;
-        nvdimm_namespace_add_poison(ndns, &pmem->bb, 0);
+        nvdimm_badblocks_populate(nd_region, &pmem->bb, &nsio->res);
 
         if (is_nd_btt(dev)) {
                 /* btt allocates its own request_queue */
@@ -595,14 +627,25 @@ static void nd_pmem_notify(struct device *dev, enum nvdimm_event event)
 {
         struct pmem_device *pmem = dev_get_drvdata(dev);
         struct nd_namespace_common *ndns = pmem->ndns;
+        struct nd_region *nd_region = to_nd_region(dev->parent);
+        struct nd_namespace_io *nsio = to_nd_namespace_io(&ndns->dev);
+        struct resource res = {
+                .start = nsio->res.start + pmem->data_offset,
+                .end = nsio->res.end,
+        };
 
         if (event != NVDIMM_REVALIDATE_POISON)
                 return;
 
-        if (is_nd_btt(dev))
-                nvdimm_namespace_add_poison(ndns, &pmem->bb, 0);
-        else
-                nvdimm_namespace_add_poison(ndns, &pmem->bb, pmem->data_offset);
+        if (is_nd_pfn(dev)) {
+                struct nd_pfn *nd_pfn = to_nd_pfn(dev);
+                struct nd_pfn_sb *pfn_sb = nd_pfn->pfn_sb;
+
+                res.start += __le32_to_cpu(pfn_sb->start_pad);
+                res.end -= __le32_to_cpu(pfn_sb->end_trunc);
+        }
+
+        nvdimm_badblocks_populate(nd_region, &pmem->bb, &res);
 }
 
 MODULE_ALIAS("pmem");
diff --git a/drivers/nvme/host/pci.c b/drivers/nvme/host/pci.c
index 24ccda303efb..4fd733ff72b1 100644
--- a/drivers/nvme/host/pci.c
+++ b/drivers/nvme/host/pci.c
@@ -1478,8 +1478,7 @@ static int nvme_setup_io_queues(struct nvme_dev *dev)
         if (result > 0) {
                 dev_err(dev->ctrl.device,
                         "Could not set queue count (%d)\n", result);
-                nr_io_queues = 0;
-                result = 0;
+                return 0;
         }
 
         if (dev->cmb && NVME_CMB_SQS(dev->cmbsz)) {
@@ -1513,7 +1512,9 @@ static int nvme_setup_io_queues(struct nvme_dev *dev)
          * If we enable msix early due to not intx, disable it again before
          * setting up the full range we need.
          */
-        if (!pdev->irq)
+        if (pdev->msi_enabled)
+                pci_disable_msi(pdev);
+        else if (pdev->msix_enabled)
                 pci_disable_msix(pdev);
 
         for (i = 0; i < nr_io_queues; i++)
@@ -1696,7 +1697,6 @@ static int nvme_pci_enable(struct nvme_dev *dev)
         if (pci_enable_device_mem(pdev))
                 return result;
 
-        dev->entry[0].vector = pdev->irq;
         pci_set_master(pdev);
 
         if (dma_set_mask_and_coherent(dev->dev, DMA_BIT_MASK(64)) &&
@@ -1709,13 +1709,18 @@ static int nvme_pci_enable(struct nvme_dev *dev)
         }
 
         /*
-         * Some devices don't advertse INTx interrupts, pre-enable a single
-         * MSIX vec for setup. We'll adjust this later.
+         * Some devices and/or platforms don't advertise or work with INTx
+         * interrupts. Pre-enable a single MSIX or MSI vec for setup. We'll
+         * adjust this later.
          */
-        if (!pdev->irq) {
-                result = pci_enable_msix(pdev, dev->entry, 1);
-                if (result < 0)
-                        goto disable;
+        if (pci_enable_msix(pdev, dev->entry, 1)) {
+                pci_enable_msi(pdev);
+                dev->entry[0].vector = pdev->irq;
+        }
+
+        if (!dev->entry[0].vector) {
+                result = -ENODEV;
+                goto disable;
         }
 
         cap = lo_hi_readq(dev->bar + NVME_REG_CAP);
@@ -1859,6 +1864,9 @@ static void nvme_reset_work(struct work_struct *work)
         if (dev->ctrl.ctrl_config & NVME_CC_ENABLE)
                 nvme_dev_disable(dev, false);
 
+        if (test_bit(NVME_CTRL_REMOVING, &dev->flags))
+                goto out;
+
         set_bit(NVME_CTRL_RESETTING, &dev->flags);
 
         result = nvme_pci_enable(dev);
@@ -2078,11 +2086,10 @@ static void nvme_remove(struct pci_dev *pdev)
 {
         struct nvme_dev *dev = pci_get_drvdata(pdev);
 
-        del_timer_sync(&dev->watchdog_timer);
-
         set_bit(NVME_CTRL_REMOVING, &dev->flags);
         pci_set_drvdata(pdev, NULL);
         flush_work(&dev->async_work);
+        flush_work(&dev->reset_work);
         flush_work(&dev->scan_work);
         nvme_remove_namespaces(&dev->ctrl);
         nvme_uninit_ctrl(&dev->ctrl);
diff --git a/drivers/nvmem/mxs-ocotp.c b/drivers/nvmem/mxs-ocotp.c
index 8ba19bba3156..2bb3c5799ac4 100644
--- a/drivers/nvmem/mxs-ocotp.c
+++ b/drivers/nvmem/mxs-ocotp.c
@@ -94,7 +94,7 @@ static int mxs_ocotp_read(void *context, const void *reg, size_t reg_size,
         if (ret)
                 goto close_banks;
 
-        while (val_size) {
+        while (val_size >= reg_size) {
                 if ((offset < OCOTP_DATA_OFFSET) || (offset % 16)) {
                         /* fill up non-data register */
                         *buf = 0;
@@ -103,7 +103,7 @@ static int mxs_ocotp_read(void *context, const void *reg, size_t reg_size,
                 }
 
                 buf++;
-                val_size--;
+                val_size -= reg_size;
                 offset += reg_size;
         }
 
diff --git a/drivers/oprofile/oprofilefs.c b/drivers/oprofile/oprofilefs.c
index b48ac6300c79..a0e5260bd006 100644
--- a/drivers/oprofile/oprofilefs.c
+++ b/drivers/oprofile/oprofilefs.c
@@ -239,8 +239,8 @@ static int oprofilefs_fill_super(struct super_block *sb, void *data, int silent)
 {
         struct inode *root_inode;
 
-        sb->s_blocksize = PAGE_CACHE_SIZE;
-        sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
+        sb->s_blocksize = PAGE_SIZE;
+        sb->s_blocksize_bits = PAGE_SHIFT;
         sb->s_magic = OPROFILEFS_MAGIC;
         sb->s_op = &s_ops;
         sb->s_time_gran = 1;
diff --git a/drivers/pci/access.c b/drivers/pci/access.c
index 01b9d0a00abc..d11cdbb8fba3 100644
--- a/drivers/pci/access.c
+++ b/drivers/pci/access.c
@@ -275,6 +275,19 @@ ssize_t pci_write_vpd(struct pci_dev *dev, loff_t pos, size_t count, const void
 }
 EXPORT_SYMBOL(pci_write_vpd);
 
+/**
+ * pci_set_vpd_size - Set size of Vital Product Data space
+ * @dev:        pci device struct
+ * @len:        size of vpd space
+ */
+int pci_set_vpd_size(struct pci_dev *dev, size_t len)
+{
+        if (!dev->vpd || !dev->vpd->ops)
+                return -ENODEV;
+        return dev->vpd->ops->set_size(dev, len);
+}
+EXPORT_SYMBOL(pci_set_vpd_size);
+
 #define PCI_VPD_MAX_SIZE (PCI_VPD_ADDR_MASK + 1)
 
 /**
@@ -498,9 +511,23 @@ out:
         return ret ? ret : count;
 }
 
+static int pci_vpd_set_size(struct pci_dev *dev, size_t len)
+{
+        struct pci_vpd *vpd = dev->vpd;
+
+        if (len == 0 || len > PCI_VPD_MAX_SIZE)
+                return -EIO;
+
+        vpd->valid = 1;
+        vpd->len = len;
+
+        return 0;
+}
+
 static const struct pci_vpd_ops pci_vpd_ops = {
         .read = pci_vpd_read,
         .write = pci_vpd_write,
+        .set_size = pci_vpd_set_size,
 };
 
 static ssize_t pci_vpd_f0_read(struct pci_dev *dev, loff_t pos, size_t count,
@@ -533,9 +560,24 @@ static ssize_t pci_vpd_f0_write(struct pci_dev *dev, loff_t pos, size_t count,
         return ret;
 }
 
+static int pci_vpd_f0_set_size(struct pci_dev *dev, size_t len)
+{
+        struct pci_dev *tdev = pci_get_slot(dev->bus,
+                                            PCI_DEVFN(PCI_SLOT(dev->devfn), 0));
+        int ret;
+
+        if (!tdev)
+                return -ENODEV;
+
+        ret = pci_set_vpd_size(tdev, len);
+        pci_dev_put(tdev);
+        return ret;
+}
+
 static const struct pci_vpd_ops pci_vpd_f0_ops = {
         .read = pci_vpd_f0_read,
         .write = pci_vpd_f0_write,
+        .set_size = pci_vpd_f0_set_size,
 };
 
 int pci_vpd_init(struct pci_dev *dev)
diff --git a/drivers/pci/host/pci-imx6.c b/drivers/pci/host/pci-imx6.c
index eb5a2755a164..2f817fa4c661 100644
--- a/drivers/pci/host/pci-imx6.c
+++ b/drivers/pci/host/pci-imx6.c
@@ -32,7 +32,7 @@
 #define to_imx6_pcie(x) container_of(x, struct imx6_pcie, pp)
 
 struct imx6_pcie {
-        struct gpio_desc        *reset_gpio;
+        int                     reset_gpio;
         struct clk              *pcie_bus;
         struct clk              *pcie_phy;
         struct clk              *pcie;
@@ -309,10 +309,10 @@ static int imx6_pcie_deassert_core_reset(struct pcie_port *pp)
         usleep_range(200, 500);
 
         /* Some boards don't have PCIe reset GPIO. */
-        if (imx6_pcie->reset_gpio) {
-                gpiod_set_value_cansleep(imx6_pcie->reset_gpio, 0);
+        if (gpio_is_valid(imx6_pcie->reset_gpio)) {
+                gpio_set_value_cansleep(imx6_pcie->reset_gpio, 0);
                 msleep(100);
-                gpiod_set_value_cansleep(imx6_pcie->reset_gpio, 1);
+                gpio_set_value_cansleep(imx6_pcie->reset_gpio, 1);
         }
         return 0;
 
@@ -523,6 +523,7 @@ static int __init imx6_pcie_probe(struct platform_device *pdev)
 {
         struct imx6_pcie *imx6_pcie;
         struct pcie_port *pp;
+        struct device_node *np = pdev->dev.of_node;
         struct resource *dbi_base;
         struct device_node *node = pdev->dev.of_node;
         int ret;
@@ -544,8 +545,15 @@ static int __init imx6_pcie_probe(struct platform_device *pdev)
                 return PTR_ERR(pp->dbi_base);
 
         /* Fetch GPIOs */
-        imx6_pcie->reset_gpio = devm_gpiod_get_optional(&pdev->dev, "reset",
-                                                        GPIOD_OUT_LOW);
+        imx6_pcie->reset_gpio = of_get_named_gpio(np, "reset-gpio", 0);
+        if (gpio_is_valid(imx6_pcie->reset_gpio)) {
+                ret = devm_gpio_request_one(&pdev->dev, imx6_pcie->reset_gpio,
+                                            GPIOF_OUT_INIT_LOW, "PCIe reset");
+                if (ret) {
+                        dev_err(&pdev->dev, "unable to get reset gpio\n");
+                        return ret;
+                }
+        }
 
         /* Fetch clocks */
         imx6_pcie->pcie_phy = devm_clk_get(&pdev->dev, "pcie_phy");
diff --git a/drivers/pci/pci-sysfs.c b/drivers/pci/pci-sysfs.c
index e982010f0ed1..342b6918bbde 100644
--- a/drivers/pci/pci-sysfs.c
+++ b/drivers/pci/pci-sysfs.c
@@ -636,7 +636,7 @@ static ssize_t pci_read_config(struct file *filp, struct kobject *kobj,
         u8 *data = (u8 *) buf;
 
         /* Several chips lock up trying to read undefined config space */
-        if (security_capable(filp->f_cred, &init_user_ns, CAP_SYS_ADMIN) == 0)
+        if (file_ns_capable(filp, &init_user_ns, CAP_SYS_ADMIN))
                 size = dev->cfg_size;
         else if (dev->hdr_type == PCI_HEADER_TYPE_CARDBUS)
                 size = 128;
diff --git a/drivers/pci/pci.h b/drivers/pci/pci.h
index d0fb93481573..a814bbb80fcb 100644
--- a/drivers/pci/pci.h
+++ b/drivers/pci/pci.h
@@ -97,6 +97,7 @@ static inline bool pci_has_subordinate(struct pci_dev *pci_dev)
 struct pci_vpd_ops {
         ssize_t (*read)(struct pci_dev *dev, loff_t pos, size_t count, void *buf);
         ssize_t (*write)(struct pci_dev *dev, loff_t pos, size_t count, const void *buf);
+        int (*set_size)(struct pci_dev *dev, size_t len);
 };
 
 struct pci_vpd {
diff --git a/drivers/pcmcia/db1xxx_ss.c b/drivers/pcmcia/db1xxx_ss.c
index 4c2fa05b4589..944674ee3464 100644
--- a/drivers/pcmcia/db1xxx_ss.c
+++ b/drivers/pcmcia/db1xxx_ss.c
@@ -56,6 +56,7 @@ struct db1x_pcmcia_sock {
         int     stschg_irq;     /* card-status-change irq */
         int     card_irq;       /* card irq */
         int     eject_irq;      /* db1200/pb1200 have these */
+        int     insert_gpio;    /* db1000 carddetect gpio */
 
 #define BOARD_TYPE_DEFAULT      0       /* most boards */
 #define BOARD_TYPE_DB1200       1       /* IRQs aren't gpios */
@@ -83,7 +84,7 @@ static int db1200_card_inserted(struct db1x_pcmcia_sock *sock)
 /* carddetect gpio: low-active */
 static int db1000_card_inserted(struct db1x_pcmcia_sock *sock)
 {
-        return !gpio_get_value(irq_to_gpio(sock->insert_irq));
+        return !gpio_get_value(sock->insert_gpio);
 }
 
 static int db1x_card_inserted(struct db1x_pcmcia_sock *sock)
@@ -457,9 +458,15 @@ static int db1x_pcmcia_socket_probe(struct platform_device *pdev)
         r = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "card");
         sock->card_irq = r ? r->start : 0;
 
-        /* insert: irq which triggers on card insertion/ejection */
+        /* insert: irq which triggers on card insertion/ejection
+         * BIG FAT NOTE: on DB1000/1100/1500/1550 we pass a GPIO here!
+         */
         r = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "insert");
         sock->insert_irq = r ? r->start : -1;
+        if (sock->board_type == BOARD_TYPE_DEFAULT) {
+                sock->insert_gpio = r ? r->start : -1;
+                sock->insert_irq = r ? gpio_to_irq(r->start) : -1;
+        }
 
         /* stschg: irq which trigger on card status change (optional) */
         r = platform_get_resource_byname(pdev, IORESOURCE_IRQ, "stschg");
diff --git a/drivers/perf/arm_pmu.c b/drivers/perf/arm_pmu.c
index 32346b5a8a11..f70090897fdf 100644
--- a/drivers/perf/arm_pmu.c
+++ b/drivers/perf/arm_pmu.c
@@ -737,8 +737,19 @@ static void cpu_pm_pmu_setup(struct arm_pmu *armpmu, unsigned long cmd)
                         break;
                 case CPU_PM_EXIT:
                 case CPU_PM_ENTER_FAILED:
-                         /* Restore and enable the counter */
-                        armpmu_start(event, PERF_EF_RELOAD);
+                         /*
+                          * Restore and enable the counter.
+                          * armpmu_start() indirectly calls
+                          *
+                          * perf_event_update_userpage()
+                          *
+                          * that requires RCU read locking to be functional,
+                          * wrap the call within RCU_NONIDLE to make the
+                          * RCU subsystem aware this cpu is not idle from
+                          * an RCU perspective for the armpmu_start() call
+                          * duration.
+                          */
+                        RCU_NONIDLE(armpmu_start(event, PERF_EF_RELOAD));
                         break;
                 default:
                         break;
diff --git a/drivers/phy/phy-rockchip-dp.c b/drivers/phy/phy-rockchip-dp.c
index 77e2d02e6bee..793ecb6d87bc 100644
--- a/drivers/phy/phy-rockchip-dp.c
+++ b/drivers/phy/phy-rockchip-dp.c
@@ -86,6 +86,9 @@ static int rockchip_dp_phy_probe(struct platform_device *pdev)
         if (!np)
                 return -ENODEV;
 
+        if (!dev->parent || !dev->parent->of_node)
+                return -ENODEV;
+
         dp = devm_kzalloc(dev, sizeof(*dp), GFP_KERNEL);
         if (IS_ERR(dp))
                 return -ENOMEM;
@@ -104,9 +107,9 @@ static int rockchip_dp_phy_probe(struct platform_device *pdev)
                 return ret;
         }
 
-        dp->grf = syscon_regmap_lookup_by_phandle(np, "rockchip,grf");
+        dp->grf = syscon_node_to_regmap(dev->parent->of_node);
         if (IS_ERR(dp->grf)) {
-                dev_err(dev, "rk3288-dp needs rockchip,grf property\n");
+                dev_err(dev, "rk3288-dp needs the General Register Files syscon\n");
                 return PTR_ERR(dp->grf);
         }
 
diff --git a/drivers/phy/phy-rockchip-emmc.c b/drivers/phy/phy-rockchip-emmc.c
index 887b4c27195f..6ebcf3e41c46 100644
--- a/drivers/phy/phy-rockchip-emmc.c
+++ b/drivers/phy/phy-rockchip-emmc.c
@@ -176,7 +176,10 @@ static int rockchip_emmc_phy_probe(struct platform_device *pdev)
         struct regmap *grf;
         unsigned int reg_offset;
 
-        grf = syscon_regmap_lookup_by_phandle(dev->of_node, "rockchip,grf");
+        if (!dev->parent || !dev->parent->of_node)
+                return -ENODEV;
+
+        grf = syscon_node_to_regmap(dev->parent->of_node);
         if (IS_ERR(grf)) {
                 dev_err(dev, "Missing rockchip,grf property\n");
                 return PTR_ERR(grf);
diff --git a/drivers/pinctrl/freescale/Kconfig b/drivers/pinctrl/freescale/Kconfig
index debe1219d76d..fc8cbf611723 100644
--- a/drivers/pinctrl/freescale/Kconfig
+++ b/drivers/pinctrl/freescale/Kconfig
@@ -2,6 +2,7 @@ config PINCTRL_IMX
         bool
         select PINMUX
         select PINCONF
+        select REGMAP
 
 config PINCTRL_IMX1_CORE
         bool
diff --git a/drivers/pinctrl/freescale/pinctrl-imx.c b/drivers/pinctrl/freescale/pinctrl-imx.c
index 46210512d8ec..9cfa544072b5 100644
--- a/drivers/pinctrl/freescale/pinctrl-imx.c
+++ b/drivers/pinctrl/freescale/pinctrl-imx.c
@@ -762,19 +762,18 @@ int imx_pinctrl_probe(struct platform_device *pdev,
 
         if (of_property_read_bool(dev_np, "fsl,input-sel")) {
                 np = of_parse_phandle(dev_np, "fsl,input-sel", 0);
-                if (np) {
-                        ipctl->input_sel_base = of_iomap(np, 0);
-                        if (IS_ERR(ipctl->input_sel_base)) {
-                                of_node_put(np);
-                                dev_err(&pdev->dev,
-                                        "iomuxc input select base address not found\n");
-                                return PTR_ERR(ipctl->input_sel_base);
-                        }
-                } else {
+                if (!np) {
                         dev_err(&pdev->dev, "iomuxc fsl,input-sel property not found\n");
                         return -EINVAL;
                 }
+
+                ipctl->input_sel_base = of_iomap(np, 0);
                 of_node_put(np);
+                if (!ipctl->input_sel_base) {
+                        dev_err(&pdev->dev,
+                                "iomuxc input select base address not found\n");
+                        return -ENOMEM;
+                }
         }
 
         imx_pinctrl_desc.name = dev_name(&pdev->dev);
diff --git a/drivers/pinctrl/intel/pinctrl-intel.c b/drivers/pinctrl/intel/pinctrl-intel.c
index 85536b467c25..6c2c816f8e5f 100644
--- a/drivers/pinctrl/intel/pinctrl-intel.c
+++ b/drivers/pinctrl/intel/pinctrl-intel.c
@@ -665,6 +665,35 @@ static void intel_gpio_irq_ack(struct irq_data *d)
         spin_unlock(&pctrl->lock);
 }
 
+static void intel_gpio_irq_enable(struct irq_data *d)
+{
+        struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
+        struct intel_pinctrl *pctrl = gpiochip_get_data(gc);
+        const struct intel_community *community;
+        unsigned pin = irqd_to_hwirq(d);
+        unsigned long flags;
+
+        spin_lock_irqsave(&pctrl->lock, flags);
+
+        community = intel_get_community(pctrl, pin);
+        if (community) {
+                unsigned padno = pin_to_padno(community, pin);
+                unsigned gpp_size = community->gpp_size;
+                unsigned gpp_offset = padno % gpp_size;
+                unsigned gpp = padno / gpp_size;
+                u32 value;
+
+                /* Clear interrupt status first to avoid unexpected interrupt */
+                writel(BIT(gpp_offset), community->regs + GPI_IS + gpp * 4);
+
+                value = readl(community->regs + community->ie_offset + gpp * 4);
+                value |= BIT(gpp_offset);
+                writel(value, community->regs + community->ie_offset + gpp * 4);
+        }
+
+        spin_unlock_irqrestore(&pctrl->lock, flags);
+}
+
 static void intel_gpio_irq_mask_unmask(struct irq_data *d, bool mask)
 {
         struct gpio_chip *gc = irq_data_get_irq_chip_data(d);
@@ -741,8 +770,9 @@ static int intel_gpio_irq_type(struct irq_data *d, unsigned type)
                 value |= PADCFG0_RXINV;
         } else if (type & IRQ_TYPE_EDGE_RISING) {
                 value |= PADCFG0_RXEVCFG_EDGE << PADCFG0_RXEVCFG_SHIFT;
-        } else if (type & IRQ_TYPE_LEVEL_LOW) {
-                value |= PADCFG0_RXINV;
+        } else if (type & IRQ_TYPE_LEVEL_MASK) {
+                if (type & IRQ_TYPE_LEVEL_LOW)
+                        value |= PADCFG0_RXINV;
         } else {
                 value |= PADCFG0_RXEVCFG_DISABLED << PADCFG0_RXEVCFG_SHIFT;
         }
@@ -852,6 +882,7 @@ static irqreturn_t intel_gpio_irq(int irq, void *data)
 
 static struct irq_chip intel_gpio_irqchip = {
         .name = "intel-gpio",
+        .irq_enable = intel_gpio_irq_enable,
         .irq_ack = intel_gpio_irq_ack,
         .irq_mask = intel_gpio_irq_mask,
         .irq_unmask = intel_gpio_irq_unmask,
diff --git a/drivers/pinctrl/mediatek/pinctrl-mtk-common.c b/drivers/pinctrl/mediatek/pinctrl-mtk-common.c
index 2bbe6f7964a7..6ab8c3ccdeea 100644
--- a/drivers/pinctrl/mediatek/pinctrl-mtk-common.c
+++ b/drivers/pinctrl/mediatek/pinctrl-mtk-common.c
@@ -1004,7 +1004,8 @@ static int mtk_gpio_set_debounce(struct gpio_chip *chip, unsigned offset,
         struct mtk_pinctrl *pctl = dev_get_drvdata(chip->parent);
         int eint_num, virq, eint_offset;
         unsigned int set_offset, bit, clr_bit, clr_offset, rst, i, unmask, dbnc;
-        static const unsigned int dbnc_arr[] = {0 , 1, 16, 32, 64, 128, 256};
+        static const unsigned int debounce_time[] = {500, 1000, 16000, 32000, 64000,
+                                                128000, 256000};
         const struct mtk_desc_pin *pin;
         struct irq_data *d;
 
@@ -1022,9 +1023,9 @@ static int mtk_gpio_set_debounce(struct gpio_chip *chip, unsigned offset,
         if (!mtk_eint_can_en_debounce(pctl, eint_num))
                 return -ENOSYS;
 
-        dbnc = ARRAY_SIZE(dbnc_arr);
-        for (i = 0; i < ARRAY_SIZE(dbnc_arr); i++) {
-                if (debounce <= dbnc_arr[i]) {
+        dbnc = ARRAY_SIZE(debounce_time);
+        for (i = 0; i < ARRAY_SIZE(debounce_time); i++) {
+                if (debounce <= debounce_time[i]) {
                         dbnc = i;
                         break;
                 }
diff --git a/drivers/pinctrl/nomadik/pinctrl-nomadik.c b/drivers/pinctrl/nomadik/pinctrl-nomadik.c
index 352406108fa0..c8969dd49449 100644
--- a/drivers/pinctrl/nomadik/pinctrl-nomadik.c
+++ b/drivers/pinctrl/nomadik/pinctrl-nomadik.c
@@ -990,7 +990,7 @@ static void nmk_gpio_dbg_show_one(struct seq_file *s,
                 int val;
 
                 if (pull)
-                        pullidx = data_out ? 1 : 2;
+                        pullidx = data_out ? 2 : 1;
 
                 seq_printf(s, " gpio-%-3d (%-20.20s) in  %s %s",
                            gpio,
diff --git a/drivers/pinctrl/pinctrl-pistachio.c b/drivers/pinctrl/pinctrl-pistachio.c
index 856f736cb1a6..2673cd9d106e 100644
--- a/drivers/pinctrl/pinctrl-pistachio.c
+++ b/drivers/pinctrl/pinctrl-pistachio.c
@@ -469,27 +469,27 @@ static const char * const pistachio_mips_pll_lock_groups[] = {
         "mfio83",
 };
 
-static const char * const pistachio_sys_pll_lock_groups[] = {
+static const char * const pistachio_audio_pll_lock_groups[] = {
         "mfio84",
 };
 
-static const char * const pistachio_wifi_pll_lock_groups[] = {
+static const char * const pistachio_rpu_v_pll_lock_groups[] = {
         "mfio85",
 };
 
-static const char * const pistachio_bt_pll_lock_groups[] = {
+static const char * const pistachio_rpu_l_pll_lock_groups[] = {
         "mfio86",
 };
 
-static const char * const pistachio_rpu_v_pll_lock_groups[] = {
+static const char * const pistachio_sys_pll_lock_groups[] = {
         "mfio87",
 };
 
-static const char * const pistachio_rpu_l_pll_lock_groups[] = {
+static const char * const pistachio_wifi_pll_lock_groups[] = {
         "mfio88",
 };
 
-static const char * const pistachio_audio_pll_lock_groups[] = {
+static const char * const pistachio_bt_pll_lock_groups[] = {
         "mfio89",
 };
 
@@ -559,12 +559,12 @@ enum pistachio_mux_option {
         PISTACHIO_FUNCTION_DREQ4,
         PISTACHIO_FUNCTION_DREQ5,
         PISTACHIO_FUNCTION_MIPS_PLL_LOCK,
+        PISTACHIO_FUNCTION_AUDIO_PLL_LOCK,
+        PISTACHIO_FUNCTION_RPU_V_PLL_LOCK,
+        PISTACHIO_FUNCTION_RPU_L_PLL_LOCK,
         PISTACHIO_FUNCTION_SYS_PLL_LOCK,
         PISTACHIO_FUNCTION_WIFI_PLL_LOCK,
         PISTACHIO_FUNCTION_BT_PLL_LOCK,
-        PISTACHIO_FUNCTION_RPU_V_PLL_LOCK,
-        PISTACHIO_FUNCTION_RPU_L_PLL_LOCK,
-        PISTACHIO_FUNCTION_AUDIO_PLL_LOCK,
         PISTACHIO_FUNCTION_DEBUG_RAW_CCA_IND,
         PISTACHIO_FUNCTION_DEBUG_ED_SEC20_CCA_IND,
         PISTACHIO_FUNCTION_DEBUG_ED_SEC40_CCA_IND,
@@ -620,12 +620,12 @@ static const struct pistachio_function pistachio_functions[] = {
         FUNCTION(dreq4),
         FUNCTION(dreq5),
         FUNCTION(mips_pll_lock),
+        FUNCTION(audio_pll_lock),
+        FUNCTION(rpu_v_pll_lock),
+        FUNCTION(rpu_l_pll_lock),
         FUNCTION(sys_pll_lock),
         FUNCTION(wifi_pll_lock),
         FUNCTION(bt_pll_lock),
-        FUNCTION(rpu_v_pll_lock),
-        FUNCTION(rpu_l_pll_lock),
-        FUNCTION(audio_pll_lock),
         FUNCTION(debug_raw_cca_ind),
         FUNCTION(debug_ed_sec20_cca_ind),
         FUNCTION(debug_ed_sec40_cca_ind),
diff --git a/drivers/pinctrl/pinctrl-single.c b/drivers/pinctrl/pinctrl-single.c
index fb126d56ad40..cf9bafa10acf 100644
--- a/drivers/pinctrl/pinctrl-single.c
+++ b/drivers/pinctrl/pinctrl-single.c
@@ -1280,9 +1280,9 @@ static int pcs_parse_bits_in_pinctrl_entry(struct pcs_device *pcs,
 
                 /* Parse pins in each row from LSB */
                 while (mask) {
-                        bit_pos = ffs(mask);
+                        bit_pos = __ffs(mask);
                         pin_num_from_lsb = bit_pos / pcs->bits_per_pin;
-                        mask_pos = ((pcs->fmask) << (bit_pos - 1));
+                        mask_pos = ((pcs->fmask) << bit_pos);
                         val_pos = val & mask_pos;
                         submask = mask & mask_pos;
 
@@ -1852,7 +1852,7 @@ static int pcs_probe(struct platform_device *pdev)
         ret = of_property_read_u32(np, "pinctrl-single,function-mask",
                                    &pcs->fmask);
         if (!ret) {
-                pcs->fshift = ffs(pcs->fmask) - 1;
+                pcs->fshift = __ffs(pcs->fmask);
                 pcs->fmax = pcs->fmask >> pcs->fshift;
         } else {
                 /* If mask property doesn't exist, function mux is invalid. */
diff --git a/drivers/pinctrl/pinctrl-xway.c b/drivers/pinctrl/pinctrl-xway.c
index 412c6b78140a..a13f2b6f6fc0 100644
--- a/drivers/pinctrl/pinctrl-xway.c
+++ b/drivers/pinctrl/pinctrl-xway.c
@@ -1573,6 +1573,22 @@ static int xway_gpio_dir_out(struct gpio_chip *chip, unsigned int pin, int val)
         return 0;
 }
 
+/*
+ * gpiolib gpiod_to_irq callback function.
+ * Returns the mapped IRQ (external interrupt) number for a given GPIO pin.
+ */
+static int xway_gpio_to_irq(struct gpio_chip *chip, unsigned offset)
+{
+        struct ltq_pinmux_info *info = dev_get_drvdata(chip->parent);
+        int i;
+
+        for (i = 0; i < info->num_exin; i++)
+                if (info->exin[i] == offset)
+                        return ltq_eiu_get_irq(i);
+
+        return -1;
+}
+
 static struct gpio_chip xway_chip = {
         .label = "gpio-xway",
         .direction_input = xway_gpio_dir_in,
@@ -1581,6 +1597,7 @@ static struct gpio_chip xway_chip = {
         .set = xway_gpio_set,
         .request = gpiochip_generic_request,
         .free = gpiochip_generic_free,
+        .to_irq = xway_gpio_to_irq,
         .base = -1,
 };
 
diff --git a/drivers/pinctrl/qcom/pinctrl-ipq4019.c b/drivers/pinctrl/qcom/pinctrl-ipq4019.c
index b5d81ced6ce6..b68ae424cee2 100644
--- a/drivers/pinctrl/qcom/pinctrl-ipq4019.c
+++ b/drivers/pinctrl/qcom/pinctrl-ipq4019.c
@@ -237,7 +237,7 @@ DECLARE_QCA_GPIO_PINS(99);
                 .pins = gpio##id##_pins,                \
                 .npins = (unsigned)ARRAY_SIZE(gpio##id##_pins), \
                 .funcs = (int[]){                       \
-                        qca_mux_NA, /* gpio mode */     \
+                        qca_mux_gpio, /* gpio mode */   \
                         qca_mux_##f1,                   \
                         qca_mux_##f2,                   \
                         qca_mux_##f3,                   \
@@ -254,11 +254,11 @@ DECLARE_QCA_GPIO_PINS(99);
                         qca_mux_##f14                   \
                 },                                      \
                 .nfuncs = 15,                           \
-                .ctl_reg = 0x1000 + 0x10 * id,          \
-                .io_reg = 0x1004 + 0x10 * id,           \
-                .intr_cfg_reg = 0x1008 + 0x10 * id,     \
-                .intr_status_reg = 0x100c + 0x10 * id,  \
-                .intr_target_reg = 0x400 + 0x4 * id,    \
+                .ctl_reg = 0x0 + 0x1000 * id,           \
+                .io_reg = 0x4 + 0x1000 * id,            \
+                .intr_cfg_reg = 0x8 + 0x1000 * id,      \
+                .intr_status_reg = 0xc + 0x1000 * id,   \
+                .intr_target_reg = 0x8 + 0x1000 * id,   \
                 .mux_bit = 2,                   \
                 .pull_bit = 0,                  \
                 .drv_bit = 6,                   \
@@ -414,7 +414,7 @@ static const struct msm_pinctrl_soc_data ipq4019_pinctrl = {
         .nfunctions = ARRAY_SIZE(ipq4019_functions),
         .groups = ipq4019_groups,
         .ngroups = ARRAY_SIZE(ipq4019_groups),
-        .ngpios = 70,
+        .ngpios = 100,
 };
 
 static int ipq4019_pinctrl_probe(struct platform_device *pdev)
diff --git a/drivers/pinctrl/sh-pfc/core.c b/drivers/pinctrl/sh-pfc/core.c
index dc3609f0c60b..ee0c1f2567d9 100644
--- a/drivers/pinctrl/sh-pfc/core.c
+++ b/drivers/pinctrl/sh-pfc/core.c
@@ -546,7 +546,9 @@ static int sh_pfc_probe(struct platform_device *pdev)
                         return ret;
         }
 
-        pinctrl_provide_dummies();
+        /* Enable dummy states for those platforms without pinctrl support */
+        if (!of_have_populated_dt())
+                pinctrl_provide_dummies();
 
         ret = sh_pfc_init_ranges(pfc);
         if (ret < 0)
diff --git a/drivers/pinctrl/sunxi/pinctrl-sun8i-a33.c b/drivers/pinctrl/sunxi/pinctrl-sun8i-a33.c
index 00265f0435a7..8b381d69df86 100644
--- a/drivers/pinctrl/sunxi/pinctrl-sun8i-a33.c
+++ b/drivers/pinctrl/sunxi/pinctrl-sun8i-a33.c
@@ -485,6 +485,7 @@ static const struct sunxi_pinctrl_desc sun8i_a33_pinctrl_data = {
         .pins = sun8i_a33_pins,
         .npins = ARRAY_SIZE(sun8i_a33_pins),
         .irq_banks = 2,
+        .irq_bank_base = 1,
 };
 
 static int sun8i_a33_pinctrl_probe(struct platform_device *pdev)
diff --git a/drivers/pinctrl/sunxi/pinctrl-sunxi.c b/drivers/pinctrl/sunxi/pinctrl-sunxi.c
index 12a1dfabb1af..3b017dbd289c 100644
--- a/drivers/pinctrl/sunxi/pinctrl-sunxi.c
+++ b/drivers/pinctrl/sunxi/pinctrl-sunxi.c
@@ -579,7 +579,7 @@ static void sunxi_pinctrl_irq_release_resources(struct irq_data *d)
 static int sunxi_pinctrl_irq_set_type(struct irq_data *d, unsigned int type)
 {
         struct sunxi_pinctrl *pctl = irq_data_get_irq_chip_data(d);
-        u32 reg = sunxi_irq_cfg_reg(d->hwirq);
+        u32 reg = sunxi_irq_cfg_reg(d->hwirq, pctl->desc->irq_bank_base);
         u8 index = sunxi_irq_cfg_offset(d->hwirq);
         unsigned long flags;
         u32 regval;
@@ -626,7 +626,8 @@ static int sunxi_pinctrl_irq_set_type(struct irq_data *d, unsigned int type)
 static void sunxi_pinctrl_irq_ack(struct irq_data *d)
 {
         struct sunxi_pinctrl *pctl = irq_data_get_irq_chip_data(d);
-        u32 status_reg = sunxi_irq_status_reg(d->hwirq);
+        u32 status_reg = sunxi_irq_status_reg(d->hwirq,
+                                              pctl->desc->irq_bank_base);
         u8 status_idx = sunxi_irq_status_offset(d->hwirq);
 
         /* Clear the IRQ */
@@ -636,7 +637,7 @@ static void sunxi_pinctrl_irq_ack(struct irq_data *d)
 static void sunxi_pinctrl_irq_mask(struct irq_data *d)
 {
         struct sunxi_pinctrl *pctl = irq_data_get_irq_chip_data(d);
-        u32 reg = sunxi_irq_ctrl_reg(d->hwirq);
+        u32 reg = sunxi_irq_ctrl_reg(d->hwirq, pctl->desc->irq_bank_base);
         u8 idx = sunxi_irq_ctrl_offset(d->hwirq);
         unsigned long flags;
         u32 val;
@@ -653,7 +654,7 @@ static void sunxi_pinctrl_irq_mask(struct irq_data *d)
 static void sunxi_pinctrl_irq_unmask(struct irq_data *d)
 {
         struct sunxi_pinctrl *pctl = irq_data_get_irq_chip_data(d);
-        u32 reg = sunxi_irq_ctrl_reg(d->hwirq);
+        u32 reg = sunxi_irq_ctrl_reg(d->hwirq, pctl->desc->irq_bank_base);
         u8 idx = sunxi_irq_ctrl_offset(d->hwirq);
         unsigned long flags;
         u32 val;
@@ -745,7 +746,7 @@ static void sunxi_pinctrl_irq_handler(struct irq_desc *desc)
         if (bank == pctl->desc->irq_banks)
                 return;
 
-        reg = sunxi_irq_status_reg_from_bank(bank);
+        reg = sunxi_irq_status_reg_from_bank(bank, pctl->desc->irq_bank_base);
         val = readl(pctl->membase + reg);
 
         if (val) {
@@ -1024,9 +1025,11 @@ int sunxi_pinctrl_init(struct platform_device *pdev,
 
         for (i = 0; i < pctl->desc->irq_banks; i++) {
                 /* Mask and clear all IRQs before registering a handler */
-                writel(0, pctl->membase + sunxi_irq_ctrl_reg_from_bank(i));
+                writel(0, pctl->membase + sunxi_irq_ctrl_reg_from_bank(i,
+                                                pctl->desc->irq_bank_base));
                 writel(0xffffffff,
-                        pctl->membase + sunxi_irq_status_reg_from_bank(i));
+                       pctl->membase + sunxi_irq_status_reg_from_bank(i,
+                                                pctl->desc->irq_bank_base));
 
                 irq_set_chained_handler_and_data(pctl->irq[i],
                                                  sunxi_pinctrl_irq_handler,
diff --git a/drivers/pinctrl/sunxi/pinctrl-sunxi.h b/drivers/pinctrl/sunxi/pinctrl-sunxi.h
index e248e81a0f9e..0afce1ab12d0 100644
--- a/drivers/pinctrl/sunxi/pinctrl-sunxi.h
+++ b/drivers/pinctrl/sunxi/pinctrl-sunxi.h
@@ -97,6 +97,7 @@ struct sunxi_pinctrl_desc {
         int                             npins;
         unsigned                        pin_base;
         unsigned                        irq_banks;
+        unsigned                        irq_bank_base;
         bool                            irq_read_needs_mux;
 };
 
@@ -233,12 +234,12 @@ static inline u32 sunxi_pull_offset(u16 pin)
         return pin_num * PULL_PINS_BITS;
 }
 
-static inline u32 sunxi_irq_cfg_reg(u16 irq)
+static inline u32 sunxi_irq_cfg_reg(u16 irq, unsigned bank_base)
 {
         u8 bank = irq / IRQ_PER_BANK;
         u8 reg = (irq % IRQ_PER_BANK) / IRQ_CFG_IRQ_PER_REG * 0x04;
 
-        return IRQ_CFG_REG + bank * IRQ_MEM_SIZE + reg;
+        return IRQ_CFG_REG + (bank_base + bank) * IRQ_MEM_SIZE + reg;
 }
 
 static inline u32 sunxi_irq_cfg_offset(u16 irq)
@@ -247,16 +248,16 @@ static inline u32 sunxi_irq_cfg_offset(u16 irq)
         return irq_num * IRQ_CFG_IRQ_BITS;
 }
 
-static inline u32 sunxi_irq_ctrl_reg_from_bank(u8 bank)
+static inline u32 sunxi_irq_ctrl_reg_from_bank(u8 bank, unsigned bank_base)
 {
-        return IRQ_CTRL_REG + bank * IRQ_MEM_SIZE;
+        return IRQ_CTRL_REG + (bank_base + bank) * IRQ_MEM_SIZE;
 }
 
-static inline u32 sunxi_irq_ctrl_reg(u16 irq)
+static inline u32 sunxi_irq_ctrl_reg(u16 irq, unsigned bank_base)
 {
         u8 bank = irq / IRQ_PER_BANK;
 
-        return sunxi_irq_ctrl_reg_from_bank(bank);
+        return sunxi_irq_ctrl_reg_from_bank(bank, bank_base);
 }
 
 static inline u32 sunxi_irq_ctrl_offset(u16 irq)
@@ -265,16 +266,16 @@ static inline u32 sunxi_irq_ctrl_offset(u16 irq)
         return irq_num * IRQ_CTRL_IRQ_BITS;
 }
 
-static inline u32 sunxi_irq_status_reg_from_bank(u8 bank)
+static inline u32 sunxi_irq_status_reg_from_bank(u8 bank, unsigned bank_base)
 {
-        return IRQ_STATUS_REG + bank * IRQ_MEM_SIZE;
+        return IRQ_STATUS_REG + (bank_base + bank) * IRQ_MEM_SIZE;
 }
 
-static inline u32 sunxi_irq_status_reg(u16 irq)
+static inline u32 sunxi_irq_status_reg(u16 irq, unsigned bank_base)
 {
         u8 bank = irq / IRQ_PER_BANK;
 
-        return sunxi_irq_status_reg_from_bank(bank);
+        return sunxi_irq_status_reg_from_bank(bank, bank_base);
 }
 
 static inline u32 sunxi_irq_status_offset(u16 irq)
diff --git a/drivers/platform/goldfish/goldfish_pipe.c b/drivers/platform/goldfish/goldfish_pipe.c
index 9973cebb4d6f..07462d79d040 100644
--- a/drivers/platform/goldfish/goldfish_pipe.c
+++ b/drivers/platform/goldfish/goldfish_pipe.c
@@ -309,8 +309,7 @@ static ssize_t goldfish_pipe_read_write(struct file *filp, char __user *buffer,
                  * much memory to the process.
                  */
                 down_read(&current->mm->mmap_sem);
-                ret = get_user_pages(current, current->mm, address, 1,
-                                     !is_write, 0, &page, NULL);
+                ret = get_user_pages(address, 1, !is_write, 0, &page, NULL);
                 up_read(&current->mm->mmap_sem);
                 if (ret < 0)
                         break;
diff --git a/drivers/platform/x86/hp_accel.c b/drivers/platform/x86/hp_accel.c
index 10ce6cba4455..09356684c32f 100644
--- a/drivers/platform/x86/hp_accel.c
+++ b/drivers/platform/x86/hp_accel.c
@@ -127,8 +127,10 @@ static int lis3lv02d_acpi_read(struct lis3lv02d *lis3, int reg, u8 *ret)
         arg0.integer.value = reg;
 
         status = acpi_evaluate_integer(dev->handle, "ALRD", &args, &lret);
+        if (ACPI_FAILURE(status))
+                return -EINVAL;
         *ret = lret;
-        return (status != AE_OK) ? -EINVAL : 0;
+        return 0;
 }
 
 /**
@@ -173,6 +175,7 @@ static int lis3lv02d_dmi_matched(const struct dmi_system_id *dmi)
 DEFINE_CONV(normal, 1, 2, 3);
 DEFINE_CONV(y_inverted, 1, -2, 3);
 DEFINE_CONV(x_inverted, -1, 2, 3);
+DEFINE_CONV(x_inverted_usd, -1, 2, -3);
 DEFINE_CONV(z_inverted, 1, 2, -3);
 DEFINE_CONV(xy_swap, 2, 1, 3);
 DEFINE_CONV(xy_rotated_left, -2, 1, 3);
@@ -236,6 +239,7 @@ static const struct dmi_system_id lis3lv02d_dmi_ids[] = {
         AXIS_DMI_MATCH("HP8710", "HP Compaq 8710", y_inverted),
         AXIS_DMI_MATCH("HDX18", "HP HDX 18", x_inverted),
         AXIS_DMI_MATCH("HPB432x", "HP ProBook 432", xy_rotated_left),
+        AXIS_DMI_MATCH("HPB440G3", "HP ProBook 440 G3", x_inverted_usd),
         AXIS_DMI_MATCH("HPB442x", "HP ProBook 442", xy_rotated_left),
         AXIS_DMI_MATCH("HPB452x", "HP ProBook 452", y_inverted),
         AXIS_DMI_MATCH("HPB522x", "HP ProBook 522", xy_swap),
diff --git a/drivers/platform/x86/intel-hid.c b/drivers/platform/x86/intel-hid.c
index f93abc8c1424..a818db6aa08f 100644
--- a/drivers/platform/x86/intel-hid.c
+++ b/drivers/platform/x86/intel-hid.c
@@ -91,6 +91,8 @@ static int intel_hid_pl_resume_handler(struct device *device)
 }
 
 static const struct dev_pm_ops intel_hid_pl_pm_ops = {
+        .freeze  = intel_hid_pl_suspend_handler,
+        .restore  = intel_hid_pl_resume_handler,
         .suspend  = intel_hid_pl_suspend_handler,
         .resume  = intel_hid_pl_resume_handler,
 };
diff --git a/drivers/platform/x86/intel_pmc_ipc.c b/drivers/platform/x86/intel_pmc_ipc.c
index 3fb1d85c70a8..6f497e80c9df 100644
--- a/drivers/platform/x86/intel_pmc_ipc.c
+++ b/drivers/platform/x86/intel_pmc_ipc.c
@@ -687,8 +687,8 @@ static int ipc_plat_get_res(struct platform_device *pdev)
         ipcdev.acpi_io_size = size;
         dev_info(&pdev->dev, "io res: %pR\n", res);
 
-        /* This is index 0 to cover BIOS data register */
         punit_res = punit_res_array;
+        /* This is index 0 to cover BIOS data register */
         res = platform_get_resource(pdev, IORESOURCE_MEM,
                                     PLAT_RESOURCE_BIOS_DATA_INDEX);
         if (!res) {
@@ -698,55 +698,51 @@ static int ipc_plat_get_res(struct platform_device *pdev)
         *punit_res = *res;
         dev_info(&pdev->dev, "punit BIOS data res: %pR\n", res);
 
+        /* This is index 1 to cover BIOS interface register */
         res = platform_get_resource(pdev, IORESOURCE_MEM,
                                     PLAT_RESOURCE_BIOS_IFACE_INDEX);
         if (!res) {
                 dev_err(&pdev->dev, "Failed to get res of punit BIOS iface\n");
                 return -ENXIO;
         }
-        /* This is index 1 to cover BIOS interface register */
         *++punit_res = *res;
         dev_info(&pdev->dev, "punit BIOS interface res: %pR\n", res);
 
+        /* This is index 2 to cover ISP data register, optional */
         res = platform_get_resource(pdev, IORESOURCE_MEM,
                                     PLAT_RESOURCE_ISP_DATA_INDEX);
-        if (!res) {
-                dev_err(&pdev->dev, "Failed to get res of punit ISP data\n");
-                return -ENXIO;
+        ++punit_res;
+        if (res) {
+                *punit_res = *res;
+                dev_info(&pdev->dev, "punit ISP data res: %pR\n", res);
         }
-        /* This is index 2 to cover ISP data register */
-        *++punit_res = *res;
-        dev_info(&pdev->dev, "punit ISP data res: %pR\n", res);
 
+        /* This is index 3 to cover ISP interface register, optional */
         res = platform_get_resource(pdev, IORESOURCE_MEM,
                                     PLAT_RESOURCE_ISP_IFACE_INDEX);
-        if (!res) {
-                dev_err(&pdev->dev, "Failed to get res of punit ISP iface\n");
-                return -ENXIO;
+        ++punit_res;
+        if (res) {
+                *punit_res = *res;
+                dev_info(&pdev->dev, "punit ISP interface res: %pR\n", res);
         }
-        /* This is index 3 to cover ISP interface register */
-        *++punit_res = *res;
-        dev_info(&pdev->dev, "punit ISP interface res: %pR\n", res);
 
+        /* This is index 4 to cover GTD data register, optional */
         res = platform_get_resource(pdev, IORESOURCE_MEM,
                                     PLAT_RESOURCE_GTD_DATA_INDEX);
-        if (!res) {
-                dev_err(&pdev->dev, "Failed to get res of punit GTD data\n");
-                return -ENXIO;
+        ++punit_res;
+        if (res) {
+                *punit_res = *res;
+                dev_info(&pdev->dev, "punit GTD data res: %pR\n", res);
         }
-        /* This is index 4 to cover GTD data register */
-        *++punit_res = *res;
-        dev_info(&pdev->dev, "punit GTD data res: %pR\n", res);
 
+        /* This is index 5 to cover GTD interface register, optional */
         res = platform_get_resource(pdev, IORESOURCE_MEM,
                                     PLAT_RESOURCE_GTD_IFACE_INDEX);
-        if (!res) {
-                dev_err(&pdev->dev, "Failed to get res of punit GTD iface\n");
-                return -ENXIO;
+        ++punit_res;
+        if (res) {
+                *punit_res = *res;
+                dev_info(&pdev->dev, "punit GTD interface res: %pR\n", res);
         }
-        /* This is index 5 to cover GTD interface register */
-        *++punit_res = *res;
-        dev_info(&pdev->dev, "punit GTD interface res: %pR\n", res);
 
         res = platform_get_resource(pdev, IORESOURCE_MEM,
                                     PLAT_RESOURCE_IPC_INDEX);
diff --git a/drivers/platform/x86/intel_punit_ipc.c b/drivers/platform/x86/intel_punit_ipc.c
index bd875409a02d..a47a41fc10ad 100644
--- a/drivers/platform/x86/intel_punit_ipc.c
+++ b/drivers/platform/x86/intel_punit_ipc.c
@@ -227,6 +227,11 @@ static int intel_punit_get_bars(struct platform_device *pdev)
         struct resource *res;
         void __iomem *addr;
 
+        /*
+         * The following resources are required
+         * - BIOS_IPC BASE_DATA
+         * - BIOS_IPC BASE_IFACE
+         */
         res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
         addr = devm_ioremap_resource(&pdev->dev, res);
         if (IS_ERR(addr))
@@ -239,29 +244,40 @@ static int intel_punit_get_bars(struct platform_device *pdev)
                 return PTR_ERR(addr);
         punit_ipcdev->base[BIOS_IPC][BASE_IFACE] = addr;
 
+        /*
+         * The following resources are optional
+         * - ISPDRIVER_IPC BASE_DATA
+         * - ISPDRIVER_IPC BASE_IFACE
+         * - GTDRIVER_IPC BASE_DATA
+         * - GTDRIVER_IPC BASE_IFACE
+         */
         res = platform_get_resource(pdev, IORESOURCE_MEM, 2);
-        addr = devm_ioremap_resource(&pdev->dev, res);
-        if (IS_ERR(addr))
-                return PTR_ERR(addr);
-        punit_ipcdev->base[ISPDRIVER_IPC][BASE_DATA] = addr;
+        if (res) {
+                addr = devm_ioremap_resource(&pdev->dev, res);
+                if (!IS_ERR(addr))
+                        punit_ipcdev->base[ISPDRIVER_IPC][BASE_DATA] = addr;
+        }
 
         res = platform_get_resource(pdev, IORESOURCE_MEM, 3);
-        addr = devm_ioremap_resource(&pdev->dev, res);
-        if (IS_ERR(addr))
-                return PTR_ERR(addr);
-        punit_ipcdev->base[ISPDRIVER_IPC][BASE_IFACE] = addr;
+        if (res) {
+                addr = devm_ioremap_resource(&pdev->dev, res);
+                if (!IS_ERR(addr))
+                        punit_ipcdev->base[ISPDRIVER_IPC][BASE_IFACE] = addr;
+        }
 
         res = platform_get_resource(pdev, IORESOURCE_MEM, 4);
-        addr = devm_ioremap_resource(&pdev->dev, res);
-        if (IS_ERR(addr))
-                return PTR_ERR(addr);
-        punit_ipcdev->base[GTDRIVER_IPC][BASE_DATA] = addr;
+        if (res) {
+                addr = devm_ioremap_resource(&pdev->dev, res);
+                if (!IS_ERR(addr))
+                        punit_ipcdev->base[GTDRIVER_IPC][BASE_DATA] = addr;
+        }
 
         res = platform_get_resource(pdev, IORESOURCE_MEM, 5);
-        addr = devm_ioremap_resource(&pdev->dev, res);
-        if (IS_ERR(addr))
-                return PTR_ERR(addr);
-        punit_ipcdev->base[GTDRIVER_IPC][BASE_IFACE] = addr;
+        if (res) {
+                addr = devm_ioremap_resource(&pdev->dev, res);
+                if (!IS_ERR(addr))
+                        punit_ipcdev->base[GTDRIVER_IPC][BASE_IFACE] = addr;
+        }
 
         return 0;
 }
diff --git a/drivers/platform/x86/intel_telemetry_pltdrv.c b/drivers/platform/x86/intel_telemetry_pltdrv.c
index 397119f83e82..781bd10ca7ac 100644
--- a/drivers/platform/x86/intel_telemetry_pltdrv.c
+++ b/drivers/platform/x86/intel_telemetry_pltdrv.c
@@ -659,7 +659,7 @@ static int telemetry_plt_update_events(struct telemetry_evtconfig pss_evtconfig,
 static int telemetry_plt_set_sampling_period(u8 pss_period, u8 ioss_period)
 {
         u32 telem_ctrl = 0;
-        int ret;
+        int ret = 0;
 
         mutex_lock(&(telm_conf->telem_lock));
         if (ioss_period) {
diff --git a/drivers/platform/x86/thinkpad_acpi.c b/drivers/platform/x86/thinkpad_acpi.c
index e305ab541a22..9255ff3ee81a 100644
--- a/drivers/platform/x86/thinkpad_acpi.c
+++ b/drivers/platform/x86/thinkpad_acpi.c
@@ -7972,10 +7972,12 @@ static int fan_get_status_safe(u8 *status)
                 fan_update_desired_level(s);
         mutex_unlock(&fan_mutex);
 
+        if (rc)
+                return rc;
         if (status)
                 *status = s;
 
-        return rc;
+        return 0;
 }
 
 static int fan_get_speed(unsigned int *speed)
diff --git a/drivers/platform/x86/toshiba_acpi.c b/drivers/platform/x86/toshiba_acpi.c
index df1f1a76a862..01e12d221a8b 100644
--- a/drivers/platform/x86/toshiba_acpi.c
+++ b/drivers/platform/x86/toshiba_acpi.c
@@ -135,7 +135,7 @@ MODULE_LICENSE("GPL");
 /* Field definitions */
 #define HCI_ACCEL_MASK                  0x7fff
 #define HCI_HOTKEY_DISABLE              0x0b
-#define HCI_HOTKEY_ENABLE               0x01
+#define HCI_HOTKEY_ENABLE               0x09
 #define HCI_HOTKEY_SPECIAL_FUNCTIONS    0x10
 #define HCI_LCD_BRIGHTNESS_BITS         3
 #define HCI_LCD_BRIGHTNESS_SHIFT        (16-HCI_LCD_BRIGHTNESS_BITS)
diff --git a/drivers/powercap/intel_rapl.c b/drivers/powercap/intel_rapl.c
index cdfd01f0adb8..8fad0a7044d3 100644
--- a/drivers/powercap/intel_rapl.c
+++ b/drivers/powercap/intel_rapl.c
@@ -1091,6 +1091,7 @@ static const struct x86_cpu_id rapl_ids[] __initconst = {
         RAPL_CPU(0x3f, rapl_defaults_hsw_server),/* Haswell servers */
         RAPL_CPU(0x4f, rapl_defaults_hsw_server),/* Broadwell servers */
         RAPL_CPU(0x45, rapl_defaults_core),/* Haswell ULT */
+        RAPL_CPU(0x46, rapl_defaults_core),/* Haswell */
         RAPL_CPU(0x47, rapl_defaults_core),/* Broadwell-H */
         RAPL_CPU(0x4E, rapl_defaults_core),/* Skylake */
         RAPL_CPU(0x4C, rapl_defaults_cht),/* Braswell/Cherryview */
diff --git a/drivers/pwm/pwm-fsl-ftm.c b/drivers/pwm/pwm-fsl-ftm.c
index 7225ac6b3df5..fad968eb75f6 100644
--- a/drivers/pwm/pwm-fsl-ftm.c
+++ b/drivers/pwm/pwm-fsl-ftm.c
@@ -392,7 +392,7 @@ static const struct regmap_config fsl_pwm_regmap_config = {
 
         .max_register = FTM_PWMLOAD,
         .volatile_reg = fsl_pwm_volatile_reg,
-        .cache_type = REGCACHE_RBTREE,
+        .cache_type = REGCACHE_FLAT,
 };
 
 static int fsl_pwm_probe(struct platform_device *pdev)
diff --git a/drivers/rapidio/devices/rio_mport_cdev.c b/drivers/rapidio/devices/rio_mport_cdev.c
index 9607bc826460..e165b7ce29d7 100644
--- a/drivers/rapidio/devices/rio_mport_cdev.c
+++ b/drivers/rapidio/devices/rio_mport_cdev.c
@@ -126,7 +126,7 @@ struct rio_mport_mapping {
         struct list_head node;
         struct mport_dev *md;
         enum rio_mport_map_dir dir;
-        u32 rioid;
+        u16 rioid;
         u64 rio_addr;
         dma_addr_t phys_addr; /* for mmap */
         void *virt_addr; /* kernel address, for dma_free_coherent */
@@ -137,7 +137,7 @@ struct rio_mport_mapping {
 
 struct rio_mport_dma_map {
         int valid;
-        uint64_t length;
+        u64 length;
         void *vaddr;
         dma_addr_t paddr;
 };
@@ -208,7 +208,7 @@ struct mport_cdev_priv {
         struct kfifo            event_fifo;
         wait_queue_head_t       event_rx_wait;
         spinlock_t              fifo_lock;
-        unsigned int            event_mask; /* RIO_DOORBELL, RIO_PORTWRITE */
+        u32                     event_mask; /* RIO_DOORBELL, RIO_PORTWRITE */
 #ifdef CONFIG_RAPIDIO_DMA_ENGINE
         struct dma_chan         *dmach;
         struct list_head        async_list;
@@ -276,7 +276,8 @@ static int rio_mport_maint_rd(struct mport_cdev_priv *priv, void __user *arg,
                 return -EFAULT;
 
         if ((maint_io.offset % 4) ||
-            (maint_io.length == 0) || (maint_io.length % 4))
+            (maint_io.length == 0) || (maint_io.length % 4) ||
+            (maint_io.length + maint_io.offset) > RIO_MAINT_SPACE_SZ)
                 return -EINVAL;
 
         buffer = vmalloc(maint_io.length);
@@ -298,7 +299,8 @@ static int rio_mport_maint_rd(struct mport_cdev_priv *priv, void __user *arg,
                 offset += 4;
         }
 
-        if (unlikely(copy_to_user(maint_io.buffer, buffer, maint_io.length)))
+        if (unlikely(copy_to_user((void __user *)(uintptr_t)maint_io.buffer,
+                                   buffer, maint_io.length)))
                 ret = -EFAULT;
 out:
         vfree(buffer);
@@ -319,7 +321,8 @@ static int rio_mport_maint_wr(struct mport_cdev_priv *priv, void __user *arg,
                 return -EFAULT;
 
         if ((maint_io.offset % 4) ||
-            (maint_io.length == 0) || (maint_io.length % 4))
+            (maint_io.length == 0) || (maint_io.length % 4) ||
+            (maint_io.length + maint_io.offset) > RIO_MAINT_SPACE_SZ)
                 return -EINVAL;
 
         buffer = vmalloc(maint_io.length);
@@ -327,7 +330,8 @@ static int rio_mport_maint_wr(struct mport_cdev_priv *priv, void __user *arg,
                 return -ENOMEM;
         length = maint_io.length;
 
-        if (unlikely(copy_from_user(buffer, maint_io.buffer, length))) {
+        if (unlikely(copy_from_user(buffer,
+                        (void __user *)(uintptr_t)maint_io.buffer, length))) {
                 ret = -EFAULT;
                 goto out;
         }
@@ -360,7 +364,7 @@ out:
  */
 static int
 rio_mport_create_outbound_mapping(struct mport_dev *md, struct file *filp,
-                                  u32 rioid, u64 raddr, u32 size,
+                                  u16 rioid, u64 raddr, u32 size,
                                   dma_addr_t *paddr)
 {
         struct rio_mport *mport = md->mport;
@@ -369,7 +373,7 @@ rio_mport_create_outbound_mapping(struct mport_dev *md, struct file *filp,
 
         rmcd_debug(OBW, "did=%d ra=0x%llx sz=0x%x", rioid, raddr, size);
 
-        map = kzalloc(sizeof(struct rio_mport_mapping), GFP_KERNEL);
+        map = kzalloc(sizeof(*map), GFP_KERNEL);
         if (map == NULL)
                 return -ENOMEM;
 
@@ -394,7 +398,7 @@ err_map_outb:
 
 static int
 rio_mport_get_outbound_mapping(struct mport_dev *md, struct file *filp,
-                               u32 rioid, u64 raddr, u32 size,
+                               u16 rioid, u64 raddr, u32 size,
                                dma_addr_t *paddr)
 {
         struct rio_mport_mapping *map;
@@ -433,7 +437,7 @@ static int rio_mport_obw_map(struct file *filp, void __user *arg)
         dma_addr_t paddr;
         int ret;
 
-        if (unlikely(copy_from_user(&map, arg, sizeof(struct rio_mmap))))
+        if (unlikely(copy_from_user(&map, arg, sizeof(map))))
                 return -EFAULT;
 
         rmcd_debug(OBW, "did=%d ra=0x%llx sz=0x%llx",
@@ -448,7 +452,7 @@ static int rio_mport_obw_map(struct file *filp, void __user *arg)
 
         map.handle = paddr;
 
-        if (unlikely(copy_to_user(arg, &map, sizeof(struct rio_mmap))))
+        if (unlikely(copy_to_user(arg, &map, sizeof(map))))
                 return -EFAULT;
         return 0;
 }
@@ -469,7 +473,7 @@ static int rio_mport_obw_free(struct file *filp, void __user *arg)
         if (!md->mport->ops->unmap_outb)
                 return -EPROTONOSUPPORT;
 
-        if (copy_from_user(&handle, arg, sizeof(u64)))
+        if (copy_from_user(&handle, arg, sizeof(handle)))
                 return -EFAULT;
 
         rmcd_debug(OBW, "h=0x%llx", handle);
@@ -498,9 +502,9 @@ static int rio_mport_obw_free(struct file *filp, void __user *arg)
 static int maint_hdid_set(struct mport_cdev_priv *priv, void __user *arg)
 {
         struct mport_dev *md = priv->md;
-        uint16_t hdid;
+        u16 hdid;
 
-        if (copy_from_user(&hdid, arg, sizeof(uint16_t)))
+        if (copy_from_user(&hdid, arg, sizeof(hdid)))
                 return -EFAULT;
 
         md->mport->host_deviceid = hdid;
@@ -520,9 +524,9 @@ static int maint_hdid_set(struct mport_cdev_priv *priv, void __user *arg)
 static int maint_comptag_set(struct mport_cdev_priv *priv, void __user *arg)
 {
         struct mport_dev *md = priv->md;
-        uint32_t comptag;
+        u32 comptag;
 
-        if (copy_from_user(&comptag, arg, sizeof(uint32_t)))
+        if (copy_from_user(&comptag, arg, sizeof(comptag)))
                 return -EFAULT;
 
         rio_local_write_config_32(md->mport, RIO_COMPONENT_TAG_CSR, comptag);
@@ -837,7 +841,7 @@ err_out:
  * @xfer: data transfer descriptor structure
  */
 static int
-rio_dma_transfer(struct file *filp, uint32_t transfer_mode,
+rio_dma_transfer(struct file *filp, u32 transfer_mode,
                  enum rio_transfer_sync sync, enum dma_data_direction dir,
                  struct rio_transfer_io *xfer)
 {
@@ -875,7 +879,7 @@ rio_dma_transfer(struct file *filp, uint32_t transfer_mode,
                 unsigned long offset;
                 long pinned;
 
-                offset = (unsigned long)xfer->loc_addr & ~PAGE_MASK;
+                offset = (unsigned long)(uintptr_t)xfer->loc_addr & ~PAGE_MASK;
                 nr_pages = PAGE_ALIGN(xfer->length + offset) >> PAGE_SHIFT;
 
                 page_list = kmalloc_array(nr_pages,
@@ -886,7 +890,7 @@ rio_dma_transfer(struct file *filp, uint32_t transfer_mode,
                 }
 
                 down_read(&current->mm->mmap_sem);
-                pinned = get_user_pages(current, current->mm,
+                pinned = get_user_pages(
                                 (unsigned long)xfer->loc_addr & PAGE_MASK,
                                 nr_pages, dir == DMA_FROM_DEVICE, 0,
                                 page_list, NULL);
@@ -1015,19 +1019,20 @@ static int rio_mport_transfer_ioctl(struct file *filp, void __user *arg)
         if (unlikely(copy_from_user(&transaction, arg, sizeof(transaction))))
                 return -EFAULT;
 
-        if (transaction.count != 1)
+        if (transaction.count != 1) /* only single transfer for now */
                 return -EINVAL;
 
         if ((transaction.transfer_mode &
              priv->md->properties.transfer_mode) == 0)
                 return -ENODEV;
 
-        transfer = vmalloc(transaction.count * sizeof(struct rio_transfer_io));
+        transfer = vmalloc(transaction.count * sizeof(*transfer));
         if (!transfer)
                 return -ENOMEM;
 
-        if (unlikely(copy_from_user(transfer, transaction.block,
-              transaction.count * sizeof(struct rio_transfer_io)))) {
+        if (unlikely(copy_from_user(transfer,
+                                    (void __user *)(uintptr_t)transaction.block,
+                                    transaction.count * sizeof(*transfer)))) {
                 ret = -EFAULT;
                 goto out_free;
         }
@@ -1038,8 +1043,9 @@ static int rio_mport_transfer_ioctl(struct file *filp, void __user *arg)
                 ret = rio_dma_transfer(filp, transaction.transfer_mode,
                         transaction.sync, dir, &transfer[i]);
 
-        if (unlikely(copy_to_user(transaction.block, transfer,
-              transaction.count * sizeof(struct rio_transfer_io))))
+        if (unlikely(copy_to_user((void __user *)(uintptr_t)transaction.block,
+                                  transfer,
+                                  transaction.count * sizeof(*transfer))))
                 ret = -EFAULT;
 
 out_free:
@@ -1129,11 +1135,11 @@ err_tmo:
 }
 
 static int rio_mport_create_dma_mapping(struct mport_dev *md, struct file *filp,
-                        uint64_t size, struct rio_mport_mapping **mapping)
+                        u64 size, struct rio_mport_mapping **mapping)
 {
         struct rio_mport_mapping *map;
 
-        map = kzalloc(sizeof(struct rio_mport_mapping), GFP_KERNEL);
+        map = kzalloc(sizeof(*map), GFP_KERNEL);
         if (map == NULL)
                 return -ENOMEM;
 
@@ -1165,7 +1171,7 @@ static int rio_mport_alloc_dma(struct file *filp, void __user *arg)
         struct rio_mport_mapping *mapping = NULL;
         int ret;
 
-        if (unlikely(copy_from_user(&map, arg, sizeof(struct rio_dma_mem))))
+        if (unlikely(copy_from_user(&map, arg, sizeof(map))))
                 return -EFAULT;
 
         ret = rio_mport_create_dma_mapping(md, filp, map.length, &mapping);
@@ -1174,7 +1180,7 @@ static int rio_mport_alloc_dma(struct file *filp, void __user *arg)
 
         map.dma_handle = mapping->phys_addr;
 
-        if (unlikely(copy_to_user(arg, &map, sizeof(struct rio_dma_mem)))) {
+        if (unlikely(copy_to_user(arg, &map, sizeof(map)))) {
                 mutex_lock(&md->buf_mutex);
                 kref_put(&mapping->ref, mport_release_mapping);
                 mutex_unlock(&md->buf_mutex);
@@ -1192,7 +1198,7 @@ static int rio_mport_free_dma(struct file *filp, void __user *arg)
         int ret = -EFAULT;
         struct rio_mport_mapping *map, *_map;
 
-        if (copy_from_user(&handle, arg, sizeof(u64)))
+        if (copy_from_user(&handle, arg, sizeof(handle)))
                 return -EFAULT;
         rmcd_debug(EXIT, "filp=%p", filp);
 
@@ -1242,14 +1248,18 @@ static int rio_mport_free_dma(struct file *filp, void __user *arg)
 
 static int
 rio_mport_create_inbound_mapping(struct mport_dev *md, struct file *filp,
-                                u64 raddr, u32 size,
+                                u64 raddr, u64 size,
                                 struct rio_mport_mapping **mapping)
 {
         struct rio_mport *mport = md->mport;
         struct rio_mport_mapping *map;
         int ret;
 
-        map = kzalloc(sizeof(struct rio_mport_mapping), GFP_KERNEL);
+        /* rio_map_inb_region() accepts u32 size */
+        if (size > 0xffffffff)
+                return -EINVAL;
+
+        map = kzalloc(sizeof(*map), GFP_KERNEL);
         if (map == NULL)
                 return -ENOMEM;
 
@@ -1262,7 +1272,7 @@ rio_mport_create_inbound_mapping(struct mport_dev *md, struct file *filp,
 
         if (raddr == RIO_MAP_ANY_ADDR)
                 raddr = map->phys_addr;
-        ret = rio_map_inb_region(mport, map->phys_addr, raddr, size, 0);
+        ret = rio_map_inb_region(mport, map->phys_addr, raddr, (u32)size, 0);
         if (ret < 0)
                 goto err_map_inb;
 
@@ -1288,7 +1298,7 @@ err_dma_alloc:
 
 static int
 rio_mport_get_inbound_mapping(struct mport_dev *md, struct file *filp,
-                              u64 raddr, u32 size,
+                              u64 raddr, u64 size,
                               struct rio_mport_mapping **mapping)
 {
         struct rio_mport_mapping *map;
@@ -1331,7 +1341,7 @@ static int rio_mport_map_inbound(struct file *filp, void __user *arg)
 
         if (!md->mport->ops->map_inb)
                 return -EPROTONOSUPPORT;
-        if (unlikely(copy_from_user(&map, arg, sizeof(struct rio_mmap))))
+        if (unlikely(copy_from_user(&map, arg, sizeof(map))))
                 return -EFAULT;
 
         rmcd_debug(IBW, "%s filp=%p", dev_name(&priv->md->dev), filp);
@@ -1344,7 +1354,7 @@ static int rio_mport_map_inbound(struct file *filp, void __user *arg)
         map.handle = mapping->phys_addr;
         map.rio_addr = mapping->rio_addr;
 
-        if (unlikely(copy_to_user(arg, &map, sizeof(struct rio_mmap)))) {
+        if (unlikely(copy_to_user(arg, &map, sizeof(map)))) {
                 /* Delete mapping if it was created by this request */
                 if (ret == 0 && mapping->filp == filp) {
                         mutex_lock(&md->buf_mutex);
@@ -1375,7 +1385,7 @@ static int rio_mport_inbound_free(struct file *filp, void __user *arg)
         if (!md->mport->ops->unmap_inb)
                 return -EPROTONOSUPPORT;
 
-        if (copy_from_user(&handle, arg, sizeof(u64)))
+        if (copy_from_user(&handle, arg, sizeof(handle)))
                 return -EFAULT;
 
         mutex_lock(&md->buf_mutex);
@@ -1401,7 +1411,7 @@ static int rio_mport_inbound_free(struct file *filp, void __user *arg)
 static int maint_port_idx_get(struct mport_cdev_priv *priv, void __user *arg)
 {
         struct mport_dev *md = priv->md;
-        uint32_t port_idx = md->mport->index;
+        u32 port_idx = md->mport->index;
 
         rmcd_debug(MPORT, "port_index=%d", port_idx);
 
@@ -1451,7 +1461,7 @@ static void rio_mport_doorbell_handler(struct rio_mport *mport, void *dev_id,
         handled = 0;
         spin_lock(&data->db_lock);
         list_for_each_entry(db_filter, &data->doorbells, data_node) {
-                if (((db_filter->filter.rioid == 0xffffffff ||
+                if (((db_filter->filter.rioid == RIO_INVALID_DESTID ||
                       db_filter->filter.rioid == src)) &&
                       info >= db_filter->filter.low &&
                       info <= db_filter->filter.high) {
@@ -1525,6 +1535,9 @@ static int rio_mport_remove_db_filter(struct mport_cdev_priv *priv,
         if (copy_from_user(&filter, arg, sizeof(filter)))
                 return -EFAULT;
 
+        if (filter.low > filter.high)
+                return -EINVAL;
+
         spin_lock_irqsave(&priv->md->db_lock, flags);
         list_for_each_entry(db_filter, &priv->db_filters, priv_node) {
                 if (db_filter->filter.rioid == filter.rioid &&
@@ -1737,10 +1750,10 @@ static int rio_mport_add_riodev(struct mport_cdev_priv *priv,
                 return -EEXIST;
         }
 
-        size = sizeof(struct rio_dev);
+        size = sizeof(*rdev);
         mport = md->mport;
-        destid = (u16)dev_info.destid;
-        hopcount = (u8)dev_info.hopcount;
+        destid = dev_info.destid;
+        hopcount = dev_info.hopcount;
 
         if (rio_mport_read_config_32(mport, destid, hopcount,
                                      RIO_PEF_CAR, &rval))
@@ -1872,8 +1885,8 @@ static int rio_mport_del_riodev(struct mport_cdev_priv *priv, void __user *arg)
                 do {
                         rdev = rio_get_comptag(dev_info.comptag, rdev);
                         if (rdev && rdev->dev.parent == &mport->net->dev &&
-                            rdev->destid == (u16)dev_info.destid &&
-                            rdev->hopcount == (u8)dev_info.hopcount)
+                            rdev->destid == dev_info.destid &&
+                            rdev->hopcount == dev_info.hopcount)
                                 break;
                 } while (rdev);
         }
@@ -2146,8 +2159,8 @@ static long mport_cdev_ioctl(struct file *filp,
                 return maint_port_idx_get(data, (void __user *)arg);
         case RIO_MPORT_GET_PROPERTIES:
                 md->properties.hdid = md->mport->host_deviceid;
-                if (copy_to_user((void __user *)arg, &(data->md->properties),
-                                 sizeof(data->md->properties)))
+                if (copy_to_user((void __user *)arg, &(md->properties),
+                                 sizeof(md->properties)))
                         return -EFAULT;
                 return 0;
         case RIO_ENABLE_DOORBELL_RANGE:
@@ -2159,11 +2172,11 @@ static long mport_cdev_ioctl(struct file *filp,
         case RIO_DISABLE_PORTWRITE_RANGE:
                 return rio_mport_remove_pw_filter(data, (void __user *)arg);
         case RIO_SET_EVENT_MASK:
-                data->event_mask = arg;
+                data->event_mask = (u32)arg;
                 return 0;
         case RIO_GET_EVENT_MASK:
                 if (copy_to_user((void __user *)arg, &data->event_mask,
-                                    sizeof(data->event_mask)))
+                                    sizeof(u32)))
                         return -EFAULT;
                 return 0;
         case RIO_MAP_OUTBOUND:
@@ -2374,7 +2387,7 @@ static ssize_t mport_write(struct file *filp, const char __user *buf,
                         return -EINVAL;
 
                 ret = rio_mport_send_doorbell(mport,
-                                              (u16)event.u.doorbell.rioid,
+                                              event.u.doorbell.rioid,
                                               event.u.doorbell.payload);
                 if (ret < 0)
                         return ret;
@@ -2421,7 +2434,7 @@ static struct mport_dev *mport_cdev_add(struct rio_mport *mport)
         struct mport_dev *md;
         struct rio_mport_attr attr;
 
-        md = kzalloc(sizeof(struct mport_dev), GFP_KERNEL);
+        md = kzalloc(sizeof(*md), GFP_KERNEL);
         if (!md) {
                 rmcd_error("Unable allocate a device object");
                 return NULL;
@@ -2470,7 +2483,7 @@ static struct mport_dev *mport_cdev_add(struct rio_mport *mport)
         /* The transfer_mode property will be returned through mport query
          * interface
          */
-#ifdef CONFIG_PPC /* for now: only on Freescale's SoCs */
+#ifdef CONFIG_FSL_RIO /* for now: only on Freescale's SoCs */
         md->properties.transfer_mode |= RIO_TRANSFER_MODE_MAPPED;
 #else
         md->properties.transfer_mode |= RIO_TRANSFER_MODE_TRANSFER;
@@ -2669,9 +2682,9 @@ static int __init mport_init(void)
 
         /* Create device class needed by udev */
         dev_class = class_create(THIS_MODULE, DRV_NAME);
-        if (!dev_class) {
+        if (IS_ERR(dev_class)) {
                 rmcd_error("Unable to create " DRV_NAME " class");
-                return -EINVAL;
+                return PTR_ERR(dev_class);
         }
 
         ret = alloc_chrdev_region(&dev_number, 0, RIO_MAX_MPORTS, DRV_NAME);
diff --git a/drivers/remoteproc/st_remoteproc.c b/drivers/remoteproc/st_remoteproc.c
index 6bb04d453247..6f056caa8a56 100644
--- a/drivers/remoteproc/st_remoteproc.c
+++ b/drivers/remoteproc/st_remoteproc.c
@@ -189,9 +189,9 @@ static int st_rproc_parse_dt(struct platform_device *pdev)
         }
 
         ddata->boot_base = syscon_regmap_lookup_by_phandle(np, "st,syscfg");
-        if (!ddata->boot_base) {
+        if (IS_ERR(ddata->boot_base)) {
                 dev_err(dev, "Boot base not found\n");
-                return -EINVAL;
+                return PTR_ERR(ddata->boot_base);
         }
 
         err = of_property_read_u32_index(np, "st,syscfg", 1,
diff --git a/drivers/rtc/rtc-ds1307.c b/drivers/rtc/rtc-ds1307.c
index b2156ee5bae1..ecb7dbae9be9 100644
--- a/drivers/rtc/rtc-ds1307.c
+++ b/drivers/rtc/rtc-ds1307.c
@@ -863,7 +863,7 @@ out:
  * A user-initiated temperature conversion is not started by this function,
  * so the temperature is updated once every 64 seconds.
  */
-static int ds3231_hwmon_read_temp(struct device *dev, s16 *mC)
+static int ds3231_hwmon_read_temp(struct device *dev, s32 *mC)
 {
         struct ds1307 *ds1307 = dev_get_drvdata(dev);
         u8 temp_buf[2];
@@ -892,7 +892,7 @@ static ssize_t ds3231_hwmon_show_temp(struct device *dev,
                                 struct device_attribute *attr, char *buf)
 {
         int ret;
-        s16 temp;
+        s32 temp;
 
         ret = ds3231_hwmon_read_temp(dev, &temp);
         if (ret)
@@ -1531,7 +1531,7 @@ read_rtc:
                 return PTR_ERR(ds1307->rtc);
         }
 
-        if (ds1307_can_wakeup_device) {
+        if (ds1307_can_wakeup_device && ds1307->client->irq <= 0) {
                 /* Disable request for an IRQ */
                 want_irq = false;
                 dev_info(&client->dev, "'wakeup-source' is set, request for an IRQ is disabled!\n");
diff --git a/drivers/s390/block/dasd_alias.c b/drivers/s390/block/dasd_alias.c
index 17ad5749e91d..1e560188dd13 100644
--- a/drivers/s390/block/dasd_alias.c
+++ b/drivers/s390/block/dasd_alias.c
@@ -317,17 +317,17 @@ static int _add_device_to_lcu(struct alias_lcu *lcu,
         struct alias_pav_group *group;
         struct dasd_uid uid;
 
+        spin_lock(get_ccwdev_lock(device->cdev));
         private->uid.type = lcu->uac->unit[private->uid.real_unit_addr].ua_type;
         private->uid.base_unit_addr =
                 lcu->uac->unit[private->uid.real_unit_addr].base_ua;
         uid = private->uid;
-
+        spin_unlock(get_ccwdev_lock(device->cdev));
         /* if we have no PAV anyway, we don't need to bother with PAV groups */
         if (lcu->pav == NO_PAV) {
                 list_move(&device->alias_list, &lcu->active_devices);
                 return 0;
         }
-
         group = _find_group(lcu, &uid);
         if (!group) {
                 group = kzalloc(sizeof(*group), GFP_ATOMIC);
@@ -397,130 +397,6 @@ suborder_not_supported(struct dasd_ccw_req *cqr)
         return 0;
 }
 
-/*
- * This function tries to lock all devices on an lcu via trylock
- * return NULL on success otherwise return first failed device
- */
-static struct dasd_device *_trylock_all_devices_on_lcu(struct alias_lcu *lcu,
-                                                      struct dasd_device *pos)
-
-{
-        struct alias_pav_group *pavgroup;
-        struct dasd_device *device;
-
-        list_for_each_entry(device, &lcu->active_devices, alias_list) {
-                if (device == pos)
-                        continue;
-                if (!spin_trylock(get_ccwdev_lock(device->cdev)))
-                        return device;
-        }
-        list_for_each_entry(device, &lcu->inactive_devices, alias_list) {
-                if (device == pos)
-                        continue;
-                if (!spin_trylock(get_ccwdev_lock(device->cdev)))
-                        return device;
-        }
-        list_for_each_entry(pavgroup, &lcu->grouplist, group) {
-                list_for_each_entry(device, &pavgroup->baselist, alias_list) {
-                        if (device == pos)
-                                continue;
-                        if (!spin_trylock(get_ccwdev_lock(device->cdev)))
-                                return device;
-                }
-                list_for_each_entry(device, &pavgroup->aliaslist, alias_list) {
-                        if (device == pos)
-                                continue;
-                        if (!spin_trylock(get_ccwdev_lock(device->cdev)))
-                                return device;
-                }
-        }
-        return NULL;
-}
-
-/*
- * unlock all devices except the one that is specified as pos
- * stop if enddev is specified and reached
- */
-static void _unlock_all_devices_on_lcu(struct alias_lcu *lcu,
-                                       struct dasd_device *pos,
-                                       struct dasd_device *enddev)
-
-{
-        struct alias_pav_group *pavgroup;
-        struct dasd_device *device;
-
-        list_for_each_entry(device, &lcu->active_devices, alias_list) {
-                if (device == pos)
-                        continue;
-                if (device == enddev)
-                        return;
-                spin_unlock(get_ccwdev_lock(device->cdev));
-        }
-        list_for_each_entry(device, &lcu->inactive_devices, alias_list) {
-                if (device == pos)
-                        continue;
-                if (device == enddev)
-                        return;
-                spin_unlock(get_ccwdev_lock(device->cdev));
-        }
-        list_for_each_entry(pavgroup, &lcu->grouplist, group) {
-                list_for_each_entry(device, &pavgroup->baselist, alias_list) {
-                        if (device == pos)
-                                continue;
-                        if (device == enddev)
-                                return;
-                        spin_unlock(get_ccwdev_lock(device->cdev));
-                }
-                list_for_each_entry(device, &pavgroup->aliaslist, alias_list) {
-                        if (device == pos)
-                                continue;
-                        if (device == enddev)
-                                return;
-                        spin_unlock(get_ccwdev_lock(device->cdev));
-                }
-        }
-}
-
-/*
- *  this function is needed because the locking order
- *  device lock -> lcu lock
- *  needs to be assured when iterating over devices in an LCU
- *
- *  if a device is specified in pos then the device lock is already hold
- */
-static void _trylock_and_lock_lcu_irqsave(struct alias_lcu *lcu,
-                                          struct dasd_device *pos,
-                                          unsigned long *flags)
-{
-        struct dasd_device *failed;
-
-        do {
-                spin_lock_irqsave(&lcu->lock, *flags);
-                failed = _trylock_all_devices_on_lcu(lcu, pos);
-                if (failed) {
-                        _unlock_all_devices_on_lcu(lcu, pos, failed);
-                        spin_unlock_irqrestore(&lcu->lock, *flags);
-                        cpu_relax();
-                }
-        } while (failed);
-}
-
-static void _trylock_and_lock_lcu(struct alias_lcu *lcu,
-                                  struct dasd_device *pos)
-{
-        struct dasd_device *failed;
-
-        do {
-                spin_lock(&lcu->lock);
-                failed = _trylock_all_devices_on_lcu(lcu, pos);
-                if (failed) {
-                        _unlock_all_devices_on_lcu(lcu, pos, failed);
-                        spin_unlock(&lcu->lock);
-                        cpu_relax();
-                }
-        } while (failed);
-}
-
 static int read_unit_address_configuration(struct dasd_device *device,
                                            struct alias_lcu *lcu)
 {
@@ -615,7 +491,7 @@ static int _lcu_update(struct dasd_device *refdev, struct alias_lcu *lcu)
         if (rc)
                 return rc;
 
-        _trylock_and_lock_lcu_irqsave(lcu, NULL, &flags);
+        spin_lock_irqsave(&lcu->lock, flags);
         lcu->pav = NO_PAV;
         for (i = 0; i < MAX_DEVICES_PER_LCU; ++i) {
                 switch (lcu->uac->unit[i].ua_type) {
@@ -634,7 +510,6 @@ static int _lcu_update(struct dasd_device *refdev, struct alias_lcu *lcu)
                                  alias_list) {
                 _add_device_to_lcu(lcu, device, refdev);
         }
-        _unlock_all_devices_on_lcu(lcu, NULL, NULL);
         spin_unlock_irqrestore(&lcu->lock, flags);
         return 0;
 }
@@ -722,8 +597,7 @@ int dasd_alias_add_device(struct dasd_device *device)
 
         lcu = private->lcu;
         rc = 0;
-        spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
-        spin_lock(&lcu->lock);
+        spin_lock_irqsave(&lcu->lock, flags);
         if (!(lcu->flags & UPDATE_PENDING)) {
                 rc = _add_device_to_lcu(lcu, device, device);
                 if (rc)
@@ -733,8 +607,7 @@ int dasd_alias_add_device(struct dasd_device *device)
                 list_move(&device->alias_list, &lcu->active_devices);
                 _schedule_lcu_update(lcu, device);
         }
-        spin_unlock(&lcu->lock);
-        spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
+        spin_unlock_irqrestore(&lcu->lock, flags);
         return rc;
 }
 
@@ -933,15 +806,27 @@ static void _stop_all_devices_on_lcu(struct alias_lcu *lcu)
         struct alias_pav_group *pavgroup;
         struct dasd_device *device;
 
-        list_for_each_entry(device, &lcu->active_devices, alias_list)
+        list_for_each_entry(device, &lcu->active_devices, alias_list) {
+                spin_lock(get_ccwdev_lock(device->cdev));
                 dasd_device_set_stop_bits(device, DASD_STOPPED_SU);
-        list_for_each_entry(device, &lcu->inactive_devices, alias_list)
+                spin_unlock(get_ccwdev_lock(device->cdev));
+        }
+        list_for_each_entry(device, &lcu->inactive_devices, alias_list) {
+                spin_lock(get_ccwdev_lock(device->cdev));
                 dasd_device_set_stop_bits(device, DASD_STOPPED_SU);
+                spin_unlock(get_ccwdev_lock(device->cdev));
+        }
         list_for_each_entry(pavgroup, &lcu->grouplist, group) {
-                list_for_each_entry(device, &pavgroup->baselist, alias_list)
+                list_for_each_entry(device, &pavgroup->baselist, alias_list) {
+                        spin_lock(get_ccwdev_lock(device->cdev));
                         dasd_device_set_stop_bits(device, DASD_STOPPED_SU);
-                list_for_each_entry(device, &pavgroup->aliaslist, alias_list)
+                        spin_unlock(get_ccwdev_lock(device->cdev));
+                }
+                list_for_each_entry(device, &pavgroup->aliaslist, alias_list) {
+                        spin_lock(get_ccwdev_lock(device->cdev));
                         dasd_device_set_stop_bits(device, DASD_STOPPED_SU);
+                        spin_unlock(get_ccwdev_lock(device->cdev));
+                }
         }
 }
 
@@ -950,15 +835,27 @@ static void _unstop_all_devices_on_lcu(struct alias_lcu *lcu)
         struct alias_pav_group *pavgroup;
         struct dasd_device *device;
 
-        list_for_each_entry(device, &lcu->active_devices, alias_list)
+        list_for_each_entry(device, &lcu->active_devices, alias_list) {
+                spin_lock(get_ccwdev_lock(device->cdev));
                 dasd_device_remove_stop_bits(device, DASD_STOPPED_SU);
-        list_for_each_entry(device, &lcu->inactive_devices, alias_list)
+                spin_unlock(get_ccwdev_lock(device->cdev));
+        }
+        list_for_each_entry(device, &lcu->inactive_devices, alias_list) {
+                spin_lock(get_ccwdev_lock(device->cdev));
                 dasd_device_remove_stop_bits(device, DASD_STOPPED_SU);
+                spin_unlock(get_ccwdev_lock(device->cdev));
+        }
         list_for_each_entry(pavgroup, &lcu->grouplist, group) {
-                list_for_each_entry(device, &pavgroup->baselist, alias_list)
+                list_for_each_entry(device, &pavgroup->baselist, alias_list) {
+                        spin_lock(get_ccwdev_lock(device->cdev));
                         dasd_device_remove_stop_bits(device, DASD_STOPPED_SU);
-                list_for_each_entry(device, &pavgroup->aliaslist, alias_list)
+                        spin_unlock(get_ccwdev_lock(device->cdev));
+                }
+                list_for_each_entry(device, &pavgroup->aliaslist, alias_list) {
+                        spin_lock(get_ccwdev_lock(device->cdev));
                         dasd_device_remove_stop_bits(device, DASD_STOPPED_SU);
+                        spin_unlock(get_ccwdev_lock(device->cdev));
+                }
         }
 }
 
@@ -984,48 +881,32 @@ static void summary_unit_check_handling_work(struct work_struct *work)
         spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
         reset_summary_unit_check(lcu, device, suc_data->reason);
 
-        _trylock_and_lock_lcu_irqsave(lcu, NULL, &flags);
+        spin_lock_irqsave(&lcu->lock, flags);
         _unstop_all_devices_on_lcu(lcu);
         _restart_all_base_devices_on_lcu(lcu);
         /* 3. read new alias configuration */
         _schedule_lcu_update(lcu, device);
         lcu->suc_data.device = NULL;
         dasd_put_device(device);
-        _unlock_all_devices_on_lcu(lcu, NULL, NULL);
         spin_unlock_irqrestore(&lcu->lock, flags);
 }
 
-/*
- * note: this will be called from int handler context (cdev locked)
- */
-void dasd_alias_handle_summary_unit_check(struct dasd_device *device,
-                                          struct irb *irb)
+void dasd_alias_handle_summary_unit_check(struct work_struct *work)
 {
+        struct dasd_device *device = container_of(work, struct dasd_device,
+                                                  suc_work);
         struct dasd_eckd_private *private = device->private;
         struct alias_lcu *lcu;
-        char reason;
-        char *sense;
-
-        sense = dasd_get_sense(irb);
-        if (sense) {
-                reason = sense[8];
-                DBF_DEV_EVENT(DBF_NOTICE, device, "%s %x",
-                            "eckd handle summary unit check: reason", reason);
-        } else {
-                DBF_DEV_EVENT(DBF_WARNING, device, "%s",
-                            "eckd handle summary unit check:"
-                            " no reason code available");
-                return;
-        }
+        unsigned long flags;
 
         lcu = private->lcu;
         if (!lcu) {
                 DBF_DEV_EVENT(DBF_WARNING, device, "%s",
                             "device not ready to handle summary"
                             " unit check (no lcu structure)");
-                return;
+                goto out;
         }
-        _trylock_and_lock_lcu(lcu, device);
+        spin_lock_irqsave(&lcu->lock, flags);
         /* If this device is about to be removed just return and wait for
          * the next interrupt on a different device
          */
@@ -1033,27 +914,26 @@ void dasd_alias_handle_summary_unit_check(struct dasd_device *device,
                 DBF_DEV_EVENT(DBF_WARNING, device, "%s",
                             "device is in offline processing,"
                             " don't do summary unit check handling");
-                _unlock_all_devices_on_lcu(lcu, device, NULL);
-                spin_unlock(&lcu->lock);
-                return;
+                goto out_unlock;
         }
         if (lcu->suc_data.device) {
                 /* already scheduled or running */
                 DBF_DEV_EVENT(DBF_WARNING, device, "%s",
                             "previous instance of summary unit check worker"
                             " still pending");
-                _unlock_all_devices_on_lcu(lcu, device, NULL);
-                spin_unlock(&lcu->lock);
-                return ;
+                goto out_unlock;
         }
         _stop_all_devices_on_lcu(lcu);
         /* prepare for lcu_update */
-        private->lcu->flags |= NEED_UAC_UPDATE | UPDATE_PENDING;
-        lcu->suc_data.reason = reason;
+        lcu->flags |= NEED_UAC_UPDATE | UPDATE_PENDING;
+        lcu->suc_data.reason = private->suc_reason;
         lcu->suc_data.device = device;
         dasd_get_device(device);
-        _unlock_all_devices_on_lcu(lcu, device, NULL);
-        spin_unlock(&lcu->lock);
         if (!schedule_work(&lcu->suc_data.worker))
                 dasd_put_device(device);
+out_unlock:
+        spin_unlock_irqrestore(&lcu->lock, flags);
+out:
+        clear_bit(DASD_FLAG_SUC, &device->flags);
+        dasd_put_device(device);
 };
diff --git a/drivers/s390/block/dasd_eckd.c b/drivers/s390/block/dasd_eckd.c
index 75c032dcf173..c1b4ae55e129 100644
--- a/drivers/s390/block/dasd_eckd.c
+++ b/drivers/s390/block/dasd_eckd.c
@@ -1682,6 +1682,8 @@ dasd_eckd_check_characteristics(struct dasd_device *device)
 
         /* setup work queue for validate server*/
         INIT_WORK(&device->kick_validate, dasd_eckd_do_validate_server);
+        /* setup work queue for summary unit check */
+        INIT_WORK(&device->suc_work, dasd_alias_handle_summary_unit_check);
 
         if (!ccw_device_is_pathgroup(device->cdev)) {
                 dev_warn(&device->cdev->dev,
@@ -2549,14 +2551,6 @@ static void dasd_eckd_check_for_device_change(struct dasd_device *device,
                     device->state == DASD_STATE_ONLINE &&
                     !test_bit(DASD_FLAG_OFFLINE, &device->flags) &&
                     !test_bit(DASD_FLAG_SUSPENDED, &device->flags)) {
-                        /*
-                         * the state change could be caused by an alias
-                         * reassignment remove device from alias handling
-                         * to prevent new requests from being scheduled on
-                         * the wrong alias device
-                         */
-                        dasd_alias_remove_device(device);
-
                         /* schedule worker to reload device */
                         dasd_reload_device(device);
                 }
@@ -2571,7 +2565,27 @@ static void dasd_eckd_check_for_device_change(struct dasd_device *device,
         /* summary unit check */
         if ((sense[27] & DASD_SENSE_BIT_0) && (sense[7] == 0x0D) &&
             (scsw_dstat(&irb->scsw) & DEV_STAT_UNIT_CHECK)) {
-                dasd_alias_handle_summary_unit_check(device, irb);
+                if (test_and_set_bit(DASD_FLAG_SUC, &device->flags)) {
+                        DBF_DEV_EVENT(DBF_WARNING, device, "%s",
+                                      "eckd suc: device already notified");
+                        return;
+                }
+                sense = dasd_get_sense(irb);
+                if (!sense) {
+                        DBF_DEV_EVENT(DBF_WARNING, device, "%s",
+                                      "eckd suc: no reason code available");
+                        clear_bit(DASD_FLAG_SUC, &device->flags);
+                        return;
+
+                }
+                private->suc_reason = sense[8];
+                DBF_DEV_EVENT(DBF_NOTICE, device, "%s %x",
+                              "eckd handle summary unit check: reason",
+                              private->suc_reason);
+                dasd_get_device(device);
+                if (!schedule_work(&device->suc_work))
+                        dasd_put_device(device);
+
                 return;
         }
 
@@ -4495,6 +4509,12 @@ static int dasd_eckd_reload_device(struct dasd_device *device)
         struct dasd_uid uid;
         unsigned long flags;
 
+        /*
+         * remove device from alias handling to prevent new requests
+         * from being scheduled on the wrong alias device
+         */
+        dasd_alias_remove_device(device);
+
         spin_lock_irqsave(get_ccwdev_lock(device->cdev), flags);
         old_base = private->uid.base_unit_addr;
         spin_unlock_irqrestore(get_ccwdev_lock(device->cdev), flags);
diff --git a/drivers/s390/block/dasd_eckd.h b/drivers/s390/block/dasd_eckd.h
index f8f91ee652d3..6d9a6d3517cd 100644
--- a/drivers/s390/block/dasd_eckd.h
+++ b/drivers/s390/block/dasd_eckd.h
@@ -525,6 +525,7 @@ struct dasd_eckd_private {
         int count;
 
         u32 fcx_max_data;
+        char suc_reason;
 };
 
 
@@ -534,7 +535,7 @@ void dasd_alias_disconnect_device_from_lcu(struct dasd_device *);
 int dasd_alias_add_device(struct dasd_device *);
 int dasd_alias_remove_device(struct dasd_device *);
 struct dasd_device *dasd_alias_get_start_dev(struct dasd_device *);
-void dasd_alias_handle_summary_unit_check(struct dasd_device *, struct irb *);
+void dasd_alias_handle_summary_unit_check(struct work_struct *);
 void dasd_eckd_reset_ccw_to_base_io(struct dasd_ccw_req *);
 void dasd_alias_lcu_setup_complete(struct dasd_device *);
 void dasd_alias_wait_for_lcu_setup(struct dasd_device *);
diff --git a/drivers/s390/block/dasd_int.h b/drivers/s390/block/dasd_int.h
index 8de29be32a56..0f0add932e7a 100644
--- a/drivers/s390/block/dasd_int.h
+++ b/drivers/s390/block/dasd_int.h
@@ -470,6 +470,7 @@ struct dasd_device {
         struct work_struct restore_device;
         struct work_struct reload_device;
         struct work_struct kick_validate;
+        struct work_struct suc_work;
         struct timer_list timer;
 
         debug_info_t *debug_area;
@@ -542,6 +543,7 @@ struct dasd_attention_data {
 #define DASD_FLAG_SAFE_OFFLINE_RUNNING  11      /* safe offline running */
 #define DASD_FLAG_ABORTALL      12      /* Abort all noretry requests */
 #define DASD_FLAG_PATH_VERIFY   13      /* Path verification worker running */
+#define DASD_FLAG_SUC           14      /* unhandled summary unit check */
 
 #define DASD_SLEEPON_START_TAG  ((void *) 1)
 #define DASD_SLEEPON_END_TAG    ((void *) 2)
diff --git a/drivers/s390/block/dcssblk.c b/drivers/s390/block/dcssblk.c
index 1bce9cf51b1e..b83908670a9a 100644
--- a/drivers/s390/block/dcssblk.c
+++ b/drivers/s390/block/dcssblk.c
@@ -756,15 +756,16 @@ dcssblk_remove_store(struct device *dev, struct device_attribute *attr, const ch
         blk_cleanup_queue(dev_info->dcssblk_queue);
         dev_info->gd->queue = NULL;
         put_disk(dev_info->gd);
-        device_unregister(&dev_info->dev);
 
         /* unload all related segments */
         list_for_each_entry(entry, &dev_info->seg_list, lh)
                 segment_unload(entry->segment_name);
 
-        put_device(&dev_info->dev);
         up_write(&dcssblk_devices_sem);
 
+        device_unregister(&dev_info->dev);
+        put_device(&dev_info->dev);
+
         rc = count;
 out_buf:
         kfree(local_buf);
diff --git a/drivers/s390/block/scm_blk.c b/drivers/s390/block/scm_blk.c
index 75d9896deccb..e6f54d3b8969 100644
--- a/drivers/s390/block/scm_blk.c
+++ b/drivers/s390/block/scm_blk.c
@@ -303,7 +303,7 @@ static void scm_blk_request(struct request_queue *rq)
                 if (req->cmd_type != REQ_TYPE_FS) {
                         blk_start_request(req);
                         blk_dump_rq_flags(req, KMSG_COMPONENT " bad request");
-                        blk_end_request_all(req, -EIO);
+                        __blk_end_request_all(req, -EIO);
                         continue;
                 }
 
diff --git a/drivers/s390/char/sclp_ctl.c b/drivers/s390/char/sclp_ctl.c
index 648cb86afd42..ea607a4a1bdd 100644
--- a/drivers/s390/char/sclp_ctl.c
+++ b/drivers/s390/char/sclp_ctl.c
@@ -56,6 +56,7 @@ static int sclp_ctl_ioctl_sccb(void __user *user_area)
 {
         struct sclp_ctl_sccb ctl_sccb;
         struct sccb_header *sccb;
+        unsigned long copied;
         int rc;
 
         if (copy_from_user(&ctl_sccb, user_area, sizeof(ctl_sccb)))
@@ -65,14 +66,15 @@ static int sclp_ctl_ioctl_sccb(void __user *user_area)
         sccb = (void *) get_zeroed_page(GFP_KERNEL | GFP_DMA);
         if (!sccb)
                 return -ENOMEM;
-        if (copy_from_user(sccb, u64_to_uptr(ctl_sccb.sccb), sizeof(*sccb))) {
+        copied = PAGE_SIZE -
+                copy_from_user(sccb, u64_to_uptr(ctl_sccb.sccb), PAGE_SIZE);
+        if (offsetof(struct sccb_header, length) +
+            sizeof(sccb->length) > copied || sccb->length > copied) {
                 rc = -EFAULT;
                 goto out_free;
         }
-        if (sccb->length > PAGE_SIZE || sccb->length < 8)
-                return -EINVAL;
-        if (copy_from_user(sccb, u64_to_uptr(ctl_sccb.sccb), sccb->length)) {
-                rc = -EFAULT;
+        if (sccb->length < 8) {
+                rc = -EINVAL;
                 goto out_free;
         }
         rc = sclp_sync_request(ctl_sccb.cmdw, sccb);
diff --git a/drivers/scsi/aacraid/linit.c b/drivers/scsi/aacraid/linit.c
index 21a67ed047e8..ff6caab8cc8b 100644
--- a/drivers/scsi/aacraid/linit.c
+++ b/drivers/scsi/aacraid/linit.c
@@ -452,10 +452,11 @@ static int aac_slave_configure(struct scsi_device *sdev)
                 else if (depth < 2)
                         depth = 2;
                 scsi_change_queue_depth(sdev, depth);
-        } else
+        } else {
                 scsi_change_queue_depth(sdev, 1);
 
                 sdev->tagged_supported = 1;
+        }
 
         return 0;
 }
diff --git a/drivers/scsi/cxgbi/libcxgbi.c b/drivers/scsi/cxgbi/libcxgbi.c
index f3bb7af4e984..ead83a24bcd1 100644
--- a/drivers/scsi/cxgbi/libcxgbi.c
+++ b/drivers/scsi/cxgbi/libcxgbi.c
@@ -688,6 +688,7 @@ static struct rt6_info *find_route_ipv6(const struct in6_addr *saddr,
 {
         struct flowi6 fl;
 
+        memset(&fl, 0, sizeof(fl));
         if (saddr)
                 memcpy(&fl.saddr, saddr, sizeof(struct in6_addr));
         if (daddr)
diff --git a/drivers/scsi/cxlflash/main.c b/drivers/scsi/cxlflash/main.c
index 35968bdb4866..8fb9643fe6e3 100644
--- a/drivers/scsi/cxlflash/main.c
+++ b/drivers/scsi/cxlflash/main.c
@@ -289,7 +289,7 @@ static void context_reset(struct afu_cmd *cmd)
                 atomic64_set(&afu->room, room);
                 if (room)
                         goto write_rrin;
-                udelay(nretry);
+                udelay(1 << nretry);
         } while (nretry++ < MC_ROOM_RETRY_CNT);
 
         pr_err("%s: no cmd_room to send reset\n", __func__);
@@ -303,7 +303,7 @@ write_rrin:
                 if (rrin != 0x1)
                         break;
                 /* Double delay each time */
-                udelay(2 << nretry);
+                udelay(1 << nretry);
         } while (nretry++ < MC_ROOM_RETRY_CNT);
 }
 
@@ -338,7 +338,7 @@ retry:
                         atomic64_set(&afu->room, room);
                         if (room)
                                 goto write_ioarrin;
-                        udelay(nretry);
+                        udelay(1 << nretry);
                 } while (nretry++ < MC_ROOM_RETRY_CNT);
 
                 dev_err(dev, "%s: no cmd_room to send 0x%X\n",
@@ -352,7 +352,7 @@ retry:
                  * afu->room.
                  */
                 if (nretry++ < MC_ROOM_RETRY_CNT) {
-                        udelay(nretry);
+                        udelay(1 << nretry);
                         goto retry;
                 }
 
@@ -683,28 +683,23 @@ static void stop_afu(struct cxlflash_cfg *cfg)
 }
 
 /**
- * term_mc() - terminates the master context
+ * term_intr() - disables all AFU interrupts
  * @cfg:        Internal structure associated with the host.
  * @level:      Depth of allocation, where to begin waterfall tear down.
  *
  * Safe to call with AFU/MC in partially allocated/initialized state.
  */
-static void term_mc(struct cxlflash_cfg *cfg, enum undo_level level)
+static void term_intr(struct cxlflash_cfg *cfg, enum undo_level level)
 {
-        int rc = 0;
         struct afu *afu = cfg->afu;
         struct device *dev = &cfg->dev->dev;
 
         if (!afu || !cfg->mcctx) {
-                dev_err(dev, "%s: returning from term_mc with NULL afu or MC\n",
-                       __func__);
+                dev_err(dev, "%s: returning with NULL afu or MC\n", __func__);
                 return;
         }
 
         switch (level) {
-        case UNDO_START:
-                rc = cxl_stop_context(cfg->mcctx);
-                BUG_ON(rc);
         case UNMAP_THREE:
                 cxl_unmap_afu_irq(cfg->mcctx, 3, afu);
         case UNMAP_TWO:
@@ -713,9 +708,34 @@ static void term_mc(struct cxlflash_cfg *cfg, enum undo_level level)
                 cxl_unmap_afu_irq(cfg->mcctx, 1, afu);
         case FREE_IRQ:
                 cxl_free_afu_irqs(cfg->mcctx);
-        case RELEASE_CONTEXT:
-                cfg->mcctx = NULL;
+                /* fall through */
+        case UNDO_NOOP:
+                /* No action required */
+                break;
+        }
+}
+
+/**
+ * term_mc() - terminates the master context
+ * @cfg:        Internal structure associated with the host.
+ * @level:      Depth of allocation, where to begin waterfall tear down.
+ *
+ * Safe to call with AFU/MC in partially allocated/initialized state.
+ */
+static void term_mc(struct cxlflash_cfg *cfg)
+{
+        int rc = 0;
+        struct afu *afu = cfg->afu;
+        struct device *dev = &cfg->dev->dev;
+
+        if (!afu || !cfg->mcctx) {
+                dev_err(dev, "%s: returning with NULL afu or MC\n", __func__);
+                return;
         }
+
+        rc = cxl_stop_context(cfg->mcctx);
+        WARN_ON(rc);
+        cfg->mcctx = NULL;
 }
 
 /**
@@ -726,10 +746,20 @@ static void term_mc(struct cxlflash_cfg *cfg, enum undo_level level)
  */
 static void term_afu(struct cxlflash_cfg *cfg)
 {
+        /*
+         * Tear down is carefully orchestrated to ensure
+         * no interrupts can come in when the problem state
+         * area is unmapped.
+         *
+         * 1) Disable all AFU interrupts
+         * 2) Unmap the problem state area
+         * 3) Stop the master context
+         */
+        term_intr(cfg, UNMAP_THREE);
         if (cfg->afu)
                 stop_afu(cfg);
 
-        term_mc(cfg, UNDO_START);
+        term_mc(cfg);
 
         pr_debug("%s: returning\n", __func__);
 }
@@ -1597,41 +1627,24 @@ static int start_afu(struct cxlflash_cfg *cfg)
 }
 
 /**
- * init_mc() - create and register as the master context
+ * init_intr() - setup interrupt handlers for the master context
  * @cfg:        Internal structure associated with the host.
  *
  * Return: 0 on success, -errno on failure
  */
-static int init_mc(struct cxlflash_cfg *cfg)
+static enum undo_level init_intr(struct cxlflash_cfg *cfg,
+                                 struct cxl_context *ctx)
 {
-        struct cxl_context *ctx;
-        struct device *dev = &cfg->dev->dev;
         struct afu *afu = cfg->afu;
+        struct device *dev = &cfg->dev->dev;
         int rc = 0;
-        enum undo_level level;
-
-        ctx = cxl_get_context(cfg->dev);
-        if (unlikely(!ctx))
-                return -ENOMEM;
-        cfg->mcctx = ctx;
-
-        /* Set it up as a master with the CXL */
-        cxl_set_master(ctx);
-
-        /* During initialization reset the AFU to start from a clean slate */
-        rc = cxl_afu_reset(cfg->mcctx);
-        if (unlikely(rc)) {
-                dev_err(dev, "%s: initial AFU reset failed rc=%d\n",
-                        __func__, rc);
-                level = RELEASE_CONTEXT;
-                goto out;
-        }
+        enum undo_level level = UNDO_NOOP;
 
         rc = cxl_allocate_afu_irqs(ctx, 3);
         if (unlikely(rc)) {
                 dev_err(dev, "%s: call to allocate_afu_irqs failed rc=%d!\n",
                         __func__, rc);
-                level = RELEASE_CONTEXT;
+                level = UNDO_NOOP;
                 goto out;
         }
 
@@ -1661,8 +1674,47 @@ static int init_mc(struct cxlflash_cfg *cfg)
                 level = UNMAP_TWO;
                 goto out;
         }
+out:
+        return level;
+}
 
-        rc = 0;
+/**
+ * init_mc() - create and register as the master context
+ * @cfg:        Internal structure associated with the host.
+ *
+ * Return: 0 on success, -errno on failure
+ */
+static int init_mc(struct cxlflash_cfg *cfg)
+{
+        struct cxl_context *ctx;
+        struct device *dev = &cfg->dev->dev;
+        int rc = 0;
+        enum undo_level level;
+
+        ctx = cxl_get_context(cfg->dev);
+        if (unlikely(!ctx)) {
+                rc = -ENOMEM;
+                goto ret;
+        }
+        cfg->mcctx = ctx;
+
+        /* Set it up as a master with the CXL */
+        cxl_set_master(ctx);
+
+        /* During initialization reset the AFU to start from a clean slate */
+        rc = cxl_afu_reset(cfg->mcctx);
+        if (unlikely(rc)) {
+                dev_err(dev, "%s: initial AFU reset failed rc=%d\n",
+                        __func__, rc);
+                goto ret;
+        }
+
+        level = init_intr(cfg, ctx);
+        if (unlikely(level)) {
+                dev_err(dev, "%s: setting up interrupts failed rc=%d\n",
+                        __func__, rc);
+                goto out;
+        }
 
         /* This performs the equivalent of the CXL_IOCTL_START_WORK.
          * The CXL_IOCTL_GET_PROCESS_ELEMENT is implicit in the process
@@ -1678,7 +1730,7 @@ ret:
         pr_debug("%s: returning rc=%d\n", __func__, rc);
         return rc;
 out:
-        term_mc(cfg, level);
+        term_intr(cfg, level);
         goto ret;
 }
 
@@ -1751,7 +1803,8 @@ out:
 err2:
         kref_put(&afu->mapcount, afu_unmap);
 err1:
-        term_mc(cfg, UNDO_START);
+        term_intr(cfg, UNMAP_THREE);
+        term_mc(cfg);
         goto out;
 }
 
@@ -2488,8 +2541,7 @@ static pci_ers_result_t cxlflash_pci_error_detected(struct pci_dev *pdev,
                 if (unlikely(rc))
                         dev_err(dev, "%s: Failed to mark user contexts!(%d)\n",
                                 __func__, rc);
-                stop_afu(cfg);
-                term_mc(cfg, UNDO_START);
+                term_afu(cfg);
                 return PCI_ERS_RESULT_NEED_RESET;
         case pci_channel_io_perm_failure:
                 cfg->state = STATE_FAILTERM;
diff --git a/drivers/scsi/cxlflash/main.h b/drivers/scsi/cxlflash/main.h
index 0faed422c7f4..eb9d8f730b38 100644
--- a/drivers/scsi/cxlflash/main.h
+++ b/drivers/scsi/cxlflash/main.h
@@ -79,12 +79,11 @@
 #define WWPN_BUF_LEN    (WWPN_LEN + 1)
 
 enum undo_level {
-        RELEASE_CONTEXT = 0,
+        UNDO_NOOP = 0,
         FREE_IRQ,
         UNMAP_ONE,
         UNMAP_TWO,
-        UNMAP_THREE,
-        UNDO_START
+        UNMAP_THREE
 };
 
 struct dev_dependent_vals {
diff --git a/drivers/scsi/device_handler/scsi_dh_alua.c b/drivers/scsi/device_handler/scsi_dh_alua.c
index a404a41e871c..8eaed0522aa3 100644
--- a/drivers/scsi/device_handler/scsi_dh_alua.c
+++ b/drivers/scsi/device_handler/scsi_dh_alua.c
@@ -1112,9 +1112,9 @@ static void alua_bus_detach(struct scsi_device *sdev)
         h->sdev = NULL;
         spin_unlock(&h->pg_lock);
         if (pg) {
-                spin_lock(&pg->lock);
+                spin_lock_irq(&pg->lock);
                 list_del_rcu(&h->node);
-                spin_unlock(&pg->lock);
+                spin_unlock_irq(&pg->lock);
                 kref_put(&pg->kref, release_port_group);
         }
         sdev->handler_data = NULL;
diff --git a/drivers/scsi/mpt3sas/mpt3sas_base.c b/drivers/scsi/mpt3sas/mpt3sas_base.c
index e4db5fb3239a..8c44b9c424af 100644
--- a/drivers/scsi/mpt3sas/mpt3sas_base.c
+++ b/drivers/scsi/mpt3sas/mpt3sas_base.c
@@ -5030,7 +5030,7 @@ _base_make_ioc_ready(struct MPT3SAS_ADAPTER *ioc, int sleep_flag,
 static int
 _base_make_ioc_operational(struct MPT3SAS_ADAPTER *ioc, int sleep_flag)
 {
-        int r, i;
+        int r, i, index;
         unsigned long   flags;
         u32 reply_address;
         u16 smid;
@@ -5039,8 +5039,7 @@ _base_make_ioc_operational(struct MPT3SAS_ADAPTER *ioc, int sleep_flag)
         struct _event_ack_list *delayed_event_ack, *delayed_event_ack_next;
         u8 hide_flag;
         struct adapter_reply_queue *reply_q;
-        long reply_post_free;
-        u32 reply_post_free_sz, index = 0;
+        Mpi2ReplyDescriptorsUnion_t *reply_post_free_contig;
 
         dinitprintk(ioc, pr_info(MPT3SAS_FMT "%s\n", ioc->name,
             __func__));
@@ -5124,27 +5123,27 @@ _base_make_ioc_operational(struct MPT3SAS_ADAPTER *ioc, int sleep_flag)
                 _base_assign_reply_queues(ioc);
 
         /* initialize Reply Post Free Queue */
-        reply_post_free_sz = ioc->reply_post_queue_depth *
-            sizeof(Mpi2DefaultReplyDescriptor_t);
-        reply_post_free = (long)ioc->reply_post[index].reply_post_free;
+        index = 0;
+        reply_post_free_contig = ioc->reply_post[0].reply_post_free;
         list_for_each_entry(reply_q, &ioc->reply_queue_list, list) {
+                /*
+                 * If RDPQ is enabled, switch to the next allocation.
+                 * Otherwise advance within the contiguous region.
+                 */
+                if (ioc->rdpq_array_enable) {
+                        reply_q->reply_post_free =
+                                ioc->reply_post[index++].reply_post_free;
+                } else {
+                        reply_q->reply_post_free = reply_post_free_contig;
+                        reply_post_free_contig += ioc->reply_post_queue_depth;
+                }
+
                 reply_q->reply_post_host_index = 0;
-                reply_q->reply_post_free = (Mpi2ReplyDescriptorsUnion_t *)
-                    reply_post_free;
                 for (i = 0; i < ioc->reply_post_queue_depth; i++)
                         reply_q->reply_post_free[i].Words =
                             cpu_to_le64(ULLONG_MAX);
                 if (!_base_is_controller_msix_enabled(ioc))
                         goto skip_init_reply_post_free_queue;
-                /*
-                 * If RDPQ is enabled, switch to the next allocation.
-                 * Otherwise advance within the contiguous region.
-                 */
-                if (ioc->rdpq_array_enable)
-                        reply_post_free = (long)
-                            ioc->reply_post[++index].reply_post_free;
-                else
-                        reply_post_free += reply_post_free_sz;
         }
  skip_init_reply_post_free_queue:
 
diff --git a/drivers/scsi/scsi.c b/drivers/scsi/scsi.c
index b1bf42b93fcc..1deb6adc411f 100644
--- a/drivers/scsi/scsi.c
+++ b/drivers/scsi/scsi.c
@@ -784,8 +784,9 @@ void scsi_attach_vpd(struct scsi_device *sdev)
         int pg83_supported = 0;
         unsigned char __rcu *vpd_buf, *orig_vpd_buf = NULL;
 
-        if (sdev->skip_vpd_pages)
+        if (!scsi_device_supports_vpd(sdev))
                 return;
+
 retry_pg0:
         vpd_buf = kmalloc(vpd_len, GFP_KERNEL);
         if (!vpd_buf)
diff --git a/drivers/scsi/scsi_sysfs.c b/drivers/scsi/scsi_sysfs.c
index 92ffd2406f97..2b642b145be1 100644
--- a/drivers/scsi/scsi_sysfs.c
+++ b/drivers/scsi/scsi_sysfs.c
@@ -81,6 +81,7 @@ const char *scsi_host_state_name(enum scsi_host_state state)
         return name;
 }
 
+#ifdef CONFIG_SCSI_DH
 static const struct {
         unsigned char   value;
         char            *name;
@@ -94,7 +95,7 @@ static const struct {
         { SCSI_ACCESS_STATE_TRANSITIONING, "transitioning" },
 };
 
-const char *scsi_access_state_name(unsigned char state)
+static const char *scsi_access_state_name(unsigned char state)
 {
         int i;
         char *name = NULL;
@@ -107,6 +108,7 @@ const char *scsi_access_state_name(unsigned char state)
         }
         return name;
 }
+#endif
 
 static int check_set(unsigned long long *val, char *src)
 {
@@ -226,7 +228,7 @@ show_shost_state(struct device *dev, struct device_attribute *attr, char *buf)
 }
 
 /* DEVICE_ATTR(state) clashes with dev_attr_state for sdev */
-struct device_attribute dev_attr_hstate =
+static struct device_attribute dev_attr_hstate =
         __ATTR(state, S_IRUGO | S_IWUSR, show_shost_state, store_shost_state);
 
 static ssize_t
@@ -401,7 +403,7 @@ static struct attribute *scsi_sysfs_shost_attrs[] = {
         NULL
 };
 
-struct attribute_group scsi_shost_attr_group = {
+static struct attribute_group scsi_shost_attr_group = {
         .attrs =        scsi_sysfs_shost_attrs,
 };
 
diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c
index 5a5457ac9cdb..f52b74cf8d1e 100644
--- a/drivers/scsi/sd.c
+++ b/drivers/scsi/sd.c
@@ -1275,18 +1275,19 @@ static int sd_getgeo(struct block_device *bdev, struct hd_geometry *geo)
         struct scsi_disk *sdkp = scsi_disk(bdev->bd_disk);
         struct scsi_device *sdp = sdkp->device;
         struct Scsi_Host *host = sdp->host;
+        sector_t capacity = logical_to_sectors(sdp, sdkp->capacity);
         int diskinfo[4];
 
         /* default to most commonly used values */
-        diskinfo[0] = 0x40;     /* 1 << 6 */
-        diskinfo[1] = 0x20;     /* 1 << 5 */
-        diskinfo[2] = sdkp->capacity >> 11;
-        
+        diskinfo[0] = 0x40;     /* 1 << 6 */
+        diskinfo[1] = 0x20;     /* 1 << 5 */
+        diskinfo[2] = capacity >> 11;
+
         /* override with calculated, extended default, or driver values */
         if (host->hostt->bios_param)
-                host->hostt->bios_param(sdp, bdev, sdkp->capacity, diskinfo);
+                host->hostt->bios_param(sdp, bdev, capacity, diskinfo);
         else
-                scsicam_bios_param(bdev, sdkp->capacity, diskinfo);
+                scsicam_bios_param(bdev, capacity, diskinfo);
 
         geo->heads = diskinfo[0];
         geo->sectors = diskinfo[1];
@@ -2337,14 +2338,6 @@ got_data:
         if (sdkp->capacity > 0xffffffff)
                 sdp->use_16_for_rw = 1;
 
-        /* Rescale capacity to 512-byte units */
-        if (sector_size == 4096)
-                sdkp->capacity <<= 3;
-        else if (sector_size == 2048)
-                sdkp->capacity <<= 2;
-        else if (sector_size == 1024)
-                sdkp->capacity <<= 1;
-
         blk_queue_physical_block_size(sdp->request_queue,
                                       sdkp->physical_block_size);
         sdkp->device->sector_size = sector_size;
@@ -2795,28 +2788,6 @@ static void sd_read_write_same(struct scsi_disk *sdkp, unsigned char *buffer)
                 sdkp->ws10 = 1;
 }
 
-static int sd_try_extended_inquiry(struct scsi_device *sdp)
-{
-        /* Attempt VPD inquiry if the device blacklist explicitly calls
-         * for it.
-         */
-        if (sdp->try_vpd_pages)
-                return 1;
-        /*
-         * Although VPD inquiries can go to SCSI-2 type devices,
-         * some USB ones crash on receiving them, and the pages
-         * we currently ask for are for SPC-3 and beyond
-         */
-        if (sdp->scsi_level > SCSI_SPC_2 && !sdp->skip_vpd_pages)
-                return 1;
-        return 0;
-}
-
-static inline u32 logical_to_sectors(struct scsi_device *sdev, u32 blocks)
-{
-        return blocks << (ilog2(sdev->sector_size) - 9);
-}
-
 /**
  *      sd_revalidate_disk - called the first time a new disk is seen,
  *      performs disk spin up, read_capacity, etc.
@@ -2856,7 +2827,7 @@ static int sd_revalidate_disk(struct gendisk *disk)
         if (sdkp->media_present) {
                 sd_read_capacity(sdkp, buffer);
 
-                if (sd_try_extended_inquiry(sdp)) {
+                if (scsi_device_supports_vpd(sdp)) {
                         sd_read_block_provisioning(sdkp);
                         sd_read_block_limits(sdkp);
                         sd_read_block_characteristics(sdkp);
@@ -2891,7 +2862,7 @@ static int sd_revalidate_disk(struct gendisk *disk)
         if (sdkp->opt_xfer_blocks &&
             sdkp->opt_xfer_blocks <= dev_max &&
             sdkp->opt_xfer_blocks <= SD_DEF_XFER_BLOCKS &&
-            sdkp->opt_xfer_blocks * sdp->sector_size >= PAGE_CACHE_SIZE)
+            sdkp->opt_xfer_blocks * sdp->sector_size >= PAGE_SIZE)
                 rw_max = q->limits.io_opt =
                         sdkp->opt_xfer_blocks * sdp->sector_size;
         else
@@ -2900,7 +2871,7 @@ static int sd_revalidate_disk(struct gendisk *disk)
         /* Combine with controller limits */
         q->limits.max_sectors = min(rw_max, queue_max_hw_sectors(q));
 
-        set_capacity(disk, sdkp->capacity);
+        set_capacity(disk, logical_to_sectors(sdp, sdkp->capacity));
         sd_config_write_same(sdkp);
         kfree(buffer);
 
diff --git a/drivers/scsi/sd.h b/drivers/scsi/sd.h
index 5f2a84aff29f..654630bb7d0e 100644
--- a/drivers/scsi/sd.h
+++ b/drivers/scsi/sd.h
@@ -65,7 +65,7 @@ struct scsi_disk {
         struct device   dev;
         struct gendisk  *disk;
         atomic_t        openers;
-        sector_t        capacity;       /* size in 512-byte sectors */
+        sector_t        capacity;       /* size in logical blocks */
         u32             max_xfer_blocks;
         u32             opt_xfer_blocks;
         u32             max_ws_blocks;
@@ -146,6 +146,11 @@ static inline int scsi_medium_access_command(struct scsi_cmnd *scmd)
         return 0;
 }
 
+static inline sector_t logical_to_sectors(struct scsi_device *sdev, sector_t blocks)
+{
+        return blocks << (ilog2(sdev->sector_size) - 9);
+}
+
 /*
  * A DIF-capable target device can be formatted with different
  * protection schemes.  Currently 0 through 3 are defined:
diff --git a/drivers/scsi/st.c b/drivers/scsi/st.c
index 71c5138ddf94..dbf1882cfbac 100644
--- a/drivers/scsi/st.c
+++ b/drivers/scsi/st.c
@@ -4941,7 +4941,7 @@ static int sgl_map_user_pages(struct st_buffer *STbp,
  out_unmap:
         if (res > 0) {
                 for (j=0; j < res; j++)
-                        page_cache_release(pages[j]);
+                        put_page(pages[j]);
                 res = 0;
         }
         kfree(pages);
@@ -4963,7 +4963,7 @@ static int sgl_unmap_user_pages(struct st_buffer *STbp,
                 /* FIXME: cache flush missing for rw==READ
                  * FIXME: call the correct reference counting function
                  */
-                page_cache_release(page);
+                put_page(page);
         }
         kfree(STbp->mapped_pages);
         STbp->mapped_pages = NULL;
diff --git a/drivers/soc/mediatek/mtk-scpsys.c b/drivers/soc/mediatek/mtk-scpsys.c
index 57e781c71e67..837effe19907 100644
--- a/drivers/soc/mediatek/mtk-scpsys.c
+++ b/drivers/soc/mediatek/mtk-scpsys.c
@@ -491,13 +491,14 @@ static int scpsys_probe(struct platform_device *pdev)
                 genpd->dev_ops.active_wakeup = scpsys_active_wakeup;
 
                 /*
-                 * With CONFIG_PM disabled turn on all domains to make the
-                 * hardware usable.
+                 * Initially turn on all domains to make the domains usable
+                 * with !CONFIG_PM and to get the hardware in sync with the
+                 * software.  The unused domains will be switched off during
+                 * late_init time.
                  */
-                if (!IS_ENABLED(CONFIG_PM))
-                        genpd->power_on(genpd);
+                genpd->power_on(genpd);
 
-                pm_genpd_init(genpd, NULL, true);
+                pm_genpd_init(genpd, NULL, false);
         }
 
         /*
diff --git a/drivers/spi/spi-imx.c b/drivers/spi/spi-imx.c
index e7a19be87c38..50769078e72e 100644
--- a/drivers/spi/spi-imx.c
+++ b/drivers/spi/spi-imx.c
@@ -211,11 +211,15 @@ static bool spi_imx_can_dma(struct spi_master *master, struct spi_device *spi,
                          struct spi_transfer *transfer)
 {
         struct spi_imx_data *spi_imx = spi_master_get_devdata(master);
-        unsigned int bpw = transfer->bits_per_word;
+        unsigned int bpw;
 
         if (!master->dma_rx)
                 return false;
 
+        if (!transfer)
+                return false;
+
+        bpw = transfer->bits_per_word;
         if (!bpw)
                 bpw = spi->bits_per_word;
 
@@ -333,8 +337,9 @@ static void __maybe_unused mx51_ecspi_trigger(struct spi_imx_data *spi_imx)
 static int __maybe_unused mx51_ecspi_config(struct spi_imx_data *spi_imx,
                 struct spi_imx_config *config)
 {
-        u32 ctrl = MX51_ECSPI_CTRL_ENABLE, cfg = 0;
+        u32 ctrl = MX51_ECSPI_CTRL_ENABLE;
         u32 clk = config->speed_hz, delay, reg;
+        u32 cfg = readl(spi_imx->base + MX51_ECSPI_CONFIG);
 
         /*
          * The hardware seems to have a race condition when changing modes. The
@@ -358,13 +363,20 @@ static int __maybe_unused mx51_ecspi_config(struct spi_imx_data *spi_imx,
 
         if (config->mode & SPI_CPHA)
                 cfg |= MX51_ECSPI_CONFIG_SCLKPHA(config->cs);
+        else
+                cfg &= ~MX51_ECSPI_CONFIG_SCLKPHA(config->cs);
 
         if (config->mode & SPI_CPOL) {
                 cfg |= MX51_ECSPI_CONFIG_SCLKPOL(config->cs);
                 cfg |= MX51_ECSPI_CONFIG_SCLKCTL(config->cs);
+        } else {
+                cfg &= ~MX51_ECSPI_CONFIG_SCLKPOL(config->cs);
+                cfg &= ~MX51_ECSPI_CONFIG_SCLKCTL(config->cs);
         }
         if (config->mode & SPI_CS_HIGH)
                 cfg |= MX51_ECSPI_CONFIG_SSBPOL(config->cs);
+        else
+                cfg &= ~MX51_ECSPI_CONFIG_SSBPOL(config->cs);
 
         if (spi_imx->usedma)
                 ctrl |= MX51_ECSPI_CTRL_SMC;
diff --git a/drivers/spi/spi-omap2-mcspi.c b/drivers/spi/spi-omap2-mcspi.c
index 0caa3c8bef46..43a02e377b3b 100644
--- a/drivers/spi/spi-omap2-mcspi.c
+++ b/drivers/spi/spi-omap2-mcspi.c
@@ -423,16 +423,12 @@ static void omap2_mcspi_tx_dma(struct spi_device *spi,
 
         if (mcspi_dma->dma_tx) {
                 struct dma_async_tx_descriptor *tx;
-                struct scatterlist sg;
 
                 dmaengine_slave_config(mcspi_dma->dma_tx, &cfg);
 
-                sg_init_table(&sg, 1);
-                sg_dma_address(&sg) = xfer->tx_dma;
-                sg_dma_len(&sg) = xfer->len;
-
-                tx = dmaengine_prep_slave_sg(mcspi_dma->dma_tx, &sg, 1,
-                DMA_MEM_TO_DEV, DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
+                tx = dmaengine_prep_slave_sg(mcspi_dma->dma_tx, xfer->tx_sg.sgl,
+                                             xfer->tx_sg.nents, DMA_MEM_TO_DEV,
+                                             DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
                 if (tx) {
                         tx->callback = omap2_mcspi_tx_callback;
                         tx->callback_param = spi;
@@ -478,20 +474,15 @@ omap2_mcspi_rx_dma(struct spi_device *spi, struct spi_transfer *xfer,
 
         if (mcspi_dma->dma_rx) {
                 struct dma_async_tx_descriptor *tx;
-                struct scatterlist sg;
 
                 dmaengine_slave_config(mcspi_dma->dma_rx, &cfg);
 
                 if ((l & OMAP2_MCSPI_CHCONF_TURBO) && mcspi->fifo_depth == 0)
                         dma_count -= es;
 
-                sg_init_table(&sg, 1);
-                sg_dma_address(&sg) = xfer->rx_dma;
-                sg_dma_len(&sg) = dma_count;
-
-                tx = dmaengine_prep_slave_sg(mcspi_dma->dma_rx, &sg, 1,
-                                DMA_DEV_TO_MEM, DMA_PREP_INTERRUPT |
-                                DMA_CTRL_ACK);
+                tx = dmaengine_prep_slave_sg(mcspi_dma->dma_rx, xfer->rx_sg.sgl,
+                                             xfer->rx_sg.nents, DMA_DEV_TO_MEM,
+                                             DMA_PREP_INTERRUPT | DMA_CTRL_ACK);
                 if (tx) {
                         tx->callback = omap2_mcspi_rx_callback;
                         tx->callback_param = spi;
@@ -505,8 +496,6 @@ omap2_mcspi_rx_dma(struct spi_device *spi, struct spi_transfer *xfer,
         omap2_mcspi_set_dma_req(spi, 1, 1);
 
         wait_for_completion(&mcspi_dma->dma_rx_completion);
-        dma_unmap_single(mcspi->dev, xfer->rx_dma, count,
-                         DMA_FROM_DEVICE);
 
         if (mcspi->fifo_depth > 0)
                 return count;
@@ -619,8 +608,6 @@ omap2_mcspi_txrx_dma(struct spi_device *spi, struct spi_transfer *xfer)
 
         if (tx != NULL) {
                 wait_for_completion(&mcspi_dma->dma_tx_completion);
-                dma_unmap_single(mcspi->dev, xfer->tx_dma, xfer->len,
-                                 DMA_TO_DEVICE);
 
                 if (mcspi->fifo_depth > 0) {
                         irqstat_reg = mcspi->base + OMAP2_MCSPI_IRQSTATUS;
@@ -1087,6 +1074,16 @@ static void omap2_mcspi_cleanup(struct spi_device *spi)
                 gpio_free(spi->cs_gpio);
 }
 
+static bool omap2_mcspi_can_dma(struct spi_master *master,
+                                struct spi_device *spi,
+                                struct spi_transfer *xfer)
+{
+        if (xfer->len < DMA_MIN_BYTES)
+                return false;
+
+        return true;
+}
+
 static int omap2_mcspi_work_one(struct omap2_mcspi *mcspi,
                 struct spi_device *spi, struct spi_transfer *t)
 {
@@ -1268,32 +1265,6 @@ static int omap2_mcspi_transfer_one(struct spi_master *master,
                 return -EINVAL;
         }
 
-        if (len < DMA_MIN_BYTES)
-                goto skip_dma_map;
-
-        if (mcspi_dma->dma_tx && tx_buf != NULL) {
-                t->tx_dma = dma_map_single(mcspi->dev, (void *) tx_buf,
-                                len, DMA_TO_DEVICE);
-                if (dma_mapping_error(mcspi->dev, t->tx_dma)) {
-                        dev_dbg(mcspi->dev, "dma %cX %d bytes error\n",
-                                        'T', len);
-                        return -EINVAL;
-                }
-        }
-        if (mcspi_dma->dma_rx && rx_buf != NULL) {
-                t->rx_dma = dma_map_single(mcspi->dev, rx_buf, t->len,
-                                DMA_FROM_DEVICE);
-                if (dma_mapping_error(mcspi->dev, t->rx_dma)) {
-                        dev_dbg(mcspi->dev, "dma %cX %d bytes error\n",
-                                        'R', len);
-                        if (tx_buf != NULL)
-                                dma_unmap_single(mcspi->dev, t->tx_dma,
-                                                len, DMA_TO_DEVICE);
-                        return -EINVAL;
-                }
-        }
-
-skip_dma_map:
         return omap2_mcspi_work_one(mcspi, spi, t);
 }
 
@@ -1377,6 +1348,7 @@ static int omap2_mcspi_probe(struct platform_device *pdev)
         master->transfer_one = omap2_mcspi_transfer_one;
         master->set_cs = omap2_mcspi_set_cs;
         master->cleanup = omap2_mcspi_cleanup;
+        master->can_dma = omap2_mcspi_can_dma;
         master->dev.of_node = node;
         master->max_speed_hz = OMAP2_MCSPI_MAX_FREQ;
         master->min_speed_hz = OMAP2_MCSPI_MAX_FREQ >> 15;
diff --git a/drivers/spi/spi-rockchip.c b/drivers/spi/spi-rockchip.c
index 8f50a4020f6f..6c6c0013ec7a 100644
--- a/drivers/spi/spi-rockchip.c
+++ b/drivers/spi/spi-rockchip.c
@@ -534,7 +534,7 @@ static void rockchip_spi_config(struct rockchip_spi *rs)
         if (WARN_ON(rs->speed > MAX_SCLK_OUT))
                 rs->speed = MAX_SCLK_OUT;
 
-        /* the minimum divsor is 2 */
+        /* the minimum divisor is 2 */
         if (rs->max_freq < 2 * rs->speed) {
                 clk_set_rate(rs->spiclk, 2 * rs->speed);
                 rs->max_freq = clk_get_rate(rs->spiclk);
@@ -730,23 +730,27 @@ static int rockchip_spi_probe(struct platform_device *pdev)
         master->transfer_one = rockchip_spi_transfer_one;
         master->handle_err = rockchip_spi_handle_err;
 
-        rs->dma_tx.ch = dma_request_slave_channel(rs->dev, "tx");
-        if (IS_ERR_OR_NULL(rs->dma_tx.ch)) {
+        rs->dma_tx.ch = dma_request_chan(rs->dev, "tx");
+        if (IS_ERR(rs->dma_tx.ch)) {
                 /* Check tx to see if we need defer probing driver */
                 if (PTR_ERR(rs->dma_tx.ch) == -EPROBE_DEFER) {
                         ret = -EPROBE_DEFER;
                         goto err_get_fifo_len;
                 }
                 dev_warn(rs->dev, "Failed to request TX DMA channel\n");
+                rs->dma_tx.ch = NULL;
         }
 
-        rs->dma_rx.ch = dma_request_slave_channel(rs->dev, "rx");
-        if (!rs->dma_rx.ch) {
-                if (rs->dma_tx.ch) {
+        rs->dma_rx.ch = dma_request_chan(rs->dev, "rx");
+        if (IS_ERR(rs->dma_rx.ch)) {
+                if (PTR_ERR(rs->dma_rx.ch) == -EPROBE_DEFER) {
                         dma_release_channel(rs->dma_tx.ch);
                         rs->dma_tx.ch = NULL;
+                        ret = -EPROBE_DEFER;
+                        goto err_get_fifo_len;
                 }
                 dev_warn(rs->dev, "Failed to request RX DMA channel\n");
+                rs->dma_rx.ch = NULL;
         }
 
         if (rs->dma_tx.ch && rs->dma_rx.ch) {
diff --git a/drivers/spi/spi.c b/drivers/spi/spi.c
index de2f2f90d799..0239b45eed92 100644
--- a/drivers/spi/spi.c
+++ b/drivers/spi/spi.c
@@ -1209,7 +1209,7 @@ static void spi_pump_messages(struct kthread_work *work)
         struct spi_master *master =
                 container_of(work, struct spi_master, pump_messages);
 
-        __spi_pump_messages(master, true, false);
+        __spi_pump_messages(master, true, master->bus_lock_flag);
 }
 
 static int spi_init_queue(struct spi_master *master)
@@ -2853,7 +2853,7 @@ static int __spi_sync(struct spi_device *spi, struct spi_message *message,
  */
 int spi_sync(struct spi_device *spi, struct spi_message *message)
 {
-        return __spi_sync(spi, message, 0);
+        return __spi_sync(spi, message, spi->master->bus_lock_flag);
 }
 EXPORT_SYMBOL_GPL(spi_sync);
 
diff --git a/drivers/staging/Kconfig b/drivers/staging/Kconfig
index cf84581287b9..5bac28a3944e 100644
--- a/drivers/staging/Kconfig
+++ b/drivers/staging/Kconfig
@@ -30,6 +30,8 @@ source "drivers/staging/wlan-ng/Kconfig"
 
 source "drivers/staging/comedi/Kconfig"
 
+source "drivers/staging/olpc_dcon/Kconfig"
+
 source "drivers/staging/rtl8192u/Kconfig"
 
 source "drivers/staging/rtl8192e/Kconfig"
diff --git a/drivers/staging/Makefile b/drivers/staging/Makefile
index 7d6448d20464..a954242b0f2c 100644
--- a/drivers/staging/Makefile
+++ b/drivers/staging/Makefile
@@ -4,6 +4,7 @@ obj-y				+= media/
 obj-$(CONFIG_SLICOSS)           += slicoss/
 obj-$(CONFIG_PRISM2_USB)        += wlan-ng/
 obj-$(CONFIG_COMEDI)            += comedi/
+obj-$(CONFIG_FB_OLPC_DCON)      += olpc_dcon/
 obj-$(CONFIG_RTL8192U)          += rtl8192u/
 obj-$(CONFIG_RTL8192E)          += rtl8192e/
 obj-$(CONFIG_R8712U)            += rtl8712/
diff --git a/drivers/staging/lustre/include/linux/libcfs/libcfs_private.h b/drivers/staging/lustre/include/linux/libcfs/libcfs_private.h
index dab486261154..13335437c69c 100644
--- a/drivers/staging/lustre/include/linux/libcfs/libcfs_private.h
+++ b/drivers/staging/lustre/include/linux/libcfs/libcfs_private.h
@@ -88,7 +88,7 @@ do {								    \
 } while (0)
 
 #ifndef LIBCFS_VMALLOC_SIZE
-#define LIBCFS_VMALLOC_SIZE     (2 << PAGE_CACHE_SHIFT) /* 2 pages */
+#define LIBCFS_VMALLOC_SIZE     (2 << PAGE_SHIFT) /* 2 pages */
 #endif
 
 #define LIBCFS_ALLOC_PRE(size, mask)                                        \
diff --git a/drivers/staging/lustre/include/linux/libcfs/linux/linux-mem.h b/drivers/staging/lustre/include/linux/libcfs/linux/linux-mem.h
index 0f2fd79e5ec8..837eb22749c3 100644
--- a/drivers/staging/lustre/include/linux/libcfs/linux/linux-mem.h
+++ b/drivers/staging/lustre/include/linux/libcfs/linux/linux-mem.h
@@ -57,7 +57,7 @@
 #include "../libcfs_cpu.h"
 #endif
 
-#define CFS_PAGE_MASK              (~((__u64)PAGE_CACHE_SIZE-1))
+#define CFS_PAGE_MASK              (~((__u64)PAGE_SIZE-1))
 #define page_index(p)       ((p)->index)
 
 #define memory_pressure_get() (current->flags & PF_MEMALLOC)
@@ -67,7 +67,7 @@
 #if BITS_PER_LONG == 32
 /* limit to lowmem on 32-bit systems */
 #define NUM_CACHEPAGES \
-        min(totalram_pages, 1UL << (30 - PAGE_CACHE_SHIFT) * 3 / 4)
+        min(totalram_pages, 1UL << (30 - PAGE_SHIFT) * 3 / 4)
 #else
 #define NUM_CACHEPAGES totalram_pages
 #endif
diff --git a/drivers/staging/lustre/include/linux/lnet/types.h b/drivers/staging/lustre/include/linux/lnet/types.h
index 08f193c341c5..1c679cb72785 100644
--- a/drivers/staging/lustre/include/linux/lnet/types.h
+++ b/drivers/staging/lustre/include/linux/lnet/types.h
@@ -514,7 +514,7 @@ typedef struct {
         /**
          * Starting offset of the fragment within the page. Note that the
          * end of the fragment must not pass the end of the page; i.e.,
-         * kiov_len + kiov_offset <= PAGE_CACHE_SIZE.
+         * kiov_len + kiov_offset <= PAGE_SIZE.
          */
         unsigned int     kiov_offset;
 } lnet_kiov_t;
diff --git a/drivers/staging/lustre/lnet/klnds/socklnd/socklnd_lib.c b/drivers/staging/lustre/lnet/klnds/socklnd/socklnd_lib.c
index 3e1f24e77f64..d4ce06d0aeeb 100644
--- a/drivers/staging/lustre/lnet/klnds/socklnd/socklnd_lib.c
+++ b/drivers/staging/lustre/lnet/klnds/socklnd/socklnd_lib.c
@@ -291,7 +291,7 @@ ksocknal_lib_kiov_vmap(lnet_kiov_t *kiov, int niov,
 
         for (nob = i = 0; i < niov; i++) {
                 if ((kiov[i].kiov_offset && i > 0) ||
-                    (kiov[i].kiov_offset + kiov[i].kiov_len != PAGE_CACHE_SIZE && i < niov - 1))
+                    (kiov[i].kiov_offset + kiov[i].kiov_len != PAGE_SIZE && i < niov - 1))
                         return NULL;
 
                 pages[i] = kiov[i].kiov_page;
diff --git a/drivers/staging/lustre/lnet/libcfs/debug.c b/drivers/staging/lustre/lnet/libcfs/debug.c
index c90e5102fe06..c3d628bac5b8 100644
--- a/drivers/staging/lustre/lnet/libcfs/debug.c
+++ b/drivers/staging/lustre/lnet/libcfs/debug.c
@@ -517,7 +517,7 @@ int libcfs_debug_init(unsigned long bufsize)
                 max = TCD_MAX_PAGES;
         } else {
                 max = max / num_possible_cpus();
-                max <<= (20 - PAGE_CACHE_SHIFT);
+                max <<= (20 - PAGE_SHIFT);
         }
         rc = cfs_tracefile_init(max);
 
diff --git a/drivers/staging/lustre/lnet/libcfs/tracefile.c b/drivers/staging/lustre/lnet/libcfs/tracefile.c
index ec3bc04bd89f..244eb89eef68 100644
--- a/drivers/staging/lustre/lnet/libcfs/tracefile.c
+++ b/drivers/staging/lustre/lnet/libcfs/tracefile.c
@@ -182,7 +182,7 @@ cfs_trace_get_tage_try(struct cfs_trace_cpu_data *tcd, unsigned long len)
         if (tcd->tcd_cur_pages > 0) {
                 __LASSERT(!list_empty(&tcd->tcd_pages));
                 tage = cfs_tage_from_list(tcd->tcd_pages.prev);
-                if (tage->used + len <= PAGE_CACHE_SIZE)
+                if (tage->used + len <= PAGE_SIZE)
                         return tage;
         }
 
@@ -260,7 +260,7 @@ static struct cfs_trace_page *cfs_trace_get_tage(struct cfs_trace_cpu_data *tcd,
          * from here: this will lead to infinite recursion.
          */
 
-        if (len > PAGE_CACHE_SIZE) {
+        if (len > PAGE_SIZE) {
                 pr_err("cowardly refusing to write %lu bytes in a page\n", len);
                 return NULL;
         }
@@ -349,7 +349,7 @@ int libcfs_debug_vmsg2(struct libcfs_debug_msg_data *msgdata,
         for (i = 0; i < 2; i++) {
                 tage = cfs_trace_get_tage(tcd, needed + known_size + 1);
                 if (!tage) {
-                        if (needed + known_size > PAGE_CACHE_SIZE)
+                        if (needed + known_size > PAGE_SIZE)
                                 mask |= D_ERROR;
 
                         cfs_trace_put_tcd(tcd);
@@ -360,7 +360,7 @@ int libcfs_debug_vmsg2(struct libcfs_debug_msg_data *msgdata,
                 string_buf = (char *)page_address(tage->page) +
                                         tage->used + known_size;
 
-                max_nob = PAGE_CACHE_SIZE - tage->used - known_size;
+                max_nob = PAGE_SIZE - tage->used - known_size;
                 if (max_nob <= 0) {
                         printk(KERN_EMERG "negative max_nob: %d\n",
                                max_nob);
@@ -424,7 +424,7 @@ int libcfs_debug_vmsg2(struct libcfs_debug_msg_data *msgdata,
         __LASSERT(debug_buf == string_buf);
 
         tage->used += needed;
-        __LASSERT(tage->used <= PAGE_CACHE_SIZE);
+        __LASSERT(tage->used <= PAGE_SIZE);
 
 console:
         if ((mask & libcfs_printk) == 0) {
@@ -835,7 +835,7 @@ EXPORT_SYMBOL(cfs_trace_copyout_string);
 
 int cfs_trace_allocate_string_buffer(char **str, int nob)
 {
-        if (nob > 2 * PAGE_CACHE_SIZE)      /* string must be "sensible" */
+        if (nob > 2 * PAGE_SIZE)            /* string must be "sensible" */
                 return -EINVAL;
 
         *str = kmalloc(nob, GFP_KERNEL | __GFP_ZERO);
@@ -951,7 +951,7 @@ int cfs_trace_set_debug_mb(int mb)
         }
 
         mb /= num_possible_cpus();
-        pages = mb << (20 - PAGE_CACHE_SHIFT);
+        pages = mb << (20 - PAGE_SHIFT);
 
         cfs_tracefile_write_lock();
 
@@ -977,7 +977,7 @@ int cfs_trace_get_debug_mb(void)
 
         cfs_tracefile_read_unlock();
 
-        return (total_pages >> (20 - PAGE_CACHE_SHIFT)) + 1;
+        return (total_pages >> (20 - PAGE_SHIFT)) + 1;
 }
 
 static int tracefiled(void *arg)
diff --git a/drivers/staging/lustre/lnet/libcfs/tracefile.h b/drivers/staging/lustre/lnet/libcfs/tracefile.h
index 4c77f9044dd3..ac84e7f4c859 100644
--- a/drivers/staging/lustre/lnet/libcfs/tracefile.h
+++ b/drivers/staging/lustre/lnet/libcfs/tracefile.h
@@ -87,7 +87,7 @@ void libcfs_unregister_panic_notifier(void);
 extern int  libcfs_panic_in_progress;
 int cfs_trace_max_debug_mb(void);
 
-#define TCD_MAX_PAGES (5 << (20 - PAGE_CACHE_SHIFT))
+#define TCD_MAX_PAGES (5 << (20 - PAGE_SHIFT))
 #define TCD_STOCK_PAGES (TCD_MAX_PAGES)
 #define CFS_TRACEFILE_SIZE (500 << 20)
 
@@ -96,7 +96,7 @@ int cfs_trace_max_debug_mb(void);
 /*
  * Private declare for tracefile
  */
-#define TCD_MAX_PAGES (5 << (20 - PAGE_CACHE_SHIFT))
+#define TCD_MAX_PAGES (5 << (20 - PAGE_SHIFT))
 #define TCD_STOCK_PAGES (TCD_MAX_PAGES)
 
 #define CFS_TRACEFILE_SIZE (500 << 20)
@@ -257,7 +257,7 @@ do {								    \
 do {                                                                \
         __LASSERT(tage);                                        \
         __LASSERT(tage->page);                            \
-        __LASSERT(tage->used <= PAGE_CACHE_SIZE);                        \
+        __LASSERT(tage->used <= PAGE_SIZE);                      \
         __LASSERT(page_count(tage->page) > 0);                \
 } while (0)
 
diff --git a/drivers/staging/lustre/lnet/lnet/lib-md.c b/drivers/staging/lustre/lnet/lnet/lib-md.c
index c74514f99f90..75d31217bf92 100644
--- a/drivers/staging/lustre/lnet/lnet/lib-md.c
+++ b/drivers/staging/lustre/lnet/lnet/lib-md.c
@@ -139,7 +139,7 @@ lnet_md_build(lnet_libmd_t *lmd, lnet_md_t *umd, int unlink)
                 for (i = 0; i < (int)niov; i++) {
                         /* We take the page pointer on trust */
                         if (lmd->md_iov.kiov[i].kiov_offset +
-                            lmd->md_iov.kiov[i].kiov_len > PAGE_CACHE_SIZE)
+                            lmd->md_iov.kiov[i].kiov_len > PAGE_SIZE)
                                 return -EINVAL; /* invalid length */
 
                         total_length += lmd->md_iov.kiov[i].kiov_len;
diff --git a/drivers/staging/lustre/lnet/lnet/lib-move.c b/drivers/staging/lustre/lnet/lnet/lib-move.c
index 0009a8de77d5..f19aa9320e34 100644
--- a/drivers/staging/lustre/lnet/lnet/lib-move.c
+++ b/drivers/staging/lustre/lnet/lnet/lib-move.c
@@ -549,12 +549,12 @@ lnet_extract_kiov(int dst_niov, lnet_kiov_t *dst,
                 if (len <= frag_len) {
                         dst->kiov_len = len;
                         LASSERT(dst->kiov_offset + dst->kiov_len
-                                        <= PAGE_CACHE_SIZE);
+                                        <= PAGE_SIZE);
                         return niov;
                 }
 
                 dst->kiov_len = frag_len;
-                LASSERT(dst->kiov_offset + dst->kiov_len <= PAGE_CACHE_SIZE);
+                LASSERT(dst->kiov_offset + dst->kiov_len <= PAGE_SIZE);
 
                 len -= frag_len;
                 dst++;
@@ -887,7 +887,7 @@ lnet_msg2bufpool(lnet_msg_t *msg)
         rbp = &the_lnet.ln_rtrpools[cpt][0];
 
         LASSERT(msg->msg_len <= LNET_MTU);
-        while (msg->msg_len > (unsigned int)rbp->rbp_npages * PAGE_CACHE_SIZE) {
+        while (msg->msg_len > (unsigned int)rbp->rbp_npages * PAGE_SIZE) {
                 rbp++;
                 LASSERT(rbp < &the_lnet.ln_rtrpools[cpt][LNET_NRBPOOLS]);
         }
diff --git a/drivers/staging/lustre/lnet/lnet/lib-socket.c b/drivers/staging/lustre/lnet/lnet/lib-socket.c
index cc0c2753dd63..891fd59401d7 100644
--- a/drivers/staging/lustre/lnet/lnet/lib-socket.c
+++ b/drivers/staging/lustre/lnet/lnet/lib-socket.c
@@ -166,9 +166,9 @@ lnet_ipif_enumerate(char ***namesp)
         nalloc = 16;    /* first guess at max interfaces */
         toobig = 0;
         for (;;) {
-                if (nalloc * sizeof(*ifr) > PAGE_CACHE_SIZE) {
+                if (nalloc * sizeof(*ifr) > PAGE_SIZE) {
                         toobig = 1;
-                        nalloc = PAGE_CACHE_SIZE / sizeof(*ifr);
+                        nalloc = PAGE_SIZE / sizeof(*ifr);
                         CWARN("Too many interfaces: only enumerating first %d\n",
                               nalloc);
                 }
diff --git a/drivers/staging/lustre/lnet/lnet/router.c b/drivers/staging/lustre/lnet/lnet/router.c
index 61459cf9d58f..b01dc424c514 100644
--- a/drivers/staging/lustre/lnet/lnet/router.c
+++ b/drivers/staging/lustre/lnet/lnet/router.c
@@ -27,8 +27,8 @@
 #define LNET_NRB_SMALL_PAGES    1
 #define LNET_NRB_LARGE_MIN      256     /* min value for each CPT */
 #define LNET_NRB_LARGE          (LNET_NRB_LARGE_MIN * 4)
-#define LNET_NRB_LARGE_PAGES   ((LNET_MTU + PAGE_CACHE_SIZE - 1) >> \
-                                 PAGE_CACHE_SHIFT)
+#define LNET_NRB_LARGE_PAGES   ((LNET_MTU + PAGE_SIZE - 1) >> \
+                                 PAGE_SHIFT)
 
 static char *forwarding = "";
 module_param(forwarding, charp, 0444);
@@ -1338,7 +1338,7 @@ lnet_new_rtrbuf(lnet_rtrbufpool_t *rbp, int cpt)
                         return NULL;
                 }
 
-                rb->rb_kiov[i].kiov_len = PAGE_CACHE_SIZE;
+                rb->rb_kiov[i].kiov_len = PAGE_SIZE;
                 rb->rb_kiov[i].kiov_offset = 0;
                 rb->rb_kiov[i].kiov_page = page;
         }
diff --git a/drivers/staging/lustre/lnet/selftest/brw_test.c b/drivers/staging/lustre/lnet/selftest/brw_test.c
index eebc92412061..dcb6e506f592 100644
--- a/drivers/staging/lustre/lnet/selftest/brw_test.c
+++ b/drivers/staging/lustre/lnet/selftest/brw_test.c
@@ -90,7 +90,7 @@ brw_client_init(sfw_test_instance_t *tsi)
                  * NB: this is not going to work for variable page size,
                  * but we have to keep it for compatibility
                  */
-                len = npg * PAGE_CACHE_SIZE;
+                len = npg * PAGE_SIZE;
 
         } else {
                 test_bulk_req_v1_t *breq = &tsi->tsi_u.bulk_v1;
@@ -104,7 +104,7 @@ brw_client_init(sfw_test_instance_t *tsi)
                 opc = breq->blk_opc;
                 flags = breq->blk_flags;
                 len = breq->blk_len;
-                npg = (len + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
+                npg = (len + PAGE_SIZE - 1) >> PAGE_SHIFT;
         }
 
         if (npg > LNET_MAX_IOV || npg <= 0)
@@ -167,13 +167,13 @@ brw_fill_page(struct page *pg, int pattern, __u64 magic)
 
         if (pattern == LST_BRW_CHECK_SIMPLE) {
                 memcpy(addr, &magic, BRW_MSIZE);
-                addr += PAGE_CACHE_SIZE - BRW_MSIZE;
+                addr += PAGE_SIZE - BRW_MSIZE;
                 memcpy(addr, &magic, BRW_MSIZE);
                 return;
         }
 
         if (pattern == LST_BRW_CHECK_FULL) {
-                for (i = 0; i < PAGE_CACHE_SIZE / BRW_MSIZE; i++)
+                for (i = 0; i < PAGE_SIZE / BRW_MSIZE; i++)
                         memcpy(addr + i * BRW_MSIZE, &magic, BRW_MSIZE);
                 return;
         }
@@ -198,7 +198,7 @@ brw_check_page(struct page *pg, int pattern, __u64 magic)
                 if (data != magic)
                         goto bad_data;
 
-                addr += PAGE_CACHE_SIZE - BRW_MSIZE;
+                addr += PAGE_SIZE - BRW_MSIZE;
                 data = *((__u64 *)addr);
                 if (data != magic)
                         goto bad_data;
@@ -207,7 +207,7 @@ brw_check_page(struct page *pg, int pattern, __u64 magic)
         }
 
         if (pattern == LST_BRW_CHECK_FULL) {
-                for (i = 0; i < PAGE_CACHE_SIZE / BRW_MSIZE; i++) {
+                for (i = 0; i < PAGE_SIZE / BRW_MSIZE; i++) {
                         data = *(((__u64 *)addr) + i);
                         if (data != magic)
                                 goto bad_data;
@@ -278,7 +278,7 @@ brw_client_prep_rpc(sfw_test_unit_t *tsu,
                 opc = breq->blk_opc;
                 flags = breq->blk_flags;
                 npg = breq->blk_npg;
-                len = npg * PAGE_CACHE_SIZE;
+                len = npg * PAGE_SIZE;
 
         } else {
                 test_bulk_req_v1_t *breq = &tsi->tsi_u.bulk_v1;
@@ -292,7 +292,7 @@ brw_client_prep_rpc(sfw_test_unit_t *tsu,
                 opc = breq->blk_opc;
                 flags = breq->blk_flags;
                 len = breq->blk_len;
-                npg = (len + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
+                npg = (len + PAGE_SIZE - 1) >> PAGE_SHIFT;
         }
 
         rc = sfw_create_test_rpc(tsu, dest, sn->sn_features, npg, len, &rpc);
@@ -463,10 +463,10 @@ brw_server_handle(struct srpc_server_rpc *rpc)
                         reply->brw_status = EINVAL;
                         return 0;
                 }
-                npg = reqst->brw_len >> PAGE_CACHE_SHIFT;
+                npg = reqst->brw_len >> PAGE_SHIFT;
 
         } else {
-                npg = (reqst->brw_len + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
+                npg = (reqst->brw_len + PAGE_SIZE - 1) >> PAGE_SHIFT;
         }
 
         replymsg->msg_ses_feats = reqstmsg->msg_ses_feats;
diff --git a/drivers/staging/lustre/lnet/selftest/conctl.c b/drivers/staging/lustre/lnet/selftest/conctl.c
index 5c7cb72eac9a..79ee6c0bf7c1 100644
--- a/drivers/staging/lustre/lnet/selftest/conctl.c
+++ b/drivers/staging/lustre/lnet/selftest/conctl.c
@@ -743,7 +743,7 @@ static int lst_test_add_ioctl(lstio_test_args_t *args)
         if (args->lstio_tes_param &&
             (args->lstio_tes_param_len <= 0 ||
              args->lstio_tes_param_len >
-             PAGE_CACHE_SIZE - sizeof(lstcon_test_t)))
+             PAGE_SIZE - sizeof(lstcon_test_t)))
                 return -EINVAL;
 
         LIBCFS_ALLOC(batch_name, args->lstio_tes_bat_nmlen + 1);
@@ -819,7 +819,7 @@ lstcon_ioctl_entry(unsigned int cmd, struct libcfs_ioctl_hdr *hdr)
 
         opc = data->ioc_u32[0];
 
-        if (data->ioc_plen1 > PAGE_CACHE_SIZE)
+        if (data->ioc_plen1 > PAGE_SIZE)
                 return -EINVAL;
 
         LIBCFS_ALLOC(buf, data->ioc_plen1);
diff --git a/drivers/staging/lustre/lnet/selftest/conrpc.c b/drivers/staging/lustre/lnet/selftest/conrpc.c
index bcd78888f9cc..35a227d0c657 100644
--- a/drivers/staging/lustre/lnet/selftest/conrpc.c
+++ b/drivers/staging/lustre/lnet/selftest/conrpc.c
@@ -786,8 +786,8 @@ lstcon_bulkrpc_v0_prep(lst_test_bulk_param_t *param, srpc_test_reqst_t *req)
         test_bulk_req_t *brq = &req->tsr_u.bulk_v0;
 
         brq->blk_opc = param->blk_opc;
-        brq->blk_npg = (param->blk_size + PAGE_CACHE_SIZE - 1) /
-                        PAGE_CACHE_SIZE;
+        brq->blk_npg = (param->blk_size + PAGE_SIZE - 1) /
+                        PAGE_SIZE;
         brq->blk_flags = param->blk_flags;
 
         return 0;
@@ -822,7 +822,7 @@ lstcon_testrpc_prep(lstcon_node_t *nd, int transop, unsigned feats,
         if (transop == LST_TRANS_TSBCLIADD) {
                 npg = sfw_id_pages(test->tes_span);
                 nob = !(feats & LST_FEAT_BULK_LEN) ?
-                      npg * PAGE_CACHE_SIZE :
+                      npg * PAGE_SIZE :
                       sizeof(lnet_process_id_packed_t) * test->tes_span;
         }
 
@@ -851,8 +851,8 @@ lstcon_testrpc_prep(lstcon_node_t *nd, int transop, unsigned feats,
                         LASSERT(nob > 0);
 
                         len = !(feats & LST_FEAT_BULK_LEN) ?
-                              PAGE_CACHE_SIZE :
-                              min_t(int, nob, PAGE_CACHE_SIZE);
+                              PAGE_SIZE :
+                              min_t(int, nob, PAGE_SIZE);
                         nob -= len;
 
                         bulk->bk_iovs[i].kiov_offset = 0;
diff --git a/drivers/staging/lustre/lnet/selftest/framework.c b/drivers/staging/lustre/lnet/selftest/framework.c
index 926c3970c498..e2c532399366 100644
--- a/drivers/staging/lustre/lnet/selftest/framework.c
+++ b/drivers/staging/lustre/lnet/selftest/framework.c
@@ -1161,7 +1161,7 @@ sfw_add_test(struct srpc_server_rpc *rpc)
                 int len;
 
                 if (!(sn->sn_features & LST_FEAT_BULK_LEN)) {
-                        len = npg * PAGE_CACHE_SIZE;
+                        len = npg * PAGE_SIZE;
 
                 } else {
                         len = sizeof(lnet_process_id_packed_t) *
diff --git a/drivers/staging/lustre/lnet/selftest/rpc.c b/drivers/staging/lustre/lnet/selftest/rpc.c
index 69be7d6f48fa..7d7748d96332 100644
--- a/drivers/staging/lustre/lnet/selftest/rpc.c
+++ b/drivers/staging/lustre/lnet/selftest/rpc.c
@@ -90,7 +90,7 @@ void srpc_set_counters(const srpc_counters_t *cnt)
 static int
 srpc_add_bulk_page(srpc_bulk_t *bk, struct page *pg, int i, int nob)
 {
-        nob = min_t(int, nob, PAGE_CACHE_SIZE);
+        nob = min_t(int, nob, PAGE_SIZE);
 
         LASSERT(nob > 0);
         LASSERT(i >= 0 && i < bk->bk_niov);
diff --git a/drivers/staging/lustre/lnet/selftest/selftest.h b/drivers/staging/lustre/lnet/selftest/selftest.h
index 288522d4d7b9..e689ca1846e1 100644
--- a/drivers/staging/lustre/lnet/selftest/selftest.h
+++ b/drivers/staging/lustre/lnet/selftest/selftest.h
@@ -390,10 +390,10 @@ typedef struct sfw_test_instance {
         } tsi_u;
 } sfw_test_instance_t;
 
-/* XXX: trailing (PAGE_CACHE_SIZE % sizeof(lnet_process_id_t)) bytes at
- * the end of pages are not used */
+/* XXX: trailing (PAGE_SIZE % sizeof(lnet_process_id_t)) bytes at the end of
+ * pages are not used */
 #define SFW_MAX_CONCUR     LST_MAX_CONCUR
-#define SFW_ID_PER_PAGE    (PAGE_CACHE_SIZE / sizeof(lnet_process_id_packed_t))
+#define SFW_ID_PER_PAGE    (PAGE_SIZE / sizeof(lnet_process_id_packed_t))
 #define SFW_MAX_NDESTS     (LNET_MAX_IOV * SFW_ID_PER_PAGE)
 #define sfw_id_pages(n)    (((n) + SFW_ID_PER_PAGE - 1) / SFW_ID_PER_PAGE)
 
diff --git a/drivers/staging/lustre/lustre/include/linux/lustre_patchless_compat.h b/drivers/staging/lustre/lustre/include/linux/lustre_patchless_compat.h
index 33e0b99e1fb4..c6c7f54637fb 100644
--- a/drivers/staging/lustre/lustre/include/linux/lustre_patchless_compat.h
+++ b/drivers/staging/lustre/lustre/include/linux/lustre_patchless_compat.h
@@ -52,7 +52,7 @@ truncate_complete_page(struct address_space *mapping, struct page *page)
                 return;
 
         if (PagePrivate(page))
-                page->mapping->a_ops->invalidatepage(page, 0, PAGE_CACHE_SIZE);
+                page->mapping->a_ops->invalidatepage(page, 0, PAGE_SIZE);
 
         cancel_dirty_page(page);
         ClearPageMappedToDisk(page);
diff --git a/drivers/staging/lustre/lustre/include/lu_object.h b/drivers/staging/lustre/lustre/include/lu_object.h
index b5088b13a305..242bb1ef6245 100644
--- a/drivers/staging/lustre/lustre/include/lu_object.h
+++ b/drivers/staging/lustre/lustre/include/lu_object.h
@@ -1118,7 +1118,7 @@ struct lu_context_key {
         {                                                        \
                 type *value;                                  \
                                                                   \
-                CLASSERT(PAGE_CACHE_SIZE >= sizeof (*value));       \
+                CLASSERT(PAGE_SIZE >= sizeof (*value));       \
                                                                   \
                 value = kzalloc(sizeof(*value), GFP_NOFS);      \
                 if (!value)                             \
diff --git a/drivers/staging/lustre/lustre/include/lustre/lustre_idl.h b/drivers/staging/lustre/lustre/include/lustre/lustre_idl.h
index da8bc6eadd13..5aae1d06a5fa 100644
--- a/drivers/staging/lustre/lustre/include/lustre/lustre_idl.h
+++ b/drivers/staging/lustre/lustre/include/lustre/lustre_idl.h
@@ -1022,16 +1022,16 @@ static inline int lu_dirent_size(struct lu_dirent *ent)
  * MDS_READPAGE page size
  *
  * This is the directory page size packed in MDS_READPAGE RPC.
- * It's different than PAGE_CACHE_SIZE because the client needs to
+ * It's different than PAGE_SIZE because the client needs to
  * access the struct lu_dirpage header packed at the beginning of
  * the "page" and without this there isn't any way to know find the
- * lu_dirpage header is if client and server PAGE_CACHE_SIZE differ.
+ * lu_dirpage header is if client and server PAGE_SIZE differ.
  */
 #define LU_PAGE_SHIFT 12
 #define LU_PAGE_SIZE  (1UL << LU_PAGE_SHIFT)
 #define LU_PAGE_MASK  (~(LU_PAGE_SIZE - 1))
 
-#define LU_PAGE_COUNT (1 << (PAGE_CACHE_SHIFT - LU_PAGE_SHIFT))
+#define LU_PAGE_COUNT (1 << (PAGE_SHIFT - LU_PAGE_SHIFT))
 
 /** @} lu_dir */
 
diff --git a/drivers/staging/lustre/lustre/include/lustre_mdc.h b/drivers/staging/lustre/lustre/include/lustre_mdc.h
index df94f9f3bef2..af77eb359c43 100644
--- a/drivers/staging/lustre/lustre/include/lustre_mdc.h
+++ b/drivers/staging/lustre/lustre/include/lustre_mdc.h
@@ -155,12 +155,12 @@ static inline void mdc_update_max_ea_from_body(struct obd_export *exp,
                 if (cli->cl_max_mds_easize < body->max_mdsize) {
                         cli->cl_max_mds_easize = body->max_mdsize;
                         cli->cl_default_mds_easize =
-                            min_t(__u32, body->max_mdsize, PAGE_CACHE_SIZE);
+                            min_t(__u32, body->max_mdsize, PAGE_SIZE);
                 }
                 if (cli->cl_max_mds_cookiesize < body->max_cookiesize) {
                         cli->cl_max_mds_cookiesize = body->max_cookiesize;
                         cli->cl_default_mds_cookiesize =
-                            min_t(__u32, body->max_cookiesize, PAGE_CACHE_SIZE);
+                            min_t(__u32, body->max_cookiesize, PAGE_SIZE);
                 }
         }
 }
diff --git a/drivers/staging/lustre/lustre/include/lustre_net.h b/drivers/staging/lustre/lustre/include/lustre_net.h
index 4fa1a18b7d15..69586a522eb7 100644
--- a/drivers/staging/lustre/lustre/include/lustre_net.h
+++ b/drivers/staging/lustre/lustre/include/lustre_net.h
@@ -99,21 +99,21 @@
  */
 #define PTLRPC_MAX_BRW_BITS     (LNET_MTU_BITS + PTLRPC_BULK_OPS_BITS)
 #define PTLRPC_MAX_BRW_SIZE     (1 << PTLRPC_MAX_BRW_BITS)
-#define PTLRPC_MAX_BRW_PAGES    (PTLRPC_MAX_BRW_SIZE >> PAGE_CACHE_SHIFT)
+#define PTLRPC_MAX_BRW_PAGES    (PTLRPC_MAX_BRW_SIZE >> PAGE_SHIFT)
 
 #define ONE_MB_BRW_SIZE         (1 << LNET_MTU_BITS)
 #define MD_MAX_BRW_SIZE         (1 << LNET_MTU_BITS)
-#define MD_MAX_BRW_PAGES        (MD_MAX_BRW_SIZE >> PAGE_CACHE_SHIFT)
+#define MD_MAX_BRW_PAGES        (MD_MAX_BRW_SIZE >> PAGE_SHIFT)
 #define DT_MAX_BRW_SIZE         PTLRPC_MAX_BRW_SIZE
-#define DT_MAX_BRW_PAGES        (DT_MAX_BRW_SIZE >> PAGE_CACHE_SHIFT)
+#define DT_MAX_BRW_PAGES        (DT_MAX_BRW_SIZE >> PAGE_SHIFT)
 #define OFD_MAX_BRW_SIZE        (1 << LNET_MTU_BITS)
 
 /* When PAGE_SIZE is a constant, we can check our arithmetic here with cpp! */
 # if ((PTLRPC_MAX_BRW_PAGES & (PTLRPC_MAX_BRW_PAGES - 1)) != 0)
 #  error "PTLRPC_MAX_BRW_PAGES isn't a power of two"
 # endif
-# if (PTLRPC_MAX_BRW_SIZE != (PTLRPC_MAX_BRW_PAGES * PAGE_CACHE_SIZE))
-#  error "PTLRPC_MAX_BRW_SIZE isn't PTLRPC_MAX_BRW_PAGES * PAGE_CACHE_SIZE"
+# if (PTLRPC_MAX_BRW_SIZE != (PTLRPC_MAX_BRW_PAGES * PAGE_SIZE))
+#  error "PTLRPC_MAX_BRW_SIZE isn't PTLRPC_MAX_BRW_PAGES * PAGE_SIZE"
 # endif
 # if (PTLRPC_MAX_BRW_SIZE > LNET_MTU * PTLRPC_BULK_OPS_COUNT)
 #  error "PTLRPC_MAX_BRW_SIZE too big"
diff --git a/drivers/staging/lustre/lustre/include/obd.h b/drivers/staging/lustre/lustre/include/obd.h
index 4a0f2e8b19f6..4264d97650ec 100644
--- a/drivers/staging/lustre/lustre/include/obd.h
+++ b/drivers/staging/lustre/lustre/include/obd.h
@@ -272,7 +272,7 @@ struct client_obd {
         int              cl_grant_shrink_interval; /* seconds */
 
         /* A chunk is an optimal size used by osc_extent to determine
-         * the extent size. A chunk is max(PAGE_CACHE_SIZE, OST block size)
+         * the extent size. A chunk is max(PAGE_SIZE, OST block size)
          */
         int               cl_chunkbits;
         int               cl_chunk;
@@ -1318,7 +1318,7 @@ bad_format:
 
 static inline int cli_brw_size(struct obd_device *obd)
 {
-        return obd->u.cli.cl_max_pages_per_rpc << PAGE_CACHE_SHIFT;
+        return obd->u.cli.cl_max_pages_per_rpc << PAGE_SHIFT;
 }
 
 #endif /* __OBD_H */
diff --git a/drivers/staging/lustre/lustre/include/obd_support.h b/drivers/staging/lustre/lustre/include/obd_support.h
index 225262fa67b6..f8ee3a3254ba 100644
--- a/drivers/staging/lustre/lustre/include/obd_support.h
+++ b/drivers/staging/lustre/lustre/include/obd_support.h
@@ -500,7 +500,7 @@ extern char obd_jobid_var[];
 
 #ifdef POISON_BULK
 #define POISON_PAGE(page, val) do {               \
-        memset(kmap(page), val, PAGE_CACHE_SIZE); \
+        memset(kmap(page), val, PAGE_SIZE); \
         kunmap(page);                             \
 } while (0)
 #else
diff --git a/drivers/staging/lustre/lustre/lclient/lcommon_cl.c b/drivers/staging/lustre/lustre/lclient/lcommon_cl.c
index aced41ab93a1..96141d17d07f 100644
--- a/drivers/staging/lustre/lustre/lclient/lcommon_cl.c
+++ b/drivers/staging/lustre/lustre/lclient/lcommon_cl.c
@@ -758,9 +758,9 @@ int ccc_prep_size(const struct lu_env *env, struct cl_object *obj,
                                  * --bug 17336
                                  */
                                 loff_t size = cl_isize_read(inode);
-                                loff_t cur_index = start >> PAGE_CACHE_SHIFT;
+                                loff_t cur_index = start >> PAGE_SHIFT;
                                 loff_t size_index = (size - 1) >>
-                                                    PAGE_CACHE_SHIFT;
+                                                    PAGE_SHIFT;
 
                                 if ((size == 0 && cur_index != 0) ||
                                     size_index < cur_index)
diff --git a/drivers/staging/lustre/lustre/ldlm/ldlm_lib.c b/drivers/staging/lustre/lustre/ldlm/ldlm_lib.c
index b586d5a88d00..7dd7df59aa1f 100644
--- a/drivers/staging/lustre/lustre/ldlm/ldlm_lib.c
+++ b/drivers/staging/lustre/lustre/ldlm/ldlm_lib.c
@@ -307,8 +307,8 @@ int client_obd_setup(struct obd_device *obddev, struct lustre_cfg *lcfg)
         cli->cl_avail_grant = 0;
         /* FIXME: Should limit this for the sum of all cl_dirty_max. */
         cli->cl_dirty_max = OSC_MAX_DIRTY_DEFAULT * 1024 * 1024;
-        if (cli->cl_dirty_max >> PAGE_CACHE_SHIFT > totalram_pages / 8)
-                cli->cl_dirty_max = totalram_pages << (PAGE_CACHE_SHIFT - 3);
+        if (cli->cl_dirty_max >> PAGE_SHIFT > totalram_pages / 8)
+                cli->cl_dirty_max = totalram_pages << (PAGE_SHIFT - 3);
         INIT_LIST_HEAD(&cli->cl_cache_waiters);
         INIT_LIST_HEAD(&cli->cl_loi_ready_list);
         INIT_LIST_HEAD(&cli->cl_loi_hp_ready_list);
@@ -353,15 +353,15 @@ int client_obd_setup(struct obd_device *obddev, struct lustre_cfg *lcfg)
          * In the future this should likely be increased. LU-1431
          */
         cli->cl_max_pages_per_rpc = min_t(int, PTLRPC_MAX_BRW_PAGES,
-                                          LNET_MTU >> PAGE_CACHE_SHIFT);
+                                          LNET_MTU >> PAGE_SHIFT);
 
         if (!strcmp(name, LUSTRE_MDC_NAME)) {
                 cli->cl_max_rpcs_in_flight = MDC_MAX_RIF_DEFAULT;
-        } else if (totalram_pages >> (20 - PAGE_CACHE_SHIFT) <= 128 /* MB */) {
+        } else if (totalram_pages >> (20 - PAGE_SHIFT) <= 128 /* MB */) {
                 cli->cl_max_rpcs_in_flight = 2;
-        } else if (totalram_pages >> (20 - PAGE_CACHE_SHIFT) <= 256 /* MB */) {
+        } else if (totalram_pages >> (20 - PAGE_SHIFT) <= 256 /* MB */) {
                 cli->cl_max_rpcs_in_flight = 3;
-        } else if (totalram_pages >> (20 - PAGE_CACHE_SHIFT) <= 512 /* MB */) {
+        } else if (totalram_pages >> (20 - PAGE_SHIFT) <= 512 /* MB */) {
                 cli->cl_max_rpcs_in_flight = 4;
         } else {
                 cli->cl_max_rpcs_in_flight = OSC_MAX_RIF_DEFAULT;
diff --git a/drivers/staging/lustre/lustre/ldlm/ldlm_pool.c b/drivers/staging/lustre/lustre/ldlm/ldlm_pool.c
index 3e937b050203..b913ba9cf97c 100644
--- a/drivers/staging/lustre/lustre/ldlm/ldlm_pool.c
+++ b/drivers/staging/lustre/lustre/ldlm/ldlm_pool.c
@@ -107,7 +107,7 @@
 /*
  * 50 ldlm locks for 1MB of RAM.
  */
-#define LDLM_POOL_HOST_L ((NUM_CACHEPAGES >> (20 - PAGE_CACHE_SHIFT)) * 50)
+#define LDLM_POOL_HOST_L ((NUM_CACHEPAGES >> (20 - PAGE_SHIFT)) * 50)
 
 /*
  * Maximal possible grant step plan in %.
diff --git a/drivers/staging/lustre/lustre/ldlm/ldlm_request.c b/drivers/staging/lustre/lustre/ldlm/ldlm_request.c
index c7904a96f9af..74e193e52cd6 100644
--- a/drivers/staging/lustre/lustre/ldlm/ldlm_request.c
+++ b/drivers/staging/lustre/lustre/ldlm/ldlm_request.c
@@ -546,7 +546,7 @@ static inline int ldlm_req_handles_avail(int req_size, int off)
 {
         int avail;
 
-        avail = min_t(int, LDLM_MAXREQSIZE, PAGE_CACHE_SIZE - 512) - req_size;
+        avail = min_t(int, LDLM_MAXREQSIZE, PAGE_SIZE - 512) - req_size;
         if (likely(avail >= 0))
                 avail /= (int)sizeof(struct lustre_handle);
         else
diff --git a/drivers/staging/lustre/lustre/llite/dir.c b/drivers/staging/lustre/lustre/llite/dir.c
index 4e0a3e583330..e4c82883e580 100644
--- a/drivers/staging/lustre/lustre/llite/dir.c
+++ b/drivers/staging/lustre/lustre/llite/dir.c
@@ -134,9 +134,8 @@
  * a header lu_dirpage which describes the start/end hash, and whether this
  * page is empty (contains no dir entry) or hash collide with next page.
  * After client receives reply, several pages will be integrated into dir page
- * in PAGE_CACHE_SIZE (if PAGE_CACHE_SIZE greater than LU_PAGE_SIZE), and the
- * lu_dirpage for this integrated page will be adjusted. See
- * lmv_adjust_dirpages().
+ * in PAGE_SIZE (if PAGE_SIZE greater than LU_PAGE_SIZE), and the lu_dirpage
+ * for this integrated page will be adjusted. See lmv_adjust_dirpages().
  *
  */
 
@@ -153,7 +152,7 @@ static int ll_dir_filler(void *_hash, struct page *page0)
         struct page **page_pool;
         struct page *page;
         struct lu_dirpage *dp;
-        int max_pages = ll_i2sbi(inode)->ll_md_brw_size >> PAGE_CACHE_SHIFT;
+        int max_pages = ll_i2sbi(inode)->ll_md_brw_size >> PAGE_SHIFT;
         int nrdpgs = 0; /* number of pages read actually */
         int npages;
         int i;
@@ -193,8 +192,8 @@ static int ll_dir_filler(void *_hash, struct page *page0)
                 if (body->valid & OBD_MD_FLSIZE)
                         cl_isize_write(inode, body->size);
 
-                nrdpgs = (request->rq_bulk->bd_nob_transferred+PAGE_CACHE_SIZE-1)
-                         >> PAGE_CACHE_SHIFT;
+                nrdpgs = (request->rq_bulk->bd_nob_transferred+PAGE_SIZE-1)
+                         >> PAGE_SHIFT;
                 SetPageUptodate(page0);
         }
         unlock_page(page0);
@@ -209,7 +208,7 @@ static int ll_dir_filler(void *_hash, struct page *page0)
                 page = page_pool[i];
 
                 if (rc < 0 || i >= nrdpgs) {
-                        page_cache_release(page);
+                        put_page(page);
                         continue;
                 }
 
@@ -230,7 +229,7 @@ static int ll_dir_filler(void *_hash, struct page *page0)
                         CDEBUG(D_VFSTRACE, "page %lu add to page cache failed: %d\n",
                                offset, ret);
                 }
-                page_cache_release(page);
+                put_page(page);
         }
 
         if (page_pool != &page0)
@@ -247,7 +246,7 @@ void ll_release_page(struct page *page, int remove)
                         truncate_complete_page(page->mapping, page);
                 unlock_page(page);
         }
-        page_cache_release(page);
+        put_page(page);
 }
 
 /*
@@ -273,7 +272,7 @@ static struct page *ll_dir_page_locate(struct inode *dir, __u64 *hash,
         if (found > 0 && !radix_tree_exceptional_entry(page)) {
                 struct lu_dirpage *dp;
 
-                page_cache_get(page);
+                get_page(page);
                 spin_unlock_irq(&mapping->tree_lock);
                 /*
                  * In contrast to find_lock_page() we are sure that directory
@@ -313,7 +312,7 @@ static struct page *ll_dir_page_locate(struct inode *dir, __u64 *hash,
                                 page = NULL;
                         }
                 } else {
-                        page_cache_release(page);
+                        put_page(page);
                         page = ERR_PTR(-EIO);
                 }
 
@@ -1507,7 +1506,7 @@ skip_lmm:
                         st.st_gid     = body->gid;
                         st.st_rdev    = body->rdev;
                         st.st_size    = body->size;
-                        st.st_blksize = PAGE_CACHE_SIZE;
+                        st.st_blksize = PAGE_SIZE;
                         st.st_blocks  = body->blocks;
                         st.st_atime   = body->atime;
                         st.st_mtime   = body->mtime;
diff --git a/drivers/staging/lustre/lustre/llite/llite_internal.h b/drivers/staging/lustre/lustre/llite/llite_internal.h
index 3e1572cb457b..e3c0f1dd4d31 100644
--- a/drivers/staging/lustre/lustre/llite/llite_internal.h
+++ b/drivers/staging/lustre/lustre/llite/llite_internal.h
@@ -310,10 +310,10 @@ static inline struct ll_inode_info *ll_i2info(struct inode *inode)
 /* default to about 40meg of readahead on a given system.  That much tied
  * up in 512k readahead requests serviced at 40ms each is about 1GB/s.
  */
-#define SBI_DEFAULT_READAHEAD_MAX (40UL << (20 - PAGE_CACHE_SHIFT))
+#define SBI_DEFAULT_READAHEAD_MAX (40UL << (20 - PAGE_SHIFT))
 
 /* default to read-ahead full files smaller than 2MB on the second read */
-#define SBI_DEFAULT_READAHEAD_WHOLE_MAX (2UL << (20 - PAGE_CACHE_SHIFT))
+#define SBI_DEFAULT_READAHEAD_WHOLE_MAX (2UL << (20 - PAGE_SHIFT))
 
 enum ra_stat {
         RA_STAT_HIT = 0,
@@ -975,13 +975,13 @@ struct vm_area_struct *our_vma(struct mm_struct *mm, unsigned long addr,
 static inline void ll_invalidate_page(struct page *vmpage)
 {
         struct address_space *mapping = vmpage->mapping;
-        loff_t offset = vmpage->index << PAGE_CACHE_SHIFT;
+        loff_t offset = vmpage->index << PAGE_SHIFT;
 
         LASSERT(PageLocked(vmpage));
         if (!mapping)
                 return;
 
-        ll_teardown_mmaps(mapping, offset, offset + PAGE_CACHE_SIZE);
+        ll_teardown_mmaps(mapping, offset, offset + PAGE_SIZE);
         truncate_complete_page(mapping, vmpage);
 }
 
diff --git a/drivers/staging/lustre/lustre/llite/llite_lib.c b/drivers/staging/lustre/lustre/llite/llite_lib.c
index 6d6bb33e3655..b57a992688a8 100644
--- a/drivers/staging/lustre/lustre/llite/llite_lib.c
+++ b/drivers/staging/lustre/lustre/llite/llite_lib.c
@@ -85,7 +85,7 @@ static struct ll_sb_info *ll_init_sbi(struct super_block *sb)
 
         si_meminfo(&si);
         pages = si.totalram - si.totalhigh;
-        if (pages >> (20 - PAGE_CACHE_SHIFT) < 512)
+        if (pages >> (20 - PAGE_SHIFT) < 512)
                 lru_page_max = pages / 2;
         else
                 lru_page_max = (pages / 4) * 3;
@@ -272,12 +272,12 @@ static int client_common_fill_super(struct super_block *sb, char *md, char *dt,
             valid != CLIENT_CONNECT_MDT_REQD) {
                 char *buf;
 
-                buf = kzalloc(PAGE_CACHE_SIZE, GFP_KERNEL);
+                buf = kzalloc(PAGE_SIZE, GFP_KERNEL);
                 if (!buf) {
                         err = -ENOMEM;
                         goto out_md_fid;
                 }
-                obd_connect_flags2str(buf, PAGE_CACHE_SIZE,
+                obd_connect_flags2str(buf, PAGE_SIZE,
                                       valid ^ CLIENT_CONNECT_MDT_REQD, ",");
                 LCONSOLE_ERROR_MSG(0x170, "Server %s does not support feature(s) needed for correct operation of this client (%s). Please upgrade server or downgrade client.\n",
                                    sbi->ll_md_exp->exp_obd->obd_name, buf);
@@ -335,7 +335,7 @@ static int client_common_fill_super(struct super_block *sb, char *md, char *dt,
         if (data->ocd_connect_flags & OBD_CONNECT_BRW_SIZE)
                 sbi->ll_md_brw_size = data->ocd_brw_size;
         else
-                sbi->ll_md_brw_size = PAGE_CACHE_SIZE;
+                sbi->ll_md_brw_size = PAGE_SIZE;
 
         if (data->ocd_connect_flags & OBD_CONNECT_LAYOUTLOCK) {
                 LCONSOLE_INFO("Layout lock feature supported.\n");
diff --git a/drivers/staging/lustre/lustre/llite/llite_mmap.c b/drivers/staging/lustre/lustre/llite/llite_mmap.c
index 69445a9f2011..5b484e62ffd0 100644
--- a/drivers/staging/lustre/lustre/llite/llite_mmap.c
+++ b/drivers/staging/lustre/lustre/llite/llite_mmap.c
@@ -58,7 +58,7 @@ void policy_from_vma(ldlm_policy_data_t *policy,
                      size_t count)
 {
         policy->l_extent.start = ((addr - vma->vm_start) & CFS_PAGE_MASK) +
-                                 (vma->vm_pgoff << PAGE_CACHE_SHIFT);
+                                 (vma->vm_pgoff << PAGE_SHIFT);
         policy->l_extent.end = (policy->l_extent.start + count - 1) |
                                ~CFS_PAGE_MASK;
 }
@@ -321,7 +321,7 @@ static int ll_fault0(struct vm_area_struct *vma, struct vm_fault *vmf)
 
                 vmpage = vio->u.fault.ft_vmpage;
                 if (result != 0 && vmpage) {
-                        page_cache_release(vmpage);
+                        put_page(vmpage);
                         vmf->page = NULL;
                 }
         }
@@ -360,7 +360,7 @@ restart:
                 lock_page(vmpage);
                 if (unlikely(!vmpage->mapping)) { /* unlucky */
                         unlock_page(vmpage);
-                        page_cache_release(vmpage);
+                        put_page(vmpage);
                         vmf->page = NULL;
 
                         if (!printed && ++count > 16) {
@@ -457,7 +457,7 @@ int ll_teardown_mmaps(struct address_space *mapping, __u64 first, __u64 last)
         LASSERTF(last > first, "last %llu first %llu\n", last, first);
         if (mapping_mapped(mapping)) {
                 rc = 0;
-                unmap_mapping_range(mapping, first + PAGE_CACHE_SIZE - 1,
+                unmap_mapping_range(mapping, first + PAGE_SIZE - 1,
                                     last - first + 1, 0);
         }
 
diff --git a/drivers/staging/lustre/lustre/llite/lloop.c b/drivers/staging/lustre/lustre/llite/lloop.c
index b725fc16cf49..f169c0db63b4 100644
--- a/drivers/staging/lustre/lustre/llite/lloop.c
+++ b/drivers/staging/lustre/lustre/llite/lloop.c
@@ -218,7 +218,7 @@ static int do_bio_lustrebacked(struct lloop_device *lo, struct bio *head)
                 offset = (pgoff_t)(bio->bi_iter.bi_sector << 9) + lo->lo_offset;
                 bio_for_each_segment(bvec, bio, iter) {
                         BUG_ON(bvec.bv_offset != 0);
-                        BUG_ON(bvec.bv_len != PAGE_CACHE_SIZE);
+                        BUG_ON(bvec.bv_len != PAGE_SIZE);
 
                         pages[page_count] = bvec.bv_page;
                         offsets[page_count] = offset;
@@ -232,7 +232,7 @@ static int do_bio_lustrebacked(struct lloop_device *lo, struct bio *head)
                         (rw == WRITE) ? LPROC_LL_BRW_WRITE : LPROC_LL_BRW_READ,
                         page_count);
 
-        pvec->ldp_size = page_count << PAGE_CACHE_SHIFT;
+        pvec->ldp_size = page_count << PAGE_SHIFT;
         pvec->ldp_nr = page_count;
 
         /* FIXME: in ll_direct_rw_pages, it has to allocate many cl_page{}s to
@@ -507,7 +507,7 @@ static int loop_set_fd(struct lloop_device *lo, struct file *unused,
 
         set_device_ro(bdev, (lo_flags & LO_FLAGS_READ_ONLY) != 0);
 
-        lo->lo_blocksize = PAGE_CACHE_SIZE;
+        lo->lo_blocksize = PAGE_SIZE;
         lo->lo_device = bdev;
         lo->lo_flags = lo_flags;
         lo->lo_backing_file = file;
@@ -525,11 +525,11 @@ static int loop_set_fd(struct lloop_device *lo, struct file *unused,
         lo->lo_queue->queuedata = lo;
 
         /* queue parameters */
-        CLASSERT(PAGE_CACHE_SIZE < (1 << (sizeof(unsigned short) * 8)));
+        CLASSERT(PAGE_SIZE < (1 << (sizeof(unsigned short) * 8)));
         blk_queue_logical_block_size(lo->lo_queue,
-                                     (unsigned short)PAGE_CACHE_SIZE);
+                                     (unsigned short)PAGE_SIZE);
         blk_queue_max_hw_sectors(lo->lo_queue,
-                                 LLOOP_MAX_SEGMENTS << (PAGE_CACHE_SHIFT - 9));
+                                 LLOOP_MAX_SEGMENTS << (PAGE_SHIFT - 9));
         blk_queue_max_segments(lo->lo_queue, LLOOP_MAX_SEGMENTS);
 
         set_capacity(disks[lo->lo_number], size);
diff --git a/drivers/staging/lustre/lustre/llite/lproc_llite.c b/drivers/staging/lustre/lustre/llite/lproc_llite.c
index 45941a6600fe..27ab1261400e 100644
--- a/drivers/staging/lustre/lustre/llite/lproc_llite.c
+++ b/drivers/staging/lustre/lustre/llite/lproc_llite.c
@@ -233,7 +233,7 @@ static ssize_t max_read_ahead_mb_show(struct kobject *kobj,
         pages_number = sbi->ll_ra_info.ra_max_pages;
         spin_unlock(&sbi->ll_lock);
 
-        mult = 1 << (20 - PAGE_CACHE_SHIFT);
+        mult = 1 << (20 - PAGE_SHIFT);
         return lprocfs_read_frac_helper(buf, PAGE_SIZE, pages_number, mult);
 }
 
@@ -251,12 +251,12 @@ static ssize_t max_read_ahead_mb_store(struct kobject *kobj,
         if (rc)
                 return rc;
 
-        pages_number *= 1 << (20 - PAGE_CACHE_SHIFT); /* MB -> pages */
+        pages_number *= 1 << (20 - PAGE_SHIFT); /* MB -> pages */
 
         if (pages_number > totalram_pages / 2) {
 
                 CERROR("can't set file readahead more than %lu MB\n",
-                       totalram_pages >> (20 - PAGE_CACHE_SHIFT + 1)); /*1/2 of RAM*/
+                       totalram_pages >> (20 - PAGE_SHIFT + 1)); /*1/2 of RAM*/
                 return -ERANGE;
         }
 
@@ -281,7 +281,7 @@ static ssize_t max_read_ahead_per_file_mb_show(struct kobject *kobj,
         pages_number = sbi->ll_ra_info.ra_max_pages_per_file;
         spin_unlock(&sbi->ll_lock);
 
-        mult = 1 << (20 - PAGE_CACHE_SHIFT);
+        mult = 1 << (20 - PAGE_SHIFT);
         return lprocfs_read_frac_helper(buf, PAGE_SIZE, pages_number, mult);
 }
 
@@ -326,7 +326,7 @@ static ssize_t max_read_ahead_whole_mb_show(struct kobject *kobj,
         pages_number = sbi->ll_ra_info.ra_max_read_ahead_whole_pages;
         spin_unlock(&sbi->ll_lock);
 
-        mult = 1 << (20 - PAGE_CACHE_SHIFT);
+        mult = 1 << (20 - PAGE_SHIFT);
         return lprocfs_read_frac_helper(buf, PAGE_SIZE, pages_number, mult);
 }
 
@@ -349,7 +349,7 @@ static ssize_t max_read_ahead_whole_mb_store(struct kobject *kobj,
          */
         if (pages_number > sbi->ll_ra_info.ra_max_pages_per_file) {
                 CERROR("can't set max_read_ahead_whole_mb more than max_read_ahead_per_file_mb: %lu\n",
-                       sbi->ll_ra_info.ra_max_pages_per_file >> (20 - PAGE_CACHE_SHIFT));
+                       sbi->ll_ra_info.ra_max_pages_per_file >> (20 - PAGE_SHIFT));
                 return -ERANGE;
         }
 
@@ -366,7 +366,7 @@ static int ll_max_cached_mb_seq_show(struct seq_file *m, void *v)
         struct super_block     *sb    = m->private;
         struct ll_sb_info      *sbi   = ll_s2sbi(sb);
         struct cl_client_cache *cache = &sbi->ll_cache;
-        int shift = 20 - PAGE_CACHE_SHIFT;
+        int shift = 20 - PAGE_SHIFT;
         int max_cached_mb;
         int unused_mb;
 
@@ -405,7 +405,7 @@ static ssize_t ll_max_cached_mb_seq_write(struct file *file,
                 return -EFAULT;
         kernbuf[count] = 0;
 
-        mult = 1 << (20 - PAGE_CACHE_SHIFT);
+        mult = 1 << (20 - PAGE_SHIFT);
         buffer += lprocfs_find_named_value(kernbuf, "max_cached_mb:", &count) -
                   kernbuf;
         rc = lprocfs_write_frac_helper(buffer, count, &pages_number, mult);
@@ -415,7 +415,7 @@ static ssize_t ll_max_cached_mb_seq_write(struct file *file,
         if (pages_number < 0 || pages_number > totalram_pages) {
                 CERROR("%s: can't set max cache more than %lu MB\n",
                        ll_get_fsname(sb, NULL, 0),
-                       totalram_pages >> (20 - PAGE_CACHE_SHIFT));
+                       totalram_pages >> (20 - PAGE_SHIFT));
                 return -ERANGE;
         }
 
diff --git a/drivers/staging/lustre/lustre/llite/rw.c b/drivers/staging/lustre/lustre/llite/rw.c
index 34614acf3f8e..edab6c5b7e50 100644
--- a/drivers/staging/lustre/lustre/llite/rw.c
+++ b/drivers/staging/lustre/lustre/llite/rw.c
@@ -146,10 +146,10 @@ static struct ll_cl_context *ll_cl_init(struct file *file,
                  */
                 io->ci_lockreq = CILR_NEVER;
 
-                pos = vmpage->index << PAGE_CACHE_SHIFT;
+                pos = vmpage->index << PAGE_SHIFT;
 
                 /* Create a temp IO to serve write. */
-                result = cl_io_rw_init(env, io, CIT_WRITE, pos, PAGE_CACHE_SIZE);
+                result = cl_io_rw_init(env, io, CIT_WRITE, pos, PAGE_SIZE);
                 if (result == 0) {
                         cio->cui_fd = LUSTRE_FPRIVATE(file);
                         cio->cui_iter = NULL;
@@ -498,7 +498,7 @@ static int ll_read_ahead_page(const struct lu_env *env, struct cl_io *io,
                 }
                 if (rc != 1)
                         unlock_page(vmpage);
-                page_cache_release(vmpage);
+                put_page(vmpage);
         } else {
                 which = RA_STAT_FAILED_GRAB_PAGE;
                 msg   = "g_c_p_n failed";
@@ -521,13 +521,13 @@ static int ll_read_ahead_page(const struct lu_env *env, struct cl_io *io,
  * striped over, rather than having a constant value for all files here.
  */
 
-/* RAS_INCREASE_STEP should be (1UL << (inode->i_blkbits - PAGE_CACHE_SHIFT)).
+/* RAS_INCREASE_STEP should be (1UL << (inode->i_blkbits - PAGE_SHIFT)).
  * Temporarily set RAS_INCREASE_STEP to 1MB. After 4MB RPC is enabled
  * by default, this should be adjusted corresponding with max_read_ahead_mb
  * and max_read_ahead_per_file_mb otherwise the readahead budget can be used
  * up quickly which will affect read performance significantly. See LU-2816
  */
-#define RAS_INCREASE_STEP(inode) (ONE_MB_BRW_SIZE >> PAGE_CACHE_SHIFT)
+#define RAS_INCREASE_STEP(inode) (ONE_MB_BRW_SIZE >> PAGE_SHIFT)
 
 static inline int stride_io_mode(struct ll_readahead_state *ras)
 {
@@ -739,7 +739,7 @@ int ll_readahead(const struct lu_env *env, struct cl_io *io,
                         end = rpc_boundary;
 
                 /* Truncate RA window to end of file */
-                end = min(end, (unsigned long)((kms - 1) >> PAGE_CACHE_SHIFT));
+                end = min(end, (unsigned long)((kms - 1) >> PAGE_SHIFT));
 
                 ras->ras_next_readahead = max(end, end + 1);
                 RAS_CDEBUG(ras);
@@ -776,7 +776,7 @@ int ll_readahead(const struct lu_env *env, struct cl_io *io,
         if (reserved != 0)
                 ll_ra_count_put(ll_i2sbi(inode), reserved);
 
-        if (ra_end == end + 1 && ra_end == (kms >> PAGE_CACHE_SHIFT))
+        if (ra_end == end + 1 && ra_end == (kms >> PAGE_SHIFT))
                 ll_ra_stats_inc(mapping, RA_STAT_EOF);
 
         /* if we didn't get to the end of the region we reserved from
@@ -985,8 +985,8 @@ void ras_update(struct ll_sb_info *sbi, struct inode *inode,
         if (ras->ras_requests == 2 && !ras->ras_request_index) {
                 __u64 kms_pages;
 
-                kms_pages = (i_size_read(inode) + PAGE_CACHE_SIZE - 1) >>
-                            PAGE_CACHE_SHIFT;
+                kms_pages = (i_size_read(inode) + PAGE_SIZE - 1) >>
+                            PAGE_SHIFT;
 
                 CDEBUG(D_READA, "kmsp %llu mwp %lu mp %lu\n", kms_pages,
                        ra->ra_max_read_ahead_whole_pages, ra->ra_max_pages_per_file);
@@ -1173,7 +1173,7 @@ int ll_writepage(struct page *vmpage, struct writeback_control *wbc)
                  * PageWriteback or clean the page.
                  */
                 result = cl_sync_file_range(inode, offset,
-                                            offset + PAGE_CACHE_SIZE - 1,
+                                            offset + PAGE_SIZE - 1,
                                             CL_FSYNC_LOCAL, 1);
                 if (result > 0) {
                         /* actually we may have written more than one page.
@@ -1211,7 +1211,7 @@ int ll_writepages(struct address_space *mapping, struct writeback_control *wbc)
         int ignore_layout = 0;
 
         if (wbc->range_cyclic) {
-                start = mapping->writeback_index << PAGE_CACHE_SHIFT;
+                start = mapping->writeback_index << PAGE_SHIFT;
                 end = OBD_OBJECT_EOF;
         } else {
                 start = wbc->range_start;
@@ -1241,7 +1241,7 @@ int ll_writepages(struct address_space *mapping, struct writeback_control *wbc)
         if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0)) {
                 if (end == OBD_OBJECT_EOF)
                         end = i_size_read(inode);
-                mapping->writeback_index = (end >> PAGE_CACHE_SHIFT) + 1;
+                mapping->writeback_index = (end >> PAGE_SHIFT) + 1;
         }
         return result;
 }
diff --git a/drivers/staging/lustre/lustre/llite/rw26.c b/drivers/staging/lustre/lustre/llite/rw26.c
index 7a5db67bc680..69aa15e8e3ef 100644
--- a/drivers/staging/lustre/lustre/llite/rw26.c
+++ b/drivers/staging/lustre/lustre/llite/rw26.c
@@ -87,7 +87,7 @@ static void ll_invalidatepage(struct page *vmpage, unsigned int offset,
          * below because they are run with page locked and all our io is
          * happening with locked page too
          */
-        if (offset == 0 && length == PAGE_CACHE_SIZE) {
+        if (offset == 0 && length == PAGE_SIZE) {
                 env = cl_env_get(&refcheck);
                 if (!IS_ERR(env)) {
                         inode = vmpage->mapping->host;
@@ -193,8 +193,8 @@ static inline int ll_get_user_pages(int rw, unsigned long user_addr,
                 return -EFBIG;
         }
 
-        *max_pages = (user_addr + size + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
-        *max_pages -= user_addr >> PAGE_CACHE_SHIFT;
+        *max_pages = (user_addr + size + PAGE_SIZE - 1) >> PAGE_SHIFT;
+        *max_pages -= user_addr >> PAGE_SHIFT;
 
         *pages = libcfs_kvzalloc(*max_pages * sizeof(**pages), GFP_NOFS);
         if (*pages) {
@@ -217,7 +217,7 @@ static void ll_free_user_pages(struct page **pages, int npages, int do_dirty)
         for (i = 0; i < npages; i++) {
                 if (do_dirty)
                         set_page_dirty_lock(pages[i]);
-                page_cache_release(pages[i]);
+                put_page(pages[i]);
         }
         kvfree(pages);
 }
@@ -357,7 +357,7 @@ static ssize_t ll_direct_IO_26_seg(const struct lu_env *env, struct cl_io *io,
  * up to 22MB for 128kB kmalloc and up to 682MB for 4MB kmalloc.
  */
 #define MAX_DIO_SIZE ((KMALLOC_MAX_SIZE / sizeof(struct brw_page) *       \
-                       PAGE_CACHE_SIZE) & ~(DT_MAX_BRW_SIZE - 1))
+                       PAGE_SIZE) & ~(DT_MAX_BRW_SIZE - 1))
 static ssize_t ll_direct_IO_26(struct kiocb *iocb, struct iov_iter *iter,
                                loff_t file_offset)
 {
@@ -382,8 +382,8 @@ static ssize_t ll_direct_IO_26(struct kiocb *iocb, struct iov_iter *iter,
         CDEBUG(D_VFSTRACE,
                "VFS Op:inode=%lu/%u(%p), size=%zd (max %lu), offset=%lld=%llx, pages %zd (max %lu)\n",
                inode->i_ino, inode->i_generation, inode, count, MAX_DIO_SIZE,
-               file_offset, file_offset, count >> PAGE_CACHE_SHIFT,
-               MAX_DIO_SIZE >> PAGE_CACHE_SHIFT);
+               file_offset, file_offset, count >> PAGE_SHIFT,
+               MAX_DIO_SIZE >> PAGE_SHIFT);
 
         /* Check that all user buffers are aligned as well */
         if (iov_iter_alignment(iter) & ~CFS_PAGE_MASK)
@@ -432,8 +432,8 @@ static ssize_t ll_direct_IO_26(struct kiocb *iocb, struct iov_iter *iter,
                          * page worth of page pointers = 4MB on i386.
                          */
                         if (result == -ENOMEM &&
-                            size > (PAGE_CACHE_SIZE / sizeof(*pages)) *
-                                   PAGE_CACHE_SIZE) {
+                            size > (PAGE_SIZE / sizeof(*pages)) *
+                            PAGE_SIZE) {
                                 size = ((((size / 2) - 1) |
                                          ~CFS_PAGE_MASK) + 1) &
                                         CFS_PAGE_MASK;
@@ -474,10 +474,10 @@ static int ll_write_begin(struct file *file, struct address_space *mapping,
                           loff_t pos, unsigned len, unsigned flags,
                           struct page **pagep, void **fsdata)
 {
-        pgoff_t index = pos >> PAGE_CACHE_SHIFT;
+        pgoff_t index = pos >> PAGE_SHIFT;
         struct page *page;
         int rc;
-        unsigned from = pos & (PAGE_CACHE_SIZE - 1);
+        unsigned from = pos & (PAGE_SIZE - 1);
 
         page = grab_cache_page_write_begin(mapping, index, flags);
         if (!page)
@@ -488,7 +488,7 @@ static int ll_write_begin(struct file *file, struct address_space *mapping,
         rc = ll_prepare_write(file, page, from, from + len);
         if (rc) {
                 unlock_page(page);
-                page_cache_release(page);
+                put_page(page);
         }
         return rc;
 }
@@ -497,12 +497,12 @@ static int ll_write_end(struct file *file, struct address_space *mapping,
                         loff_t pos, unsigned len, unsigned copied,
                         struct page *page, void *fsdata)
 {
-        unsigned from = pos & (PAGE_CACHE_SIZE - 1);
+        unsigned from = pos & (PAGE_SIZE - 1);
         int rc;
 
         rc = ll_commit_write(file, page, from, from + copied);
         unlock_page(page);
-        page_cache_release(page);
+        put_page(page);
 
         return rc ?: copied;
 }
diff --git a/drivers/staging/lustre/lustre/llite/vvp_io.c b/drivers/staging/lustre/lustre/llite/vvp_io.c
index fb0c26ee7ff3..85a835976174 100644
--- a/drivers/staging/lustre/lustre/llite/vvp_io.c
+++ b/drivers/staging/lustre/lustre/llite/vvp_io.c
@@ -512,9 +512,9 @@ static int vvp_io_read_start(const struct lu_env *env,
                 vio->cui_ra_window_set = 1;
                 bead->lrr_start = cl_index(obj, pos);
                 /*
-                 * XXX: explicit PAGE_CACHE_SIZE
+                 * XXX: explicit PAGE_SIZE
                  */
-                bead->lrr_count = cl_index(obj, tot + PAGE_CACHE_SIZE - 1);
+                bead->lrr_count = cl_index(obj, tot + PAGE_SIZE - 1);
                 ll_ra_read_in(file, bead);
         }
 
@@ -959,7 +959,7 @@ static int vvp_io_prepare_write(const struct lu_env *env,
                  * We're completely overwriting an existing page, so _don't_
                  * set it up to date until commit_write
                  */
-                if (from == 0 && to == PAGE_CACHE_SIZE) {
+                if (from == 0 && to == PAGE_SIZE) {
                         CL_PAGE_HEADER(D_PAGE, env, pg, "full page write\n");
                         POISON_PAGE(page, 0x11);
                 } else
@@ -1022,7 +1022,7 @@ static int vvp_io_commit_write(const struct lu_env *env,
                         set_page_dirty(vmpage);
                         vvp_write_pending(cl2ccc(obj), cp);
                 } else if (result == -EDQUOT) {
-                        pgoff_t last_index = i_size_read(inode) >> PAGE_CACHE_SHIFT;
+                        pgoff_t last_index = i_size_read(inode) >> PAGE_SHIFT;
                         bool need_clip = true;
 
                         /*
@@ -1040,7 +1040,7 @@ static int vvp_io_commit_write(const struct lu_env *env,
                          * being.
                          */
                         if (last_index > pg->cp_index) {
-                                to = PAGE_CACHE_SIZE;
+                                to = PAGE_SIZE;
                                 need_clip = false;
                         } else if (last_index == pg->cp_index) {
                                 int size_to = i_size_read(inode) & ~CFS_PAGE_MASK;
diff --git a/drivers/staging/lustre/lustre/llite/vvp_page.c b/drivers/staging/lustre/lustre/llite/vvp_page.c
index 850bae734075..33ca3eb34965 100644
--- a/drivers/staging/lustre/lustre/llite/vvp_page.c
+++ b/drivers/staging/lustre/lustre/llite/vvp_page.c
@@ -57,7 +57,7 @@ static void vvp_page_fini_common(struct ccc_page *cp)
         struct page *vmpage = cp->cpg_page;
 
         LASSERT(vmpage);
-        page_cache_release(vmpage);
+        put_page(vmpage);
 }
 
 static void vvp_page_fini(const struct lu_env *env,
@@ -164,12 +164,12 @@ static int vvp_page_unmap(const struct lu_env *env,
         LASSERT(vmpage);
         LASSERT(PageLocked(vmpage));
 
-        offset = vmpage->index << PAGE_CACHE_SHIFT;
+        offset = vmpage->index << PAGE_SHIFT;
 
         /*
          * XXX is it safe to call this with the page lock held?
          */
-        ll_teardown_mmaps(vmpage->mapping, offset, offset + PAGE_CACHE_SIZE);
+        ll_teardown_mmaps(vmpage->mapping, offset, offset + PAGE_SIZE);
         return 0;
 }
 
@@ -537,7 +537,7 @@ int vvp_page_init(const struct lu_env *env, struct cl_object *obj,
         CLOBINVRNT(env, obj, ccc_object_invariant(obj));
 
         cpg->cpg_page = vmpage;
-        page_cache_get(vmpage);
+        get_page(vmpage);
 
         INIT_LIST_HEAD(&cpg->cpg_pending_linkage);
         if (page->cp_type == CPT_CACHEABLE) {
diff --git a/drivers/staging/lustre/lustre/lmv/lmv_obd.c b/drivers/staging/lustre/lustre/lmv/lmv_obd.c
index 0f776cf8a5aa..9abb7c2b9231 100644
--- a/drivers/staging/lustre/lustre/lmv/lmv_obd.c
+++ b/drivers/staging/lustre/lustre/lmv/lmv_obd.c
@@ -2017,7 +2017,7 @@ static int lmv_sync(struct obd_export *exp, const struct lu_fid *fid,
  * |s|e|f|p|ent| 0 | ... | 0 |
  * '-----------------   -----'
  *
- * However, on hosts where the native VM page size (PAGE_CACHE_SIZE) is
+ * However, on hosts where the native VM page size (PAGE_SIZE) is
  * larger than LU_PAGE_SIZE, a single host page may contain multiple
  * lu_dirpages. After reading the lu_dirpages from the MDS, the
  * ldp_hash_end of the first lu_dirpage refers to the one immediately
@@ -2048,7 +2048,7 @@ static int lmv_sync(struct obd_export *exp, const struct lu_fid *fid,
  * - Adjust the lde_reclen of the ending entry of each lu_dirpage to span
  *   to the first entry of the next lu_dirpage.
  */
-#if PAGE_CACHE_SIZE > LU_PAGE_SIZE
+#if PAGE_SIZE > LU_PAGE_SIZE
 static void lmv_adjust_dirpages(struct page **pages, int ncfspgs, int nlupgs)
 {
         int i;
@@ -2101,7 +2101,7 @@ static void lmv_adjust_dirpages(struct page **pages, int ncfspgs, int nlupgs)
 }
 #else
 #define lmv_adjust_dirpages(pages, ncfspgs, nlupgs) do {} while (0)
-#endif  /* PAGE_CACHE_SIZE > LU_PAGE_SIZE */
+#endif  /* PAGE_SIZE > LU_PAGE_SIZE */
 
 static int lmv_readpage(struct obd_export *exp, struct md_op_data *op_data,
                         struct page **pages, struct ptlrpc_request **request)
@@ -2110,7 +2110,7 @@ static int lmv_readpage(struct obd_export *exp, struct md_op_data *op_data,
         struct lmv_obd          *lmv = &obd->u.lmv;
         __u64                   offset = op_data->op_offset;
         int                     rc;
-        int                     ncfspgs; /* pages read in PAGE_CACHE_SIZE */
+        int                     ncfspgs; /* pages read in PAGE_SIZE */
         int                     nlupgs; /* pages read in LU_PAGE_SIZE */
         struct lmv_tgt_desc     *tgt;
 
@@ -2129,8 +2129,8 @@ static int lmv_readpage(struct obd_export *exp, struct md_op_data *op_data,
         if (rc != 0)
                 return rc;
 
-        ncfspgs = ((*request)->rq_bulk->bd_nob_transferred + PAGE_CACHE_SIZE - 1)
-                 >> PAGE_CACHE_SHIFT;
+        ncfspgs = ((*request)->rq_bulk->bd_nob_transferred + PAGE_SIZE - 1)
+                 >> PAGE_SHIFT;
         nlupgs = (*request)->rq_bulk->bd_nob_transferred >> LU_PAGE_SHIFT;
         LASSERT(!((*request)->rq_bulk->bd_nob_transferred & ~LU_PAGE_MASK));
         LASSERT(ncfspgs > 0 && ncfspgs <= op_data->op_npages);
diff --git a/drivers/staging/lustre/lustre/mdc/mdc_request.c b/drivers/staging/lustre/lustre/mdc/mdc_request.c
index 55dd8ef9525b..b91d3ff18b02 100644
--- a/drivers/staging/lustre/lustre/mdc/mdc_request.c
+++ b/drivers/staging/lustre/lustre/mdc/mdc_request.c
@@ -1002,10 +1002,10 @@ restart_bulk:
 
         /* NB req now owns desc and will free it when it gets freed */
         for (i = 0; i < op_data->op_npages; i++)
-                ptlrpc_prep_bulk_page_pin(desc, pages[i], 0, PAGE_CACHE_SIZE);
+                ptlrpc_prep_bulk_page_pin(desc, pages[i], 0, PAGE_SIZE);
 
         mdc_readdir_pack(req, op_data->op_offset,
-                         PAGE_CACHE_SIZE * op_data->op_npages,
+                         PAGE_SIZE * op_data->op_npages,
                          &op_data->op_fid1);
 
         ptlrpc_request_set_replen(req);
@@ -1037,7 +1037,7 @@ restart_bulk:
         if (req->rq_bulk->bd_nob_transferred & ~LU_PAGE_MASK) {
                 CERROR("Unexpected # bytes transferred: %d (%ld expected)\n",
                        req->rq_bulk->bd_nob_transferred,
-                       PAGE_CACHE_SIZE * op_data->op_npages);
+                       PAGE_SIZE * op_data->op_npages);
                 ptlrpc_req_finished(req);
                 return -EPROTO;
         }
diff --git a/drivers/staging/lustre/lustre/mgc/mgc_request.c b/drivers/staging/lustre/lustre/mgc/mgc_request.c
index b7dc87248032..3924b095bfb0 100644
--- a/drivers/staging/lustre/lustre/mgc/mgc_request.c
+++ b/drivers/staging/lustre/lustre/mgc/mgc_request.c
@@ -1113,7 +1113,7 @@ static int mgc_import_event(struct obd_device *obd,
 }
 
 enum {
-        CONFIG_READ_NRPAGES_INIT = 1 << (20 - PAGE_CACHE_SHIFT),
+        CONFIG_READ_NRPAGES_INIT = 1 << (20 - PAGE_SHIFT),
         CONFIG_READ_NRPAGES      = 4
 };
 
@@ -1137,19 +1137,19 @@ static int mgc_apply_recover_logs(struct obd_device *mgc,
         LASSERT(cfg->cfg_instance);
         LASSERT(cfg->cfg_sb == cfg->cfg_instance);
 
-        inst = kzalloc(PAGE_CACHE_SIZE, GFP_KERNEL);
+        inst = kzalloc(PAGE_SIZE, GFP_KERNEL);
         if (!inst)
                 return -ENOMEM;
 
-        pos = snprintf(inst, PAGE_CACHE_SIZE, "%p", cfg->cfg_instance);
-        if (pos >= PAGE_CACHE_SIZE) {
+        pos = snprintf(inst, PAGE_SIZE, "%p", cfg->cfg_instance);
+        if (pos >= PAGE_SIZE) {
                 kfree(inst);
                 return -E2BIG;
         }
 
         ++pos;
         buf   = inst + pos;
-        bufsz = PAGE_CACHE_SIZE - pos;
+        bufsz = PAGE_SIZE - pos;
 
         while (datalen > 0) {
                 int   entry_len = sizeof(*entry);
@@ -1181,7 +1181,7 @@ static int mgc_apply_recover_logs(struct obd_device *mgc,
                 /* Keep this swab for normal mixed endian handling. LU-1644 */
                 if (mne_swab)
                         lustre_swab_mgs_nidtbl_entry(entry);
-                if (entry->mne_length > PAGE_CACHE_SIZE) {
+                if (entry->mne_length > PAGE_SIZE) {
                         CERROR("MNE too large (%u)\n", entry->mne_length);
                         break;
                 }
@@ -1371,7 +1371,7 @@ again:
         }
         body->mcb_offset = cfg->cfg_last_idx + 1;
         body->mcb_type   = cld->cld_type;
-        body->mcb_bits   = PAGE_CACHE_SHIFT;
+        body->mcb_bits   = PAGE_SHIFT;
         body->mcb_units  = nrpages;
 
         /* allocate bulk transfer descriptor */
@@ -1383,7 +1383,7 @@ again:
         }
 
         for (i = 0; i < nrpages; i++)
-                ptlrpc_prep_bulk_page_pin(desc, pages[i], 0, PAGE_CACHE_SIZE);
+                ptlrpc_prep_bulk_page_pin(desc, pages[i], 0, PAGE_SIZE);
 
         ptlrpc_request_set_replen(req);
         rc = ptlrpc_queue_wait(req);
@@ -1411,7 +1411,7 @@ again:
                 goto out;
         }
 
-        if (ealen > nrpages << PAGE_CACHE_SHIFT) {
+        if (ealen > nrpages << PAGE_SHIFT) {
                 rc = -EINVAL;
                 goto out;
         }
@@ -1439,7 +1439,7 @@ again:
 
                 ptr = kmap(pages[i]);
                 rc2 = mgc_apply_recover_logs(obd, cld, res->mcr_offset, ptr,
-                                             min_t(int, ealen, PAGE_CACHE_SIZE),
+                                             min_t(int, ealen, PAGE_SIZE),
                                              mne_swab);
                 kunmap(pages[i]);
                 if (rc2 < 0) {
@@ -1448,7 +1448,7 @@ again:
                         break;
                 }
 
-                ealen -= PAGE_CACHE_SIZE;
+                ealen -= PAGE_SIZE;
         }
 
 out:
diff --git a/drivers/staging/lustre/lustre/obdclass/cl_page.c b/drivers/staging/lustre/lustre/obdclass/cl_page.c
index 231a2f26c693..394580016638 100644
--- a/drivers/staging/lustre/lustre/obdclass/cl_page.c
+++ b/drivers/staging/lustre/lustre/obdclass/cl_page.c
@@ -1477,7 +1477,7 @@ loff_t cl_offset(const struct cl_object *obj, pgoff_t idx)
         /*
          * XXX for now.
          */
-        return (loff_t)idx << PAGE_CACHE_SHIFT;
+        return (loff_t)idx << PAGE_SHIFT;
 }
 EXPORT_SYMBOL(cl_offset);
 
@@ -1489,13 +1489,13 @@ pgoff_t cl_index(const struct cl_object *obj, loff_t offset)
         /*
          * XXX for now.
          */
-        return offset >> PAGE_CACHE_SHIFT;
+        return offset >> PAGE_SHIFT;
 }
 EXPORT_SYMBOL(cl_index);
 
 int cl_page_size(const struct cl_object *obj)
 {
-        return 1 << PAGE_CACHE_SHIFT;
+        return 1 << PAGE_SHIFT;
 }
 EXPORT_SYMBOL(cl_page_size);
 
diff --git a/drivers/staging/lustre/lustre/obdclass/class_obd.c b/drivers/staging/lustre/lustre/obdclass/class_obd.c
index 1a938e1376f9..c2cf015962dd 100644
--- a/drivers/staging/lustre/lustre/obdclass/class_obd.c
+++ b/drivers/staging/lustre/lustre/obdclass/class_obd.c
@@ -461,9 +461,9 @@ static int obd_init_checks(void)
                 CWARN("LPD64 wrong length! strlen(%s)=%d != 2\n", buf, len);
                 ret = -EINVAL;
         }
-        if ((u64val & ~CFS_PAGE_MASK) >= PAGE_CACHE_SIZE) {
+        if ((u64val & ~CFS_PAGE_MASK) >= PAGE_SIZE) {
                 CWARN("mask failed: u64val %llu >= %llu\n", u64val,
-                      (__u64)PAGE_CACHE_SIZE);
+                      (__u64)PAGE_SIZE);
                 ret = -EINVAL;
         }
 
@@ -509,7 +509,7 @@ static int __init obdclass_init(void)
          * For clients with less memory, a larger fraction is needed
          * for other purposes (mostly for BGL).
          */
-        if (totalram_pages <= 512 << (20 - PAGE_CACHE_SHIFT))
+        if (totalram_pages <= 512 << (20 - PAGE_SHIFT))
                 obd_max_dirty_pages = totalram_pages / 4;
         else
                 obd_max_dirty_pages = totalram_pages / 2;
diff --git a/drivers/staging/lustre/lustre/obdclass/linux/linux-obdo.c b/drivers/staging/lustre/lustre/obdclass/linux/linux-obdo.c
index 9496c09b2b69..b41b65e2f021 100644
--- a/drivers/staging/lustre/lustre/obdclass/linux/linux-obdo.c
+++ b/drivers/staging/lustre/lustre/obdclass/linux/linux-obdo.c
@@ -47,7 +47,6 @@
 #include "../../include/lustre/lustre_idl.h"
 
 #include <linux/fs.h>
-#include <linux/pagemap.h> /* for PAGE_CACHE_SIZE */
 
 void obdo_refresh_inode(struct inode *dst, struct obdo *src, u32 valid)
 {
@@ -71,8 +70,8 @@ void obdo_refresh_inode(struct inode *dst, struct obdo *src, u32 valid)
         if (valid & OBD_MD_FLBLKSZ && src->o_blksize > (1 << dst->i_blkbits))
                 dst->i_blkbits = ffs(src->o_blksize) - 1;
 
-        if (dst->i_blkbits < PAGE_CACHE_SHIFT)
-                dst->i_blkbits = PAGE_CACHE_SHIFT;
+        if (dst->i_blkbits < PAGE_SHIFT)
+                dst->i_blkbits = PAGE_SHIFT;
 
         /* allocation of space */
         if (valid & OBD_MD_FLBLOCKS && src->o_blocks > dst->i_blocks)
diff --git a/drivers/staging/lustre/lustre/obdclass/linux/linux-sysctl.c b/drivers/staging/lustre/lustre/obdclass/linux/linux-sysctl.c
index fd333b9e968c..e6bf414a4444 100644
--- a/drivers/staging/lustre/lustre/obdclass/linux/linux-sysctl.c
+++ b/drivers/staging/lustre/lustre/obdclass/linux/linux-sysctl.c
@@ -100,7 +100,7 @@ static ssize_t max_dirty_mb_show(struct kobject *kobj, struct attribute *attr,
                                  char *buf)
 {
         return sprintf(buf, "%ul\n",
-                        obd_max_dirty_pages / (1 << (20 - PAGE_CACHE_SHIFT)));
+                        obd_max_dirty_pages / (1 << (20 - PAGE_SHIFT)));
 }
 
 static ssize_t max_dirty_mb_store(struct kobject *kobj, struct attribute *attr,
@@ -113,14 +113,14 @@ static ssize_t max_dirty_mb_store(struct kobject *kobj, struct attribute *attr,
         if (rc)
                 return rc;
 
-        val *= 1 << (20 - PAGE_CACHE_SHIFT); /* convert to pages */
+        val *= 1 << (20 - PAGE_SHIFT); /* convert to pages */
 
         if (val > ((totalram_pages / 10) * 9)) {
                 /* Somebody wants to assign too much memory to dirty pages */
                 return -EINVAL;
         }
 
-        if (val < 4 << (20 - PAGE_CACHE_SHIFT)) {
+        if (val < 4 << (20 - PAGE_SHIFT)) {
                 /* Less than 4 Mb for dirty cache is also bad */
                 return -EINVAL;
         }
diff --git a/drivers/staging/lustre/lustre/obdclass/lu_object.c b/drivers/staging/lustre/lustre/obdclass/lu_object.c
index 65a4746c89ca..978568ada8e9 100644
--- a/drivers/staging/lustre/lustre/obdclass/lu_object.c
+++ b/drivers/staging/lustre/lustre/obdclass/lu_object.c
@@ -840,8 +840,8 @@ static int lu_htable_order(void)
 
 #if BITS_PER_LONG == 32
         /* limit hashtable size for lowmem systems to low RAM */
-        if (cache_size > 1 << (30 - PAGE_CACHE_SHIFT))
-                cache_size = 1 << (30 - PAGE_CACHE_SHIFT) * 3 / 4;
+        if (cache_size > 1 << (30 - PAGE_SHIFT))
+                cache_size = 1 << (30 - PAGE_SHIFT) * 3 / 4;
 #endif
 
         /* clear off unreasonable cache setting. */
@@ -853,7 +853,7 @@ static int lu_htable_order(void)
                 lu_cache_percent = LU_CACHE_PERCENT_DEFAULT;
         }
         cache_size = cache_size / 100 * lu_cache_percent *
-                (PAGE_CACHE_SIZE / 1024);
+                (PAGE_SIZE / 1024);
 
         for (bits = 1; (1 << bits) < cache_size; ++bits) {
                 ;
diff --git a/drivers/staging/lustre/lustre/obdecho/echo_client.c b/drivers/staging/lustre/lustre/obdecho/echo_client.c
index 64ffe243f870..1e83669c204d 100644
--- a/drivers/staging/lustre/lustre/obdecho/echo_client.c
+++ b/drivers/staging/lustre/lustre/obdecho/echo_client.c
@@ -278,7 +278,7 @@ static void echo_page_fini(const struct lu_env *env,
         struct page *vmpage      = ep->ep_vmpage;
 
         atomic_dec(&eco->eo_npages);
-        page_cache_release(vmpage);
+        put_page(vmpage);
 }
 
 static int echo_page_prep(const struct lu_env *env,
@@ -373,7 +373,7 @@ static int echo_page_init(const struct lu_env *env, struct cl_object *obj,
         struct echo_object *eco = cl2echo_obj(obj);
 
         ep->ep_vmpage = vmpage;
-        page_cache_get(vmpage);
+        get_page(vmpage);
         mutex_init(&ep->ep_lock);
         cl_page_slice_add(page, &ep->ep_cl, obj, &echo_page_ops);
         atomic_inc(&eco->eo_npages);
@@ -1138,7 +1138,7 @@ static int cl_echo_object_brw(struct echo_object *eco, int rw, u64 offset,
         LASSERT(rc == 0);
 
         rc = cl_echo_enqueue0(env, eco, offset,
-                              offset + npages * PAGE_CACHE_SIZE - 1,
+                              offset + npages * PAGE_SIZE - 1,
                               rw == READ ? LCK_PR : LCK_PW, &lh.cookie,
                               CEF_NEVER);
         if (rc < 0)
@@ -1311,11 +1311,11 @@ echo_client_page_debug_setup(struct page *page, int rw, u64 id,
         int      delta;
 
         /* no partial pages on the client */
-        LASSERT(count == PAGE_CACHE_SIZE);
+        LASSERT(count == PAGE_SIZE);
 
         addr = kmap(page);
 
-        for (delta = 0; delta < PAGE_CACHE_SIZE; delta += OBD_ECHO_BLOCK_SIZE) {
+        for (delta = 0; delta < PAGE_SIZE; delta += OBD_ECHO_BLOCK_SIZE) {
                 if (rw == OBD_BRW_WRITE) {
                         stripe_off = offset + delta;
                         stripe_id = id;
@@ -1341,11 +1341,11 @@ static int echo_client_page_debug_check(struct page *page, u64 id,
         int     rc2;
 
         /* no partial pages on the client */
-        LASSERT(count == PAGE_CACHE_SIZE);
+        LASSERT(count == PAGE_SIZE);
 
         addr = kmap(page);
 
-        for (rc = delta = 0; delta < PAGE_CACHE_SIZE; delta += OBD_ECHO_BLOCK_SIZE) {
+        for (rc = delta = 0; delta < PAGE_SIZE; delta += OBD_ECHO_BLOCK_SIZE) {
                 stripe_off = offset + delta;
                 stripe_id = id;
 
@@ -1391,7 +1391,7 @@ static int echo_client_kbrw(struct echo_device *ed, int rw, struct obdo *oa,
                 return -EINVAL;
 
         /* XXX think again with misaligned I/O */
-        npages = count >> PAGE_CACHE_SHIFT;
+        npages = count >> PAGE_SHIFT;
 
         if (rw == OBD_BRW_WRITE)
                 brw_flags = OBD_BRW_ASYNC;
@@ -1408,7 +1408,7 @@ static int echo_client_kbrw(struct echo_device *ed, int rw, struct obdo *oa,
 
         for (i = 0, pgp = pga, off = offset;
              i < npages;
-             i++, pgp++, off += PAGE_CACHE_SIZE) {
+             i++, pgp++, off += PAGE_SIZE) {
 
                 LASSERT(!pgp->pg);      /* for cleanup */
 
@@ -1418,7 +1418,7 @@ static int echo_client_kbrw(struct echo_device *ed, int rw, struct obdo *oa,
                         goto out;
 
                 pages[i] = pgp->pg;
-                pgp->count = PAGE_CACHE_SIZE;
+                pgp->count = PAGE_SIZE;
                 pgp->off = off;
                 pgp->flag = brw_flags;
 
@@ -1473,8 +1473,8 @@ static int echo_client_prep_commit(const struct lu_env *env,
         if (count <= 0 || (count & (~CFS_PAGE_MASK)) != 0)
                 return -EINVAL;
 
-        npages = batch >> PAGE_CACHE_SHIFT;
-        tot_pages = count >> PAGE_CACHE_SHIFT;
+        npages = batch >> PAGE_SHIFT;
+        tot_pages = count >> PAGE_SHIFT;
 
         lnb = kcalloc(npages, sizeof(struct niobuf_local), GFP_NOFS);
         rnb = kcalloc(npages, sizeof(struct niobuf_remote), GFP_NOFS);
@@ -1497,9 +1497,9 @@ static int echo_client_prep_commit(const struct lu_env *env,
                 if (tot_pages < npages)
                         npages = tot_pages;
 
-                for (i = 0; i < npages; i++, off += PAGE_CACHE_SIZE) {
+                for (i = 0; i < npages; i++, off += PAGE_SIZE) {
                         rnb[i].offset = off;
-                        rnb[i].len = PAGE_CACHE_SIZE;
+                        rnb[i].len = PAGE_SIZE;
                         rnb[i].flags = brw_flags;
                 }
 
@@ -1878,7 +1878,7 @@ static int __init obdecho_init(void)
 {
         LCONSOLE_INFO("Echo OBD driver; http://www.lustre.org/\n");
 
-        LASSERT(PAGE_CACHE_SIZE % OBD_ECHO_BLOCK_SIZE == 0);
+        LASSERT(PAGE_SIZE % OBD_ECHO_BLOCK_SIZE == 0);
 
         return echo_client_init();
 }
diff --git a/drivers/staging/lustre/lustre/osc/lproc_osc.c b/drivers/staging/lustre/lustre/osc/lproc_osc.c
index 57c43c506ef2..a3358c39b2f1 100644
--- a/drivers/staging/lustre/lustre/osc/lproc_osc.c
+++ b/drivers/staging/lustre/lustre/osc/lproc_osc.c
@@ -162,15 +162,15 @@ static ssize_t max_dirty_mb_store(struct kobject *kobj,
         if (rc)
                 return rc;
 
-        pages_number *= 1 << (20 - PAGE_CACHE_SHIFT); /* MB -> pages */
+        pages_number *= 1 << (20 - PAGE_SHIFT); /* MB -> pages */
 
         if (pages_number <= 0 ||
-            pages_number > OSC_MAX_DIRTY_MB_MAX << (20 - PAGE_CACHE_SHIFT) ||
+            pages_number > OSC_MAX_DIRTY_MB_MAX << (20 - PAGE_SHIFT) ||
             pages_number > totalram_pages / 4) /* 1/4 of RAM */
                 return -ERANGE;
 
         client_obd_list_lock(&cli->cl_loi_list_lock);
-        cli->cl_dirty_max = (u32)(pages_number << PAGE_CACHE_SHIFT);
+        cli->cl_dirty_max = (u32)(pages_number << PAGE_SHIFT);
         osc_wake_cache_waiters(cli);
         client_obd_list_unlock(&cli->cl_loi_list_lock);
 
@@ -182,7 +182,7 @@ static int osc_cached_mb_seq_show(struct seq_file *m, void *v)
 {
         struct obd_device *dev = m->private;
         struct client_obd *cli = &dev->u.cli;
-        int shift = 20 - PAGE_CACHE_SHIFT;
+        int shift = 20 - PAGE_SHIFT;
 
         seq_printf(m,
                    "used_mb: %d\n"
@@ -211,7 +211,7 @@ static ssize_t osc_cached_mb_seq_write(struct file *file,
                 return -EFAULT;
         kernbuf[count] = 0;
 
-        mult = 1 << (20 - PAGE_CACHE_SHIFT);
+        mult = 1 << (20 - PAGE_SHIFT);
         buffer += lprocfs_find_named_value(kernbuf, "used_mb:", &count) -
                   kernbuf;
         rc = lprocfs_write_frac_helper(buffer, count, &pages_number, mult);
@@ -569,12 +569,12 @@ static ssize_t max_pages_per_rpc_store(struct kobject *kobj,
 
         /* if the max_pages is specified in bytes, convert to pages */
         if (val >= ONE_MB_BRW_SIZE)
-                val >>= PAGE_CACHE_SHIFT;
+                val >>= PAGE_SHIFT;
 
-        chunk_mask = ~((1 << (cli->cl_chunkbits - PAGE_CACHE_SHIFT)) - 1);
+        chunk_mask = ~((1 << (cli->cl_chunkbits - PAGE_SHIFT)) - 1);
         /* max_pages_per_rpc must be chunk aligned */
         val = (val + ~chunk_mask) & chunk_mask;
-        if (val == 0 || val > ocd->ocd_brw_size >> PAGE_CACHE_SHIFT) {
+        if (val == 0 || val > ocd->ocd_brw_size >> PAGE_SHIFT) {
                 return -ERANGE;
         }
         client_obd_list_lock(&cli->cl_loi_list_lock);
diff --git a/drivers/staging/lustre/lustre/osc/osc_cache.c b/drivers/staging/lustre/lustre/osc/osc_cache.c
index 63363111380c..5f25bf83dcfc 100644
--- a/drivers/staging/lustre/lustre/osc/osc_cache.c
+++ b/drivers/staging/lustre/lustre/osc/osc_cache.c
@@ -544,7 +544,7 @@ static int osc_extent_merge(const struct lu_env *env, struct osc_extent *cur,
                 return -ERANGE;
 
         LASSERT(cur->oe_osclock == victim->oe_osclock);
-        ppc_bits = osc_cli(obj)->cl_chunkbits - PAGE_CACHE_SHIFT;
+        ppc_bits = osc_cli(obj)->cl_chunkbits - PAGE_SHIFT;
         chunk_start = cur->oe_start >> ppc_bits;
         chunk_end = cur->oe_end >> ppc_bits;
         if (chunk_start != (victim->oe_end >> ppc_bits) + 1 &&
@@ -647,8 +647,8 @@ static struct osc_extent *osc_extent_find(const struct lu_env *env,
         lock = cl_lock_at_pgoff(env, osc2cl(obj), index, NULL, 1, 0);
         LASSERT(lock->cll_descr.cld_mode >= CLM_WRITE);
 
-        LASSERT(cli->cl_chunkbits >= PAGE_CACHE_SHIFT);
-        ppc_bits = cli->cl_chunkbits - PAGE_CACHE_SHIFT;
+        LASSERT(cli->cl_chunkbits >= PAGE_SHIFT);
+        ppc_bits = cli->cl_chunkbits - PAGE_SHIFT;
         chunk_mask = ~((1 << ppc_bits) - 1);
         chunksize = 1 << cli->cl_chunkbits;
         chunk = index >> ppc_bits;
@@ -871,8 +871,8 @@ int osc_extent_finish(const struct lu_env *env, struct osc_extent *ext,
 
         if (!sent) {
                 lost_grant = ext->oe_grants;
-        } else if (blocksize < PAGE_CACHE_SIZE &&
-                   last_count != PAGE_CACHE_SIZE) {
+        } else if (blocksize < PAGE_SIZE &&
+                   last_count != PAGE_SIZE) {
                 /* For short writes we shouldn't count parts of pages that
                  * span a whole chunk on the OST side, or our accounting goes
                  * wrong.  Should match the code in filter_grant_check.
@@ -884,7 +884,7 @@ int osc_extent_finish(const struct lu_env *env, struct osc_extent *ext,
                 if (end)
                         count += blocksize - end;
 
-                lost_grant = PAGE_CACHE_SIZE - count;
+                lost_grant = PAGE_SIZE - count;
         }
         if (ext->oe_grants > 0)
                 osc_free_grant(cli, nr_pages, lost_grant);
@@ -967,7 +967,7 @@ static int osc_extent_truncate(struct osc_extent *ext, pgoff_t trunc_index,
         struct osc_async_page *oap;
         struct osc_async_page *tmp;
         int pages_in_chunk = 0;
-        int ppc_bits = cli->cl_chunkbits - PAGE_CACHE_SHIFT;
+        int ppc_bits = cli->cl_chunkbits - PAGE_SHIFT;
         __u64 trunc_chunk = trunc_index >> ppc_bits;
         int grants = 0;
         int nr_pages = 0;
@@ -1125,7 +1125,7 @@ static int osc_extent_make_ready(const struct lu_env *env,
         if (!(last->oap_async_flags & ASYNC_COUNT_STABLE)) {
                 last->oap_count = osc_refresh_count(env, last, OBD_BRW_WRITE);
                 LASSERT(last->oap_count > 0);
-                LASSERT(last->oap_page_off + last->oap_count <= PAGE_CACHE_SIZE);
+                LASSERT(last->oap_page_off + last->oap_count <= PAGE_SIZE);
                 last->oap_async_flags |= ASYNC_COUNT_STABLE;
         }
 
@@ -1134,7 +1134,7 @@ static int osc_extent_make_ready(const struct lu_env *env,
          */
         list_for_each_entry(oap, &ext->oe_pages, oap_pending_item) {
                 if (!(oap->oap_async_flags & ASYNC_COUNT_STABLE)) {
-                        oap->oap_count = PAGE_CACHE_SIZE - oap->oap_page_off;
+                        oap->oap_count = PAGE_SIZE - oap->oap_page_off;
                         oap->oap_async_flags |= ASYNC_COUNT_STABLE;
                 }
         }
@@ -1158,7 +1158,7 @@ static int osc_extent_expand(struct osc_extent *ext, pgoff_t index, int *grants)
         struct osc_object *obj = ext->oe_obj;
         struct client_obd *cli = osc_cli(obj);
         struct osc_extent *next;
-        int ppc_bits = cli->cl_chunkbits - PAGE_CACHE_SHIFT;
+        int ppc_bits = cli->cl_chunkbits - PAGE_SHIFT;
         pgoff_t chunk = index >> ppc_bits;
         pgoff_t end_chunk;
         pgoff_t end_index;
@@ -1293,9 +1293,9 @@ static int osc_refresh_count(const struct lu_env *env,
                 return 0;
         else if (cl_offset(obj, page->cp_index + 1) > kms)
                 /* catch sub-page write at end of file */
-                return kms % PAGE_CACHE_SIZE;
+                return kms % PAGE_SIZE;
         else
-                return PAGE_CACHE_SIZE;
+                return PAGE_SIZE;
 }
 
 static int osc_completion(const struct lu_env *env, struct osc_async_page *oap,
@@ -1376,10 +1376,10 @@ static void osc_consume_write_grant(struct client_obd *cli,
         assert_spin_locked(&cli->cl_loi_list_lock.lock);
         LASSERT(!(pga->flag & OBD_BRW_FROM_GRANT));
         atomic_inc(&obd_dirty_pages);
-        cli->cl_dirty += PAGE_CACHE_SIZE;
+        cli->cl_dirty += PAGE_SIZE;
         pga->flag |= OBD_BRW_FROM_GRANT;
         CDEBUG(D_CACHE, "using %lu grant credits for brw %p page %p\n",
-               PAGE_CACHE_SIZE, pga, pga->pg);
+               PAGE_SIZE, pga, pga->pg);
         osc_update_next_shrink(cli);
 }
 
@@ -1396,11 +1396,11 @@ static void osc_release_write_grant(struct client_obd *cli,
 
         pga->flag &= ~OBD_BRW_FROM_GRANT;
         atomic_dec(&obd_dirty_pages);
-        cli->cl_dirty -= PAGE_CACHE_SIZE;
+        cli->cl_dirty -= PAGE_SIZE;
         if (pga->flag & OBD_BRW_NOCACHE) {
                 pga->flag &= ~OBD_BRW_NOCACHE;
                 atomic_dec(&obd_dirty_transit_pages);
-                cli->cl_dirty_transit -= PAGE_CACHE_SIZE;
+                cli->cl_dirty_transit -= PAGE_SIZE;
         }
 }
 
@@ -1456,7 +1456,7 @@ static void osc_unreserve_grant(struct client_obd *cli,
  * used, we should return these grants to OST. There're two cases where grants
  * can be lost:
  * 1. truncate;
- * 2. blocksize at OST is less than PAGE_CACHE_SIZE and a partial page was
+ * 2. blocksize at OST is less than PAGE_SIZE and a partial page was
  *    written. In this case OST may use less chunks to serve this partial
  *    write. OSTs don't actually know the page size on the client side. so
  *    clients have to calculate lost grant by the blocksize on the OST.
@@ -1469,7 +1469,7 @@ static void osc_free_grant(struct client_obd *cli, unsigned int nr_pages,
 
         client_obd_list_lock(&cli->cl_loi_list_lock);
         atomic_sub(nr_pages, &obd_dirty_pages);
-        cli->cl_dirty -= nr_pages << PAGE_CACHE_SHIFT;
+        cli->cl_dirty -= nr_pages << PAGE_SHIFT;
         cli->cl_lost_grant += lost_grant;
         if (cli->cl_avail_grant < grant && cli->cl_lost_grant >= grant) {
                 /* borrow some grant from truncate to avoid the case that
@@ -1512,11 +1512,11 @@ static int osc_enter_cache_try(struct client_obd *cli,
         if (rc < 0)
                 return 0;
 
-        if (cli->cl_dirty + PAGE_CACHE_SIZE <= cli->cl_dirty_max &&
+        if (cli->cl_dirty + PAGE_SIZE <= cli->cl_dirty_max &&
             atomic_read(&obd_dirty_pages) + 1 <= obd_max_dirty_pages) {
                 osc_consume_write_grant(cli, &oap->oap_brw_page);
                 if (transient) {
-                        cli->cl_dirty_transit += PAGE_CACHE_SIZE;
+                        cli->cl_dirty_transit += PAGE_SIZE;
                         atomic_inc(&obd_dirty_transit_pages);
                         oap->oap_brw_flags |= OBD_BRW_NOCACHE;
                 }
@@ -1562,7 +1562,7 @@ static int osc_enter_cache(const struct lu_env *env, struct client_obd *cli,
          * of queued writes and create a discontiguous rpc stream
          */
         if (OBD_FAIL_CHECK(OBD_FAIL_OSC_NO_GRANT) ||
-            cli->cl_dirty_max < PAGE_CACHE_SIZE     ||
+            cli->cl_dirty_max < PAGE_SIZE     ||
             cli->cl_ar.ar_force_sync || loi->loi_ar.ar_force_sync) {
                 rc = -EDQUOT;
                 goto out;
@@ -1632,7 +1632,7 @@ void osc_wake_cache_waiters(struct client_obd *cli)
 
                 ocw->ocw_rc = -EDQUOT;
                 /* we can't dirty more */
-                if ((cli->cl_dirty + PAGE_CACHE_SIZE > cli->cl_dirty_max) ||
+                if ((cli->cl_dirty + PAGE_SIZE > cli->cl_dirty_max) ||
                     (atomic_read(&obd_dirty_pages) + 1 >
                      obd_max_dirty_pages)) {
                         CDEBUG(D_CACHE, "no dirty room: dirty: %ld osc max %ld, sys max %d\n",
diff --git a/drivers/staging/lustre/lustre/osc/osc_page.c b/drivers/staging/lustre/lustre/osc/osc_page.c
index d720b1a1c18c..ce9ddd515f64 100644
--- a/drivers/staging/lustre/lustre/osc/osc_page.c
+++ b/drivers/staging/lustre/lustre/osc/osc_page.c
@@ -410,7 +410,7 @@ int osc_page_init(const struct lu_env *env, struct cl_object *obj,
         int result;
 
         opg->ops_from = 0;
-        opg->ops_to = PAGE_CACHE_SIZE;
+        opg->ops_to = PAGE_SIZE;
 
         result = osc_prep_async_page(osc, opg, vmpage,
                                      cl_offset(obj, page->cp_index));
@@ -487,9 +487,9 @@ static atomic_t osc_lru_waiters = ATOMIC_INIT(0);
 /* LRU pages are freed in batch mode. OSC should at least free this
  * number of pages to avoid running out of LRU budget, and..
  */
-static const int lru_shrink_min = 2 << (20 - PAGE_CACHE_SHIFT);  /* 2M */
+static const int lru_shrink_min = 2 << (20 - PAGE_SHIFT);  /* 2M */
 /* free this number at most otherwise it will take too long time to finish. */
-static const int lru_shrink_max = 32 << (20 - PAGE_CACHE_SHIFT); /* 32M */
+static const int lru_shrink_max = 32 << (20 - PAGE_SHIFT); /* 32M */
 
 /* Check if we can free LRU slots from this OSC. If there exists LRU waiters,
  * we should free slots aggressively. In this way, slots are freed in a steady
diff --git a/drivers/staging/lustre/lustre/osc/osc_request.c b/drivers/staging/lustre/lustre/osc/osc_request.c
index 74805f1ae888..30526ebcad04 100644
--- a/drivers/staging/lustre/lustre/osc/osc_request.c
+++ b/drivers/staging/lustre/lustre/osc/osc_request.c
@@ -826,7 +826,7 @@ static void osc_announce_cached(struct client_obd *cli, struct obdo *oa,
                 oa->o_undirty = 0;
         } else {
                 long max_in_flight = (cli->cl_max_pages_per_rpc <<
-                                      PAGE_CACHE_SHIFT)*
+                                      PAGE_SHIFT)*
                                      (cli->cl_max_rpcs_in_flight + 1);
                 oa->o_undirty = max(cli->cl_dirty_max, max_in_flight);
         }
@@ -909,11 +909,11 @@ static void osc_shrink_grant_local(struct client_obd *cli, struct obdo *oa)
 static int osc_shrink_grant(struct client_obd *cli)
 {
         __u64 target_bytes = (cli->cl_max_rpcs_in_flight + 1) *
-                             (cli->cl_max_pages_per_rpc << PAGE_CACHE_SHIFT);
+                             (cli->cl_max_pages_per_rpc << PAGE_SHIFT);
 
         client_obd_list_lock(&cli->cl_loi_list_lock);
         if (cli->cl_avail_grant <= target_bytes)
-                target_bytes = cli->cl_max_pages_per_rpc << PAGE_CACHE_SHIFT;
+                target_bytes = cli->cl_max_pages_per_rpc << PAGE_SHIFT;
         client_obd_list_unlock(&cli->cl_loi_list_lock);
 
         return osc_shrink_grant_to_target(cli, target_bytes);
@@ -929,8 +929,8 @@ int osc_shrink_grant_to_target(struct client_obd *cli, __u64 target_bytes)
          * We don't want to shrink below a single RPC, as that will negatively
          * impact block allocation and long-term performance.
          */
-        if (target_bytes < cli->cl_max_pages_per_rpc << PAGE_CACHE_SHIFT)
-                target_bytes = cli->cl_max_pages_per_rpc << PAGE_CACHE_SHIFT;
+        if (target_bytes < cli->cl_max_pages_per_rpc << PAGE_SHIFT)
+                target_bytes = cli->cl_max_pages_per_rpc << PAGE_SHIFT;
 
         if (target_bytes >= cli->cl_avail_grant) {
                 client_obd_list_unlock(&cli->cl_loi_list_lock);
@@ -978,7 +978,7 @@ static int osc_should_shrink_grant(struct client_obd *client)
                  * cli_brw_size(obd->u.cli.cl_import->imp_obd->obd_self_export)
                  * Keep comment here so that it can be found by searching.
                  */
-                int brw_size = client->cl_max_pages_per_rpc << PAGE_CACHE_SHIFT;
+                int brw_size = client->cl_max_pages_per_rpc << PAGE_SHIFT;
 
                 if (client->cl_import->imp_state == LUSTRE_IMP_FULL &&
                     client->cl_avail_grant > brw_size)
@@ -1052,7 +1052,7 @@ static void osc_init_grant(struct client_obd *cli, struct obd_connect_data *ocd)
         }
 
         /* determine the appropriate chunk size used by osc_extent. */
-        cli->cl_chunkbits = max_t(int, PAGE_CACHE_SHIFT, ocd->ocd_blocksize);
+        cli->cl_chunkbits = max_t(int, PAGE_SHIFT, ocd->ocd_blocksize);
         client_obd_list_unlock(&cli->cl_loi_list_lock);
 
         CDEBUG(D_CACHE, "%s, setting cl_avail_grant: %ld cl_lost_grant: %ld chunk bits: %d\n",
@@ -1317,9 +1317,9 @@ static int osc_brw_prep_request(int cmd, struct client_obd *cli,
                 LASSERT(pg->count > 0);
                 /* make sure there is no gap in the middle of page array */
                 LASSERTF(page_count == 1 ||
-                         (ergo(i == 0, poff + pg->count == PAGE_CACHE_SIZE) &&
+                         (ergo(i == 0, poff + pg->count == PAGE_SIZE) &&
                           ergo(i > 0 && i < page_count - 1,
-                               poff == 0 && pg->count == PAGE_CACHE_SIZE)   &&
+                               poff == 0 && pg->count == PAGE_SIZE)   &&
                           ergo(i == page_count - 1, poff == 0)),
                          "i: %d/%d pg: %p off: %llu, count: %u\n",
                          i, page_count, pg, pg->off, pg->count);
@@ -1877,7 +1877,7 @@ int osc_build_rpc(const struct lu_env *env, struct client_obd *cli,
                                                 oap->oap_count;
                         else
                                 LASSERT(oap->oap_page_off + oap->oap_count ==
-                                        PAGE_CACHE_SIZE);
+                                        PAGE_SIZE);
                 }
         }
 
@@ -1993,7 +1993,7 @@ int osc_build_rpc(const struct lu_env *env, struct client_obd *cli,
                 tmp->oap_request = ptlrpc_request_addref(req);
 
         client_obd_list_lock(&cli->cl_loi_list_lock);
-        starting_offset >>= PAGE_CACHE_SHIFT;
+        starting_offset >>= PAGE_SHIFT;
         if (cmd == OBD_BRW_READ) {
                 cli->cl_r_in_flight++;
                 lprocfs_oh_tally_log2(&cli->cl_read_page_hist, page_count);
@@ -2790,12 +2790,12 @@ out:
                                                 CFS_PAGE_MASK;
 
                 if (OBD_OBJECT_EOF - fm_key->fiemap.fm_length <=
-                    fm_key->fiemap.fm_start + PAGE_CACHE_SIZE - 1)
+                    fm_key->fiemap.fm_start + PAGE_SIZE - 1)
                         policy.l_extent.end = OBD_OBJECT_EOF;
                 else
                         policy.l_extent.end = (fm_key->fiemap.fm_start +
                                 fm_key->fiemap.fm_length +
-                                PAGE_CACHE_SIZE - 1) & CFS_PAGE_MASK;
+                                PAGE_SIZE - 1) & CFS_PAGE_MASK;
 
                 ostid_build_res_name(&fm_key->oa.o_oi, &res_id);
                 mode = ldlm_lock_match(exp->exp_obd->obd_namespace,
diff --git a/drivers/staging/lustre/lustre/ptlrpc/client.c b/drivers/staging/lustre/lustre/ptlrpc/client.c
index 1b7673eec4d7..cf3ac8eee9ee 100644
--- a/drivers/staging/lustre/lustre/ptlrpc/client.c
+++ b/drivers/staging/lustre/lustre/ptlrpc/client.c
@@ -174,12 +174,12 @@ void __ptlrpc_prep_bulk_page(struct ptlrpc_bulk_desc *desc,
         LASSERT(page);
         LASSERT(pageoffset >= 0);
         LASSERT(len > 0);
-        LASSERT(pageoffset + len <= PAGE_CACHE_SIZE);
+        LASSERT(pageoffset + len <= PAGE_SIZE);
 
         desc->bd_nob += len;
 
         if (pin)
-                page_cache_get(page);
+                get_page(page);
 
         ptlrpc_add_bulk_page(desc, page, pageoffset, len);
 }
@@ -206,7 +206,7 @@ void __ptlrpc_free_bulk(struct ptlrpc_bulk_desc *desc, int unpin)
 
         if (unpin) {
                 for (i = 0; i < desc->bd_iov_count; i++)
-                        page_cache_release(desc->bd_iov[i].kiov_page);
+                        put_page(desc->bd_iov[i].kiov_page);
         }
 
         kfree(desc);
diff --git a/drivers/staging/lustre/lustre/ptlrpc/import.c b/drivers/staging/lustre/lustre/ptlrpc/import.c
index b4eddf291269..cd94fed0ffdf 100644
--- a/drivers/staging/lustre/lustre/ptlrpc/import.c
+++ b/drivers/staging/lustre/lustre/ptlrpc/import.c
@@ -1092,7 +1092,7 @@ finish:
 
                 if (ocd->ocd_connect_flags & OBD_CONNECT_BRW_SIZE)
                         cli->cl_max_pages_per_rpc =
-                                min(ocd->ocd_brw_size >> PAGE_CACHE_SHIFT,
+                                min(ocd->ocd_brw_size >> PAGE_SHIFT,
                                     cli->cl_max_pages_per_rpc);
                 else if (imp->imp_connect_op == MDS_CONNECT ||
                          imp->imp_connect_op == MGS_CONNECT)
diff --git a/drivers/staging/lustre/lustre/ptlrpc/lproc_ptlrpc.c b/drivers/staging/lustre/lustre/ptlrpc/lproc_ptlrpc.c
index cee04efb6fb5..c95a91ce26c9 100644
--- a/drivers/staging/lustre/lustre/ptlrpc/lproc_ptlrpc.c
+++ b/drivers/staging/lustre/lustre/ptlrpc/lproc_ptlrpc.c
@@ -308,7 +308,7 @@ ptlrpc_lprocfs_req_history_max_seq_write(struct file *file,
          * hose a kernel by allowing the request history to grow too
          * far.
          */
-        bufpages = (svc->srv_buf_size + PAGE_CACHE_SIZE - 1) >> PAGE_CACHE_SHIFT;
+        bufpages = (svc->srv_buf_size + PAGE_SIZE - 1) >> PAGE_SHIFT;
         if (val > totalram_pages / (2 * bufpages))
                 return -ERANGE;
 
@@ -1226,7 +1226,7 @@ int lprocfs_wr_import(struct file *file, const char __user *buffer,
         const char prefix[] = "connection=";
         const int prefix_len = sizeof(prefix) - 1;
 
-        if (count > PAGE_CACHE_SIZE - 1 || count <= prefix_len)
+        if (count > PAGE_SIZE - 1 || count <= prefix_len)
                 return -EINVAL;
 
         kbuf = kzalloc(count + 1, GFP_NOFS);
diff --git a/drivers/staging/lustre/lustre/ptlrpc/recover.c b/drivers/staging/lustre/lustre/ptlrpc/recover.c
index 5f27d9c2e4ef..30d9a164e52d 100644
--- a/drivers/staging/lustre/lustre/ptlrpc/recover.c
+++ b/drivers/staging/lustre/lustre/ptlrpc/recover.c
@@ -195,7 +195,7 @@ int ptlrpc_resend(struct obd_import *imp)
         }
 
         list_for_each_entry_safe(req, next, &imp->imp_sending_list, rq_list) {
-                LASSERTF((long)req > PAGE_CACHE_SIZE && req != LP_POISON,
+                LASSERTF((long)req > PAGE_SIZE && req != LP_POISON,
                          "req %p bad\n", req);
                 LASSERTF(req->rq_type != LI_POISON, "req %p freed\n", req);
                 if (!ptlrpc_no_resend(req))
diff --git a/drivers/staging/lustre/lustre/ptlrpc/sec_bulk.c b/drivers/staging/lustre/lustre/ptlrpc/sec_bulk.c
index 72d5b9bf5b29..d3872b8c9a6e 100644
--- a/drivers/staging/lustre/lustre/ptlrpc/sec_bulk.c
+++ b/drivers/staging/lustre/lustre/ptlrpc/sec_bulk.c
@@ -58,7 +58,7 @@
  * bulk encryption page pools      *
  ****************************************/
 
-#define POINTERS_PER_PAGE       (PAGE_CACHE_SIZE / sizeof(void *))
+#define POINTERS_PER_PAGE       (PAGE_SIZE / sizeof(void *))
 #define PAGES_PER_POOL          (POINTERS_PER_PAGE)
 
 #define IDLE_IDX_MAX     (100)
diff --git a/drivers/staging/media/davinci_vpfe/vpfe_video.c b/drivers/staging/media/davinci_vpfe/vpfe_video.c
index b793c04028a3..be72a8e5f221 100644
--- a/drivers/staging/media/davinci_vpfe/vpfe_video.c
+++ b/drivers/staging/media/davinci_vpfe/vpfe_video.c
@@ -172,9 +172,11 @@ static int vpfe_prepare_pipeline(struct vpfe_video_device *video)
 static int vpfe_update_pipe_state(struct vpfe_video_device *video)
 {
         struct vpfe_pipeline *pipe = &video->pipe;
+        int ret;
 
-        if (vpfe_prepare_pipeline(video))
-                return vpfe_prepare_pipeline(video);
+        ret = vpfe_prepare_pipeline(video);
+        if (ret)
+                return ret;
 
         /*
          * Find out if there is any input video
@@ -182,9 +184,10 @@ static int vpfe_update_pipe_state(struct vpfe_video_device *video)
          */
         if (pipe->input_num == 0) {
                 pipe->state = VPFE_PIPELINE_STREAM_CONTINUOUS;
-                if (vpfe_update_current_ext_subdev(video)) {
+                ret = vpfe_update_current_ext_subdev(video);
+                if (ret) {
                         pr_err("Invalid external subdev\n");
-                        return vpfe_update_current_ext_subdev(video);
+                        return ret;
                 }
         } else {
                 pipe->state = VPFE_PIPELINE_STREAM_SINGLESHOT;
@@ -667,6 +670,7 @@ static int vpfe_enum_fmt(struct file *file, void  *priv,
         struct v4l2_subdev *subdev;
         struct v4l2_format format;
         struct media_pad *remote;
+        int ret;
 
         v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_enum_fmt\n");
 
@@ -695,10 +699,11 @@ static int vpfe_enum_fmt(struct file *file, void  *priv,
         sd_fmt.pad = remote->index;
         sd_fmt.which = V4L2_SUBDEV_FORMAT_ACTIVE;
         /* get output format of remote subdev */
-        if (v4l2_subdev_call(subdev, pad, get_fmt, NULL, &sd_fmt)) {
+        ret = v4l2_subdev_call(subdev, pad, get_fmt, NULL, &sd_fmt);
+        if (ret) {
                 v4l2_err(&vpfe_dev->v4l2_dev,
                          "invalid remote subdev for video node\n");
-                return v4l2_subdev_call(subdev, pad, get_fmt, NULL, &sd_fmt);
+                return ret;
         }
         /* convert to pix format */
         mbus.code = sd_fmt.format.code;
@@ -725,6 +730,7 @@ static int vpfe_s_fmt(struct file *file, void *priv,
         struct vpfe_video_device *video = video_drvdata(file);
         struct vpfe_device *vpfe_dev = video->vpfe_dev;
         struct v4l2_format format;
+        int ret;
 
         v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_s_fmt\n");
         /* If streaming is started, return error */
@@ -733,8 +739,9 @@ static int vpfe_s_fmt(struct file *file, void *priv,
                 return -EBUSY;
         }
         /* get adjacent subdev's output pad format */
-        if (__vpfe_video_get_format(video, &format))
-                return __vpfe_video_get_format(video, &format);
+        ret = __vpfe_video_get_format(video, &format);
+        if (ret)
+                return ret;
         *fmt = format;
         video->fmt = *fmt;
         return 0;
@@ -757,11 +764,13 @@ static int vpfe_try_fmt(struct file *file, void *priv,
         struct vpfe_video_device *video = video_drvdata(file);
         struct vpfe_device *vpfe_dev = video->vpfe_dev;
         struct v4l2_format format;
+        int ret;
 
         v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_try_fmt\n");
         /* get adjacent subdev's output pad format */
-        if (__vpfe_video_get_format(video, &format))
-                return __vpfe_video_get_format(video, &format);
+        ret = __vpfe_video_get_format(video, &format);
+        if (ret)
+                return ret;
 
         *fmt = format;
         return 0;
@@ -838,8 +847,9 @@ static int vpfe_s_input(struct file *file, void *priv, unsigned int index)
 
         v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_s_input\n");
 
-        if (mutex_lock_interruptible(&video->lock))
-                return mutex_lock_interruptible(&video->lock);
+        ret = mutex_lock_interruptible(&video->lock);
+        if (ret)
+                return ret;
         /*
          * If streaming is started return device busy
          * error
@@ -940,8 +950,9 @@ static int vpfe_s_std(struct file *file, void *priv, v4l2_std_id std_id)
         v4l2_dbg(1, debug, &vpfe_dev->v4l2_dev, "vpfe_s_std\n");
 
         /* Call decoder driver function to set the standard */
-        if (mutex_lock_interruptible(&video->lock))
-                return mutex_lock_interruptible(&video->lock);
+        ret = mutex_lock_interruptible(&video->lock);
+        if (ret)
+                return ret;
         sdinfo = video->current_ext_subdev;
         /* If streaming is started, return device busy error */
         if (video->started) {
@@ -1327,8 +1338,9 @@ static int vpfe_reqbufs(struct file *file, void *priv,
                 return -EINVAL;
         }
 
-        if (mutex_lock_interruptible(&video->lock))
-                return mutex_lock_interruptible(&video->lock);
+        ret = mutex_lock_interruptible(&video->lock);
+        if (ret)
+                return ret;
 
         if (video->io_usrs != 0) {
                 v4l2_err(&vpfe_dev->v4l2_dev, "Only one IO user allowed\n");
@@ -1354,10 +1366,11 @@ static int vpfe_reqbufs(struct file *file, void *priv,
         q->buf_struct_size = sizeof(struct vpfe_cap_buffer);
         q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
 
-        if (vb2_queue_init(q)) {
+        ret = vb2_queue_init(q);
+        if (ret) {
                 v4l2_err(&vpfe_dev->v4l2_dev, "vb2_queue_init() failed\n");
                 vb2_dma_contig_cleanup_ctx(vpfe_dev->pdev);
-                return vb2_queue_init(q);
+                return ret;
         }
 
         fh->io_allowed = 1;
@@ -1533,8 +1546,9 @@ static int vpfe_streamoff(struct file *file, void *priv,
                 return -EINVAL;
         }
 
-        if (mutex_lock_interruptible(&video->lock))
-                return mutex_lock_interruptible(&video->lock);
+        ret = mutex_lock_interruptible(&video->lock);
+        if (ret)
+                return ret;
 
         vpfe_stop_capture(video);
         ret = vb2_streamoff(&video->buffer_queue, buf_type);
diff --git a/drivers/staging/olpc_dcon/Kconfig b/drivers/staging/olpc_dcon/Kconfig
new file mode 100644
index 000000000000..d277f048789e
--- /dev/null
+++ b/drivers/staging/olpc_dcon/Kconfig
@@ -0,0 +1,35 @@
+config FB_OLPC_DCON
+        tristate "One Laptop Per Child Display CONtroller support"
+        depends on OLPC && FB
+        depends on I2C
+        depends on (GPIO_CS5535 || GPIO_CS5535=n)
+        select BACKLIGHT_CLASS_DEVICE
+        ---help---
+          In order to support very low power operation, the XO laptop uses a
+          secondary Display CONtroller, or DCON.  This secondary controller
+          is present in the video pipeline between the primary display
+          controller (integrate into the processor or chipset) and the LCD
+          panel.  It allows the main processor/display controller to be
+          completely powered off while still retaining an image on the display.
+          This controller is only available on OLPC platforms.  Unless you have
+          one of these platforms, you will want to say 'N'.
+
+config FB_OLPC_DCON_1
+        bool "OLPC XO-1 DCON support"
+        depends on FB_OLPC_DCON && GPIO_CS5535
+        default y
+        ---help---
+          Enable support for the DCON in XO-1 model laptops.  The kernel
+          communicates with the DCON using model-specific code.  If you
+          have an XO-1 (or if you're unsure what model you have), you should
+          say 'Y'.
+
+config FB_OLPC_DCON_1_5
+        bool "OLPC XO-1.5 DCON support"
+        depends on FB_OLPC_DCON && ACPI
+        default y
+        ---help---
+          Enable support for the DCON in XO-1.5 model laptops.  The kernel
+          communicates with the DCON using model-specific code.  If you
+          have an XO-1.5 (or if you're unsure what model you have), you
+          should say 'Y'.
diff --git a/drivers/staging/olpc_dcon/Makefile b/drivers/staging/olpc_dcon/Makefile
new file mode 100644
index 000000000000..36c7e67fec20
--- /dev/null
+++ b/drivers/staging/olpc_dcon/Makefile
@@ -0,0 +1,6 @@
+olpc-dcon-objs += olpc_dcon.o
+olpc-dcon-$(CONFIG_FB_OLPC_DCON_1)      += olpc_dcon_xo_1.o
+olpc-dcon-$(CONFIG_FB_OLPC_DCON_1_5)    += olpc_dcon_xo_1_5.o
+obj-$(CONFIG_FB_OLPC_DCON)      += olpc-dcon.o
+
+
diff --git a/drivers/staging/olpc_dcon/TODO b/drivers/staging/olpc_dcon/TODO
new file mode 100644
index 000000000000..61c2e65ac354
--- /dev/null
+++ b/drivers/staging/olpc_dcon/TODO
@@ -0,0 +1,9 @@
+TODO:
+        - see if vx855 gpio API can be made similar enough to cs5535 so we can
+          share more code
+        - allow simultaneous XO-1 and XO-1.5 support
+
+Please send patches to Greg Kroah-Hartman <greg@kroah.com> and
+copy:
+        Daniel Drake <dsd@laptop.org>
+        Jens Frederich <jfrederich@gmail.com>
diff --git a/drivers/staging/olpc_dcon/olpc_dcon.c b/drivers/staging/olpc_dcon/olpc_dcon.c
new file mode 100644
index 000000000000..f45b2ef05f48
--- /dev/null
+++ b/drivers/staging/olpc_dcon/olpc_dcon.c
@@ -0,0 +1,813 @@
+/*
+ * Mainly by David Woodhouse, somewhat modified by Jordan Crouse
+ *
+ * Copyright © 2006-2007  Red Hat, Inc.
+ * Copyright © 2006-2007  Advanced Micro Devices, Inc.
+ * Copyright © 2009       VIA Technology, Inc.
+ * Copyright (c) 2010-2011  Andres Salomon <dilinger@queued.net>
+ *
+ * This program is free software.  You can redistribute it and/or
+ * modify it under the terms of version 2 of the GNU General Public
+ * License as published by the Free Software Foundation.
+ */
+
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
+#include <linux/kernel.h>
+#include <linux/fb.h>
+#include <linux/console.h>
+#include <linux/i2c.h>
+#include <linux/platform_device.h>
+#include <linux/interrupt.h>
+#include <linux/delay.h>
+#include <linux/module.h>
+#include <linux/backlight.h>
+#include <linux/device.h>
+#include <linux/uaccess.h>
+#include <linux/ctype.h>
+#include <linux/reboot.h>
+#include <linux/olpc-ec.h>
+#include <asm/tsc.h>
+#include <asm/olpc.h>
+
+#include "olpc_dcon.h"
+
+/* Module definitions */
+
+static ushort resumeline = 898;
+module_param(resumeline, ushort, 0444);
+
+static struct dcon_platform_data *pdata;
+
+/* I2C structures */
+
+/* Platform devices */
+static struct platform_device *dcon_device;
+
+static unsigned short normal_i2c[] = { 0x0d, I2C_CLIENT_END };
+
+static s32 dcon_write(struct dcon_priv *dcon, u8 reg, u16 val)
+{
+        return i2c_smbus_write_word_data(dcon->client, reg, val);
+}
+
+static s32 dcon_read(struct dcon_priv *dcon, u8 reg)
+{
+        return i2c_smbus_read_word_data(dcon->client, reg);
+}
+
+/* ===== API functions - these are called by a variety of users ==== */
+
+static int dcon_hw_init(struct dcon_priv *dcon, int is_init)
+{
+        u16 ver;
+        int rc = 0;
+
+        ver = dcon_read(dcon, DCON_REG_ID);
+        if ((ver >> 8) != 0xDC) {
+                pr_err("DCON ID not 0xDCxx: 0x%04x instead.\n", ver);
+                rc = -ENXIO;
+                goto err;
+        }
+
+        if (is_init) {
+                pr_info("Discovered DCON version %x\n", ver & 0xFF);
+                rc = pdata->init(dcon);
+                if (rc != 0) {
+                        pr_err("Unable to init.\n");
+                        goto err;
+                }
+        }
+
+        if (ver < 0xdc02) {
+                dev_err(&dcon->client->dev,
+                                "DCON v1 is unsupported, giving up..\n");
+                rc = -ENODEV;
+                goto err;
+        }
+
+        /* SDRAM setup/hold time */
+        dcon_write(dcon, 0x3a, 0xc040);
+        dcon_write(dcon, DCON_REG_MEM_OPT_A, 0x0000);  /* clear option bits */
+        dcon_write(dcon, DCON_REG_MEM_OPT_A,
+                                MEM_DLL_CLOCK_DELAY | MEM_POWER_DOWN);
+        dcon_write(dcon, DCON_REG_MEM_OPT_B, MEM_SOFT_RESET);
+
+        /* Colour swizzle, AA, no passthrough, backlight */
+        if (is_init) {
+                dcon->disp_mode = MODE_PASSTHRU | MODE_BL_ENABLE |
+                                MODE_CSWIZZLE | MODE_COL_AA;
+        }
+        dcon_write(dcon, DCON_REG_MODE, dcon->disp_mode);
+
+        /* Set the scanline to interrupt on during resume */
+        dcon_write(dcon, DCON_REG_SCAN_INT, resumeline);
+
+err:
+        return rc;
+}
+
+/*
+ * The smbus doesn't always come back due to what is believed to be
+ * hardware (power rail) bugs.  For older models where this is known to
+ * occur, our solution is to attempt to wait for the bus to stabilize;
+ * if it doesn't happen, cut power to the dcon, repower it, and wait
+ * for the bus to stabilize.  Rinse, repeat until we have a working
+ * smbus.  For newer models, we simply BUG(); we want to know if this
+ * still happens despite the power fixes that have been made!
+ */
+static int dcon_bus_stabilize(struct dcon_priv *dcon, int is_powered_down)
+{
+        unsigned long timeout;
+        u8 pm;
+        int x;
+
+power_up:
+        if (is_powered_down) {
+                pm = 1;
+                x = olpc_ec_cmd(EC_DCON_POWER_MODE, &pm, 1, NULL, 0);
+                if (x) {
+                        pr_warn("unable to force dcon to power up: %d!\n", x);
+                        return x;
+                }
+                usleep_range(10000, 11000);  /* we'll be conservative */
+        }
+
+        pdata->bus_stabilize_wiggle();
+
+        for (x = -1, timeout = 50; timeout && x < 0; timeout--) {
+                usleep_range(1000, 1100);
+                x = dcon_read(dcon, DCON_REG_ID);
+        }
+        if (x < 0) {
+                pr_err("unable to stabilize dcon's smbus, reasserting power and praying.\n");
+                BUG_ON(olpc_board_at_least(olpc_board(0xc2)));
+                pm = 0;
+                olpc_ec_cmd(EC_DCON_POWER_MODE, &pm, 1, NULL, 0);
+                msleep(100);
+                is_powered_down = 1;
+                goto power_up;  /* argh, stupid hardware.. */
+        }
+
+        if (is_powered_down)
+                return dcon_hw_init(dcon, 0);
+        return 0;
+}
+
+static void dcon_set_backlight(struct dcon_priv *dcon, u8 level)
+{
+        dcon->bl_val = level;
+        dcon_write(dcon, DCON_REG_BRIGHT, dcon->bl_val);
+
+        /* Purposely turn off the backlight when we go to level 0 */
+        if (dcon->bl_val == 0) {
+                dcon->disp_mode &= ~MODE_BL_ENABLE;
+                dcon_write(dcon, DCON_REG_MODE, dcon->disp_mode);
+        } else if (!(dcon->disp_mode & MODE_BL_ENABLE)) {
+                dcon->disp_mode |= MODE_BL_ENABLE;
+                dcon_write(dcon, DCON_REG_MODE, dcon->disp_mode);
+        }
+}
+
+/* Set the output type to either color or mono */
+static int dcon_set_mono_mode(struct dcon_priv *dcon, bool enable_mono)
+{
+        if (dcon->mono == enable_mono)
+                return 0;
+
+        dcon->mono = enable_mono;
+
+        if (enable_mono) {
+                dcon->disp_mode &= ~(MODE_CSWIZZLE | MODE_COL_AA);
+                dcon->disp_mode |= MODE_MONO_LUMA;
+        } else {
+                dcon->disp_mode &= ~(MODE_MONO_LUMA);
+                dcon->disp_mode |= MODE_CSWIZZLE | MODE_COL_AA;
+        }
+
+        dcon_write(dcon, DCON_REG_MODE, dcon->disp_mode);
+        return 0;
+}
+
+/* For now, this will be really stupid - we need to address how
+ * DCONLOAD works in a sleep and account for it accordingly
+ */
+
+static void dcon_sleep(struct dcon_priv *dcon, bool sleep)
+{
+        int x;
+
+        /* Turn off the backlight and put the DCON to sleep */
+
+        if (dcon->asleep == sleep)
+                return;
+
+        if (!olpc_board_at_least(olpc_board(0xc2)))
+                return;
+
+        if (sleep) {
+                u8 pm = 0;
+
+                x = olpc_ec_cmd(EC_DCON_POWER_MODE, &pm, 1, NULL, 0);
+                if (x)
+                        pr_warn("unable to force dcon to power down: %d!\n", x);
+                else
+                        dcon->asleep = sleep;
+        } else {
+                /* Only re-enable the backlight if the backlight value is set */
+                if (dcon->bl_val != 0)
+                        dcon->disp_mode |= MODE_BL_ENABLE;
+                x = dcon_bus_stabilize(dcon, 1);
+                if (x)
+                        pr_warn("unable to reinit dcon hardware: %d!\n", x);
+                else
+                        dcon->asleep = sleep;
+
+                /* Restore backlight */
+                dcon_set_backlight(dcon, dcon->bl_val);
+        }
+
+        /* We should turn off some stuff in the framebuffer - but what? */
+}
+
+/* the DCON seems to get confused if we change DCONLOAD too
+ * frequently -- i.e., approximately faster than frame time.
+ * normally we don't change it this fast, so in general we won't
+ * delay here.
+ */
+static void dcon_load_holdoff(struct dcon_priv *dcon)
+{
+        ktime_t delta_t, now;
+
+        while (1) {
+                now = ktime_get();
+                delta_t = ktime_sub(now, dcon->load_time);
+                if (ktime_to_ns(delta_t) > NSEC_PER_MSEC * 20)
+                        break;
+                mdelay(4);
+        }
+}
+
+static bool dcon_blank_fb(struct dcon_priv *dcon, bool blank)
+{
+        int err;
+
+        console_lock();
+        if (!lock_fb_info(dcon->fbinfo)) {
+                console_unlock();
+                dev_err(&dcon->client->dev, "unable to lock framebuffer\n");
+                return false;
+        }
+
+        dcon->ignore_fb_events = true;
+        err = fb_blank(dcon->fbinfo,
+                        blank ? FB_BLANK_POWERDOWN : FB_BLANK_UNBLANK);
+        dcon->ignore_fb_events = false;
+        unlock_fb_info(dcon->fbinfo);
+        console_unlock();
+
+        if (err) {
+                dev_err(&dcon->client->dev, "couldn't %sblank framebuffer\n",
+                                blank ? "" : "un");
+                return false;
+        }
+        return true;
+}
+
+/* Set the source of the display (CPU or DCON) */
+static void dcon_source_switch(struct work_struct *work)
+{
+        struct dcon_priv *dcon = container_of(work, struct dcon_priv,
+                        switch_source);
+        int source = dcon->pending_src;
+
+        if (dcon->curr_src == source)
+                return;
+
+        dcon_load_holdoff(dcon);
+
+        dcon->switched = false;
+
+        switch (source) {
+        case DCON_SOURCE_CPU:
+                pr_info("dcon_source_switch to CPU\n");
+                /* Enable the scanline interrupt bit */
+                if (dcon_write(dcon, DCON_REG_MODE,
+                                dcon->disp_mode | MODE_SCAN_INT))
+                        pr_err("couldn't enable scanline interrupt!\n");
+                else
+                        /* Wait up to one second for the scanline interrupt */
+                        wait_event_timeout(dcon->waitq, dcon->switched, HZ);
+
+                if (!dcon->switched)
+                        pr_err("Timeout entering CPU mode; expect a screen glitch.\n");
+
+                /* Turn off the scanline interrupt */
+                if (dcon_write(dcon, DCON_REG_MODE, dcon->disp_mode))
+                        pr_err("couldn't disable scanline interrupt!\n");
+
+                /*
+                 * Ideally we'd like to disable interrupts here so that the
+                 * fb unblanking and DCON turn on happen at a known time value;
+                 * however, we can't do that right now with fb_blank
+                 * messing with semaphores.
+                 *
+                 * For now, we just hope..
+                 */
+                if (!dcon_blank_fb(dcon, false)) {
+                        pr_err("Failed to enter CPU mode\n");
+                        dcon->pending_src = DCON_SOURCE_DCON;
+                        return;
+                }
+
+                /* And turn off the DCON */
+                pdata->set_dconload(1);
+                dcon->load_time = ktime_get();
+
+                pr_info("The CPU has control\n");
+                break;
+        case DCON_SOURCE_DCON:
+        {
+                ktime_t delta_t;
+
+                pr_info("dcon_source_switch to DCON\n");
+
+                /* Clear DCONLOAD - this implies that the DCON is in control */
+                pdata->set_dconload(0);
+                dcon->load_time = ktime_get();
+
+                wait_event_timeout(dcon->waitq, dcon->switched, HZ/2);
+
+                if (!dcon->switched) {
+                        pr_err("Timeout entering DCON mode; expect a screen glitch.\n");
+                } else {
+                        /* sometimes the DCON doesn't follow its own rules,
+                         * and doesn't wait for two vsync pulses before
+                         * ack'ing the frame load with an IRQ.  the result
+                         * is that the display shows the *previously*
+                         * loaded frame.  we can detect this by looking at
+                         * the time between asserting DCONLOAD and the IRQ --
+                         * if it's less than 20msec, then the DCON couldn't
+                         * have seen two VSYNC pulses.  in that case we
+                         * deassert and reassert, and hope for the best.
+                         * see http://dev.laptop.org/ticket/9664
+                         */
+                        delta_t = ktime_sub(dcon->irq_time, dcon->load_time);
+                        if (dcon->switched && ktime_to_ns(delta_t)
+                            < NSEC_PER_MSEC * 20) {
+                                pr_err("missed loading, retrying\n");
+                                pdata->set_dconload(1);
+                                mdelay(41);
+                                pdata->set_dconload(0);
+                                dcon->load_time = ktime_get();
+                                mdelay(41);
+                        }
+                }
+
+                dcon_blank_fb(dcon, true);
+                pr_info("The DCON has control\n");
+                break;
+        }
+        default:
+                BUG();
+        }
+
+        dcon->curr_src = source;
+}
+
+static void dcon_set_source(struct dcon_priv *dcon, int arg)
+{
+        if (dcon->pending_src == arg)
+                return;
+
+        dcon->pending_src = arg;
+
+        if (dcon->curr_src != arg)
+                schedule_work(&dcon->switch_source);
+}
+
+static void dcon_set_source_sync(struct dcon_priv *dcon, int arg)
+{
+        dcon_set_source(dcon, arg);
+        flush_scheduled_work();
+}
+
+static ssize_t dcon_mode_show(struct device *dev,
+        struct device_attribute *attr, char *buf)
+{
+        struct dcon_priv *dcon = dev_get_drvdata(dev);
+
+        return sprintf(buf, "%4.4X\n", dcon->disp_mode);
+}
+
+static ssize_t dcon_sleep_show(struct device *dev,
+        struct device_attribute *attr, char *buf)
+{
+        struct dcon_priv *dcon = dev_get_drvdata(dev);
+
+        return sprintf(buf, "%d\n", dcon->asleep);
+}
+
+static ssize_t dcon_freeze_show(struct device *dev,
+        struct device_attribute *attr, char *buf)
+{
+        struct dcon_priv *dcon = dev_get_drvdata(dev);
+
+        return sprintf(buf, "%d\n", dcon->curr_src == DCON_SOURCE_DCON ? 1 : 0);
+}
+
+static ssize_t dcon_mono_show(struct device *dev,
+        struct device_attribute *attr, char *buf)
+{
+        struct dcon_priv *dcon = dev_get_drvdata(dev);
+
+        return sprintf(buf, "%d\n", dcon->mono);
+}
+
+static ssize_t dcon_resumeline_show(struct device *dev,
+        struct device_attribute *attr, char *buf)
+{
+        return sprintf(buf, "%d\n", resumeline);
+}
+
+static ssize_t dcon_mono_store(struct device *dev,
+        struct device_attribute *attr, const char *buf, size_t count)
+{
+        unsigned long enable_mono;
+        int rc;
+
+        rc = kstrtoul(buf, 10, &enable_mono);
+        if (rc)
+                return rc;
+
+        dcon_set_mono_mode(dev_get_drvdata(dev), enable_mono ? true : false);
+
+        return count;
+}
+
+static ssize_t dcon_freeze_store(struct device *dev,
+        struct device_attribute *attr, const char *buf, size_t count)
+{
+        struct dcon_priv *dcon = dev_get_drvdata(dev);
+        unsigned long output;
+        int ret;
+
+        ret = kstrtoul(buf, 10, &output);
+        if (ret)
+                return ret;
+
+        pr_info("dcon_freeze_store: %lu\n", output);
+
+        switch (output) {
+        case 0:
+                dcon_set_source(dcon, DCON_SOURCE_CPU);
+                break;
+        case 1:
+                dcon_set_source_sync(dcon, DCON_SOURCE_DCON);
+                break;
+        case 2:  /* normally unused */
+                dcon_set_source(dcon, DCON_SOURCE_DCON);
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        return count;
+}
+
+static ssize_t dcon_resumeline_store(struct device *dev,
+        struct device_attribute *attr, const char *buf, size_t count)
+{
+        unsigned short rl;
+        int rc;
+
+        rc = kstrtou16(buf, 10, &rl);
+        if (rc)
+                return rc;
+
+        resumeline = rl;
+        dcon_write(dev_get_drvdata(dev), DCON_REG_SCAN_INT, resumeline);
+
+        return count;
+}
+
+static ssize_t dcon_sleep_store(struct device *dev,
+        struct device_attribute *attr, const char *buf, size_t count)
+{
+        unsigned long output;
+        int ret;
+
+        ret = kstrtoul(buf, 10, &output);
+        if (ret)
+                return ret;
+
+        dcon_sleep(dev_get_drvdata(dev), output ? true : false);
+        return count;
+}
+
+static struct device_attribute dcon_device_files[] = {
+        __ATTR(mode, 0444, dcon_mode_show, NULL),
+        __ATTR(sleep, 0644, dcon_sleep_show, dcon_sleep_store),
+        __ATTR(freeze, 0644, dcon_freeze_show, dcon_freeze_store),
+        __ATTR(monochrome, 0644, dcon_mono_show, dcon_mono_store),
+        __ATTR(resumeline, 0644, dcon_resumeline_show, dcon_resumeline_store),
+};
+
+static int dcon_bl_update(struct backlight_device *dev)
+{
+        struct dcon_priv *dcon = bl_get_data(dev);
+        u8 level = dev->props.brightness & 0x0F;
+
+        if (dev->props.power != FB_BLANK_UNBLANK)
+                level = 0;
+
+        if (level != dcon->bl_val)
+                dcon_set_backlight(dcon, level);
+
+        /* power down the DCON when the screen is blanked */
+        if (!dcon->ignore_fb_events)
+                dcon_sleep(dcon, !!(dev->props.state & BL_CORE_FBBLANK));
+
+        return 0;
+}
+
+static int dcon_bl_get(struct backlight_device *dev)
+{
+        struct dcon_priv *dcon = bl_get_data(dev);
+
+        return dcon->bl_val;
+}
+
+static const struct backlight_ops dcon_bl_ops = {
+        .update_status = dcon_bl_update,
+        .get_brightness = dcon_bl_get,
+};
+
+static struct backlight_properties dcon_bl_props = {
+        .max_brightness = 15,
+        .type = BACKLIGHT_RAW,
+        .power = FB_BLANK_UNBLANK,
+};
+
+static int dcon_reboot_notify(struct notifier_block *nb,
+                              unsigned long foo, void *bar)
+{
+        struct dcon_priv *dcon = container_of(nb, struct dcon_priv, reboot_nb);
+
+        if (!dcon || !dcon->client)
+                return NOTIFY_DONE;
+
+        /* Turn off the DCON. Entirely. */
+        dcon_write(dcon, DCON_REG_MODE, 0x39);
+        dcon_write(dcon, DCON_REG_MODE, 0x32);
+        return NOTIFY_DONE;
+}
+
+static int unfreeze_on_panic(struct notifier_block *nb,
+                             unsigned long e, void *p)
+{
+        pdata->set_dconload(1);
+        return NOTIFY_DONE;
+}
+
+static struct notifier_block dcon_panic_nb = {
+        .notifier_call = unfreeze_on_panic,
+};
+
+static int dcon_detect(struct i2c_client *client, struct i2c_board_info *info)
+{
+        strlcpy(info->type, "olpc_dcon", I2C_NAME_SIZE);
+
+        return 0;
+}
+
+static int dcon_probe(struct i2c_client *client, const struct i2c_device_id *id)
+{
+        struct dcon_priv *dcon;
+        int rc, i, j;
+
+        if (!pdata)
+                return -ENXIO;
+
+        dcon = kzalloc(sizeof(*dcon), GFP_KERNEL);
+        if (!dcon)
+                return -ENOMEM;
+
+        dcon->client = client;
+        init_waitqueue_head(&dcon->waitq);
+        INIT_WORK(&dcon->switch_source, dcon_source_switch);
+        dcon->reboot_nb.notifier_call = dcon_reboot_notify;
+        dcon->reboot_nb.priority = -1;
+
+        i2c_set_clientdata(client, dcon);
+
+        if (num_registered_fb < 1) {
+                dev_err(&client->dev, "DCON driver requires a registered fb\n");
+                rc = -EIO;
+                goto einit;
+        }
+        dcon->fbinfo = registered_fb[0];
+
+        rc = dcon_hw_init(dcon, 1);
+        if (rc)
+                goto einit;
+
+        /* Add the DCON device */
+
+        dcon_device = platform_device_alloc("dcon", -1);
+
+        if (!dcon_device) {
+                pr_err("Unable to create the DCON device\n");
+                rc = -ENOMEM;
+                goto eirq;
+        }
+        rc = platform_device_add(dcon_device);
+        platform_set_drvdata(dcon_device, dcon);
+
+        if (rc) {
+                pr_err("Unable to add the DCON device\n");
+                goto edev;
+        }
+
+        for (i = 0; i < ARRAY_SIZE(dcon_device_files); i++) {
+                rc = device_create_file(&dcon_device->dev,
+                                        &dcon_device_files[i]);
+                if (rc) {
+                        dev_err(&dcon_device->dev, "Cannot create sysfs file\n");
+                        goto ecreate;
+                }
+        }
+
+        dcon->bl_val = dcon_read(dcon, DCON_REG_BRIGHT) & 0x0F;
+
+        /* Add the backlight device for the DCON */
+        dcon_bl_props.brightness = dcon->bl_val;
+        dcon->bl_dev = backlight_device_register("dcon-bl", &dcon_device->dev,
+                dcon, &dcon_bl_ops, &dcon_bl_props);
+        if (IS_ERR(dcon->bl_dev)) {
+                dev_err(&client->dev, "cannot register backlight dev (%ld)\n",
+                                PTR_ERR(dcon->bl_dev));
+                dcon->bl_dev = NULL;
+        }
+
+        register_reboot_notifier(&dcon->reboot_nb);
+        atomic_notifier_chain_register(&panic_notifier_list, &dcon_panic_nb);
+
+        return 0;
+
+ ecreate:
+        for (j = 0; j < i; j++)
+                device_remove_file(&dcon_device->dev, &dcon_device_files[j]);
+ edev:
+        platform_device_unregister(dcon_device);
+        dcon_device = NULL;
+ eirq:
+        free_irq(DCON_IRQ, dcon);
+ einit:
+        kfree(dcon);
+        return rc;
+}
+
+static int dcon_remove(struct i2c_client *client)
+{
+        struct dcon_priv *dcon = i2c_get_clientdata(client);
+
+        unregister_reboot_notifier(&dcon->reboot_nb);
+        atomic_notifier_chain_unregister(&panic_notifier_list, &dcon_panic_nb);
+
+        free_irq(DCON_IRQ, dcon);
+
+        backlight_device_unregister(dcon->bl_dev);
+
+        if (dcon_device)
+                platform_device_unregister(dcon_device);
+        cancel_work_sync(&dcon->switch_source);
+
+        kfree(dcon);
+
+        return 0;
+}
+
+#ifdef CONFIG_PM
+static int dcon_suspend(struct device *dev)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        struct dcon_priv *dcon = i2c_get_clientdata(client);
+
+        if (!dcon->asleep) {
+                /* Set up the DCON to have the source */
+                dcon_set_source_sync(dcon, DCON_SOURCE_DCON);
+        }
+
+        return 0;
+}
+
+static int dcon_resume(struct device *dev)
+{
+        struct i2c_client *client = to_i2c_client(dev);
+        struct dcon_priv *dcon = i2c_get_clientdata(client);
+
+        if (!dcon->asleep) {
+                dcon_bus_stabilize(dcon, 0);
+                dcon_set_source(dcon, DCON_SOURCE_CPU);
+        }
+
+        return 0;
+}
+
+#else
+
+#define dcon_suspend NULL
+#define dcon_resume NULL
+
+#endif /* CONFIG_PM */
+
+irqreturn_t dcon_interrupt(int irq, void *id)
+{
+        struct dcon_priv *dcon = id;
+        u8 status;
+
+        if (pdata->read_status(&status))
+                return IRQ_NONE;
+
+        switch (status & 3) {
+        case 3:
+                pr_debug("DCONLOAD_MISSED interrupt\n");
+                break;
+
+        case 2: /* switch to DCON mode */
+        case 1: /* switch to CPU mode */
+                dcon->switched = true;
+                dcon->irq_time = ktime_get();
+                wake_up(&dcon->waitq);
+                break;
+
+        case 0:
+                /* workaround resume case:  the DCON (on 1.5) doesn't
+                 * ever assert status 0x01 when switching to CPU mode
+                 * during resume.  this is because DCONLOAD is de-asserted
+                 * _immediately_ upon exiting S3, so the actual release
+                 * of the DCON happened long before this point.
+                 * see http://dev.laptop.org/ticket/9869
+                 */
+                if (dcon->curr_src != dcon->pending_src && !dcon->switched) {
+                        dcon->switched = true;
+                        dcon->irq_time = ktime_get();
+                        wake_up(&dcon->waitq);
+                        pr_debug("switching w/ status 0/0\n");
+                } else {
+                        pr_debug("scanline interrupt w/CPU\n");
+                }
+        }
+
+        return IRQ_HANDLED;
+}
+
+static const struct dev_pm_ops dcon_pm_ops = {
+        .suspend = dcon_suspend,
+        .resume = dcon_resume,
+};
+
+static const struct i2c_device_id dcon_idtable[] = {
+        { "olpc_dcon",  0 },
+        { }
+};
+MODULE_DEVICE_TABLE(i2c, dcon_idtable);
+
+static struct i2c_driver dcon_driver = {
+        .driver = {
+                .name   = "olpc_dcon",
+                .pm = &dcon_pm_ops,
+        },
+        .class = I2C_CLASS_DDC | I2C_CLASS_HWMON,
+        .id_table = dcon_idtable,
+        .probe = dcon_probe,
+        .remove = dcon_remove,
+        .detect = dcon_detect,
+        .address_list = normal_i2c,
+};
+
+static int __init olpc_dcon_init(void)
+{
+#ifdef CONFIG_FB_OLPC_DCON_1_5
+        /* XO-1.5 */
+        if (olpc_board_at_least(olpc_board(0xd0)))
+                pdata = &dcon_pdata_xo_1_5;
+#endif
+#ifdef CONFIG_FB_OLPC_DCON_1
+        if (!pdata)
+                pdata = &dcon_pdata_xo_1;
+#endif
+
+        return i2c_add_driver(&dcon_driver);
+}
+
+static void __exit olpc_dcon_exit(void)
+{
+        i2c_del_driver(&dcon_driver);
+}
+
+module_init(olpc_dcon_init);
+module_exit(olpc_dcon_exit);
+
+MODULE_LICENSE("GPL");
diff --git a/drivers/staging/olpc_dcon/olpc_dcon.h b/drivers/staging/olpc_dcon/olpc_dcon.h
new file mode 100644
index 000000000000..215e7ec4dea2
--- /dev/null
+++ b/drivers/staging/olpc_dcon/olpc_dcon.h
@@ -0,0 +1,111 @@
+#ifndef OLPC_DCON_H_
+#define OLPC_DCON_H_
+
+#include <linux/notifier.h>
+#include <linux/workqueue.h>
+
+/* DCON registers */
+
+#define DCON_REG_ID              0
+#define DCON_REG_MODE            1
+
+#define MODE_PASSTHRU   (1<<0)
+#define MODE_SLEEP      (1<<1)
+#define MODE_SLEEP_AUTO (1<<2)
+#define MODE_BL_ENABLE  (1<<3)
+#define MODE_BLANK      (1<<4)
+#define MODE_CSWIZZLE   (1<<5)
+#define MODE_COL_AA     (1<<6)
+#define MODE_MONO_LUMA  (1<<7)
+#define MODE_SCAN_INT   (1<<8)
+#define MODE_CLOCKDIV   (1<<9)
+#define MODE_DEBUG      (1<<14)
+#define MODE_SELFTEST   (1<<15)
+
+#define DCON_REG_HRES           0x2
+#define DCON_REG_HTOTAL         0x3
+#define DCON_REG_HSYNC_WIDTH    0x4
+#define DCON_REG_VRES           0x5
+#define DCON_REG_VTOTAL         0x6
+#define DCON_REG_VSYNC_WIDTH    0x7
+#define DCON_REG_TIMEOUT        0x8
+#define DCON_REG_SCAN_INT       0x9
+#define DCON_REG_BRIGHT         0xa
+#define DCON_REG_MEM_OPT_A      0x41
+#define DCON_REG_MEM_OPT_B      0x42
+
+/* Load Delay Locked Loop (DLL) settings for clock delay */
+#define MEM_DLL_CLOCK_DELAY     (1<<0)
+/* Memory controller power down function */
+#define MEM_POWER_DOWN          (1<<8)
+/* Memory controller software reset */
+#define MEM_SOFT_RESET          (1<<0)
+
+/* Status values */
+
+#define DCONSTAT_SCANINT        0
+#define DCONSTAT_SCANINT_DCON   1
+#define DCONSTAT_DISPLAYLOAD    2
+#define DCONSTAT_MISSED         3
+
+/* Source values */
+
+#define DCON_SOURCE_DCON        0
+#define DCON_SOURCE_CPU         1
+
+/* Interrupt */
+#define DCON_IRQ                6
+
+struct dcon_priv {
+        struct i2c_client *client;
+        struct fb_info *fbinfo;
+        struct backlight_device *bl_dev;
+
+        wait_queue_head_t waitq;
+        struct work_struct switch_source;
+        struct notifier_block reboot_nb;
+
+        /* Shadow register for the DCON_REG_MODE register */
+        u8 disp_mode;
+
+        /* The current backlight value - this saves us some smbus traffic */
+        u8 bl_val;
+
+        /* Current source, initialized at probe time */
+        int curr_src;
+
+        /* Desired source */
+        int pending_src;
+
+        /* Variables used during switches */
+        bool switched;
+        ktime_t irq_time;
+        ktime_t load_time;
+
+        /* Current output type; true == mono, false == color */
+        bool mono;
+        bool asleep;
+        /* This get set while controlling fb blank state from the driver */
+        bool ignore_fb_events;
+};
+
+struct dcon_platform_data {
+        int (*init)(struct dcon_priv *);
+        void (*bus_stabilize_wiggle)(void);
+        void (*set_dconload)(int);
+        int (*read_status)(u8 *);
+};
+
+#include <linux/interrupt.h>
+
+irqreturn_t dcon_interrupt(int irq, void *id);
+
+#ifdef CONFIG_FB_OLPC_DCON_1
+extern struct dcon_platform_data dcon_pdata_xo_1;
+#endif
+
+#ifdef CONFIG_FB_OLPC_DCON_1_5
+extern struct dcon_platform_data dcon_pdata_xo_1_5;
+#endif
+
+#endif
diff --git a/drivers/staging/olpc_dcon/olpc_dcon_xo_1.c b/drivers/staging/olpc_dcon/olpc_dcon_xo_1.c
new file mode 100644
index 000000000000..0c5a10c69401
--- /dev/null
+++ b/drivers/staging/olpc_dcon/olpc_dcon_xo_1.c
@@ -0,0 +1,205 @@
+/*
+ * Mainly by David Woodhouse, somewhat modified by Jordan Crouse
+ *
+ * Copyright © 2006-2007  Red Hat, Inc.
+ * Copyright © 2006-2007  Advanced Micro Devices, Inc.
+ * Copyright © 2009       VIA Technology, Inc.
+ * Copyright (c) 2010  Andres Salomon <dilinger@queued.net>
+ *
+ * This program is free software.  You can redistribute it and/or
+ * modify it under the terms of version 2 of the GNU General Public
+ * License as published by the Free Software Foundation.
+ */
+
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
+#include <linux/cs5535.h>
+#include <linux/gpio.h>
+#include <linux/delay.h>
+#include <asm/olpc.h>
+
+#include "olpc_dcon.h"
+
+static int dcon_init_xo_1(struct dcon_priv *dcon)
+{
+        unsigned char lob;
+
+        if (gpio_request(OLPC_GPIO_DCON_STAT0, "OLPC-DCON")) {
+                pr_err("failed to request STAT0 GPIO\n");
+                return -EIO;
+        }
+        if (gpio_request(OLPC_GPIO_DCON_STAT1, "OLPC-DCON")) {
+                pr_err("failed to request STAT1 GPIO\n");
+                goto err_gp_stat1;
+        }
+        if (gpio_request(OLPC_GPIO_DCON_IRQ, "OLPC-DCON")) {
+                pr_err("failed to request IRQ GPIO\n");
+                goto err_gp_irq;
+        }
+        if (gpio_request(OLPC_GPIO_DCON_LOAD, "OLPC-DCON")) {
+                pr_err("failed to request LOAD GPIO\n");
+                goto err_gp_load;
+        }
+        if (gpio_request(OLPC_GPIO_DCON_BLANK, "OLPC-DCON")) {
+                pr_err("failed to request BLANK GPIO\n");
+                goto err_gp_blank;
+        }
+
+        /* Turn off the event enable for GPIO7 just to be safe */
+        cs5535_gpio_clear(OLPC_GPIO_DCON_IRQ, GPIO_EVENTS_ENABLE);
+
+        /*
+         * Determine the current state by reading the GPIO bit; earlier
+         * stages of the boot process have established the state.
+         *
+         * Note that we read GPIO_OUTPUT_VAL rather than GPIO_READ_BACK here;
+         * this is because OFW will disable input for the pin and set a value..
+         * READ_BACK will only contain a valid value if input is enabled and
+         * then a value is set.  So, future readings of the pin can use
+         * READ_BACK, but the first one cannot.  Awesome, huh?
+         */
+        dcon->curr_src = cs5535_gpio_isset(OLPC_GPIO_DCON_LOAD, GPIO_OUTPUT_VAL)
+                ? DCON_SOURCE_CPU
+                : DCON_SOURCE_DCON;
+        dcon->pending_src = dcon->curr_src;
+
+        /* Set the directions for the GPIO pins */
+        gpio_direction_input(OLPC_GPIO_DCON_STAT0);
+        gpio_direction_input(OLPC_GPIO_DCON_STAT1);
+        gpio_direction_input(OLPC_GPIO_DCON_IRQ);
+        gpio_direction_input(OLPC_GPIO_DCON_BLANK);
+        gpio_direction_output(OLPC_GPIO_DCON_LOAD,
+                        dcon->curr_src == DCON_SOURCE_CPU);
+
+        /* Set up the interrupt mappings */
+
+        /* Set the IRQ to pair 2 */
+        cs5535_gpio_setup_event(OLPC_GPIO_DCON_IRQ, 2, 0);
+
+        /* Enable group 2 to trigger the DCON interrupt */
+        cs5535_gpio_set_irq(2, DCON_IRQ);
+
+        /* Select edge level for interrupt (in PIC) */
+        lob = inb(0x4d0);
+        lob &= ~(1 << DCON_IRQ);
+        outb(lob, 0x4d0);
+
+        /* Register the interrupt handler */
+        if (request_irq(DCON_IRQ, &dcon_interrupt, 0, "DCON", dcon)) {
+                pr_err("failed to request DCON's irq\n");
+                goto err_req_irq;
+        }
+
+        /* Clear INV_EN for GPIO7 (DCONIRQ) */
+        cs5535_gpio_clear(OLPC_GPIO_DCON_IRQ, GPIO_INPUT_INVERT);
+
+        /* Enable filter for GPIO12 (DCONBLANK) */
+        cs5535_gpio_set(OLPC_GPIO_DCON_BLANK, GPIO_INPUT_FILTER);
+
+        /* Disable filter for GPIO7 */
+        cs5535_gpio_clear(OLPC_GPIO_DCON_IRQ, GPIO_INPUT_FILTER);
+
+        /* Disable event counter for GPIO7 (DCONIRQ) and GPIO12 (DCONBLANK) */
+        cs5535_gpio_clear(OLPC_GPIO_DCON_IRQ, GPIO_INPUT_EVENT_COUNT);
+        cs5535_gpio_clear(OLPC_GPIO_DCON_BLANK, GPIO_INPUT_EVENT_COUNT);
+
+        /* Add GPIO12 to the Filter Event Pair #7 */
+        cs5535_gpio_set(OLPC_GPIO_DCON_BLANK, GPIO_FE7_SEL);
+
+        /* Turn off negative Edge Enable for GPIO12 */
+        cs5535_gpio_clear(OLPC_GPIO_DCON_BLANK, GPIO_NEGATIVE_EDGE_EN);
+
+        /* Enable negative Edge Enable for GPIO7 */
+        cs5535_gpio_set(OLPC_GPIO_DCON_IRQ, GPIO_NEGATIVE_EDGE_EN);
+
+        /* Zero the filter amount for Filter Event Pair #7 */
+        cs5535_gpio_set(0, GPIO_FLTR7_AMOUNT);
+
+        /* Clear the negative edge status for GPIO7 and GPIO12 */
+        cs5535_gpio_set(OLPC_GPIO_DCON_IRQ, GPIO_NEGATIVE_EDGE_STS);
+        cs5535_gpio_set(OLPC_GPIO_DCON_BLANK, GPIO_NEGATIVE_EDGE_STS);
+
+        /* FIXME:  Clear the positive status as well, just to be sure */
+        cs5535_gpio_set(OLPC_GPIO_DCON_IRQ, GPIO_POSITIVE_EDGE_STS);
+        cs5535_gpio_set(OLPC_GPIO_DCON_BLANK, GPIO_POSITIVE_EDGE_STS);
+
+        /* Enable events for GPIO7 (DCONIRQ) and GPIO12 (DCONBLANK) */
+        cs5535_gpio_set(OLPC_GPIO_DCON_IRQ, GPIO_EVENTS_ENABLE);
+        cs5535_gpio_set(OLPC_GPIO_DCON_BLANK, GPIO_EVENTS_ENABLE);
+
+        return 0;
+
+err_req_irq:
+        gpio_free(OLPC_GPIO_DCON_BLANK);
+err_gp_blank:
+        gpio_free(OLPC_GPIO_DCON_LOAD);
+err_gp_load:
+        gpio_free(OLPC_GPIO_DCON_IRQ);
+err_gp_irq:
+        gpio_free(OLPC_GPIO_DCON_STAT1);
+err_gp_stat1:
+        gpio_free(OLPC_GPIO_DCON_STAT0);
+        return -EIO;
+}
+
+static void dcon_wiggle_xo_1(void)
+{
+        int x;
+
+        /*
+         * According to HiMax, when powering the DCON up we should hold
+         * SMB_DATA high for 8 SMB_CLK cycles.  This will force the DCON
+         * state machine to reset to a (sane) initial state.  Mitch Bradley
+         * did some testing and discovered that holding for 16 SMB_CLK cycles
+         * worked a lot more reliably, so that's what we do here.
+         *
+         * According to the cs5536 spec, to set GPIO14 to SMB_CLK we must
+         * simultaneously set AUX1 IN/OUT to GPIO14; ditto for SMB_DATA and
+         * GPIO15.
+         */
+        cs5535_gpio_set(OLPC_GPIO_SMB_CLK, GPIO_OUTPUT_VAL);
+        cs5535_gpio_set(OLPC_GPIO_SMB_DATA, GPIO_OUTPUT_VAL);
+        cs5535_gpio_set(OLPC_GPIO_SMB_CLK, GPIO_OUTPUT_ENABLE);
+        cs5535_gpio_set(OLPC_GPIO_SMB_DATA, GPIO_OUTPUT_ENABLE);
+        cs5535_gpio_clear(OLPC_GPIO_SMB_CLK, GPIO_OUTPUT_AUX1);
+        cs5535_gpio_clear(OLPC_GPIO_SMB_DATA, GPIO_OUTPUT_AUX1);
+        cs5535_gpio_clear(OLPC_GPIO_SMB_CLK, GPIO_OUTPUT_AUX2);
+        cs5535_gpio_clear(OLPC_GPIO_SMB_DATA, GPIO_OUTPUT_AUX2);
+        cs5535_gpio_clear(OLPC_GPIO_SMB_CLK, GPIO_INPUT_AUX1);
+        cs5535_gpio_clear(OLPC_GPIO_SMB_DATA, GPIO_INPUT_AUX1);
+
+        for (x = 0; x < 16; x++) {
+                udelay(5);
+                cs5535_gpio_clear(OLPC_GPIO_SMB_CLK, GPIO_OUTPUT_VAL);
+                udelay(5);
+                cs5535_gpio_set(OLPC_GPIO_SMB_CLK, GPIO_OUTPUT_VAL);
+        }
+        udelay(5);
+        cs5535_gpio_set(OLPC_GPIO_SMB_CLK, GPIO_OUTPUT_AUX1);
+        cs5535_gpio_set(OLPC_GPIO_SMB_DATA, GPIO_OUTPUT_AUX1);
+        cs5535_gpio_set(OLPC_GPIO_SMB_CLK, GPIO_INPUT_AUX1);
+        cs5535_gpio_set(OLPC_GPIO_SMB_DATA, GPIO_INPUT_AUX1);
+}
+
+static void dcon_set_dconload_1(int val)
+{
+        gpio_set_value(OLPC_GPIO_DCON_LOAD, val);
+}
+
+static int dcon_read_status_xo_1(u8 *status)
+{
+        *status = gpio_get_value(OLPC_GPIO_DCON_STAT0);
+        *status |= gpio_get_value(OLPC_GPIO_DCON_STAT1) << 1;
+
+        /* Clear the negative edge status for GPIO7 */
+        cs5535_gpio_set(OLPC_GPIO_DCON_IRQ, GPIO_NEGATIVE_EDGE_STS);
+
+        return 0;
+}
+
+struct dcon_platform_data dcon_pdata_xo_1 = {
+        .init = dcon_init_xo_1,
+        .bus_stabilize_wiggle = dcon_wiggle_xo_1,
+        .set_dconload = dcon_set_dconload_1,
+        .read_status = dcon_read_status_xo_1,
+};
diff --git a/drivers/staging/olpc_dcon/olpc_dcon_xo_1_5.c b/drivers/staging/olpc_dcon/olpc_dcon_xo_1_5.c
new file mode 100644
index 000000000000..6a4d379c16a3
--- /dev/null
+++ b/drivers/staging/olpc_dcon/olpc_dcon_xo_1_5.c
@@ -0,0 +1,161 @@
+/*
+ * Copyright (c) 2009,2010       One Laptop per Child
+ *
+ * This program is free software.  You can redistribute it and/or
+ * modify it under the terms of version 2 of the GNU General Public
+ * License as published by the Free Software Foundation.
+ */
+
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
+#include <linux/acpi.h>
+#include <linux/delay.h>
+#include <linux/gpio.h>
+#include <asm/olpc.h>
+
+/* TODO: this eventually belongs in linux/vx855.h */
+#define NR_VX855_GPI    14
+#define NR_VX855_GPO    13
+#define NR_VX855_GPIO   15
+
+#define VX855_GPI(n)    (n)
+#define VX855_GPO(n)    (NR_VX855_GPI + (n))
+#define VX855_GPIO(n)   (NR_VX855_GPI + NR_VX855_GPO + (n))
+
+#include "olpc_dcon.h"
+
+/* Hardware setup on the XO 1.5:
+ *      DCONLOAD connects to VX855_GPIO1 (not SMBCK2)
+ *      DCONBLANK connects to VX855_GPIO8 (not SSPICLK)  unused in driver
+ *      DCONSTAT0 connects to VX855_GPI10 (not SSPISDI)
+ *      DCONSTAT1 connects to VX855_GPI11 (not nSSPISS)
+ *      DCONIRQ connects to VX855_GPIO12
+ *      DCONSMBDATA connects to VX855 graphics CRTSPD
+ *      DCONSMBCLK connects to VX855 graphics CRTSPCLK
+ */
+
+#define VX855_GENL_PURPOSE_OUTPUT 0x44c /* PMIO_Rx4c-4f */
+#define VX855_GPI_STATUS_CHG 0x450  /* PMIO_Rx50 */
+#define VX855_GPI_SCI_SMI 0x452  /* PMIO_Rx52 */
+#define BIT_GPIO12 0x40
+
+#define PREFIX "OLPC DCON:"
+
+static void dcon_clear_irq(void)
+{
+        /* irq status will appear in PMIO_Rx50[6] (RW1C) on gpio12 */
+        outb(BIT_GPIO12, VX855_GPI_STATUS_CHG);
+}
+
+static int dcon_was_irq(void)
+{
+        u_int8_t tmp;
+
+        /* irq status will appear in PMIO_Rx50[6] on gpio12 */
+        tmp = inb(VX855_GPI_STATUS_CHG);
+        return !!(tmp & BIT_GPIO12);
+
+        return 0;
+}
+
+static int dcon_init_xo_1_5(struct dcon_priv *dcon)
+{
+        unsigned int irq;
+
+        dcon_clear_irq();
+
+        /* set   PMIO_Rx52[6] to enable SCI/SMI on gpio12 */
+        outb(inb(VX855_GPI_SCI_SMI)|BIT_GPIO12, VX855_GPI_SCI_SMI);
+
+        /* Determine the current state of DCONLOAD, likely set by firmware */
+        /* GPIO1 */
+        dcon->curr_src = (inl(VX855_GENL_PURPOSE_OUTPUT) & 0x1000) ?
+                        DCON_SOURCE_CPU : DCON_SOURCE_DCON;
+        dcon->pending_src = dcon->curr_src;
+
+        /* we're sharing the IRQ with ACPI */
+        irq = acpi_gbl_FADT.sci_interrupt;
+        if (request_irq(irq, &dcon_interrupt, IRQF_SHARED, "DCON", dcon)) {
+                pr_err("DCON (IRQ%d) allocation failed\n", irq);
+                return 1;
+        }
+
+        return 0;
+}
+
+static void set_i2c_line(int sda, int scl)
+{
+        unsigned char tmp;
+        unsigned int port = 0x26;
+
+        /* FIXME: This directly accesses the CRT GPIO controller !!! */
+        outb(port, 0x3c4);
+        tmp = inb(0x3c5);
+
+        if (scl)
+                tmp |= 0x20;
+        else
+                tmp &= ~0x20;
+
+        if (sda)
+                tmp |= 0x10;
+        else
+                tmp &= ~0x10;
+
+        tmp |= 0x01;
+
+        outb(port, 0x3c4);
+        outb(tmp, 0x3c5);
+}
+
+
+static void dcon_wiggle_xo_1_5(void)
+{
+        int x;
+
+        /*
+         * According to HiMax, when powering the DCON up we should hold
+         * SMB_DATA high for 8 SMB_CLK cycles.  This will force the DCON
+         * state machine to reset to a (sane) initial state.  Mitch Bradley
+         * did some testing and discovered that holding for 16 SMB_CLK cycles
+         * worked a lot more reliably, so that's what we do here.
+         */
+        set_i2c_line(1, 1);
+
+        for (x = 0; x < 16; x++) {
+                udelay(5);
+                set_i2c_line(1, 0);
+                udelay(5);
+                set_i2c_line(1, 1);
+        }
+        udelay(5);
+
+        /* set   PMIO_Rx52[6] to enable SCI/SMI on gpio12 */
+        outb(inb(VX855_GPI_SCI_SMI)|BIT_GPIO12, VX855_GPI_SCI_SMI);
+}
+
+static void dcon_set_dconload_xo_1_5(int val)
+{
+        gpio_set_value(VX855_GPIO(1), val);
+}
+
+static int dcon_read_status_xo_1_5(u8 *status)
+{
+        if (!dcon_was_irq())
+                return -1;
+
+        /* i believe this is the same as "inb(0x44b) & 3" */
+        *status = gpio_get_value(VX855_GPI(10));
+        *status |= gpio_get_value(VX855_GPI(11)) << 1;
+
+        dcon_clear_irq();
+
+        return 0;
+}
+
+struct dcon_platform_data dcon_pdata_xo_1_5 = {
+        .init = dcon_init_xo_1_5,
+        .bus_stabilize_wiggle = dcon_wiggle_xo_1_5,
+        .set_dconload = dcon_set_dconload_xo_1_5,
+        .read_status = dcon_read_status_xo_1_5,
+};
diff --git a/drivers/staging/rdma/hfi1/Kconfig b/drivers/staging/rdma/hfi1/Kconfig
index 3e668d852f03..a925fb0db706 100644
--- a/drivers/staging/rdma/hfi1/Kconfig
+++ b/drivers/staging/rdma/hfi1/Kconfig
@@ -2,6 +2,7 @@ config INFINIBAND_HFI1
         tristate "Intel OPA Gen1 support"
         depends on X86_64 && INFINIBAND_RDMAVT
         select MMU_NOTIFIER
+        select CRC32
         default m
         ---help---
         This is a low-level driver for Intel OPA Gen1 adapter.
diff --git a/drivers/staging/rdma/hfi1/TODO b/drivers/staging/rdma/hfi1/TODO
index 05de0dad8762..4c6f1d7d2eaf 100644
--- a/drivers/staging/rdma/hfi1/TODO
+++ b/drivers/staging/rdma/hfi1/TODO
@@ -3,4 +3,4 @@ July, 2015
 - Remove unneeded file entries in sysfs
 - Remove software processing of IB protocol and place in library for use
   by qib, ipath (if still present), hfi1, and eventually soft-roce
-
+- Replace incorrect uAPI
diff --git a/drivers/staging/rdma/hfi1/file_ops.c b/drivers/staging/rdma/hfi1/file_ops.c
index 8396dc5fb6c1..c1c5bf82addb 100644
--- a/drivers/staging/rdma/hfi1/file_ops.c
+++ b/drivers/staging/rdma/hfi1/file_ops.c
@@ -49,6 +49,8 @@
 #include <linux/vmalloc.h>
 #include <linux/io.h>
 
+#include <rdma/ib.h>
+
 #include "hfi.h"
 #include "pio.h"
 #include "device.h"
@@ -190,6 +192,10 @@ static ssize_t hfi1_file_write(struct file *fp, const char __user *data,
         int uctxt_required = 1;
         int must_be_root = 0;
 
+        /* FIXME: This interface cannot continue out of staging */
+        if (WARN_ON_ONCE(!ib_safe_file_access(fp)))
+                return -EACCES;
+
         if (count < sizeof(cmd)) {
                 ret = -EINVAL;
                 goto bail;
@@ -791,15 +797,16 @@ static int hfi1_file_close(struct inode *inode, struct file *fp)
         spin_unlock_irqrestore(&dd->uctxt_lock, flags);
 
         dd->rcd[uctxt->ctxt] = NULL;
+
+        hfi1_user_exp_rcv_free(fdata);
+        hfi1_clear_ctxt_pkey(dd, uctxt->ctxt);
+
         uctxt->rcvwait_to = 0;
         uctxt->piowait_to = 0;
         uctxt->rcvnowait = 0;
         uctxt->pionowait = 0;
         uctxt->event_flags = 0;
 
-        hfi1_user_exp_rcv_free(fdata);
-        hfi1_clear_ctxt_pkey(dd, uctxt->ctxt);
-
         hfi1_stats.sps_ctxts--;
         if (++dd->freectxts == dd->num_user_contexts)
                 aspm_enable_all(dd);
@@ -1127,27 +1134,13 @@ bail:
 
 static int user_init(struct file *fp)
 {
-        int ret;
         unsigned int rcvctrl_ops = 0;
         struct hfi1_filedata *fd = fp->private_data;
         struct hfi1_ctxtdata *uctxt = fd->uctxt;
 
         /* make sure that the context has already been setup */
-        if (!test_bit(HFI1_CTXT_SETUP_DONE, &uctxt->event_flags)) {
-                ret = -EFAULT;
-                goto done;
-        }
-
-        /*
-         * Subctxts don't need to initialize anything since master
-         * has done it.
-         */
-        if (fd->subctxt) {
-                ret = wait_event_interruptible(uctxt->wait, !test_bit(
-                                               HFI1_CTXT_MASTER_UNINIT,
-                                               &uctxt->event_flags));
-                goto expected;
-        }
+        if (!test_bit(HFI1_CTXT_SETUP_DONE, &uctxt->event_flags))
+                return -EFAULT;
 
         /* initialize poll variables... */
         uctxt->urgent = 0;
@@ -1202,19 +1195,7 @@ static int user_init(struct file *fp)
                 wake_up(&uctxt->wait);
         }
 
-expected:
-        /*
-         * Expected receive has to be setup for all processes (including
-         * shared contexts). However, it has to be done after the master
-         * context has been fully configured as it depends on the
-         * eager/expected split of the RcvArray entries.
-         * Setting it up here ensures that the subcontexts will be waiting
-         * (due to the above wait_event_interruptible() until the master
-         * is setup.
-         */
-        ret = hfi1_user_exp_rcv_init(fp);
-done:
-        return ret;
+        return 0;
 }
 
 static int get_ctxt_info(struct file *fp, void __user *ubase, __u32 len)
@@ -1261,7 +1242,7 @@ static int setup_ctxt(struct file *fp)
         int ret = 0;
 
         /*
-         * Context should be set up only once (including allocation and
+         * Context should be set up only once, including allocation and
          * programming of eager buffers. This is done if context sharing
          * is not requested or by the master process.
          */
@@ -1282,10 +1263,29 @@ static int setup_ctxt(struct file *fp)
                         if (ret)
                                 goto done;
                 }
+        } else {
+                ret = wait_event_interruptible(uctxt->wait, !test_bit(
+                                               HFI1_CTXT_MASTER_UNINIT,
+                                               &uctxt->event_flags));
+                if (ret)
+                        goto done;
         }
+
         ret = hfi1_user_sdma_alloc_queues(uctxt, fp);
         if (ret)
                 goto done;
+        /*
+         * Expected receive has to be setup for all processes (including
+         * shared contexts). However, it has to be done after the master
+         * context has been fully configured as it depends on the
+         * eager/expected split of the RcvArray entries.
+         * Setting it up here ensures that the subcontexts will be waiting
+         * (due to the above wait_event_interruptible() until the master
+         * is setup.
+         */
+        ret = hfi1_user_exp_rcv_init(fp);
+        if (ret)
+                goto done;
 
         set_bit(HFI1_CTXT_SETUP_DONE, &uctxt->event_flags);
 done:
@@ -1565,29 +1565,8 @@ static loff_t ui_lseek(struct file *filp, loff_t offset, int whence)
 {
         struct hfi1_devdata *dd = filp->private_data;
 
-        switch (whence) {
-        case SEEK_SET:
-                break;
-        case SEEK_CUR:
-                offset += filp->f_pos;
-                break;
-        case SEEK_END:
-                offset = ((dd->kregend - dd->kregbase) + DC8051_DATA_MEM_SIZE) -
-                        offset;
-                break;
-        default:
-                return -EINVAL;
-        }
-
-        if (offset < 0)
-                return -EINVAL;
-
-        if (offset >= (dd->kregend - dd->kregbase) + DC8051_DATA_MEM_SIZE)
-                return -EINVAL;
-
-        filp->f_pos = offset;
-
-        return filp->f_pos;
+        return fixed_size_llseek(filp, offset, whence,
+                (dd->kregend - dd->kregbase) + DC8051_DATA_MEM_SIZE);
 }
 
 /* NOTE: assumes unsigned long is 8 bytes */
diff --git a/drivers/staging/rdma/hfi1/mmu_rb.c b/drivers/staging/rdma/hfi1/mmu_rb.c
index c7ad0164ea9a..b3f0682a36c9 100644
--- a/drivers/staging/rdma/hfi1/mmu_rb.c
+++ b/drivers/staging/rdma/hfi1/mmu_rb.c
@@ -71,6 +71,7 @@ static inline void mmu_notifier_range_start(struct mmu_notifier *,
                                             struct mm_struct *,
                                             unsigned long, unsigned long);
 static void mmu_notifier_mem_invalidate(struct mmu_notifier *,
+                                        struct mm_struct *,
                                         unsigned long, unsigned long);
 static struct mmu_rb_node *__mmu_rb_search(struct mmu_rb_handler *,
                                            unsigned long, unsigned long);
@@ -137,7 +138,7 @@ void hfi1_mmu_rb_unregister(struct rb_root *root)
                         rbnode = rb_entry(node, struct mmu_rb_node, node);
                         rb_erase(node, root);
                         if (handler->ops->remove)
-                                handler->ops->remove(root, rbnode, false);
+                                handler->ops->remove(root, rbnode, NULL);
                 }
         }
 
@@ -176,7 +177,7 @@ unlock:
         return ret;
 }
 
-/* Caller must host handler lock */
+/* Caller must hold handler lock */
 static struct mmu_rb_node *__mmu_rb_search(struct mmu_rb_handler *handler,
                                            unsigned long addr,
                                            unsigned long len)
@@ -200,15 +201,21 @@ static struct mmu_rb_node *__mmu_rb_search(struct mmu_rb_handler *handler,
         return node;
 }
 
+/* Caller must *not* hold handler lock. */
 static void __mmu_rb_remove(struct mmu_rb_handler *handler,
-                            struct mmu_rb_node *node, bool arg)
+                            struct mmu_rb_node *node, struct mm_struct *mm)
 {
+        unsigned long flags;
+
         /* Validity of handler and node pointers has been checked by caller. */
         hfi1_cdbg(MMU, "Removing node addr 0x%llx, len %u", node->addr,
                   node->len);
+        spin_lock_irqsave(&handler->lock, flags);
         __mmu_int_rb_remove(node, handler->root);
+        spin_unlock_irqrestore(&handler->lock, flags);
+
         if (handler->ops->remove)
-                handler->ops->remove(handler->root, node, arg);
+                handler->ops->remove(handler->root, node, mm);
 }
 
 struct mmu_rb_node *hfi1_mmu_rb_search(struct rb_root *root, unsigned long addr,
@@ -231,14 +238,11 @@ struct mmu_rb_node *hfi1_mmu_rb_search(struct rb_root *root, unsigned long addr,
 void hfi1_mmu_rb_remove(struct rb_root *root, struct mmu_rb_node *node)
 {
         struct mmu_rb_handler *handler = find_mmu_handler(root);
-        unsigned long flags;
 
         if (!handler || !node)
                 return;
 
-        spin_lock_irqsave(&handler->lock, flags);
-        __mmu_rb_remove(handler, node, false);
-        spin_unlock_irqrestore(&handler->lock, flags);
+        __mmu_rb_remove(handler, node, NULL);
 }
 
 static struct mmu_rb_handler *find_mmu_handler(struct rb_root *root)
@@ -260,7 +264,7 @@ unlock:
 static inline void mmu_notifier_page(struct mmu_notifier *mn,
                                      struct mm_struct *mm, unsigned long addr)
 {
-        mmu_notifier_mem_invalidate(mn, addr, addr + PAGE_SIZE);
+        mmu_notifier_mem_invalidate(mn, mm, addr, addr + PAGE_SIZE);
 }
 
 static inline void mmu_notifier_range_start(struct mmu_notifier *mn,
@@ -268,25 +272,31 @@ static inline void mmu_notifier_range_start(struct mmu_notifier *mn,
                                             unsigned long start,
                                             unsigned long end)
 {
-        mmu_notifier_mem_invalidate(mn, start, end);
+        mmu_notifier_mem_invalidate(mn, mm, start, end);
 }
 
 static void mmu_notifier_mem_invalidate(struct mmu_notifier *mn,
+                                        struct mm_struct *mm,
                                         unsigned long start, unsigned long end)
 {
         struct mmu_rb_handler *handler =
                 container_of(mn, struct mmu_rb_handler, mn);
         struct rb_root *root = handler->root;
-        struct mmu_rb_node *node;
+        struct mmu_rb_node *node, *ptr = NULL;
         unsigned long flags;
 
         spin_lock_irqsave(&handler->lock, flags);
-        for (node = __mmu_int_rb_iter_first(root, start, end - 1); node;
-             node = __mmu_int_rb_iter_next(node, start, end - 1)) {
+        for (node = __mmu_int_rb_iter_first(root, start, end - 1);
+             node; node = ptr) {
+                /* Guard against node removal. */
+                ptr = __mmu_int_rb_iter_next(node, start, end - 1);
                 hfi1_cdbg(MMU, "Invalidating node addr 0x%llx, len %u",
                           node->addr, node->len);
-                if (handler->ops->invalidate(root, node))
-                        __mmu_rb_remove(handler, node, true);
+                if (handler->ops->invalidate(root, node)) {
+                        spin_unlock_irqrestore(&handler->lock, flags);
+                        __mmu_rb_remove(handler, node, mm);
+                        spin_lock_irqsave(&handler->lock, flags);
+                }
         }
         spin_unlock_irqrestore(&handler->lock, flags);
 }
diff --git a/drivers/staging/rdma/hfi1/mmu_rb.h b/drivers/staging/rdma/hfi1/mmu_rb.h
index f8523fdb8a18..19a306e83c7d 100644
--- a/drivers/staging/rdma/hfi1/mmu_rb.h
+++ b/drivers/staging/rdma/hfi1/mmu_rb.h
@@ -59,7 +59,8 @@ struct mmu_rb_node {
 struct mmu_rb_ops {
         bool (*filter)(struct mmu_rb_node *, unsigned long, unsigned long);
         int (*insert)(struct rb_root *, struct mmu_rb_node *);
-        void (*remove)(struct rb_root *, struct mmu_rb_node *, bool);
+        void (*remove)(struct rb_root *, struct mmu_rb_node *,
+                       struct mm_struct *);
         int (*invalidate)(struct rb_root *, struct mmu_rb_node *);
 };
 
diff --git a/drivers/staging/rdma/hfi1/qp.c b/drivers/staging/rdma/hfi1/qp.c
index 29a5ad28019b..dc9119e1b458 100644
--- a/drivers/staging/rdma/hfi1/qp.c
+++ b/drivers/staging/rdma/hfi1/qp.c
@@ -519,10 +519,12 @@ static void iowait_sdma_drained(struct iowait *wait)
          * do the flush work until that QP's
          * sdma work has finished.
          */
+        spin_lock(&qp->s_lock);
         if (qp->s_flags & RVT_S_WAIT_DMA) {
                 qp->s_flags &= ~RVT_S_WAIT_DMA;
                 hfi1_schedule_send(qp);
         }
+        spin_unlock(&qp->s_lock);
 }
 
 /**
diff --git a/drivers/staging/rdma/hfi1/user_exp_rcv.c b/drivers/staging/rdma/hfi1/user_exp_rcv.c
index 0861e095df8d..8bd56d5c783d 100644
--- a/drivers/staging/rdma/hfi1/user_exp_rcv.c
+++ b/drivers/staging/rdma/hfi1/user_exp_rcv.c
@@ -87,7 +87,8 @@ static u32 find_phys_blocks(struct page **, unsigned, struct tid_pageset *);
 static int set_rcvarray_entry(struct file *, unsigned long, u32,
                               struct tid_group *, struct page **, unsigned);
 static int mmu_rb_insert(struct rb_root *, struct mmu_rb_node *);
-static void mmu_rb_remove(struct rb_root *, struct mmu_rb_node *, bool);
+static void mmu_rb_remove(struct rb_root *, struct mmu_rb_node *,
+                          struct mm_struct *);
 static int mmu_rb_invalidate(struct rb_root *, struct mmu_rb_node *);
 static int program_rcvarray(struct file *, unsigned long, struct tid_group *,
                             struct tid_pageset *, unsigned, u16, struct page **,
@@ -254,6 +255,8 @@ int hfi1_user_exp_rcv_free(struct hfi1_filedata *fd)
         struct hfi1_ctxtdata *uctxt = fd->uctxt;
         struct tid_group *grp, *gptr;
 
+        if (!test_bit(HFI1_CTXT_SETUP_DONE, &uctxt->event_flags))
+                return 0;
         /*
          * The notifier would have been removed when the process'es mm
          * was freed.
@@ -899,7 +902,7 @@ static int unprogram_rcvarray(struct file *fp, u32 tidinfo,
         if (!node || node->rcventry != (uctxt->expected_base + rcventry))
                 return -EBADF;
         if (HFI1_CAP_IS_USET(TID_UNMAP))
-                mmu_rb_remove(&fd->tid_rb_root, &node->mmu, false);
+                mmu_rb_remove(&fd->tid_rb_root, &node->mmu, NULL);
         else
                 hfi1_mmu_rb_remove(&fd->tid_rb_root, &node->mmu);
 
@@ -965,7 +968,7 @@ static void unlock_exp_tids(struct hfi1_ctxtdata *uctxt,
                                         continue;
                                 if (HFI1_CAP_IS_USET(TID_UNMAP))
                                         mmu_rb_remove(&fd->tid_rb_root,
-                                                      &node->mmu, false);
+                                                      &node->mmu, NULL);
                                 else
                                         hfi1_mmu_rb_remove(&fd->tid_rb_root,
                                                            &node->mmu);
@@ -1032,7 +1035,7 @@ static int mmu_rb_insert(struct rb_root *root, struct mmu_rb_node *node)
 }
 
 static void mmu_rb_remove(struct rb_root *root, struct mmu_rb_node *node,
-                          bool notifier)
+                          struct mm_struct *mm)
 {
         struct hfi1_filedata *fdata =
                 container_of(root, struct hfi1_filedata, tid_rb_root);
diff --git a/drivers/staging/rdma/hfi1/user_sdma.c b/drivers/staging/rdma/hfi1/user_sdma.c
index ab6b6a42000f..d53a659548e0 100644
--- a/drivers/staging/rdma/hfi1/user_sdma.c
+++ b/drivers/staging/rdma/hfi1/user_sdma.c
@@ -278,7 +278,8 @@ static inline void pq_update(struct hfi1_user_sdma_pkt_q *);
 static void user_sdma_free_request(struct user_sdma_request *, bool);
 static int pin_vector_pages(struct user_sdma_request *,
                             struct user_sdma_iovec *);
-static void unpin_vector_pages(struct mm_struct *, struct page **, unsigned);
+static void unpin_vector_pages(struct mm_struct *, struct page **, unsigned,
+                               unsigned);
 static int check_header_template(struct user_sdma_request *,
                                  struct hfi1_pkt_header *, u32, u32);
 static int set_txreq_header(struct user_sdma_request *,
@@ -299,7 +300,8 @@ static int defer_packet_queue(
 static void activate_packet_queue(struct iowait *, int);
 static bool sdma_rb_filter(struct mmu_rb_node *, unsigned long, unsigned long);
 static int sdma_rb_insert(struct rb_root *, struct mmu_rb_node *);
-static void sdma_rb_remove(struct rb_root *, struct mmu_rb_node *, bool);
+static void sdma_rb_remove(struct rb_root *, struct mmu_rb_node *,
+                           struct mm_struct *);
 static int sdma_rb_invalidate(struct rb_root *, struct mmu_rb_node *);
 
 static struct mmu_rb_ops sdma_rb_ops = {
@@ -1063,8 +1065,10 @@ static int pin_vector_pages(struct user_sdma_request *req,
         rb_node = hfi1_mmu_rb_search(&pq->sdma_rb_root,
                                      (unsigned long)iovec->iov.iov_base,
                                      iovec->iov.iov_len);
-        if (rb_node)
+        if (rb_node && !IS_ERR(rb_node))
                 node = container_of(rb_node, struct sdma_mmu_node, rb);
+        else
+                rb_node = NULL;
 
         if (!node) {
                 node = kzalloc(sizeof(*node), GFP_KERNEL);
@@ -1107,7 +1111,8 @@ retry:
                         goto bail;
                 }
                 if (pinned != npages) {
-                        unpin_vector_pages(current->mm, pages, pinned);
+                        unpin_vector_pages(current->mm, pages, node->npages,
+                                           pinned);
                         ret = -EFAULT;
                         goto bail;
                 }
@@ -1147,9 +1152,9 @@ bail:
 }
 
 static void unpin_vector_pages(struct mm_struct *mm, struct page **pages,
-                               unsigned npages)
+                               unsigned start, unsigned npages)
 {
-        hfi1_release_user_pages(mm, pages, npages, 0);
+        hfi1_release_user_pages(mm, pages + start, npages, 0);
         kfree(pages);
 }
 
@@ -1502,7 +1507,7 @@ static void user_sdma_free_request(struct user_sdma_request *req, bool unpin)
                                 &req->pq->sdma_rb_root,
                                 (unsigned long)req->iovs[i].iov.iov_base,
                                 req->iovs[i].iov.iov_len);
-                        if (!mnode)
+                        if (!mnode || IS_ERR(mnode))
                                 continue;
 
                         node = container_of(mnode, struct sdma_mmu_node, rb);
@@ -1547,7 +1552,7 @@ static int sdma_rb_insert(struct rb_root *root, struct mmu_rb_node *mnode)
 }
 
 static void sdma_rb_remove(struct rb_root *root, struct mmu_rb_node *mnode,
-                           bool notifier)
+                           struct mm_struct *mm)
 {
         struct sdma_mmu_node *node =
                 container_of(mnode, struct sdma_mmu_node, rb);
@@ -1557,14 +1562,20 @@ static void sdma_rb_remove(struct rb_root *root, struct mmu_rb_node *mnode,
         node->pq->n_locked -= node->npages;
         spin_unlock(&node->pq->evict_lock);
 
-        unpin_vector_pages(notifier ? NULL : current->mm, node->pages,
+        /*
+         * If mm is set, we are being called by the MMU notifier and we
+         * should not pass a mm_struct to unpin_vector_page(). This is to
+         * prevent a deadlock when hfi1_release_user_pages() attempts to
+         * take the mmap_sem, which the MMU notifier has already taken.
+         */
+        unpin_vector_pages(mm ? NULL : current->mm, node->pages, 0,
                            node->npages);
         /*
          * If called by the MMU notifier, we have to adjust the pinned
          * page count ourselves.
          */
-        if (notifier)
-                current->mm->pinned_vm -= node->npages;
+        if (mm)
+                mm->pinned_vm -= node->npages;
         kfree(node);
 }
 
diff --git a/drivers/target/iscsi/iscsi_target_configfs.c b/drivers/target/iscsi/iscsi_target_configfs.c
index a24443ba59ea..97e5b69e0668 100644
--- a/drivers/target/iscsi/iscsi_target_configfs.c
+++ b/drivers/target/iscsi/iscsi_target_configfs.c
@@ -779,14 +779,6 @@ static int lio_target_init_nodeacl(struct se_node_acl *se_nacl,
         return 0;
 }
 
-static void lio_target_cleanup_nodeacl( struct se_node_acl *se_nacl)
-{
-        struct iscsi_node_acl *acl = container_of(se_nacl,
-                        struct iscsi_node_acl, se_node_acl);
-
-        configfs_remove_default_groups(&acl->se_node_acl.acl_fabric_stat_group);
-}
-
 /* End items for lio_target_acl_cit */
 
 /* Start items for lio_target_tpg_attrib_cit */
@@ -1247,6 +1239,16 @@ static struct se_wwn *lio_target_call_coreaddtiqn(
         if (IS_ERR(tiqn))
                 return ERR_CAST(tiqn);
 
+        pr_debug("LIO_Target_ConfigFS: REGISTER -> %s\n", tiqn->tiqn);
+        pr_debug("LIO_Target_ConfigFS: REGISTER -> Allocated Node:"
+                        " %s\n", name);
+        return &tiqn->tiqn_wwn;
+}
+
+static void lio_target_add_wwn_groups(struct se_wwn *wwn)
+{
+        struct iscsi_tiqn *tiqn = container_of(wwn, struct iscsi_tiqn, tiqn_wwn);
+
         config_group_init_type_name(&tiqn->tiqn_stat_grps.iscsi_instance_group,
                         "iscsi_instance", &iscsi_stat_instance_cit);
         configfs_add_default_group(&tiqn->tiqn_stat_grps.iscsi_instance_group,
@@ -1271,12 +1273,6 @@ static struct se_wwn *lio_target_call_coreaddtiqn(
                         "iscsi_logout_stats", &iscsi_stat_logout_cit);
         configfs_add_default_group(&tiqn->tiqn_stat_grps.iscsi_logout_stats_group,
                         &tiqn->tiqn_wwn.fabric_stat_group);
-
-
-        pr_debug("LIO_Target_ConfigFS: REGISTER -> %s\n", tiqn->tiqn);
-        pr_debug("LIO_Target_ConfigFS: REGISTER -> Allocated Node:"
-                        " %s\n", name);
-        return &tiqn->tiqn_wwn;
 }
 
 static void lio_target_call_coredeltiqn(
@@ -1284,8 +1280,6 @@ static void lio_target_call_coredeltiqn(
 {
         struct iscsi_tiqn *tiqn = container_of(wwn, struct iscsi_tiqn, tiqn_wwn);
 
-        configfs_remove_default_groups(&tiqn->tiqn_wwn.fabric_stat_group);
-
         pr_debug("LIO_Target_ConfigFS: DEREGISTER -> %s\n",
                         tiqn->tiqn);
         iscsit_del_tiqn(tiqn);
@@ -1660,12 +1654,12 @@ const struct target_core_fabric_ops iscsi_ops = {
         .aborted_task                   = lio_aborted_task,
         .fabric_make_wwn                = lio_target_call_coreaddtiqn,
         .fabric_drop_wwn                = lio_target_call_coredeltiqn,
+        .add_wwn_groups                 = lio_target_add_wwn_groups,
         .fabric_make_tpg                = lio_target_tiqn_addtpg,
         .fabric_drop_tpg                = lio_target_tiqn_deltpg,
         .fabric_make_np                 = lio_target_call_addnptotpg,
         .fabric_drop_np                 = lio_target_call_delnpfromtpg,
         .fabric_init_nodeacl            = lio_target_init_nodeacl,
-        .fabric_cleanup_nodeacl         = lio_target_cleanup_nodeacl,
 
         .tfc_discovery_attrs            = lio_target_discovery_auth_attrs,
         .tfc_wwn_attrs                  = lio_target_wwn_attrs,
diff --git a/drivers/target/target_core_fabric_configfs.c b/drivers/target/target_core_fabric_configfs.c
index 1bd5c72b663e..31a096aa16ab 100644
--- a/drivers/target/target_core_fabric_configfs.c
+++ b/drivers/target/target_core_fabric_configfs.c
@@ -338,10 +338,8 @@ static void target_fabric_nacl_base_release(struct config_item *item)
 {
         struct se_node_acl *se_nacl = container_of(to_config_group(item),
                         struct se_node_acl, acl_group);
-        struct target_fabric_configfs *tf = se_nacl->se_tpg->se_tpg_wwn->wwn_tf;
 
-        if (tf->tf_ops->fabric_cleanup_nodeacl)
-                tf->tf_ops->fabric_cleanup_nodeacl(se_nacl);
+        configfs_remove_default_groups(&se_nacl->acl_fabric_stat_group);
         core_tpg_del_initiator_node_acl(se_nacl);
 }
 
@@ -383,14 +381,6 @@ static struct config_group *target_fabric_make_nodeacl(
         if (IS_ERR(se_nacl))
                 return ERR_CAST(se_nacl);
 
-        if (tf->tf_ops->fabric_init_nodeacl) {
-                int ret = tf->tf_ops->fabric_init_nodeacl(se_nacl, name);
-                if (ret) {
-                        core_tpg_del_initiator_node_acl(se_nacl);
-                        return ERR_PTR(ret);
-                }
-        }
-
         config_group_init_type_name(&se_nacl->acl_group, name,
                         &tf->tf_tpg_nacl_base_cit);
 
@@ -414,6 +404,15 @@ static struct config_group *target_fabric_make_nodeacl(
         configfs_add_default_group(&se_nacl->acl_fabric_stat_group,
                         &se_nacl->acl_group);
 
+        if (tf->tf_ops->fabric_init_nodeacl) {
+                int ret = tf->tf_ops->fabric_init_nodeacl(se_nacl, name);
+                if (ret) {
+                        configfs_remove_default_groups(&se_nacl->acl_fabric_stat_group);
+                        core_tpg_del_initiator_node_acl(se_nacl);
+                        return ERR_PTR(ret);
+                }
+        }
+
         return &se_nacl->acl_group;
 }
 
@@ -892,6 +891,7 @@ static void target_fabric_release_wwn(struct config_item *item)
                                 struct se_wwn, wwn_group);
         struct target_fabric_configfs *tf = wwn->wwn_tf;
 
+        configfs_remove_default_groups(&wwn->fabric_stat_group);
         tf->tf_ops->fabric_drop_wwn(wwn);
 }
 
@@ -945,6 +945,8 @@ static struct config_group *target_fabric_make_wwn(
                         &tf->tf_wwn_fabric_stats_cit);
         configfs_add_default_group(&wwn->fabric_stat_group, &wwn->wwn_group);
 
+        if (tf->tf_ops->add_wwn_groups)
+                tf->tf_ops->add_wwn_groups(wwn);
         return &wwn->wwn_group;
 }
 
diff --git a/drivers/thermal/Kconfig b/drivers/thermal/Kconfig
index c37eedc35a24..3c3dc4a3d52c 100644
--- a/drivers/thermal/Kconfig
+++ b/drivers/thermal/Kconfig
@@ -376,6 +376,8 @@ config MTK_THERMAL
         tristate "Temperature sensor driver for mediatek SoCs"
         depends on ARCH_MEDIATEK || COMPILE_TEST
         depends on HAS_IOMEM
+        depends on NVMEM || NVMEM=n
+        depends on RESET_CONTROLLER
         default y
         help
           Enable this option if you want to have support for thermal management
diff --git a/drivers/thermal/hisi_thermal.c b/drivers/thermal/hisi_thermal.c
index 36d07295f8e3..5e820b541506 100644
--- a/drivers/thermal/hisi_thermal.c
+++ b/drivers/thermal/hisi_thermal.c
@@ -68,12 +68,12 @@ static inline int _step_to_temp(int step)
          * Every step equals (1 * 200) / 255 celsius, and finally
          * need convert to millicelsius.
          */
-        return (HISI_TEMP_BASE + (step * 200 / 255)) * 1000;
+        return (HISI_TEMP_BASE * 1000 + (step * 200000 / 255));
 }
 
 static inline long _temp_to_step(long temp)
 {
-        return ((temp / 1000 - HISI_TEMP_BASE) * 255 / 200);
+        return ((temp - HISI_TEMP_BASE * 1000) * 255) / 200000;
 }
 
 static long hisi_thermal_get_sensor_temp(struct hisi_thermal_data *data,
diff --git a/drivers/thermal/mtk_thermal.c b/drivers/thermal/mtk_thermal.c
index 3d93b1c07cee..507632b9648e 100644
--- a/drivers/thermal/mtk_thermal.c
+++ b/drivers/thermal/mtk_thermal.c
@@ -27,7 +27,6 @@
 #include <linux/thermal.h>
 #include <linux/reset.h>
 #include <linux/types.h>
-#include <linux/nvmem-consumer.h>
 
 /* AUXADC Registers */
 #define AUXADC_CON0_V           0x000
@@ -619,7 +618,7 @@ static struct platform_driver mtk_thermal_driver = {
 
 module_platform_driver(mtk_thermal_driver);
 
-MODULE_AUTHOR("Sascha Hauer <s.hauer@pengutronix.de");
+MODULE_AUTHOR("Sascha Hauer <s.hauer@pengutronix.de>");
 MODULE_AUTHOR("Hanyi Wu <hanyi.wu@mediatek.com>");
 MODULE_DESCRIPTION("Mediatek thermal driver");
 MODULE_LICENSE("GPL v2");
diff --git a/drivers/thermal/of-thermal.c b/drivers/thermal/of-thermal.c
index 49ac23d3e776..d8ec44b194d6 100644
--- a/drivers/thermal/of-thermal.c
+++ b/drivers/thermal/of-thermal.c
@@ -803,8 +803,8 @@ static int thermal_of_populate_trip(struct device_node *np,
  * otherwise, it returns a corresponding ERR_PTR(). Caller must
  * check the return value with help of IS_ERR() helper.
  */
-static struct __thermal_zone *
-thermal_of_build_thermal_zone(struct device_node *np)
+static struct __thermal_zone
+__init *thermal_of_build_thermal_zone(struct device_node *np)
 {
         struct device_node *child = NULL, *gchild;
         struct __thermal_zone *tz;
diff --git a/drivers/thermal/power_allocator.c b/drivers/thermal/power_allocator.c
index 1246aa6fcab0..2f1a863a8e15 100644
--- a/drivers/thermal/power_allocator.c
+++ b/drivers/thermal/power_allocator.c
@@ -301,7 +301,7 @@ static void divvy_up_power(u32 *req_power, u32 *max_power, int num_actors,
         capped_extra_power = 0;
         extra_power = 0;
         for (i = 0; i < num_actors; i++) {
-                u64 req_range = req_power[i] * power_range;
+                u64 req_range = (u64)req_power[i] * power_range;
 
                 granted_power[i] = DIV_ROUND_CLOSEST_ULL(req_range,
                                                          total_req_power);
diff --git a/drivers/thermal/thermal_core.c b/drivers/thermal/thermal_core.c
index d4b54653ecf8..5133cd1e10b7 100644
--- a/drivers/thermal/thermal_core.c
+++ b/drivers/thermal/thermal_core.c
@@ -688,7 +688,7 @@ trip_point_temp_store(struct device *dev, struct device_attribute *attr,
 {
         struct thermal_zone_device *tz = to_thermal_zone(dev);
         int trip, ret;
-        unsigned long temperature;
+        int temperature;
 
         if (!tz->ops->set_trip_temp)
                 return -EPERM;
@@ -696,7 +696,7 @@ trip_point_temp_store(struct device *dev, struct device_attribute *attr,
         if (!sscanf(attr->attr.name, "trip_point_%d_temp", &trip))
                 return -EINVAL;
 
-        if (kstrtoul(buf, 10, &temperature))
+        if (kstrtoint(buf, 10, &temperature))
                 return -EINVAL;
 
         ret = tz->ops->set_trip_temp(tz, trip, temperature);
@@ -899,9 +899,9 @@ emul_temp_store(struct device *dev, struct device_attribute *attr,
 {
         struct thermal_zone_device *tz = to_thermal_zone(dev);
         int ret = 0;
-        unsigned long temperature;
+        int temperature;
 
-        if (kstrtoul(buf, 10, &temperature))
+        if (kstrtoint(buf, 10, &temperature))
                 return -EINVAL;
 
         if (!tz->ops->set_emul_temp) {
@@ -959,7 +959,7 @@ static DEVICE_ATTR(sustainable_power, S_IWUSR | S_IRUGO, sustainable_power_show,
         struct thermal_zone_device *tz = to_thermal_zone(dev);          \
                                                                         \
         if (tz->tzp)                                                    \
-                return sprintf(buf, "%u\n", tz->tzp->name);             \
+                return sprintf(buf, "%d\n", tz->tzp->name);             \
         else                                                            \
                 return -EIO;                                            \
         }                                                               \
diff --git a/drivers/tty/pty.c b/drivers/tty/pty.c
index e16a49b507ef..cf0dc51a2690 100644
--- a/drivers/tty/pty.c
+++ b/drivers/tty/pty.c
@@ -626,7 +626,7 @@ static int pty_unix98_ioctl(struct tty_struct *tty,
  */
 
 static struct tty_struct *ptm_unix98_lookup(struct tty_driver *driver,
-                struct inode *ptm_inode, int idx)
+                struct file *file, int idx)
 {
         /* Master must be open via /dev/ptmx */
         return ERR_PTR(-EIO);
@@ -642,12 +642,12 @@ static struct tty_struct *ptm_unix98_lookup(struct tty_driver *driver,
  */
 
 static struct tty_struct *pts_unix98_lookup(struct tty_driver *driver,
-                struct inode *pts_inode, int idx)
+                struct file *file, int idx)
 {
         struct tty_struct *tty;
 
         mutex_lock(&devpts_mutex);
-        tty = devpts_get_priv(pts_inode);
+        tty = devpts_get_priv(file->f_path.dentry);
         mutex_unlock(&devpts_mutex);
         /* Master must be open before slave */
         if (!tty)
@@ -663,14 +663,14 @@ static int pty_unix98_install(struct tty_driver *driver, struct tty_struct *tty)
 /* this is called once with whichever end is closed last */
 static void pty_unix98_remove(struct tty_driver *driver, struct tty_struct *tty)
 {
-        struct inode *ptmx_inode;
+        struct pts_fs_info *fsi;
 
         if (tty->driver->subtype == PTY_TYPE_MASTER)
-                ptmx_inode = tty->driver_data;
+                fsi = tty->driver_data;
         else
-                ptmx_inode = tty->link->driver_data;
-        devpts_kill_index(ptmx_inode, tty->index);
-        devpts_del_ref(ptmx_inode);
+                fsi = tty->link->driver_data;
+        devpts_kill_index(fsi, tty->index);
+        devpts_put_ref(fsi);
 }
 
 static const struct tty_operations ptm_unix98_ops = {
@@ -720,8 +720,9 @@ static const struct tty_operations pty_unix98_ops = {
 
 static int ptmx_open(struct inode *inode, struct file *filp)
 {
+        struct pts_fs_info *fsi;
         struct tty_struct *tty;
-        struct inode *slave_inode;
+        struct dentry *dentry;
         int retval;
         int index;
 
@@ -734,54 +735,46 @@ static int ptmx_open(struct inode *inode, struct file *filp)
         if (retval)
                 return retval;
 
+        fsi = devpts_get_ref(inode, filp);
+        retval = -ENODEV;
+        if (!fsi)
+                goto out_free_file;
+
         /* find a device that is not in use. */
         mutex_lock(&devpts_mutex);
-        index = devpts_new_index(inode);
-        if (index < 0) {
-                retval = index;
-                mutex_unlock(&devpts_mutex);
-                goto err_file;
-        }
-
+        index = devpts_new_index(fsi);
         mutex_unlock(&devpts_mutex);
 
-        mutex_lock(&tty_mutex);
-        tty = tty_init_dev(ptm_driver, index);
+        retval = index;
+        if (index < 0)
+                goto out_put_ref;
 
-        if (IS_ERR(tty)) {
-                retval = PTR_ERR(tty);
-                goto out;
-        }
 
+        mutex_lock(&tty_mutex);
+        tty = tty_init_dev(ptm_driver, index);
         /* The tty returned here is locked so we can safely
            drop the mutex */
         mutex_unlock(&tty_mutex);
 
-        set_bit(TTY_PTY_LOCK, &tty->flags); /* LOCK THE SLAVE */
-        tty->driver_data = inode;
+        retval = PTR_ERR(tty);
+        if (IS_ERR(tty))
+                goto out;
 
         /*
-         * In the case where all references to ptmx inode are dropped and we
-         * still have /dev/tty opened pointing to the master/slave pair (ptmx
-         * is closed/released before /dev/tty), we must make sure that the inode
-         * is still valid when we call the final pty_unix98_shutdown, thus we
-         * hold an additional reference to the ptmx inode. For the same /dev/tty
-         * last close case, we also need to make sure the super_block isn't
-         * destroyed (devpts instance unmounted), before /dev/tty is closed and
-         * on its release devpts_kill_index is called.
+         * From here on out, the tty is "live", and the index and
+         * fsi will be killed/put by the tty_release()
          */
-        devpts_add_ref(inode);
+        set_bit(TTY_PTY_LOCK, &tty->flags); /* LOCK THE SLAVE */
+        tty->driver_data = fsi;
 
         tty_add_file(tty, filp);
 
-        slave_inode = devpts_pty_new(inode,
-                        MKDEV(UNIX98_PTY_SLAVE_MAJOR, index), index,
-                        tty->link);
-        if (IS_ERR(slave_inode)) {
-                retval = PTR_ERR(slave_inode);
+        dentry = devpts_pty_new(fsi, index, tty->link);
+        if (IS_ERR(dentry)) {
+                retval = PTR_ERR(dentry);
                 goto err_release;
         }
-        tty->link->driver_data = slave_inode;
+        tty->link->driver_data = dentry;
 
         retval = ptm_driver->ops->open(tty, filp);
         if (retval)
@@ -793,12 +786,14 @@ static int ptmx_open(struct inode *inode, struct file *filp)
         return 0;
 err_release:
         tty_unlock(tty);
+        // This will also put-ref the fsi
         tty_release(inode, filp);
         return retval;
 out:
-        mutex_unlock(&tty_mutex);
-        devpts_kill_index(inode, index);
-err_file:
+        devpts_kill_index(fsi, index);
+out_put_ref:
+        devpts_put_ref(fsi);
+out_free_file:
         tty_free_file(filp);
         return retval;
 }
diff --git a/drivers/tty/serial/8250/8250_port.c b/drivers/tty/serial/8250/8250_port.c
index e213da01a3d7..00ad2637b08c 100644
--- a/drivers/tty/serial/8250/8250_port.c
+++ b/drivers/tty/serial/8250/8250_port.c
@@ -1403,9 +1403,18 @@ static void __do_stop_tx_rs485(struct uart_8250_port *p)
         /*
          * Empty the RX FIFO, we are not interested in anything
          * received during the half-duplex transmission.
+         * Enable previously disabled RX interrupts.
          */
-        if (!(p->port.rs485.flags & SER_RS485_RX_DURING_TX))
+        if (!(p->port.rs485.flags & SER_RS485_RX_DURING_TX)) {
                 serial8250_clear_fifos(p);
+
+                serial8250_rpm_get(p);
+
+                p->ier |= UART_IER_RLSI | UART_IER_RDI;
+                serial_port_out(&p->port, UART_IER, p->ier);
+
+                serial8250_rpm_put(p);
+        }
 }
 
 static void serial8250_em485_handle_stop_tx(unsigned long arg)
diff --git a/drivers/tty/serial/8250/Kconfig b/drivers/tty/serial/8250/Kconfig
index 64742a086ae3..4d7cb9c04fce 100644
--- a/drivers/tty/serial/8250/Kconfig
+++ b/drivers/tty/serial/8250/Kconfig
@@ -324,7 +324,6 @@ config SERIAL_8250_EM
 config SERIAL_8250_RT288X
         bool "Ralink RT288x/RT305x/RT3662/RT3883 serial port support"
         depends on SERIAL_8250
-        depends on MIPS || COMPILE_TEST
         default y if MIPS_ALCHEMY || SOC_RT288X || SOC_RT305X || SOC_RT3883 || SOC_MT7620
         help
           Selecting this option will add support for the alternate register
diff --git a/drivers/tty/serial/uartlite.c b/drivers/tty/serial/uartlite.c
index c9fdfc8bf47f..d08baa668d5d 100644
--- a/drivers/tty/serial/uartlite.c
+++ b/drivers/tty/serial/uartlite.c
@@ -72,7 +72,7 @@ static void uartlite_outbe32(u32 val, void __iomem *addr)
         iowrite32be(val, addr);
 }
 
-static const struct uartlite_reg_ops uartlite_be = {
+static struct uartlite_reg_ops uartlite_be = {
         .in = uartlite_inbe32,
         .out = uartlite_outbe32,
 };
@@ -87,21 +87,21 @@ static void uartlite_outle32(u32 val, void __iomem *addr)
         iowrite32(val, addr);
 }
 
-static const struct uartlite_reg_ops uartlite_le = {
+static struct uartlite_reg_ops uartlite_le = {
         .in = uartlite_inle32,
         .out = uartlite_outle32,
 };
 
 static inline u32 uart_in32(u32 offset, struct uart_port *port)
 {
-        const struct uartlite_reg_ops *reg_ops = port->private_data;
+        struct uartlite_reg_ops *reg_ops = port->private_data;
 
         return reg_ops->in(port->membase + offset);
 }
 
 static inline void uart_out32(u32 val, u32 offset, struct uart_port *port)
 {
-        const struct uartlite_reg_ops *reg_ops = port->private_data;
+        struct uartlite_reg_ops *reg_ops = port->private_data;
 
         reg_ops->out(val, port->membase + offset);
 }
diff --git a/drivers/tty/tty_io.c b/drivers/tty/tty_io.c
index 8d26ed79bb4c..24d5491ef0da 100644
--- a/drivers/tty/tty_io.c
+++ b/drivers/tty/tty_io.c
@@ -1367,12 +1367,12 @@ static ssize_t tty_line_name(struct tty_driver *driver, int index, char *p)
  *      Locking: tty_mutex must be held. If the tty is found, bump the tty kref.
  */
 static struct tty_struct *tty_driver_lookup_tty(struct tty_driver *driver,
-                struct inode *inode, int idx)
+                struct file *file, int idx)
 {
         struct tty_struct *tty;
 
         if (driver->ops->lookup)
-                tty = driver->ops->lookup(driver, inode, idx);
+                tty = driver->ops->lookup(driver, file, idx);
         else
                 tty = driver->ttys[idx];
 
@@ -2040,7 +2040,7 @@ static struct tty_struct *tty_open_by_driver(dev_t device, struct inode *inode,
         }
 
         /* check whether we're reopening an existing tty */
-        tty = tty_driver_lookup_tty(driver, inode, index);
+        tty = tty_driver_lookup_tty(driver, filp, index);
         if (IS_ERR(tty)) {
                 mutex_unlock(&tty_mutex);
                 goto out;
@@ -2049,14 +2049,13 @@ static struct tty_struct *tty_open_by_driver(dev_t device, struct inode *inode,
         if (tty) {
                 mutex_unlock(&tty_mutex);
                 retval = tty_lock_interruptible(tty);
+                tty_kref_put(tty);  /* drop kref from tty_driver_lookup_tty() */
                 if (retval) {
                         if (retval == -EINTR)
                                 retval = -ERESTARTSYS;
                         tty = ERR_PTR(retval);
                         goto out;
                 }
-                /* safe to drop the kref from tty_driver_lookup_tty() */
-                tty_kref_put(tty);
                 retval = tty_reopen(tty);
                 if (retval < 0) {
                         tty_unlock(tty);
@@ -2158,7 +2157,7 @@ retry_open:
         read_lock(&tasklist_lock);
         spin_lock_irq(&current->sighand->siglock);
         noctty = (filp->f_flags & O_NOCTTY) ||
-                        device == MKDEV(TTY_MAJOR, 0) ||
+                        (IS_ENABLED(CONFIG_VT) && device == MKDEV(TTY_MAJOR, 0)) ||
                         device == MKDEV(TTYAUX_MAJOR, 1) ||
                         (tty->driver->type == TTY_DRIVER_TYPE_PTY &&
                          tty->driver->subtype == PTY_TYPE_MASTER);
diff --git a/drivers/usb/class/cdc-acm.c b/drivers/usb/class/cdc-acm.c
index 83fd30b0577c..a6c4a1b895bd 100644
--- a/drivers/usb/class/cdc-acm.c
+++ b/drivers/usb/class/cdc-acm.c
@@ -744,11 +744,15 @@ static void acm_tty_flush_chars(struct tty_struct *tty)
         int err;
         unsigned long flags;
 
+        if (!cur) /* nothing to do */
+                return;
+
         acm->putbuffer = NULL;
         err = usb_autopm_get_interface_async(acm->control);
         spin_lock_irqsave(&acm->write_lock, flags);
         if (err < 0) {
                 cur->use = 0;
+                acm->putbuffer = cur;
                 goto out;
         }
 
diff --git a/drivers/usb/core/config.c b/drivers/usb/core/config.c
index 5eb1a87228b4..31ccdccd7a04 100644
--- a/drivers/usb/core/config.c
+++ b/drivers/usb/core/config.c
@@ -75,8 +75,6 @@ static void usb_parse_ss_endpoint_companion(struct device *ddev, int cfgno,
          * be the first thing immediately following the endpoint descriptor.
          */
         desc = (struct usb_ss_ep_comp_descriptor *) buffer;
-        buffer += desc->bLength;
-        size -= desc->bLength;
 
         if (desc->bDescriptorType != USB_DT_SS_ENDPOINT_COMP ||
                         size < USB_DT_SS_EP_COMP_SIZE) {
@@ -100,7 +98,8 @@ static void usb_parse_ss_endpoint_companion(struct device *ddev, int cfgno,
                                         ep->desc.wMaxPacketSize;
                 return;
         }
-
+        buffer += desc->bLength;
+        size -= desc->bLength;
         memcpy(&ep->ss_ep_comp, desc, USB_DT_SS_EP_COMP_SIZE);
 
         /* Check the various values */
@@ -146,12 +145,6 @@ static void usb_parse_ss_endpoint_companion(struct device *ddev, int cfgno,
                 ep->ss_ep_comp.bmAttributes = 2;
         }
 
-        /* Parse a possible SuperSpeedPlus isoc ep companion descriptor */
-        if (usb_endpoint_xfer_isoc(&ep->desc) &&
-            USB_SS_SSP_ISOC_COMP(desc->bmAttributes))
-                usb_parse_ssp_isoc_endpoint_companion(ddev, cfgno, inum, asnum,
-                                                        ep, buffer, size);
-
         if (usb_endpoint_xfer_isoc(&ep->desc))
                 max_tx = (desc->bMaxBurst + 1) *
                         (USB_SS_MULT(desc->bmAttributes)) *
@@ -171,6 +164,11 @@ static void usb_parse_ss_endpoint_companion(struct device *ddev, int cfgno,
                                 max_tx);
                 ep->ss_ep_comp.wBytesPerInterval = cpu_to_le16(max_tx);
         }
+        /* Parse a possible SuperSpeedPlus isoc ep companion descriptor */
+        if (usb_endpoint_xfer_isoc(&ep->desc) &&
+            USB_SS_SSP_ISOC_COMP(desc->bmAttributes))
+                usb_parse_ssp_isoc_endpoint_companion(ddev, cfgno, inum, asnum,
+                                                        ep, buffer, size);
 }
 
 static int usb_parse_endpoint(struct device *ddev, int cfgno, int inum,
diff --git a/drivers/usb/core/hcd-pci.c b/drivers/usb/core/hcd-pci.c
index f9d42cf23e55..7859d738df41 100644
--- a/drivers/usb/core/hcd-pci.c
+++ b/drivers/usb/core/hcd-pci.c
@@ -73,6 +73,15 @@ static void for_each_companion(struct pci_dev *pdev, struct usb_hcd *hcd,
                 if (companion->bus != pdev->bus ||
                                 PCI_SLOT(companion->devfn) != slot)
                         continue;
+
+                /*
+                 * Companion device should be either UHCI,OHCI or EHCI host
+                 * controller, otherwise skip.
+                 */
+                if (companion->class != CL_UHCI && companion->class != CL_OHCI &&
+                                companion->class != CL_EHCI)
+                        continue;
+
                 companion_hcd = pci_get_drvdata(companion);
                 if (!companion_hcd || !companion_hcd->self.root_hub)
                         continue;
diff --git a/drivers/usb/core/port.c b/drivers/usb/core/port.c
index 14718a9ffcfb..460c855be0d0 100644
--- a/drivers/usb/core/port.c
+++ b/drivers/usb/core/port.c
@@ -249,18 +249,12 @@ static int usb_port_runtime_suspend(struct device *dev)
 
         return retval;
 }
-
-static int usb_port_prepare(struct device *dev)
-{
-        return 1;
-}
 #endif
 
 static const struct dev_pm_ops usb_port_pm_ops = {
 #ifdef CONFIG_PM
         .runtime_suspend =      usb_port_runtime_suspend,
         .runtime_resume =       usb_port_runtime_resume,
-        .prepare =              usb_port_prepare,
 #endif
 };
 
diff --git a/drivers/usb/core/usb.c b/drivers/usb/core/usb.c
index dcb85e3cd5a7..479187c32571 100644
--- a/drivers/usb/core/usb.c
+++ b/drivers/usb/core/usb.c
@@ -312,13 +312,7 @@ static int usb_dev_uevent(struct device *dev, struct kobj_uevent_env *env)
 
 static int usb_dev_prepare(struct device *dev)
 {
-        struct usb_device *udev = to_usb_device(dev);
-
-        /* Return 0 if the current wakeup setting is wrong, otherwise 1 */
-        if (udev->do_remote_wakeup != device_may_wakeup(dev))
-                return 0;
-
-        return 1;
+        return 0;               /* Implement eventually? */
 }
 
 static void usb_dev_complete(struct device *dev)
diff --git a/drivers/usb/dwc2/gadget.c b/drivers/usb/dwc2/gadget.c
index e9940dd004e4..818f158232bb 100644
--- a/drivers/usb/dwc2/gadget.c
+++ b/drivers/usb/dwc2/gadget.c
@@ -2254,6 +2254,7 @@ void dwc2_hsotg_core_init_disconnected(struct dwc2_hsotg *hsotg,
 {
         u32 intmsk;
         u32 val;
+        u32 usbcfg;
 
         /* Kill any ep0 requests as controller will be reinitialized */
         kill_all_requests(hsotg, hsotg->eps_out[0], -ECONNRESET);
@@ -2267,10 +2268,16 @@ void dwc2_hsotg_core_init_disconnected(struct dwc2_hsotg *hsotg,
          * set configuration.
          */
 
+        /* keep other bits untouched (so e.g. forced modes are not lost) */
+        usbcfg = dwc2_readl(hsotg->regs + GUSBCFG);
+        usbcfg &= ~(GUSBCFG_TOUTCAL_MASK | GUSBCFG_PHYIF16 | GUSBCFG_SRPCAP |
+                GUSBCFG_HNPCAP);
+
         /* set the PLL on, remove the HNP/SRP and set the PHY */
         val = (hsotg->phyif == GUSBCFG_PHYIF8) ? 9 : 5;
-        dwc2_writel(hsotg->phyif | GUSBCFG_TOUTCAL(7) |
-               (val << GUSBCFG_USBTRDTIM_SHIFT), hsotg->regs + GUSBCFG);
+        usbcfg |= hsotg->phyif | GUSBCFG_TOUTCAL(7) |
+                (val << GUSBCFG_USBTRDTIM_SHIFT);
+        dwc2_writel(usbcfg, hsotg->regs + GUSBCFG);
 
         dwc2_hsotg_init_fifo(hsotg);
 
@@ -3031,6 +3038,7 @@ static struct usb_ep_ops dwc2_hsotg_ep_ops = {
 static void dwc2_hsotg_init(struct dwc2_hsotg *hsotg)
 {
         u32 trdtim;
+        u32 usbcfg;
         /* unmask subset of endpoint interrupts */
 
         dwc2_writel(DIEPMSK_TIMEOUTMSK | DIEPMSK_AHBERRMSK |
@@ -3054,11 +3062,16 @@ static void dwc2_hsotg_init(struct dwc2_hsotg *hsotg)
 
         dwc2_hsotg_init_fifo(hsotg);
 
+        /* keep other bits untouched (so e.g. forced modes are not lost) */
+        usbcfg = dwc2_readl(hsotg->regs + GUSBCFG);
+        usbcfg &= ~(GUSBCFG_TOUTCAL_MASK | GUSBCFG_PHYIF16 | GUSBCFG_SRPCAP |
+                GUSBCFG_HNPCAP);
+
         /* set the PLL on, remove the HNP/SRP and set the PHY */
         trdtim = (hsotg->phyif == GUSBCFG_PHYIF8) ? 9 : 5;
-        dwc2_writel(hsotg->phyif | GUSBCFG_TOUTCAL(7) |
-                (trdtim << GUSBCFG_USBTRDTIM_SHIFT),
-                hsotg->regs + GUSBCFG);
+        usbcfg |= hsotg->phyif | GUSBCFG_TOUTCAL(7) |
+                (trdtim << GUSBCFG_USBTRDTIM_SHIFT);
+        dwc2_writel(usbcfg, hsotg->regs + GUSBCFG);
 
         if (using_dma(hsotg))
                 __orr32(hsotg->regs + GAHBCFG, GAHBCFG_DMA_EN);
diff --git a/drivers/usb/dwc3/core.c b/drivers/usb/dwc3/core.c
index 17fd81447c9f..34277ced26bd 100644
--- a/drivers/usb/dwc3/core.c
+++ b/drivers/usb/dwc3/core.c
@@ -67,23 +67,9 @@ void dwc3_set_mode(struct dwc3 *dwc, u32 mode)
 static int dwc3_core_soft_reset(struct dwc3 *dwc)
 {
         u32             reg;
+        int             retries = 1000;
         int             ret;
 
-        /* Before Resetting PHY, put Core in Reset */
-        reg = dwc3_readl(dwc->regs, DWC3_GCTL);
-        reg |= DWC3_GCTL_CORESOFTRESET;
-        dwc3_writel(dwc->regs, DWC3_GCTL, reg);
-
-        /* Assert USB3 PHY reset */
-        reg = dwc3_readl(dwc->regs, DWC3_GUSB3PIPECTL(0));
-        reg |= DWC3_GUSB3PIPECTL_PHYSOFTRST;
-        dwc3_writel(dwc->regs, DWC3_GUSB3PIPECTL(0), reg);
-
-        /* Assert USB2 PHY reset */
-        reg = dwc3_readl(dwc->regs, DWC3_GUSB2PHYCFG(0));
-        reg |= DWC3_GUSB2PHYCFG_PHYSOFTRST;
-        dwc3_writel(dwc->regs, DWC3_GUSB2PHYCFG(0), reg);
-
         usb_phy_init(dwc->usb2_phy);
         usb_phy_init(dwc->usb3_phy);
         ret = phy_init(dwc->usb2_generic_phy);
@@ -95,26 +81,28 @@ static int dwc3_core_soft_reset(struct dwc3 *dwc)
                 phy_exit(dwc->usb2_generic_phy);
                 return ret;
         }
-        mdelay(100);
 
-        /* Clear USB3 PHY reset */
-        reg = dwc3_readl(dwc->regs, DWC3_GUSB3PIPECTL(0));
-        reg &= ~DWC3_GUSB3PIPECTL_PHYSOFTRST;
-        dwc3_writel(dwc->regs, DWC3_GUSB3PIPECTL(0), reg);
+        /*
+         * We're resetting only the device side because, if we're in host mode,
+         * XHCI driver will reset the host block. If dwc3 was configured for
+         * host-only mode, then we can return early.
+         */
+        if (dwc->dr_mode == USB_DR_MODE_HOST)
+                return 0;
 
-        /* Clear USB2 PHY reset */
-        reg = dwc3_readl(dwc->regs, DWC3_GUSB2PHYCFG(0));
-        reg &= ~DWC3_GUSB2PHYCFG_PHYSOFTRST;
-        dwc3_writel(dwc->regs, DWC3_GUSB2PHYCFG(0), reg);
+        reg = dwc3_readl(dwc->regs, DWC3_DCTL);
+        reg |= DWC3_DCTL_CSFTRST;
+        dwc3_writel(dwc->regs, DWC3_DCTL, reg);
 
-        mdelay(100);
+        do {
+                reg = dwc3_readl(dwc->regs, DWC3_DCTL);
+                if (!(reg & DWC3_DCTL_CSFTRST))
+                        return 0;
 
-        /* After PHYs are stable we can take Core out of reset state */
-        reg = dwc3_readl(dwc->regs, DWC3_GCTL);
-        reg &= ~DWC3_GCTL_CORESOFTRESET;
-        dwc3_writel(dwc->regs, DWC3_GCTL, reg);
+                udelay(1);
+        } while (--retries);
 
-        return 0;
+        return -ETIMEDOUT;
 }
 
 /**
@@ -1162,6 +1150,11 @@ static int dwc3_suspend(struct device *dev)
         phy_exit(dwc->usb2_generic_phy);
         phy_exit(dwc->usb3_generic_phy);
 
+        usb_phy_set_suspend(dwc->usb2_phy, 1);
+        usb_phy_set_suspend(dwc->usb3_phy, 1);
+        WARN_ON(phy_power_off(dwc->usb2_generic_phy) < 0);
+        WARN_ON(phy_power_off(dwc->usb3_generic_phy) < 0);
+
         pinctrl_pm_select_sleep_state(dev);
 
         return 0;
@@ -1175,11 +1168,21 @@ static int dwc3_resume(struct device *dev)
 
         pinctrl_pm_select_default_state(dev);
 
+        usb_phy_set_suspend(dwc->usb2_phy, 0);
+        usb_phy_set_suspend(dwc->usb3_phy, 0);
+        ret = phy_power_on(dwc->usb2_generic_phy);
+        if (ret < 0)
+                return ret;
+
+        ret = phy_power_on(dwc->usb3_generic_phy);
+        if (ret < 0)
+                goto err_usb2phy_power;
+
         usb_phy_init(dwc->usb3_phy);
         usb_phy_init(dwc->usb2_phy);
         ret = phy_init(dwc->usb2_generic_phy);
         if (ret < 0)
-                return ret;
+                goto err_usb3phy_power;
 
         ret = phy_init(dwc->usb3_generic_phy);
         if (ret < 0)
@@ -1212,6 +1215,12 @@ static int dwc3_resume(struct device *dev)
 err_usb2phy_init:
         phy_exit(dwc->usb2_generic_phy);
 
+err_usb3phy_power:
+        phy_power_off(dwc->usb3_generic_phy);
+
+err_usb2phy_power:
+        phy_power_off(dwc->usb2_generic_phy);
+
         return ret;
 }
 
diff --git a/drivers/usb/dwc3/debugfs.c b/drivers/usb/dwc3/debugfs.c
index 9ac37fe1b6a7..cebf9e38b60a 100644
--- a/drivers/usb/dwc3/debugfs.c
+++ b/drivers/usb/dwc3/debugfs.c
@@ -645,7 +645,7 @@ int dwc3_debugfs_init(struct dwc3 *dwc)
         file = debugfs_create_regset32("regdump", S_IRUGO, root, dwc->regset);
         if (!file) {
                 ret = -ENOMEM;
-                goto err1;
+                goto err2;
         }
 
         if (IS_ENABLED(CONFIG_USB_DWC3_DUAL_ROLE)) {
@@ -653,7 +653,7 @@ int dwc3_debugfs_init(struct dwc3 *dwc)
                                 dwc, &dwc3_mode_fops);
                 if (!file) {
                         ret = -ENOMEM;
-                        goto err1;
+                        goto err2;
                 }
         }
 
@@ -663,19 +663,22 @@ int dwc3_debugfs_init(struct dwc3 *dwc)
                                 dwc, &dwc3_testmode_fops);
                 if (!file) {
                         ret = -ENOMEM;
-                        goto err1;
+                        goto err2;
                 }
 
                 file = debugfs_create_file("link_state", S_IRUGO | S_IWUSR, root,
                                 dwc, &dwc3_link_state_fops);
                 if (!file) {
                         ret = -ENOMEM;
-                        goto err1;
+                        goto err2;
                 }
         }
 
         return 0;
 
+err2:
+        kfree(dwc->regset);
+
 err1:
         debugfs_remove_recursive(root);
 
@@ -686,5 +689,5 @@ err0:
 void dwc3_debugfs_exit(struct dwc3 *dwc)
 {
         debugfs_remove_recursive(dwc->root);
-        dwc->root = NULL;
+        kfree(dwc->regset);
 }
diff --git a/drivers/usb/dwc3/dwc3-keystone.c b/drivers/usb/dwc3/dwc3-keystone.c
index 2be268d2423d..72664700b8a2 100644
--- a/drivers/usb/dwc3/dwc3-keystone.c
+++ b/drivers/usb/dwc3/dwc3-keystone.c
@@ -39,8 +39,6 @@
 #define USBSS_IRQ_COREIRQ_EN    BIT(0)
 #define USBSS_IRQ_COREIRQ_CLR   BIT(0)
 
-static u64 kdwc3_dma_mask;
-
 struct dwc3_keystone {
         struct device                   *dev;
         struct clk                      *clk;
@@ -108,9 +106,6 @@ static int kdwc3_probe(struct platform_device *pdev)
         if (IS_ERR(kdwc->usbss))
                 return PTR_ERR(kdwc->usbss);
 
-        kdwc3_dma_mask = dma_get_mask(dev);
-        dev->dma_mask = &kdwc3_dma_mask;
-
         kdwc->clk = devm_clk_get(kdwc->dev, "usb");
 
         error = clk_prepare_enable(kdwc->clk);
diff --git a/drivers/usb/dwc3/dwc3-omap.c b/drivers/usb/dwc3/dwc3-omap.c
index 22e9606d8e08..55da2c7f727f 100644
--- a/drivers/usb/dwc3/dwc3-omap.c
+++ b/drivers/usb/dwc3/dwc3-omap.c
@@ -496,7 +496,7 @@ static int dwc3_omap_probe(struct platform_device *pdev)
         ret = pm_runtime_get_sync(dev);
         if (ret < 0) {
                 dev_err(dev, "get_sync failed with err %d\n", ret);
-                goto err0;
+                goto err1;
         }
 
         dwc3_omap_map_offset(omap);
@@ -516,28 +516,24 @@ static int dwc3_omap_probe(struct platform_device *pdev)
 
         ret = dwc3_omap_extcon_register(omap);
         if (ret < 0)
-                goto err2;
+                goto err1;
 
         ret = of_platform_populate(node, NULL, NULL, dev);
         if (ret) {
                 dev_err(&pdev->dev, "failed to create dwc3 core\n");
-                goto err3;
+                goto err2;
         }
 
         dwc3_omap_enable_irqs(omap);
 
         return 0;
 
-err3:
+err2:
         extcon_unregister_notifier(omap->edev, EXTCON_USB, &omap->vbus_nb);
         extcon_unregister_notifier(omap->edev, EXTCON_USB_HOST, &omap->id_nb);
-err2:
-        dwc3_omap_disable_irqs(omap);
 
 err1:
         pm_runtime_put_sync(dev);
-
-err0:
         pm_runtime_disable(dev);
 
         return ret;
diff --git a/drivers/usb/dwc3/dwc3-pci.c b/drivers/usb/dwc3/dwc3-pci.c
index 009d83048c8c..adc1e8a624cb 100644
--- a/drivers/usb/dwc3/dwc3-pci.c
+++ b/drivers/usb/dwc3/dwc3-pci.c
@@ -35,6 +35,7 @@
 #define PCI_DEVICE_ID_INTEL_SPTLP               0x9d30
 #define PCI_DEVICE_ID_INTEL_SPTH                0xa130
 #define PCI_DEVICE_ID_INTEL_BXT                 0x0aaa
+#define PCI_DEVICE_ID_INTEL_BXT_M               0x1aaa
 #define PCI_DEVICE_ID_INTEL_APL                 0x5aaa
 
 static const struct acpi_gpio_params reset_gpios = { 0, 0, false };
@@ -213,6 +214,7 @@ static const struct pci_device_id dwc3_pci_id_table[] = {
         { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_SPTLP), },
         { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_SPTH), },
         { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_BXT), },
+        { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_BXT_M), },
         { PCI_DEVICE(PCI_VENDOR_ID_INTEL, PCI_DEVICE_ID_INTEL_APL), },
         { PCI_DEVICE(PCI_VENDOR_ID_AMD, PCI_DEVICE_ID_AMD_NL_USB), },
         {  }    /* Terminating Entry */
diff --git a/drivers/usb/dwc3/gadget.c b/drivers/usb/dwc3/gadget.c
index 3ac170f9d94d..8e4a1b195e9b 100644
--- a/drivers/usb/dwc3/gadget.c
+++ b/drivers/usb/dwc3/gadget.c
@@ -568,7 +568,7 @@ static int __dwc3_gadget_ep_enable(struct dwc3_ep *dep,
                 dwc3_writel(dwc->regs, DWC3_DALEPENA, reg);
 
                 if (!usb_endpoint_xfer_isoc(desc))
-                        return 0;
+                        goto out;
 
                 /* Link TRB for ISOC. The HWO bit is never reset */
                 trb_st_hw = &dep->trb_pool[0];
@@ -582,9 +582,10 @@ static int __dwc3_gadget_ep_enable(struct dwc3_ep *dep,
                 trb_link->ctrl |= DWC3_TRB_CTRL_HWO;
         }
 
+out:
         switch (usb_endpoint_type(desc)) {
         case USB_ENDPOINT_XFER_CONTROL:
-                strlcat(dep->name, "-control", sizeof(dep->name));
+                /* don't change name */
                 break;
         case USB_ENDPOINT_XFER_ISOC:
                 strlcat(dep->name, "-isoc", sizeof(dep->name));
@@ -2487,7 +2488,11 @@ static void dwc3_gadget_wakeup_interrupt(struct dwc3 *dwc)
          * implemented.
          */
 
-        dwc->gadget_driver->resume(&dwc->gadget);
+        if (dwc->gadget_driver && dwc->gadget_driver->resume) {
+                spin_unlock(&dwc->lock);
+                dwc->gadget_driver->resume(&dwc->gadget);
+                spin_lock(&dwc->lock);
+        }
 }
 
 static void dwc3_gadget_linksts_change_interrupt(struct dwc3 *dwc,
@@ -2931,6 +2936,9 @@ void dwc3_gadget_exit(struct dwc3 *dwc)
 
 int dwc3_gadget_suspend(struct dwc3 *dwc)
 {
+        if (!dwc->gadget_driver)
+                return 0;
+
         if (dwc->pullups_connected) {
                 dwc3_gadget_disable_irq(dwc);
                 dwc3_gadget_run_stop(dwc, true, true);
@@ -2949,6 +2957,9 @@ int dwc3_gadget_resume(struct dwc3 *dwc)
         struct dwc3_ep          *dep;
         int                     ret;
 
+        if (!dwc->gadget_driver)
+                return 0;
+
         /* Start with SuperSpeed Default */
         dwc3_gadget_ep0_desc.wMaxPacketSize = cpu_to_le16(512);
 
diff --git a/drivers/usb/gadget/composite.c b/drivers/usb/gadget/composite.c
index a5c62093c26c..524e233d48de 100644
--- a/drivers/usb/gadget/composite.c
+++ b/drivers/usb/gadget/composite.c
@@ -651,12 +651,15 @@ static int bos_desc(struct usb_composite_dev *cdev)
                 ssp_cap->bLength = USB_DT_USB_SSP_CAP_SIZE(1);
                 ssp_cap->bDescriptorType = USB_DT_DEVICE_CAPABILITY;
                 ssp_cap->bDevCapabilityType = USB_SSP_CAP_TYPE;
+                ssp_cap->bReserved = 0;
+                ssp_cap->wReserved = 0;
 
                 /* SSAC = 1 (2 attributes) */
                 ssp_cap->bmAttributes = cpu_to_le32(1);
 
                 /* Min RX/TX Lane Count = 1 */
-                ssp_cap->wFunctionalitySupport = (1 << 8) | (1 << 12);
+                ssp_cap->wFunctionalitySupport =
+                        cpu_to_le16((1 << 8) | (1 << 12));
 
                 /*
                  * bmSublinkSpeedAttr[0]:
@@ -666,7 +669,7 @@ static int bos_desc(struct usb_composite_dev *cdev)
                  *   LSM = 10 (10 Gbps)
                  */
                 ssp_cap->bmSublinkSpeedAttr[0] =
-                        (3 << 4) | (1 << 14) | (0xa << 16);
+                        cpu_to_le32((3 << 4) | (1 << 14) | (0xa << 16));
                 /*
                  * bmSublinkSpeedAttr[1] =
                  *   ST  = Symmetric, TX
@@ -675,7 +678,8 @@ static int bos_desc(struct usb_composite_dev *cdev)
                  *   LSM = 10 (10 Gbps)
                  */
                 ssp_cap->bmSublinkSpeedAttr[1] =
-                        (3 << 4) | (1 << 14) | (0xa << 16) | (1 << 7);
+                        cpu_to_le32((3 << 4) | (1 << 14) |
+                                    (0xa << 16) | (1 << 7));
         }
 
         return le16_to_cpu(bos->wTotalLength);
diff --git a/drivers/usb/gadget/function/f_fs.c b/drivers/usb/gadget/function/f_fs.c
index 8cfce105c7ee..15b648cbc75c 100644
--- a/drivers/usb/gadget/function/f_fs.c
+++ b/drivers/usb/gadget/function/f_fs.c
@@ -646,6 +646,7 @@ static void ffs_user_copy_worker(struct work_struct *work)
                                                    work);
         int ret = io_data->req->status ? io_data->req->status :
                                          io_data->req->actual;
+        bool kiocb_has_eventfd = io_data->kiocb->ki_flags & IOCB_EVENTFD;
 
         if (io_data->read && ret > 0) {
                 use_mm(io_data->mm);
@@ -657,13 +658,11 @@ static void ffs_user_copy_worker(struct work_struct *work)
 
         io_data->kiocb->ki_complete(io_data->kiocb, ret, ret);
 
-        if (io_data->ffs->ffs_eventfd &&
-            !(io_data->kiocb->ki_flags & IOCB_EVENTFD))
+        if (io_data->ffs->ffs_eventfd && !kiocb_has_eventfd)
                 eventfd_signal(io_data->ffs->ffs_eventfd, 1);
 
         usb_ep_free_request(io_data->ep, io_data->req);
 
-        io_data->kiocb->private = NULL;
         if (io_data->read)
                 kfree(io_data->to_free);
         kfree(io_data->buf);
@@ -1147,8 +1146,8 @@ static int ffs_sb_fill(struct super_block *sb, void *_data, int silent)
         ffs->sb              = sb;
         data->ffs_data       = NULL;
         sb->s_fs_info        = ffs;
-        sb->s_blocksize      = PAGE_CACHE_SIZE;
-        sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
+        sb->s_blocksize      = PAGE_SIZE;
+        sb->s_blocksize_bits = PAGE_SHIFT;
         sb->s_magic          = FUNCTIONFS_MAGIC;
         sb->s_op             = &ffs_sb_operations;
         sb->s_time_gran      = 1;
diff --git a/drivers/usb/gadget/function/f_midi.c b/drivers/usb/gadget/function/f_midi.c
index 84c0ee5ebd1e..58fc199a18ec 100644
--- a/drivers/usb/gadget/function/f_midi.c
+++ b/drivers/usb/gadget/function/f_midi.c
@@ -24,6 +24,7 @@
 #include <linux/slab.h>
 #include <linux/device.h>
 #include <linux/kfifo.h>
+#include <linux/spinlock.h>
 
 #include <sound/core.h>
 #include <sound/initval.h>
@@ -89,6 +90,7 @@ struct f_midi {
         unsigned int buflen, qlen;
         /* This fifo is used as a buffer ring for pre-allocated IN usb_requests */
         DECLARE_KFIFO_PTR(in_req_fifo, struct usb_request *);
+        spinlock_t transmit_lock;
         unsigned int in_last_port;
 
         struct gmidi_in_port    in_ports_array[/* in_ports */];
@@ -358,7 +360,9 @@ static int f_midi_set_alt(struct usb_function *f, unsigned intf, unsigned alt)
         /* allocate a bunch of read buffers and queue them all at once. */
         for (i = 0; i < midi->qlen && err == 0; i++) {
                 struct usb_request *req =
-                        midi_alloc_ep_req(midi->out_ep, midi->buflen);
+                        midi_alloc_ep_req(midi->out_ep,
+                                max_t(unsigned, midi->buflen,
+                                        bulk_out_desc.wMaxPacketSize));
                 if (req == NULL)
                         return -ENOMEM;
 
@@ -597,17 +601,24 @@ static void f_midi_transmit(struct f_midi *midi)
 {
         struct usb_ep *ep = midi->in_ep;
         int ret;
+        unsigned long flags;
 
         /* We only care about USB requests if IN endpoint is enabled */
         if (!ep || !ep->enabled)
                 goto drop_out;
 
+        spin_lock_irqsave(&midi->transmit_lock, flags);
+
         do {
                 ret = f_midi_do_transmit(midi, ep);
-                if (ret < 0)
+                if (ret < 0) {
+                        spin_unlock_irqrestore(&midi->transmit_lock, flags);
                         goto drop_out;
+                }
         } while (ret);
 
+        spin_unlock_irqrestore(&midi->transmit_lock, flags);
+
         return;
 
 drop_out:
@@ -1201,6 +1212,8 @@ static struct usb_function *f_midi_alloc(struct usb_function_instance *fi)
         if (status)
                 goto setup_fail;
 
+        spin_lock_init(&midi->transmit_lock);
+
         ++opts->refcnt;
         mutex_unlock(&opts->lock);
 
diff --git a/drivers/usb/gadget/legacy/inode.c b/drivers/usb/gadget/legacy/inode.c
index 5cdaf0150a4e..e64479f882a5 100644
--- a/drivers/usb/gadget/legacy/inode.c
+++ b/drivers/usb/gadget/legacy/inode.c
@@ -1954,8 +1954,8 @@ gadgetfs_fill_super (struct super_block *sb, void *opts, int silent)
                 return -ENODEV;
 
         /* superblock */
-        sb->s_blocksize = PAGE_CACHE_SIZE;
-        sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
+        sb->s_blocksize = PAGE_SIZE;
+        sb->s_blocksize_bits = PAGE_SHIFT;
         sb->s_magic = GADGETFS_MAGIC;
         sb->s_op = &gadget_fs_operations;
         sb->s_time_gran = 1;
diff --git a/drivers/usb/gadget/udc/atmel_usba_udc.c b/drivers/usb/gadget/udc/atmel_usba_udc.c
index 81d42cce885a..18569de06b04 100644
--- a/drivers/usb/gadget/udc/atmel_usba_udc.c
+++ b/drivers/usb/gadget/udc/atmel_usba_udc.c
@@ -1045,20 +1045,6 @@ static void reset_all_endpoints(struct usba_udc *udc)
                 list_del_init(&req->queue);
                 request_complete(ep, req, -ECONNRESET);
         }
-
-        /* NOTE:  normally, the next call to the gadget driver is in
-         * charge of disabling endpoints... usually disconnect().
-         * The exception would be entering a high speed test mode.
-         *
-         * FIXME remove this code ... and retest thoroughly.
-         */
-        list_for_each_entry(ep, &udc->gadget.ep_list, ep.ep_list) {
-                if (ep->ep.desc) {
-                        spin_unlock(&udc->lock);
-                        usba_ep_disable(&ep->ep);
-                        spin_lock(&udc->lock);
-                }
-        }
 }
 
 static struct usba_ep *get_ep_by_addr(struct usba_udc *udc, u16 wIndex)
diff --git a/drivers/usb/gadget/udc/udc-core.c b/drivers/usb/gadget/udc/udc-core.c
index 4151597e9d28..e4e70e11d0f6 100644
--- a/drivers/usb/gadget/udc/udc-core.c
+++ b/drivers/usb/gadget/udc/udc-core.c
@@ -371,12 +371,6 @@ int usb_add_gadget_udc_release(struct device *parent, struct usb_gadget *gadget,
         INIT_WORK(&gadget->work, usb_gadget_state_work);
         gadget->dev.parent = parent;
 
-#ifdef  CONFIG_HAS_DMA
-        dma_set_coherent_mask(&gadget->dev, parent->coherent_dma_mask);
-        gadget->dev.dma_parms = parent->dma_parms;
-        gadget->dev.dma_mask = parent->dma_mask;
-#endif
-
         if (release)
                 gadget->dev.release = release;
         else
diff --git a/drivers/usb/host/xhci-mem.c b/drivers/usb/host/xhci-mem.c
index 80c1de239e9a..bad0d1f9a41d 100644
--- a/drivers/usb/host/xhci-mem.c
+++ b/drivers/usb/host/xhci-mem.c
@@ -1861,6 +1861,12 @@ no_bw:
         kfree(xhci->rh_bw);
         kfree(xhci->ext_caps);
 
+        xhci->usb2_ports = NULL;
+        xhci->usb3_ports = NULL;
+        xhci->port_array = NULL;
+        xhci->rh_bw = NULL;
+        xhci->ext_caps = NULL;
+
         xhci->page_size = 0;
         xhci->page_shift = 0;
         xhci->bus_state[0].bus_suspended = 0;
diff --git a/drivers/usb/host/xhci-pci.c b/drivers/usb/host/xhci-pci.c
index f0640b7a1c42..48672fac7ff3 100644
--- a/drivers/usb/host/xhci-pci.c
+++ b/drivers/usb/host/xhci-pci.c
@@ -48,6 +48,7 @@
 #define PCI_DEVICE_ID_INTEL_SUNRISEPOINT_H_XHCI         0xa12f
 #define PCI_DEVICE_ID_INTEL_SUNRISEPOINT_LP_XHCI        0x9d2f
 #define PCI_DEVICE_ID_INTEL_BROXTON_M_XHCI              0x0aa8
+#define PCI_DEVICE_ID_INTEL_BROXTON_B_XHCI              0x1aa8
 
 static const char hcd_name[] = "xhci_hcd";
 
@@ -155,7 +156,8 @@ static void xhci_pci_quirks(struct device *dev, struct xhci_hcd *xhci)
                 (pdev->device == PCI_DEVICE_ID_INTEL_SUNRISEPOINT_LP_XHCI ||
                  pdev->device == PCI_DEVICE_ID_INTEL_SUNRISEPOINT_H_XHCI ||
                  pdev->device == PCI_DEVICE_ID_INTEL_CHERRYVIEW_XHCI ||
-                 pdev->device == PCI_DEVICE_ID_INTEL_BROXTON_M_XHCI)) {
+                 pdev->device == PCI_DEVICE_ID_INTEL_BROXTON_M_XHCI ||
+                 pdev->device == PCI_DEVICE_ID_INTEL_BROXTON_B_XHCI)) {
                 xhci->quirks |= XHCI_PME_STUCK_QUIRK;
         }
         if (pdev->vendor == PCI_VENDOR_ID_INTEL &&
@@ -302,6 +304,7 @@ static void xhci_pci_remove(struct pci_dev *dev)
         struct xhci_hcd *xhci;
 
         xhci = hcd_to_xhci(pci_get_drvdata(dev));
+        xhci->xhc_state |= XHCI_STATE_REMOVING;
         if (xhci->shared_hcd) {
                 usb_remove_hcd(xhci->shared_hcd);
                 usb_put_hcd(xhci->shared_hcd);
diff --git a/drivers/usb/host/xhci-plat.c b/drivers/usb/host/xhci-plat.c
index 5c15e9bc5f7a..474b5fa14900 100644
--- a/drivers/usb/host/xhci-plat.c
+++ b/drivers/usb/host/xhci-plat.c
@@ -39,12 +39,25 @@ static const struct xhci_driver_overrides xhci_plat_overrides __initconst = {
 
 static void xhci_plat_quirks(struct device *dev, struct xhci_hcd *xhci)
 {
+        struct usb_hcd *hcd = xhci_to_hcd(xhci);
+
         /*
          * As of now platform drivers don't provide MSI support so we ensure
          * here that the generic code does not try to make a pci_dev from our
          * dev struct in order to setup MSI
          */
         xhci->quirks |= XHCI_PLAT;
+
+        /*
+         * On R-Car Gen2 and Gen3, the AC64 bit (bit 0) of HCCPARAMS1 is set
+         * to 1. However, these SoCs don't support 64-bit address memory
+         * pointers. So, this driver clears the AC64 bit of xhci->hcc_params
+         * to call dma_set_coherent_mask(dev, DMA_BIT_MASK(32)) in
+         * xhci_gen_setup().
+         */
+        if (xhci_plat_type_is(hcd, XHCI_PLAT_TYPE_RENESAS_RCAR_GEN2) ||
+            xhci_plat_type_is(hcd, XHCI_PLAT_TYPE_RENESAS_RCAR_GEN3))
+                xhci->quirks |= XHCI_NO_64BIT_SUPPORT;
 }
 
 /* called during probe() after chip reset completes */
diff --git a/drivers/usb/host/xhci-plat.h b/drivers/usb/host/xhci-plat.h
index 5a2e2e3936c4..529c3c40f901 100644
--- a/drivers/usb/host/xhci-plat.h
+++ b/drivers/usb/host/xhci-plat.h
@@ -14,7 +14,7 @@
 #include "xhci.h"       /* for hcd_to_xhci() */
 
 enum xhci_plat_type {
-        XHCI_PLAT_TYPE_MARVELL_ARMADA,
+        XHCI_PLAT_TYPE_MARVELL_ARMADA = 1,
         XHCI_PLAT_TYPE_RENESAS_RCAR_GEN2,
         XHCI_PLAT_TYPE_RENESAS_RCAR_GEN3,
 };
diff --git a/drivers/usb/host/xhci-ring.c b/drivers/usb/host/xhci-ring.c
index 7cf66212ceae..99b4ff42f7a0 100644
--- a/drivers/usb/host/xhci-ring.c
+++ b/drivers/usb/host/xhci-ring.c
@@ -4004,7 +4004,8 @@ static int queue_command(struct xhci_hcd *xhci, struct xhci_command *cmd,
         int reserved_trbs = xhci->cmd_ring_reserved_trbs;
         int ret;
 
-        if (xhci->xhc_state) {
+        if ((xhci->xhc_state & XHCI_STATE_DYING) ||
+                (xhci->xhc_state & XHCI_STATE_HALTED)) {
                 xhci_dbg(xhci, "xHCI dying or halted, can't queue_command\n");
                 return -ESHUTDOWN;
         }
diff --git a/drivers/usb/host/xhci.c b/drivers/usb/host/xhci.c
index d51ee0c3cf9f..9e71c96ad74a 100644
--- a/drivers/usb/host/xhci.c
+++ b/drivers/usb/host/xhci.c
@@ -147,7 +147,8 @@ static int xhci_start(struct xhci_hcd *xhci)
                                 "waited %u microseconds.\n",
                                 XHCI_MAX_HALT_USEC);
         if (!ret)
-                xhci->xhc_state &= ~(XHCI_STATE_HALTED | XHCI_STATE_DYING);
+                /* clear state flags. Including dying, halted or removing */
+                xhci->xhc_state = 0;
 
         return ret;
 }
@@ -1108,8 +1109,8 @@ int xhci_resume(struct xhci_hcd *xhci, bool hibernated)
                 /* Resume root hubs only when have pending events. */
                 status = readl(&xhci->op_regs->status);
                 if (status & STS_EINT) {
-                        usb_hcd_resume_root_hub(hcd);
                         usb_hcd_resume_root_hub(xhci->shared_hcd);
+                        usb_hcd_resume_root_hub(hcd);
                 }
         }
 
@@ -1124,10 +1125,10 @@ int xhci_resume(struct xhci_hcd *xhci, bool hibernated)
 
         /* Re-enable port polling. */
         xhci_dbg(xhci, "%s: starting port polling.\n", __func__);
-        set_bit(HCD_FLAG_POLL_RH, &hcd->flags);
-        usb_hcd_poll_rh_status(hcd);
         set_bit(HCD_FLAG_POLL_RH, &xhci->shared_hcd->flags);
         usb_hcd_poll_rh_status(xhci->shared_hcd);
+        set_bit(HCD_FLAG_POLL_RH, &hcd->flags);
+        usb_hcd_poll_rh_status(hcd);
 
         return retval;
 }
@@ -2773,7 +2774,8 @@ int xhci_check_bandwidth(struct usb_hcd *hcd, struct usb_device *udev)
         if (ret <= 0)
                 return ret;
         xhci = hcd_to_xhci(hcd);
-        if (xhci->xhc_state & XHCI_STATE_DYING)
+        if ((xhci->xhc_state & XHCI_STATE_DYING) ||
+                (xhci->xhc_state & XHCI_STATE_REMOVING))
                 return -ENODEV;
 
         xhci_dbg(xhci, "%s called for udev %p\n", __func__, udev);
@@ -3820,7 +3822,7 @@ static int xhci_setup_device(struct usb_hcd *hcd, struct usb_device *udev,
 
         mutex_lock(&xhci->mutex);
 
-        if (xhci->xhc_state)    /* dying or halted */
+        if (xhci->xhc_state)    /* dying, removing or halted */
                 goto out;
 
         if (!udev->slot_id) {
@@ -4948,6 +4950,16 @@ int xhci_gen_setup(struct usb_hcd *hcd, xhci_get_quirks_t get_quirks)
                 return retval;
         xhci_dbg(xhci, "Reset complete\n");
 
+        /*
+         * On some xHCI controllers (e.g. R-Car SoCs), the AC64 bit (bit 0)
+         * of HCCPARAMS1 is set to 1. However, the xHCs don't support 64-bit
+         * address memory pointers actually. So, this driver clears the AC64
+         * bit of xhci->hcc_params to call dma_set_coherent_mask(dev,
+         * DMA_BIT_MASK(32)) in this xhci_gen_setup().
+         */
+        if (xhci->quirks & XHCI_NO_64BIT_SUPPORT)
+                xhci->hcc_params &= ~BIT(0);
+
         /* Set dma_mask and coherent_dma_mask to 64-bits,
          * if xHC supports 64-bit addressing */
         if (HCC_64BIT_ADDR(xhci->hcc_params) &&
diff --git a/drivers/usb/host/xhci.h b/drivers/usb/host/xhci.h
index e293e0974f48..6c629c97f8ad 100644
--- a/drivers/usb/host/xhci.h
+++ b/drivers/usb/host/xhci.h
@@ -1605,6 +1605,7 @@ struct xhci_hcd {
  */
 #define XHCI_STATE_DYING        (1 << 0)
 #define XHCI_STATE_HALTED       (1 << 1)
+#define XHCI_STATE_REMOVING     (1 << 2)
         /* Statistics */
         int                     error_bitmask;
         unsigned int            quirks;
@@ -1641,6 +1642,7 @@ struct xhci_hcd {
 #define XHCI_PME_STUCK_QUIRK    (1 << 20)
 #define XHCI_MTK_HOST           (1 << 21)
 #define XHCI_SSIC_PORT_UNUSED   (1 << 22)
+#define XHCI_NO_64BIT_SUPPORT   (1 << 23)
         unsigned int            num_active_eps;
         unsigned int            limit_active_eps;
         /* There are two roothubs to keep track of bus suspend info for */
diff --git a/drivers/usb/musb/jz4740.c b/drivers/usb/musb/jz4740.c
index 5e5a8fa005f8..bc8889956d17 100644
--- a/drivers/usb/musb/jz4740.c
+++ b/drivers/usb/musb/jz4740.c
@@ -83,9 +83,9 @@ static int jz4740_musb_init(struct musb *musb)
 {
         usb_phy_generic_register();
         musb->xceiv = usb_get_phy(USB_PHY_TYPE_USB2);
-        if (!musb->xceiv) {
+        if (IS_ERR(musb->xceiv)) {
                 pr_err("HS UDC: no transceiver configured\n");
-                return -ENODEV;
+                return PTR_ERR(musb->xceiv);
         }
 
         /* Silicon does not implement ConfigData register.
diff --git a/drivers/usb/musb/musb_gadget.c b/drivers/usb/musb/musb_gadget.c
index 87bd578799a8..152865b36522 100644
--- a/drivers/usb/musb/musb_gadget.c
+++ b/drivers/usb/musb/musb_gadget.c
@@ -1164,12 +1164,12 @@ static int musb_gadget_disable(struct usb_ep *ep)
                 musb_writew(epio, MUSB_RXMAXP, 0);
         }
 
-        musb_ep->desc = NULL;
-        musb_ep->end_point.desc = NULL;
-
         /* abort all pending DMA and requests */
         nuke(musb_ep, -ESHUTDOWN);
 
+        musb_ep->desc = NULL;
+        musb_ep->end_point.desc = NULL;
+
         schedule_work(&musb->irq_work);
 
         spin_unlock_irqrestore(&(musb->lock), flags);
diff --git a/drivers/usb/musb/musb_host.c b/drivers/usb/musb/musb_host.c
index 58487a473521..2f8ad7f1f482 100644
--- a/drivers/usb/musb/musb_host.c
+++ b/drivers/usb/musb/musb_host.c
@@ -2735,7 +2735,7 @@ static const struct hc_driver musb_hc_driver = {
         .description            = "musb-hcd",
         .product_desc           = "MUSB HDRC host driver",
         .hcd_priv_size          = sizeof(struct musb *),
-        .flags                  = HCD_USB2 | HCD_MEMORY | HCD_BH,
+        .flags                  = HCD_USB2 | HCD_MEMORY,
 
         /* not using irq handler or reset hooks from usbcore, since
          * those must be shared with peripheral code for OTG configs
diff --git a/drivers/usb/phy/phy-qcom-8x16-usb.c b/drivers/usb/phy/phy-qcom-8x16-usb.c
index 579587d97217..3d7af85aecb9 100644
--- a/drivers/usb/phy/phy-qcom-8x16-usb.c
+++ b/drivers/usb/phy/phy-qcom-8x16-usb.c
@@ -65,9 +65,7 @@ struct phy_8x16 {
         void __iomem                    *regs;
         struct clk                      *core_clk;
         struct clk                      *iface_clk;
-        struct regulator                *v3p3;
-        struct regulator                *v1p8;
-        struct regulator                *vdd;
+        struct regulator_bulk_data      regulator[3];
 
         struct reset_control            *phy_reset;
 
@@ -78,51 +76,6 @@ struct phy_8x16 {
         struct notifier_block           reboot_notify;
 };
 
-static int phy_8x16_regulators_enable(struct phy_8x16 *qphy)
-{
-        int ret;
-
-        ret = regulator_set_voltage(qphy->vdd, HSPHY_VDD_MIN, HSPHY_VDD_MAX);
-        if (ret)
-                return ret;
-
-        ret = regulator_enable(qphy->vdd);
-        if (ret)
-                return ret;
-
-        ret = regulator_set_voltage(qphy->v3p3, HSPHY_3P3_MIN, HSPHY_3P3_MAX);
-        if (ret)
-                goto off_vdd;
-
-        ret = regulator_enable(qphy->v3p3);
-        if (ret)
-                goto off_vdd;
-
-        ret = regulator_set_voltage(qphy->v1p8, HSPHY_1P8_MIN, HSPHY_1P8_MAX);
-        if (ret)
-                goto off_3p3;
-
-        ret = regulator_enable(qphy->v1p8);
-        if (ret)
-                goto off_3p3;
-
-        return 0;
-
-off_3p3:
-        regulator_disable(qphy->v3p3);
-off_vdd:
-        regulator_disable(qphy->vdd);
-
-        return ret;
-}
-
-static void phy_8x16_regulators_disable(struct phy_8x16 *qphy)
-{
-        regulator_disable(qphy->v1p8);
-        regulator_disable(qphy->v3p3);
-        regulator_disable(qphy->vdd);
-}
-
 static int phy_8x16_notify_connect(struct usb_phy *phy,
                                    enum usb_device_speed speed)
 {
@@ -261,7 +214,6 @@ static void phy_8x16_shutdown(struct usb_phy *phy)
 
 static int phy_8x16_read_devicetree(struct phy_8x16 *qphy)
 {
-        struct regulator_bulk_data regs[3];
         struct device *dev = qphy->phy.dev;
         int ret;
 
@@ -273,18 +225,15 @@ static int phy_8x16_read_devicetree(struct phy_8x16 *qphy)
         if (IS_ERR(qphy->iface_clk))
                 return PTR_ERR(qphy->iface_clk);
 
-        regs[0].supply = "v3p3";
-        regs[1].supply = "v1p8";
-        regs[2].supply = "vddcx";
+        qphy->regulator[0].supply = "v3p3";
+        qphy->regulator[1].supply = "v1p8";
+        qphy->regulator[2].supply = "vddcx";
 
-        ret = devm_regulator_bulk_get(dev, ARRAY_SIZE(regs), regs);
+        ret = devm_regulator_bulk_get(dev, ARRAY_SIZE(qphy->regulator),
+                                      qphy->regulator);
         if (ret)
                 return ret;
 
-        qphy->v3p3 = regs[0].consumer;
-        qphy->v1p8 = regs[1].consumer;
-        qphy->vdd  = regs[2].consumer;
-
         qphy->phy_reset = devm_reset_control_get(dev, "phy");
         if (IS_ERR(qphy->phy_reset))
                 return PTR_ERR(qphy->phy_reset);
@@ -364,8 +313,9 @@ static int phy_8x16_probe(struct platform_device *pdev)
         if (ret < 0)
                 goto off_core;
 
-        ret = phy_8x16_regulators_enable(qphy);
-        if (0 && ret)
+        ret = regulator_bulk_enable(ARRAY_SIZE(qphy->regulator),
+                                    qphy->regulator);
+        if (WARN_ON(ret))
                 goto off_clks;
 
         qphy->vbus_notify.notifier_call = phy_8x16_vbus_notify;
@@ -387,7 +337,7 @@ off_extcon:
         extcon_unregister_notifier(qphy->vbus_edev, EXTCON_USB,
                                    &qphy->vbus_notify);
 off_power:
-        phy_8x16_regulators_disable(qphy);
+        regulator_bulk_disable(ARRAY_SIZE(qphy->regulator), qphy->regulator);
 off_clks:
         clk_disable_unprepare(qphy->iface_clk);
 off_core:
@@ -413,7 +363,7 @@ static int phy_8x16_remove(struct platform_device *pdev)
 
         clk_disable_unprepare(qphy->iface_clk);
         clk_disable_unprepare(qphy->core_clk);
-        phy_8x16_regulators_disable(qphy);
+        regulator_bulk_disable(ARRAY_SIZE(qphy->regulator), qphy->regulator);
         return 0;
 }
 
diff --git a/drivers/usb/renesas_usbhs/fifo.c b/drivers/usb/renesas_usbhs/fifo.c
index b4de70ee16d3..000f9750149f 100644
--- a/drivers/usb/renesas_usbhs/fifo.c
+++ b/drivers/usb/renesas_usbhs/fifo.c
@@ -190,7 +190,8 @@ static int usbhsf_pkt_handler(struct usbhs_pipe *pipe, int type)
                 goto __usbhs_pkt_handler_end;
         }
 
-        ret = func(pkt, &is_done);
+        if (likely(func))
+                ret = func(pkt, &is_done);
 
         if (is_done)
                 __usbhsf_pkt_del(pkt);
@@ -889,6 +890,7 @@ static int usbhsf_dma_prepare_push(struct usbhs_pkt *pkt, int *is_done)
 
         pkt->trans = len;
 
+        usbhsf_tx_irq_ctrl(pipe, 0);
         INIT_WORK(&pkt->work, xfer_work);
         schedule_work(&pkt->work);
 
diff --git a/drivers/usb/renesas_usbhs/mod_gadget.c b/drivers/usb/renesas_usbhs/mod_gadget.c
index 664b263e4b20..53d104b56ef1 100644
--- a/drivers/usb/renesas_usbhs/mod_gadget.c
+++ b/drivers/usb/renesas_usbhs/mod_gadget.c
@@ -158,10 +158,14 @@ static void usbhsg_queue_done(struct usbhs_priv *priv, struct usbhs_pkt *pkt)
         struct usbhs_pipe *pipe = pkt->pipe;
         struct usbhsg_uep *uep = usbhsg_pipe_to_uep(pipe);
         struct usbhsg_request *ureq = usbhsg_pkt_to_ureq(pkt);
+        unsigned long flags;
 
         ureq->req.actual = pkt->actual;
 
-        usbhsg_queue_pop(uep, ureq, 0);
+        usbhs_lock(priv, flags);
+        if (uep)
+                __usbhsg_queue_pop(uep, ureq, 0);
+        usbhs_unlock(priv, flags);
 }
 
 static void usbhsg_queue_push(struct usbhsg_uep *uep,
diff --git a/drivers/usb/serial/cp210x.c b/drivers/usb/serial/cp210x.c
index fbfe761c7fba..7c9f25e9c422 100644
--- a/drivers/usb/serial/cp210x.c
+++ b/drivers/usb/serial/cp210x.c
@@ -109,6 +109,7 @@ static const struct usb_device_id id_table[] = {
         { USB_DEVICE(0x10C4, 0x826B) }, /* Cygnal Integrated Products, Inc., Fasttrax GPS demonstration module */
         { USB_DEVICE(0x10C4, 0x8281) }, /* Nanotec Plug & Drive */
         { USB_DEVICE(0x10C4, 0x8293) }, /* Telegesis ETRX2USB */
+        { USB_DEVICE(0x10C4, 0x82F4) }, /* Starizona MicroTouch */
         { USB_DEVICE(0x10C4, 0x82F9) }, /* Procyon AVS */
         { USB_DEVICE(0x10C4, 0x8341) }, /* Siemens MC35PU GPRS Modem */
         { USB_DEVICE(0x10C4, 0x8382) }, /* Cygnal Integrated Products, Inc. */
@@ -118,6 +119,7 @@ static const struct usb_device_id id_table[] = {
         { USB_DEVICE(0x10C4, 0x8418) }, /* IRZ Automation Teleport SG-10 GSM/GPRS Modem */
         { USB_DEVICE(0x10C4, 0x846E) }, /* BEI USB Sensor Interface (VCP) */
         { USB_DEVICE(0x10C4, 0x8477) }, /* Balluff RFID */
+        { USB_DEVICE(0x10C4, 0x84B6) }, /* Starizona Hyperion */
         { USB_DEVICE(0x10C4, 0x85EA) }, /* AC-Services IBUS-IF */
         { USB_DEVICE(0x10C4, 0x85EB) }, /* AC-Services CIS-IBUS */
         { USB_DEVICE(0x10C4, 0x85F8) }, /* Virtenio Preon32 */
@@ -141,6 +143,8 @@ static const struct usb_device_id id_table[] = {
         { USB_DEVICE(0x10C4, 0xF004) }, /* Elan Digital Systems USBcount50 */
         { USB_DEVICE(0x10C5, 0xEA61) }, /* Silicon Labs MobiData GPRS USB Modem */
         { USB_DEVICE(0x10CE, 0xEA6A) }, /* Silicon Labs MobiData GPRS USB Modem 100EU */
+        { USB_DEVICE(0x12B8, 0xEC60) }, /* Link G4 ECU */
+        { USB_DEVICE(0x12B8, 0xEC62) }, /* Link G4+ ECU */
         { USB_DEVICE(0x13AD, 0x9999) }, /* Baltech card reader */
         { USB_DEVICE(0x1555, 0x0004) }, /* Owen AC4 USB-RS485 Converter */
         { USB_DEVICE(0x166A, 0x0201) }, /* Clipsal 5500PACA C-Bus Pascal Automation Controller */
@@ -165,6 +169,7 @@ static const struct usb_device_id id_table[] = {
         { USB_DEVICE(0x18EF, 0xE025) }, /* ELV Marble Sound Board 1 */
         { USB_DEVICE(0x1901, 0x0190) }, /* GE B850 CP2105 Recorder interface */
         { USB_DEVICE(0x1901, 0x0193) }, /* GE B650 CP2104 PMC interface */
+        { USB_DEVICE(0x1901, 0x0194) }, /* GE Healthcare Remote Alarm Box */
         { USB_DEVICE(0x19CF, 0x3000) }, /* Parrot NMEA GPS Flight Recorder */
         { USB_DEVICE(0x1ADB, 0x0001) }, /* Schweitzer Engineering C662 Cable */
         { USB_DEVICE(0x1B1C, 0x1C00) }, /* Corsair USB Dongle */
diff --git a/drivers/usb/serial/cypress_m8.c b/drivers/usb/serial/cypress_m8.c
index b283eb8b86d6..bbeeb2bd55a8 100644
--- a/drivers/usb/serial/cypress_m8.c
+++ b/drivers/usb/serial/cypress_m8.c
@@ -447,6 +447,11 @@ static int cypress_generic_port_probe(struct usb_serial_port *port)
         struct usb_serial *serial = port->serial;
         struct cypress_private *priv;
 
+        if (!port->interrupt_out_urb || !port->interrupt_in_urb) {
+                dev_err(&port->dev, "required endpoint is missing\n");
+                return -ENODEV;
+        }
+
         priv = kzalloc(sizeof(struct cypress_private), GFP_KERNEL);
         if (!priv)
                 return -ENOMEM;
@@ -606,12 +611,6 @@ static int cypress_open(struct tty_struct *tty, struct usb_serial_port *port)
                 cypress_set_termios(tty, port, &priv->tmp_termios);
 
         /* setup the port and start reading from the device */
-        if (!port->interrupt_in_urb) {
-                dev_err(&port->dev, "%s - interrupt_in_urb is empty!\n",
-                        __func__);
-                return -1;
-        }
-
         usb_fill_int_urb(port->interrupt_in_urb, serial->dev,
                 usb_rcvintpipe(serial->dev, port->interrupt_in_endpointAddress),
                 port->interrupt_in_urb->transfer_buffer,
diff --git a/drivers/usb/serial/digi_acceleport.c b/drivers/usb/serial/digi_acceleport.c
index 010a42a92688..16e8e37b3b36 100644
--- a/drivers/usb/serial/digi_acceleport.c
+++ b/drivers/usb/serial/digi_acceleport.c
@@ -1251,8 +1251,27 @@ static int digi_port_init(struct usb_serial_port *port, unsigned port_num)
 
 static int digi_startup(struct usb_serial *serial)
 {
+        struct device *dev = &serial->interface->dev;
         struct digi_serial *serial_priv;
         int ret;
+        int i;
+
+        /* check whether the device has the expected number of endpoints */
+        if (serial->num_port_pointers < serial->type->num_ports + 1) {
+                dev_err(dev, "OOB endpoints missing\n");
+                return -ENODEV;
+        }
+
+        for (i = 0; i < serial->type->num_ports + 1 ; i++) {
+                if (!serial->port[i]->read_urb) {
+                        dev_err(dev, "bulk-in endpoint missing\n");
+                        return -ENODEV;
+                }
+                if (!serial->port[i]->write_urb) {
+                        dev_err(dev, "bulk-out endpoint missing\n");
+                        return -ENODEV;
+                }
+        }
 
         serial_priv = kzalloc(sizeof(*serial_priv), GFP_KERNEL);
         if (!serial_priv)
diff --git a/drivers/usb/serial/ftdi_sio.c b/drivers/usb/serial/ftdi_sio.c
index 427ae43ee898..3a814e802dee 100644
--- a/drivers/usb/serial/ftdi_sio.c
+++ b/drivers/usb/serial/ftdi_sio.c
@@ -1004,6 +1004,10 @@ static const struct usb_device_id id_table_combined[] = {
         { USB_DEVICE(FTDI_VID, CHETCO_SEASMART_DISPLAY_PID) },
         { USB_DEVICE(FTDI_VID, CHETCO_SEASMART_LITE_PID) },
         { USB_DEVICE(FTDI_VID, CHETCO_SEASMART_ANALOG_PID) },
+        /* ICP DAS I-756xU devices */
+        { USB_DEVICE(ICPDAS_VID, ICPDAS_I7560U_PID) },
+        { USB_DEVICE(ICPDAS_VID, ICPDAS_I7561U_PID) },
+        { USB_DEVICE(ICPDAS_VID, ICPDAS_I7563U_PID) },
         { }                                     /* Terminating entry */
 };
 
diff --git a/drivers/usb/serial/ftdi_sio_ids.h b/drivers/usb/serial/ftdi_sio_ids.h
index a84df2513994..c5d6c1e73e8e 100644
--- a/drivers/usb/serial/ftdi_sio_ids.h
+++ b/drivers/usb/serial/ftdi_sio_ids.h
@@ -872,6 +872,14 @@
 #define NOVITUS_BONO_E_PID              0x6010
 
 /*
+ * ICPDAS I-756*U devices
+ */
+#define ICPDAS_VID                      0x1b5c
+#define ICPDAS_I7560U_PID               0x0103
+#define ICPDAS_I7561U_PID               0x0104
+#define ICPDAS_I7563U_PID               0x0105
+
+/*
  * RT Systems programming cables for various ham radios
  */
 #define RTSYSTEMS_VID           0x2100  /* Vendor ID */
diff --git a/drivers/usb/serial/mct_u232.c b/drivers/usb/serial/mct_u232.c
index 4446b8d70ac2..885655315de1 100644
--- a/drivers/usb/serial/mct_u232.c
+++ b/drivers/usb/serial/mct_u232.c
@@ -376,14 +376,21 @@ static void mct_u232_msr_to_state(struct usb_serial_port *port,
 
 static int mct_u232_port_probe(struct usb_serial_port *port)
 {
+        struct usb_serial *serial = port->serial;
         struct mct_u232_private *priv;
 
+        /* check first to simplify error handling */
+        if (!serial->port[1] || !serial->port[1]->interrupt_in_urb) {
+                dev_err(&port->dev, "expected endpoint missing\n");
+                return -ENODEV;
+        }
+
         priv = kzalloc(sizeof(*priv), GFP_KERNEL);
         if (!priv)
                 return -ENOMEM;
 
         /* Use second interrupt-in endpoint for reading. */
-        priv->read_urb = port->serial->port[1]->interrupt_in_urb;
+        priv->read_urb = serial->port[1]->interrupt_in_urb;
         priv->read_urb->context = port;
 
         spin_lock_init(&priv->lock);
diff --git a/drivers/usb/serial/option.c b/drivers/usb/serial/option.c
index 348e19834b83..c6f497f16526 100644
--- a/drivers/usb/serial/option.c
+++ b/drivers/usb/serial/option.c
@@ -1818,6 +1818,8 @@ static const struct usb_device_id option_ids[] = {
         { USB_DEVICE_AND_INTERFACE_INFO(0x2001, 0x7d02, 0xff, 0x00, 0x00) },
         { USB_DEVICE_AND_INTERFACE_INFO(0x2001, 0x7d03, 0xff, 0x02, 0x01) },
         { USB_DEVICE_AND_INTERFACE_INFO(0x2001, 0x7d03, 0xff, 0x00, 0x00) },
+        { USB_DEVICE_INTERFACE_CLASS(0x2001, 0x7e19, 0xff),                     /* D-Link DWM-221 B1 */
+          .driver_info = (kernel_ulong_t)&net_intf4_blacklist },
         { USB_DEVICE_AND_INTERFACE_INFO(0x07d1, 0x3e01, 0xff, 0xff, 0xff) }, /* D-Link DWM-152/C1 */
         { USB_DEVICE_AND_INTERFACE_INFO(0x07d1, 0x3e02, 0xff, 0xff, 0xff) }, /* D-Link DWM-156/C1 */
         { USB_DEVICE_INTERFACE_CLASS(0x2020, 0x4000, 0xff) },                /* OLICARD300 - MT6225 */
diff --git a/drivers/usb/storage/scsiglue.c b/drivers/usb/storage/scsiglue.c
index dba51362d2e2..90901861bfc0 100644
--- a/drivers/usb/storage/scsiglue.c
+++ b/drivers/usb/storage/scsiglue.c
@@ -123,7 +123,7 @@ static int slave_configure(struct scsi_device *sdev)
                 unsigned int max_sectors = 64;
 
                 if (us->fflags & US_FL_MAX_SECTORS_MIN)
-                        max_sectors = PAGE_CACHE_SIZE >> 9;
+                        max_sectors = PAGE_SIZE >> 9;
                 if (queue_max_hw_sectors(sdev->request_queue) > max_sectors)
                         blk_queue_max_hw_sectors(sdev->request_queue,
                                               max_sectors);
diff --git a/drivers/usb/storage/uas.c b/drivers/usb/storage/uas.c
index 13e4cc31bc79..16bc679dc2fc 100644
--- a/drivers/usb/storage/uas.c
+++ b/drivers/usb/storage/uas.c
@@ -2,7 +2,7 @@
  * USB Attached SCSI
  * Note that this is not the same as the USB Mass Storage driver
  *
- * Copyright Hans de Goede <hdegoede@redhat.com> for Red Hat, Inc. 2013 - 2014
+ * Copyright Hans de Goede <hdegoede@redhat.com> for Red Hat, Inc. 2013 - 2016
  * Copyright Matthew Wilcox for Intel Corp, 2010
  * Copyright Sarah Sharp for Intel Corp, 2010
  *
@@ -781,6 +781,17 @@ static int uas_eh_bus_reset_handler(struct scsi_cmnd *cmnd)
         return SUCCESS;
 }
 
+static int uas_target_alloc(struct scsi_target *starget)
+{
+        struct uas_dev_info *devinfo = (struct uas_dev_info *)
+                        dev_to_shost(starget->dev.parent)->hostdata;
+
+        if (devinfo->flags & US_FL_NO_REPORT_LUNS)
+                starget->no_report_luns = 1;
+
+        return 0;
+}
+
 static int uas_slave_alloc(struct scsi_device *sdev)
 {
         struct uas_dev_info *devinfo =
@@ -824,7 +835,6 @@ static int uas_slave_configure(struct scsi_device *sdev)
         if (devinfo->flags & US_FL_BROKEN_FUA)
                 sdev->broken_fua = 1;
 
-        scsi_change_queue_depth(sdev, devinfo->qdepth - 2);
         return 0;
 }
 
@@ -832,6 +842,7 @@ static struct scsi_host_template uas_host_template = {
         .module = THIS_MODULE,
         .name = "uas",
         .queuecommand = uas_queuecommand,
+        .target_alloc = uas_target_alloc,
         .slave_alloc = uas_slave_alloc,
         .slave_configure = uas_slave_configure,
         .eh_abort_handler = uas_eh_abort_handler,
@@ -956,6 +967,12 @@ static int uas_probe(struct usb_interface *intf, const struct usb_device_id *id)
         if (result)
                 goto set_alt0;
 
+        /*
+         * 1 tag is reserved for untagged commands +
+         * 1 tag to avoid off by one errors in some bridge firmwares
+         */
+        shost->can_queue = devinfo->qdepth - 2;
+
         usb_set_intfdata(intf, shost);
         result = scsi_add_host(shost, &intf->dev);
         if (result)
diff --git a/drivers/usb/storage/unusual_uas.h b/drivers/usb/storage/unusual_uas.h
index ccc113e83d88..53341a77d89f 100644
--- a/drivers/usb/storage/unusual_uas.h
+++ b/drivers/usb/storage/unusual_uas.h
@@ -64,6 +64,13 @@ UNUSUAL_DEV(0x0bc2, 0x3312, 0x0000, 0x9999,
                 USB_SC_DEVICE, USB_PR_DEVICE, NULL,
                 US_FL_NO_ATA_1X),
 
+/* Reported-by: David Webb <djw@noc.ac.uk> */
+UNUSUAL_DEV(0x0bc2, 0x331a, 0x0000, 0x9999,
+                "Seagate",
+                "Expansion Desk",
+                USB_SC_DEVICE, USB_PR_DEVICE, NULL,
+                US_FL_NO_REPORT_LUNS),
+
 /* Reported-by: Hans de Goede <hdegoede@redhat.com> */
 UNUSUAL_DEV(0x0bc2, 0x3320, 0x0000, 0x9999,
                 "Seagate",
diff --git a/drivers/usb/storage/usb.c b/drivers/usb/storage/usb.c
index 43576ed31ccd..9de988a0f856 100644
--- a/drivers/usb/storage/usb.c
+++ b/drivers/usb/storage/usb.c
@@ -482,7 +482,7 @@ void usb_stor_adjust_quirks(struct usb_device *udev, unsigned long *fflags)
                         US_FL_NO_READ_DISC_INFO | US_FL_NO_READ_CAPACITY_16 |
                         US_FL_INITIAL_READ10 | US_FL_WRITE_CACHE |
                         US_FL_NO_ATA_1X | US_FL_NO_REPORT_OPCODES |
-                        US_FL_MAX_SECTORS_240);
+                        US_FL_MAX_SECTORS_240 | US_FL_NO_REPORT_LUNS);
 
         p = quirks;
         while (*p) {
@@ -532,6 +532,9 @@ void usb_stor_adjust_quirks(struct usb_device *udev, unsigned long *fflags)
                 case 'i':
                         f |= US_FL_IGNORE_DEVICE;
                         break;
+                case 'j':
+                        f |= US_FL_NO_REPORT_LUNS;
+                        break;
                 case 'l':
                         f |= US_FL_NOT_LOCKABLE;
                         break;
diff --git a/drivers/usb/usbip/usbip_common.c b/drivers/usb/usbip/usbip_common.c
index facaaf003f19..e40da7759a0e 100644
--- a/drivers/usb/usbip/usbip_common.c
+++ b/drivers/usb/usbip/usbip_common.c
@@ -741,6 +741,17 @@ int usbip_recv_xbuff(struct usbip_device *ud, struct urb *urb)
         if (!(size > 0))
                 return 0;
 
+        if (size > urb->transfer_buffer_length) {
+                /* should not happen, probably malicious packet */
+                if (ud->side == USBIP_STUB) {
+                        usbip_event_add(ud, SDEV_EVENT_ERROR_TCP);
+                        return 0;
+                } else {
+                        usbip_event_add(ud, VDEV_EVENT_ERROR_TCP);
+                        return -EPIPE;
+                }
+        }
+
         ret = usbip_recv(ud->tcp_socket, urb->transfer_buffer, size);
         if (ret != size) {
                 dev_err(&urb->dev->dev, "recv xbuf, %d\n", ret);
diff --git a/drivers/video/fbdev/amba-clcd.c b/drivers/video/fbdev/amba-clcd.c
index fe274b5851c7..93e66a9148b9 100644
--- a/drivers/video/fbdev/amba-clcd.c
+++ b/drivers/video/fbdev/amba-clcd.c
@@ -440,13 +440,14 @@ static int clcdfb_register(struct clcd_fb *fb)
                 fb->off_ienb = CLCD_PL111_IENB;
                 fb->off_cntl = CLCD_PL111_CNTL;
         } else {
-#ifdef CONFIG_ARCH_VERSATILE
-                fb->off_ienb = CLCD_PL111_IENB;
-                fb->off_cntl = CLCD_PL111_CNTL;
-#else
-                fb->off_ienb = CLCD_PL110_IENB;
-                fb->off_cntl = CLCD_PL110_CNTL;
-#endif
+                if (of_machine_is_compatible("arm,versatile-ab") ||
+                    of_machine_is_compatible("arm,versatile-pb")) {
+                        fb->off_ienb = CLCD_PL111_IENB;
+                        fb->off_cntl = CLCD_PL111_CNTL;
+                } else {
+                        fb->off_ienb = CLCD_PL110_IENB;
+                        fb->off_cntl = CLCD_PL110_CNTL;
+                }
         }
 
         fb->clk = clk_get(&fb->dev->dev, NULL);
diff --git a/drivers/video/fbdev/omap2/omapfb/displays/panel-sharp-ls037v7dw01.c b/drivers/video/fbdev/omap2/omapfb/displays/panel-sharp-ls037v7dw01.c
index abfd1f6e3327..1954ec913ce5 100644
--- a/drivers/video/fbdev/omap2/omapfb/displays/panel-sharp-ls037v7dw01.c
+++ b/drivers/video/fbdev/omap2/omapfb/displays/panel-sharp-ls037v7dw01.c
@@ -200,20 +200,16 @@ static struct omap_dss_driver sharp_ls_ops = {
 static int sharp_ls_get_gpio(struct device *dev, int gpio, unsigned long flags,
                   char *desc, struct gpio_desc **gpiod)
 {
-        struct gpio_desc *gd;
         int r;
 
-        *gpiod = NULL;
-
         r = devm_gpio_request_one(dev, gpio, flags, desc);
-        if (r)
+        if (r) {
+                *gpiod = NULL;
                 return r == -ENOENT ? 0 : r;
+        }
 
-        gd = gpio_to_desc(gpio);
-        if (IS_ERR(gd))
-                return PTR_ERR(gd) == -ENOENT ? 0 : PTR_ERR(gd);
+        *gpiod = gpio_to_desc(gpio);
 
-        *gpiod = gd;
         return 0;
 }
 
diff --git a/drivers/video/fbdev/pvr2fb.c b/drivers/video/fbdev/pvr2fb.c
index 71a923e53f93..3b1ca4411073 100644
--- a/drivers/video/fbdev/pvr2fb.c
+++ b/drivers/video/fbdev/pvr2fb.c
@@ -735,7 +735,7 @@ out:
 
 out_unmap:
         for (i = 0; i < nr_pages; i++)
-                page_cache_release(pages[i]);
+                put_page(pages[i]);
 
         kfree(pages);
 
diff --git a/drivers/virtio/virtio_pci_modern.c b/drivers/virtio/virtio_pci_modern.c
index f6f28cc7eb45..e76bd91a29da 100644
--- a/drivers/virtio/virtio_pci_modern.c
+++ b/drivers/virtio/virtio_pci_modern.c
@@ -17,6 +17,7 @@
  *
  */
 
+#include <linux/delay.h>
 #define VIRTIO_PCI_NO_LEGACY
 #include "virtio_pci_common.h"
 
@@ -271,9 +272,13 @@ static void vp_reset(struct virtio_device *vdev)
         struct virtio_pci_device *vp_dev = to_vp_device(vdev);
         /* 0 status means a reset. */
         vp_iowrite8(0, &vp_dev->common->device_status);
-        /* Flush out the status write, and flush in device writes,
-         * including MSI-X interrupts, if any. */
-        vp_ioread8(&vp_dev->common->device_status);
+        /* After writing 0 to device_status, the driver MUST wait for a read of
+         * device_status to return 0 before reinitializing the device.
+         * This will flush out the status write, and flush in device writes,
+         * including MSI-X interrupts, if any.
+         */
+        while (vp_ioread8(&vp_dev->common->device_status))
+                msleep(1);
         /* Flush pending VQ/configuration callbacks. */
         vp_synchronize_vectors(vdev);
 }
diff --git a/drivers/virtio/virtio_ring.c b/drivers/virtio/virtio_ring.c
index 5c802d47892c..ca6bfddaacad 100644
--- a/drivers/virtio/virtio_ring.c
+++ b/drivers/virtio/virtio_ring.c
@@ -1006,7 +1006,7 @@ struct virtqueue *vring_create_virtqueue(
         const char *name)
 {
         struct virtqueue *vq;
-        void *queue;
+        void *queue = NULL;
         dma_addr_t dma_addr;
         size_t queue_size_in_bytes;
         struct vring vring;
diff --git a/drivers/xen/balloon.c b/drivers/xen/balloon.c
index 9781e0dd59d6..d46839f51e73 100644
--- a/drivers/xen/balloon.c
+++ b/drivers/xen/balloon.c
@@ -151,6 +151,8 @@ static DECLARE_WAIT_QUEUE_HEAD(balloon_wq);
 static void balloon_process(struct work_struct *work);
 static DECLARE_DELAYED_WORK(balloon_worker, balloon_process);
 
+static void release_memory_resource(struct resource *resource);
+
 /* When ballooning out (allocating memory to return to Xen) we don't really
    want the kernel to try too hard since that can trigger the oom killer. */
 #define GFP_BALLOON \
@@ -267,6 +269,20 @@ static struct resource *additional_memory_resource(phys_addr_t size)
                 return NULL;
         }
 
+#ifdef CONFIG_SPARSEMEM
+        {
+                unsigned long limit = 1UL << (MAX_PHYSMEM_BITS - PAGE_SHIFT);
+                unsigned long pfn = res->start >> PAGE_SHIFT;
+
+                if (pfn > limit) {
+                        pr_err("New System RAM resource outside addressable RAM (%lu > %lu)\n",
+                               pfn, limit);
+                        release_memory_resource(res);
+                        return NULL;
+                }
+        }
+#endif
+
         return res;
 }
 
diff --git a/drivers/xen/events/events_base.c b/drivers/xen/events/events_base.c
index 488017a0806a..cb7138c97c69 100644
--- a/drivers/xen/events/events_base.c
+++ b/drivers/xen/events/events_base.c
@@ -484,9 +484,19 @@ static void eoi_pirq(struct irq_data *data)
         struct physdev_eoi eoi = { .irq = pirq_from_irq(data->irq) };
         int rc = 0;
 
-        irq_move_irq(data);
+        if (!VALID_EVTCHN(evtchn))
+                return;
 
-        if (VALID_EVTCHN(evtchn))
+        if (unlikely(irqd_is_setaffinity_pending(data))) {
+                int masked = test_and_set_mask(evtchn);
+
+                clear_evtchn(evtchn);
+
+                irq_move_masked_irq(data);
+
+                if (!masked)
+                        unmask_evtchn(evtchn);
+        } else
                 clear_evtchn(evtchn);
 
         if (pirq_needs_eoi(data->irq)) {
@@ -1357,9 +1367,19 @@ static void ack_dynirq(struct irq_data *data)
 {
         int evtchn = evtchn_from_irq(data->irq);
 
-        irq_move_irq(data);
+        if (!VALID_EVTCHN(evtchn))
+                return;
 
-        if (VALID_EVTCHN(evtchn))
+        if (unlikely(irqd_is_setaffinity_pending(data))) {
+                int masked = test_and_set_mask(evtchn);
+
+                clear_evtchn(evtchn);
+
+                irq_move_masked_irq(data);
+
+                if (!masked)
+                        unmask_evtchn(evtchn);
+        } else
                 clear_evtchn(evtchn);
 }
 
diff --git a/drivers/xen/evtchn.c b/drivers/xen/evtchn.c
index 38272ad24551..f4edd6df3df2 100644
--- a/drivers/xen/evtchn.c
+++ b/drivers/xen/evtchn.c
@@ -316,7 +316,6 @@ static int evtchn_resize_ring(struct per_user_data *u)
 {
         unsigned int new_size;
         evtchn_port_t *new_ring, *old_ring;
-        unsigned int p, c;
 
         /*
          * Ensure the ring is large enough to capture all possible
@@ -346,20 +345,17 @@ static int evtchn_resize_ring(struct per_user_data *u)
         /*
          * Copy the old ring contents to the new ring.
          *
-         * If the ring contents crosses the end of the current ring,
-         * it needs to be copied in two chunks.
+         * To take care of wrapping, a full ring, and the new index
+         * pointing into the second half, simply copy the old contents
+         * twice.
          *
          * +---------+    +------------------+
-         * |34567  12| -> |       1234567    |
-         * +-----p-c-+    +------------------+
+         * |34567  12| -> |34567  1234567  12|
+         * +-----p-c-+    +-------c------p---+
          */
-        p = evtchn_ring_offset(u, u->ring_prod);
-        c = evtchn_ring_offset(u, u->ring_cons);
-        if (p < c) {
-                memcpy(new_ring + c, u->ring + c, (u->ring_size - c) * sizeof(*u->ring));
-                memcpy(new_ring + u->ring_size, u->ring, p * sizeof(*u->ring));
-        } else
-                memcpy(new_ring + c, u->ring + c, (p - c) * sizeof(*u->ring));
+        memcpy(new_ring, old_ring, u->ring_size * sizeof(*u->ring));
+        memcpy(new_ring + u->ring_size, old_ring,
+               u->ring_size * sizeof(*u->ring));
 
         u->ring = new_ring;
         u->ring_size = new_size;