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

[Mike Pagano]

commit:     f0692fef2ebc8ccdee5117b2b793b72a24c01158
Author:     Mike Pagano <mpagano <AT> gentoo <DOT> org>
AuthorDate: Thu Sep 17 14:55:20 2020 +0000
Commit:     Mike Pagano <mpagano <AT> gentoo <DOT> org>
CommitDate: Thu Sep 17 14:55:20 2020 +0000
URL:        https://gitweb.gentoo.org/proj/linux-patches.git/commit/?id=f0692fef

Linux patch 4.19.146

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

 0000_README               |    4 +
 1145_linux-4.19.146.patch | 3221 +++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 3225 insertions(+)

diff --git a/0000_README b/0000_README
index 7d78220..4416605 100644
--- a/0000_README
+++ b/0000_README
@@ -619,6 +619,10 @@ Patch:  1144_linux-4.19.145.patch
 From:   https://www.kernel.org
 Desc:   Linux 4.19.145
 
+Patch:  1145_linux-4.19.146.patch
+From:   https://www.kernel.org
+Desc:   Linux 4.19.146
+
 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/1145_linux-4.19.146.patch b/1145_linux-4.19.146.patch
new file mode 100644
index 0000000..6b815f5
--- /dev/null
+++ b/1145_linux-4.19.146.patch
@@ -0,0 +1,3221 @@
+diff --git a/Makefile b/Makefile
+index 6bf851efcabe9..aaeb3f3dbcea8 100644
+--- a/Makefile
++++ b/Makefile
+@@ -1,7 +1,7 @@
+ # SPDX-License-Identifier: GPL-2.0
+ VERSION = 4
+ PATCHLEVEL = 19
+-SUBLEVEL = 145
++SUBLEVEL = 146
+ EXTRAVERSION =
+ NAME = "People's Front"
+ 
+diff --git a/arch/arc/boot/dts/hsdk.dts b/arch/arc/boot/dts/hsdk.dts
+index d131c54acd3ec..f6b6e3c9ca8aa 100644
+--- a/arch/arc/boot/dts/hsdk.dts
++++ b/arch/arc/boot/dts/hsdk.dts
+@@ -83,6 +83,8 @@
+ 
+ 	arcpct: pct {
+ 		compatible = "snps,archs-pct";
++		interrupt-parent = <&cpu_intc>;
++		interrupts = <20>;
+ 	};
+ 
+ 	/* TIMER0 with interrupt for clockevent */
+@@ -173,7 +175,7 @@
+ 			reg = <0x8000 0x2000>;
+ 			interrupts = <10>;
+ 			interrupt-names = "macirq";
+-			phy-mode = "rgmii";
++			phy-mode = "rgmii-id";
+ 			snps,pbl = <32>;
+ 			snps,multicast-filter-bins = <256>;
+ 			clocks = <&gmacclk>;
+@@ -191,7 +193,7 @@
+ 				#address-cells = <1>;
+ 				#size-cells = <0>;
+ 				compatible = "snps,dwmac-mdio";
+-				phy0: ethernet-phy@0 {
++				phy0: ethernet-phy@0 { /* Micrel KSZ9031 */
+ 					reg = <0>;
+ 					ti,rx-internal-delay = <DP83867_RGMIIDCTL_2_00_NS>;
+ 					ti,tx-internal-delay = <DP83867_RGMIIDCTL_2_00_NS>;
+diff --git a/arch/arc/plat-eznps/include/plat/ctop.h b/arch/arc/plat-eznps/include/plat/ctop.h
+index 4f6a1673b3a6e..ddfca2c3357a0 100644
+--- a/arch/arc/plat-eznps/include/plat/ctop.h
++++ b/arch/arc/plat-eznps/include/plat/ctop.h
+@@ -43,7 +43,6 @@
+ #define CTOP_AUX_DPC				(CTOP_AUX_BASE + 0x02C)
+ #define CTOP_AUX_LPC				(CTOP_AUX_BASE + 0x030)
+ #define CTOP_AUX_EFLAGS				(CTOP_AUX_BASE + 0x080)
+-#define CTOP_AUX_IACK				(CTOP_AUX_BASE + 0x088)
+ #define CTOP_AUX_GPA1				(CTOP_AUX_BASE + 0x08C)
+ #define CTOP_AUX_UDMC				(CTOP_AUX_BASE + 0x300)
+ 
+diff --git a/arch/arm/boot/dts/bcm-hr2.dtsi b/arch/arm/boot/dts/bcm-hr2.dtsi
+index e35398cc60a06..dd71ab08136be 100644
+--- a/arch/arm/boot/dts/bcm-hr2.dtsi
++++ b/arch/arm/boot/dts/bcm-hr2.dtsi
+@@ -217,7 +217,7 @@
+ 		};
+ 
+ 		qspi: spi@27200 {
+-			compatible = "brcm,spi-bcm-qspi", "brcm,spi-nsp-qspi";
++			compatible = "brcm,spi-nsp-qspi", "brcm,spi-bcm-qspi";
+ 			reg = <0x027200 0x184>,
+ 			      <0x027000 0x124>,
+ 			      <0x11c408 0x004>,
+diff --git a/arch/arm/boot/dts/bcm-nsp.dtsi b/arch/arm/boot/dts/bcm-nsp.dtsi
+index 273a316045798..b395cb195db21 100644
+--- a/arch/arm/boot/dts/bcm-nsp.dtsi
++++ b/arch/arm/boot/dts/bcm-nsp.dtsi
+@@ -274,7 +274,7 @@
+ 		};
+ 
+ 		qspi: spi@27200 {
+-			compatible = "brcm,spi-bcm-qspi", "brcm,spi-nsp-qspi";
++			compatible = "brcm,spi-nsp-qspi", "brcm,spi-bcm-qspi";
+ 			reg = <0x027200 0x184>,
+ 			      <0x027000 0x124>,
+ 			      <0x11c408 0x004>,
+diff --git a/arch/arm/boot/dts/bcm5301x.dtsi b/arch/arm/boot/dts/bcm5301x.dtsi
+index a678fb7c9e3b2..c91716d5980c3 100644
+--- a/arch/arm/boot/dts/bcm5301x.dtsi
++++ b/arch/arm/boot/dts/bcm5301x.dtsi
+@@ -445,7 +445,7 @@
+ 	};
+ 
+ 	spi@18029200 {
+-		compatible = "brcm,spi-bcm-qspi", "brcm,spi-nsp-qspi";
++		compatible = "brcm,spi-nsp-qspi", "brcm,spi-bcm-qspi";
+ 		reg = <0x18029200 0x184>,
+ 		      <0x18029000 0x124>,
+ 		      <0x1811b408 0x004>,
+diff --git a/arch/arm/boot/dts/logicpd-som-lv-baseboard.dtsi b/arch/arm/boot/dts/logicpd-som-lv-baseboard.dtsi
+index 3e39b9a1f35d0..0093548d50ff8 100644
+--- a/arch/arm/boot/dts/logicpd-som-lv-baseboard.dtsi
++++ b/arch/arm/boot/dts/logicpd-som-lv-baseboard.dtsi
+@@ -55,6 +55,8 @@
+ 
+ &mcbsp2 {
+ 	status = "okay";
++	pinctrl-names = "default";
++	pinctrl-0 = <&mcbsp2_pins>;
+ };
+ 
+ &charger {
+diff --git a/arch/arm/boot/dts/logicpd-torpedo-baseboard.dtsi b/arch/arm/boot/dts/logicpd-torpedo-baseboard.dtsi
+index 86c5644f558cb..032e8dde13817 100644
+--- a/arch/arm/boot/dts/logicpd-torpedo-baseboard.dtsi
++++ b/arch/arm/boot/dts/logicpd-torpedo-baseboard.dtsi
+@@ -84,6 +84,8 @@
+ };
+ 
+ &mcbsp2 {
++	pinctrl-names = "default";
++	pinctrl-0 = <&mcbsp2_pins>;
+ 	status = "okay";
+ };
+ 
+diff --git a/arch/arm/boot/dts/ls1021a.dtsi b/arch/arm/boot/dts/ls1021a.dtsi
+index d18c043264440..b66b2bd1aa856 100644
+--- a/arch/arm/boot/dts/ls1021a.dtsi
++++ b/arch/arm/boot/dts/ls1021a.dtsi
+@@ -168,7 +168,7 @@
+ 			#address-cells = <1>;
+ 			#size-cells = <0>;
+ 			reg = <0x0 0x1550000 0x0 0x10000>,
+-			      <0x0 0x40000000 0x0 0x40000000>;
++			      <0x0 0x40000000 0x0 0x20000000>;
+ 			reg-names = "QuadSPI", "QuadSPI-memory";
+ 			interrupts = <GIC_SPI 131 IRQ_TYPE_LEVEL_HIGH>;
+ 			clock-names = "qspi_en", "qspi";
+diff --git a/arch/arm/boot/dts/socfpga_arria10.dtsi b/arch/arm/boot/dts/socfpga_arria10.dtsi
+index ba5657574d9bb..4b1c8bec2de35 100644
+--- a/arch/arm/boot/dts/socfpga_arria10.dtsi
++++ b/arch/arm/boot/dts/socfpga_arria10.dtsi
+@@ -791,7 +791,7 @@
+ 		timer3: timer3@ffd00100 {
+ 			compatible = "snps,dw-apb-timer";
+ 			interrupts = <0 118 IRQ_TYPE_LEVEL_HIGH>;
+-			reg = <0xffd01000 0x100>;
++			reg = <0xffd00100 0x100>;
+ 			clocks = <&l4_sys_free_clk>;
+ 			clock-names = "timer";
+ 		};
+diff --git a/arch/arm/boot/dts/vfxxx.dtsi b/arch/arm/boot/dts/vfxxx.dtsi
+index d392794d9c139..de81e8b4afde9 100644
+--- a/arch/arm/boot/dts/vfxxx.dtsi
++++ b/arch/arm/boot/dts/vfxxx.dtsi
+@@ -532,7 +532,7 @@
+ 			};
+ 
+ 			ocotp: ocotp@400a5000 {
+-				compatible = "fsl,vf610-ocotp";
++				compatible = "fsl,vf610-ocotp", "syscon";
+ 				reg = <0x400a5000 0x1000>;
+ 				clocks = <&clks VF610_CLK_OCOTP>;
+ 			};
+diff --git a/arch/arm64/boot/dts/broadcom/northstar2/ns2.dtsi b/arch/arm64/boot/dts/broadcom/northstar2/ns2.dtsi
+index ea854f689fda8..6bfb7bbd264af 100644
+--- a/arch/arm64/boot/dts/broadcom/northstar2/ns2.dtsi
++++ b/arch/arm64/boot/dts/broadcom/northstar2/ns2.dtsi
+@@ -745,7 +745,7 @@
+ 		};
+ 
+ 		qspi: spi@66470200 {
+-			compatible = "brcm,spi-bcm-qspi", "brcm,spi-ns2-qspi";
++			compatible = "brcm,spi-ns2-qspi", "brcm,spi-bcm-qspi";
+ 			reg = <0x66470200 0x184>,
+ 				<0x66470000 0x124>,
+ 				<0x67017408 0x004>,
+diff --git a/arch/powerpc/configs/pasemi_defconfig b/arch/powerpc/configs/pasemi_defconfig
+index 4504380c7a922..60839eeada8b7 100644
+--- a/arch/powerpc/configs/pasemi_defconfig
++++ b/arch/powerpc/configs/pasemi_defconfig
+@@ -110,7 +110,6 @@ CONFIG_FB_NVIDIA=y
+ CONFIG_FB_NVIDIA_I2C=y
+ CONFIG_FB_RADEON=y
+ # CONFIG_LCD_CLASS_DEVICE is not set
+-CONFIG_VGACON_SOFT_SCROLLBACK=y
+ CONFIG_LOGO=y
+ CONFIG_SOUND=y
+ CONFIG_SND=y
+diff --git a/arch/powerpc/configs/ppc6xx_defconfig b/arch/powerpc/configs/ppc6xx_defconfig
+index 7032d4244ec5f..e30af76f47537 100644
+--- a/arch/powerpc/configs/ppc6xx_defconfig
++++ b/arch/powerpc/configs/ppc6xx_defconfig
+@@ -779,7 +779,6 @@ CONFIG_FB_TRIDENT=m
+ CONFIG_FB_SM501=m
+ CONFIG_FB_IBM_GXT4500=y
+ CONFIG_LCD_PLATFORM=m
+-CONFIG_VGACON_SOFT_SCROLLBACK=y
+ CONFIG_FRAMEBUFFER_CONSOLE=y
+ CONFIG_FRAMEBUFFER_CONSOLE_ROTATION=y
+ CONFIG_LOGO=y
+diff --git a/arch/x86/configs/i386_defconfig b/arch/x86/configs/i386_defconfig
+index ce75be940567e..5a23a4ccd7556 100644
+--- a/arch/x86/configs/i386_defconfig
++++ b/arch/x86/configs/i386_defconfig
+@@ -216,7 +216,6 @@ CONFIG_FB_MODE_HELPERS=y
+ CONFIG_FB_TILEBLITTING=y
+ CONFIG_FB_EFI=y
+ # CONFIG_LCD_CLASS_DEVICE is not set
+-CONFIG_VGACON_SOFT_SCROLLBACK=y
+ CONFIG_LOGO=y
+ # CONFIG_LOGO_LINUX_MONO is not set
+ # CONFIG_LOGO_LINUX_VGA16 is not set
+diff --git a/arch/x86/configs/x86_64_defconfig b/arch/x86/configs/x86_64_defconfig
+index 45b0f4d84d83b..dc08812929046 100644
+--- a/arch/x86/configs/x86_64_defconfig
++++ b/arch/x86/configs/x86_64_defconfig
+@@ -212,7 +212,6 @@ CONFIG_FB_MODE_HELPERS=y
+ CONFIG_FB_TILEBLITTING=y
+ CONFIG_FB_EFI=y
+ # CONFIG_LCD_CLASS_DEVICE is not set
+-CONFIG_VGACON_SOFT_SCROLLBACK=y
+ CONFIG_LOGO=y
+ # CONFIG_LOGO_LINUX_MONO is not set
+ # CONFIG_LOGO_LINUX_VGA16 is not set
+diff --git a/arch/x86/kvm/vmx.c b/arch/x86/kvm/vmx.c
+index 2f823f35dee50..d6bcbce6c15cb 100644
+--- a/arch/x86/kvm/vmx.c
++++ b/arch/x86/kvm/vmx.c
+@@ -10128,6 +10128,7 @@ static int vmx_handle_exit(struct kvm_vcpu *vcpu)
+ 			(exit_reason != EXIT_REASON_EXCEPTION_NMI &&
+ 			exit_reason != EXIT_REASON_EPT_VIOLATION &&
+ 			exit_reason != EXIT_REASON_PML_FULL &&
++			exit_reason != EXIT_REASON_APIC_ACCESS &&
+ 			exit_reason != EXIT_REASON_TASK_SWITCH)) {
+ 		vcpu->run->exit_reason = KVM_EXIT_INTERNAL_ERROR;
+ 		vcpu->run->internal.suberror = KVM_INTERNAL_ERROR_DELIVERY_EV;
+diff --git a/drivers/atm/firestream.c b/drivers/atm/firestream.c
+index 112b1001c2694..ef395b238816c 100644
+--- a/drivers/atm/firestream.c
++++ b/drivers/atm/firestream.c
+@@ -1013,6 +1013,7 @@ static int fs_open(struct atm_vcc *atm_vcc)
+ 				error = make_rate (pcr, r, &tmc0, NULL);
+ 				if (error) {
+ 					kfree(tc);
++					kfree(vcc);
+ 					return error;
+ 				}
+ 			}
+diff --git a/drivers/block/rbd.c b/drivers/block/rbd.c
+index 1101290971699..9f1265ce2e365 100644
+--- a/drivers/block/rbd.c
++++ b/drivers/block/rbd.c
+@@ -4124,6 +4124,9 @@ static ssize_t rbd_config_info_show(struct device *dev,
+ {
+ 	struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
+ 
++	if (!capable(CAP_SYS_ADMIN))
++		return -EPERM;
++
+ 	return sprintf(buf, "%s\n", rbd_dev->config_info);
+ }
+ 
+@@ -4235,6 +4238,9 @@ static ssize_t rbd_image_refresh(struct device *dev,
+ 	struct rbd_device *rbd_dev = dev_to_rbd_dev(dev);
+ 	int ret;
+ 
++	if (!capable(CAP_SYS_ADMIN))
++		return -EPERM;
++
+ 	ret = rbd_dev_refresh(rbd_dev);
+ 	if (ret)
+ 		return ret;
+@@ -5846,6 +5852,9 @@ static ssize_t do_rbd_add(struct bus_type *bus,
+ 	struct rbd_client *rbdc;
+ 	int rc;
+ 
++	if (!capable(CAP_SYS_ADMIN))
++		return -EPERM;
++
+ 	if (!try_module_get(THIS_MODULE))
+ 		return -ENODEV;
+ 
+@@ -5995,6 +6004,9 @@ static ssize_t do_rbd_remove(struct bus_type *bus,
+ 	bool force = false;
+ 	int ret;
+ 
++	if (!capable(CAP_SYS_ADMIN))
++		return -EPERM;
++
+ 	dev_id = -1;
+ 	opt_buf[0] = '\0';
+ 	sscanf(buf, "%d %5s", &dev_id, opt_buf);
+diff --git a/drivers/cpufreq/intel_pstate.c b/drivers/cpufreq/intel_pstate.c
+index 99166000ffb77..864a7e8ebdfc3 100644
+--- a/drivers/cpufreq/intel_pstate.c
++++ b/drivers/cpufreq/intel_pstate.c
+@@ -712,7 +712,7 @@ static void intel_pstate_get_hwp_max(unsigned int cpu, int *phy_max,
+ 
+ 	rdmsrl_on_cpu(cpu, MSR_HWP_CAPABILITIES, &cap);
+ 	WRITE_ONCE(all_cpu_data[cpu]->hwp_cap_cached, cap);
+-	if (global.no_turbo)
++	if (global.no_turbo || global.turbo_disabled)
+ 		*current_max = HWP_GUARANTEED_PERF(cap);
+ 	else
+ 		*current_max = HWP_HIGHEST_PERF(cap);
+@@ -2325,9 +2325,15 @@ static int intel_pstate_update_status(const char *buf, size_t size)
+ {
+ 	int ret;
+ 
+-	if (size == 3 && !strncmp(buf, "off", size))
+-		return intel_pstate_driver ?
+-			intel_pstate_unregister_driver() : -EINVAL;
++	if (size == 3 && !strncmp(buf, "off", size)) {
++		if (!intel_pstate_driver)
++			return -EINVAL;
++
++		if (hwp_active)
++			return -EBUSY;
++
++		return intel_pstate_unregister_driver();
++	}
+ 
+ 	if (size == 6 && !strncmp(buf, "active", size)) {
+ 		if (intel_pstate_driver) {
+diff --git a/drivers/dma/acpi-dma.c b/drivers/dma/acpi-dma.c
+index 4a748c3435d7d..8d99c84361cbb 100644
+--- a/drivers/dma/acpi-dma.c
++++ b/drivers/dma/acpi-dma.c
+@@ -131,11 +131,13 @@ static void acpi_dma_parse_csrt(struct acpi_device *adev, struct acpi_dma *adma)
+ 		if (ret < 0) {
+ 			dev_warn(&adev->dev,
+ 				 "error in parsing resource group\n");
+-			return;
++			break;
+ 		}
+ 
+ 		grp = (struct acpi_csrt_group *)((void *)grp + grp->length);
+ 	}
++
++	acpi_put_table((struct acpi_table_header *)csrt);
+ }
+ 
+ /**
+diff --git a/drivers/gpu/drm/amd/powerplay/hwmgr/smu7_hwmgr.c b/drivers/gpu/drm/amd/powerplay/hwmgr/smu7_hwmgr.c
+index 219440bebd052..72c0a2ae2dd4f 100644
+--- a/drivers/gpu/drm/amd/powerplay/hwmgr/smu7_hwmgr.c
++++ b/drivers/gpu/drm/amd/powerplay/hwmgr/smu7_hwmgr.c
+@@ -3566,7 +3566,8 @@ static int smu7_read_sensor(struct pp_hwmgr *hwmgr, int idx,
+ 	case AMDGPU_PP_SENSOR_GPU_POWER:
+ 		return smu7_get_gpu_power(hwmgr, (uint32_t *)value);
+ 	case AMDGPU_PP_SENSOR_VDDGFX:
+-		if ((data->vr_config & 0xff) == 0x2)
++		if ((data->vr_config & VRCONF_VDDGFX_MASK) ==
++		    (VR_SVI2_PLANE_2 << VRCONF_VDDGFX_SHIFT))
+ 			val_vid = PHM_READ_INDIRECT_FIELD(hwmgr->device,
+ 					CGS_IND_REG__SMC, PWR_SVI2_STATUS, PLANE2_VID);
+ 		else
+diff --git a/drivers/gpu/drm/msm/adreno/a5xx_gpu.c b/drivers/gpu/drm/msm/adreno/a5xx_gpu.c
+index ba6f3c14495c0..1fc9a7fa37b45 100644
+--- a/drivers/gpu/drm/msm/adreno/a5xx_gpu.c
++++ b/drivers/gpu/drm/msm/adreno/a5xx_gpu.c
+@@ -1518,7 +1518,8 @@ struct msm_gpu *a5xx_gpu_init(struct drm_device *dev)
+ 
+ 	check_speed_bin(&pdev->dev);
+ 
+-	ret = adreno_gpu_init(dev, pdev, adreno_gpu, &funcs, 4);
++	/* Restricting nr_rings to 1 to temporarily disable preemption */
++	ret = adreno_gpu_init(dev, pdev, adreno_gpu, &funcs, 1);
+ 	if (ret) {
+ 		a5xx_destroy(&(a5xx_gpu->base.base));
+ 		return ERR_PTR(ret);
+diff --git a/drivers/gpu/drm/sun4i/sun6i_mipi_dsi.c b/drivers/gpu/drm/sun4i/sun6i_mipi_dsi.c
+index 79eb11cd185d1..9a5584efd5e78 100644
+--- a/drivers/gpu/drm/sun4i/sun6i_mipi_dsi.c
++++ b/drivers/gpu/drm/sun4i/sun6i_mipi_dsi.c
+@@ -761,7 +761,7 @@ static int sun6i_dsi_dcs_write_long(struct sun6i_dsi *dsi,
+ 	regmap_write(dsi->regs, SUN6I_DSI_CMD_TX_REG(0),
+ 		     sun6i_dsi_dcs_build_pkt_hdr(dsi, msg));
+ 
+-	bounce = kzalloc(msg->tx_len + sizeof(crc), GFP_KERNEL);
++	bounce = kzalloc(ALIGN(msg->tx_len + sizeof(crc), 4), GFP_KERNEL);
+ 	if (!bounce)
+ 		return -ENOMEM;
+ 
+@@ -772,7 +772,7 @@ static int sun6i_dsi_dcs_write_long(struct sun6i_dsi *dsi,
+ 	memcpy((u8 *)bounce + msg->tx_len, &crc, sizeof(crc));
+ 	len += sizeof(crc);
+ 
+-	regmap_bulk_write(dsi->regs, SUN6I_DSI_CMD_TX_REG(1), bounce, len);
++	regmap_bulk_write(dsi->regs, SUN6I_DSI_CMD_TX_REG(1), bounce, DIV_ROUND_UP(len, 4));
+ 	regmap_write(dsi->regs, SUN6I_DSI_CMD_CTL_REG, len + 4 - 1);
+ 	kfree(bounce);
+ 
+diff --git a/drivers/gpu/drm/tve200/tve200_display.c b/drivers/gpu/drm/tve200/tve200_display.c
+index e8723a2412a6f..c0b113ba329c2 100644
+--- a/drivers/gpu/drm/tve200/tve200_display.c
++++ b/drivers/gpu/drm/tve200/tve200_display.c
+@@ -17,6 +17,7 @@
+ #include <linux/version.h>
+ #include <linux/dma-buf.h>
+ #include <linux/of_graph.h>
++#include <linux/delay.h>
+ 
+ #include <drm/drmP.h>
+ #include <drm/drm_panel.h>
+@@ -132,9 +133,25 @@ static void tve200_display_enable(struct drm_simple_display_pipe *pipe,
+ 	struct drm_connector *connector = priv->connector;
+ 	u32 format = fb->format->format;
+ 	u32 ctrl1 = 0;
++	int retries;
+ 
+ 	clk_prepare_enable(priv->clk);
+ 
++	/* Reset the TVE200 and wait for it to come back online */
++	writel(TVE200_CTRL_4_RESET, priv->regs + TVE200_CTRL_4);
++	for (retries = 0; retries < 5; retries++) {
++		usleep_range(30000, 50000);
++		if (readl(priv->regs + TVE200_CTRL_4) & TVE200_CTRL_4_RESET)
++			continue;
++		else
++			break;
++	}
++	if (retries == 5 &&
++	    readl(priv->regs + TVE200_CTRL_4) & TVE200_CTRL_4_RESET) {
++		dev_err(drm->dev, "can't get hardware out of reset\n");
++		return;
++	}
++
+ 	/* Function 1 */
+ 	ctrl1 |= TVE200_CTRL_CSMODE;
+ 	/* Interlace mode for CCIR656: parameterize? */
+@@ -231,8 +248,9 @@ static void tve200_display_disable(struct drm_simple_display_pipe *pipe)
+ 
+ 	drm_crtc_vblank_off(crtc);
+ 
+-	/* Disable and Power Down */
++	/* Disable put into reset and Power Down */
+ 	writel(0, priv->regs + TVE200_CTRL);
++	writel(TVE200_CTRL_4_RESET, priv->regs + TVE200_CTRL_4);
+ 
+ 	clk_disable_unprepare(priv->clk);
+ }
+@@ -280,6 +298,8 @@ static int tve200_display_enable_vblank(struct drm_simple_display_pipe *pipe)
+ 	struct drm_device *drm = crtc->dev;
+ 	struct tve200_drm_dev_private *priv = drm->dev_private;
+ 
++	/* Clear any IRQs and enable */
++	writel(0xFF, priv->regs + TVE200_INT_CLR);
+ 	writel(TVE200_INT_V_STATUS, priv->regs + TVE200_INT_EN);
+ 	return 0;
+ }
+diff --git a/drivers/hid/hid-elan.c b/drivers/hid/hid-elan.c
+index 07e26c3567eb9..6346282e0ff05 100644
+--- a/drivers/hid/hid-elan.c
++++ b/drivers/hid/hid-elan.c
+@@ -192,6 +192,7 @@ static int elan_input_configured(struct hid_device *hdev, struct hid_input *hi)
+ 	ret = input_mt_init_slots(input, ELAN_MAX_FINGERS, INPUT_MT_POINTER);
+ 	if (ret) {
+ 		hid_err(hdev, "Failed to init elan MT slots: %d\n", ret);
++		input_free_device(input);
+ 		return ret;
+ 	}
+ 
+@@ -202,6 +203,7 @@ static int elan_input_configured(struct hid_device *hdev, struct hid_input *hi)
+ 	if (ret) {
+ 		hid_err(hdev, "Failed to register elan input device: %d\n",
+ 			ret);
++		input_mt_destroy_slots(input);
+ 		input_free_device(input);
+ 		return ret;
+ 	}
+diff --git a/drivers/hid/hid-ids.h b/drivers/hid/hid-ids.h
+index 2c100b73d3fc1..e18d796d985f8 100644
+--- a/drivers/hid/hid-ids.h
++++ b/drivers/hid/hid-ids.h
+@@ -985,6 +985,8 @@
+ #define USB_DEVICE_ID_SAITEK_RAT9	0x0cfa
+ #define USB_DEVICE_ID_SAITEK_MMO7	0x0cd0
+ #define USB_DEVICE_ID_SAITEK_X52	0x075c
++#define USB_DEVICE_ID_SAITEK_X52_2	0x0255
++#define USB_DEVICE_ID_SAITEK_X52_PRO	0x0762
+ 
+ #define USB_VENDOR_ID_SAMSUNG		0x0419
+ #define USB_DEVICE_ID_SAMSUNG_IR_REMOTE	0x0001
+diff --git a/drivers/hid/hid-quirks.c b/drivers/hid/hid-quirks.c
+index 62f87f8bd9720..2d8d20a7f4574 100644
+--- a/drivers/hid/hid-quirks.c
++++ b/drivers/hid/hid-quirks.c
+@@ -147,6 +147,8 @@ static const struct hid_device_id hid_quirks[] = {
+ 	{ HID_USB_DEVICE(USB_VENDOR_ID_RETROUSB, USB_DEVICE_ID_RETROUSB_SNES_RETROPORT), HID_QUIRK_INCREMENT_USAGE_ON_DUPLICATE },
+ 	{ HID_USB_DEVICE(USB_VENDOR_ID_SAITEK, USB_DEVICE_ID_SAITEK_RUMBLEPAD), HID_QUIRK_BADPAD },
+ 	{ HID_USB_DEVICE(USB_VENDOR_ID_SAITEK, USB_DEVICE_ID_SAITEK_X52), HID_QUIRK_INCREMENT_USAGE_ON_DUPLICATE },
++	{ HID_USB_DEVICE(USB_VENDOR_ID_SAITEK, USB_DEVICE_ID_SAITEK_X52_2), HID_QUIRK_INCREMENT_USAGE_ON_DUPLICATE },
++	{ HID_USB_DEVICE(USB_VENDOR_ID_SAITEK, USB_DEVICE_ID_SAITEK_X52_PRO), HID_QUIRK_INCREMENT_USAGE_ON_DUPLICATE },
+ 	{ HID_USB_DEVICE(USB_VENDOR_ID_SEMICO, USB_DEVICE_ID_SEMICO_USB_KEYKOARD2), HID_QUIRK_NO_INIT_REPORTS },
+ 	{ HID_USB_DEVICE(USB_VENDOR_ID_SEMICO, USB_DEVICE_ID_SEMICO_USB_KEYKOARD), HID_QUIRK_NO_INIT_REPORTS },
+ 	{ HID_USB_DEVICE(USB_VENDOR_ID_SENNHEISER, USB_DEVICE_ID_SENNHEISER_BTD500USB), HID_QUIRK_NOGET },
+diff --git a/drivers/iio/accel/bmc150-accel-core.c b/drivers/iio/accel/bmc150-accel-core.c
+index cb8c98a440109..e029d4b0f7afd 100644
+--- a/drivers/iio/accel/bmc150-accel-core.c
++++ b/drivers/iio/accel/bmc150-accel-core.c
+@@ -197,6 +197,14 @@ struct bmc150_accel_data {
+ 	struct mutex mutex;
+ 	u8 fifo_mode, watermark;
+ 	s16 buffer[8];
++	/*
++	 * Ensure there is sufficient space and correct alignment for
++	 * the timestamp if enabled
++	 */
++	struct {
++		__le16 channels[3];
++		s64 ts __aligned(8);
++	} scan;
+ 	u8 bw_bits;
+ 	u32 slope_dur;
+ 	u32 slope_thres;
+@@ -915,15 +923,16 @@ static int __bmc150_accel_fifo_flush(struct iio_dev *indio_dev,
+ 	 * now.
+ 	 */
+ 	for (i = 0; i < count; i++) {
+-		u16 sample[8];
+ 		int j, bit;
+ 
+ 		j = 0;
+ 		for_each_set_bit(bit, indio_dev->active_scan_mask,
+ 				 indio_dev->masklength)
+-			memcpy(&sample[j++], &buffer[i * 3 + bit], 2);
++			memcpy(&data->scan.channels[j++], &buffer[i * 3 + bit],
++			       sizeof(data->scan.channels[0]));
+ 
+-		iio_push_to_buffers_with_timestamp(indio_dev, sample, tstamp);
++		iio_push_to_buffers_with_timestamp(indio_dev, &data->scan,
++						   tstamp);
+ 
+ 		tstamp += sample_period;
+ 	}
+diff --git a/drivers/iio/accel/kxsd9.c b/drivers/iio/accel/kxsd9.c
+index 0c0df4fce4206..f74cb2e082a67 100644
+--- a/drivers/iio/accel/kxsd9.c
++++ b/drivers/iio/accel/kxsd9.c
+@@ -212,14 +212,20 @@ static irqreturn_t kxsd9_trigger_handler(int irq, void *p)
+ 	const struct iio_poll_func *pf = p;
+ 	struct iio_dev *indio_dev = pf->indio_dev;
+ 	struct kxsd9_state *st = iio_priv(indio_dev);
++	/*
++	 * Ensure correct positioning and alignment of timestamp.
++	 * No need to zero initialize as all elements written.
++	 */
++	struct {
++		__be16 chan[4];
++		s64 ts __aligned(8);
++	} hw_values;
+ 	int ret;
+-	/* 4 * 16bit values AND timestamp */
+-	__be16 hw_values[8];
+ 
+ 	ret = regmap_bulk_read(st->map,
+ 			       KXSD9_REG_X,
+-			       &hw_values,
+-			       8);
++			       hw_values.chan,
++			       sizeof(hw_values.chan));
+ 	if (ret) {
+ 		dev_err(st->dev,
+ 			"error reading data\n");
+@@ -227,7 +233,7 @@ static irqreturn_t kxsd9_trigger_handler(int irq, void *p)
+ 	}
+ 
+ 	iio_push_to_buffers_with_timestamp(indio_dev,
+-					   hw_values,
++					   &hw_values,
+ 					   iio_get_time_ns(indio_dev));
+ 	iio_trigger_notify_done(indio_dev->trig);
+ 
+diff --git a/drivers/iio/accel/mma7455_core.c b/drivers/iio/accel/mma7455_core.c
+index da0ceaac46b53..a3b5d5780bc8f 100644
+--- a/drivers/iio/accel/mma7455_core.c
++++ b/drivers/iio/accel/mma7455_core.c
+@@ -55,6 +55,14 @@
+ 
+ struct mma7455_data {
+ 	struct regmap *regmap;
++	/*
++	 * Used to reorganize data.  Will ensure correct alignment of
++	 * the timestamp if present
++	 */
++	struct {
++		__le16 channels[3];
++		s64 ts __aligned(8);
++	} scan;
+ };
+ 
+ static int mma7455_drdy(struct mma7455_data *mma7455)
+@@ -85,19 +93,19 @@ static irqreturn_t mma7455_trigger_handler(int irq, void *p)
+ 	struct iio_poll_func *pf = p;
+ 	struct iio_dev *indio_dev = pf->indio_dev;
+ 	struct mma7455_data *mma7455 = iio_priv(indio_dev);
+-	u8 buf[16]; /* 3 x 16-bit channels + padding + ts */
+ 	int ret;
+ 
+ 	ret = mma7455_drdy(mma7455);
+ 	if (ret)
+ 		goto done;
+ 
+-	ret = regmap_bulk_read(mma7455->regmap, MMA7455_REG_XOUTL, buf,
+-			       sizeof(__le16) * 3);
++	ret = regmap_bulk_read(mma7455->regmap, MMA7455_REG_XOUTL,
++			       mma7455->scan.channels,
++			       sizeof(mma7455->scan.channels));
+ 	if (ret)
+ 		goto done;
+ 
+-	iio_push_to_buffers_with_timestamp(indio_dev, buf,
++	iio_push_to_buffers_with_timestamp(indio_dev, &mma7455->scan,
+ 					   iio_get_time_ns(indio_dev));
+ 
+ done:
+diff --git a/drivers/iio/accel/mma8452.c b/drivers/iio/accel/mma8452.c
+index fcfec758fec63..15c254b4745cc 100644
+--- a/drivers/iio/accel/mma8452.c
++++ b/drivers/iio/accel/mma8452.c
+@@ -107,6 +107,12 @@ struct mma8452_data {
+ 	u8 data_cfg;
+ 	const struct mma_chip_info *chip_info;
+ 	int sleep_val;
++
++	/* Ensure correct alignment of time stamp when present */
++	struct {
++		__be16 channels[3];
++		s64 ts __aligned(8);
++	} buffer;
+ };
+ 
+  /**
+@@ -1088,14 +1094,13 @@ static irqreturn_t mma8452_trigger_handler(int irq, void *p)
+ 	struct iio_poll_func *pf = p;
+ 	struct iio_dev *indio_dev = pf->indio_dev;
+ 	struct mma8452_data *data = iio_priv(indio_dev);
+-	u8 buffer[16]; /* 3 16-bit channels + padding + ts */
+ 	int ret;
+ 
+-	ret = mma8452_read(data, (__be16 *)buffer);
++	ret = mma8452_read(data, data->buffer.channels);
+ 	if (ret < 0)
+ 		goto done;
+ 
+-	iio_push_to_buffers_with_timestamp(indio_dev, buffer,
++	iio_push_to_buffers_with_timestamp(indio_dev, &data->buffer,
+ 					   iio_get_time_ns(indio_dev));
+ 
+ done:
+diff --git a/drivers/iio/adc/ina2xx-adc.c b/drivers/iio/adc/ina2xx-adc.c
+index d1239624187da..1ab106b3d3a6b 100644
+--- a/drivers/iio/adc/ina2xx-adc.c
++++ b/drivers/iio/adc/ina2xx-adc.c
+@@ -146,6 +146,11 @@ struct ina2xx_chip_info {
+ 	int range_vbus; /* Bus voltage maximum in V */
+ 	int pga_gain_vshunt; /* Shunt voltage PGA gain */
+ 	bool allow_async_readout;
++	/* data buffer needs space for channel data and timestamp */
++	struct {
++		u16 chan[4];
++		u64 ts __aligned(8);
++	} scan;
+ };
+ 
+ static const struct ina2xx_config ina2xx_config[] = {
+@@ -736,8 +741,6 @@ static int ina2xx_conversion_ready(struct iio_dev *indio_dev)
+ static int ina2xx_work_buffer(struct iio_dev *indio_dev)
+ {
+ 	struct ina2xx_chip_info *chip = iio_priv(indio_dev);
+-	/* data buffer needs space for channel data and timestap */
+-	unsigned short data[4 + sizeof(s64)/sizeof(short)];
+ 	int bit, ret, i = 0;
+ 	s64 time;
+ 
+@@ -756,10 +759,10 @@ static int ina2xx_work_buffer(struct iio_dev *indio_dev)
+ 		if (ret < 0)
+ 			return ret;
+ 
+-		data[i++] = val;
++		chip->scan.chan[i++] = val;
+ 	}
+ 
+-	iio_push_to_buffers_with_timestamp(indio_dev, data, time);
++	iio_push_to_buffers_with_timestamp(indio_dev, &chip->scan, time);
+ 
+ 	return 0;
+ };
+diff --git a/drivers/iio/adc/max1118.c b/drivers/iio/adc/max1118.c
+index 49db9e9ae625c..b372b226ac203 100644
+--- a/drivers/iio/adc/max1118.c
++++ b/drivers/iio/adc/max1118.c
+@@ -38,6 +38,11 @@ struct max1118 {
+ 	struct spi_device *spi;
+ 	struct mutex lock;
+ 	struct regulator *reg;
++	/* Ensure natural alignment of buffer elements */
++	struct {
++		u8 channels[2];
++		s64 ts __aligned(8);
++	} scan;
+ 
+ 	u8 data ____cacheline_aligned;
+ };
+@@ -162,7 +167,6 @@ static irqreturn_t max1118_trigger_handler(int irq, void *p)
+ 	struct iio_poll_func *pf = p;
+ 	struct iio_dev *indio_dev = pf->indio_dev;
+ 	struct max1118 *adc = iio_priv(indio_dev);
+-	u8 data[16] = { }; /* 2x 8-bit ADC data + padding + 8 bytes timestamp */
+ 	int scan_index;
+ 	int i = 0;
+ 
+@@ -180,10 +184,10 @@ static irqreturn_t max1118_trigger_handler(int irq, void *p)
+ 			goto out;
+ 		}
+ 
+-		data[i] = ret;
++		adc->scan.channels[i] = ret;
+ 		i++;
+ 	}
+-	iio_push_to_buffers_with_timestamp(indio_dev, data,
++	iio_push_to_buffers_with_timestamp(indio_dev, &adc->scan,
+ 					   iio_get_time_ns(indio_dev));
+ out:
+ 	mutex_unlock(&adc->lock);
+diff --git a/drivers/iio/adc/mcp3422.c b/drivers/iio/adc/mcp3422.c
+index 819f260115005..4ee4ca35c2550 100644
+--- a/drivers/iio/adc/mcp3422.c
++++ b/drivers/iio/adc/mcp3422.c
+@@ -99,16 +99,12 @@ static int mcp3422_update_config(struct mcp3422 *adc, u8 newconfig)
+ {
+ 	int ret;
+ 
+-	mutex_lock(&adc->lock);
+-
+ 	ret = i2c_master_send(adc->i2c, &newconfig, 1);
+ 	if (ret > 0) {
+ 		adc->config = newconfig;
+ 		ret = 0;
+ 	}
+ 
+-	mutex_unlock(&adc->lock);
+-
+ 	return ret;
+ }
+ 
+@@ -141,6 +137,8 @@ static int mcp3422_read_channel(struct mcp3422 *adc,
+ 	u8 config;
+ 	u8 req_channel = channel->channel;
+ 
++	mutex_lock(&adc->lock);
++
+ 	if (req_channel != MCP3422_CHANNEL(adc->config)) {
+ 		config = adc->config;
+ 		config &= ~MCP3422_CHANNEL_MASK;
+@@ -148,12 +146,18 @@ static int mcp3422_read_channel(struct mcp3422 *adc,
+ 		config &= ~MCP3422_PGA_MASK;
+ 		config |= MCP3422_PGA_VALUE(adc->pga[req_channel]);
+ 		ret = mcp3422_update_config(adc, config);
+-		if (ret < 0)
++		if (ret < 0) {
++			mutex_unlock(&adc->lock);
+ 			return ret;
++		}
+ 		msleep(mcp3422_read_times[MCP3422_SAMPLE_RATE(adc->config)]);
+ 	}
+ 
+-	return mcp3422_read(adc, value, &config);
++	ret = mcp3422_read(adc, value, &config);
++
++	mutex_unlock(&adc->lock);
++
++	return ret;
+ }
+ 
+ static int mcp3422_read_raw(struct iio_dev *iio,
+diff --git a/drivers/iio/adc/ti-adc081c.c b/drivers/iio/adc/ti-adc081c.c
+index 405e3779c0c56..ef95363ebac2a 100644
+--- a/drivers/iio/adc/ti-adc081c.c
++++ b/drivers/iio/adc/ti-adc081c.c
+@@ -36,6 +36,12 @@ struct adc081c {
+ 
+ 	/* 8, 10 or 12 */
+ 	int bits;
++
++	/* Ensure natural alignment of buffer elements */
++	struct {
++		u16 channel;
++		s64 ts __aligned(8);
++	} scan;
+ };
+ 
+ #define REG_CONV_RES 0x00
+@@ -131,14 +137,13 @@ static irqreturn_t adc081c_trigger_handler(int irq, void *p)
+ 	struct iio_poll_func *pf = p;
+ 	struct iio_dev *indio_dev = pf->indio_dev;
+ 	struct adc081c *data = iio_priv(indio_dev);
+-	u16 buf[8]; /* 2 bytes data + 6 bytes padding + 8 bytes timestamp */
+ 	int ret;
+ 
+ 	ret = i2c_smbus_read_word_swapped(data->i2c, REG_CONV_RES);
+ 	if (ret < 0)
+ 		goto out;
+-	buf[0] = ret;
+-	iio_push_to_buffers_with_timestamp(indio_dev, buf,
++	data->scan.channel = ret;
++	iio_push_to_buffers_with_timestamp(indio_dev, &data->scan,
+ 					   iio_get_time_ns(indio_dev));
+ out:
+ 	iio_trigger_notify_done(indio_dev->trig);
+diff --git a/drivers/iio/adc/ti-adc084s021.c b/drivers/iio/adc/ti-adc084s021.c
+index 25504640e1261..ec490e7a5b737 100644
+--- a/drivers/iio/adc/ti-adc084s021.c
++++ b/drivers/iio/adc/ti-adc084s021.c
+@@ -28,6 +28,11 @@ struct adc084s021 {
+ 	struct spi_transfer spi_trans;
+ 	struct regulator *reg;
+ 	struct mutex lock;
++	/* Buffer used to align data */
++	struct {
++		__be16 channels[4];
++		s64 ts __aligned(8);
++	} scan;
+ 	/*
+ 	 * DMA (thus cache coherency maintenance) requires the
+ 	 * transfer buffers to live in their own cache line.
+@@ -143,14 +148,13 @@ static irqreturn_t adc084s021_buffer_trigger_handler(int irq, void *pollfunc)
+ 	struct iio_poll_func *pf = pollfunc;
+ 	struct iio_dev *indio_dev = pf->indio_dev;
+ 	struct adc084s021 *adc = iio_priv(indio_dev);
+-	__be16 data[8] = {0}; /* 4 * 16-bit words of data + 8 bytes timestamp */
+ 
+ 	mutex_lock(&adc->lock);
+ 
+-	if (adc084s021_adc_conversion(adc, &data) < 0)
++	if (adc084s021_adc_conversion(adc, adc->scan.channels) < 0)
+ 		dev_err(&adc->spi->dev, "Failed to read data\n");
+ 
+-	iio_push_to_buffers_with_timestamp(indio_dev, data,
++	iio_push_to_buffers_with_timestamp(indio_dev, &adc->scan,
+ 					   iio_get_time_ns(indio_dev));
+ 	mutex_unlock(&adc->lock);
+ 	iio_trigger_notify_done(indio_dev->trig);
+diff --git a/drivers/iio/adc/ti-ads1015.c b/drivers/iio/adc/ti-ads1015.c
+index 6a114dcb4a3a7..dc8d859e4b92c 100644
+--- a/drivers/iio/adc/ti-ads1015.c
++++ b/drivers/iio/adc/ti-ads1015.c
+@@ -312,6 +312,7 @@ static const struct iio_chan_spec ads1115_channels[] = {
+ 	IIO_CHAN_SOFT_TIMESTAMP(ADS1015_TIMESTAMP),
+ };
+ 
++#ifdef CONFIG_PM
+ static int ads1015_set_power_state(struct ads1015_data *data, bool on)
+ {
+ 	int ret;
+@@ -329,6 +330,15 @@ static int ads1015_set_power_state(struct ads1015_data *data, bool on)
+ 	return ret < 0 ? ret : 0;
+ }
+ 
++#else /* !CONFIG_PM */
++
++static int ads1015_set_power_state(struct ads1015_data *data, bool on)
++{
++	return 0;
++}
++
++#endif /* !CONFIG_PM */
++
+ static
+ int ads1015_get_adc_result(struct ads1015_data *data, int chan, int *val)
+ {
+diff --git a/drivers/iio/chemical/ccs811.c b/drivers/iio/chemical/ccs811.c
+index b4a46eb457893..46d5d48b58b6c 100644
+--- a/drivers/iio/chemical/ccs811.c
++++ b/drivers/iio/chemical/ccs811.c
+@@ -78,6 +78,11 @@ struct ccs811_data {
+ 	struct ccs811_reading buffer;
+ 	struct iio_trigger *drdy_trig;
+ 	bool drdy_trig_on;
++	/* Ensures correct alignment of timestamp if present */
++	struct {
++		s16 channels[2];
++		s64 ts __aligned(8);
++	} scan;
+ };
+ 
+ static const struct iio_chan_spec ccs811_channels[] = {
+@@ -309,17 +314,17 @@ static irqreturn_t ccs811_trigger_handler(int irq, void *p)
+ 	struct iio_dev *indio_dev = pf->indio_dev;
+ 	struct ccs811_data *data = iio_priv(indio_dev);
+ 	struct i2c_client *client = data->client;
+-	s16 buf[8]; /* s16 eCO2 + s16 TVOC + padding + 8 byte timestamp */
+ 	int ret;
+ 
+-	ret = i2c_smbus_read_i2c_block_data(client, CCS811_ALG_RESULT_DATA, 4,
+-					    (u8 *)&buf);
++	ret = i2c_smbus_read_i2c_block_data(client, CCS811_ALG_RESULT_DATA,
++					    sizeof(data->scan.channels),
++					    (u8 *)data->scan.channels);
+ 	if (ret != 4) {
+ 		dev_err(&client->dev, "cannot read sensor data\n");
+ 		goto err;
+ 	}
+ 
+-	iio_push_to_buffers_with_timestamp(indio_dev, buf,
++	iio_push_to_buffers_with_timestamp(indio_dev, &data->scan,
+ 					   iio_get_time_ns(indio_dev));
+ 
+ err:
+diff --git a/drivers/iio/light/ltr501.c b/drivers/iio/light/ltr501.c
+index 830a2d45aa4dd..947f17588024a 100644
+--- a/drivers/iio/light/ltr501.c
++++ b/drivers/iio/light/ltr501.c
+@@ -1245,13 +1245,16 @@ static irqreturn_t ltr501_trigger_handler(int irq, void *p)
+ 	struct iio_poll_func *pf = p;
+ 	struct iio_dev *indio_dev = pf->indio_dev;
+ 	struct ltr501_data *data = iio_priv(indio_dev);
+-	u16 buf[8];
++	struct {
++		u16 channels[3];
++		s64 ts __aligned(8);
++	} scan;
+ 	__le16 als_buf[2];
+ 	u8 mask = 0;
+ 	int j = 0;
+ 	int ret, psdata;
+ 
+-	memset(buf, 0, sizeof(buf));
++	memset(&scan, 0, sizeof(scan));
+ 
+ 	/* figure out which data needs to be ready */
+ 	if (test_bit(0, indio_dev->active_scan_mask) ||
+@@ -1270,9 +1273,9 @@ static irqreturn_t ltr501_trigger_handler(int irq, void *p)
+ 		if (ret < 0)
+ 			return ret;
+ 		if (test_bit(0, indio_dev->active_scan_mask))
+-			buf[j++] = le16_to_cpu(als_buf[1]);
++			scan.channels[j++] = le16_to_cpu(als_buf[1]);
+ 		if (test_bit(1, indio_dev->active_scan_mask))
+-			buf[j++] = le16_to_cpu(als_buf[0]);
++			scan.channels[j++] = le16_to_cpu(als_buf[0]);
+ 	}
+ 
+ 	if (mask & LTR501_STATUS_PS_RDY) {
+@@ -1280,10 +1283,10 @@ static irqreturn_t ltr501_trigger_handler(int irq, void *p)
+ 				       &psdata, 2);
+ 		if (ret < 0)
+ 			goto done;
+-		buf[j++] = psdata & LTR501_PS_DATA_MASK;
++		scan.channels[j++] = psdata & LTR501_PS_DATA_MASK;
+ 	}
+ 
+-	iio_push_to_buffers_with_timestamp(indio_dev, buf,
++	iio_push_to_buffers_with_timestamp(indio_dev, &scan,
+ 					   iio_get_time_ns(indio_dev));
+ 
+ done:
+diff --git a/drivers/iio/light/max44000.c b/drivers/iio/light/max44000.c
+index bcdb0eb9e5371..7d2b3d0657262 100644
+--- a/drivers/iio/light/max44000.c
++++ b/drivers/iio/light/max44000.c
+@@ -78,6 +78,11 @@
+ struct max44000_data {
+ 	struct mutex lock;
+ 	struct regmap *regmap;
++	/* Ensure naturally aligned timestamp */
++	struct {
++		u16 channels[2];
++		s64 ts __aligned(8);
++	} scan;
+ };
+ 
+ /* Default scale is set to the minimum of 0.03125 or 1 / (1 << 5) lux */
+@@ -491,7 +496,6 @@ static irqreturn_t max44000_trigger_handler(int irq, void *p)
+ 	struct iio_poll_func *pf = p;
+ 	struct iio_dev *indio_dev = pf->indio_dev;
+ 	struct max44000_data *data = iio_priv(indio_dev);
+-	u16 buf[8]; /* 2x u16 + padding + 8 bytes timestamp */
+ 	int index = 0;
+ 	unsigned int regval;
+ 	int ret;
+@@ -501,17 +505,17 @@ static irqreturn_t max44000_trigger_handler(int irq, void *p)
+ 		ret = max44000_read_alsval(data);
+ 		if (ret < 0)
+ 			goto out_unlock;
+-		buf[index++] = ret;
++		data->scan.channels[index++] = ret;
+ 	}
+ 	if (test_bit(MAX44000_SCAN_INDEX_PRX, indio_dev->active_scan_mask)) {
+ 		ret = regmap_read(data->regmap, MAX44000_REG_PRX_DATA, &regval);
+ 		if (ret < 0)
+ 			goto out_unlock;
+-		buf[index] = regval;
++		data->scan.channels[index] = regval;
+ 	}
+ 	mutex_unlock(&data->lock);
+ 
+-	iio_push_to_buffers_with_timestamp(indio_dev, buf,
++	iio_push_to_buffers_with_timestamp(indio_dev, &data->scan,
+ 					   iio_get_time_ns(indio_dev));
+ 	iio_trigger_notify_done(indio_dev->trig);
+ 	return IRQ_HANDLED;
+diff --git a/drivers/iio/magnetometer/ak8975.c b/drivers/iio/magnetometer/ak8975.c
+index 42a827a665121..379aa7f4a8041 100644
+--- a/drivers/iio/magnetometer/ak8975.c
++++ b/drivers/iio/magnetometer/ak8975.c
+@@ -381,6 +381,12 @@ struct ak8975_data {
+ 	struct iio_mount_matrix orientation;
+ 	struct regulator	*vdd;
+ 	struct regulator	*vid;
++
++	/* Ensure natural alignment of timestamp */
++	struct {
++		s16 channels[3];
++		s64 ts __aligned(8);
++	} scan;
+ };
+ 
+ /* Enable attached power regulator if any. */
+@@ -815,7 +821,6 @@ static void ak8975_fill_buffer(struct iio_dev *indio_dev)
+ 	const struct i2c_client *client = data->client;
+ 	const struct ak_def *def = data->def;
+ 	int ret;
+-	s16 buff[8]; /* 3 x 16 bits axis values + 1 aligned 64 bits timestamp */
+ 	__le16 fval[3];
+ 
+ 	mutex_lock(&data->lock);
+@@ -838,12 +843,13 @@ static void ak8975_fill_buffer(struct iio_dev *indio_dev)
+ 	mutex_unlock(&data->lock);
+ 
+ 	/* Clamp to valid range. */
+-	buff[0] = clamp_t(s16, le16_to_cpu(fval[0]), -def->range, def->range);
+-	buff[1] = clamp_t(s16, le16_to_cpu(fval[1]), -def->range, def->range);
+-	buff[2] = clamp_t(s16, le16_to_cpu(fval[2]), -def->range, def->range);
++	data->scan.channels[0] = clamp_t(s16, le16_to_cpu(fval[0]), -def->range, def->range);
++	data->scan.channels[1] = clamp_t(s16, le16_to_cpu(fval[1]), -def->range, def->range);
++	data->scan.channels[2] = clamp_t(s16, le16_to_cpu(fval[2]), -def->range, def->range);
+ 
+-	iio_push_to_buffers_with_timestamp(indio_dev, buff,
++	iio_push_to_buffers_with_timestamp(indio_dev, &data->scan,
+ 					   iio_get_time_ns(indio_dev));
++
+ 	return;
+ 
+ unlock:
+diff --git a/drivers/infiniband/core/verbs.c b/drivers/infiniband/core/verbs.c
+index e8432876cc860..e1ecd4682c096 100644
+--- a/drivers/infiniband/core/verbs.c
++++ b/drivers/infiniband/core/verbs.c
+@@ -1711,7 +1711,7 @@ int ib_get_eth_speed(struct ib_device *dev, u8 port_num, u8 *speed, u8 *width)
+ 
+ 	dev_put(netdev);
+ 
+-	if (!rc) {
++	if (!rc && lksettings.base.speed != (u32)SPEED_UNKNOWN) {
+ 		netdev_speed = lksettings.base.speed;
+ 	} else {
+ 		netdev_speed = SPEED_1000;
+diff --git a/drivers/infiniband/hw/bnxt_re/ib_verbs.c b/drivers/infiniband/hw/bnxt_re/ib_verbs.c
+index c9af2d139f5cb..957da3ffe593c 100644
+--- a/drivers/infiniband/hw/bnxt_re/ib_verbs.c
++++ b/drivers/infiniband/hw/bnxt_re/ib_verbs.c
+@@ -3033,6 +3033,19 @@ static void bnxt_re_process_res_rawqp1_wc(struct ib_wc *wc,
+ 	wc->wc_flags |= IB_WC_GRH;
+ }
+ 
++static bool bnxt_re_check_if_vlan_valid(struct bnxt_re_dev *rdev,
++					u16 vlan_id)
++{
++	/*
++	 * Check if the vlan is configured in the host.  If not configured, it
++	 * can be a transparent VLAN. So dont report the vlan id.
++	 */
++	if (!__vlan_find_dev_deep_rcu(rdev->netdev,
++				      htons(ETH_P_8021Q), vlan_id))
++		return false;
++	return true;
++}
++
+ static bool bnxt_re_is_vlan_pkt(struct bnxt_qplib_cqe *orig_cqe,
+ 				u16 *vid, u8 *sl)
+ {
+@@ -3101,9 +3114,11 @@ static void bnxt_re_process_res_shadow_qp_wc(struct bnxt_re_qp *qp,
+ 	wc->src_qp = orig_cqe->src_qp;
+ 	memcpy(wc->smac, orig_cqe->smac, ETH_ALEN);
+ 	if (bnxt_re_is_vlan_pkt(orig_cqe, &vlan_id, &sl)) {
+-		wc->vlan_id = vlan_id;
+-		wc->sl = sl;
+-		wc->wc_flags |= IB_WC_WITH_VLAN;
++		if (bnxt_re_check_if_vlan_valid(rdev, vlan_id)) {
++			wc->vlan_id = vlan_id;
++			wc->sl = sl;
++			wc->wc_flags |= IB_WC_WITH_VLAN;
++		}
+ 	}
+ 	wc->port_num = 1;
+ 	wc->vendor_err = orig_cqe->status;
+diff --git a/drivers/infiniband/sw/rxe/rxe.c b/drivers/infiniband/sw/rxe/rxe.c
+index 10999fa692818..94dedabe648c2 100644
+--- a/drivers/infiniband/sw/rxe/rxe.c
++++ b/drivers/infiniband/sw/rxe/rxe.c
+@@ -163,9 +163,6 @@ static int rxe_init_ports(struct rxe_dev *rxe)
+ 
+ 	rxe_init_port_param(port);
+ 
+-	if (!port->attr.pkey_tbl_len || !port->attr.gid_tbl_len)
+-		return -EINVAL;
+-
+ 	port->pkey_tbl = kcalloc(port->attr.pkey_tbl_len,
+ 			sizeof(*port->pkey_tbl), GFP_KERNEL);
+ 
+diff --git a/drivers/infiniband/sw/rxe/rxe_mr.c b/drivers/infiniband/sw/rxe/rxe_mr.c
+index dff605fdf60fa..2cca89ca08cd4 100644
+--- a/drivers/infiniband/sw/rxe/rxe_mr.c
++++ b/drivers/infiniband/sw/rxe/rxe_mr.c
+@@ -203,6 +203,7 @@ int rxe_mem_init_user(struct rxe_pd *pd, u64 start,
+ 			vaddr = page_address(sg_page(sg));
+ 			if (!vaddr) {
+ 				pr_warn("null vaddr\n");
++				ib_umem_release(umem);
+ 				err = -ENOMEM;
+ 				goto err1;
+ 			}
+diff --git a/drivers/infiniband/sw/rxe/rxe_verbs.c b/drivers/infiniband/sw/rxe/rxe_verbs.c
+index 3a94eb5edcf90..f7f9caaec7d6b 100644
+--- a/drivers/infiniband/sw/rxe/rxe_verbs.c
++++ b/drivers/infiniband/sw/rxe/rxe_verbs.c
+@@ -1146,7 +1146,7 @@ static ssize_t parent_show(struct device *device,
+ 	struct rxe_dev *rxe = container_of(device, struct rxe_dev,
+ 					   ib_dev.dev);
+ 
+-	return snprintf(buf, 16, "%s\n", rxe_parent_name(rxe, 1));
++	return scnprintf(buf, PAGE_SIZE, "%s\n", rxe_parent_name(rxe, 1));
+ }
+ 
+ static DEVICE_ATTR_RO(parent);
+diff --git a/drivers/iommu/amd_iommu_v2.c b/drivers/iommu/amd_iommu_v2.c
+index 58da65df03f5e..7a59a8ebac108 100644
+--- a/drivers/iommu/amd_iommu_v2.c
++++ b/drivers/iommu/amd_iommu_v2.c
+@@ -776,6 +776,13 @@ int amd_iommu_init_device(struct pci_dev *pdev, int pasids)
+ 
+ 	might_sleep();
+ 
++	/*
++	 * When memory encryption is active the device is likely not in a
++	 * direct-mapped domain. Forbid using IOMMUv2 functionality for now.
++	 */
++	if (mem_encrypt_active())
++		return -ENODEV;
++
+ 	if (!amd_iommu_v2_supported())
+ 		return -ENODEV;
+ 
+diff --git a/drivers/mmc/host/sdhci-msm.c b/drivers/mmc/host/sdhci-msm.c
+index 643fd1a1b88be..4970cd40813b2 100644
+--- a/drivers/mmc/host/sdhci-msm.c
++++ b/drivers/mmc/host/sdhci-msm.c
+@@ -1060,7 +1060,7 @@ static void sdhci_msm_set_cdr(struct sdhci_host *host, bool enable)
+ static int sdhci_msm_execute_tuning(struct mmc_host *mmc, u32 opcode)
+ {
+ 	struct sdhci_host *host = mmc_priv(mmc);
+-	int tuning_seq_cnt = 3;
++	int tuning_seq_cnt = 10;
+ 	u8 phase, tuned_phases[16], tuned_phase_cnt = 0;
+ 	int rc;
+ 	struct mmc_ios ios = host->mmc->ios;
+@@ -1124,6 +1124,22 @@ retry:
+ 	} while (++phase < ARRAY_SIZE(tuned_phases));
+ 
+ 	if (tuned_phase_cnt) {
++		if (tuned_phase_cnt == ARRAY_SIZE(tuned_phases)) {
++			/*
++			 * All phases valid is _almost_ as bad as no phases
++			 * valid.  Probably all phases are not really reliable
++			 * but we didn't detect where the unreliable place is.
++			 * That means we'll essentially be guessing and hoping
++			 * we get a good phase.  Better to try a few times.
++			 */
++			dev_dbg(mmc_dev(mmc), "%s: All phases valid; try again\n",
++				mmc_hostname(mmc));
++			if (--tuning_seq_cnt) {
++				tuned_phase_cnt = 0;
++				goto retry;
++			}
++		}
++
+ 		rc = msm_find_most_appropriate_phase(host, tuned_phases,
+ 						     tuned_phase_cnt);
+ 		if (rc < 0)
+diff --git a/drivers/net/wan/hdlc_cisco.c b/drivers/net/wan/hdlc_cisco.c
+index 320039d329c7d..c169a26e5359a 100644
+--- a/drivers/net/wan/hdlc_cisco.c
++++ b/drivers/net/wan/hdlc_cisco.c
+@@ -374,6 +374,7 @@ static int cisco_ioctl(struct net_device *dev, struct ifreq *ifr)
+ 		memcpy(&state(hdlc)->settings, &new_settings, size);
+ 		spin_lock_init(&state(hdlc)->lock);
+ 		dev->header_ops = &cisco_header_ops;
++		dev->hard_header_len = sizeof(struct hdlc_header);
+ 		dev->type = ARPHRD_CISCO;
+ 		call_netdevice_notifiers(NETDEV_POST_TYPE_CHANGE, dev);
+ 		netif_dormant_on(dev);
+diff --git a/drivers/net/wan/lapbether.c b/drivers/net/wan/lapbether.c
+index c94dfa70f2a33..15177a54b17d7 100644
+--- a/drivers/net/wan/lapbether.c
++++ b/drivers/net/wan/lapbether.c
+@@ -213,6 +213,8 @@ static void lapbeth_data_transmit(struct net_device *ndev, struct sk_buff *skb)
+ 
+ 	skb->dev = dev = lapbeth->ethdev;
+ 
++	skb_reset_network_header(skb);
++
+ 	dev_hard_header(skb, dev, ETH_P_DEC, bcast_addr, NULL, 0);
+ 
+ 	dev_queue_xmit(skb);
+@@ -343,6 +345,7 @@ static int lapbeth_new_device(struct net_device *dev)
+ 	 */
+ 	ndev->needed_headroom = -1 + 3 + 2 + dev->hard_header_len
+ 					   + dev->needed_headroom;
++	ndev->needed_tailroom = dev->needed_tailroom;
+ 
+ 	lapbeth = netdev_priv(ndev);
+ 	lapbeth->axdev = ndev;
+diff --git a/drivers/nfc/st95hf/core.c b/drivers/nfc/st95hf/core.c
+index 01acb6e533655..c4b6e29c07192 100644
+--- a/drivers/nfc/st95hf/core.c
++++ b/drivers/nfc/st95hf/core.c
+@@ -981,7 +981,7 @@ static int st95hf_in_send_cmd(struct nfc_digital_dev *ddev,
+ 	rc = down_killable(&stcontext->exchange_lock);
+ 	if (rc) {
+ 		WARN(1, "Semaphore is not found up in st95hf_in_send_cmd\n");
+-		return rc;
++		goto free_skb_resp;
+ 	}
+ 
+ 	rc = st95hf_spi_send(&stcontext->spicontext, skb->data,
+diff --git a/drivers/nvme/host/fabrics.c b/drivers/nvme/host/fabrics.c
+index bcd09d3a44dad..05dd46f984414 100644
+--- a/drivers/nvme/host/fabrics.c
++++ b/drivers/nvme/host/fabrics.c
+@@ -577,7 +577,6 @@ bool __nvmf_check_ready(struct nvme_ctrl *ctrl, struct request *rq,
+ 	 * which is require to set the queue live in the appropinquate states.
+ 	 */
+ 	switch (ctrl->state) {
+-	case NVME_CTRL_NEW:
+ 	case NVME_CTRL_CONNECTING:
+ 		if (req->cmd->common.opcode == nvme_fabrics_command &&
+ 		    req->cmd->fabrics.fctype == nvme_fabrics_type_connect)
+diff --git a/drivers/nvme/host/rdma.c b/drivers/nvme/host/rdma.c
+index f393a6193252e..7e2cdb17c26d8 100644
+--- a/drivers/nvme/host/rdma.c
++++ b/drivers/nvme/host/rdma.c
+@@ -118,6 +118,7 @@ struct nvme_rdma_ctrl {
+ 	struct sockaddr_storage src_addr;
+ 
+ 	struct nvme_ctrl	ctrl;
++	struct mutex		teardown_lock;
+ 	bool			use_inline_data;
+ };
+ 
+@@ -880,6 +881,7 @@ out_free_io_queues:
+ static void nvme_rdma_teardown_admin_queue(struct nvme_rdma_ctrl *ctrl,
+ 		bool remove)
+ {
++	mutex_lock(&ctrl->teardown_lock);
+ 	blk_mq_quiesce_queue(ctrl->ctrl.admin_q);
+ 	nvme_rdma_stop_queue(&ctrl->queues[0]);
+ 	if (ctrl->ctrl.admin_tagset)
+@@ -887,11 +889,13 @@ static void nvme_rdma_teardown_admin_queue(struct nvme_rdma_ctrl *ctrl,
+ 			nvme_cancel_request, &ctrl->ctrl);
+ 	blk_mq_unquiesce_queue(ctrl->ctrl.admin_q);
+ 	nvme_rdma_destroy_admin_queue(ctrl, remove);
++	mutex_unlock(&ctrl->teardown_lock);
+ }
+ 
+ static void nvme_rdma_teardown_io_queues(struct nvme_rdma_ctrl *ctrl,
+ 		bool remove)
+ {
++	mutex_lock(&ctrl->teardown_lock);
+ 	if (ctrl->ctrl.queue_count > 1) {
+ 		nvme_stop_queues(&ctrl->ctrl);
+ 		nvme_rdma_stop_io_queues(ctrl);
+@@ -902,6 +906,7 @@ static void nvme_rdma_teardown_io_queues(struct nvme_rdma_ctrl *ctrl,
+ 			nvme_start_queues(&ctrl->ctrl);
+ 		nvme_rdma_destroy_io_queues(ctrl, remove);
+ 	}
++	mutex_unlock(&ctrl->teardown_lock);
+ }
+ 
+ static void nvme_rdma_stop_ctrl(struct nvme_ctrl *nctrl)
+@@ -1955,6 +1960,7 @@ static struct nvme_ctrl *nvme_rdma_create_ctrl(struct device *dev,
+ 		return ERR_PTR(-ENOMEM);
+ 	ctrl->ctrl.opts = opts;
+ 	INIT_LIST_HEAD(&ctrl->list);
++	mutex_init(&ctrl->teardown_lock);
+ 
+ 	if (opts->mask & NVMF_OPT_TRSVCID)
+ 		port = opts->trsvcid;
+diff --git a/drivers/phy/qualcomm/phy-qcom-qmp.c b/drivers/phy/qualcomm/phy-qcom-qmp.c
+index cf515928fed09..68107611c70a2 100644
+--- a/drivers/phy/qualcomm/phy-qcom-qmp.c
++++ b/drivers/phy/qualcomm/phy-qcom-qmp.c
+@@ -311,8 +311,8 @@ static const struct qmp_phy_init_tbl ipq8074_pcie_serdes_tbl[] = {
+ 	QMP_PHY_INIT_CFG(QSERDES_COM_BG_TRIM, 0xf),
+ 	QMP_PHY_INIT_CFG(QSERDES_COM_LOCK_CMP_EN, 0x1),
+ 	QMP_PHY_INIT_CFG(QSERDES_COM_VCO_TUNE_MAP, 0x0),
+-	QMP_PHY_INIT_CFG(QSERDES_COM_VCO_TUNE_TIMER1, 0x1f),
+-	QMP_PHY_INIT_CFG(QSERDES_COM_VCO_TUNE_TIMER2, 0x3f),
++	QMP_PHY_INIT_CFG(QSERDES_COM_VCO_TUNE_TIMER1, 0xff),
++	QMP_PHY_INIT_CFG(QSERDES_COM_VCO_TUNE_TIMER2, 0x1f),
+ 	QMP_PHY_INIT_CFG(QSERDES_COM_CMN_CONFIG, 0x6),
+ 	QMP_PHY_INIT_CFG(QSERDES_COM_PLL_IVCO, 0xf),
+ 	QMP_PHY_INIT_CFG(QSERDES_COM_HSCLK_SEL, 0x0),
+@@ -338,7 +338,6 @@ static const struct qmp_phy_init_tbl ipq8074_pcie_serdes_tbl[] = {
+ 	QMP_PHY_INIT_CFG(QSERDES_COM_INTEGLOOP_GAIN1_MODE0, 0x0),
+ 	QMP_PHY_INIT_CFG(QSERDES_COM_INTEGLOOP_GAIN0_MODE0, 0x80),
+ 	QMP_PHY_INIT_CFG(QSERDES_COM_BIAS_EN_CTRL_BY_PSM, 0x1),
+-	QMP_PHY_INIT_CFG(QSERDES_COM_VCO_TUNE_CTRL, 0xa),
+ 	QMP_PHY_INIT_CFG(QSERDES_COM_SSC_EN_CENTER, 0x1),
+ 	QMP_PHY_INIT_CFG(QSERDES_COM_SSC_PER1, 0x31),
+ 	QMP_PHY_INIT_CFG(QSERDES_COM_SSC_PER2, 0x1),
+@@ -347,7 +346,6 @@ static const struct qmp_phy_init_tbl ipq8074_pcie_serdes_tbl[] = {
+ 	QMP_PHY_INIT_CFG(QSERDES_COM_SSC_STEP_SIZE1, 0x2f),
+ 	QMP_PHY_INIT_CFG(QSERDES_COM_SSC_STEP_SIZE2, 0x19),
+ 	QMP_PHY_INIT_CFG(QSERDES_COM_CLK_EP_DIV, 0x19),
+-	QMP_PHY_INIT_CFG(QSERDES_RX_SIGDET_CNTRL, 0x7),
+ };
+ 
+ static const struct qmp_phy_init_tbl ipq8074_pcie_tx_tbl[] = {
+@@ -355,6 +353,8 @@ static const struct qmp_phy_init_tbl ipq8074_pcie_tx_tbl[] = {
+ 	QMP_PHY_INIT_CFG(QSERDES_TX_LANE_MODE, 0x6),
+ 	QMP_PHY_INIT_CFG(QSERDES_TX_RES_CODE_LANE_OFFSET, 0x2),
+ 	QMP_PHY_INIT_CFG(QSERDES_TX_RCV_DETECT_LVL_2, 0x12),
++	QMP_PHY_INIT_CFG(QSERDES_TX_EMP_POST1_LVL, 0x36),
++	QMP_PHY_INIT_CFG(QSERDES_TX_SLEW_CNTL, 0x0a),
+ };
+ 
+ static const struct qmp_phy_init_tbl ipq8074_pcie_rx_tbl[] = {
+@@ -365,7 +365,6 @@ static const struct qmp_phy_init_tbl ipq8074_pcie_rx_tbl[] = {
+ 	QMP_PHY_INIT_CFG(QSERDES_RX_RX_EQU_ADAPTOR_CNTRL4, 0xdb),
+ 	QMP_PHY_INIT_CFG(QSERDES_RX_UCDR_SO_SATURATION_AND_ENABLE, 0x4b),
+ 	QMP_PHY_INIT_CFG(QSERDES_RX_UCDR_SO_GAIN, 0x4),
+-	QMP_PHY_INIT_CFG(QSERDES_RX_UCDR_SO_GAIN_HALF, 0x4),
+ };
+ 
+ static const struct qmp_phy_init_tbl ipq8074_pcie_pcs_tbl[] = {
+@@ -818,6 +817,9 @@ static const struct qmp_phy_cfg msm8996_usb3phy_cfg = {
+ 	.mask_pcs_ready		= PHYSTATUS,
+ };
+ 
++static const char * const ipq8074_pciephy_clk_l[] = {
++	"aux", "cfg_ahb",
++};
+ /* list of resets */
+ static const char * const ipq8074_pciephy_reset_l[] = {
+ 	"phy", "common",
+@@ -835,8 +837,8 @@ static const struct qmp_phy_cfg ipq8074_pciephy_cfg = {
+ 	.rx_tbl_num		= ARRAY_SIZE(ipq8074_pcie_rx_tbl),
+ 	.pcs_tbl		= ipq8074_pcie_pcs_tbl,
+ 	.pcs_tbl_num		= ARRAY_SIZE(ipq8074_pcie_pcs_tbl),
+-	.clk_list		= NULL,
+-	.num_clks		= 0,
++	.clk_list		= ipq8074_pciephy_clk_l,
++	.num_clks		= ARRAY_SIZE(ipq8074_pciephy_clk_l),
+ 	.reset_list		= ipq8074_pciephy_reset_l,
+ 	.num_resets		= ARRAY_SIZE(ipq8074_pciephy_reset_l),
+ 	.vreg_list		= NULL,
+diff --git a/drivers/phy/qualcomm/phy-qcom-qmp.h b/drivers/phy/qualcomm/phy-qcom-qmp.h
+index 5d78d43ba9fc5..6b3aaf521e588 100644
+--- a/drivers/phy/qualcomm/phy-qcom-qmp.h
++++ b/drivers/phy/qualcomm/phy-qcom-qmp.h
+@@ -77,6 +77,8 @@
+ #define QSERDES_COM_CORECLK_DIV_MODE1			0x1bc
+ 
+ /* Only for QMP V2 PHY - TX registers */
++#define QSERDES_TX_EMP_POST1_LVL			0x018
++#define QSERDES_TX_SLEW_CNTL				0x040
+ #define QSERDES_TX_RES_CODE_LANE_OFFSET			0x054
+ #define QSERDES_TX_DEBUG_BUS_SEL			0x064
+ #define QSERDES_TX_HIGHZ_TRANSCEIVEREN_BIAS_DRVR_EN	0x068
+diff --git a/drivers/regulator/core.c b/drivers/regulator/core.c
+index 4bab758d14b1a..37e6270749eef 100644
+--- a/drivers/regulator/core.c
++++ b/drivers/regulator/core.c
+@@ -1257,7 +1257,7 @@ static int set_consumer_device_supply(struct regulator_dev *rdev,
+ 				      const char *consumer_dev_name,
+ 				      const char *supply)
+ {
+-	struct regulator_map *node;
++	struct regulator_map *node, *new_node;
+ 	int has_dev;
+ 
+ 	if (supply == NULL)
+@@ -1268,6 +1268,22 @@ static int set_consumer_device_supply(struct regulator_dev *rdev,
+ 	else
+ 		has_dev = 0;
+ 
++	new_node = kzalloc(sizeof(struct regulator_map), GFP_KERNEL);
++	if (new_node == NULL)
++		return -ENOMEM;
++
++	new_node->regulator = rdev;
++	new_node->supply = supply;
++
++	if (has_dev) {
++		new_node->dev_name = kstrdup(consumer_dev_name, GFP_KERNEL);
++		if (new_node->dev_name == NULL) {
++			kfree(new_node);
++			return -ENOMEM;
++		}
++	}
++
++	mutex_lock(&regulator_list_mutex);
+ 	list_for_each_entry(node, &regulator_map_list, list) {
+ 		if (node->dev_name && consumer_dev_name) {
+ 			if (strcmp(node->dev_name, consumer_dev_name) != 0)
+@@ -1285,26 +1301,19 @@ static int set_consumer_device_supply(struct regulator_dev *rdev,
+ 			 node->regulator->desc->name,
+ 			 supply,
+ 			 dev_name(&rdev->dev), rdev_get_name(rdev));
+-		return -EBUSY;
++		goto fail;
+ 	}
+ 
+-	node = kzalloc(sizeof(struct regulator_map), GFP_KERNEL);
+-	if (node == NULL)
+-		return -ENOMEM;
+-
+-	node->regulator = rdev;
+-	node->supply = supply;
+-
+-	if (has_dev) {
+-		node->dev_name = kstrdup(consumer_dev_name, GFP_KERNEL);
+-		if (node->dev_name == NULL) {
+-			kfree(node);
+-			return -ENOMEM;
+-		}
+-	}
++	list_add(&new_node->list, &regulator_map_list);
++	mutex_unlock(&regulator_list_mutex);
+ 
+-	list_add(&node->list, &regulator_map_list);
+ 	return 0;
++
++fail:
++	mutex_unlock(&regulator_list_mutex);
++	kfree(new_node->dev_name);
++	kfree(new_node);
++	return -EBUSY;
+ }
+ 
+ static void unset_regulator_supplies(struct regulator_dev *rdev)
+@@ -4375,19 +4384,16 @@ regulator_register(const struct regulator_desc *regulator_desc,
+ 
+ 	/* add consumers devices */
+ 	if (init_data) {
+-		mutex_lock(&regulator_list_mutex);
+ 		for (i = 0; i < init_data->num_consumer_supplies; i++) {
+ 			ret = set_consumer_device_supply(rdev,
+ 				init_data->consumer_supplies[i].dev_name,
+ 				init_data->consumer_supplies[i].supply);
+ 			if (ret < 0) {
+-				mutex_unlock(&regulator_list_mutex);
+ 				dev_err(dev, "Failed to set supply %s\n",
+ 					init_data->consumer_supplies[i].supply);
+ 				goto unset_supplies;
+ 			}
+ 		}
+-		mutex_unlock(&regulator_list_mutex);
+ 	}
+ 
+ 	if (!rdev->desc->ops->get_voltage &&
+diff --git a/drivers/scsi/libsas/sas_ata.c b/drivers/scsi/libsas/sas_ata.c
+index 64a958a99f6a8..d82698b7dfe6c 100644
+--- a/drivers/scsi/libsas/sas_ata.c
++++ b/drivers/scsi/libsas/sas_ata.c
+@@ -223,7 +223,10 @@ static unsigned int sas_ata_qc_issue(struct ata_queued_cmd *qc)
+ 		task->num_scatter = si;
+ 	}
+ 
+-	task->data_dir = qc->dma_dir;
++	if (qc->tf.protocol == ATA_PROT_NODATA)
++		task->data_dir = DMA_NONE;
++	else
++		task->data_dir = qc->dma_dir;
+ 	task->scatter = qc->sg;
+ 	task->ata_task.retry_count = 1;
+ 	task->task_state_flags = SAS_TASK_STATE_PENDING;
+diff --git a/drivers/staging/greybus/audio_topology.c b/drivers/staging/greybus/audio_topology.c
+index b71078339e860..860247d718184 100644
+--- a/drivers/staging/greybus/audio_topology.c
++++ b/drivers/staging/greybus/audio_topology.c
+@@ -460,6 +460,15 @@ static int gbcodec_mixer_dapm_ctl_put(struct snd_kcontrol *kcontrol,
+ 	val = ucontrol->value.integer.value[0] & mask;
+ 	connect = !!val;
+ 
++	ret = gb_pm_runtime_get_sync(bundle);
++	if (ret)
++		return ret;
++
++	ret = gb_audio_gb_get_control(module->mgmt_connection, data->ctl_id,
++				      GB_AUDIO_INVALID_INDEX, &gbvalue);
++	if (ret)
++		goto exit;
++
+ 	/* update ucontrol */
+ 	if (gbvalue.value.integer_value[0] != val) {
+ 		for (wi = 0; wi < wlist->num_widgets; wi++) {
+@@ -473,25 +482,17 @@ static int gbcodec_mixer_dapm_ctl_put(struct snd_kcontrol *kcontrol,
+ 		gbvalue.value.integer_value[0] =
+ 			cpu_to_le32(ucontrol->value.integer.value[0]);
+ 
+-		ret = gb_pm_runtime_get_sync(bundle);
+-		if (ret)
+-			return ret;
+-
+ 		ret = gb_audio_gb_set_control(module->mgmt_connection,
+ 					      data->ctl_id,
+ 					      GB_AUDIO_INVALID_INDEX, &gbvalue);
+-
+-		gb_pm_runtime_put_autosuspend(bundle);
+-
+-		if (ret) {
+-			dev_err_ratelimited(codec->dev,
+-					    "%d:Error in %s for %s\n", ret,
+-					    __func__, kcontrol->id.name);
+-			return ret;
+-		}
+ 	}
+ 
+-	return 0;
++exit:
++	gb_pm_runtime_put_autosuspend(bundle);
++	if (ret)
++		dev_err_ratelimited(codec_dev, "%d:Error in %s for %s\n", ret,
++				    __func__, kcontrol->id.name);
++	return ret;
+ }
+ 
+ #define SOC_DAPM_MIXER_GB(xname, kcount, data) \
+diff --git a/drivers/staging/wlan-ng/hfa384x_usb.c b/drivers/staging/wlan-ng/hfa384x_usb.c
+index 65ad9773018ee..7686805dfe0f2 100644
+--- a/drivers/staging/wlan-ng/hfa384x_usb.c
++++ b/drivers/staging/wlan-ng/hfa384x_usb.c
+@@ -532,13 +532,8 @@ static void hfa384x_usb_defer(struct work_struct *data)
+  */
+ void hfa384x_create(struct hfa384x *hw, struct usb_device *usb)
+ {
+-	memset(hw, 0, sizeof(*hw));
+ 	hw->usb = usb;
+ 
+-	/* set up the endpoints */
+-	hw->endp_in = usb_rcvbulkpipe(usb, 1);
+-	hw->endp_out = usb_sndbulkpipe(usb, 2);
+-
+ 	/* Set up the waitq */
+ 	init_waitqueue_head(&hw->cmdq);
+ 
+diff --git a/drivers/staging/wlan-ng/prism2usb.c b/drivers/staging/wlan-ng/prism2usb.c
+index 8d32b1603d10a..9eee72aff7233 100644
+--- a/drivers/staging/wlan-ng/prism2usb.c
++++ b/drivers/staging/wlan-ng/prism2usb.c
+@@ -61,23 +61,14 @@ static int prism2sta_probe_usb(struct usb_interface *interface,
+ 			       const struct usb_device_id *id)
+ {
+ 	struct usb_device *dev;
+-	const struct usb_endpoint_descriptor *epd;
+-	const struct usb_host_interface *iface_desc = interface->cur_altsetting;
++	struct usb_endpoint_descriptor *bulk_in, *bulk_out;
++	struct usb_host_interface *iface_desc = interface->cur_altsetting;
+ 	struct wlandevice *wlandev = NULL;
+ 	struct hfa384x *hw = NULL;
+ 	int result = 0;
+ 
+-	if (iface_desc->desc.bNumEndpoints != 2) {
+-		result = -ENODEV;
+-		goto failed;
+-	}
+-
+-	result = -EINVAL;
+-	epd = &iface_desc->endpoint[1].desc;
+-	if (!usb_endpoint_is_bulk_in(epd))
+-		goto failed;
+-	epd = &iface_desc->endpoint[2].desc;
+-	if (!usb_endpoint_is_bulk_out(epd))
++	result = usb_find_common_endpoints(iface_desc, &bulk_in, &bulk_out, NULL, NULL);
++	if (result)
+ 		goto failed;
+ 
+ 	dev = interface_to_usbdev(interface);
+@@ -96,6 +87,8 @@ static int prism2sta_probe_usb(struct usb_interface *interface,
+ 	}
+ 
+ 	/* Initialize the hw data */
++	hw->endp_in = usb_rcvbulkpipe(dev, bulk_in->bEndpointAddress);
++	hw->endp_out = usb_sndbulkpipe(dev, bulk_out->bEndpointAddress);
+ 	hfa384x_create(hw, dev);
+ 	hw->wlandev = wlandev;
+ 
+diff --git a/drivers/target/iscsi/iscsi_target.c b/drivers/target/iscsi/iscsi_target.c
+index 1633e26662687..2602b57936d4b 100644
+--- a/drivers/target/iscsi/iscsi_target.c
++++ b/drivers/target/iscsi/iscsi_target.c
+@@ -1381,14 +1381,27 @@ static u32 iscsit_do_crypto_hash_sg(
+ 	sg = cmd->first_data_sg;
+ 	page_off = cmd->first_data_sg_off;
+ 
++	if (data_length && page_off) {
++		struct scatterlist first_sg;
++		u32 len = min_t(u32, data_length, sg->length - page_off);
++
++		sg_init_table(&first_sg, 1);
++		sg_set_page(&first_sg, sg_page(sg), len, sg->offset + page_off);
++
++		ahash_request_set_crypt(hash, &first_sg, NULL, len);
++		crypto_ahash_update(hash);
++
++		data_length -= len;
++		sg = sg_next(sg);
++	}
++
+ 	while (data_length) {
+-		u32 cur_len = min_t(u32, data_length, (sg->length - page_off));
++		u32 cur_len = min_t(u32, data_length, sg->length);
+ 
+ 		ahash_request_set_crypt(hash, sg, NULL, cur_len);
+ 		crypto_ahash_update(hash);
+ 
+ 		data_length -= cur_len;
+-		page_off = 0;
+ 		/* iscsit_map_iovec has already checked for invalid sg pointers */
+ 		sg = sg_next(sg);
+ 	}
+diff --git a/drivers/target/iscsi/iscsi_target_login.c b/drivers/target/iscsi/iscsi_target_login.c
+index f25049ba4a85b..db93bd0a9b886 100644
+--- a/drivers/target/iscsi/iscsi_target_login.c
++++ b/drivers/target/iscsi/iscsi_target_login.c
+@@ -1183,7 +1183,7 @@ void iscsit_free_conn(struct iscsi_conn *conn)
+ }
+ 
+ void iscsi_target_login_sess_out(struct iscsi_conn *conn,
+-		struct iscsi_np *np, bool zero_tsih, bool new_sess)
++				 bool zero_tsih, bool new_sess)
+ {
+ 	if (!new_sess)
+ 		goto old_sess_out;
+@@ -1201,7 +1201,6 @@ void iscsi_target_login_sess_out(struct iscsi_conn *conn,
+ 	conn->sess = NULL;
+ 
+ old_sess_out:
+-	iscsi_stop_login_thread_timer(np);
+ 	/*
+ 	 * If login negotiation fails check if the Time2Retain timer
+ 	 * needs to be restarted.
+@@ -1441,8 +1440,9 @@ static int __iscsi_target_login_thread(struct iscsi_np *np)
+ new_sess_out:
+ 	new_sess = true;
+ old_sess_out:
++	iscsi_stop_login_thread_timer(np);
+ 	tpg_np = conn->tpg_np;
+-	iscsi_target_login_sess_out(conn, np, zero_tsih, new_sess);
++	iscsi_target_login_sess_out(conn, zero_tsih, new_sess);
+ 	new_sess = false;
+ 
+ 	if (tpg) {
+diff --git a/drivers/target/iscsi/iscsi_target_login.h b/drivers/target/iscsi/iscsi_target_login.h
+index 3b8e3639ff5d0..fc95e6150253f 100644
+--- a/drivers/target/iscsi/iscsi_target_login.h
++++ b/drivers/target/iscsi/iscsi_target_login.h
+@@ -22,8 +22,7 @@ extern int iscsit_put_login_tx(struct iscsi_conn *, struct iscsi_login *, u32);
+ extern void iscsit_free_conn(struct iscsi_conn *);
+ extern int iscsit_start_kthreads(struct iscsi_conn *);
+ extern void iscsi_post_login_handler(struct iscsi_np *, struct iscsi_conn *, u8);
+-extern void iscsi_target_login_sess_out(struct iscsi_conn *, struct iscsi_np *,
+-				bool, bool);
++extern void iscsi_target_login_sess_out(struct iscsi_conn *, bool, bool);
+ extern int iscsi_target_login_thread(void *);
+ extern void iscsi_handle_login_thread_timeout(struct timer_list *t);
+ 
+diff --git a/drivers/target/iscsi/iscsi_target_nego.c b/drivers/target/iscsi/iscsi_target_nego.c
+index 8a5e8d17a9426..5db8842a80265 100644
+--- a/drivers/target/iscsi/iscsi_target_nego.c
++++ b/drivers/target/iscsi/iscsi_target_nego.c
+@@ -554,12 +554,11 @@ static bool iscsi_target_sk_check_and_clear(struct iscsi_conn *conn, unsigned in
+ 
+ static void iscsi_target_login_drop(struct iscsi_conn *conn, struct iscsi_login *login)
+ {
+-	struct iscsi_np *np = login->np;
+ 	bool zero_tsih = login->zero_tsih;
+ 
+ 	iscsi_remove_failed_auth_entry(conn);
+ 	iscsi_target_nego_release(conn);
+-	iscsi_target_login_sess_out(conn, np, zero_tsih, true);
++	iscsi_target_login_sess_out(conn, zero_tsih, true);
+ }
+ 
+ struct conn_timeout {
+diff --git a/drivers/usb/core/message.c b/drivers/usb/core/message.c
+index f705ea52eb973..152228d33ad20 100644
+--- a/drivers/usb/core/message.c
++++ b/drivers/usb/core/message.c
+@@ -1204,6 +1204,34 @@ void usb_disable_interface(struct usb_device *dev, struct usb_interface *intf,
+ 	}
+ }
+ 
++/*
++ * usb_disable_device_endpoints -- Disable all endpoints for a device
++ * @dev: the device whose endpoints are being disabled
++ * @skip_ep0: 0 to disable endpoint 0, 1 to skip it.
++ */
++static void usb_disable_device_endpoints(struct usb_device *dev, int skip_ep0)
++{
++	struct usb_hcd *hcd = bus_to_hcd(dev->bus);
++	int i;
++
++	if (hcd->driver->check_bandwidth) {
++		/* First pass: Cancel URBs, leave endpoint pointers intact. */
++		for (i = skip_ep0; i < 16; ++i) {
++			usb_disable_endpoint(dev, i, false);
++			usb_disable_endpoint(dev, i + USB_DIR_IN, false);
++		}
++		/* Remove endpoints from the host controller internal state */
++		mutex_lock(hcd->bandwidth_mutex);
++		usb_hcd_alloc_bandwidth(dev, NULL, NULL, NULL);
++		mutex_unlock(hcd->bandwidth_mutex);
++	}
++	/* Second pass: remove endpoint pointers */
++	for (i = skip_ep0; i < 16; ++i) {
++		usb_disable_endpoint(dev, i, true);
++		usb_disable_endpoint(dev, i + USB_DIR_IN, true);
++	}
++}
++
+ /**
+  * usb_disable_device - Disable all the endpoints for a USB device
+  * @dev: the device whose endpoints are being disabled
+@@ -1217,7 +1245,6 @@ void usb_disable_interface(struct usb_device *dev, struct usb_interface *intf,
+ void usb_disable_device(struct usb_device *dev, int skip_ep0)
+ {
+ 	int i;
+-	struct usb_hcd *hcd = bus_to_hcd(dev->bus);
+ 
+ 	/* getting rid of interfaces will disconnect
+ 	 * any drivers bound to them (a key side effect)
+@@ -1263,22 +1290,8 @@ void usb_disable_device(struct usb_device *dev, int skip_ep0)
+ 
+ 	dev_dbg(&dev->dev, "%s nuking %s URBs\n", __func__,
+ 		skip_ep0 ? "non-ep0" : "all");
+-	if (hcd->driver->check_bandwidth) {
+-		/* First pass: Cancel URBs, leave endpoint pointers intact. */
+-		for (i = skip_ep0; i < 16; ++i) {
+-			usb_disable_endpoint(dev, i, false);
+-			usb_disable_endpoint(dev, i + USB_DIR_IN, false);
+-		}
+-		/* Remove endpoints from the host controller internal state */
+-		mutex_lock(hcd->bandwidth_mutex);
+-		usb_hcd_alloc_bandwidth(dev, NULL, NULL, NULL);
+-		mutex_unlock(hcd->bandwidth_mutex);
+-		/* Second pass: remove endpoint pointers */
+-	}
+-	for (i = skip_ep0; i < 16; ++i) {
+-		usb_disable_endpoint(dev, i, true);
+-		usb_disable_endpoint(dev, i + USB_DIR_IN, true);
+-	}
++
++	usb_disable_device_endpoints(dev, skip_ep0);
+ }
+ 
+ /**
+@@ -1521,6 +1534,9 @@ EXPORT_SYMBOL_GPL(usb_set_interface);
+  * The caller must own the device lock.
+  *
+  * Return: Zero on success, else a negative error code.
++ *
++ * If this routine fails the device will probably be in an unusable state
++ * with endpoints disabled, and interfaces only partially enabled.
+  */
+ int usb_reset_configuration(struct usb_device *dev)
+ {
+@@ -1536,10 +1552,7 @@ int usb_reset_configuration(struct usb_device *dev)
+ 	 * calls during probe() are fine
+ 	 */
+ 
+-	for (i = 1; i < 16; ++i) {
+-		usb_disable_endpoint(dev, i, true);
+-		usb_disable_endpoint(dev, i + USB_DIR_IN, true);
+-	}
++	usb_disable_device_endpoints(dev, 1); /* skip ep0*/
+ 
+ 	config = dev->actconfig;
+ 	retval = 0;
+@@ -1552,34 +1565,10 @@ int usb_reset_configuration(struct usb_device *dev)
+ 		mutex_unlock(hcd->bandwidth_mutex);
+ 		return -ENOMEM;
+ 	}
+-	/* Make sure we have enough bandwidth for each alternate setting 0 */
+-	for (i = 0; i < config->desc.bNumInterfaces; i++) {
+-		struct usb_interface *intf = config->interface[i];
+-		struct usb_host_interface *alt;
+ 
+-		alt = usb_altnum_to_altsetting(intf, 0);
+-		if (!alt)
+-			alt = &intf->altsetting[0];
+-		if (alt != intf->cur_altsetting)
+-			retval = usb_hcd_alloc_bandwidth(dev, NULL,
+-					intf->cur_altsetting, alt);
+-		if (retval < 0)
+-			break;
+-	}
+-	/* If not, reinstate the old alternate settings */
++	/* xHCI adds all endpoints in usb_hcd_alloc_bandwidth */
++	retval = usb_hcd_alloc_bandwidth(dev, config, NULL, NULL);
+ 	if (retval < 0) {
+-reset_old_alts:
+-		for (i--; i >= 0; i--) {
+-			struct usb_interface *intf = config->interface[i];
+-			struct usb_host_interface *alt;
+-
+-			alt = usb_altnum_to_altsetting(intf, 0);
+-			if (!alt)
+-				alt = &intf->altsetting[0];
+-			if (alt != intf->cur_altsetting)
+-				usb_hcd_alloc_bandwidth(dev, NULL,
+-						alt, intf->cur_altsetting);
+-		}
+ 		usb_enable_lpm(dev);
+ 		mutex_unlock(hcd->bandwidth_mutex);
+ 		return retval;
+@@ -1588,8 +1577,12 @@ reset_old_alts:
+ 			USB_REQ_SET_CONFIGURATION, 0,
+ 			config->desc.bConfigurationValue, 0,
+ 			NULL, 0, USB_CTRL_SET_TIMEOUT);
+-	if (retval < 0)
+-		goto reset_old_alts;
++	if (retval < 0) {
++		usb_hcd_alloc_bandwidth(dev, NULL, NULL, NULL);
++		usb_enable_lpm(dev);
++		mutex_unlock(hcd->bandwidth_mutex);
++		return retval;
++	}
+ 	mutex_unlock(hcd->bandwidth_mutex);
+ 
+ 	/* re-init hc/hcd interface/endpoint state */
+diff --git a/drivers/usb/core/sysfs.c b/drivers/usb/core/sysfs.c
+index 7e88fdfe3cf5c..b93b18ba89df6 100644
+--- a/drivers/usb/core/sysfs.c
++++ b/drivers/usb/core/sysfs.c
+@@ -888,7 +888,11 @@ read_descriptors(struct file *filp, struct kobject *kobj,
+ 	size_t srclen, n;
+ 	int cfgno;
+ 	void *src;
++	int retval;
+ 
++	retval = usb_lock_device_interruptible(udev);
++	if (retval < 0)
++		return -EINTR;
+ 	/* The binary attribute begins with the device descriptor.
+ 	 * Following that are the raw descriptor entries for all the
+ 	 * configurations (config plus subsidiary descriptors).
+@@ -913,6 +917,7 @@ read_descriptors(struct file *filp, struct kobject *kobj,
+ 			off -= srclen;
+ 		}
+ 	}
++	usb_unlock_device(udev);
+ 	return count - nleft;
+ }
+ 
+diff --git a/drivers/usb/serial/ftdi_sio.c b/drivers/usb/serial/ftdi_sio.c
+index ce9cc1f90b052..f0f630e1cf1c9 100644
+--- a/drivers/usb/serial/ftdi_sio.c
++++ b/drivers/usb/serial/ftdi_sio.c
+@@ -703,6 +703,7 @@ static const struct usb_device_id id_table_combined[] = {
+ 	{ USB_DEVICE(XSENS_VID, XSENS_AWINDA_STATION_PID) },
+ 	{ USB_DEVICE(XSENS_VID, XSENS_CONVERTER_PID) },
+ 	{ USB_DEVICE(XSENS_VID, XSENS_MTDEVBOARD_PID) },
++	{ USB_DEVICE(XSENS_VID, XSENS_MTIUSBCONVERTER_PID) },
+ 	{ USB_DEVICE(XSENS_VID, XSENS_MTW_PID) },
+ 	{ USB_DEVICE(FTDI_VID, FTDI_OMNI1509) },
+ 	{ USB_DEVICE(MOBILITY_VID, MOBILITY_USB_SERIAL_PID) },
+diff --git a/drivers/usb/serial/ftdi_sio_ids.h b/drivers/usb/serial/ftdi_sio_ids.h
+index e8373528264c3..b5ca17a5967a0 100644
+--- a/drivers/usb/serial/ftdi_sio_ids.h
++++ b/drivers/usb/serial/ftdi_sio_ids.h
+@@ -160,6 +160,7 @@
+ #define XSENS_AWINDA_DONGLE_PID 0x0102
+ #define XSENS_MTW_PID		0x0200	/* Xsens MTw */
+ #define XSENS_MTDEVBOARD_PID	0x0300	/* Motion Tracker Development Board */
++#define XSENS_MTIUSBCONVERTER_PID	0x0301	/* MTi USB converter */
+ #define XSENS_CONVERTER_PID	0xD00D	/* Xsens USB-serial converter */
+ 
+ /* Xsens devices using FTDI VID */
+diff --git a/drivers/usb/serial/option.c b/drivers/usb/serial/option.c
+index 6e44aaafdcb10..810f1010ab132 100644
+--- a/drivers/usb/serial/option.c
++++ b/drivers/usb/serial/option.c
+@@ -1094,14 +1094,18 @@ static const struct usb_device_id option_ids[] = {
+ 	{ USB_DEVICE(QUALCOMM_VENDOR_ID, UBLOX_PRODUCT_R410M),
+ 	  .driver_info = RSVD(1) | RSVD(3) },
+ 	/* Quectel products using Quectel vendor ID */
+-	{ USB_DEVICE(QUECTEL_VENDOR_ID, QUECTEL_PRODUCT_EC21),
+-	  .driver_info = RSVD(4) },
+-	{ USB_DEVICE(QUECTEL_VENDOR_ID, QUECTEL_PRODUCT_EC25),
+-	  .driver_info = RSVD(4) },
+-	{ USB_DEVICE(QUECTEL_VENDOR_ID, QUECTEL_PRODUCT_EG95),
+-	  .driver_info = RSVD(4) },
+-	{ USB_DEVICE(QUECTEL_VENDOR_ID, QUECTEL_PRODUCT_BG96),
+-	  .driver_info = RSVD(4) },
++	{ USB_DEVICE_AND_INTERFACE_INFO(QUECTEL_VENDOR_ID, QUECTEL_PRODUCT_EC21, 0xff, 0xff, 0xff),
++	  .driver_info = NUMEP2 },
++	{ USB_DEVICE_AND_INTERFACE_INFO(QUECTEL_VENDOR_ID, QUECTEL_PRODUCT_EC21, 0xff, 0, 0) },
++	{ USB_DEVICE_AND_INTERFACE_INFO(QUECTEL_VENDOR_ID, QUECTEL_PRODUCT_EC25, 0xff, 0xff, 0xff),
++	  .driver_info = NUMEP2 },
++	{ USB_DEVICE_AND_INTERFACE_INFO(QUECTEL_VENDOR_ID, QUECTEL_PRODUCT_EC25, 0xff, 0, 0) },
++	{ USB_DEVICE_AND_INTERFACE_INFO(QUECTEL_VENDOR_ID, QUECTEL_PRODUCT_EG95, 0xff, 0xff, 0xff),
++	  .driver_info = NUMEP2 },
++	{ USB_DEVICE_AND_INTERFACE_INFO(QUECTEL_VENDOR_ID, QUECTEL_PRODUCT_EG95, 0xff, 0, 0) },
++	{ USB_DEVICE_AND_INTERFACE_INFO(QUECTEL_VENDOR_ID, QUECTEL_PRODUCT_BG96, 0xff, 0xff, 0xff),
++	  .driver_info = NUMEP2 },
++	{ USB_DEVICE_AND_INTERFACE_INFO(QUECTEL_VENDOR_ID, QUECTEL_PRODUCT_BG96, 0xff, 0, 0) },
+ 	{ USB_DEVICE_AND_INTERFACE_INFO(QUECTEL_VENDOR_ID, QUECTEL_PRODUCT_EP06, 0xff, 0xff, 0xff),
+ 	  .driver_info = RSVD(1) | RSVD(2) | RSVD(3) | RSVD(4) | NUMEP2 },
+ 	{ USB_DEVICE_AND_INTERFACE_INFO(QUECTEL_VENDOR_ID, QUECTEL_PRODUCT_EP06, 0xff, 0, 0) },
+@@ -1819,6 +1823,8 @@ static const struct usb_device_id option_ids[] = {
+ 	{ USB_DEVICE_INTERFACE_CLASS(0x1e0e, 0x9003, 0xff) },	/* Simcom SIM7500/SIM7600 MBIM mode */
+ 	{ USB_DEVICE_INTERFACE_CLASS(0x1e0e, 0x9011, 0xff),	/* Simcom SIM7500/SIM7600 RNDIS mode */
+ 	  .driver_info = RSVD(7) },
++	{ USB_DEVICE_INTERFACE_CLASS(0x1e0e, 0x9205, 0xff) },	/* Simcom SIM7070/SIM7080/SIM7090 AT+ECM mode */
++	{ USB_DEVICE_INTERFACE_CLASS(0x1e0e, 0x9206, 0xff) },	/* Simcom SIM7070/SIM7080/SIM7090 AT-only mode */
+ 	{ USB_DEVICE(ALCATEL_VENDOR_ID, ALCATEL_PRODUCT_X060S_X200),
+ 	  .driver_info = NCTRL(0) | NCTRL(1) | RSVD(4) },
+ 	{ USB_DEVICE(ALCATEL_VENDOR_ID, ALCATEL_PRODUCT_X220_X500D),
+diff --git a/drivers/usb/typec/ucsi/ucsi_acpi.c b/drivers/usb/typec/ucsi/ucsi_acpi.c
+index a18112a83faed..dda8bd39c9186 100644
+--- a/drivers/usb/typec/ucsi/ucsi_acpi.c
++++ b/drivers/usb/typec/ucsi/ucsi_acpi.c
+@@ -64,11 +64,15 @@ static void ucsi_acpi_notify(acpi_handle handle, u32 event, void *data)
+ 
+ static int ucsi_acpi_probe(struct platform_device *pdev)
+ {
++	struct acpi_device *adev = ACPI_COMPANION(&pdev->dev);
+ 	struct ucsi_acpi *ua;
+ 	struct resource *res;
+ 	acpi_status status;
+ 	int ret;
+ 
++	if (adev->dep_unmet)
++		return -EPROBE_DEFER;
++
+ 	ua = devm_kzalloc(&pdev->dev, sizeof(*ua), GFP_KERNEL);
+ 	if (!ua)
+ 		return -ENOMEM;
+diff --git a/drivers/video/console/Kconfig b/drivers/video/console/Kconfig
+index 787792c3d08d6..40d5fea8513cf 100644
+--- a/drivers/video/console/Kconfig
++++ b/drivers/video/console/Kconfig
+@@ -21,52 +21,6 @@ config VGA_CONSOLE
+ 
+ 	  Say Y.
+ 
+-config VGACON_SOFT_SCROLLBACK
+-       bool "Enable Scrollback Buffer in System RAM"
+-       depends on VGA_CONSOLE
+-       default n
+-       help
+-         The scrollback buffer of the standard VGA console is located in
+-	 the VGA RAM.  The size of this RAM is fixed and is quite small.
+-	 If you require a larger scrollback buffer, this can be placed in
+-	 System RAM which is dynamically allocated during initialization.
+-	 Placing the scrollback buffer in System RAM will slightly slow
+-	 down the console.
+-
+-	 If you want this feature, say 'Y' here and enter the amount of
+-	 RAM to allocate for this buffer.  If unsure, say 'N'.
+-
+-config VGACON_SOFT_SCROLLBACK_SIZE
+-       int "Scrollback Buffer Size (in KB)"
+-       depends on VGACON_SOFT_SCROLLBACK
+-       range 1 1024
+-       default "64"
+-       help
+-	  Enter the amount of System RAM to allocate for scrollback
+-	  buffers of VGA consoles. Each 64KB will give you approximately
+-	  16 80x25 screenfuls of scrollback buffer.
+-
+-config VGACON_SOFT_SCROLLBACK_PERSISTENT_ENABLE_BY_DEFAULT
+-	bool "Persistent Scrollback History for each console by default"
+-	depends on VGACON_SOFT_SCROLLBACK
+-	default n
+-	help
+-	  Say Y here if the scrollback history should persist by default when
+-	  switching between consoles. Otherwise, the scrollback history will be
+-	  flushed each time the console is switched. This feature can also be
+-	  enabled using the boot command line parameter
+-	  'vgacon.scrollback_persistent=1'.
+-
+-	  This feature might break your tool of choice to flush the scrollback
+-	  buffer, e.g. clear(1) will work fine but Debian's clear_console(1)
+-	  will be broken, which might cause security issues.
+-	  You can use the escape sequence \e[3J instead if this feature is
+-	  activated.
+-
+-	  Note that a buffer of VGACON_SOFT_SCROLLBACK_SIZE is taken for each
+-	  created tty device.
+-	  So if you use a RAM-constrained system, say N here.
+-
+ config MDA_CONSOLE
+ 	depends on !M68K && !PARISC && ISA
+ 	tristate "MDA text console (dual-headed)"
+diff --git a/drivers/video/console/vgacon.c b/drivers/video/console/vgacon.c
+index e079b910feb24..55507df335bdd 100644
+--- a/drivers/video/console/vgacon.c
++++ b/drivers/video/console/vgacon.c
+@@ -165,214 +165,6 @@ static inline void vga_set_mem_top(struct vc_data *c)
+ 	write_vga(12, (c->vc_visible_origin - vga_vram_base) / 2);
+ }
+ 
+-#ifdef CONFIG_VGACON_SOFT_SCROLLBACK
+-/* software scrollback */
+-struct vgacon_scrollback_info {
+-	void *data;
+-	int tail;
+-	int size;
+-	int rows;
+-	int cnt;
+-	int cur;
+-	int save;
+-	int restore;
+-};
+-
+-static struct vgacon_scrollback_info *vgacon_scrollback_cur;
+-static struct vgacon_scrollback_info vgacon_scrollbacks[MAX_NR_CONSOLES];
+-static bool scrollback_persistent = \
+-	IS_ENABLED(CONFIG_VGACON_SOFT_SCROLLBACK_PERSISTENT_ENABLE_BY_DEFAULT);
+-module_param_named(scrollback_persistent, scrollback_persistent, bool, 0000);
+-MODULE_PARM_DESC(scrollback_persistent, "Enable persistent scrollback for all vga consoles");
+-
+-static void vgacon_scrollback_reset(int vc_num, size_t reset_size)
+-{
+-	struct vgacon_scrollback_info *scrollback = &vgacon_scrollbacks[vc_num];
+-
+-	if (scrollback->data && reset_size > 0)
+-		memset(scrollback->data, 0, reset_size);
+-
+-	scrollback->cnt  = 0;
+-	scrollback->tail = 0;
+-	scrollback->cur  = 0;
+-}
+-
+-static void vgacon_scrollback_init(int vc_num)
+-{
+-	int pitch = vga_video_num_columns * 2;
+-	size_t size = CONFIG_VGACON_SOFT_SCROLLBACK_SIZE * 1024;
+-	int rows = size / pitch;
+-	void *data;
+-
+-	data = kmalloc_array(CONFIG_VGACON_SOFT_SCROLLBACK_SIZE, 1024,
+-			     GFP_NOWAIT);
+-
+-	vgacon_scrollbacks[vc_num].data = data;
+-	vgacon_scrollback_cur = &vgacon_scrollbacks[vc_num];
+-
+-	vgacon_scrollback_cur->rows = rows - 1;
+-	vgacon_scrollback_cur->size = rows * pitch;
+-
+-	vgacon_scrollback_reset(vc_num, size);
+-}
+-
+-static void vgacon_scrollback_switch(int vc_num)
+-{
+-	if (!scrollback_persistent)
+-		vc_num = 0;
+-
+-	if (!vgacon_scrollbacks[vc_num].data) {
+-		vgacon_scrollback_init(vc_num);
+-	} else {
+-		if (scrollback_persistent) {
+-			vgacon_scrollback_cur = &vgacon_scrollbacks[vc_num];
+-		} else {
+-			size_t size = CONFIG_VGACON_SOFT_SCROLLBACK_SIZE * 1024;
+-
+-			vgacon_scrollback_reset(vc_num, size);
+-		}
+-	}
+-}
+-
+-static void vgacon_scrollback_startup(void)
+-{
+-	vgacon_scrollback_cur = &vgacon_scrollbacks[0];
+-	vgacon_scrollback_init(0);
+-}
+-
+-static void vgacon_scrollback_update(struct vc_data *c, int t, int count)
+-{
+-	void *p;
+-
+-	if (!vgacon_scrollback_cur->data || !vgacon_scrollback_cur->size ||
+-	    c->vc_num != fg_console)
+-		return;
+-
+-	p = (void *) (c->vc_origin + t * c->vc_size_row);
+-
+-	while (count--) {
+-		if ((vgacon_scrollback_cur->tail + c->vc_size_row) >
+-		    vgacon_scrollback_cur->size)
+-			vgacon_scrollback_cur->tail = 0;
+-
+-		scr_memcpyw(vgacon_scrollback_cur->data +
+-			    vgacon_scrollback_cur->tail,
+-			    p, c->vc_size_row);
+-
+-		vgacon_scrollback_cur->cnt++;
+-		p += c->vc_size_row;
+-		vgacon_scrollback_cur->tail += c->vc_size_row;
+-
+-		if (vgacon_scrollback_cur->tail >= vgacon_scrollback_cur->size)
+-			vgacon_scrollback_cur->tail = 0;
+-
+-		if (vgacon_scrollback_cur->cnt > vgacon_scrollback_cur->rows)
+-			vgacon_scrollback_cur->cnt = vgacon_scrollback_cur->rows;
+-
+-		vgacon_scrollback_cur->cur = vgacon_scrollback_cur->cnt;
+-	}
+-}
+-
+-static void vgacon_restore_screen(struct vc_data *c)
+-{
+-	c->vc_origin = c->vc_visible_origin;
+-	vgacon_scrollback_cur->save = 0;
+-
+-	if (!vga_is_gfx && !vgacon_scrollback_cur->restore) {
+-		scr_memcpyw((u16 *) c->vc_origin, (u16 *) c->vc_screenbuf,
+-			    c->vc_screenbuf_size > vga_vram_size ?
+-			    vga_vram_size : c->vc_screenbuf_size);
+-		vgacon_scrollback_cur->restore = 1;
+-		vgacon_scrollback_cur->cur = vgacon_scrollback_cur->cnt;
+-	}
+-}
+-
+-static void vgacon_scrolldelta(struct vc_data *c, int lines)
+-{
+-	int start, end, count, soff;
+-
+-	if (!lines) {
+-		vgacon_restore_screen(c);
+-		return;
+-	}
+-
+-	if (!vgacon_scrollback_cur->data)
+-		return;
+-
+-	if (!vgacon_scrollback_cur->save) {
+-		vgacon_cursor(c, CM_ERASE);
+-		vgacon_save_screen(c);
+-		c->vc_origin = (unsigned long)c->vc_screenbuf;
+-		vgacon_scrollback_cur->save = 1;
+-	}
+-
+-	vgacon_scrollback_cur->restore = 0;
+-	start = vgacon_scrollback_cur->cur + lines;
+-	end = start + abs(lines);
+-
+-	if (start < 0)
+-		start = 0;
+-
+-	if (start > vgacon_scrollback_cur->cnt)
+-		start = vgacon_scrollback_cur->cnt;
+-
+-	if (end < 0)
+-		end = 0;
+-
+-	if (end > vgacon_scrollback_cur->cnt)
+-		end = vgacon_scrollback_cur->cnt;
+-
+-	vgacon_scrollback_cur->cur = start;
+-	count = end - start;
+-	soff = vgacon_scrollback_cur->tail -
+-		((vgacon_scrollback_cur->cnt - end) * c->vc_size_row);
+-	soff -= count * c->vc_size_row;
+-
+-	if (soff < 0)
+-		soff += vgacon_scrollback_cur->size;
+-
+-	count = vgacon_scrollback_cur->cnt - start;
+-
+-	if (count > c->vc_rows)
+-		count = c->vc_rows;
+-
+-	if (count) {
+-		int copysize;
+-
+-		int diff = c->vc_rows - count;
+-		void *d = (void *) c->vc_visible_origin;
+-		void *s = (void *) c->vc_screenbuf;
+-
+-		count *= c->vc_size_row;
+-		/* how much memory to end of buffer left? */
+-		copysize = min(count, vgacon_scrollback_cur->size - soff);
+-		scr_memcpyw(d, vgacon_scrollback_cur->data + soff, copysize);
+-		d += copysize;
+-		count -= copysize;
+-
+-		if (count) {
+-			scr_memcpyw(d, vgacon_scrollback_cur->data, count);
+-			d += count;
+-		}
+-
+-		if (diff)
+-			scr_memcpyw(d, s, diff * c->vc_size_row);
+-	} else
+-		vgacon_cursor(c, CM_MOVE);
+-}
+-
+-static void vgacon_flush_scrollback(struct vc_data *c)
+-{
+-	size_t size = CONFIG_VGACON_SOFT_SCROLLBACK_SIZE * 1024;
+-
+-	vgacon_scrollback_reset(c->vc_num, size);
+-}
+-#else
+-#define vgacon_scrollback_startup(...) do { } while (0)
+-#define vgacon_scrollback_init(...)    do { } while (0)
+-#define vgacon_scrollback_update(...)  do { } while (0)
+-#define vgacon_scrollback_switch(...)  do { } while (0)
+-
+ static void vgacon_restore_screen(struct vc_data *c)
+ {
+ 	if (c->vc_origin != c->vc_visible_origin)
+@@ -386,11 +178,6 @@ static void vgacon_scrolldelta(struct vc_data *c, int lines)
+ 	vga_set_mem_top(c);
+ }
+ 
+-static void vgacon_flush_scrollback(struct vc_data *c)
+-{
+-}
+-#endif /* CONFIG_VGACON_SOFT_SCROLLBACK */
+-
+ static const char *vgacon_startup(void)
+ {
+ 	const char *display_desc = NULL;
+@@ -573,10 +360,7 @@ static const char *vgacon_startup(void)
+ 	vgacon_xres = screen_info.orig_video_cols * VGA_FONTWIDTH;
+ 	vgacon_yres = vga_scan_lines;
+ 
+-	if (!vga_init_done) {
+-		vgacon_scrollback_startup();
+-		vga_init_done = true;
+-	}
++	vga_init_done = true;
+ 
+ 	return display_desc;
+ }
+@@ -867,7 +651,6 @@ static int vgacon_switch(struct vc_data *c)
+ 			vgacon_doresize(c, c->vc_cols, c->vc_rows);
+ 	}
+ 
+-	vgacon_scrollback_switch(c->vc_num);
+ 	return 0;		/* Redrawing not needed */
+ }
+ 
+@@ -1384,7 +1167,6 @@ static bool vgacon_scroll(struct vc_data *c, unsigned int t, unsigned int b,
+ 	oldo = c->vc_origin;
+ 	delta = lines * c->vc_size_row;
+ 	if (dir == SM_UP) {
+-		vgacon_scrollback_update(c, t, lines);
+ 		if (c->vc_scr_end + delta >= vga_vram_end) {
+ 			scr_memcpyw((u16 *) vga_vram_base,
+ 				    (u16 *) (oldo + delta),
+@@ -1448,7 +1230,6 @@ const struct consw vga_con = {
+ 	.con_save_screen = vgacon_save_screen,
+ 	.con_build_attr = vgacon_build_attr,
+ 	.con_invert_region = vgacon_invert_region,
+-	.con_flush_scrollback = vgacon_flush_scrollback,
+ };
+ EXPORT_SYMBOL(vga_con);
+ 
+diff --git a/drivers/video/fbdev/core/bitblit.c b/drivers/video/fbdev/core/bitblit.c
+index 35ebeeccde4df..436365efae731 100644
+--- a/drivers/video/fbdev/core/bitblit.c
++++ b/drivers/video/fbdev/core/bitblit.c
+@@ -234,7 +234,7 @@ static void bit_clear_margins(struct vc_data *vc, struct fb_info *info,
+ }
+ 
+ static void bit_cursor(struct vc_data *vc, struct fb_info *info, int mode,
+-		       int softback_lines, int fg, int bg)
++		       int fg, int bg)
+ {
+ 	struct fb_cursor cursor;
+ 	struct fbcon_ops *ops = info->fbcon_par;
+@@ -247,15 +247,6 @@ static void bit_cursor(struct vc_data *vc, struct fb_info *info, int mode,
+ 
+ 	cursor.set = 0;
+ 
+-	if (softback_lines) {
+-		if (y + softback_lines >= vc->vc_rows) {
+-			mode = CM_ERASE;
+-			ops->cursor_flash = 0;
+-			return;
+-		} else
+-			y += softback_lines;
+-	}
+-
+  	c = scr_readw((u16 *) vc->vc_pos);
+ 	attribute = get_attribute(info, c);
+ 	src = vc->vc_font.data + ((c & charmask) * (w * vc->vc_font.height));
+diff --git a/drivers/video/fbdev/core/fbcon.c b/drivers/video/fbdev/core/fbcon.c
+index f75557b39a61d..29226b6cb632d 100644
+--- a/drivers/video/fbdev/core/fbcon.c
++++ b/drivers/video/fbdev/core/fbcon.c
+@@ -102,12 +102,6 @@ static int logo_lines;
+ /* logo_shown is an index to vc_cons when >= 0; otherwise follows FBCON_LOGO
+    enums.  */
+ static int logo_shown = FBCON_LOGO_CANSHOW;
+-/* Software scrollback */
+-static int fbcon_softback_size = 32768;
+-static unsigned long softback_buf, softback_curr;
+-static unsigned long softback_in;
+-static unsigned long softback_top, softback_end;
+-static int softback_lines;
+ /* console mappings */
+ static int first_fb_vc;
+ static int last_fb_vc = MAX_NR_CONSOLES - 1;
+@@ -148,8 +142,6 @@ static int margin_color;
+ 
+ static const struct consw fb_con;
+ 
+-#define CM_SOFTBACK	(8)
+-
+ #define advance_row(p, delta) (unsigned short *)((unsigned long)(p) + (delta) * vc->vc_size_row)
+ 
+ static int fbcon_set_origin(struct vc_data *);
+@@ -355,18 +347,6 @@ static int get_color(struct vc_data *vc, struct fb_info *info,
+ 	return color;
+ }
+ 
+-static void fbcon_update_softback(struct vc_data *vc)
+-{
+-	int l = fbcon_softback_size / vc->vc_size_row;
+-
+-	if (l > 5)
+-		softback_end = softback_buf + l * vc->vc_size_row;
+-	else
+-		/* Smaller scrollback makes no sense, and 0 would screw
+-		   the operation totally */
+-		softback_top = 0;
+-}
+-
+ static void fb_flashcursor(struct work_struct *work)
+ {
+ 	struct fb_info *info = container_of(work, struct fb_info, queue);
+@@ -396,7 +376,7 @@ static void fb_flashcursor(struct work_struct *work)
+ 	c = scr_readw((u16 *) vc->vc_pos);
+ 	mode = (!ops->cursor_flash || ops->cursor_state.enable) ?
+ 		CM_ERASE : CM_DRAW;
+-	ops->cursor(vc, info, mode, softback_lines, get_color(vc, info, c, 1),
++	ops->cursor(vc, info, mode, get_color(vc, info, c, 1),
+ 		    get_color(vc, info, c, 0));
+ 	console_unlock();
+ }
+@@ -453,13 +433,7 @@ static int __init fb_console_setup(char *this_opt)
+ 		}
+ 		
+ 		if (!strncmp(options, "scrollback:", 11)) {
+-			options += 11;
+-			if (*options) {
+-				fbcon_softback_size = simple_strtoul(options, &options, 0);
+-				if (*options == 'k' || *options == 'K') {
+-					fbcon_softback_size *= 1024;
+-				}
+-			}
++			pr_warn("Ignoring scrollback size option\n");
+ 			continue;
+ 		}
+ 		
+@@ -988,31 +962,6 @@ static const char *fbcon_startup(void)
+ 
+ 	set_blitting_type(vc, info);
+ 
+-	if (info->fix.type != FB_TYPE_TEXT) {
+-		if (fbcon_softback_size) {
+-			if (!softback_buf) {
+-				softback_buf =
+-				    (unsigned long)
+-				    kmalloc(fbcon_softback_size,
+-					    GFP_KERNEL);
+-				if (!softback_buf) {
+-					fbcon_softback_size = 0;
+-					softback_top = 0;
+-				}
+-			}
+-		} else {
+-			if (softback_buf) {
+-				kfree((void *) softback_buf);
+-				softback_buf = 0;
+-				softback_top = 0;
+-			}
+-		}
+-		if (softback_buf)
+-			softback_in = softback_top = softback_curr =
+-			    softback_buf;
+-		softback_lines = 0;
+-	}
+-
+ 	/* Setup default font */
+ 	if (!p->fontdata && !vc->vc_font.data) {
+ 		if (!fontname[0] || !(font = find_font(fontname)))
+@@ -1181,9 +1130,6 @@ static void fbcon_init(struct vc_data *vc, int init)
+ 	if (logo)
+ 		fbcon_prepare_logo(vc, info, cols, rows, new_cols, new_rows);
+ 
+-	if (vc == svc && softback_buf)
+-		fbcon_update_softback(vc);
+-
+ 	if (ops->rotate_font && ops->rotate_font(info, vc)) {
+ 		ops->rotate = FB_ROTATE_UR;
+ 		set_blitting_type(vc, info);
+@@ -1346,7 +1292,6 @@ static void fbcon_cursor(struct vc_data *vc, int mode)
+ {
+ 	struct fb_info *info = registered_fb[con2fb_map[vc->vc_num]];
+ 	struct fbcon_ops *ops = info->fbcon_par;
+-	int y;
+  	int c = scr_readw((u16 *) vc->vc_pos);
+ 
+ 	ops->cur_blink_jiffies = msecs_to_jiffies(vc->vc_cur_blink_ms);
+@@ -1360,16 +1305,8 @@ static void fbcon_cursor(struct vc_data *vc, int mode)
+ 		fbcon_add_cursor_timer(info);
+ 
+ 	ops->cursor_flash = (mode == CM_ERASE) ? 0 : 1;
+-	if (mode & CM_SOFTBACK) {
+-		mode &= ~CM_SOFTBACK;
+-		y = softback_lines;
+-	} else {
+-		if (softback_lines)
+-			fbcon_set_origin(vc);
+-		y = 0;
+-	}
+ 
+-	ops->cursor(vc, info, mode, y, get_color(vc, info, c, 1),
++	ops->cursor(vc, info, mode, get_color(vc, info, c, 1),
+ 		    get_color(vc, info, c, 0));
+ }
+ 
+@@ -1440,8 +1377,6 @@ static void fbcon_set_disp(struct fb_info *info, struct fb_var_screeninfo *var,
+ 
+ 	if (con_is_visible(vc)) {
+ 		update_screen(vc);
+-		if (softback_buf)
+-			fbcon_update_softback(vc);
+ 	}
+ }
+ 
+@@ -1579,99 +1514,6 @@ static __inline__ void ypan_down_redraw(struct vc_data *vc, int t, int count)
+ 	scrollback_current = 0;
+ }
+ 
+-static void fbcon_redraw_softback(struct vc_data *vc, struct display *p,
+-				  long delta)
+-{
+-	int count = vc->vc_rows;
+-	unsigned short *d, *s;
+-	unsigned long n;
+-	int line = 0;
+-
+-	d = (u16 *) softback_curr;
+-	if (d == (u16 *) softback_in)
+-		d = (u16 *) vc->vc_origin;
+-	n = softback_curr + delta * vc->vc_size_row;
+-	softback_lines -= delta;
+-	if (delta < 0) {
+-		if (softback_curr < softback_top && n < softback_buf) {
+-			n += softback_end - softback_buf;
+-			if (n < softback_top) {
+-				softback_lines -=
+-				    (softback_top - n) / vc->vc_size_row;
+-				n = softback_top;
+-			}
+-		} else if (softback_curr >= softback_top
+-			   && n < softback_top) {
+-			softback_lines -=
+-			    (softback_top - n) / vc->vc_size_row;
+-			n = softback_top;
+-		}
+-	} else {
+-		if (softback_curr > softback_in && n >= softback_end) {
+-			n += softback_buf - softback_end;
+-			if (n > softback_in) {
+-				n = softback_in;
+-				softback_lines = 0;
+-			}
+-		} else if (softback_curr <= softback_in && n > softback_in) {
+-			n = softback_in;
+-			softback_lines = 0;
+-		}
+-	}
+-	if (n == softback_curr)
+-		return;
+-	softback_curr = n;
+-	s = (u16 *) softback_curr;
+-	if (s == (u16 *) softback_in)
+-		s = (u16 *) vc->vc_origin;
+-	while (count--) {
+-		unsigned short *start;
+-		unsigned short *le;
+-		unsigned short c;
+-		int x = 0;
+-		unsigned short attr = 1;
+-
+-		start = s;
+-		le = advance_row(s, 1);
+-		do {
+-			c = scr_readw(s);
+-			if (attr != (c & 0xff00)) {
+-				attr = c & 0xff00;
+-				if (s > start) {
+-					fbcon_putcs(vc, start, s - start,
+-						    line, x);
+-					x += s - start;
+-					start = s;
+-				}
+-			}
+-			if (c == scr_readw(d)) {
+-				if (s > start) {
+-					fbcon_putcs(vc, start, s - start,
+-						    line, x);
+-					x += s - start + 1;
+-					start = s + 1;
+-				} else {
+-					x++;
+-					start++;
+-				}
+-			}
+-			s++;
+-			d++;
+-		} while (s < le);
+-		if (s > start)
+-			fbcon_putcs(vc, start, s - start, line, x);
+-		line++;
+-		if (d == (u16 *) softback_end)
+-			d = (u16 *) softback_buf;
+-		if (d == (u16 *) softback_in)
+-			d = (u16 *) vc->vc_origin;
+-		if (s == (u16 *) softback_end)
+-			s = (u16 *) softback_buf;
+-		if (s == (u16 *) softback_in)
+-			s = (u16 *) vc->vc_origin;
+-	}
+-}
+-
+ static void fbcon_redraw_move(struct vc_data *vc, struct display *p,
+ 			      int line, int count, int dy)
+ {
+@@ -1811,31 +1653,6 @@ static void fbcon_redraw(struct vc_data *vc, struct display *p,
+ 	}
+ }
+ 
+-static inline void fbcon_softback_note(struct vc_data *vc, int t,
+-				       int count)
+-{
+-	unsigned short *p;
+-
+-	if (vc->vc_num != fg_console)
+-		return;
+-	p = (unsigned short *) (vc->vc_origin + t * vc->vc_size_row);
+-
+-	while (count) {
+-		scr_memcpyw((u16 *) softback_in, p, vc->vc_size_row);
+-		count--;
+-		p = advance_row(p, 1);
+-		softback_in += vc->vc_size_row;
+-		if (softback_in == softback_end)
+-			softback_in = softback_buf;
+-		if (softback_in == softback_top) {
+-			softback_top += vc->vc_size_row;
+-			if (softback_top == softback_end)
+-				softback_top = softback_buf;
+-		}
+-	}
+-	softback_curr = softback_in;
+-}
+-
+ static bool fbcon_scroll(struct vc_data *vc, unsigned int t, unsigned int b,
+ 		enum con_scroll dir, unsigned int count)
+ {
+@@ -1858,8 +1675,6 @@ static bool fbcon_scroll(struct vc_data *vc, unsigned int t, unsigned int b,
+ 	case SM_UP:
+ 		if (count > vc->vc_rows)	/* Maximum realistic size */
+ 			count = vc->vc_rows;
+-		if (softback_top)
+-			fbcon_softback_note(vc, t, count);
+ 		if (logo_shown >= 0)
+ 			goto redraw_up;
+ 		switch (p->scrollmode) {
+@@ -2230,14 +2045,6 @@ static int fbcon_switch(struct vc_data *vc)
+ 	info = registered_fb[con2fb_map[vc->vc_num]];
+ 	ops = info->fbcon_par;
+ 
+-	if (softback_top) {
+-		if (softback_lines)
+-			fbcon_set_origin(vc);
+-		softback_top = softback_curr = softback_in = softback_buf;
+-		softback_lines = 0;
+-		fbcon_update_softback(vc);
+-	}
+-
+ 	if (logo_shown >= 0) {
+ 		struct vc_data *conp2 = vc_cons[logo_shown].d;
+ 
+@@ -2571,9 +2378,6 @@ static int fbcon_do_set_font(struct vc_data *vc, int w, int h,
+ 	int cnt;
+ 	char *old_data = NULL;
+ 
+-	if (con_is_visible(vc) && softback_lines)
+-		fbcon_set_origin(vc);
+-
+ 	resize = (w != vc->vc_font.width) || (h != vc->vc_font.height);
+ 	if (p->userfont)
+ 		old_data = vc->vc_font.data;
+@@ -2599,8 +2403,6 @@ static int fbcon_do_set_font(struct vc_data *vc, int w, int h,
+ 		cols /= w;
+ 		rows /= h;
+ 		vc_resize(vc, cols, rows);
+-		if (con_is_visible(vc) && softback_buf)
+-			fbcon_update_softback(vc);
+ 	} else if (con_is_visible(vc)
+ 		   && vc->vc_mode == KD_TEXT) {
+ 		fbcon_clear_margins(vc, 0);
+@@ -2759,19 +2561,7 @@ static void fbcon_set_palette(struct vc_data *vc, const unsigned char *table)
+ 
+ static u16 *fbcon_screen_pos(struct vc_data *vc, int offset)
+ {
+-	unsigned long p;
+-	int line;
+-	
+-	if (vc->vc_num != fg_console || !softback_lines)
+-		return (u16 *) (vc->vc_origin + offset);
+-	line = offset / vc->vc_size_row;
+-	if (line >= softback_lines)
+-		return (u16 *) (vc->vc_origin + offset -
+-				softback_lines * vc->vc_size_row);
+-	p = softback_curr + offset;
+-	if (p >= softback_end)
+-		p += softback_buf - softback_end;
+-	return (u16 *) p;
++	return (u16 *) (vc->vc_origin + offset);
+ }
+ 
+ static unsigned long fbcon_getxy(struct vc_data *vc, unsigned long pos,
+@@ -2785,22 +2575,7 @@ static unsigned long fbcon_getxy(struct vc_data *vc, unsigned long pos,
+ 
+ 		x = offset % vc->vc_cols;
+ 		y = offset / vc->vc_cols;
+-		if (vc->vc_num == fg_console)
+-			y += softback_lines;
+ 		ret = pos + (vc->vc_cols - x) * 2;
+-	} else if (vc->vc_num == fg_console && softback_lines) {
+-		unsigned long offset = pos - softback_curr;
+-
+-		if (pos < softback_curr)
+-			offset += softback_end - softback_buf;
+-		offset /= 2;
+-		x = offset % vc->vc_cols;
+-		y = offset / vc->vc_cols;
+-		ret = pos + (vc->vc_cols - x) * 2;
+-		if (ret == softback_end)
+-			ret = softback_buf;
+-		if (ret == softback_in)
+-			ret = vc->vc_origin;
+ 	} else {
+ 		/* Should not happen */
+ 		x = y = 0;
+@@ -2828,106 +2603,11 @@ static void fbcon_invert_region(struct vc_data *vc, u16 * p, int cnt)
+ 			a = ((a) & 0x88ff) | (((a) & 0x7000) >> 4) |
+ 			    (((a) & 0x0700) << 4);
+ 		scr_writew(a, p++);
+-		if (p == (u16 *) softback_end)
+-			p = (u16 *) softback_buf;
+-		if (p == (u16 *) softback_in)
+-			p = (u16 *) vc->vc_origin;
+ 	}
+ }
+ 
+-static void fbcon_scrolldelta(struct vc_data *vc, int lines)
+-{
+-	struct fb_info *info = registered_fb[con2fb_map[fg_console]];
+-	struct fbcon_ops *ops = info->fbcon_par;
+-	struct display *disp = &fb_display[fg_console];
+-	int offset, limit, scrollback_old;
+-
+-	if (softback_top) {
+-		if (vc->vc_num != fg_console)
+-			return;
+-		if (vc->vc_mode != KD_TEXT || !lines)
+-			return;
+-		if (logo_shown >= 0) {
+-			struct vc_data *conp2 = vc_cons[logo_shown].d;
+-
+-			if (conp2->vc_top == logo_lines
+-			    && conp2->vc_bottom == conp2->vc_rows)
+-				conp2->vc_top = 0;
+-			if (logo_shown == vc->vc_num) {
+-				unsigned long p, q;
+-				int i;
+-
+-				p = softback_in;
+-				q = vc->vc_origin +
+-				    logo_lines * vc->vc_size_row;
+-				for (i = 0; i < logo_lines; i++) {
+-					if (p == softback_top)
+-						break;
+-					if (p == softback_buf)
+-						p = softback_end;
+-					p -= vc->vc_size_row;
+-					q -= vc->vc_size_row;
+-					scr_memcpyw((u16 *) q, (u16 *) p,
+-						    vc->vc_size_row);
+-				}
+-				softback_in = softback_curr = p;
+-				update_region(vc, vc->vc_origin,
+-					      logo_lines * vc->vc_cols);
+-			}
+-			logo_shown = FBCON_LOGO_CANSHOW;
+-		}
+-		fbcon_cursor(vc, CM_ERASE | CM_SOFTBACK);
+-		fbcon_redraw_softback(vc, disp, lines);
+-		fbcon_cursor(vc, CM_DRAW | CM_SOFTBACK);
+-		return;
+-	}
+-
+-	if (!scrollback_phys_max)
+-		return;
+-
+-	scrollback_old = scrollback_current;
+-	scrollback_current -= lines;
+-	if (scrollback_current < 0)
+-		scrollback_current = 0;
+-	else if (scrollback_current > scrollback_max)
+-		scrollback_current = scrollback_max;
+-	if (scrollback_current == scrollback_old)
+-		return;
+-
+-	if (fbcon_is_inactive(vc, info))
+-		return;
+-
+-	fbcon_cursor(vc, CM_ERASE);
+-
+-	offset = disp->yscroll - scrollback_current;
+-	limit = disp->vrows;
+-	switch (disp->scrollmode) {
+-	case SCROLL_WRAP_MOVE:
+-		info->var.vmode |= FB_VMODE_YWRAP;
+-		break;
+-	case SCROLL_PAN_MOVE:
+-	case SCROLL_PAN_REDRAW:
+-		limit -= vc->vc_rows;
+-		info->var.vmode &= ~FB_VMODE_YWRAP;
+-		break;
+-	}
+-	if (offset < 0)
+-		offset += limit;
+-	else if (offset >= limit)
+-		offset -= limit;
+-
+-	ops->var.xoffset = 0;
+-	ops->var.yoffset = offset * vc->vc_font.height;
+-	ops->update_start(info);
+-
+-	if (!scrollback_current)
+-		fbcon_cursor(vc, CM_DRAW);
+-}
+-
+ static int fbcon_set_origin(struct vc_data *vc)
+ {
+-	if (softback_lines)
+-		fbcon_scrolldelta(vc, softback_lines);
+ 	return 0;
+ }
+ 
+@@ -2991,8 +2671,6 @@ static void fbcon_modechanged(struct fb_info *info)
+ 
+ 		fbcon_set_palette(vc, color_table);
+ 		update_screen(vc);
+-		if (softback_buf)
+-			fbcon_update_softback(vc);
+ 	}
+ }
+ 
+@@ -3434,7 +3112,6 @@ static const struct consw fb_con = {
+ 	.con_font_default	= fbcon_set_def_font,
+ 	.con_font_copy 		= fbcon_copy_font,
+ 	.con_set_palette 	= fbcon_set_palette,
+-	.con_scrolldelta 	= fbcon_scrolldelta,
+ 	.con_set_origin 	= fbcon_set_origin,
+ 	.con_invert_region 	= fbcon_invert_region,
+ 	.con_screen_pos 	= fbcon_screen_pos,
+@@ -3691,9 +3368,6 @@ static void fbcon_exit(void)
+ 	}
+ #endif
+ 
+-	kfree((void *)softback_buf);
+-	softback_buf = 0UL;
+-
+ 	for_each_registered_fb(i) {
+ 		int pending = 0;
+ 
+diff --git a/drivers/video/fbdev/core/fbcon.h b/drivers/video/fbdev/core/fbcon.h
+index 21912a3ba32f8..aeea63abbe987 100644
+--- a/drivers/video/fbdev/core/fbcon.h
++++ b/drivers/video/fbdev/core/fbcon.h
+@@ -62,7 +62,7 @@ struct fbcon_ops {
+ 	void (*clear_margins)(struct vc_data *vc, struct fb_info *info,
+ 			      int color, int bottom_only);
+ 	void (*cursor)(struct vc_data *vc, struct fb_info *info, int mode,
+-		       int softback_lines, int fg, int bg);
++		       int fg, int bg);
+ 	int  (*update_start)(struct fb_info *info);
+ 	int  (*rotate_font)(struct fb_info *info, struct vc_data *vc);
+ 	struct fb_var_screeninfo var;  /* copy of the current fb_var_screeninfo */
+diff --git a/drivers/video/fbdev/core/fbcon_ccw.c b/drivers/video/fbdev/core/fbcon_ccw.c
+index 78f3a56214782..71ad6967a70ee 100644
+--- a/drivers/video/fbdev/core/fbcon_ccw.c
++++ b/drivers/video/fbdev/core/fbcon_ccw.c
+@@ -219,7 +219,7 @@ static void ccw_clear_margins(struct vc_data *vc, struct fb_info *info,
+ }
+ 
+ static void ccw_cursor(struct vc_data *vc, struct fb_info *info, int mode,
+-		       int softback_lines, int fg, int bg)
++		       int fg, int bg)
+ {
+ 	struct fb_cursor cursor;
+ 	struct fbcon_ops *ops = info->fbcon_par;
+@@ -236,15 +236,6 @@ static void ccw_cursor(struct vc_data *vc, struct fb_info *info, int mode,
+ 
+ 	cursor.set = 0;
+ 
+-	if (softback_lines) {
+-		if (y + softback_lines >= vc->vc_rows) {
+-			mode = CM_ERASE;
+-			ops->cursor_flash = 0;
+-			return;
+-		} else
+-			y += softback_lines;
+-	}
+-
+  	c = scr_readw((u16 *) vc->vc_pos);
+ 	attribute = get_attribute(info, c);
+ 	src = ops->fontbuffer + ((c & charmask) * (w * vc->vc_font.width));
+diff --git a/drivers/video/fbdev/core/fbcon_cw.c b/drivers/video/fbdev/core/fbcon_cw.c
+index fd098ff17574b..31fe5dd651d44 100644
+--- a/drivers/video/fbdev/core/fbcon_cw.c
++++ b/drivers/video/fbdev/core/fbcon_cw.c
+@@ -202,7 +202,7 @@ static void cw_clear_margins(struct vc_data *vc, struct fb_info *info,
+ }
+ 
+ static void cw_cursor(struct vc_data *vc, struct fb_info *info, int mode,
+-		      int softback_lines, int fg, int bg)
++		      int fg, int bg)
+ {
+ 	struct fb_cursor cursor;
+ 	struct fbcon_ops *ops = info->fbcon_par;
+@@ -219,15 +219,6 @@ static void cw_cursor(struct vc_data *vc, struct fb_info *info, int mode,
+ 
+ 	cursor.set = 0;
+ 
+-	if (softback_lines) {
+-		if (y + softback_lines >= vc->vc_rows) {
+-			mode = CM_ERASE;
+-			ops->cursor_flash = 0;
+-			return;
+-		} else
+-			y += softback_lines;
+-	}
+-
+  	c = scr_readw((u16 *) vc->vc_pos);
+ 	attribute = get_attribute(info, c);
+ 	src = ops->fontbuffer + ((c & charmask) * (w * vc->vc_font.width));
+diff --git a/drivers/video/fbdev/core/fbcon_ud.c b/drivers/video/fbdev/core/fbcon_ud.c
+index e165a3fad29ad..b2dd1370e39b2 100644
+--- a/drivers/video/fbdev/core/fbcon_ud.c
++++ b/drivers/video/fbdev/core/fbcon_ud.c
+@@ -249,7 +249,7 @@ static void ud_clear_margins(struct vc_data *vc, struct fb_info *info,
+ }
+ 
+ static void ud_cursor(struct vc_data *vc, struct fb_info *info, int mode,
+-		      int softback_lines, int fg, int bg)
++		      int fg, int bg)
+ {
+ 	struct fb_cursor cursor;
+ 	struct fbcon_ops *ops = info->fbcon_par;
+@@ -267,15 +267,6 @@ static void ud_cursor(struct vc_data *vc, struct fb_info *info, int mode,
+ 
+ 	cursor.set = 0;
+ 
+-	if (softback_lines) {
+-		if (y + softback_lines >= vc->vc_rows) {
+-			mode = CM_ERASE;
+-			ops->cursor_flash = 0;
+-			return;
+-		} else
+-			y += softback_lines;
+-	}
+-
+  	c = scr_readw((u16 *) vc->vc_pos);
+ 	attribute = get_attribute(info, c);
+ 	src = ops->fontbuffer + ((c & charmask) * (w * vc->vc_font.height));
+diff --git a/drivers/video/fbdev/core/tileblit.c b/drivers/video/fbdev/core/tileblit.c
+index 93390312957ff..eb664dbf96f66 100644
+--- a/drivers/video/fbdev/core/tileblit.c
++++ b/drivers/video/fbdev/core/tileblit.c
+@@ -80,7 +80,7 @@ static void tile_clear_margins(struct vc_data *vc, struct fb_info *info,
+ }
+ 
+ static void tile_cursor(struct vc_data *vc, struct fb_info *info, int mode,
+-			int softback_lines, int fg, int bg)
++			int fg, int bg)
+ {
+ 	struct fb_tilecursor cursor;
+ 	int use_sw = (vc->vc_cursor_type & 0x10);
+diff --git a/drivers/video/fbdev/vga16fb.c b/drivers/video/fbdev/vga16fb.c
+index 2c6a576ed84c7..4b83109202b1c 100644
+--- a/drivers/video/fbdev/vga16fb.c
++++ b/drivers/video/fbdev/vga16fb.c
+@@ -1121,7 +1121,7 @@ static void vga_8planes_imageblit(struct fb_info *info, const struct fb_image *i
+         char oldop = setop(0);
+         char oldsr = setsr(0);
+         char oldmask = selectmask();
+-        const char *cdat = image->data;
++	const unsigned char *cdat = image->data;
+ 	u32 dx = image->dx;
+         char __iomem *where;
+         int y;
+diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c
+index ec3aa76d19b7f..319a89d4d0735 100644
+--- a/fs/btrfs/extent-tree.c
++++ b/fs/btrfs/extent-tree.c
+@@ -1057,12 +1057,11 @@ int btrfs_get_extent_inline_ref_type(const struct extent_buffer *eb,
+ 			if (type == BTRFS_SHARED_BLOCK_REF_KEY) {
+ 				ASSERT(eb->fs_info);
+ 				/*
+-				 * Every shared one has parent tree
+-				 * block, which must be aligned to
+-				 * nodesize.
++				 * Every shared one has parent tree block,
++				 * which must be aligned to sector size.
+ 				 */
+ 				if (offset &&
+-				    IS_ALIGNED(offset, eb->fs_info->nodesize))
++				    IS_ALIGNED(offset, eb->fs_info->sectorsize))
+ 					return type;
+ 			}
+ 		} else if (is_data == BTRFS_REF_TYPE_DATA) {
+@@ -1071,12 +1070,11 @@ int btrfs_get_extent_inline_ref_type(const struct extent_buffer *eb,
+ 			if (type == BTRFS_SHARED_DATA_REF_KEY) {
+ 				ASSERT(eb->fs_info);
+ 				/*
+-				 * Every shared one has parent tree
+-				 * block, which must be aligned to
+-				 * nodesize.
++				 * Every shared one has parent tree block,
++				 * which must be aligned to sector size.
+ 				 */
+ 				if (offset &&
+-				    IS_ALIGNED(offset, eb->fs_info->nodesize))
++				    IS_ALIGNED(offset, eb->fs_info->sectorsize))
+ 					return type;
+ 			}
+ 		} else {
+@@ -1086,8 +1084,9 @@ int btrfs_get_extent_inline_ref_type(const struct extent_buffer *eb,
+ 	}
+ 
+ 	btrfs_print_leaf((struct extent_buffer *)eb);
+-	btrfs_err(eb->fs_info, "eb %llu invalid extent inline ref type %d",
+-		  eb->start, type);
++	btrfs_err(eb->fs_info,
++		  "eb %llu iref 0x%lx invalid extent inline ref type %d",
++		  eb->start, (unsigned long)iref, type);
+ 	WARN_ON(1);
+ 
+ 	return BTRFS_REF_TYPE_INVALID;
+diff --git a/fs/btrfs/ioctl.c b/fs/btrfs/ioctl.c
+index 85990755edd90..01a90fa03c24f 100644
+--- a/fs/btrfs/ioctl.c
++++ b/fs/btrfs/ioctl.c
+@@ -2189,7 +2189,8 @@ static noinline int search_ioctl(struct inode *inode,
+ 	key.offset = sk->min_offset;
+ 
+ 	while (1) {
+-		ret = fault_in_pages_writeable(ubuf, *buf_size - sk_offset);
++		ret = fault_in_pages_writeable(ubuf + sk_offset,
++					       *buf_size - sk_offset);
+ 		if (ret)
+ 			break;
+ 
+diff --git a/fs/btrfs/print-tree.c b/fs/btrfs/print-tree.c
+index df49931ffe922..4b217e9a581ce 100644
+--- a/fs/btrfs/print-tree.c
++++ b/fs/btrfs/print-tree.c
+@@ -95,9 +95,10 @@ static void print_extent_item(struct extent_buffer *eb, int slot, int type)
+ 			 * offset is supposed to be a tree block which
+ 			 * must be aligned to nodesize.
+ 			 */
+-			if (!IS_ALIGNED(offset, eb->fs_info->nodesize))
+-				pr_info("\t\t\t(parent %llu is NOT ALIGNED to nodesize %llu)\n",
+-					offset, (unsigned long long)eb->fs_info->nodesize);
++			if (!IS_ALIGNED(offset, eb->fs_info->sectorsize))
++				pr_info(
++			"\t\t\t(parent %llu not aligned to sectorsize %u)\n",
++					offset, eb->fs_info->sectorsize);
+ 			break;
+ 		case BTRFS_EXTENT_DATA_REF_KEY:
+ 			dref = (struct btrfs_extent_data_ref *)(&iref->offset);
+@@ -112,8 +113,9 @@ static void print_extent_item(struct extent_buffer *eb, int slot, int type)
+ 			 * must be aligned to nodesize.
+ 			 */
+ 			if (!IS_ALIGNED(offset, eb->fs_info->nodesize))
+-				pr_info("\t\t\t(parent %llu is NOT ALIGNED to nodesize %llu)\n",
+-				     offset, (unsigned long long)eb->fs_info->nodesize);
++				pr_info(
++			"\t\t\t(parent %llu not aligned to sectorsize %u)\n",
++				     offset, eb->fs_info->sectorsize);
+ 			break;
+ 		default:
+ 			pr_cont("(extent %llu has INVALID ref type %d)\n",
+diff --git a/fs/btrfs/volumes.c b/fs/btrfs/volumes.c
+index 498ec4b10e610..815b655b8f10a 100644
+--- a/fs/btrfs/volumes.c
++++ b/fs/btrfs/volumes.c
+@@ -4,6 +4,7 @@
+  */
+ 
+ #include <linux/sched.h>
++#include <linux/sched/mm.h>
+ #include <linux/bio.h>
+ #include <linux/slab.h>
+ #include <linux/buffer_head.h>
+@@ -6292,8 +6293,17 @@ static struct btrfs_device *add_missing_dev(struct btrfs_fs_devices *fs_devices,
+ 					    u64 devid, u8 *dev_uuid)
+ {
+ 	struct btrfs_device *device;
++	unsigned int nofs_flag;
+ 
++	/*
++	 * We call this under the chunk_mutex, so we want to use NOFS for this
++	 * allocation, however we don't want to change btrfs_alloc_device() to
++	 * always do NOFS because we use it in a lot of other GFP_KERNEL safe
++	 * places.
++	 */
++	nofs_flag = memalloc_nofs_save();
+ 	device = btrfs_alloc_device(NULL, &devid, dev_uuid);
++	memalloc_nofs_restore(nofs_flag);
+ 	if (IS_ERR(device))
+ 		return device;
+ 
+diff --git a/fs/xfs/libxfs/xfs_attr_leaf.c b/fs/xfs/libxfs/xfs_attr_leaf.c
+index 087a5715cf20e..bd37f4a292c3b 100644
+--- a/fs/xfs/libxfs/xfs_attr_leaf.c
++++ b/fs/xfs/libxfs/xfs_attr_leaf.c
+@@ -551,8 +551,8 @@ xfs_attr_shortform_create(xfs_da_args_t *args)
+ 		ASSERT(ifp->if_flags & XFS_IFINLINE);
+ 	}
+ 	xfs_idata_realloc(dp, sizeof(*hdr), XFS_ATTR_FORK);
+-	hdr = (xfs_attr_sf_hdr_t *)ifp->if_u1.if_data;
+-	hdr->count = 0;
++	hdr = (struct xfs_attr_sf_hdr *)ifp->if_u1.if_data;
++	memset(hdr, 0, sizeof(*hdr));
+ 	hdr->totsize = cpu_to_be16(sizeof(*hdr));
+ 	xfs_trans_log_inode(args->trans, dp, XFS_ILOG_CORE | XFS_ILOG_ADATA);
+ }
+diff --git a/include/linux/netfilter/nf_conntrack_sctp.h b/include/linux/netfilter/nf_conntrack_sctp.h
+index 9a33f171aa822..625f491b95de8 100644
+--- a/include/linux/netfilter/nf_conntrack_sctp.h
++++ b/include/linux/netfilter/nf_conntrack_sctp.h
+@@ -9,6 +9,8 @@ struct ip_ct_sctp {
+ 	enum sctp_conntrack state;
+ 
+ 	__be32 vtag[IP_CT_DIR_MAX];
++	u8 last_dir;
++	u8 flags;
+ };
+ 
+ #endif /* _NF_CONNTRACK_SCTP_H */
+diff --git a/include/soc/nps/common.h b/include/soc/nps/common.h
+index 9b1d43d671a3f..8c18dc6d3fde5 100644
+--- a/include/soc/nps/common.h
++++ b/include/soc/nps/common.h
+@@ -45,6 +45,12 @@
+ #define CTOP_INST_MOV2B_FLIP_R3_B1_B2_INST	0x5B60
+ #define CTOP_INST_MOV2B_FLIP_R3_B1_B2_LIMM	0x00010422
+ 
++#ifndef AUX_IENABLE
++#define AUX_IENABLE				0x40c
++#endif
++
++#define CTOP_AUX_IACK				(0xFFFFF800 + 0x088)
++
+ #ifndef __ASSEMBLY__
+ 
+ /* In order to increase compilation test coverage */
+diff --git a/kernel/gcov/gcc_4_7.c b/kernel/gcov/gcc_4_7.c
+index ca5e5c0ef8536..5b9e76117ded1 100644
+--- a/kernel/gcov/gcc_4_7.c
++++ b/kernel/gcov/gcc_4_7.c
+@@ -19,7 +19,9 @@
+ #include <linux/vmalloc.h>
+ #include "gcov.h"
+ 
+-#if (__GNUC__ >= 7)
++#if (__GNUC__ >= 10)
++#define GCOV_COUNTERS			8
++#elif (__GNUC__ >= 7)
+ #define GCOV_COUNTERS			9
+ #elif (__GNUC__ > 5) || (__GNUC__ == 5 && __GNUC_MINOR__ >= 1)
+ #define GCOV_COUNTERS			10
+diff --git a/net/netfilter/nf_conntrack_proto_sctp.c b/net/netfilter/nf_conntrack_proto_sctp.c
+index 7d7e30ea0ecf9..a937d4f75613f 100644
+--- a/net/netfilter/nf_conntrack_proto_sctp.c
++++ b/net/netfilter/nf_conntrack_proto_sctp.c
+@@ -65,6 +65,8 @@ static const unsigned int sctp_timeouts[SCTP_CONNTRACK_MAX] = {
+ 	[SCTP_CONNTRACK_HEARTBEAT_ACKED]	= 210 SECS,
+ };
+ 
++#define	SCTP_FLAG_HEARTBEAT_VTAG_FAILED	1
++
+ #define sNO SCTP_CONNTRACK_NONE
+ #define	sCL SCTP_CONNTRACK_CLOSED
+ #define	sCW SCTP_CONNTRACK_COOKIE_WAIT
+@@ -288,6 +290,7 @@ static int sctp_packet(struct nf_conn *ct,
+ 	u_int32_t offset, count;
+ 	unsigned int *timeouts;
+ 	unsigned long map[256 / sizeof(unsigned long)] = { 0 };
++	bool ignore = false;
+ 
+ 	sh = skb_header_pointer(skb, dataoff, sizeof(_sctph), &_sctph);
+ 	if (sh == NULL)
+@@ -332,15 +335,39 @@ static int sctp_packet(struct nf_conn *ct,
+ 			/* Sec 8.5.1 (D) */
+ 			if (sh->vtag != ct->proto.sctp.vtag[dir])
+ 				goto out_unlock;
+-		} else if (sch->type == SCTP_CID_HEARTBEAT ||
+-			   sch->type == SCTP_CID_HEARTBEAT_ACK) {
++		} else if (sch->type == SCTP_CID_HEARTBEAT) {
++			if (ct->proto.sctp.vtag[dir] == 0) {
++				pr_debug("Setting %d vtag %x for dir %d\n", sch->type, sh->vtag, dir);
++				ct->proto.sctp.vtag[dir] = sh->vtag;
++			} else if (sh->vtag != ct->proto.sctp.vtag[dir]) {
++				if (test_bit(SCTP_CID_DATA, map) || ignore)
++					goto out_unlock;
++
++				ct->proto.sctp.flags |= SCTP_FLAG_HEARTBEAT_VTAG_FAILED;
++				ct->proto.sctp.last_dir = dir;
++				ignore = true;
++				continue;
++			} else if (ct->proto.sctp.flags & SCTP_FLAG_HEARTBEAT_VTAG_FAILED) {
++				ct->proto.sctp.flags &= ~SCTP_FLAG_HEARTBEAT_VTAG_FAILED;
++			}
++		} else if (sch->type == SCTP_CID_HEARTBEAT_ACK) {
+ 			if (ct->proto.sctp.vtag[dir] == 0) {
+ 				pr_debug("Setting vtag %x for dir %d\n",
+ 					 sh->vtag, dir);
+ 				ct->proto.sctp.vtag[dir] = sh->vtag;
+ 			} else if (sh->vtag != ct->proto.sctp.vtag[dir]) {
+-				pr_debug("Verification tag check failed\n");
+-				goto out_unlock;
++				if (test_bit(SCTP_CID_DATA, map) || ignore)
++					goto out_unlock;
++
++				if ((ct->proto.sctp.flags & SCTP_FLAG_HEARTBEAT_VTAG_FAILED) == 0 ||
++				    ct->proto.sctp.last_dir == dir)
++					goto out_unlock;
++
++				ct->proto.sctp.flags &= ~SCTP_FLAG_HEARTBEAT_VTAG_FAILED;
++				ct->proto.sctp.vtag[dir] = sh->vtag;
++				ct->proto.sctp.vtag[!dir] = 0;
++			} else if (ct->proto.sctp.flags & SCTP_FLAG_HEARTBEAT_VTAG_FAILED) {
++				ct->proto.sctp.flags &= ~SCTP_FLAG_HEARTBEAT_VTAG_FAILED;
+ 			}
+ 		}
+ 
+@@ -375,6 +402,10 @@ static int sctp_packet(struct nf_conn *ct,
+ 	}
+ 	spin_unlock_bh(&ct->lock);
+ 
++	/* allow but do not refresh timeout */
++	if (ignore)
++		return NF_ACCEPT;
++
+ 	timeouts = nf_ct_timeout_lookup(ct);
+ 	if (!timeouts)
+ 		timeouts = sctp_pernet(nf_ct_net(ct))->timeouts;
+diff --git a/sound/hda/hdac_device.c b/sound/hda/hdac_device.c
+index dbf02a3a8d2f2..58b53a4bc4d01 100644
+--- a/sound/hda/hdac_device.c
++++ b/sound/hda/hdac_device.c
+@@ -124,6 +124,8 @@ EXPORT_SYMBOL_GPL(snd_hdac_device_init);
+ void snd_hdac_device_exit(struct hdac_device *codec)
+ {
+ 	pm_runtime_put_noidle(&codec->dev);
++	/* keep balance of runtime PM child_count in parent device */
++	pm_runtime_set_suspended(&codec->dev);
+ 	snd_hdac_bus_remove_device(codec->bus, codec);
+ 	kfree(codec->vendor_name);
+ 	kfree(codec->chip_name);
+diff --git a/sound/pci/hda/patch_hdmi.c b/sound/pci/hda/patch_hdmi.c
+index b8e5f2b19ff85..708efb9b43877 100644
+--- a/sound/pci/hda/patch_hdmi.c
++++ b/sound/pci/hda/patch_hdmi.c
+@@ -3431,6 +3431,7 @@ static int tegra_hdmi_build_pcms(struct hda_codec *codec)
+ 
+ static int patch_tegra_hdmi(struct hda_codec *codec)
+ {
++	struct hdmi_spec *spec;
+ 	int err;
+ 
+ 	err = patch_generic_hdmi(codec);
+@@ -3438,6 +3439,10 @@ static int patch_tegra_hdmi(struct hda_codec *codec)
+ 		return err;
+ 
+ 	codec->patch_ops.build_pcms = tegra_hdmi_build_pcms;
++	spec = codec->spec;
++	spec->chmap.ops.chmap_cea_alloc_validate_get_type =
++		nvhdmi_chmap_cea_alloc_validate_get_type;
++	spec->chmap.ops.chmap_validate = nvhdmi_chmap_validate;
+ 
+ 	return 0;
+ }