[gentoo-commits] proj/linux-patches:5.8 commit in: /

[Mike Pagano]

commit:     0183b5b10995269f4f30116a291631085336b482
Author:     Mike Pagano <mpagano <AT> gentoo <DOT> org>
AuthorDate: Wed Oct  7 12:47:24 2020 +0000
Commit:     Mike Pagano <mpagano <AT> gentoo <DOT> org>
CommitDate: Wed Oct  7 12:47:24 2020 +0000
URL:        https://gitweb.gentoo.org/proj/linux-patches.git/commit/?id=0183b5b1

Linux patch 5.8.14

Signed-off-by: Mike Pagano <mpagano <AT> gentoo.org>

 0000_README             |    4 +
 1013_linux-5.8.14.patch | 3103 +++++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 3107 insertions(+)

diff --git a/0000_README b/0000_README
index 0944db1..6e16f1d 100644
--- a/0000_README
+++ b/0000_README
@@ -95,6 +95,10 @@ Patch:  1012_linux-5.8.13.patch
 From:   http://www.kernel.org
 Desc:   Linux 5.8.13
 
+Patch:  1013_linux-5.8.14.patch
+From:   http://www.kernel.org
+Desc:   Linux 5.8.14
+
 Patch:  1500_XATTR_USER_PREFIX.patch
 From:   https://bugs.gentoo.org/show_bug.cgi?id=470644
 Desc:   Support for namespace user.pax.* on tmpfs.

diff --git a/1013_linux-5.8.14.patch b/1013_linux-5.8.14.patch
new file mode 100644
index 0000000..fe7cc03
--- /dev/null
+++ b/1013_linux-5.8.14.patch
@@ -0,0 +1,3103 @@
+diff --git a/Documentation/devicetree/bindings/gpio/sgpio-aspeed.txt b/Documentation/devicetree/bindings/gpio/sgpio-aspeed.txt
+index d4d83916c09dd..be329ea4794f8 100644
+--- a/Documentation/devicetree/bindings/gpio/sgpio-aspeed.txt
++++ b/Documentation/devicetree/bindings/gpio/sgpio-aspeed.txt
+@@ -20,8 +20,9 @@ Required properties:
+ - gpio-controller : Marks the device node as a GPIO controller
+ - interrupts : Interrupt specifier, see interrupt-controller/interrupts.txt
+ - interrupt-controller : Mark the GPIO controller as an interrupt-controller
+-- ngpios : number of GPIO lines, see gpio.txt
+-  (should be multiple of 8, up to 80 pins)
++- ngpios : number of *hardware* GPIO lines, see gpio.txt. This will expose
++  2 software GPIOs per hardware GPIO: one for hardware input, one for hardware
++  output. Up to 80 pins, must be a multiple of 8.
+ - clocks : A phandle to the APB clock for SGPM clock division
+ - bus-frequency : SGPM CLK frequency
+ 
+diff --git a/Makefile b/Makefile
+index 0d81d8cba48b6..33ceda527e5ef 100644
+--- a/Makefile
++++ b/Makefile
+@@ -1,7 +1,7 @@
+ # SPDX-License-Identifier: GPL-2.0
+ VERSION = 5
+ PATCHLEVEL = 8
+-SUBLEVEL = 13
++SUBLEVEL = 14
+ EXTRAVERSION =
+ NAME = Kleptomaniac Octopus
+ 
+diff --git a/block/blk-mq.c b/block/blk-mq.c
+index a366726094a89..8e623e0282757 100644
+--- a/block/blk-mq.c
++++ b/block/blk-mq.c
+@@ -1304,6 +1304,11 @@ bool blk_mq_dispatch_rq_list(struct request_queue *q, struct list_head *list,
+ 
+ 	hctx->dispatched[queued_to_index(queued)]++;
+ 
++	/* If we didn't flush the entire list, we could have told the driver
++	 * there was more coming, but that turned out to be a lie.
++	 */
++	if ((!list_empty(list) || errors) && q->mq_ops->commit_rqs && queued)
++		q->mq_ops->commit_rqs(hctx);
+ 	/*
+ 	 * Any items that need requeuing? Stuff them into hctx->dispatch,
+ 	 * that is where we will continue on next queue run.
+@@ -1311,14 +1316,6 @@ bool blk_mq_dispatch_rq_list(struct request_queue *q, struct list_head *list,
+ 	if (!list_empty(list)) {
+ 		bool needs_restart;
+ 
+-		/*
+-		 * If we didn't flush the entire list, we could have told
+-		 * the driver there was more coming, but that turned out to
+-		 * be a lie.
+-		 */
+-		if (q->mq_ops->commit_rqs && queued)
+-			q->mq_ops->commit_rqs(hctx);
+-
+ 		spin_lock(&hctx->lock);
+ 		list_splice_tail_init(list, &hctx->dispatch);
+ 		spin_unlock(&hctx->lock);
+@@ -1971,6 +1968,7 @@ void blk_mq_try_issue_list_directly(struct blk_mq_hw_ctx *hctx,
+ 		struct list_head *list)
+ {
+ 	int queued = 0;
++	int errors = 0;
+ 
+ 	while (!list_empty(list)) {
+ 		blk_status_t ret;
+@@ -1987,6 +1985,7 @@ void blk_mq_try_issue_list_directly(struct blk_mq_hw_ctx *hctx,
+ 				break;
+ 			}
+ 			blk_mq_end_request(rq, ret);
++			errors++;
+ 		} else
+ 			queued++;
+ 	}
+@@ -1996,7 +1995,8 @@ void blk_mq_try_issue_list_directly(struct blk_mq_hw_ctx *hctx,
+ 	 * the driver there was more coming, but that turned out to
+ 	 * be a lie.
+ 	 */
+-	if (!list_empty(list) && hctx->queue->mq_ops->commit_rqs && queued)
++	if ((!list_empty(list) || errors) &&
++	     hctx->queue->mq_ops->commit_rqs && queued)
+ 		hctx->queue->mq_ops->commit_rqs(hctx);
+ }
+ 
+diff --git a/block/blk-settings.c b/block/blk-settings.c
+index 9a2c23cd97007..525bdb699deb8 100644
+--- a/block/blk-settings.c
++++ b/block/blk-settings.c
+@@ -832,6 +832,52 @@ bool blk_queue_can_use_dma_map_merging(struct request_queue *q,
+ }
+ EXPORT_SYMBOL_GPL(blk_queue_can_use_dma_map_merging);
+ 
++/**
++ * blk_queue_set_zoned - configure a disk queue zoned model.
++ * @disk:	the gendisk of the queue to configure
++ * @model:	the zoned model to set
++ *
++ * Set the zoned model of the request queue of @disk according to @model.
++ * When @model is BLK_ZONED_HM (host managed), this should be called only
++ * if zoned block device support is enabled (CONFIG_BLK_DEV_ZONED option).
++ * If @model specifies BLK_ZONED_HA (host aware), the effective model used
++ * depends on CONFIG_BLK_DEV_ZONED settings and on the existence of partitions
++ * on the disk.
++ */
++void blk_queue_set_zoned(struct gendisk *disk, enum blk_zoned_model model)
++{
++	switch (model) {
++	case BLK_ZONED_HM:
++		/*
++		 * Host managed devices are supported only if
++		 * CONFIG_BLK_DEV_ZONED is enabled.
++		 */
++		WARN_ON_ONCE(!IS_ENABLED(CONFIG_BLK_DEV_ZONED));
++		break;
++	case BLK_ZONED_HA:
++		/*
++		 * Host aware devices can be treated either as regular block
++		 * devices (similar to drive managed devices) or as zoned block
++		 * devices to take advantage of the zone command set, similarly
++		 * to host managed devices. We try the latter if there are no
++		 * partitions and zoned block device support is enabled, else
++		 * we do nothing special as far as the block layer is concerned.
++		 */
++		if (!IS_ENABLED(CONFIG_BLK_DEV_ZONED) ||
++		    disk_has_partitions(disk))
++			model = BLK_ZONED_NONE;
++		break;
++	case BLK_ZONED_NONE:
++	default:
++		if (WARN_ON_ONCE(model != BLK_ZONED_NONE))
++			model = BLK_ZONED_NONE;
++		break;
++	}
++
++	disk->queue->limits.zoned = model;
++}
++EXPORT_SYMBOL_GPL(blk_queue_set_zoned);
++
+ static int __init blk_settings_init(void)
+ {
+ 	blk_max_low_pfn = max_low_pfn - 1;
+diff --git a/drivers/clk/samsung/clk-exynos4.c b/drivers/clk/samsung/clk-exynos4.c
+index 51564fc23c639..f4086287bb71b 100644
+--- a/drivers/clk/samsung/clk-exynos4.c
++++ b/drivers/clk/samsung/clk-exynos4.c
+@@ -927,7 +927,7 @@ static const struct samsung_gate_clock exynos4210_gate_clks[] __initconst = {
+ 	GATE(CLK_PCIE, "pcie", "aclk133", GATE_IP_FSYS, 14, 0, 0),
+ 	GATE(CLK_SMMU_PCIE, "smmu_pcie", "aclk133", GATE_IP_FSYS, 18, 0, 0),
+ 	GATE(CLK_MODEMIF, "modemif", "aclk100", GATE_IP_PERIL, 28, 0, 0),
+-	GATE(CLK_CHIPID, "chipid", "aclk100", E4210_GATE_IP_PERIR, 0, 0, 0),
++	GATE(CLK_CHIPID, "chipid", "aclk100", E4210_GATE_IP_PERIR, 0, CLK_IGNORE_UNUSED, 0),
+ 	GATE(CLK_SYSREG, "sysreg", "aclk100", E4210_GATE_IP_PERIR, 0,
+ 			CLK_IGNORE_UNUSED, 0),
+ 	GATE(CLK_HDMI_CEC, "hdmi_cec", "aclk100", E4210_GATE_IP_PERIR, 11, 0,
+@@ -969,7 +969,7 @@ static const struct samsung_gate_clock exynos4x12_gate_clks[] __initconst = {
+ 		0),
+ 	GATE(CLK_TSADC, "tsadc", "aclk133", E4X12_GATE_BUS_FSYS1, 16, 0, 0),
+ 	GATE(CLK_MIPI_HSI, "mipi_hsi", "aclk133", GATE_IP_FSYS, 10, 0, 0),
+-	GATE(CLK_CHIPID, "chipid", "aclk100", E4X12_GATE_IP_PERIR, 0, 0, 0),
++	GATE(CLK_CHIPID, "chipid", "aclk100", E4X12_GATE_IP_PERIR, 0, CLK_IGNORE_UNUSED, 0),
+ 	GATE(CLK_SYSREG, "sysreg", "aclk100", E4X12_GATE_IP_PERIR, 1,
+ 			CLK_IGNORE_UNUSED, 0),
+ 	GATE(CLK_HDMI_CEC, "hdmi_cec", "aclk100", E4X12_GATE_IP_PERIR, 11, 0,
+diff --git a/drivers/clk/samsung/clk-exynos5420.c b/drivers/clk/samsung/clk-exynos5420.c
+index fea33399a632d..bd620876544d9 100644
+--- a/drivers/clk/samsung/clk-exynos5420.c
++++ b/drivers/clk/samsung/clk-exynos5420.c
+@@ -1655,6 +1655,11 @@ static void __init exynos5x_clk_init(struct device_node *np,
+ 	 * main G3D clock enablement status.
+ 	 */
+ 	clk_prepare_enable(__clk_lookup("mout_sw_aclk_g3d"));
++	/*
++	 * Keep top BPLL mux enabled permanently to ensure that DRAM operates
++	 * properly.
++	 */
++	clk_prepare_enable(__clk_lookup("mout_bpll"));
+ 
+ 	samsung_clk_of_add_provider(np, ctx);
+ }
+diff --git a/drivers/clk/socfpga/clk-s10.c b/drivers/clk/socfpga/clk-s10.c
+index c1dfc9b34e4e9..661a8e9bfb9bd 100644
+--- a/drivers/clk/socfpga/clk-s10.c
++++ b/drivers/clk/socfpga/clk-s10.c
+@@ -209,7 +209,7 @@ static const struct stratix10_perip_cnt_clock s10_main_perip_cnt_clks[] = {
+ 	{ STRATIX10_EMAC_B_FREE_CLK, "emacb_free_clk", NULL, emacb_free_mux, ARRAY_SIZE(emacb_free_mux),
+ 	  0, 0, 2, 0xB0, 1},
+ 	{ STRATIX10_EMAC_PTP_FREE_CLK, "emac_ptp_free_clk", NULL, emac_ptp_free_mux,
+-	  ARRAY_SIZE(emac_ptp_free_mux), 0, 0, 4, 0xB0, 2},
++	  ARRAY_SIZE(emac_ptp_free_mux), 0, 0, 2, 0xB0, 2},
+ 	{ STRATIX10_GPIO_DB_FREE_CLK, "gpio_db_free_clk", NULL, gpio_db_free_mux,
+ 	  ARRAY_SIZE(gpio_db_free_mux), 0, 0, 0, 0xB0, 3},
+ 	{ STRATIX10_SDMMC_FREE_CLK, "sdmmc_free_clk", NULL, sdmmc_free_mux,
+diff --git a/drivers/clk/tegra/clk-pll.c b/drivers/clk/tegra/clk-pll.c
+index 0b212cf2e7942..1cc982d3de635 100644
+--- a/drivers/clk/tegra/clk-pll.c
++++ b/drivers/clk/tegra/clk-pll.c
+@@ -1601,9 +1601,6 @@ static int clk_plle_tegra114_enable(struct clk_hw *hw)
+ 	unsigned long flags = 0;
+ 	unsigned long input_rate;
+ 
+-	if (clk_pll_is_enabled(hw))
+-		return 0;
+-
+ 	input_rate = clk_hw_get_rate(clk_hw_get_parent(hw));
+ 
+ 	if (_get_table_rate(hw, &sel, pll->params->fixed_rate, input_rate))
+diff --git a/drivers/clk/tegra/clk-tegra210-emc.c b/drivers/clk/tegra/clk-tegra210-emc.c
+index 352a2c3fc3740..51fd0ec2a2d04 100644
+--- a/drivers/clk/tegra/clk-tegra210-emc.c
++++ b/drivers/clk/tegra/clk-tegra210-emc.c
+@@ -12,6 +12,8 @@
+ #include <linux/io.h>
+ #include <linux/slab.h>
+ 
++#include "clk.h"
++
+ #define CLK_SOURCE_EMC 0x19c
+ #define  CLK_SOURCE_EMC_2X_CLK_SRC GENMASK(31, 29)
+ #define  CLK_SOURCE_EMC_MC_EMC_SAME_FREQ BIT(16)
+diff --git a/drivers/clocksource/timer-gx6605s.c b/drivers/clocksource/timer-gx6605s.c
+index 80d0939d040b5..8d386adbe8009 100644
+--- a/drivers/clocksource/timer-gx6605s.c
++++ b/drivers/clocksource/timer-gx6605s.c
+@@ -28,6 +28,7 @@ static irqreturn_t gx6605s_timer_interrupt(int irq, void *dev)
+ 	void __iomem *base = timer_of_base(to_timer_of(ce));
+ 
+ 	writel_relaxed(GX6605S_STATUS_CLR, base + TIMER_STATUS);
++	writel_relaxed(0, base + TIMER_INI);
+ 
+ 	ce->event_handler(ce);
+ 
+diff --git a/drivers/cpuidle/cpuidle-psci.c b/drivers/cpuidle/cpuidle-psci.c
+index 3806f911b61c0..915172e3ec906 100644
+--- a/drivers/cpuidle/cpuidle-psci.c
++++ b/drivers/cpuidle/cpuidle-psci.c
+@@ -64,7 +64,7 @@ static int psci_enter_domain_idle_state(struct cpuidle_device *dev,
+ 		return -1;
+ 
+ 	/* Do runtime PM to manage a hierarchical CPU toplogy. */
+-	pm_runtime_put_sync_suspend(pd_dev);
++	RCU_NONIDLE(pm_runtime_put_sync_suspend(pd_dev));
+ 
+ 	state = psci_get_domain_state();
+ 	if (!state)
+@@ -72,7 +72,7 @@ static int psci_enter_domain_idle_state(struct cpuidle_device *dev,
+ 
+ 	ret = psci_cpu_suspend_enter(state) ? -1 : idx;
+ 
+-	pm_runtime_get_sync(pd_dev);
++	RCU_NONIDLE(pm_runtime_get_sync(pd_dev));
+ 
+ 	cpu_pm_exit();
+ 
+diff --git a/drivers/dma/dmatest.c b/drivers/dma/dmatest.c
+index 604f803579312..323822372b4ce 100644
+--- a/drivers/dma/dmatest.c
++++ b/drivers/dma/dmatest.c
+@@ -129,6 +129,7 @@ struct dmatest_params {
+  * @nr_channels:	number of channels under test
+  * @lock:		access protection to the fields of this structure
+  * @did_init:		module has been initialized completely
++ * @last_error:		test has faced configuration issues
+  */
+ static struct dmatest_info {
+ 	/* Test parameters */
+@@ -137,6 +138,7 @@ static struct dmatest_info {
+ 	/* Internal state */
+ 	struct list_head	channels;
+ 	unsigned int		nr_channels;
++	int			last_error;
+ 	struct mutex		lock;
+ 	bool			did_init;
+ } test_info = {
+@@ -1175,10 +1177,22 @@ static int dmatest_run_set(const char *val, const struct kernel_param *kp)
+ 		return ret;
+ 	} else if (dmatest_run) {
+ 		if (!is_threaded_test_pending(info)) {
+-			pr_info("No channels configured, continue with any\n");
+-			if (!is_threaded_test_run(info))
+-				stop_threaded_test(info);
+-			add_threaded_test(info);
++			/*
++			 * We have nothing to run. This can be due to:
++			 */
++			ret = info->last_error;
++			if (ret) {
++				/* 1) Misconfiguration */
++				pr_err("Channel misconfigured, can't continue\n");
++				mutex_unlock(&info->lock);
++				return ret;
++			} else {
++				/* 2) We rely on defaults */
++				pr_info("No channels configured, continue with any\n");
++				if (!is_threaded_test_run(info))
++					stop_threaded_test(info);
++				add_threaded_test(info);
++			}
+ 		}
+ 		start_threaded_tests(info);
+ 	} else {
+@@ -1195,7 +1209,7 @@ static int dmatest_chan_set(const char *val, const struct kernel_param *kp)
+ 	struct dmatest_info *info = &test_info;
+ 	struct dmatest_chan *dtc;
+ 	char chan_reset_val[20];
+-	int ret = 0;
++	int ret;
+ 
+ 	mutex_lock(&info->lock);
+ 	ret = param_set_copystring(val, kp);
+@@ -1250,12 +1264,14 @@ static int dmatest_chan_set(const char *val, const struct kernel_param *kp)
+ 		goto add_chan_err;
+ 	}
+ 
++	info->last_error = ret;
+ 	mutex_unlock(&info->lock);
+ 
+ 	return ret;
+ 
+ add_chan_err:
+ 	param_set_copystring(chan_reset_val, kp);
++	info->last_error = ret;
+ 	mutex_unlock(&info->lock);
+ 
+ 	return ret;
+diff --git a/drivers/gpio/gpio-amd-fch.c b/drivers/gpio/gpio-amd-fch.c
+index 4e44ba4d7423c..2a21354ed6a03 100644
+--- a/drivers/gpio/gpio-amd-fch.c
++++ b/drivers/gpio/gpio-amd-fch.c
+@@ -92,7 +92,7 @@ static int amd_fch_gpio_get_direction(struct gpio_chip *gc, unsigned int gpio)
+ 	ret = (readl_relaxed(ptr) & AMD_FCH_GPIO_FLAG_DIRECTION);
+ 	spin_unlock_irqrestore(&priv->lock, flags);
+ 
+-	return ret ? GPIO_LINE_DIRECTION_IN : GPIO_LINE_DIRECTION_OUT;
++	return ret ? GPIO_LINE_DIRECTION_OUT : GPIO_LINE_DIRECTION_IN;
+ }
+ 
+ static void amd_fch_gpio_set(struct gpio_chip *gc,
+diff --git a/drivers/gpio/gpio-aspeed-sgpio.c b/drivers/gpio/gpio-aspeed-sgpio.c
+index d16645c1d8d9d..a0eb00c024f62 100644
+--- a/drivers/gpio/gpio-aspeed-sgpio.c
++++ b/drivers/gpio/gpio-aspeed-sgpio.c
+@@ -17,7 +17,17 @@
+ #include <linux/spinlock.h>
+ #include <linux/string.h>
+ 
+-#define MAX_NR_SGPIO			80
++/*
++ * MAX_NR_HW_GPIO represents the number of actual hardware-supported GPIOs (ie,
++ * slots within the clocked serial GPIO data). Since each HW GPIO is both an
++ * input and an output, we provide MAX_NR_HW_GPIO * 2 lines on our gpiochip
++ * device.
++ *
++ * We use SGPIO_OUTPUT_OFFSET to define the split between the inputs and
++ * outputs; the inputs start at line 0, the outputs start at OUTPUT_OFFSET.
++ */
++#define MAX_NR_HW_SGPIO			80
++#define SGPIO_OUTPUT_OFFSET		MAX_NR_HW_SGPIO
+ 
+ #define ASPEED_SGPIO_CTRL		0x54
+ 
+@@ -30,8 +40,8 @@ struct aspeed_sgpio {
+ 	struct clk *pclk;
+ 	spinlock_t lock;
+ 	void __iomem *base;
+-	uint32_t dir_in[3];
+ 	int irq;
++	int n_sgpio;
+ };
+ 
+ struct aspeed_sgpio_bank {
+@@ -111,31 +121,69 @@ static void __iomem *bank_reg(struct aspeed_sgpio *gpio,
+ 	}
+ }
+ 
+-#define GPIO_BANK(x)    ((x) >> 5)
+-#define GPIO_OFFSET(x)  ((x) & 0x1f)
++#define GPIO_BANK(x)    ((x % SGPIO_OUTPUT_OFFSET) >> 5)
++#define GPIO_OFFSET(x)  ((x % SGPIO_OUTPUT_OFFSET) & 0x1f)
+ #define GPIO_BIT(x)     BIT(GPIO_OFFSET(x))
+ 
+ static const struct aspeed_sgpio_bank *to_bank(unsigned int offset)
+ {
+-	unsigned int bank = GPIO_BANK(offset);
++	unsigned int bank;
++
++	bank = GPIO_BANK(offset);
+ 
+ 	WARN_ON(bank >= ARRAY_SIZE(aspeed_sgpio_banks));
+ 	return &aspeed_sgpio_banks[bank];
+ }
+ 
++static int aspeed_sgpio_init_valid_mask(struct gpio_chip *gc,
++		unsigned long *valid_mask, unsigned int ngpios)
++{
++	struct aspeed_sgpio *sgpio = gpiochip_get_data(gc);
++	int n = sgpio->n_sgpio;
++	int c = SGPIO_OUTPUT_OFFSET - n;
++
++	WARN_ON(ngpios < MAX_NR_HW_SGPIO * 2);
++
++	/* input GPIOs in the lower range */
++	bitmap_set(valid_mask, 0, n);
++	bitmap_clear(valid_mask, n, c);
++
++	/* output GPIOS above SGPIO_OUTPUT_OFFSET */
++	bitmap_set(valid_mask, SGPIO_OUTPUT_OFFSET, n);
++	bitmap_clear(valid_mask, SGPIO_OUTPUT_OFFSET + n, c);
++
++	return 0;
++}
++
++static void aspeed_sgpio_irq_init_valid_mask(struct gpio_chip *gc,
++		unsigned long *valid_mask, unsigned int ngpios)
++{
++	struct aspeed_sgpio *sgpio = gpiochip_get_data(gc);
++	int n = sgpio->n_sgpio;
++
++	WARN_ON(ngpios < MAX_NR_HW_SGPIO * 2);
++
++	/* input GPIOs in the lower range */
++	bitmap_set(valid_mask, 0, n);
++	bitmap_clear(valid_mask, n, ngpios - n);
++}
++
++static bool aspeed_sgpio_is_input(unsigned int offset)
++{
++	return offset < SGPIO_OUTPUT_OFFSET;
++}
++
+ static int aspeed_sgpio_get(struct gpio_chip *gc, unsigned int offset)
+ {
+ 	struct aspeed_sgpio *gpio = gpiochip_get_data(gc);
+ 	const struct aspeed_sgpio_bank *bank = to_bank(offset);
+ 	unsigned long flags;
+ 	enum aspeed_sgpio_reg reg;
+-	bool is_input;
+ 	int rc = 0;
+ 
+ 	spin_lock_irqsave(&gpio->lock, flags);
+ 
+-	is_input = gpio->dir_in[GPIO_BANK(offset)] & GPIO_BIT(offset);
+-	reg = is_input ? reg_val : reg_rdata;
++	reg = aspeed_sgpio_is_input(offset) ? reg_val : reg_rdata;
+ 	rc = !!(ioread32(bank_reg(gpio, bank, reg)) & GPIO_BIT(offset));
+ 
+ 	spin_unlock_irqrestore(&gpio->lock, flags);
+@@ -143,22 +191,31 @@ static int aspeed_sgpio_get(struct gpio_chip *gc, unsigned int offset)
+ 	return rc;
+ }
+ 
+-static void sgpio_set_value(struct gpio_chip *gc, unsigned int offset, int val)
++static int sgpio_set_value(struct gpio_chip *gc, unsigned int offset, int val)
+ {
+ 	struct aspeed_sgpio *gpio = gpiochip_get_data(gc);
+ 	const struct aspeed_sgpio_bank *bank = to_bank(offset);
+-	void __iomem *addr;
++	void __iomem *addr_r, *addr_w;
+ 	u32 reg = 0;
+ 
+-	addr = bank_reg(gpio, bank, reg_val);
+-	reg = ioread32(addr);
++	if (aspeed_sgpio_is_input(offset))
++		return -EINVAL;
++
++	/* Since this is an output, read the cached value from rdata, then
++	 * update val. */
++	addr_r = bank_reg(gpio, bank, reg_rdata);
++	addr_w = bank_reg(gpio, bank, reg_val);
++
++	reg = ioread32(addr_r);
+ 
+ 	if (val)
+ 		reg |= GPIO_BIT(offset);
+ 	else
+ 		reg &= ~GPIO_BIT(offset);
+ 
+-	iowrite32(reg, addr);
++	iowrite32(reg, addr_w);
++
++	return 0;
+ }
+ 
+ static void aspeed_sgpio_set(struct gpio_chip *gc, unsigned int offset, int val)
+@@ -175,43 +232,28 @@ static void aspeed_sgpio_set(struct gpio_chip *gc, unsigned int offset, int val)
+ 
+ static int aspeed_sgpio_dir_in(struct gpio_chip *gc, unsigned int offset)
+ {
+-	struct aspeed_sgpio *gpio = gpiochip_get_data(gc);
+-	unsigned long flags;
+-
+-	spin_lock_irqsave(&gpio->lock, flags);
+-	gpio->dir_in[GPIO_BANK(offset)] |= GPIO_BIT(offset);
+-	spin_unlock_irqrestore(&gpio->lock, flags);
+-
+-	return 0;
++	return aspeed_sgpio_is_input(offset) ? 0 : -EINVAL;
+ }
+ 
+ static int aspeed_sgpio_dir_out(struct gpio_chip *gc, unsigned int offset, int val)
+ {
+ 	struct aspeed_sgpio *gpio = gpiochip_get_data(gc);
+ 	unsigned long flags;
++	int rc;
+ 
+-	spin_lock_irqsave(&gpio->lock, flags);
+-
+-	gpio->dir_in[GPIO_BANK(offset)] &= ~GPIO_BIT(offset);
+-	sgpio_set_value(gc, offset, val);
++	/* No special action is required for setting the direction; we'll
++	 * error-out in sgpio_set_value if this isn't an output GPIO */
+ 
++	spin_lock_irqsave(&gpio->lock, flags);
++	rc = sgpio_set_value(gc, offset, val);
+ 	spin_unlock_irqrestore(&gpio->lock, flags);
+ 
+-	return 0;
++	return rc;
+ }
+ 
+ static int aspeed_sgpio_get_direction(struct gpio_chip *gc, unsigned int offset)
+ {
+-	int dir_status;
+-	struct aspeed_sgpio *gpio = gpiochip_get_data(gc);
+-	unsigned long flags;
+-
+-	spin_lock_irqsave(&gpio->lock, flags);
+-	dir_status = gpio->dir_in[GPIO_BANK(offset)] & GPIO_BIT(offset);
+-	spin_unlock_irqrestore(&gpio->lock, flags);
+-
+-	return dir_status;
+-
++	return !!aspeed_sgpio_is_input(offset);
+ }
+ 
+ static void irqd_to_aspeed_sgpio_data(struct irq_data *d,
+@@ -402,6 +444,7 @@ static int aspeed_sgpio_setup_irqs(struct aspeed_sgpio *gpio,
+ 
+ 	irq = &gpio->chip.irq;
+ 	irq->chip = &aspeed_sgpio_irqchip;
++	irq->init_valid_mask = aspeed_sgpio_irq_init_valid_mask;
+ 	irq->handler = handle_bad_irq;
+ 	irq->default_type = IRQ_TYPE_NONE;
+ 	irq->parent_handler = aspeed_sgpio_irq_handler;
+@@ -409,17 +452,15 @@ static int aspeed_sgpio_setup_irqs(struct aspeed_sgpio *gpio,
+ 	irq->parents = &gpio->irq;
+ 	irq->num_parents = 1;
+ 
+-	/* set IRQ settings and Enable Interrupt */
++	/* Apply default IRQ settings */
+ 	for (i = 0; i < ARRAY_SIZE(aspeed_sgpio_banks); i++) {
+ 		bank = &aspeed_sgpio_banks[i];
+ 		/* set falling or level-low irq */
+ 		iowrite32(0x00000000, bank_reg(gpio, bank, reg_irq_type0));
+ 		/* trigger type is edge */
+ 		iowrite32(0x00000000, bank_reg(gpio, bank, reg_irq_type1));
+-		/* dual edge trigger mode. */
+-		iowrite32(0xffffffff, bank_reg(gpio, bank, reg_irq_type2));
+-		/* enable irq */
+-		iowrite32(0xffffffff, bank_reg(gpio, bank, reg_irq_enable));
++		/* single edge trigger */
++		iowrite32(0x00000000, bank_reg(gpio, bank, reg_irq_type2));
+ 	}
+ 
+ 	return 0;
+@@ -452,11 +493,12 @@ static int __init aspeed_sgpio_probe(struct platform_device *pdev)
+ 	if (rc < 0) {
+ 		dev_err(&pdev->dev, "Could not read ngpios property\n");
+ 		return -EINVAL;
+-	} else if (nr_gpios > MAX_NR_SGPIO) {
++	} else if (nr_gpios > MAX_NR_HW_SGPIO) {
+ 		dev_err(&pdev->dev, "Number of GPIOs exceeds the maximum of %d: %d\n",
+-			MAX_NR_SGPIO, nr_gpios);
++			MAX_NR_HW_SGPIO, nr_gpios);
+ 		return -EINVAL;
+ 	}
++	gpio->n_sgpio = nr_gpios;
+ 
+ 	rc = of_property_read_u32(pdev->dev.of_node, "bus-frequency", &sgpio_freq);
+ 	if (rc < 0) {
+@@ -497,7 +539,8 @@ static int __init aspeed_sgpio_probe(struct platform_device *pdev)
+ 	spin_lock_init(&gpio->lock);
+ 
+ 	gpio->chip.parent = &pdev->dev;
+-	gpio->chip.ngpio = nr_gpios;
++	gpio->chip.ngpio = MAX_NR_HW_SGPIO * 2;
++	gpio->chip.init_valid_mask = aspeed_sgpio_init_valid_mask;
+ 	gpio->chip.direction_input = aspeed_sgpio_dir_in;
+ 	gpio->chip.direction_output = aspeed_sgpio_dir_out;
+ 	gpio->chip.get_direction = aspeed_sgpio_get_direction;
+@@ -509,9 +552,6 @@ static int __init aspeed_sgpio_probe(struct platform_device *pdev)
+ 	gpio->chip.label = dev_name(&pdev->dev);
+ 	gpio->chip.base = -1;
+ 
+-	/* set all SGPIO pins as input (1). */
+-	memset(gpio->dir_in, 0xff, sizeof(gpio->dir_in));
+-
+ 	aspeed_sgpio_setup_irqs(gpio, pdev);
+ 
+ 	rc = devm_gpiochip_add_data(&pdev->dev, &gpio->chip, gpio);
+diff --git a/drivers/gpio/gpio-aspeed.c b/drivers/gpio/gpio-aspeed.c
+index 879db23d84549..d07bf2c3f1369 100644
+--- a/drivers/gpio/gpio-aspeed.c
++++ b/drivers/gpio/gpio-aspeed.c
+@@ -1114,8 +1114,8 @@ static const struct aspeed_gpio_config ast2500_config =
+ 
+ static const struct aspeed_bank_props ast2600_bank_props[] = {
+ 	/*     input	  output   */
+-	{5, 0xffffffff,  0x0000ffff}, /* U/V/W/X */
+-	{6, 0xffff0000,  0x0fff0000}, /* Y/Z */
++	{5, 0xffffffff,  0xffffff00}, /* U/V/W/X */
++	{6, 0x0000ffff,  0x0000ffff}, /* Y/Z */
+ 	{ },
+ };
+ 
+diff --git a/drivers/gpio/gpio-mockup.c b/drivers/gpio/gpio-mockup.c
+index bc345185db260..1652897fdf90d 100644
+--- a/drivers/gpio/gpio-mockup.c
++++ b/drivers/gpio/gpio-mockup.c
+@@ -552,6 +552,7 @@ static int __init gpio_mockup_init(void)
+ 	err = platform_driver_register(&gpio_mockup_driver);
+ 	if (err) {
+ 		gpio_mockup_err("error registering platform driver\n");
++		debugfs_remove_recursive(gpio_mockup_dbg_dir);
+ 		return err;
+ 	}
+ 
+@@ -582,6 +583,7 @@ static int __init gpio_mockup_init(void)
+ 			gpio_mockup_err("error registering device");
+ 			platform_driver_unregister(&gpio_mockup_driver);
+ 			gpio_mockup_unregister_pdevs();
++			debugfs_remove_recursive(gpio_mockup_dbg_dir);
+ 			return PTR_ERR(pdev);
+ 		}
+ 
+diff --git a/drivers/gpio/gpio-pca953x.c b/drivers/gpio/gpio-pca953x.c
+index a3b9bdedbe443..11c3bbd105f11 100644
+--- a/drivers/gpio/gpio-pca953x.c
++++ b/drivers/gpio/gpio-pca953x.c
+@@ -813,7 +813,7 @@ static irqreturn_t pca953x_irq_handler(int irq, void *devid)
+ {
+ 	struct pca953x_chip *chip = devid;
+ 	struct gpio_chip *gc = &chip->gpio_chip;
+-	DECLARE_BITMAP(pending, MAX_LINE);
++	DECLARE_BITMAP(pending, MAX_LINE) = {};
+ 	int level;
+ 	bool ret;
+ 
+@@ -938,6 +938,7 @@ out:
+ static int device_pca957x_init(struct pca953x_chip *chip, u32 invert)
+ {
+ 	DECLARE_BITMAP(val, MAX_LINE);
++	unsigned int i;
+ 	int ret;
+ 
+ 	ret = device_pca95xx_init(chip, invert);
+@@ -945,7 +946,9 @@ static int device_pca957x_init(struct pca953x_chip *chip, u32 invert)
+ 		goto out;
+ 
+ 	/* To enable register 6, 7 to control pull up and pull down */
+-	memset(val, 0x02, NBANK(chip));
++	for (i = 0; i < NBANK(chip); i++)
++		bitmap_set_value8(val, 0x02, i * BANK_SZ);
++
+ 	ret = pca953x_write_regs(chip, PCA957X_BKEN, val);
+ 	if (ret)
+ 		goto out;
+diff --git a/drivers/gpio/gpio-siox.c b/drivers/gpio/gpio-siox.c
+index 26e1fe092304d..f8c5e9fc4baca 100644
+--- a/drivers/gpio/gpio-siox.c
++++ b/drivers/gpio/gpio-siox.c
+@@ -245,6 +245,7 @@ static int gpio_siox_probe(struct siox_device *sdevice)
+ 	girq->chip = &ddata->ichip;
+ 	girq->default_type = IRQ_TYPE_NONE;
+ 	girq->handler = handle_level_irq;
++	girq->threaded = true;
+ 
+ 	ret = devm_gpiochip_add_data(dev, &ddata->gchip, NULL);
+ 	if (ret)
+diff --git a/drivers/gpio/gpio-sprd.c b/drivers/gpio/gpio-sprd.c
+index d7314d39ab65b..36ea8a3bd4510 100644
+--- a/drivers/gpio/gpio-sprd.c
++++ b/drivers/gpio/gpio-sprd.c
+@@ -149,17 +149,20 @@ static int sprd_gpio_irq_set_type(struct irq_data *data,
+ 		sprd_gpio_update(chip, offset, SPRD_GPIO_IS, 0);
+ 		sprd_gpio_update(chip, offset, SPRD_GPIO_IBE, 0);
+ 		sprd_gpio_update(chip, offset, SPRD_GPIO_IEV, 1);
++		sprd_gpio_update(chip, offset, SPRD_GPIO_IC, 1);
+ 		irq_set_handler_locked(data, handle_edge_irq);
+ 		break;
+ 	case IRQ_TYPE_EDGE_FALLING:
+ 		sprd_gpio_update(chip, offset, SPRD_GPIO_IS, 0);
+ 		sprd_gpio_update(chip, offset, SPRD_GPIO_IBE, 0);
+ 		sprd_gpio_update(chip, offset, SPRD_GPIO_IEV, 0);
++		sprd_gpio_update(chip, offset, SPRD_GPIO_IC, 1);
+ 		irq_set_handler_locked(data, handle_edge_irq);
+ 		break;
+ 	case IRQ_TYPE_EDGE_BOTH:
+ 		sprd_gpio_update(chip, offset, SPRD_GPIO_IS, 0);
+ 		sprd_gpio_update(chip, offset, SPRD_GPIO_IBE, 1);
++		sprd_gpio_update(chip, offset, SPRD_GPIO_IC, 1);
+ 		irq_set_handler_locked(data, handle_edge_irq);
+ 		break;
+ 	case IRQ_TYPE_LEVEL_HIGH:
+diff --git a/drivers/gpio/gpio-tc3589x.c b/drivers/gpio/gpio-tc3589x.c
+index 6be0684cfa494..a70bc71281056 100644
+--- a/drivers/gpio/gpio-tc3589x.c
++++ b/drivers/gpio/gpio-tc3589x.c
+@@ -212,7 +212,7 @@ static void tc3589x_gpio_irq_sync_unlock(struct irq_data *d)
+ 				continue;
+ 
+ 			tc3589x_gpio->oldregs[i][j] = new;
+-			tc3589x_reg_write(tc3589x, regmap[i] + j * 8, new);
++			tc3589x_reg_write(tc3589x, regmap[i] + j, new);
+ 		}
+ 	}
+ 
+diff --git a/drivers/gpio/gpiolib.c b/drivers/gpio/gpiolib.c
+index 4fa075d49fbc9..6e813b13d6988 100644
+--- a/drivers/gpio/gpiolib.c
++++ b/drivers/gpio/gpiolib.c
+@@ -836,6 +836,21 @@ static __poll_t lineevent_poll(struct file *filep,
+ 	return events;
+ }
+ 
++static ssize_t lineevent_get_size(void)
++{
++#ifdef __x86_64__
++	/* i386 has no padding after 'id' */
++	if (in_ia32_syscall()) {
++		struct compat_gpioeevent_data {
++			compat_u64	timestamp;
++			u32		id;
++		};
++
++		return sizeof(struct compat_gpioeevent_data);
++	}
++#endif
++	return sizeof(struct gpioevent_data);
++}
+ 
+ static ssize_t lineevent_read(struct file *filep,
+ 			      char __user *buf,
+@@ -845,9 +860,20 @@ static ssize_t lineevent_read(struct file *filep,
+ 	struct lineevent_state *le = filep->private_data;
+ 	struct gpioevent_data ge;
+ 	ssize_t bytes_read = 0;
++	ssize_t ge_size;
+ 	int ret;
+ 
+-	if (count < sizeof(ge))
++	/*
++	 * When compatible system call is being used the struct gpioevent_data,
++	 * in case of at least ia32, has different size due to the alignment
++	 * differences. Because we have first member 64 bits followed by one of
++	 * 32 bits there is no gap between them. The only difference is the
++	 * padding at the end of the data structure. Hence, we calculate the
++	 * actual sizeof() and pass this as an argument to copy_to_user() to
++	 * drop unneeded bytes from the output.
++	 */
++	ge_size = lineevent_get_size();
++	if (count < ge_size)
+ 		return -EINVAL;
+ 
+ 	do {
+@@ -883,10 +909,10 @@ static ssize_t lineevent_read(struct file *filep,
+ 			break;
+ 		}
+ 
+-		if (copy_to_user(buf + bytes_read, &ge, sizeof(ge)))
++		if (copy_to_user(buf + bytes_read, &ge, ge_size))
+ 			return -EFAULT;
+-		bytes_read += sizeof(ge);
+-	} while (count >= bytes_read + sizeof(ge));
++		bytes_read += ge_size;
++	} while (count >= bytes_read + ge_size);
+ 
+ 	return bytes_read;
+ }
+diff --git a/drivers/gpu/drm/amd/amdgpu/amdgpu_display.c b/drivers/gpu/drm/amd/amdgpu/amdgpu_display.c
+index 5e51f0acf744f..f05fecbec0a86 100644
+--- a/drivers/gpu/drm/amd/amdgpu/amdgpu_display.c
++++ b/drivers/gpu/drm/amd/amdgpu/amdgpu_display.c
+@@ -297,7 +297,7 @@ int amdgpu_display_crtc_set_config(struct drm_mode_set *set,
+ 	   take the current one */
+ 	if (active && !adev->have_disp_power_ref) {
+ 		adev->have_disp_power_ref = true;
+-		goto out;
++		return ret;
+ 	}
+ 	/* if we have no active crtcs, then drop the power ref
+ 	   we got before */
+diff --git a/drivers/gpu/drm/i915/gvt/vgpu.c b/drivers/gpu/drm/i915/gvt/vgpu.c
+index 7d361623ff679..041f601b07d06 100644
+--- a/drivers/gpu/drm/i915/gvt/vgpu.c
++++ b/drivers/gpu/drm/i915/gvt/vgpu.c
+@@ -367,6 +367,7 @@ void intel_gvt_destroy_idle_vgpu(struct intel_vgpu *vgpu)
+ static struct intel_vgpu *__intel_gvt_create_vgpu(struct intel_gvt *gvt,
+ 		struct intel_vgpu_creation_params *param)
+ {
++	struct drm_i915_private *dev_priv = gvt->gt->i915;
+ 	struct intel_vgpu *vgpu;
+ 	int ret;
+ 
+@@ -434,7 +435,10 @@ static struct intel_vgpu *__intel_gvt_create_vgpu(struct intel_gvt *gvt,
+ 	if (ret)
+ 		goto out_clean_sched_policy;
+ 
+-	ret = intel_gvt_hypervisor_set_edid(vgpu, PORT_D);
++	if (IS_BROADWELL(dev_priv))
++		ret = intel_gvt_hypervisor_set_edid(vgpu, PORT_B);
++	else
++		ret = intel_gvt_hypervisor_set_edid(vgpu, PORT_D);
+ 	if (ret)
+ 		goto out_clean_sched_policy;
+ 
+diff --git a/drivers/gpu/drm/sun4i/sun8i_mixer.c b/drivers/gpu/drm/sun4i/sun8i_mixer.c
+index cc4fb916318f3..c3304028e3dcd 100644
+--- a/drivers/gpu/drm/sun4i/sun8i_mixer.c
++++ b/drivers/gpu/drm/sun4i/sun8i_mixer.c
+@@ -307,7 +307,7 @@ static struct regmap_config sun8i_mixer_regmap_config = {
+ 	.reg_bits	= 32,
+ 	.val_bits	= 32,
+ 	.reg_stride	= 4,
+-	.max_register	= 0xbfffc, /* guessed */
++	.max_register	= 0xffffc, /* guessed */
+ };
+ 
+ static int sun8i_mixer_of_get_id(struct device_node *node)
+diff --git a/drivers/i2c/busses/i2c-cpm.c b/drivers/i2c/busses/i2c-cpm.c
+index 1213e1932ccb5..24d584a1c9a78 100644
+--- a/drivers/i2c/busses/i2c-cpm.c
++++ b/drivers/i2c/busses/i2c-cpm.c
+@@ -65,6 +65,9 @@ struct i2c_ram {
+ 	char    res1[4];	/* Reserved */
+ 	ushort  rpbase;		/* Relocation pointer */
+ 	char    res2[2];	/* Reserved */
++	/* The following elements are only for CPM2 */
++	char    res3[4];	/* Reserved */
++	uint    sdmatmp;	/* Internal */
+ };
+ 
+ #define I2COM_START	0x80
+diff --git a/drivers/i2c/busses/i2c-i801.c b/drivers/i2c/busses/i2c-i801.c
+index 3843eabeddda3..6126290e4d650 100644
+--- a/drivers/i2c/busses/i2c-i801.c
++++ b/drivers/i2c/busses/i2c-i801.c
+@@ -1913,6 +1913,7 @@ static int i801_probe(struct pci_dev *dev, const struct pci_device_id *id)
+ 
+ 	pci_set_drvdata(dev, priv);
+ 
++	dev_pm_set_driver_flags(&dev->dev, DPM_FLAG_NO_DIRECT_COMPLETE);
+ 	pm_runtime_set_autosuspend_delay(&dev->dev, 1000);
+ 	pm_runtime_use_autosuspend(&dev->dev);
+ 	pm_runtime_put_autosuspend(&dev->dev);
+diff --git a/drivers/i2c/busses/i2c-npcm7xx.c b/drivers/i2c/busses/i2c-npcm7xx.c
+index dfcf04e1967f1..2ad166355ec9b 100644
+--- a/drivers/i2c/busses/i2c-npcm7xx.c
++++ b/drivers/i2c/busses/i2c-npcm7xx.c
+@@ -2163,6 +2163,15 @@ static int npcm_i2c_master_xfer(struct i2c_adapter *adap, struct i2c_msg *msgs,
+ 	if (bus->cmd_err == -EAGAIN)
+ 		ret = i2c_recover_bus(adap);
+ 
++	/*
++	 * After any type of error, check if LAST bit is still set,
++	 * due to a HW issue.
++	 * It cannot be cleared without resetting the module.
++	 */
++	if (bus->cmd_err &&
++	    (NPCM_I2CRXF_CTL_LAST_PEC & ioread8(bus->reg + NPCM_I2CRXF_CTL)))
++		npcm_i2c_reset(bus);
++
+ #if IS_ENABLED(CONFIG_I2C_SLAVE)
+ 	/* reenable slave if it was enabled */
+ 	if (bus->slave)
+diff --git a/drivers/iio/adc/qcom-spmi-adc5.c b/drivers/iio/adc/qcom-spmi-adc5.c
+index 21fdcde77883f..56e7696aa3c0f 100644
+--- a/drivers/iio/adc/qcom-spmi-adc5.c
++++ b/drivers/iio/adc/qcom-spmi-adc5.c
+@@ -786,7 +786,7 @@ static int adc5_probe(struct platform_device *pdev)
+ 
+ static struct platform_driver adc5_driver = {
+ 	.driver = {
+-		.name = "qcom-spmi-adc5.c",
++		.name = "qcom-spmi-adc5",
+ 		.of_match_table = adc5_match_table,
+ 	},
+ 	.probe = adc5_probe,
+diff --git a/drivers/input/mouse/trackpoint.c b/drivers/input/mouse/trackpoint.c
+index 854d5e7587241..ef2fa0905208d 100644
+--- a/drivers/input/mouse/trackpoint.c
++++ b/drivers/input/mouse/trackpoint.c
+@@ -282,6 +282,8 @@ static int trackpoint_start_protocol(struct psmouse *psmouse,
+ 	case TP_VARIANT_ALPS:
+ 	case TP_VARIANT_ELAN:
+ 	case TP_VARIANT_NXP:
++	case TP_VARIANT_JYT_SYNAPTICS:
++	case TP_VARIANT_SYNAPTICS:
+ 		if (variant_id)
+ 			*variant_id = param[0];
+ 		if (firmware_id)
+diff --git a/drivers/input/serio/i8042-x86ia64io.h b/drivers/input/serio/i8042-x86ia64io.h
+index 37fb9aa88f9c3..a4c9b9652560a 100644
+--- a/drivers/input/serio/i8042-x86ia64io.h
++++ b/drivers/input/serio/i8042-x86ia64io.h
+@@ -721,6 +721,13 @@ static const struct dmi_system_id __initconst i8042_dmi_nopnp_table[] = {
+ 			DMI_MATCH(DMI_BOARD_VENDOR, "MICRO-STAR INTERNATIONAL CO., LTD"),
+ 		},
+ 	},
++	{
++		/* Acer Aspire 5 A515 */
++		.matches = {
++			DMI_MATCH(DMI_BOARD_NAME, "Grumpy_PK"),
++			DMI_MATCH(DMI_BOARD_VENDOR, "PK"),
++		},
++	},
+ 	{ }
+ };
+ 
+diff --git a/drivers/iommu/amd/init.c b/drivers/iommu/amd/init.c
+index bf45f8e2c7edd..016e35d3d6c86 100644
+--- a/drivers/iommu/amd/init.c
++++ b/drivers/iommu/amd/init.c
+@@ -1110,25 +1110,6 @@ static int __init add_early_maps(void)
+ 	return 0;
+ }
+ 
+-/*
+- * Reads the device exclusion range from ACPI and initializes the IOMMU with
+- * it
+- */
+-static void __init set_device_exclusion_range(u16 devid, struct ivmd_header *m)
+-{
+-	if (!(m->flags & IVMD_FLAG_EXCL_RANGE))
+-		return;
+-
+-	/*
+-	 * Treat per-device exclusion ranges as r/w unity-mapped regions
+-	 * since some buggy BIOSes might lead to the overwritten exclusion
+-	 * range (exclusion_start and exclusion_length members). This
+-	 * happens when there are multiple exclusion ranges (IVMD entries)
+-	 * defined in ACPI table.
+-	 */
+-	m->flags = (IVMD_FLAG_IW | IVMD_FLAG_IR | IVMD_FLAG_UNITY_MAP);
+-}
+-
+ /*
+  * Takes a pointer to an AMD IOMMU entry in the ACPI table and
+  * initializes the hardware and our data structures with it.
+@@ -2080,30 +2061,6 @@ static void __init free_unity_maps(void)
+ 	}
+ }
+ 
+-/* called when we find an exclusion range definition in ACPI */
+-static int __init init_exclusion_range(struct ivmd_header *m)
+-{
+-	int i;
+-
+-	switch (m->type) {
+-	case ACPI_IVMD_TYPE:
+-		set_device_exclusion_range(m->devid, m);
+-		break;
+-	case ACPI_IVMD_TYPE_ALL:
+-		for (i = 0; i <= amd_iommu_last_bdf; ++i)
+-			set_device_exclusion_range(i, m);
+-		break;
+-	case ACPI_IVMD_TYPE_RANGE:
+-		for (i = m->devid; i <= m->aux; ++i)
+-			set_device_exclusion_range(i, m);
+-		break;
+-	default:
+-		break;
+-	}
+-
+-	return 0;
+-}
+-
+ /* called for unity map ACPI definition */
+ static int __init init_unity_map_range(struct ivmd_header *m)
+ {
+@@ -2114,9 +2071,6 @@ static int __init init_unity_map_range(struct ivmd_header *m)
+ 	if (e == NULL)
+ 		return -ENOMEM;
+ 
+-	if (m->flags & IVMD_FLAG_EXCL_RANGE)
+-		init_exclusion_range(m);
+-
+ 	switch (m->type) {
+ 	default:
+ 		kfree(e);
+@@ -2140,6 +2094,16 @@ static int __init init_unity_map_range(struct ivmd_header *m)
+ 	e->address_end = e->address_start + PAGE_ALIGN(m->range_length);
+ 	e->prot = m->flags >> 1;
+ 
++	/*
++	 * Treat per-device exclusion ranges as r/w unity-mapped regions
++	 * since some buggy BIOSes might lead to the overwritten exclusion
++	 * range (exclusion_start and exclusion_length members). This
++	 * happens when there are multiple exclusion ranges (IVMD entries)
++	 * defined in ACPI table.
++	 */
++	if (m->flags & IVMD_FLAG_EXCL_RANGE)
++		e->prot = (IVMD_FLAG_IW | IVMD_FLAG_IR) >> 1;
++
+ 	DUMP_printk("%s devid_start: %02x:%02x.%x devid_end: %02x:%02x.%x"
+ 		    " range_start: %016llx range_end: %016llx flags: %x\n", s,
+ 		    PCI_BUS_NUM(e->devid_start), PCI_SLOT(e->devid_start),
+diff --git a/drivers/iommu/exynos-iommu.c b/drivers/iommu/exynos-iommu.c
+index 60c8a56e4a3f8..89f628da148ac 100644
+--- a/drivers/iommu/exynos-iommu.c
++++ b/drivers/iommu/exynos-iommu.c
+@@ -1295,13 +1295,17 @@ static int exynos_iommu_of_xlate(struct device *dev,
+ 		return -ENODEV;
+ 
+ 	data = platform_get_drvdata(sysmmu);
+-	if (!data)
++	if (!data) {
++		put_device(&sysmmu->dev);
+ 		return -ENODEV;
++	}
+ 
+ 	if (!owner) {
+ 		owner = kzalloc(sizeof(*owner), GFP_KERNEL);
+-		if (!owner)
++		if (!owner) {
++			put_device(&sysmmu->dev);
+ 			return -ENOMEM;
++		}
+ 
+ 		INIT_LIST_HEAD(&owner->controllers);
+ 		mutex_init(&owner->rpm_lock);
+diff --git a/drivers/memstick/core/memstick.c b/drivers/memstick/core/memstick.c
+index 693ee73eb2912..ef03d6fafc5ce 100644
+--- a/drivers/memstick/core/memstick.c
++++ b/drivers/memstick/core/memstick.c
+@@ -441,6 +441,9 @@ static void memstick_check(struct work_struct *work)
+ 	} else if (host->card->stop)
+ 		host->card->stop(host->card);
+ 
++	if (host->removing)
++		goto out_power_off;
++
+ 	card = memstick_alloc_card(host);
+ 
+ 	if (!card) {
+@@ -545,6 +548,7 @@ EXPORT_SYMBOL(memstick_add_host);
+  */
+ void memstick_remove_host(struct memstick_host *host)
+ {
++	host->removing = 1;
+ 	flush_workqueue(workqueue);
+ 	mutex_lock(&host->lock);
+ 	if (host->card)
+diff --git a/drivers/mmc/host/sdhci-pci-core.c b/drivers/mmc/host/sdhci-pci-core.c
+index af413805bbf1a..914f5184295ff 100644
+--- a/drivers/mmc/host/sdhci-pci-core.c
++++ b/drivers/mmc/host/sdhci-pci-core.c
+@@ -794,7 +794,8 @@ static int byt_emmc_probe_slot(struct sdhci_pci_slot *slot)
+ static bool glk_broken_cqhci(struct sdhci_pci_slot *slot)
+ {
+ 	return slot->chip->pdev->device == PCI_DEVICE_ID_INTEL_GLK_EMMC &&
+-	       dmi_match(DMI_BIOS_VENDOR, "LENOVO");
++	       (dmi_match(DMI_BIOS_VENDOR, "LENOVO") ||
++		dmi_match(DMI_SYS_VENDOR, "IRBIS"));
+ }
+ 
+ static int glk_emmc_probe_slot(struct sdhci_pci_slot *slot)
+diff --git a/drivers/net/dsa/ocelot/felix_vsc9959.c b/drivers/net/dsa/ocelot/felix_vsc9959.c
+index 1dd9e348152d7..7c167a394b762 100644
+--- a/drivers/net/dsa/ocelot/felix_vsc9959.c
++++ b/drivers/net/dsa/ocelot/felix_vsc9959.c
+@@ -607,17 +607,17 @@ struct vcap_field vsc9959_vcap_is2_keys[] = {
+ 	[VCAP_IS2_HK_DIP_EQ_SIP]		= {118,   1},
+ 	/* IP4_TCP_UDP (TYPE=100) */
+ 	[VCAP_IS2_HK_TCP]			= {119,   1},
+-	[VCAP_IS2_HK_L4_SPORT]			= {120,  16},
+-	[VCAP_IS2_HK_L4_DPORT]			= {136,  16},
++	[VCAP_IS2_HK_L4_DPORT]			= {120,  16},
++	[VCAP_IS2_HK_L4_SPORT]			= {136,  16},
+ 	[VCAP_IS2_HK_L4_RNG]			= {152,   8},
+ 	[VCAP_IS2_HK_L4_SPORT_EQ_DPORT]		= {160,   1},
+ 	[VCAP_IS2_HK_L4_SEQUENCE_EQ0]		= {161,   1},
+-	[VCAP_IS2_HK_L4_URG]			= {162,   1},
+-	[VCAP_IS2_HK_L4_ACK]			= {163,   1},
+-	[VCAP_IS2_HK_L4_PSH]			= {164,   1},
+-	[VCAP_IS2_HK_L4_RST]			= {165,   1},
+-	[VCAP_IS2_HK_L4_SYN]			= {166,   1},
+-	[VCAP_IS2_HK_L4_FIN]			= {167,   1},
++	[VCAP_IS2_HK_L4_FIN]			= {162,   1},
++	[VCAP_IS2_HK_L4_SYN]			= {163,   1},
++	[VCAP_IS2_HK_L4_RST]			= {164,   1},
++	[VCAP_IS2_HK_L4_PSH]			= {165,   1},
++	[VCAP_IS2_HK_L4_ACK]			= {166,   1},
++	[VCAP_IS2_HK_L4_URG]			= {167,   1},
+ 	[VCAP_IS2_HK_L4_1588_DOM]		= {168,   8},
+ 	[VCAP_IS2_HK_L4_1588_VER]		= {176,   4},
+ 	/* IP4_OTHER (TYPE=101) */
+diff --git a/drivers/net/ethernet/dec/tulip/de2104x.c b/drivers/net/ethernet/dec/tulip/de2104x.c
+index 592454f444ce2..0b30011b9839e 100644
+--- a/drivers/net/ethernet/dec/tulip/de2104x.c
++++ b/drivers/net/ethernet/dec/tulip/de2104x.c
+@@ -85,7 +85,7 @@ MODULE_PARM_DESC (rx_copybreak, "de2104x Breakpoint at which Rx packets are copi
+ #define DSL			CONFIG_DE2104X_DSL
+ #endif
+ 
+-#define DE_RX_RING_SIZE		64
++#define DE_RX_RING_SIZE		128
+ #define DE_TX_RING_SIZE		64
+ #define DE_RING_BYTES		\
+ 		((sizeof(struct de_desc) * DE_RX_RING_SIZE) +	\
+diff --git a/drivers/net/hyperv/hyperv_net.h b/drivers/net/hyperv/hyperv_net.h
+index abda736e7c7dc..a4d2dd2637e26 100644
+--- a/drivers/net/hyperv/hyperv_net.h
++++ b/drivers/net/hyperv/hyperv_net.h
+@@ -973,6 +973,9 @@ struct net_device_context {
+ 	/* Serial number of the VF to team with */
+ 	u32 vf_serial;
+ 
++	/* Is the current data path through the VF NIC? */
++	bool  data_path_is_vf;
++
+ 	/* Used to temporarily save the config info across hibernation */
+ 	struct netvsc_device_info *saved_netvsc_dev_info;
+ };
+diff --git a/drivers/net/hyperv/netvsc_drv.c b/drivers/net/hyperv/netvsc_drv.c
+index a2db5ef3b62a2..3b0dc1f0ef212 100644
+--- a/drivers/net/hyperv/netvsc_drv.c
++++ b/drivers/net/hyperv/netvsc_drv.c
+@@ -2323,7 +2323,16 @@ static int netvsc_register_vf(struct net_device *vf_netdev)
+ 	return NOTIFY_OK;
+ }
+ 
+-/* VF up/down change detected, schedule to change data path */
++/* Change the data path when VF UP/DOWN/CHANGE are detected.
++ *
++ * Typically a UP or DOWN event is followed by a CHANGE event, so
++ * net_device_ctx->data_path_is_vf is used to cache the current data path
++ * to avoid the duplicate call of netvsc_switch_datapath() and the duplicate
++ * message.
++ *
++ * During hibernation, if a VF NIC driver (e.g. mlx5) preserves the network
++ * interface, there is only the CHANGE event and no UP or DOWN event.
++ */
+ static int netvsc_vf_changed(struct net_device *vf_netdev)
+ {
+ 	struct net_device_context *net_device_ctx;
+@@ -2340,6 +2349,10 @@ static int netvsc_vf_changed(struct net_device *vf_netdev)
+ 	if (!netvsc_dev)
+ 		return NOTIFY_DONE;
+ 
++	if (net_device_ctx->data_path_is_vf == vf_is_up)
++		return NOTIFY_OK;
++	net_device_ctx->data_path_is_vf = vf_is_up;
++
+ 	netvsc_switch_datapath(ndev, vf_is_up);
+ 	netdev_info(ndev, "Data path switched %s VF: %s\n",
+ 		    vf_is_up ? "to" : "from", vf_netdev->name);
+@@ -2581,6 +2594,12 @@ static int netvsc_resume(struct hv_device *dev)
+ 	rtnl_lock();
+ 
+ 	net_device_ctx = netdev_priv(net);
++
++	/* Reset the data path to the netvsc NIC before re-opening the vmbus
++	 * channel. Later netvsc_netdev_event() will switch the data path to
++	 * the VF upon the UP or CHANGE event.
++	 */
++	net_device_ctx->data_path_is_vf = false;
+ 	device_info = net_device_ctx->saved_netvsc_dev_info;
+ 
+ 	ret = netvsc_attach(net, device_info);
+diff --git a/drivers/net/usb/rndis_host.c b/drivers/net/usb/rndis_host.c
+index bd9c07888ebb4..6fa7a009a24a4 100644
+--- a/drivers/net/usb/rndis_host.c
++++ b/drivers/net/usb/rndis_host.c
+@@ -201,7 +201,7 @@ int rndis_command(struct usbnet *dev, struct rndis_msg_hdr *buf, int buflen)
+ 			dev_dbg(&info->control->dev,
+ 				"rndis response error, code %d\n", retval);
+ 		}
+-		msleep(20);
++		msleep(40);
+ 	}
+ 	dev_dbg(&info->control->dev, "rndis response timeout\n");
+ 	return -ETIMEDOUT;
+diff --git a/drivers/net/wan/hdlc_cisco.c b/drivers/net/wan/hdlc_cisco.c
+index 444130655d8ea..cb5898f7d68c9 100644
+--- a/drivers/net/wan/hdlc_cisco.c
++++ b/drivers/net/wan/hdlc_cisco.c
+@@ -118,6 +118,7 @@ static void cisco_keepalive_send(struct net_device *dev, u32 type,
+ 	skb_put(skb, sizeof(struct cisco_packet));
+ 	skb->priority = TC_PRIO_CONTROL;
+ 	skb->dev = dev;
++	skb->protocol = htons(ETH_P_HDLC);
+ 	skb_reset_network_header(skb);
+ 
+ 	dev_queue_xmit(skb);
+diff --git a/drivers/net/wan/hdlc_fr.c b/drivers/net/wan/hdlc_fr.c
+index 9acad651ea1f6..d6cfd51613ed8 100644
+--- a/drivers/net/wan/hdlc_fr.c
++++ b/drivers/net/wan/hdlc_fr.c
+@@ -433,6 +433,8 @@ static netdev_tx_t pvc_xmit(struct sk_buff *skb, struct net_device *dev)
+ 			if (pvc->state.fecn) /* TX Congestion counter */
+ 				dev->stats.tx_compressed++;
+ 			skb->dev = pvc->frad;
++			skb->protocol = htons(ETH_P_HDLC);
++			skb_reset_network_header(skb);
+ 			dev_queue_xmit(skb);
+ 			return NETDEV_TX_OK;
+ 		}
+@@ -555,6 +557,7 @@ static void fr_lmi_send(struct net_device *dev, int fullrep)
+ 	skb_put(skb, i);
+ 	skb->priority = TC_PRIO_CONTROL;
+ 	skb->dev = dev;
++	skb->protocol = htons(ETH_P_HDLC);
+ 	skb_reset_network_header(skb);
+ 
+ 	dev_queue_xmit(skb);
+@@ -1041,7 +1044,7 @@ static void pvc_setup(struct net_device *dev)
+ {
+ 	dev->type = ARPHRD_DLCI;
+ 	dev->flags = IFF_POINTOPOINT;
+-	dev->hard_header_len = 10;
++	dev->hard_header_len = 0;
+ 	dev->addr_len = 2;
+ 	netif_keep_dst(dev);
+ }
+@@ -1093,6 +1096,7 @@ static int fr_add_pvc(struct net_device *frad, unsigned int dlci, int type)
+ 	dev->mtu = HDLC_MAX_MTU;
+ 	dev->min_mtu = 68;
+ 	dev->max_mtu = HDLC_MAX_MTU;
++	dev->needed_headroom = 10;
+ 	dev->priv_flags |= IFF_NO_QUEUE;
+ 	dev->ml_priv = pvc;
+ 
+diff --git a/drivers/net/wan/hdlc_ppp.c b/drivers/net/wan/hdlc_ppp.c
+index 16f33d1ffbfb9..64f8556513369 100644
+--- a/drivers/net/wan/hdlc_ppp.c
++++ b/drivers/net/wan/hdlc_ppp.c
+@@ -251,6 +251,7 @@ static void ppp_tx_cp(struct net_device *dev, u16 pid, u8 code,
+ 
+ 	skb->priority = TC_PRIO_CONTROL;
+ 	skb->dev = dev;
++	skb->protocol = htons(ETH_P_HDLC);
+ 	skb_reset_network_header(skb);
+ 	skb_queue_tail(&tx_queue, skb);
+ }
+diff --git a/drivers/net/wan/lapbether.c b/drivers/net/wan/lapbether.c
+index e61616b0b91c7..b726101d4707a 100644
+--- a/drivers/net/wan/lapbether.c
++++ b/drivers/net/wan/lapbether.c
+@@ -198,8 +198,6 @@ static void lapbeth_data_transmit(struct net_device *ndev, struct sk_buff *skb)
+ 	struct net_device *dev;
+ 	int size = skb->len;
+ 
+-	skb->protocol = htons(ETH_P_X25);
+-
+ 	ptr = skb_push(skb, 2);
+ 
+ 	*ptr++ = size % 256;
+@@ -210,6 +208,8 @@ static void lapbeth_data_transmit(struct net_device *ndev, struct sk_buff *skb)
+ 
+ 	skb->dev = dev = lapbeth->ethdev;
+ 
++	skb->protocol = htons(ETH_P_DEC);
++
+ 	skb_reset_network_header(skb);
+ 
+ 	dev_hard_header(skb, dev, ETH_P_DEC, bcast_addr, NULL, 0);
+diff --git a/drivers/net/wireless/mediatek/mt76/mt7915/init.c b/drivers/net/wireless/mediatek/mt76/mt7915/init.c
+index aadf56e80bae8..d7a3b05ab50c3 100644
+--- a/drivers/net/wireless/mediatek/mt76/mt7915/init.c
++++ b/drivers/net/wireless/mediatek/mt76/mt7915/init.c
+@@ -691,8 +691,12 @@ void mt7915_unregister_device(struct mt7915_dev *dev)
+ 	spin_lock_bh(&dev->token_lock);
+ 	idr_for_each_entry(&dev->token, txwi, id) {
+ 		mt7915_txp_skb_unmap(&dev->mt76, txwi);
+-		if (txwi->skb)
+-			dev_kfree_skb_any(txwi->skb);
++		if (txwi->skb) {
++			struct ieee80211_hw *hw;
++
++			hw = mt76_tx_status_get_hw(&dev->mt76, txwi->skb);
++			ieee80211_free_txskb(hw, txwi->skb);
++		}
+ 		mt76_put_txwi(&dev->mt76, txwi);
+ 	}
+ 	spin_unlock_bh(&dev->token_lock);
+diff --git a/drivers/net/wireless/mediatek/mt76/mt7915/mac.c b/drivers/net/wireless/mediatek/mt76/mt7915/mac.c
+index a264e304a3dfb..5800b2d1fb233 100644
+--- a/drivers/net/wireless/mediatek/mt76/mt7915/mac.c
++++ b/drivers/net/wireless/mediatek/mt76/mt7915/mac.c
+@@ -844,7 +844,7 @@ mt7915_tx_complete_status(struct mt76_dev *mdev, struct sk_buff *skb,
+ 	if (sta || !(info->flags & IEEE80211_TX_CTL_NO_ACK))
+ 		mt7915_tx_status(sta, hw, info, NULL);
+ 
+-	dev_kfree_skb(skb);
++	ieee80211_free_txskb(hw, skb);
+ }
+ 
+ void mt7915_txp_skb_unmap(struct mt76_dev *dev,
+diff --git a/drivers/net/wireless/ti/wlcore/cmd.h b/drivers/net/wireless/ti/wlcore/cmd.h
+index 9acd8a41ea61f..f2609d5b6bf71 100644
+--- a/drivers/net/wireless/ti/wlcore/cmd.h
++++ b/drivers/net/wireless/ti/wlcore/cmd.h
+@@ -458,7 +458,6 @@ enum wl1271_cmd_key_type {
+ 	KEY_TKIP = 2,
+ 	KEY_AES  = 3,
+ 	KEY_GEM  = 4,
+-	KEY_IGTK  = 5,
+ };
+ 
+ struct wl1271_cmd_set_keys {
+diff --git a/drivers/net/wireless/ti/wlcore/main.c b/drivers/net/wireless/ti/wlcore/main.c
+index de6c8a7589ca3..ef169de992249 100644
+--- a/drivers/net/wireless/ti/wlcore/main.c
++++ b/drivers/net/wireless/ti/wlcore/main.c
+@@ -3550,9 +3550,6 @@ int wlcore_set_key(struct wl1271 *wl, enum set_key_cmd cmd,
+ 	case WL1271_CIPHER_SUITE_GEM:
+ 		key_type = KEY_GEM;
+ 		break;
+-	case WLAN_CIPHER_SUITE_AES_CMAC:
+-		key_type = KEY_IGTK;
+-		break;
+ 	default:
+ 		wl1271_error("Unknown key algo 0x%x", key_conf->cipher);
+ 
+@@ -6222,7 +6219,6 @@ static int wl1271_init_ieee80211(struct wl1271 *wl)
+ 		WLAN_CIPHER_SUITE_TKIP,
+ 		WLAN_CIPHER_SUITE_CCMP,
+ 		WL1271_CIPHER_SUITE_GEM,
+-		WLAN_CIPHER_SUITE_AES_CMAC,
+ 	};
+ 
+ 	/* The tx descriptor buffer */
+diff --git a/drivers/nvme/host/core.c b/drivers/nvme/host/core.c
+index f2556f0ea20dc..69165a8f7c1f0 100644
+--- a/drivers/nvme/host/core.c
++++ b/drivers/nvme/host/core.c
+@@ -3060,10 +3060,24 @@ static int nvme_dev_open(struct inode *inode, struct file *file)
+ 		return -EWOULDBLOCK;
+ 	}
+ 
++	nvme_get_ctrl(ctrl);
++	if (!try_module_get(ctrl->ops->module))
++		return -EINVAL;
++
+ 	file->private_data = ctrl;
+ 	return 0;
+ }
+ 
++static int nvme_dev_release(struct inode *inode, struct file *file)
++{
++	struct nvme_ctrl *ctrl =
++		container_of(inode->i_cdev, struct nvme_ctrl, cdev);
++
++	module_put(ctrl->ops->module);
++	nvme_put_ctrl(ctrl);
++	return 0;
++}
++
+ static int nvme_dev_user_cmd(struct nvme_ctrl *ctrl, void __user *argp)
+ {
+ 	struct nvme_ns *ns;
+@@ -3126,6 +3140,7 @@ static long nvme_dev_ioctl(struct file *file, unsigned int cmd,
+ static const struct file_operations nvme_dev_fops = {
+ 	.owner		= THIS_MODULE,
+ 	.open		= nvme_dev_open,
++	.release	= nvme_dev_release,
+ 	.unlocked_ioctl	= nvme_dev_ioctl,
+ 	.compat_ioctl	= compat_ptr_ioctl,
+ };
+diff --git a/drivers/nvme/host/fc.c b/drivers/nvme/host/fc.c
+index 92c966ac34c20..43c1745ecd45b 100644
+--- a/drivers/nvme/host/fc.c
++++ b/drivers/nvme/host/fc.c
+@@ -3668,12 +3668,14 @@ nvme_fc_create_ctrl(struct device *dev, struct nvmf_ctrl_options *opts)
+ 	spin_lock_irqsave(&nvme_fc_lock, flags);
+ 	list_for_each_entry(lport, &nvme_fc_lport_list, port_list) {
+ 		if (lport->localport.node_name != laddr.nn ||
+-		    lport->localport.port_name != laddr.pn)
++		    lport->localport.port_name != laddr.pn ||
++		    lport->localport.port_state != FC_OBJSTATE_ONLINE)
+ 			continue;
+ 
+ 		list_for_each_entry(rport, &lport->endp_list, endp_list) {
+ 			if (rport->remoteport.node_name != raddr.nn ||
+-			    rport->remoteport.port_name != raddr.pn)
++			    rport->remoteport.port_name != raddr.pn ||
++			    rport->remoteport.port_state != FC_OBJSTATE_ONLINE)
+ 				continue;
+ 
+ 			/* if fail to get reference fall through. Will error */
+diff --git a/drivers/nvme/host/pci.c b/drivers/nvme/host/pci.c
+index 69a19fe241063..cc3ae9c63a01b 100644
+--- a/drivers/nvme/host/pci.c
++++ b/drivers/nvme/host/pci.c
+@@ -942,13 +942,6 @@ static inline void nvme_handle_cqe(struct nvme_queue *nvmeq, u16 idx)
+ 	struct nvme_completion *cqe = &nvmeq->cqes[idx];
+ 	struct request *req;
+ 
+-	if (unlikely(cqe->command_id >= nvmeq->q_depth)) {
+-		dev_warn(nvmeq->dev->ctrl.device,
+-			"invalid id %d completed on queue %d\n",
+-			cqe->command_id, le16_to_cpu(cqe->sq_id));
+-		return;
+-	}
+-
+ 	/*
+ 	 * AEN requests are special as they don't time out and can
+ 	 * survive any kind of queue freeze and often don't respond to
+@@ -962,6 +955,13 @@ static inline void nvme_handle_cqe(struct nvme_queue *nvmeq, u16 idx)
+ 	}
+ 
+ 	req = blk_mq_tag_to_rq(nvme_queue_tagset(nvmeq), cqe->command_id);
++	if (unlikely(!req)) {
++		dev_warn(nvmeq->dev->ctrl.device,
++			"invalid id %d completed on queue %d\n",
++			cqe->command_id, le16_to_cpu(cqe->sq_id));
++		return;
++	}
++
+ 	trace_nvme_sq(req, cqe->sq_head, nvmeq->sq_tail);
+ 	nvme_end_request(req, cqe->status, cqe->result);
+ }
+@@ -3093,7 +3093,8 @@ static const struct pci_device_id nvme_id_table[] = {
+ 	{ PCI_VDEVICE(INTEL, 0xf1a5),	/* Intel 600P/P3100 */
+ 		.driver_data = NVME_QUIRK_NO_DEEPEST_PS |
+ 				NVME_QUIRK_MEDIUM_PRIO_SQ |
+-				NVME_QUIRK_NO_TEMP_THRESH_CHANGE },
++				NVME_QUIRK_NO_TEMP_THRESH_CHANGE |
++				NVME_QUIRK_DISABLE_WRITE_ZEROES, },
+ 	{ PCI_VDEVICE(INTEL, 0xf1a6),	/* Intel 760p/Pro 7600p */
+ 		.driver_data = NVME_QUIRK_IGNORE_DEV_SUBNQN, },
+ 	{ PCI_VDEVICE(INTEL, 0x5845),	/* Qemu emulated controller */
+diff --git a/drivers/phy/ti/phy-am654-serdes.c b/drivers/phy/ti/phy-am654-serdes.c
+index a174b3c3f010f..819c49af169ac 100644
+--- a/drivers/phy/ti/phy-am654-serdes.c
++++ b/drivers/phy/ti/phy-am654-serdes.c
+@@ -725,8 +725,10 @@ static int serdes_am654_probe(struct platform_device *pdev)
+ 	pm_runtime_enable(dev);
+ 
+ 	phy = devm_phy_create(dev, NULL, &ops);
+-	if (IS_ERR(phy))
+-		return PTR_ERR(phy);
++	if (IS_ERR(phy)) {
++		ret = PTR_ERR(phy);
++		goto clk_err;
++	}
+ 
+ 	phy_set_drvdata(phy, am654_phy);
+ 	phy_provider = devm_of_phy_provider_register(dev, serdes_am654_xlate);
+diff --git a/drivers/pinctrl/mediatek/pinctrl-mtk-common-v2.c b/drivers/pinctrl/mediatek/pinctrl-mtk-common-v2.c
+index 2f3dfb56c3fa4..35bbe59357088 100644
+--- a/drivers/pinctrl/mediatek/pinctrl-mtk-common-v2.c
++++ b/drivers/pinctrl/mediatek/pinctrl-mtk-common-v2.c
+@@ -259,6 +259,10 @@ bool mtk_is_virt_gpio(struct mtk_pinctrl *hw, unsigned int gpio_n)
+ 
+ 	desc = (const struct mtk_pin_desc *)&hw->soc->pins[gpio_n];
+ 
++	/* if the GPIO is not supported for eint mode */
++	if (desc->eint.eint_m == NO_EINT_SUPPORT)
++		return virt_gpio;
++
+ 	if (desc->funcs && !desc->funcs[desc->eint.eint_m].name)
+ 		virt_gpio = true;
+ 
+diff --git a/drivers/pinctrl/mvebu/pinctrl-armada-xp.c b/drivers/pinctrl/mvebu/pinctrl-armada-xp.c
+index a767a05fa3a0d..48e2a6c56a83b 100644
+--- a/drivers/pinctrl/mvebu/pinctrl-armada-xp.c
++++ b/drivers/pinctrl/mvebu/pinctrl-armada-xp.c
+@@ -414,7 +414,7 @@ static struct mvebu_mpp_mode mv98dx3236_mpp_modes[] = {
+ 		 MPP_VAR_FUNCTION(0x1, "i2c0", "sck",        V_98DX3236_PLUS)),
+ 	MPP_MODE(15,
+ 		 MPP_VAR_FUNCTION(0x0, "gpio", NULL,         V_98DX3236_PLUS),
+-		 MPP_VAR_FUNCTION(0x4, "i2c0", "sda",        V_98DX3236_PLUS)),
++		 MPP_VAR_FUNCTION(0x1, "i2c0", "sda",        V_98DX3236_PLUS)),
+ 	MPP_MODE(16,
+ 		 MPP_VAR_FUNCTION(0x0, "gpo", NULL,          V_98DX3236_PLUS),
+ 		 MPP_VAR_FUNCTION(0x4, "dev", "oe",          V_98DX3236_PLUS)),
+diff --git a/drivers/pinctrl/qcom/pinctrl-sm8250.c b/drivers/pinctrl/qcom/pinctrl-sm8250.c
+index a660f1274b667..826df0d637eaa 100644
+--- a/drivers/pinctrl/qcom/pinctrl-sm8250.c
++++ b/drivers/pinctrl/qcom/pinctrl-sm8250.c
+@@ -1308,7 +1308,7 @@ static const struct msm_pingroup sm8250_groups[] = {
+ 	[178] = PINGROUP(178, WEST, _, _, _, _, _, _, _, _, _),
+ 	[179] = PINGROUP(179, WEST, _, _, _, _, _, _, _, _, _),
+ 	[180] = UFS_RESET(ufs_reset, 0xb8000),
+-	[181] = SDC_PINGROUP(sdc2_clk, 0x7000, 14, 6),
++	[181] = SDC_PINGROUP(sdc2_clk, 0xb7000, 14, 6),
+ 	[182] = SDC_PINGROUP(sdc2_cmd, 0xb7000, 11, 3),
+ 	[183] = SDC_PINGROUP(sdc2_data, 0xb7000, 9, 0),
+ };
+diff --git a/drivers/scsi/iscsi_tcp.c b/drivers/scsi/iscsi_tcp.c
+index b5dd1caae5e92..d10efb66cf193 100644
+--- a/drivers/scsi/iscsi_tcp.c
++++ b/drivers/scsi/iscsi_tcp.c
+@@ -736,6 +736,7 @@ static int iscsi_sw_tcp_conn_get_param(struct iscsi_cls_conn *cls_conn,
+ 	struct iscsi_tcp_conn *tcp_conn = conn->dd_data;
+ 	struct iscsi_sw_tcp_conn *tcp_sw_conn = tcp_conn->dd_data;
+ 	struct sockaddr_in6 addr;
++	struct socket *sock;
+ 	int rc;
+ 
+ 	switch(param) {
+@@ -747,13 +748,17 @@ static int iscsi_sw_tcp_conn_get_param(struct iscsi_cls_conn *cls_conn,
+ 			spin_unlock_bh(&conn->session->frwd_lock);
+ 			return -ENOTCONN;
+ 		}
++		sock = tcp_sw_conn->sock;
++		sock_hold(sock->sk);
++		spin_unlock_bh(&conn->session->frwd_lock);
++
+ 		if (param == ISCSI_PARAM_LOCAL_PORT)
+-			rc = kernel_getsockname(tcp_sw_conn->sock,
++			rc = kernel_getsockname(sock,
+ 						(struct sockaddr *)&addr);
+ 		else
+-			rc = kernel_getpeername(tcp_sw_conn->sock,
++			rc = kernel_getpeername(sock,
+ 						(struct sockaddr *)&addr);
+-		spin_unlock_bh(&conn->session->frwd_lock);
++		sock_put(sock->sk);
+ 		if (rc < 0)
+ 			return rc;
+ 
+@@ -775,6 +780,7 @@ static int iscsi_sw_tcp_host_get_param(struct Scsi_Host *shost,
+ 	struct iscsi_tcp_conn *tcp_conn;
+ 	struct iscsi_sw_tcp_conn *tcp_sw_conn;
+ 	struct sockaddr_in6 addr;
++	struct socket *sock;
+ 	int rc;
+ 
+ 	switch (param) {
+@@ -789,16 +795,18 @@ static int iscsi_sw_tcp_host_get_param(struct Scsi_Host *shost,
+ 			return -ENOTCONN;
+ 		}
+ 		tcp_conn = conn->dd_data;
+-
+ 		tcp_sw_conn = tcp_conn->dd_data;
+-		if (!tcp_sw_conn->sock) {
++		sock = tcp_sw_conn->sock;
++		if (!sock) {
+ 			spin_unlock_bh(&session->frwd_lock);
+ 			return -ENOTCONN;
+ 		}
++		sock_hold(sock->sk);
++		spin_unlock_bh(&session->frwd_lock);
+ 
+-		rc = kernel_getsockname(tcp_sw_conn->sock,
++		rc = kernel_getsockname(sock,
+ 					(struct sockaddr *)&addr);
+-		spin_unlock_bh(&session->frwd_lock);
++		sock_put(sock->sk);
+ 		if (rc < 0)
+ 			return rc;
+ 
+diff --git a/drivers/scsi/sd.c b/drivers/scsi/sd.c
+index d90fefffe31b7..4b2117cb84837 100644
+--- a/drivers/scsi/sd.c
++++ b/drivers/scsi/sd.c
+@@ -2966,26 +2966,32 @@ static void sd_read_block_characteristics(struct scsi_disk *sdkp)
+ 
+ 	if (sdkp->device->type == TYPE_ZBC) {
+ 		/* Host-managed */
+-		q->limits.zoned = BLK_ZONED_HM;
++		blk_queue_set_zoned(sdkp->disk, BLK_ZONED_HM);
+ 	} else {
+ 		sdkp->zoned = (buffer[8] >> 4) & 3;
+-		if (sdkp->zoned == 1 && !disk_has_partitions(sdkp->disk)) {
++		if (sdkp->zoned == 1) {
+ 			/* Host-aware */
+-			q->limits.zoned = BLK_ZONED_HA;
++			blk_queue_set_zoned(sdkp->disk, BLK_ZONED_HA);
+ 		} else {
+-			/*
+-			 * Treat drive-managed devices and host-aware devices
+-			 * with partitions as regular block devices.
+-			 */
+-			q->limits.zoned = BLK_ZONED_NONE;
+-			if (sdkp->zoned == 2 && sdkp->first_scan)
+-				sd_printk(KERN_NOTICE, sdkp,
+-					  "Drive-managed SMR disk\n");
++			/* Regular disk or drive managed disk */
++			blk_queue_set_zoned(sdkp->disk, BLK_ZONED_NONE);
+ 		}
+ 	}
+-	if (blk_queue_is_zoned(q) && sdkp->first_scan)
++
++	if (!sdkp->first_scan)
++		goto out;
++
++	if (blk_queue_is_zoned(q)) {
+ 		sd_printk(KERN_NOTICE, sdkp, "Host-%s zoned block device\n",
+ 		      q->limits.zoned == BLK_ZONED_HM ? "managed" : "aware");
++	} else {
++		if (sdkp->zoned == 1)
++			sd_printk(KERN_NOTICE, sdkp,
++				  "Host-aware SMR disk used as regular disk\n");
++		else if (sdkp->zoned == 2)
++			sd_printk(KERN_NOTICE, sdkp,
++				  "Drive-managed SMR disk\n");
++	}
+ 
+  out:
+ 	kfree(buffer);
+@@ -3398,10 +3404,6 @@ static int sd_probe(struct device *dev)
+ 	sdkp->first_scan = 1;
+ 	sdkp->max_medium_access_timeouts = SD_MAX_MEDIUM_TIMEOUTS;
+ 
+-	error = sd_zbc_init_disk(sdkp);
+-	if (error)
+-		goto out_free_index;
+-
+ 	sd_revalidate_disk(gd);
+ 
+ 	gd->flags = GENHD_FL_EXT_DEVT;
+diff --git a/drivers/scsi/sd.h b/drivers/scsi/sd.h
+index 3a74f4b45134f..9c24de305c6b9 100644
+--- a/drivers/scsi/sd.h
++++ b/drivers/scsi/sd.h
+@@ -213,7 +213,6 @@ static inline int sd_is_zoned(struct scsi_disk *sdkp)
+ 
+ #ifdef CONFIG_BLK_DEV_ZONED
+ 
+-int sd_zbc_init_disk(struct scsi_disk *sdkp);
+ void sd_zbc_release_disk(struct scsi_disk *sdkp);
+ extern int sd_zbc_read_zones(struct scsi_disk *sdkp, unsigned char *buffer);
+ extern void sd_zbc_print_zones(struct scsi_disk *sdkp);
+@@ -229,17 +228,6 @@ blk_status_t sd_zbc_prepare_zone_append(struct scsi_cmnd *cmd, sector_t *lba,
+ 
+ #else /* CONFIG_BLK_DEV_ZONED */
+ 
+-static inline int sd_zbc_init(void)
+-{
+-	return 0;
+-}
+-
+-static inline int sd_zbc_init_disk(struct scsi_disk *sdkp)
+-{
+-	return 0;
+-}
+-
+-static inline void sd_zbc_exit(void) {}
+ static inline void sd_zbc_release_disk(struct scsi_disk *sdkp) {}
+ 
+ static inline int sd_zbc_read_zones(struct scsi_disk *sdkp,
+@@ -260,7 +248,7 @@ static inline blk_status_t sd_zbc_setup_zone_mgmt_cmnd(struct scsi_cmnd *cmd,
+ static inline unsigned int sd_zbc_complete(struct scsi_cmnd *cmd,
+ 			unsigned int good_bytes, struct scsi_sense_hdr *sshdr)
+ {
+-	return 0;
++	return good_bytes;
+ }
+ 
+ static inline blk_status_t sd_zbc_prepare_zone_append(struct scsi_cmnd *cmd,
+diff --git a/drivers/scsi/sd_zbc.c b/drivers/scsi/sd_zbc.c
+index 6f7eba66687e9..8384b5dcfa029 100644
+--- a/drivers/scsi/sd_zbc.c
++++ b/drivers/scsi/sd_zbc.c
+@@ -633,6 +633,45 @@ static int sd_zbc_check_capacity(struct scsi_disk *sdkp, unsigned char *buf,
+ 	return 0;
+ }
+ 
++void sd_zbc_print_zones(struct scsi_disk *sdkp)
++{
++	if (!sd_is_zoned(sdkp) || !sdkp->capacity)
++		return;
++
++	if (sdkp->capacity & (sdkp->zone_blocks - 1))
++		sd_printk(KERN_NOTICE, sdkp,
++			  "%u zones of %u logical blocks + 1 runt zone\n",
++			  sdkp->nr_zones - 1,
++			  sdkp->zone_blocks);
++	else
++		sd_printk(KERN_NOTICE, sdkp,
++			  "%u zones of %u logical blocks\n",
++			  sdkp->nr_zones,
++			  sdkp->zone_blocks);
++}
++
++static int sd_zbc_init_disk(struct scsi_disk *sdkp)
++{
++	sdkp->zones_wp_offset = NULL;
++	spin_lock_init(&sdkp->zones_wp_offset_lock);
++	sdkp->rev_wp_offset = NULL;
++	mutex_init(&sdkp->rev_mutex);
++	INIT_WORK(&sdkp->zone_wp_offset_work, sd_zbc_update_wp_offset_workfn);
++	sdkp->zone_wp_update_buf = kzalloc(SD_BUF_SIZE, GFP_KERNEL);
++	if (!sdkp->zone_wp_update_buf)
++		return -ENOMEM;
++
++	return 0;
++}
++
++void sd_zbc_release_disk(struct scsi_disk *sdkp)
++{
++	kvfree(sdkp->zones_wp_offset);
++	sdkp->zones_wp_offset = NULL;
++	kfree(sdkp->zone_wp_update_buf);
++	sdkp->zone_wp_update_buf = NULL;
++}
++
+ static void sd_zbc_revalidate_zones_cb(struct gendisk *disk)
+ {
+ 	struct scsi_disk *sdkp = scsi_disk(disk);
+@@ -645,8 +684,30 @@ static int sd_zbc_revalidate_zones(struct scsi_disk *sdkp,
+ 				   unsigned int nr_zones)
+ {
+ 	struct gendisk *disk = sdkp->disk;
++	struct request_queue *q = disk->queue;
++	u32 max_append;
+ 	int ret = 0;
+ 
++	/*
++	 * For all zoned disks, initialize zone append emulation data if not
++	 * already done. This is necessary also for host-aware disks used as
++	 * regular disks due to the presence of partitions as these partitions
++	 * may be deleted and the disk zoned model changed back from
++	 * BLK_ZONED_NONE to BLK_ZONED_HA.
++	 */
++	if (sd_is_zoned(sdkp) && !sdkp->zone_wp_update_buf) {
++		ret = sd_zbc_init_disk(sdkp);
++		if (ret)
++			return ret;
++	}
++
++	/*
++	 * There is nothing to do for regular disks, including host-aware disks
++	 * that have partitions.
++	 */
++	if (!blk_queue_is_zoned(q))
++		return 0;
++
+ 	/*
+ 	 * Make sure revalidate zones are serialized to ensure exclusive
+ 	 * updates of the scsi disk data.
+@@ -681,6 +742,19 @@ static int sd_zbc_revalidate_zones(struct scsi_disk *sdkp,
+ 	kvfree(sdkp->rev_wp_offset);
+ 	sdkp->rev_wp_offset = NULL;
+ 
++	if (ret) {
++		sdkp->zone_blocks = 0;
++		sdkp->nr_zones = 0;
++		sdkp->capacity = 0;
++		goto unlock;
++	}
++
++	max_append = min_t(u32, logical_to_sectors(sdkp->device, zone_blocks),
++			   q->limits.max_segments << (PAGE_SHIFT - 9));
++	max_append = min_t(u32, max_append, queue_max_hw_sectors(q));
++
++	blk_queue_max_zone_append_sectors(q, max_append);
++
+ unlock:
+ 	mutex_unlock(&sdkp->rev_mutex);
+ 
+@@ -693,7 +767,6 @@ int sd_zbc_read_zones(struct scsi_disk *sdkp, unsigned char *buf)
+ 	struct request_queue *q = disk->queue;
+ 	unsigned int nr_zones;
+ 	u32 zone_blocks = 0;
+-	u32 max_append;
+ 	int ret;
+ 
+ 	if (!sd_is_zoned(sdkp))
+@@ -726,20 +799,6 @@ int sd_zbc_read_zones(struct scsi_disk *sdkp, unsigned char *buf)
+ 	if (ret)
+ 		goto err;
+ 
+-	/*
+-	 * On the first scan 'chunk_sectors' isn't setup yet, so calling
+-	 * blk_queue_max_zone_append_sectors() will result in a WARN(). Defer
+-	 * this setting to the second scan.
+-	 */
+-	if (sdkp->first_scan)
+-		return 0;
+-
+-	max_append = min_t(u32, logical_to_sectors(sdkp->device, zone_blocks),
+-			   q->limits.max_segments << (PAGE_SHIFT - 9));
+-	max_append = min_t(u32, max_append, queue_max_hw_sectors(q));
+-
+-	blk_queue_max_zone_append_sectors(q, max_append);
+-
+ 	return 0;
+ 
+ err:
+@@ -747,45 +806,3 @@ err:
+ 
+ 	return ret;
+ }
+-
+-void sd_zbc_print_zones(struct scsi_disk *sdkp)
+-{
+-	if (!sd_is_zoned(sdkp) || !sdkp->capacity)
+-		return;
+-
+-	if (sdkp->capacity & (sdkp->zone_blocks - 1))
+-		sd_printk(KERN_NOTICE, sdkp,
+-			  "%u zones of %u logical blocks + 1 runt zone\n",
+-			  sdkp->nr_zones - 1,
+-			  sdkp->zone_blocks);
+-	else
+-		sd_printk(KERN_NOTICE, sdkp,
+-			  "%u zones of %u logical blocks\n",
+-			  sdkp->nr_zones,
+-			  sdkp->zone_blocks);
+-}
+-
+-int sd_zbc_init_disk(struct scsi_disk *sdkp)
+-{
+-	if (!sd_is_zoned(sdkp))
+-		return 0;
+-
+-	sdkp->zones_wp_offset = NULL;
+-	spin_lock_init(&sdkp->zones_wp_offset_lock);
+-	sdkp->rev_wp_offset = NULL;
+-	mutex_init(&sdkp->rev_mutex);
+-	INIT_WORK(&sdkp->zone_wp_offset_work, sd_zbc_update_wp_offset_workfn);
+-	sdkp->zone_wp_update_buf = kzalloc(SD_BUF_SIZE, GFP_KERNEL);
+-	if (!sdkp->zone_wp_update_buf)
+-		return -ENOMEM;
+-
+-	return 0;
+-}
+-
+-void sd_zbc_release_disk(struct scsi_disk *sdkp)
+-{
+-	kvfree(sdkp->zones_wp_offset);
+-	sdkp->zones_wp_offset = NULL;
+-	kfree(sdkp->zone_wp_update_buf);
+-	sdkp->zone_wp_update_buf = NULL;
+-}
+diff --git a/drivers/spi/spi-fsl-espi.c b/drivers/spi/spi-fsl-espi.c
+index e60581283a247..6d148ab70b93e 100644
+--- a/drivers/spi/spi-fsl-espi.c
++++ b/drivers/spi/spi-fsl-espi.c
+@@ -564,13 +564,14 @@ static void fsl_espi_cpu_irq(struct fsl_espi *espi, u32 events)
+ static irqreturn_t fsl_espi_irq(s32 irq, void *context_data)
+ {
+ 	struct fsl_espi *espi = context_data;
+-	u32 events;
++	u32 events, mask;
+ 
+ 	spin_lock(&espi->lock);
+ 
+ 	/* Get interrupt events(tx/rx) */
+ 	events = fsl_espi_read_reg(espi, ESPI_SPIE);
+-	if (!events) {
++	mask = fsl_espi_read_reg(espi, ESPI_SPIM);
++	if (!(events & mask)) {
+ 		spin_unlock(&espi->lock);
+ 		return IRQ_NONE;
+ 	}
+diff --git a/drivers/target/target_core_transport.c b/drivers/target/target_core_transport.c
+index e6e1fa68de542..94f4f05b5002c 100644
+--- a/drivers/target/target_core_transport.c
++++ b/drivers/target/target_core_transport.c
+@@ -1840,7 +1840,8 @@ int target_submit_tmr(struct se_cmd *se_cmd, struct se_session *se_sess,
+ 	 * out unpacked_lun for the original se_cmd.
+ 	 */
+ 	if (tm_type == TMR_ABORT_TASK && (flags & TARGET_SCF_LOOKUP_LUN_FROM_TAG)) {
+-		if (!target_lookup_lun_from_tag(se_sess, tag, &unpacked_lun))
++		if (!target_lookup_lun_from_tag(se_sess, tag,
++						&se_cmd->orig_fe_lun))
+ 			goto failure;
+ 	}
+ 
+diff --git a/drivers/usb/core/driver.c b/drivers/usb/core/driver.c
+index 7e73e989645bd..b351962279e4d 100644
+--- a/drivers/usb/core/driver.c
++++ b/drivers/usb/core/driver.c
+@@ -269,8 +269,30 @@ static int usb_probe_device(struct device *dev)
+ 	if (error)
+ 		return error;
+ 
++	/* Probe the USB device with the driver in hand, but only
++	 * defer to a generic driver in case the current USB
++	 * device driver has an id_table or a match function; i.e.,
++	 * when the device driver was explicitly matched against
++	 * a device.
++	 *
++	 * If the device driver does not have either of these,
++	 * then we assume that it can bind to any device and is
++	 * not truly a more specialized/non-generic driver, so a
++	 * return value of -ENODEV should not force the device
++	 * to be handled by the generic USB driver, as there
++	 * can still be another, more specialized, device driver.
++	 *
++	 * This accommodates the usbip driver.
++	 *
++	 * TODO: What if, in the future, there are multiple
++	 * specialized USB device drivers for a particular device?
++	 * In such cases, there is a need to try all matching
++	 * specialised device drivers prior to setting the
++	 * use_generic_driver bit.
++	 */
+ 	error = udriver->probe(udev);
+-	if (error == -ENODEV && udriver != &usb_generic_driver) {
++	if (error == -ENODEV && udriver != &usb_generic_driver &&
++	    (udriver->id_table || udriver->match)) {
+ 		udev->use_generic_driver = 1;
+ 		return -EPROBE_DEFER;
+ 	}
+@@ -831,14 +853,17 @@ static int usb_device_match(struct device *dev, struct device_driver *drv)
+ 		udev = to_usb_device(dev);
+ 		udrv = to_usb_device_driver(drv);
+ 
+-		if (udrv->id_table &&
+-		    usb_device_match_id(udev, udrv->id_table) != NULL) {
+-			return 1;
+-		}
++		if (udrv->id_table)
++			return usb_device_match_id(udev, udrv->id_table) != NULL;
+ 
+ 		if (udrv->match)
+ 			return udrv->match(udev);
+-		return 0;
++
++		/* If the device driver under consideration does not have a
++		 * id_table or a match function, then let the driver's probe
++		 * function decide.
++		 */
++		return 1;
+ 
+ 	} else if (is_usb_interface(dev)) {
+ 		struct usb_interface *intf;
+@@ -905,26 +930,19 @@ static int usb_uevent(struct device *dev, struct kobj_uevent_env *env)
+ 	return 0;
+ }
+ 
+-static bool is_dev_usb_generic_driver(struct device *dev)
+-{
+-	struct usb_device_driver *udd = dev->driver ?
+-		to_usb_device_driver(dev->driver) : NULL;
+-
+-	return udd == &usb_generic_driver;
+-}
+-
+ static int __usb_bus_reprobe_drivers(struct device *dev, void *data)
+ {
+ 	struct usb_device_driver *new_udriver = data;
+ 	struct usb_device *udev;
+ 	int ret;
+ 
+-	if (!is_dev_usb_generic_driver(dev))
++	/* Don't reprobe if current driver isn't usb_generic_driver */
++	if (dev->driver != &usb_generic_driver.drvwrap.driver)
+ 		return 0;
+ 
+ 	udev = to_usb_device(dev);
+ 	if (usb_device_match_id(udev, new_udriver->id_table) == NULL &&
+-	    (!new_udriver->match || new_udriver->match(udev) != 0))
++	    (!new_udriver->match || new_udriver->match(udev) == 0))
+ 		return 0;
+ 
+ 	ret = device_reprobe(dev);
+diff --git a/drivers/usb/gadget/function/f_ncm.c b/drivers/usb/gadget/function/f_ncm.c
+index b4206b0dede54..1f638759a9533 100644
+--- a/drivers/usb/gadget/function/f_ncm.c
++++ b/drivers/usb/gadget/function/f_ncm.c
+@@ -1189,7 +1189,6 @@ static int ncm_unwrap_ntb(struct gether *port,
+ 	const struct ndp_parser_opts *opts = ncm->parser_opts;
+ 	unsigned	crc_len = ncm->is_crc ? sizeof(uint32_t) : 0;
+ 	int		dgram_counter;
+-	bool		ndp_after_header;
+ 
+ 	/* dwSignature */
+ 	if (get_unaligned_le32(tmp) != opts->nth_sign) {
+@@ -1216,7 +1215,6 @@ static int ncm_unwrap_ntb(struct gether *port,
+ 	}
+ 
+ 	ndp_index = get_ncm(&tmp, opts->ndp_index);
+-	ndp_after_header = false;
+ 
+ 	/* Run through all the NDP's in the NTB */
+ 	do {
+@@ -1232,8 +1230,6 @@ static int ncm_unwrap_ntb(struct gether *port,
+ 			     ndp_index);
+ 			goto err;
+ 		}
+-		if (ndp_index == opts->nth_size)
+-			ndp_after_header = true;
+ 
+ 		/*
+ 		 * walk through NDP
+@@ -1312,37 +1308,13 @@ static int ncm_unwrap_ntb(struct gether *port,
+ 			index2 = get_ncm(&tmp, opts->dgram_item_len);
+ 			dg_len2 = get_ncm(&tmp, opts->dgram_item_len);
+ 
+-			if (index2 == 0 || dg_len2 == 0)
+-				break;
+-
+ 			/* wDatagramIndex[1] */
+-			if (ndp_after_header) {
+-				if (index2 < opts->nth_size + opts->ndp_size) {
+-					INFO(port->func.config->cdev,
+-					     "Bad index: %#X\n", index2);
+-					goto err;
+-				}
+-			} else {
+-				if (index2 < opts->nth_size + opts->dpe_size) {
+-					INFO(port->func.config->cdev,
+-					     "Bad index: %#X\n", index2);
+-					goto err;
+-				}
+-			}
+ 			if (index2 > block_len - opts->dpe_size) {
+ 				INFO(port->func.config->cdev,
+ 				     "Bad index: %#X\n", index2);
+ 				goto err;
+ 			}
+ 
+-			/* wDatagramLength[1] */
+-			if ((dg_len2 < 14 + crc_len) ||
+-					(dg_len2 > frame_max)) {
+-				INFO(port->func.config->cdev,
+-				     "Bad dgram length: %#X\n", dg_len);
+-				goto err;
+-			}
+-
+ 			/*
+ 			 * Copy the data into a new skb.
+ 			 * This ensures the truesize is correct
+@@ -1359,6 +1331,8 @@ static int ncm_unwrap_ntb(struct gether *port,
+ 			ndp_len -= 2 * (opts->dgram_item_len * 2);
+ 
+ 			dgram_counter++;
++			if (index2 == 0 || dg_len2 == 0)
++				break;
+ 		} while (ndp_len > 2 * (opts->dgram_item_len * 2));
+ 	} while (ndp_index);
+ 
+diff --git a/drivers/usb/usbip/stub_dev.c b/drivers/usb/usbip/stub_dev.c
+index 9d7d642022d1f..2305d425e6c9a 100644
+--- a/drivers/usb/usbip/stub_dev.c
++++ b/drivers/usb/usbip/stub_dev.c
+@@ -461,11 +461,6 @@ static void stub_disconnect(struct usb_device *udev)
+ 	return;
+ }
+ 
+-static bool usbip_match(struct usb_device *udev)
+-{
+-	return true;
+-}
+-
+ #ifdef CONFIG_PM
+ 
+ /* These functions need usb_port_suspend and usb_port_resume,
+@@ -491,7 +486,6 @@ struct usb_device_driver stub_driver = {
+ 	.name		= "usbip-host",
+ 	.probe		= stub_probe,
+ 	.disconnect	= stub_disconnect,
+-	.match		= usbip_match,
+ #ifdef CONFIG_PM
+ 	.suspend	= stub_suspend,
+ 	.resume		= stub_resume,
+diff --git a/drivers/xen/events/events_base.c b/drivers/xen/events/events_base.c
+index 90b8f56fbadb1..6f02c18fa65c8 100644
+--- a/drivers/xen/events/events_base.c
++++ b/drivers/xen/events/events_base.c
+@@ -92,6 +92,8 @@ static bool (*pirq_needs_eoi)(unsigned irq);
+ /* Xen will never allocate port zero for any purpose. */
+ #define VALID_EVTCHN(chn)	((chn) != 0)
+ 
++static struct irq_info *legacy_info_ptrs[NR_IRQS_LEGACY];
++
+ static struct irq_chip xen_dynamic_chip;
+ static struct irq_chip xen_percpu_chip;
+ static struct irq_chip xen_pirq_chip;
+@@ -156,7 +158,18 @@ int get_evtchn_to_irq(evtchn_port_t evtchn)
+ /* Get info for IRQ */
+ struct irq_info *info_for_irq(unsigned irq)
+ {
+-	return irq_get_chip_data(irq);
++	if (irq < nr_legacy_irqs())
++		return legacy_info_ptrs[irq];
++	else
++		return irq_get_chip_data(irq);
++}
++
++static void set_info_for_irq(unsigned int irq, struct irq_info *info)
++{
++	if (irq < nr_legacy_irqs())
++		legacy_info_ptrs[irq] = info;
++	else
++		irq_set_chip_data(irq, info);
+ }
+ 
+ /* Constructors for packed IRQ information. */
+@@ -377,7 +390,7 @@ static void xen_irq_init(unsigned irq)
+ 	info->type = IRQT_UNBOUND;
+ 	info->refcnt = -1;
+ 
+-	irq_set_chip_data(irq, info);
++	set_info_for_irq(irq, info);
+ 
+ 	list_add_tail(&info->list, &xen_irq_list_head);
+ }
+@@ -426,14 +439,14 @@ static int __must_check xen_allocate_irq_gsi(unsigned gsi)
+ 
+ static void xen_free_irq(unsigned irq)
+ {
+-	struct irq_info *info = irq_get_chip_data(irq);
++	struct irq_info *info = info_for_irq(irq);
+ 
+ 	if (WARN_ON(!info))
+ 		return;
+ 
+ 	list_del(&info->list);
+ 
+-	irq_set_chip_data(irq, NULL);
++	set_info_for_irq(irq, NULL);
+ 
+ 	WARN_ON(info->refcnt > 0);
+ 
+@@ -603,7 +616,7 @@ EXPORT_SYMBOL_GPL(xen_irq_from_gsi);
+ static void __unbind_from_irq(unsigned int irq)
+ {
+ 	evtchn_port_t evtchn = evtchn_from_irq(irq);
+-	struct irq_info *info = irq_get_chip_data(irq);
++	struct irq_info *info = info_for_irq(irq);
+ 
+ 	if (info->refcnt > 0) {
+ 		info->refcnt--;
+@@ -1108,7 +1121,7 @@ int bind_ipi_to_irqhandler(enum ipi_vector ipi,
+ 
+ void unbind_from_irqhandler(unsigned int irq, void *dev_id)
+ {
+-	struct irq_info *info = irq_get_chip_data(irq);
++	struct irq_info *info = info_for_irq(irq);
+ 
+ 	if (WARN_ON(!info))
+ 		return;
+@@ -1142,7 +1155,7 @@ int evtchn_make_refcounted(evtchn_port_t evtchn)
+ 	if (irq == -1)
+ 		return -ENOENT;
+ 
+-	info = irq_get_chip_data(irq);
++	info = info_for_irq(irq);
+ 
+ 	if (!info)
+ 		return -ENOENT;
+@@ -1170,7 +1183,7 @@ int evtchn_get(evtchn_port_t evtchn)
+ 	if (irq == -1)
+ 		goto done;
+ 
+-	info = irq_get_chip_data(irq);
++	info = info_for_irq(irq);
+ 
+ 	if (!info)
+ 		goto done;
+diff --git a/fs/autofs/waitq.c b/fs/autofs/waitq.c
+index 74c886f7c51cb..5ced859dac539 100644
+--- a/fs/autofs/waitq.c
++++ b/fs/autofs/waitq.c
+@@ -53,7 +53,7 @@ static int autofs_write(struct autofs_sb_info *sbi,
+ 
+ 	mutex_lock(&sbi->pipe_mutex);
+ 	while (bytes) {
+-		wr = kernel_write(file, data, bytes, &file->f_pos);
++		wr = __kernel_write(file, data, bytes, NULL);
+ 		if (wr <= 0)
+ 			break;
+ 		data += wr;
+diff --git a/fs/btrfs/dev-replace.c b/fs/btrfs/dev-replace.c
+index db93909b25e08..eb86e4b88c73a 100644
+--- a/fs/btrfs/dev-replace.c
++++ b/fs/btrfs/dev-replace.c
+@@ -599,6 +599,37 @@ static void btrfs_rm_dev_replace_unblocked(struct btrfs_fs_info *fs_info)
+ 	wake_up(&fs_info->dev_replace.replace_wait);
+ }
+ 
++/*
++ * When finishing the device replace, before swapping the source device with the
++ * target device we must update the chunk allocation state in the target device,
++ * as it is empty because replace works by directly copying the chunks and not
++ * through the normal chunk allocation path.
++ */
++static int btrfs_set_target_alloc_state(struct btrfs_device *srcdev,
++					struct btrfs_device *tgtdev)
++{
++	struct extent_state *cached_state = NULL;
++	u64 start = 0;
++	u64 found_start;
++	u64 found_end;
++	int ret = 0;
++
++	lockdep_assert_held(&srcdev->fs_info->chunk_mutex);
++
++	while (!find_first_extent_bit(&srcdev->alloc_state, start,
++				      &found_start, &found_end,
++				      CHUNK_ALLOCATED, &cached_state)) {
++		ret = set_extent_bits(&tgtdev->alloc_state, found_start,
++				      found_end, CHUNK_ALLOCATED);
++		if (ret)
++			break;
++		start = found_end + 1;
++	}
++
++	free_extent_state(cached_state);
++	return ret;
++}
++
+ static int btrfs_dev_replace_finishing(struct btrfs_fs_info *fs_info,
+ 				       int scrub_ret)
+ {
+@@ -673,8 +704,14 @@ static int btrfs_dev_replace_finishing(struct btrfs_fs_info *fs_info,
+ 	dev_replace->time_stopped = ktime_get_real_seconds();
+ 	dev_replace->item_needs_writeback = 1;
+ 
+-	/* replace old device with new one in mapping tree */
++	/*
++	 * Update allocation state in the new device and replace the old device
++	 * with the new one in the mapping tree.
++	 */
+ 	if (!scrub_ret) {
++		scrub_ret = btrfs_set_target_alloc_state(src_device, tgt_device);
++		if (scrub_ret)
++			goto error;
+ 		btrfs_dev_replace_update_device_in_mapping_tree(fs_info,
+ 								src_device,
+ 								tgt_device);
+@@ -685,6 +722,7 @@ static int btrfs_dev_replace_finishing(struct btrfs_fs_info *fs_info,
+ 				 btrfs_dev_name(src_device),
+ 				 src_device->devid,
+ 				 rcu_str_deref(tgt_device->name), scrub_ret);
++error:
+ 		up_write(&dev_replace->rwsem);
+ 		mutex_unlock(&fs_info->chunk_mutex);
+ 		mutex_unlock(&fs_info->fs_devices->device_list_mutex);
+diff --git a/fs/eventpoll.c b/fs/eventpoll.c
+index 8107e06d7f6f5..4df61129566d4 100644
+--- a/fs/eventpoll.c
++++ b/fs/eventpoll.c
+@@ -218,8 +218,7 @@ struct eventpoll {
+ 	struct file *file;
+ 
+ 	/* used to optimize loop detection check */
+-	struct list_head visited_list_link;
+-	int visited;
++	u64 gen;
+ 
+ #ifdef CONFIG_NET_RX_BUSY_POLL
+ 	/* used to track busy poll napi_id */
+@@ -274,6 +273,8 @@ static long max_user_watches __read_mostly;
+  */
+ static DEFINE_MUTEX(epmutex);
+ 
++static u64 loop_check_gen = 0;
++
+ /* Used to check for epoll file descriptor inclusion loops */
+ static struct nested_calls poll_loop_ncalls;
+ 
+@@ -283,9 +284,6 @@ static struct kmem_cache *epi_cache __read_mostly;
+ /* Slab cache used to allocate "struct eppoll_entry" */
+ static struct kmem_cache *pwq_cache __read_mostly;
+ 
+-/* Visited nodes during ep_loop_check(), so we can unset them when we finish */
+-static LIST_HEAD(visited_list);
+-
+ /*
+  * List of files with newly added links, where we may need to limit the number
+  * of emanating paths. Protected by the epmutex.
+@@ -1450,7 +1448,7 @@ static int reverse_path_check(void)
+ 
+ static int ep_create_wakeup_source(struct epitem *epi)
+ {
+-	const char *name;
++	struct name_snapshot n;
+ 	struct wakeup_source *ws;
+ 
+ 	if (!epi->ep->ws) {
+@@ -1459,8 +1457,9 @@ static int ep_create_wakeup_source(struct epitem *epi)
+ 			return -ENOMEM;
+ 	}
+ 
+-	name = epi->ffd.file->f_path.dentry->d_name.name;
+-	ws = wakeup_source_register(NULL, name);
++	take_dentry_name_snapshot(&n, epi->ffd.file->f_path.dentry);
++	ws = wakeup_source_register(NULL, n.name.name);
++	release_dentry_name_snapshot(&n);
+ 
+ 	if (!ws)
+ 		return -ENOMEM;
+@@ -1522,6 +1521,22 @@ static int ep_insert(struct eventpoll *ep, const struct epoll_event *event,
+ 		RCU_INIT_POINTER(epi->ws, NULL);
+ 	}
+ 
++	/* Add the current item to the list of active epoll hook for this file */
++	spin_lock(&tfile->f_lock);
++	list_add_tail_rcu(&epi->fllink, &tfile->f_ep_links);
++	spin_unlock(&tfile->f_lock);
++
++	/*
++	 * Add the current item to the RB tree. All RB tree operations are
++	 * protected by "mtx", and ep_insert() is called with "mtx" held.
++	 */
++	ep_rbtree_insert(ep, epi);
++
++	/* now check if we've created too many backpaths */
++	error = -EINVAL;
++	if (full_check && reverse_path_check())
++		goto error_remove_epi;
++
+ 	/* Initialize the poll table using the queue callback */
+ 	epq.epi = epi;
+ 	init_poll_funcptr(&epq.pt, ep_ptable_queue_proc);
+@@ -1544,22 +1559,6 @@ static int ep_insert(struct eventpoll *ep, const struct epoll_event *event,
+ 	if (epi->nwait < 0)
+ 		goto error_unregister;
+ 
+-	/* Add the current item to the list of active epoll hook for this file */
+-	spin_lock(&tfile->f_lock);
+-	list_add_tail_rcu(&epi->fllink, &tfile->f_ep_links);
+-	spin_unlock(&tfile->f_lock);
+-
+-	/*
+-	 * Add the current item to the RB tree. All RB tree operations are
+-	 * protected by "mtx", and ep_insert() is called with "mtx" held.
+-	 */
+-	ep_rbtree_insert(ep, epi);
+-
+-	/* now check if we've created too many backpaths */
+-	error = -EINVAL;
+-	if (full_check && reverse_path_check())
+-		goto error_remove_epi;
+-
+ 	/* We have to drop the new item inside our item list to keep track of it */
+ 	write_lock_irq(&ep->lock);
+ 
+@@ -1588,6 +1587,8 @@ static int ep_insert(struct eventpoll *ep, const struct epoll_event *event,
+ 
+ 	return 0;
+ 
++error_unregister:
++	ep_unregister_pollwait(ep, epi);
+ error_remove_epi:
+ 	spin_lock(&tfile->f_lock);
+ 	list_del_rcu(&epi->fllink);
+@@ -1595,9 +1596,6 @@ error_remove_epi:
+ 
+ 	rb_erase_cached(&epi->rbn, &ep->rbr);
+ 
+-error_unregister:
+-	ep_unregister_pollwait(ep, epi);
+-
+ 	/*
+ 	 * We need to do this because an event could have been arrived on some
+ 	 * allocated wait queue. Note that we don't care about the ep->ovflist
+@@ -1972,13 +1970,12 @@ static int ep_loop_check_proc(void *priv, void *cookie, int call_nests)
+ 	struct epitem *epi;
+ 
+ 	mutex_lock_nested(&ep->mtx, call_nests + 1);
+-	ep->visited = 1;
+-	list_add(&ep->visited_list_link, &visited_list);
++	ep->gen = loop_check_gen;
+ 	for (rbp = rb_first_cached(&ep->rbr); rbp; rbp = rb_next(rbp)) {
+ 		epi = rb_entry(rbp, struct epitem, rbn);
+ 		if (unlikely(is_file_epoll(epi->ffd.file))) {
+ 			ep_tovisit = epi->ffd.file->private_data;
+-			if (ep_tovisit->visited)
++			if (ep_tovisit->gen == loop_check_gen)
+ 				continue;
+ 			error = ep_call_nested(&poll_loop_ncalls,
+ 					ep_loop_check_proc, epi->ffd.file,
+@@ -2019,18 +2016,8 @@ static int ep_loop_check_proc(void *priv, void *cookie, int call_nests)
+  */
+ static int ep_loop_check(struct eventpoll *ep, struct file *file)
+ {
+-	int ret;
+-	struct eventpoll *ep_cur, *ep_next;
+-
+-	ret = ep_call_nested(&poll_loop_ncalls,
++	return ep_call_nested(&poll_loop_ncalls,
+ 			      ep_loop_check_proc, file, ep, current);
+-	/* clear visited list */
+-	list_for_each_entry_safe(ep_cur, ep_next, &visited_list,
+-							visited_list_link) {
+-		ep_cur->visited = 0;
+-		list_del(&ep_cur->visited_list_link);
+-	}
+-	return ret;
+ }
+ 
+ static void clear_tfile_check_list(void)
+@@ -2195,11 +2182,13 @@ int do_epoll_ctl(int epfd, int op, int fd, struct epoll_event *epds,
+ 		goto error_tgt_fput;
+ 	if (op == EPOLL_CTL_ADD) {
+ 		if (!list_empty(&f.file->f_ep_links) ||
++				ep->gen == loop_check_gen ||
+ 						is_file_epoll(tf.file)) {
+ 			mutex_unlock(&ep->mtx);
+ 			error = epoll_mutex_lock(&epmutex, 0, nonblock);
+ 			if (error)
+ 				goto error_tgt_fput;
++			loop_check_gen++;
+ 			full_check = 1;
+ 			if (is_file_epoll(tf.file)) {
+ 				error = -ELOOP;
+@@ -2263,6 +2252,7 @@ int do_epoll_ctl(int epfd, int op, int fd, struct epoll_event *epds,
+ error_tgt_fput:
+ 	if (full_check) {
+ 		clear_tfile_check_list();
++		loop_check_gen++;
+ 		mutex_unlock(&epmutex);
+ 	}
+ 
+diff --git a/fs/fuse/file.c b/fs/fuse/file.c
+index 83d917f7e5425..98e170cc0b932 100644
+--- a/fs/fuse/file.c
++++ b/fs/fuse/file.c
+@@ -3091,11 +3091,10 @@ fuse_direct_IO(struct kiocb *iocb, struct iov_iter *iter)
+ 	ssize_t ret = 0;
+ 	struct file *file = iocb->ki_filp;
+ 	struct fuse_file *ff = file->private_data;
+-	bool async_dio = ff->fc->async_dio;
+ 	loff_t pos = 0;
+ 	struct inode *inode;
+ 	loff_t i_size;
+-	size_t count = iov_iter_count(iter);
++	size_t count = iov_iter_count(iter), shortened = 0;
+ 	loff_t offset = iocb->ki_pos;
+ 	struct fuse_io_priv *io;
+ 
+@@ -3103,17 +3102,9 @@ fuse_direct_IO(struct kiocb *iocb, struct iov_iter *iter)
+ 	inode = file->f_mapping->host;
+ 	i_size = i_size_read(inode);
+ 
+-	if ((iov_iter_rw(iter) == READ) && (offset > i_size))
++	if ((iov_iter_rw(iter) == READ) && (offset >= i_size))
+ 		return 0;
+ 
+-	/* optimization for short read */
+-	if (async_dio && iov_iter_rw(iter) != WRITE && offset + count > i_size) {
+-		if (offset >= i_size)
+-			return 0;
+-		iov_iter_truncate(iter, fuse_round_up(ff->fc, i_size - offset));
+-		count = iov_iter_count(iter);
+-	}
+-
+ 	io = kmalloc(sizeof(struct fuse_io_priv), GFP_KERNEL);
+ 	if (!io)
+ 		return -ENOMEM;
+@@ -3129,15 +3120,22 @@ fuse_direct_IO(struct kiocb *iocb, struct iov_iter *iter)
+ 	 * By default, we want to optimize all I/Os with async request
+ 	 * submission to the client filesystem if supported.
+ 	 */
+-	io->async = async_dio;
++	io->async = ff->fc->async_dio;
+ 	io->iocb = iocb;
+ 	io->blocking = is_sync_kiocb(iocb);
+ 
++	/* optimization for short read */
++	if (io->async && !io->write && offset + count > i_size) {
++		iov_iter_truncate(iter, fuse_round_up(ff->fc, i_size - offset));
++		shortened = count - iov_iter_count(iter);
++		count -= shortened;
++	}
++
+ 	/*
+ 	 * We cannot asynchronously extend the size of a file.
+ 	 * In such case the aio will behave exactly like sync io.
+ 	 */
+-	if ((offset + count > i_size) && iov_iter_rw(iter) == WRITE)
++	if ((offset + count > i_size) && io->write)
+ 		io->blocking = true;
+ 
+ 	if (io->async && io->blocking) {
+@@ -3155,6 +3153,7 @@ fuse_direct_IO(struct kiocb *iocb, struct iov_iter *iter)
+ 	} else {
+ 		ret = __fuse_direct_read(io, iter, &pos);
+ 	}
++	iov_iter_reexpand(iter, iov_iter_count(iter) + shortened);
+ 
+ 	if (io->async) {
+ 		bool blocking = io->blocking;
+diff --git a/fs/io_uring.c b/fs/io_uring.c
+index 1d5640cc2a488..ebc3586b18795 100644
+--- a/fs/io_uring.c
++++ b/fs/io_uring.c
+@@ -3318,7 +3318,7 @@ static int io_epoll_ctl_prep(struct io_kiocb *req,
+ #if defined(CONFIG_EPOLL)
+ 	if (sqe->ioprio || sqe->buf_index)
+ 		return -EINVAL;
+-	if (unlikely(req->ctx->flags & IORING_SETUP_IOPOLL))
++	if (unlikely(req->ctx->flags & (IORING_SETUP_IOPOLL | IORING_SETUP_SQPOLL)))
+ 		return -EINVAL;
+ 
+ 	req->epoll.epfd = READ_ONCE(sqe->fd);
+@@ -3435,7 +3435,7 @@ static int io_fadvise(struct io_kiocb *req, bool force_nonblock)
+ 
+ static int io_statx_prep(struct io_kiocb *req, const struct io_uring_sqe *sqe)
+ {
+-	if (unlikely(req->ctx->flags & IORING_SETUP_IOPOLL))
++	if (unlikely(req->ctx->flags & (IORING_SETUP_IOPOLL | IORING_SETUP_SQPOLL)))
+ 		return -EINVAL;
+ 	if (sqe->ioprio || sqe->buf_index)
+ 		return -EINVAL;
+@@ -4310,6 +4310,8 @@ static int io_poll_double_wake(struct wait_queue_entry *wait, unsigned mode,
+ 	if (mask && !(mask & poll->events))
+ 		return 0;
+ 
++	list_del_init(&wait->entry);
++
+ 	if (poll && poll->head) {
+ 		bool done;
+ 
+@@ -5040,6 +5042,8 @@ static int io_async_cancel(struct io_kiocb *req)
+ static int io_files_update_prep(struct io_kiocb *req,
+ 				const struct io_uring_sqe *sqe)
+ {
++	if (unlikely(req->ctx->flags & IORING_SETUP_SQPOLL))
++		return -EINVAL;
+ 	if (unlikely(req->flags & (REQ_F_FIXED_FILE | REQ_F_BUFFER_SELECT)))
+ 		return -EINVAL;
+ 	if (sqe->ioprio || sqe->rw_flags)
+diff --git a/fs/nfs/dir.c b/fs/nfs/dir.c
+index 5a331da5f55ad..785f46217f11a 100644
+--- a/fs/nfs/dir.c
++++ b/fs/nfs/dir.c
+@@ -579,6 +579,9 @@ int nfs_readdir_page_filler(nfs_readdir_descriptor_t *desc, struct nfs_entry *en
+ 	xdr_set_scratch_buffer(&stream, page_address(scratch), PAGE_SIZE);
+ 
+ 	do {
++		if (entry->label)
++			entry->label->len = NFS4_MAXLABELLEN;
++
+ 		status = xdr_decode(desc, entry, &stream);
+ 		if (status != 0) {
+ 			if (status == -EAGAIN)
+diff --git a/fs/nfs/flexfilelayout/flexfilelayout.c b/fs/nfs/flexfilelayout/flexfilelayout.c
+index 048272d60a165..f9348ed1bcdad 100644
+--- a/fs/nfs/flexfilelayout/flexfilelayout.c
++++ b/fs/nfs/flexfilelayout/flexfilelayout.c
+@@ -838,6 +838,7 @@ ff_layout_pg_init_read(struct nfs_pageio_descriptor *pgio,
+ 	struct nfs4_ff_layout_mirror *mirror;
+ 	struct nfs4_pnfs_ds *ds;
+ 	int ds_idx;
++	u32 i;
+ 
+ retry:
+ 	ff_layout_pg_check_layout(pgio, req);
+@@ -864,14 +865,14 @@ retry:
+ 		goto retry;
+ 	}
+ 
+-	mirror = FF_LAYOUT_COMP(pgio->pg_lseg, ds_idx);
++	for (i = 0; i < pgio->pg_mirror_count; i++) {
++		mirror = FF_LAYOUT_COMP(pgio->pg_lseg, i);
++		pgm = &pgio->pg_mirrors[i];
++		pgm->pg_bsize = mirror->mirror_ds->ds_versions[0].rsize;
++	}
+ 
+ 	pgio->pg_mirror_idx = ds_idx;
+ 
+-	/* read always uses only one mirror - idx 0 for pgio layer */
+-	pgm = &pgio->pg_mirrors[0];
+-	pgm->pg_bsize = mirror->mirror_ds->ds_versions[0].rsize;
+-
+ 	if (NFS_SERVER(pgio->pg_inode)->flags &
+ 			(NFS_MOUNT_SOFT|NFS_MOUNT_SOFTERR))
+ 		pgio->pg_maxretrans = io_maxretrans;
+diff --git a/fs/nfs/nfs42proc.c b/fs/nfs/nfs42proc.c
+index e2ae54b35dfe1..395a468e349b0 100644
+--- a/fs/nfs/nfs42proc.c
++++ b/fs/nfs/nfs42proc.c
+@@ -355,7 +355,15 @@ static ssize_t _nfs42_proc_copy(struct file *src,
+ 
+ 	truncate_pagecache_range(dst_inode, pos_dst,
+ 				 pos_dst + res->write_res.count);
+-
++	spin_lock(&dst_inode->i_lock);
++	NFS_I(dst_inode)->cache_validity |= (NFS_INO_REVAL_PAGECACHE |
++			NFS_INO_REVAL_FORCED | NFS_INO_INVALID_SIZE |
++			NFS_INO_INVALID_ATTR | NFS_INO_INVALID_DATA);
++	spin_unlock(&dst_inode->i_lock);
++	spin_lock(&src_inode->i_lock);
++	NFS_I(src_inode)->cache_validity |= (NFS_INO_REVAL_PAGECACHE |
++			NFS_INO_REVAL_FORCED | NFS_INO_INVALID_ATIME);
++	spin_unlock(&src_inode->i_lock);
+ 	status = res->write_res.count;
+ out:
+ 	if (args->sync)
+diff --git a/fs/pipe.c b/fs/pipe.c
+index 60dbee4571436..117db82b10af5 100644
+--- a/fs/pipe.c
++++ b/fs/pipe.c
+@@ -106,25 +106,6 @@ void pipe_double_lock(struct pipe_inode_info *pipe1,
+ 	}
+ }
+ 
+-/* Drop the inode semaphore and wait for a pipe event, atomically */
+-void pipe_wait(struct pipe_inode_info *pipe)
+-{
+-	DEFINE_WAIT(rdwait);
+-	DEFINE_WAIT(wrwait);
+-
+-	/*
+-	 * Pipes are system-local resources, so sleeping on them
+-	 * is considered a noninteractive wait:
+-	 */
+-	prepare_to_wait(&pipe->rd_wait, &rdwait, TASK_INTERRUPTIBLE);
+-	prepare_to_wait(&pipe->wr_wait, &wrwait, TASK_INTERRUPTIBLE);
+-	pipe_unlock(pipe);
+-	schedule();
+-	finish_wait(&pipe->rd_wait, &rdwait);
+-	finish_wait(&pipe->wr_wait, &wrwait);
+-	pipe_lock(pipe);
+-}
+-
+ static void anon_pipe_buf_release(struct pipe_inode_info *pipe,
+ 				  struct pipe_buffer *buf)
+ {
+@@ -1035,12 +1016,52 @@ SYSCALL_DEFINE1(pipe, int __user *, fildes)
+ 	return do_pipe2(fildes, 0);
+ }
+ 
++/*
++ * This is the stupid "wait for pipe to be readable or writable"
++ * model.
++ *
++ * See pipe_read/write() for the proper kind of exclusive wait,
++ * but that requires that we wake up any other readers/writers
++ * if we then do not end up reading everything (ie the whole
++ * "wake_next_reader/writer" logic in pipe_read/write()).
++ */
++void pipe_wait_readable(struct pipe_inode_info *pipe)
++{
++	pipe_unlock(pipe);
++	wait_event_interruptible(pipe->rd_wait, pipe_readable(pipe));
++	pipe_lock(pipe);
++}
++
++void pipe_wait_writable(struct pipe_inode_info *pipe)
++{
++	pipe_unlock(pipe);
++	wait_event_interruptible(pipe->wr_wait, pipe_writable(pipe));
++	pipe_lock(pipe);
++}
++
++/*
++ * This depends on both the wait (here) and the wakeup (wake_up_partner)
++ * holding the pipe lock, so "*cnt" is stable and we know a wakeup cannot
++ * race with the count check and waitqueue prep.
++ *
++ * Normally in order to avoid races, you'd do the prepare_to_wait() first,
++ * then check the condition you're waiting for, and only then sleep. But
++ * because of the pipe lock, we can check the condition before being on
++ * the wait queue.
++ *
++ * We use the 'rd_wait' waitqueue for pipe partner waiting.
++ */
+ static int wait_for_partner(struct pipe_inode_info *pipe, unsigned int *cnt)
+ {
++	DEFINE_WAIT(rdwait);
+ 	int cur = *cnt;
+ 
+ 	while (cur == *cnt) {
+-		pipe_wait(pipe);
++		prepare_to_wait(&pipe->rd_wait, &rdwait, TASK_INTERRUPTIBLE);
++		pipe_unlock(pipe);
++		schedule();
++		finish_wait(&pipe->rd_wait, &rdwait);
++		pipe_lock(pipe);
+ 		if (signal_pending(current))
+ 			break;
+ 	}
+@@ -1050,7 +1071,6 @@ static int wait_for_partner(struct pipe_inode_info *pipe, unsigned int *cnt)
+ static void wake_up_partner(struct pipe_inode_info *pipe)
+ {
+ 	wake_up_interruptible_all(&pipe->rd_wait);
+-	wake_up_interruptible_all(&pipe->wr_wait);
+ }
+ 
+ static int fifo_open(struct inode *inode, struct file *filp)
+diff --git a/fs/read_write.c b/fs/read_write.c
+index 4fb797822567a..9a5cb9c2f0d46 100644
+--- a/fs/read_write.c
++++ b/fs/read_write.c
+@@ -538,6 +538,14 @@ ssize_t __kernel_write(struct file *file, const void *buf, size_t count, loff_t
+ 	inc_syscw(current);
+ 	return ret;
+ }
++/*
++ * This "EXPORT_SYMBOL_GPL()" is more of a "EXPORT_SYMBOL_DONTUSE()",
++ * but autofs is one of the few internal kernel users that actually
++ * wants this _and_ can be built as a module. So we need to export
++ * this symbol for autofs, even though it really isn't appropriate
++ * for any other kernel modules.
++ */
++EXPORT_SYMBOL_GPL(__kernel_write);
+ 
+ ssize_t kernel_write(struct file *file, const void *buf, size_t count,
+ 			    loff_t *pos)
+diff --git a/fs/splice.c b/fs/splice.c
+index d7c8a7c4db07f..c3d00dfc73446 100644
+--- a/fs/splice.c
++++ b/fs/splice.c
+@@ -563,7 +563,7 @@ static int splice_from_pipe_next(struct pipe_inode_info *pipe, struct splice_des
+ 			sd->need_wakeup = false;
+ 		}
+ 
+-		pipe_wait(pipe);
++		pipe_wait_readable(pipe);
+ 	}
+ 
+ 	return 1;
+@@ -1077,7 +1077,7 @@ static int wait_for_space(struct pipe_inode_info *pipe, unsigned flags)
+ 			return -EAGAIN;
+ 		if (signal_pending(current))
+ 			return -ERESTARTSYS;
+-		pipe_wait(pipe);
++		pipe_wait_writable(pipe);
+ 	}
+ }
+ 
+@@ -1454,7 +1454,7 @@ static int ipipe_prep(struct pipe_inode_info *pipe, unsigned int flags)
+ 			ret = -EAGAIN;
+ 			break;
+ 		}
+-		pipe_wait(pipe);
++		pipe_wait_readable(pipe);
+ 	}
+ 
+ 	pipe_unlock(pipe);
+@@ -1493,7 +1493,7 @@ static int opipe_prep(struct pipe_inode_info *pipe, unsigned int flags)
+ 			ret = -ERESTARTSYS;
+ 			break;
+ 		}
+-		pipe_wait(pipe);
++		pipe_wait_writable(pipe);
+ 	}
+ 
+ 	pipe_unlock(pipe);
+diff --git a/fs/vboxsf/super.c b/fs/vboxsf/super.c
+index 8fe03b4a0d2b0..25aade3441922 100644
+--- a/fs/vboxsf/super.c
++++ b/fs/vboxsf/super.c
+@@ -384,7 +384,7 @@ fail_nomem:
+ 
+ static int vboxsf_parse_monolithic(struct fs_context *fc, void *data)
+ {
+-	char *options = data;
++	unsigned char *options = data;
+ 
+ 	if (options && options[0] == VBSF_MOUNT_SIGNATURE_BYTE_0 &&
+ 		       options[1] == VBSF_MOUNT_SIGNATURE_BYTE_1 &&
+diff --git a/include/linux/blkdev.h b/include/linux/blkdev.h
+index 57241417ff2f8..1af8c9ac50a4b 100644
+--- a/include/linux/blkdev.h
++++ b/include/linux/blkdev.h
+@@ -354,6 +354,8 @@ struct queue_limits {
+ typedef int (*report_zones_cb)(struct blk_zone *zone, unsigned int idx,
+ 			       void *data);
+ 
++void blk_queue_set_zoned(struct gendisk *disk, enum blk_zoned_model model);
++
+ #ifdef CONFIG_BLK_DEV_ZONED
+ 
+ #define BLK_ALL_ZONES  ((unsigned int)-1)
+diff --git a/include/linux/memstick.h b/include/linux/memstick.h
+index da4c65f9435ff..ebf73d4ee9690 100644
+--- a/include/linux/memstick.h
++++ b/include/linux/memstick.h
+@@ -281,6 +281,7 @@ struct memstick_host {
+ 
+ 	struct memstick_dev *card;
+ 	unsigned int        retries;
++	bool removing;
+ 
+ 	/* Notify the host that some requests are pending. */
+ 	void                (*request)(struct memstick_host *host);
+diff --git a/include/linux/pipe_fs_i.h b/include/linux/pipe_fs_i.h
+index 50afd0d0084ca..5d2705f1d01c3 100644
+--- a/include/linux/pipe_fs_i.h
++++ b/include/linux/pipe_fs_i.h
+@@ -240,8 +240,9 @@ extern unsigned int pipe_max_size;
+ extern unsigned long pipe_user_pages_hard;
+ extern unsigned long pipe_user_pages_soft;
+ 
+-/* Drop the inode semaphore and wait for a pipe event, atomically */
+-void pipe_wait(struct pipe_inode_info *pipe);
++/* Wait for a pipe to be readable/writable while dropping the pipe lock */
++void pipe_wait_readable(struct pipe_inode_info *);
++void pipe_wait_writable(struct pipe_inode_info *);
+ 
+ struct pipe_inode_info *alloc_pipe_info(void);
+ void free_pipe_info(struct pipe_inode_info *);
+diff --git a/kernel/trace/ftrace.c b/kernel/trace/ftrace.c
+index b5cb5be3ca6f6..b3d0d266fb737 100644
+--- a/kernel/trace/ftrace.c
++++ b/kernel/trace/ftrace.c
+@@ -6877,16 +6877,14 @@ static void ftrace_ops_assist_func(unsigned long ip, unsigned long parent_ip,
+ {
+ 	int bit;
+ 
+-	if ((op->flags & FTRACE_OPS_FL_RCU) && !rcu_is_watching())
+-		return;
+-
+ 	bit = trace_test_and_set_recursion(TRACE_LIST_START, TRACE_LIST_MAX);
+ 	if (bit < 0)
+ 		return;
+ 
+ 	preempt_disable_notrace();
+ 
+-	op->func(ip, parent_ip, op, regs);
++	if (!(op->flags & FTRACE_OPS_FL_RCU) || rcu_is_watching())
++		op->func(ip, parent_ip, op, regs);
+ 
+ 	preempt_enable_notrace();
+ 	trace_clear_recursion(bit);
+diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c
+index 6fc6da55b94e2..68c0ff4bd02fa 100644
+--- a/kernel/trace/trace.c
++++ b/kernel/trace/trace.c
+@@ -3507,13 +3507,15 @@ struct trace_entry *trace_find_next_entry(struct trace_iterator *iter,
+ 	if (iter->ent && iter->ent != iter->temp) {
+ 		if ((!iter->temp || iter->temp_size < iter->ent_size) &&
+ 		    !WARN_ON_ONCE(iter->temp == static_temp_buf)) {
+-			kfree(iter->temp);
+-			iter->temp = kmalloc(iter->ent_size, GFP_KERNEL);
+-			if (!iter->temp)
++			void *temp;
++			temp = kmalloc(iter->ent_size, GFP_KERNEL);
++			if (!temp)
+ 				return NULL;
++			kfree(iter->temp);
++			iter->temp = temp;
++			iter->temp_size = iter->ent_size;
+ 		}
+ 		memcpy(iter->temp, iter->ent, iter->ent_size);
+-		iter->temp_size = iter->ent_size;
+ 		iter->ent = iter->temp;
+ 	}
+ 	entry = __find_next_entry(iter, ent_cpu, NULL, ent_ts);
+@@ -3743,14 +3745,14 @@ unsigned long trace_total_entries(struct trace_array *tr)
+ 
+ static void print_lat_help_header(struct seq_file *m)
+ {
+-	seq_puts(m, "#                  _------=> CPU#            \n"
+-		    "#                 / _-----=> irqs-off        \n"
+-		    "#                | / _----=> need-resched    \n"
+-		    "#                || / _---=> hardirq/softirq \n"
+-		    "#                ||| / _--=> preempt-depth   \n"
+-		    "#                |||| /     delay            \n"
+-		    "#  cmd     pid   ||||| time  |   caller      \n"
+-		    "#     \\   /      |||||  \\    |   /         \n");
++	seq_puts(m, "#                    _------=> CPU#            \n"
++		    "#                   / _-----=> irqs-off        \n"
++		    "#                  | / _----=> need-resched    \n"
++		    "#                  || / _---=> hardirq/softirq \n"
++		    "#                  ||| / _--=> preempt-depth   \n"
++		    "#                  |||| /     delay            \n"
++		    "#  cmd     pid     ||||| time  |   caller      \n"
++		    "#     \\   /        |||||  \\    |   /         \n");
+ }
+ 
+ static void print_event_info(struct array_buffer *buf, struct seq_file *m)
+@@ -3771,26 +3773,26 @@ static void print_func_help_header(struct array_buffer *buf, struct seq_file *m,
+ 
+ 	print_event_info(buf, m);
+ 
+-	seq_printf(m, "#           TASK-PID   %s  CPU#   TIMESTAMP  FUNCTION\n", tgid ? "TGID     " : "");
+-	seq_printf(m, "#              | |     %s    |       |         |\n",	 tgid ? "  |      " : "");
++	seq_printf(m, "#           TASK-PID    %s CPU#     TIMESTAMP  FUNCTION\n", tgid ? "   TGID   " : "");
++	seq_printf(m, "#              | |      %s   |         |         |\n",      tgid ? "     |    " : "");
+ }
+ 
+ static void print_func_help_header_irq(struct array_buffer *buf, struct seq_file *m,
+ 				       unsigned int flags)
+ {
+ 	bool tgid = flags & TRACE_ITER_RECORD_TGID;
+-	const char *space = "          ";
+-	int prec = tgid ? 10 : 2;
++	const char *space = "            ";
++	int prec = tgid ? 12 : 2;
+ 
+ 	print_event_info(buf, m);
+ 
+-	seq_printf(m, "#                          %.*s  _-----=> irqs-off\n", prec, space);
+-	seq_printf(m, "#                          %.*s / _----=> need-resched\n", prec, space);
+-	seq_printf(m, "#                          %.*s| / _---=> hardirq/softirq\n", prec, space);
+-	seq_printf(m, "#                          %.*s|| / _--=> preempt-depth\n", prec, space);
+-	seq_printf(m, "#                          %.*s||| /     delay\n", prec, space);
+-	seq_printf(m, "#           TASK-PID %.*sCPU#  ||||    TIMESTAMP  FUNCTION\n", prec, "   TGID   ");
+-	seq_printf(m, "#              | |   %.*s  |   ||||       |         |\n", prec, "     |    ");
++	seq_printf(m, "#                            %.*s  _-----=> irqs-off\n", prec, space);
++	seq_printf(m, "#                            %.*s / _----=> need-resched\n", prec, space);
++	seq_printf(m, "#                            %.*s| / _---=> hardirq/softirq\n", prec, space);
++	seq_printf(m, "#                            %.*s|| / _--=> preempt-depth\n", prec, space);
++	seq_printf(m, "#                            %.*s||| /     delay\n", prec, space);
++	seq_printf(m, "#           TASK-PID  %.*s CPU#  ||||   TIMESTAMP  FUNCTION\n", prec, "     TGID   ");
++	seq_printf(m, "#              | |    %.*s   |   ||||      |         |\n", prec, "       |    ");
+ }
+ 
+ void
+diff --git a/kernel/trace/trace_output.c b/kernel/trace/trace_output.c
+index 73976de7f8cc8..a8d719263e1bc 100644
+--- a/kernel/trace/trace_output.c
++++ b/kernel/trace/trace_output.c
+@@ -497,7 +497,7 @@ lat_print_generic(struct trace_seq *s, struct trace_entry *entry, int cpu)
+ 
+ 	trace_find_cmdline(entry->pid, comm);
+ 
+-	trace_seq_printf(s, "%8.8s-%-5d %3d",
++	trace_seq_printf(s, "%8.8s-%-7d %3d",
+ 			 comm, entry->pid, cpu);
+ 
+ 	return trace_print_lat_fmt(s, entry);
+@@ -588,15 +588,15 @@ int trace_print_context(struct trace_iterator *iter)
+ 
+ 	trace_find_cmdline(entry->pid, comm);
+ 
+-	trace_seq_printf(s, "%16s-%-5d ", comm, entry->pid);
++	trace_seq_printf(s, "%16s-%-7d ", comm, entry->pid);
+ 
+ 	if (tr->trace_flags & TRACE_ITER_RECORD_TGID) {
+ 		unsigned int tgid = trace_find_tgid(entry->pid);
+ 
+ 		if (!tgid)
+-			trace_seq_printf(s, "(-----) ");
++			trace_seq_printf(s, "(-------) ");
+ 		else
+-			trace_seq_printf(s, "(%5d) ", tgid);
++			trace_seq_printf(s, "(%7d) ", tgid);
+ 	}
+ 
+ 	trace_seq_printf(s, "[%03d] ", iter->cpu);
+@@ -636,7 +636,7 @@ int trace_print_lat_context(struct trace_iterator *iter)
+ 		trace_find_cmdline(entry->pid, comm);
+ 
+ 		trace_seq_printf(
+-			s, "%16s %5d %3d %d %08x %08lx ",
++			s, "%16s %7d %3d %d %08x %08lx ",
+ 			comm, entry->pid, iter->cpu, entry->flags,
+ 			entry->preempt_count, iter->idx);
+ 	} else {
+@@ -917,7 +917,7 @@ static enum print_line_t trace_ctxwake_print(struct trace_iterator *iter,
+ 	S = task_index_to_char(field->prev_state);
+ 	trace_find_cmdline(field->next_pid, comm);
+ 	trace_seq_printf(&iter->seq,
+-			 " %5d:%3d:%c %s [%03d] %5d:%3d:%c %s\n",
++			 " %7d:%3d:%c %s [%03d] %7d:%3d:%c %s\n",
+ 			 field->prev_pid,
+ 			 field->prev_prio,
+ 			 S, delim,
+diff --git a/lib/random32.c b/lib/random32.c
+index 3d749abb9e80d..1786f78bf4c53 100644
+--- a/lib/random32.c
++++ b/lib/random32.c
+@@ -48,7 +48,7 @@ static inline void prandom_state_selftest(void)
+ }
+ #endif
+ 
+-DEFINE_PER_CPU(struct rnd_state, net_rand_state);
++DEFINE_PER_CPU(struct rnd_state, net_rand_state)  __latent_entropy;
+ 
+ /**
+  *	prandom_u32_state - seeded pseudo-random number generator.
+diff --git a/net/mac80211/rx.c b/net/mac80211/rx.c
+index 5c5af4b5fc080..f2c3ac648fc08 100644
+--- a/net/mac80211/rx.c
++++ b/net/mac80211/rx.c
+@@ -451,7 +451,8 @@ ieee80211_add_rx_radiotap_header(struct ieee80211_local *local,
+ 	else if (status->bw == RATE_INFO_BW_5)
+ 		channel_flags |= IEEE80211_CHAN_QUARTER;
+ 
+-	if (status->band == NL80211_BAND_5GHZ)
++	if (status->band == NL80211_BAND_5GHZ ||
++	    status->band == NL80211_BAND_6GHZ)
+ 		channel_flags |= IEEE80211_CHAN_OFDM | IEEE80211_CHAN_5GHZ;
+ 	else if (status->encoding != RX_ENC_LEGACY)
+ 		channel_flags |= IEEE80211_CHAN_DYN | IEEE80211_CHAN_2GHZ;
+diff --git a/net/mac80211/vht.c b/net/mac80211/vht.c
+index 9c6045f9c24da..d1b64d0751f2e 100644
+--- a/net/mac80211/vht.c
++++ b/net/mac80211/vht.c
+@@ -168,10 +168,7 @@ ieee80211_vht_cap_ie_to_sta_vht_cap(struct ieee80211_sub_if_data *sdata,
+ 	/* take some capabilities as-is */
+ 	cap_info = le32_to_cpu(vht_cap_ie->vht_cap_info);
+ 	vht_cap->cap = cap_info;
+-	vht_cap->cap &= IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_3895 |
+-			IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_7991 |
+-			IEEE80211_VHT_CAP_MAX_MPDU_LENGTH_11454 |
+-			IEEE80211_VHT_CAP_RXLDPC |
++	vht_cap->cap &= IEEE80211_VHT_CAP_RXLDPC |
+ 			IEEE80211_VHT_CAP_VHT_TXOP_PS |
+ 			IEEE80211_VHT_CAP_HTC_VHT |
+ 			IEEE80211_VHT_CAP_MAX_A_MPDU_LENGTH_EXPONENT_MASK |
+@@ -180,6 +177,9 @@ ieee80211_vht_cap_ie_to_sta_vht_cap(struct ieee80211_sub_if_data *sdata,
+ 			IEEE80211_VHT_CAP_RX_ANTENNA_PATTERN |
+ 			IEEE80211_VHT_CAP_TX_ANTENNA_PATTERN;
+ 
++	vht_cap->cap |= min_t(u32, cap_info & IEEE80211_VHT_CAP_MAX_MPDU_MASK,
++			      own_cap.cap & IEEE80211_VHT_CAP_MAX_MPDU_MASK);
++
+ 	/* and some based on our own capabilities */
+ 	switch (own_cap.cap & IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_MASK) {
+ 	case IEEE80211_VHT_CAP_SUPP_CHAN_WIDTH_160MHZ:
+diff --git a/scripts/dtc/Makefile b/scripts/dtc/Makefile
+index 0b44917f981c7..d4129e0275e4a 100644
+--- a/scripts/dtc/Makefile
++++ b/scripts/dtc/Makefile
+@@ -10,7 +10,7 @@ dtc-objs	:= dtc.o flattree.o fstree.o data.o livetree.o treesource.o \
+ dtc-objs	+= dtc-lexer.lex.o dtc-parser.tab.o
+ 
+ # Source files need to get at the userspace version of libfdt_env.h to compile
+-HOST_EXTRACFLAGS := -I $(srctree)/$(src)/libfdt
++HOST_EXTRACFLAGS += -I $(srctree)/$(src)/libfdt
+ 
+ ifeq ($(shell pkg-config --exists yaml-0.1 2>/dev/null && echo yes),)
+ ifneq ($(CHECK_DT_BINDING)$(CHECK_DTBS),)
+diff --git a/scripts/kallsyms.c b/scripts/kallsyms.c
+index 6dc3078649fa0..e8b26050f5458 100644
+--- a/scripts/kallsyms.c
++++ b/scripts/kallsyms.c
+@@ -82,6 +82,7 @@ static char *sym_name(const struct sym_entry *s)
+ 
+ static bool is_ignored_symbol(const char *name, char type)
+ {
++	/* Symbol names that exactly match to the following are ignored.*/
+ 	static const char * const ignored_symbols[] = {
+ 		/*
+ 		 * Symbols which vary between passes. Passes 1 and 2 must have
+@@ -104,6 +105,7 @@ static bool is_ignored_symbol(const char *name, char type)
+ 		NULL
+ 	};
+ 
++	/* Symbol names that begin with the following are ignored.*/
+ 	static const char * const ignored_prefixes[] = {
+ 		"$",			/* local symbols for ARM, MIPS, etc. */
+ 		".LASANPC",		/* s390 kasan local symbols */
+@@ -112,6 +114,7 @@ static bool is_ignored_symbol(const char *name, char type)
+ 		NULL
+ 	};
+ 
++	/* Symbol names that end with the following are ignored.*/
+ 	static const char * const ignored_suffixes[] = {
+ 		"_from_arm",		/* arm */
+ 		"_from_thumb",		/* arm */
+@@ -119,9 +122,15 @@ static bool is_ignored_symbol(const char *name, char type)
+ 		NULL
+ 	};
+ 
++	/* Symbol names that contain the following are ignored.*/
++	static const char * const ignored_matches[] = {
++		".long_branch.",	/* ppc stub */
++		".plt_branch.",		/* ppc stub */
++		NULL
++	};
++
+ 	const char * const *p;
+ 
+-	/* Exclude symbols which vary between passes. */
+ 	for (p = ignored_symbols; *p; p++)
+ 		if (!strcmp(name, *p))
+ 			return true;
+@@ -137,6 +146,11 @@ static bool is_ignored_symbol(const char *name, char type)
+ 			return true;
+ 	}
+ 
++	for (p = ignored_matches; *p; p++) {
++		if (strstr(name, *p))
++			return true;
++	}
++
+ 	if (type == 'U' || type == 'u')
+ 		return true;
+ 	/* exclude debugging symbols */
+diff --git a/tools/io_uring/io_uring-bench.c b/tools/io_uring/io_uring-bench.c
+index 0f257139b003e..7703f01183854 100644
+--- a/tools/io_uring/io_uring-bench.c
++++ b/tools/io_uring/io_uring-bench.c
+@@ -130,7 +130,7 @@ static int io_uring_register_files(struct submitter *s)
+ 					s->nr_files);
+ }
+ 
+-static int gettid(void)
++static int lk_gettid(void)
+ {
+ 	return syscall(__NR_gettid);
+ }
+@@ -281,7 +281,7 @@ static void *submitter_fn(void *data)
+ 	struct io_sq_ring *ring = &s->sq_ring;
+ 	int ret, prepped;
+ 
+-	printf("submitter=%d\n", gettid());
++	printf("submitter=%d\n", lk_gettid());
+ 
+ 	srand48_r(pthread_self(), &s->rand);
+ 
+diff --git a/tools/lib/bpf/Makefile b/tools/lib/bpf/Makefile
+index c820b0be9d637..9ae8f4ef0aac2 100644
+--- a/tools/lib/bpf/Makefile
++++ b/tools/lib/bpf/Makefile
+@@ -59,7 +59,7 @@ FEATURE_USER = .libbpf
+ FEATURE_TESTS = libelf libelf-mmap zlib bpf reallocarray
+ FEATURE_DISPLAY = libelf zlib bpf
+ 
+-INCLUDES = -I. -I$(srctree)/tools/include -I$(srctree)/tools/arch/$(ARCH)/include/uapi -I$(srctree)/tools/include/uapi
++INCLUDES = -I. -I$(srctree)/tools/include -I$(srctree)/tools/include/uapi
+ FEATURE_CHECK_CFLAGS-bpf = $(INCLUDES)
+ 
+ check_feat := 1