From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from lists.gentoo.org (pigeon.gentoo.org [208.92.234.80]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by finch.gentoo.org (Postfix) with ESMTPS id 56DC2158086 for ; Wed, 20 Oct 2021 13:22:56 +0000 (UTC) Received: from pigeon.gentoo.org (localhost [127.0.0.1]) by pigeon.gentoo.org (Postfix) with SMTP id 874DEE0825; Wed, 20 Oct 2021 13:22:55 +0000 (UTC) Received: from smtp.gentoo.org (dev.gentoo.org [IPv6:2001:470:ea4a:1:5054:ff:fec7:86e4]) (using TLSv1.2 with cipher ECDHE-RSA-CHACHA20-POLY1305 (256/256 bits)) (No client certificate requested) by pigeon.gentoo.org (Postfix) with ESMTPS id 3E0BAE0825 for ; Wed, 20 Oct 2021 13:22:55 +0000 (UTC) Received: from oystercatcher.gentoo.org (oystercatcher.gentoo.org [148.251.78.52]) (using TLSv1.2 with cipher ECDHE-RSA-CHACHA20-POLY1305 (256/256 bits)) (No client certificate requested) by smtp.gentoo.org (Postfix) with ESMTPS id 5F7C0343621 for ; Wed, 20 Oct 2021 13:22:53 +0000 (UTC) Received: from localhost.localdomain (localhost [IPv6:::1]) by oystercatcher.gentoo.org (Postfix) with ESMTP id A45DE83 for ; Wed, 20 Oct 2021 13:22:51 +0000 (UTC) From: "Mike Pagano" To: gentoo-commits@lists.gentoo.org Content-Transfer-Encoding: 8bit Content-type: text/plain; charset=UTF-8 Reply-To: gentoo-dev@lists.gentoo.org, "Mike Pagano" Message-ID: <1634736153.a7ca4775ed7327b81ce2817711f77e28b0bcb732.mpagano@gentoo> Subject: [gentoo-commits] proj/linux-patches:5.14 commit in: / X-VCS-Repository: proj/linux-patches X-VCS-Files: 0000_README 1013_linux-5.14.14.patch X-VCS-Directories: / X-VCS-Committer: mpagano X-VCS-Committer-Name: Mike Pagano X-VCS-Revision: a7ca4775ed7327b81ce2817711f77e28b0bcb732 X-VCS-Branch: 5.14 Date: Wed, 20 Oct 2021 13:22:51 +0000 (UTC) Precedence: bulk List-Post: List-Help: List-Unsubscribe: List-Subscribe: List-Id: Gentoo Linux mail X-BeenThere: gentoo-commits@lists.gentoo.org X-Auto-Response-Suppress: DR, RN, NRN, OOF, AutoReply X-Archives-Salt: 19741d9b-1ea5-4712-b14d-9290477c1b00 X-Archives-Hash: b2a14486a2461ff1e8e512c881c42145 commit: a7ca4775ed7327b81ce2817711f77e28b0bcb732 Author: Mike Pagano gentoo org> AuthorDate: Wed Oct 20 13:22:33 2021 +0000 Commit: Mike Pagano gentoo org> CommitDate: Wed Oct 20 13:22:33 2021 +0000 URL: https://gitweb.gentoo.org/proj/linux-patches.git/commit/?id=a7ca4775 Linux patch 5.14.14 Signed-off-by: Mike Pagano gentoo.org> 0000_README | 4 + 1013_linux-5.14.14.patch | 4421 ++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 4425 insertions(+) diff --git a/0000_README b/0000_README index 31ed9a4..1bea116 100644 --- a/0000_README +++ b/0000_README @@ -99,6 +99,10 @@ Patch: 1012_linux-5.14.13.patch From: http://www.kernel.org Desc: Linux 5.14.13 +Patch: 1013_linux-5.14.14.patch +From: http://www.kernel.org +Desc: Linux 5.14.14 + Patch: 1500_XATTR_USER_PREFIX.patch From: https://bugs.gentoo.org/show_bug.cgi?id=470644 Desc: Support for namespace user.pax.* on tmpfs. diff --git a/1013_linux-5.14.14.patch b/1013_linux-5.14.14.patch new file mode 100644 index 0000000..f4e20f8 --- /dev/null +++ b/1013_linux-5.14.14.patch @@ -0,0 +1,4421 @@ +diff --git a/Makefile b/Makefile +index 7bdca9dc0e61b..f05668e1ffaba 100644 +--- a/Makefile ++++ b/Makefile +@@ -1,7 +1,7 @@ + # SPDX-License-Identifier: GPL-2.0 + VERSION = 5 + PATCHLEVEL = 14 +-SUBLEVEL = 13 ++SUBLEVEL = 14 + EXTRAVERSION = + NAME = Opossums on Parade + +diff --git a/arch/arm/boot/dts/bcm2711-rpi-4-b.dts b/arch/arm/boot/dts/bcm2711-rpi-4-b.dts +index f24bdd0870a52..72ce80fbf2662 100644 +--- a/arch/arm/boot/dts/bcm2711-rpi-4-b.dts ++++ b/arch/arm/boot/dts/bcm2711-rpi-4-b.dts +@@ -40,8 +40,8 @@ + regulator-always-on; + regulator-settling-time-us = <5000>; + gpios = <&expgpio 4 GPIO_ACTIVE_HIGH>; +- states = <1800000 0x1 +- 3300000 0x0>; ++ states = <1800000 0x1>, ++ <3300000 0x0>; + status = "okay"; + }; + +@@ -217,15 +217,16 @@ + }; + + &pcie0 { +- pci@1,0 { ++ pci@0,0 { ++ device_type = "pci"; + #address-cells = <3>; + #size-cells = <2>; + ranges; + + reg = <0 0 0 0 0>; + +- usb@1,0 { +- reg = <0x10000 0 0 0 0>; ++ usb@0,0 { ++ reg = <0 0 0 0 0>; + resets = <&reset RASPBERRYPI_FIRMWARE_RESET_ID_USB>; + }; + }; +diff --git a/arch/arm/boot/dts/bcm2711.dtsi b/arch/arm/boot/dts/bcm2711.dtsi +index b8a4096192aa9..3b60297af7f60 100644 +--- a/arch/arm/boot/dts/bcm2711.dtsi ++++ b/arch/arm/boot/dts/bcm2711.dtsi +@@ -300,6 +300,14 @@ + status = "disabled"; + }; + ++ vec: vec@7ec13000 { ++ compatible = "brcm,bcm2711-vec"; ++ reg = <0x7ec13000 0x1000>; ++ clocks = <&clocks BCM2835_CLOCK_VEC>; ++ interrupts = ; ++ status = "disabled"; ++ }; ++ + dvp: clock@7ef00000 { + compatible = "brcm,brcm2711-dvp"; + reg = <0x7ef00000 0x10>; +@@ -532,8 +540,8 @@ + compatible = "brcm,genet-mdio-v5"; + reg = <0xe14 0x8>; + reg-names = "mdio"; +- #address-cells = <0x0>; +- #size-cells = <0x1>; ++ #address-cells = <0x1>; ++ #size-cells = <0x0>; + }; + }; + }; +diff --git a/arch/arm/boot/dts/bcm2835-common.dtsi b/arch/arm/boot/dts/bcm2835-common.dtsi +index 4119271c979d6..c25e797b90600 100644 +--- a/arch/arm/boot/dts/bcm2835-common.dtsi ++++ b/arch/arm/boot/dts/bcm2835-common.dtsi +@@ -106,6 +106,14 @@ + status = "okay"; + }; + ++ vec: vec@7e806000 { ++ compatible = "brcm,bcm2835-vec"; ++ reg = <0x7e806000 0x1000>; ++ clocks = <&clocks BCM2835_CLOCK_VEC>; ++ interrupts = <2 27>; ++ status = "disabled"; ++ }; ++ + pixelvalve@7e807000 { + compatible = "brcm,bcm2835-pixelvalve2"; + reg = <0x7e807000 0x100>; +diff --git a/arch/arm/boot/dts/bcm283x.dtsi b/arch/arm/boot/dts/bcm283x.dtsi +index 0f3be55201a5b..a3e06b6809476 100644 +--- a/arch/arm/boot/dts/bcm283x.dtsi ++++ b/arch/arm/boot/dts/bcm283x.dtsi +@@ -464,14 +464,6 @@ + status = "disabled"; + }; + +- vec: vec@7e806000 { +- compatible = "brcm,bcm2835-vec"; +- reg = <0x7e806000 0x1000>; +- clocks = <&clocks BCM2835_CLOCK_VEC>; +- interrupts = <2 27>; +- status = "disabled"; +- }; +- + usb: usb@7e980000 { + compatible = "brcm,bcm2835-usb"; + reg = <0x7e980000 0x10000>; +diff --git a/arch/arm64/mm/hugetlbpage.c b/arch/arm64/mm/hugetlbpage.c +index 23505fc353247..a8158c9489666 100644 +--- a/arch/arm64/mm/hugetlbpage.c ++++ b/arch/arm64/mm/hugetlbpage.c +@@ -43,7 +43,7 @@ void __init arm64_hugetlb_cma_reserve(void) + #ifdef CONFIG_ARM64_4K_PAGES + order = PUD_SHIFT - PAGE_SHIFT; + #else +- order = CONT_PMD_SHIFT + PMD_SHIFT - PAGE_SHIFT; ++ order = CONT_PMD_SHIFT - PAGE_SHIFT; + #endif + /* + * HugeTLB CMA reservation is required for gigantic +diff --git a/arch/csky/kernel/ptrace.c b/arch/csky/kernel/ptrace.c +index 0105ac81b4328..1a5f54e0d2726 100644 +--- a/arch/csky/kernel/ptrace.c ++++ b/arch/csky/kernel/ptrace.c +@@ -99,7 +99,8 @@ static int gpr_set(struct task_struct *target, + if (ret) + return ret; + +- regs.sr = task_pt_regs(target)->sr; ++ /* BIT(0) of regs.sr is Condition Code/Carry bit */ ++ regs.sr = (regs.sr & BIT(0)) | (task_pt_regs(target)->sr & ~BIT(0)); + #ifdef CONFIG_CPU_HAS_HILO + regs.dcsr = task_pt_regs(target)->dcsr; + #endif +diff --git a/arch/csky/kernel/signal.c b/arch/csky/kernel/signal.c +index 312f046d452d8..6ba3969ec175e 100644 +--- a/arch/csky/kernel/signal.c ++++ b/arch/csky/kernel/signal.c +@@ -52,10 +52,14 @@ static long restore_sigcontext(struct pt_regs *regs, + struct sigcontext __user *sc) + { + int err = 0; ++ unsigned long sr = regs->sr; + + /* sc_pt_regs is structured the same as the start of pt_regs */ + err |= __copy_from_user(regs, &sc->sc_pt_regs, sizeof(struct pt_regs)); + ++ /* BIT(0) of regs->sr is Condition Code/Carry bit */ ++ regs->sr = (sr & ~1) | (regs->sr & 1); ++ + /* Restore the floating-point state. */ + err |= restore_fpu_state(sc); + +diff --git a/arch/powerpc/sysdev/xive/common.c b/arch/powerpc/sysdev/xive/common.c +index 8183ca343675a..1d2546ac6fbc3 100644 +--- a/arch/powerpc/sysdev/xive/common.c ++++ b/arch/powerpc/sysdev/xive/common.c +@@ -961,7 +961,8 @@ static int xive_get_irqchip_state(struct irq_data *data, + * interrupt to be inactive in that case. + */ + *state = (pq != XIVE_ESB_INVALID) && !xd->stale_p && +- (xd->saved_p || !!(pq & XIVE_ESB_VAL_P)); ++ (xd->saved_p || (!!(pq & XIVE_ESB_VAL_P) && ++ !irqd_irq_disabled(data))); + return 0; + default: + return -EINVAL; +diff --git a/arch/s390/lib/string.c b/arch/s390/lib/string.c +index cfcdf76d6a957..a95ca6df4e5e6 100644 +--- a/arch/s390/lib/string.c ++++ b/arch/s390/lib/string.c +@@ -259,14 +259,13 @@ EXPORT_SYMBOL(strcmp); + #ifdef __HAVE_ARCH_STRRCHR + char *strrchr(const char *s, int c) + { +- size_t len = __strend(s) - s; +- +- if (len) +- do { +- if (s[len] == (char) c) +- return (char *) s + len; +- } while (--len > 0); +- return NULL; ++ ssize_t len = __strend(s) - s; ++ ++ do { ++ if (s[len] == (char)c) ++ return (char *)s + len; ++ } while (--len >= 0); ++ return NULL; + } + EXPORT_SYMBOL(strrchr); + #endif +diff --git a/arch/x86/Kconfig b/arch/x86/Kconfig +index 51341f2e218de..551eaab376f31 100644 +--- a/arch/x86/Kconfig ++++ b/arch/x86/Kconfig +@@ -1520,7 +1520,6 @@ config AMD_MEM_ENCRYPT + + config AMD_MEM_ENCRYPT_ACTIVE_BY_DEFAULT + bool "Activate AMD Secure Memory Encryption (SME) by default" +- default y + depends on AMD_MEM_ENCRYPT + help + Say yes to have system memory encrypted by default if running on +diff --git a/arch/x86/kernel/cpu/resctrl/core.c b/arch/x86/kernel/cpu/resctrl/core.c +index 23001ae03e82b..7afc2d72d8634 100644 +--- a/arch/x86/kernel/cpu/resctrl/core.c ++++ b/arch/x86/kernel/cpu/resctrl/core.c +@@ -590,6 +590,8 @@ static void domain_add_cpu(int cpu, struct rdt_resource *r) + } + + if (r->mon_capable && domain_setup_mon_state(r, d)) { ++ kfree(d->ctrl_val); ++ kfree(d->mbps_val); + kfree(d); + return; + } +diff --git a/arch/x86/kernel/fpu/signal.c b/arch/x86/kernel/fpu/signal.c +index fa17a27390ab0..831b25c5e7058 100644 +--- a/arch/x86/kernel/fpu/signal.c ++++ b/arch/x86/kernel/fpu/signal.c +@@ -385,7 +385,7 @@ static int __fpu_restore_sig(void __user *buf, void __user *buf_fx, + return -EINVAL; + } else { + /* Mask invalid bits out for historical reasons (broken hardware). */ +- fpu->state.fxsave.mxcsr &= ~mxcsr_feature_mask; ++ fpu->state.fxsave.mxcsr &= mxcsr_feature_mask; + } + + /* Enforce XFEATURE_MASK_FPSSE when XSAVE is enabled */ +diff --git a/drivers/acpi/arm64/gtdt.c b/drivers/acpi/arm64/gtdt.c +index 0a0a982f9c28d..c0e77c1c8e09d 100644 +--- a/drivers/acpi/arm64/gtdt.c ++++ b/drivers/acpi/arm64/gtdt.c +@@ -36,7 +36,7 @@ struct acpi_gtdt_descriptor { + + static struct acpi_gtdt_descriptor acpi_gtdt_desc __initdata; + +-static inline void *next_platform_timer(void *platform_timer) ++static inline __init void *next_platform_timer(void *platform_timer) + { + struct acpi_gtdt_header *gh = platform_timer; + +diff --git a/drivers/acpi/x86/s2idle.c b/drivers/acpi/x86/s2idle.c +index bd92b549fd5a4..1c48358b43ba3 100644 +--- a/drivers/acpi/x86/s2idle.c ++++ b/drivers/acpi/x86/s2idle.c +@@ -371,7 +371,7 @@ static int lps0_device_attach(struct acpi_device *adev, + return 0; + + if (acpi_s2idle_vendor_amd()) { +- /* AMD0004, AMDI0005: ++ /* AMD0004, AMD0005, AMDI0005: + * - Should use rev_id 0x0 + * - function mask > 0x3: Should use AMD method, but has off by one bug + * - function mask = 0x3: Should use Microsoft method +@@ -390,6 +390,7 @@ static int lps0_device_attach(struct acpi_device *adev, + ACPI_LPS0_DSM_UUID_MICROSOFT, 0, + &lps0_dsm_guid_microsoft); + if (lps0_dsm_func_mask > 0x3 && (!strcmp(hid, "AMD0004") || ++ !strcmp(hid, "AMD0005") || + !strcmp(hid, "AMDI0005"))) { + lps0_dsm_func_mask = (lps0_dsm_func_mask << 1) | 0x1; + acpi_handle_debug(adev->handle, "_DSM UUID %s: Adjusted function mask: 0x%x\n", +diff --git a/drivers/ata/libahci_platform.c b/drivers/ata/libahci_platform.c +index b2f5520882918..0910441321f72 100644 +--- a/drivers/ata/libahci_platform.c ++++ b/drivers/ata/libahci_platform.c +@@ -440,10 +440,7 @@ struct ahci_host_priv *ahci_platform_get_resources(struct platform_device *pdev, + hpriv->phy_regulator = devm_regulator_get(dev, "phy"); + if (IS_ERR(hpriv->phy_regulator)) { + rc = PTR_ERR(hpriv->phy_regulator); +- if (rc == -EPROBE_DEFER) +- goto err_out; +- rc = 0; +- hpriv->phy_regulator = NULL; ++ goto err_out; + } + + if (flags & AHCI_PLATFORM_GET_RESETS) { +diff --git a/drivers/ata/pata_legacy.c b/drivers/ata/pata_legacy.c +index c3e6592712c4b..0a8bf09a5c19e 100644 +--- a/drivers/ata/pata_legacy.c ++++ b/drivers/ata/pata_legacy.c +@@ -352,7 +352,8 @@ static unsigned int pdc_data_xfer_vlb(struct ata_queued_cmd *qc, + iowrite32_rep(ap->ioaddr.data_addr, buf, buflen >> 2); + + if (unlikely(slop)) { +- __le32 pad; ++ __le32 pad = 0; ++ + if (rw == READ) { + pad = cpu_to_le32(ioread32(ap->ioaddr.data_addr)); + memcpy(buf + buflen - slop, &pad, slop); +@@ -742,7 +743,8 @@ static unsigned int vlb32_data_xfer(struct ata_queued_cmd *qc, + ioread32_rep(ap->ioaddr.data_addr, buf, buflen >> 2); + + if (unlikely(slop)) { +- __le32 pad; ++ __le32 pad = 0; ++ + if (rw == WRITE) { + memcpy(&pad, buf + buflen - slop, slop); + iowrite32(le32_to_cpu(pad), ap->ioaddr.data_addr); +diff --git a/drivers/base/core.c b/drivers/base/core.c +index 56f54e6eb9874..f150ebebb3068 100644 +--- a/drivers/base/core.c ++++ b/drivers/base/core.c +@@ -675,7 +675,8 @@ struct device_link *device_link_add(struct device *consumer, + { + struct device_link *link; + +- if (!consumer || !supplier || flags & ~DL_ADD_VALID_FLAGS || ++ if (!consumer || !supplier || consumer == supplier || ++ flags & ~DL_ADD_VALID_FLAGS || + (flags & DL_FLAG_STATELESS && flags & DL_MANAGED_LINK_FLAGS) || + (flags & DL_FLAG_SYNC_STATE_ONLY && + (flags & ~DL_FLAG_INFERRED) != DL_FLAG_SYNC_STATE_ONLY) || +diff --git a/drivers/block/rnbd/rnbd-clt-sysfs.c b/drivers/block/rnbd/rnbd-clt-sysfs.c +index 324afdd63a967..102c08ad4dd06 100644 +--- a/drivers/block/rnbd/rnbd-clt-sysfs.c ++++ b/drivers/block/rnbd/rnbd-clt-sysfs.c +@@ -71,8 +71,10 @@ static int rnbd_clt_parse_map_options(const char *buf, size_t max_path_cnt, + int opt_mask = 0; + int token; + int ret = -EINVAL; +- int i, dest_port, nr_poll_queues; ++ int nr_poll_queues = 0; ++ int dest_port = 0; + int p_cnt = 0; ++ int i; + + options = kstrdup(buf, GFP_KERNEL); + if (!options) +diff --git a/drivers/block/virtio_blk.c b/drivers/block/virtio_blk.c +index afb37aac09e88..e870248d5c152 100644 +--- a/drivers/block/virtio_blk.c ++++ b/drivers/block/virtio_blk.c +@@ -692,28 +692,6 @@ static const struct blk_mq_ops virtio_mq_ops = { + static unsigned int virtblk_queue_depth; + module_param_named(queue_depth, virtblk_queue_depth, uint, 0444); + +-static int virtblk_validate(struct virtio_device *vdev) +-{ +- u32 blk_size; +- +- if (!vdev->config->get) { +- dev_err(&vdev->dev, "%s failure: config access disabled\n", +- __func__); +- return -EINVAL; +- } +- +- if (!virtio_has_feature(vdev, VIRTIO_BLK_F_BLK_SIZE)) +- return 0; +- +- blk_size = virtio_cread32(vdev, +- offsetof(struct virtio_blk_config, blk_size)); +- +- if (blk_size < SECTOR_SIZE || blk_size > PAGE_SIZE) +- __virtio_clear_bit(vdev, VIRTIO_BLK_F_BLK_SIZE); +- +- return 0; +-} +- + static int virtblk_probe(struct virtio_device *vdev) + { + struct virtio_blk *vblk; +@@ -725,6 +703,12 @@ static int virtblk_probe(struct virtio_device *vdev) + u8 physical_block_exp, alignment_offset; + unsigned int queue_depth; + ++ if (!vdev->config->get) { ++ dev_err(&vdev->dev, "%s failure: config access disabled\n", ++ __func__); ++ return -EINVAL; ++ } ++ + err = ida_simple_get(&vd_index_ida, 0, minor_to_index(1 << MINORBITS), + GFP_KERNEL); + if (err < 0) +@@ -765,7 +749,7 @@ static int virtblk_probe(struct virtio_device *vdev) + goto out_free_vblk; + + /* Default queue sizing is to fill the ring. */ +- if (likely(!virtblk_queue_depth)) { ++ if (!virtblk_queue_depth) { + queue_depth = vblk->vqs[0].vq->num_free; + /* ... but without indirect descs, we use 2 descs per req */ + if (!virtio_has_feature(vdev, VIRTIO_RING_F_INDIRECT_DESC)) +@@ -839,14 +823,6 @@ static int virtblk_probe(struct virtio_device *vdev) + else + blk_size = queue_logical_block_size(q); + +- if (unlikely(blk_size < SECTOR_SIZE || blk_size > PAGE_SIZE)) { +- dev_err(&vdev->dev, +- "block size is changed unexpectedly, now is %u\n", +- blk_size); +- err = -EINVAL; +- goto err_cleanup_disk; +- } +- + /* Use topology information if available */ + err = virtio_cread_feature(vdev, VIRTIO_BLK_F_TOPOLOGY, + struct virtio_blk_config, physical_block_exp, +@@ -905,8 +881,6 @@ static int virtblk_probe(struct virtio_device *vdev) + device_add_disk(&vdev->dev, vblk->disk, virtblk_attr_groups); + return 0; + +-err_cleanup_disk: +- blk_cleanup_disk(vblk->disk); + out_free_tags: + blk_mq_free_tag_set(&vblk->tag_set); + out_free_vq: +@@ -1009,7 +983,6 @@ static struct virtio_driver virtio_blk = { + .driver.name = KBUILD_MODNAME, + .driver.owner = THIS_MODULE, + .id_table = id_table, +- .validate = virtblk_validate, + .probe = virtblk_probe, + .remove = virtblk_remove, + .config_changed = virtblk_config_changed, +diff --git a/drivers/bus/simple-pm-bus.c b/drivers/bus/simple-pm-bus.c +index 01a3d0cd08edc..6b8d6257ed8a4 100644 +--- a/drivers/bus/simple-pm-bus.c ++++ b/drivers/bus/simple-pm-bus.c +@@ -13,11 +13,36 @@ + #include + #include + +- + static int simple_pm_bus_probe(struct platform_device *pdev) + { +- const struct of_dev_auxdata *lookup = dev_get_platdata(&pdev->dev); +- struct device_node *np = pdev->dev.of_node; ++ const struct device *dev = &pdev->dev; ++ const struct of_dev_auxdata *lookup = dev_get_platdata(dev); ++ struct device_node *np = dev->of_node; ++ const struct of_device_id *match; ++ ++ /* ++ * Allow user to use driver_override to bind this driver to a ++ * transparent bus device which has a different compatible string ++ * that's not listed in simple_pm_bus_of_match. We don't want to do any ++ * of the simple-pm-bus tasks for these devices, so return early. ++ */ ++ if (pdev->driver_override) ++ return 0; ++ ++ match = of_match_device(dev->driver->of_match_table, dev); ++ /* ++ * These are transparent bus devices (not simple-pm-bus matches) that ++ * have their child nodes populated automatically. So, don't need to ++ * do anything more. We only match with the device if this driver is ++ * the most specific match because we don't want to incorrectly bind to ++ * a device that has a more specific driver. ++ */ ++ if (match && match->data) { ++ if (of_property_match_string(np, "compatible", match->compatible) == 0) ++ return 0; ++ else ++ return -ENODEV; ++ } + + dev_dbg(&pdev->dev, "%s\n", __func__); + +@@ -31,14 +56,25 @@ static int simple_pm_bus_probe(struct platform_device *pdev) + + static int simple_pm_bus_remove(struct platform_device *pdev) + { ++ const void *data = of_device_get_match_data(&pdev->dev); ++ ++ if (pdev->driver_override || data) ++ return 0; ++ + dev_dbg(&pdev->dev, "%s\n", __func__); + + pm_runtime_disable(&pdev->dev); + return 0; + } + ++#define ONLY_BUS ((void *) 1) /* Match if the device is only a bus. */ ++ + static const struct of_device_id simple_pm_bus_of_match[] = { + { .compatible = "simple-pm-bus", }, ++ { .compatible = "simple-bus", .data = ONLY_BUS }, ++ { .compatible = "simple-mfd", .data = ONLY_BUS }, ++ { .compatible = "isa", .data = ONLY_BUS }, ++ { .compatible = "arm,amba-bus", .data = ONLY_BUS }, + { /* sentinel */ } + }; + MODULE_DEVICE_TABLE(of, simple_pm_bus_of_match); +diff --git a/drivers/clk/renesas/renesas-rzg2l-cpg.c b/drivers/clk/renesas/renesas-rzg2l-cpg.c +index f894a210de902..ab6149b2048b5 100644 +--- a/drivers/clk/renesas/renesas-rzg2l-cpg.c ++++ b/drivers/clk/renesas/renesas-rzg2l-cpg.c +@@ -398,7 +398,7 @@ static int rzg2l_mod_clock_is_enabled(struct clk_hw *hw) + + value = readl(priv->base + CLK_MON_R(clock->off)); + +- return !(value & bitmask); ++ return value & bitmask; + } + + static const struct clk_ops rzg2l_mod_clock_ops = { +diff --git a/drivers/clk/socfpga/clk-agilex.c b/drivers/clk/socfpga/clk-agilex.c +index 242e94c0cf8a3..bf8cd928c2283 100644 +--- a/drivers/clk/socfpga/clk-agilex.c ++++ b/drivers/clk/socfpga/clk-agilex.c +@@ -165,13 +165,6 @@ static const struct clk_parent_data mpu_mux[] = { + .name = "boot_clk", }, + }; + +-static const struct clk_parent_data s2f_usr0_mux[] = { +- { .fw_name = "f2s-free-clk", +- .name = "f2s-free-clk", }, +- { .fw_name = "boot_clk", +- .name = "boot_clk", }, +-}; +- + static const struct clk_parent_data emac_mux[] = { + { .fw_name = "emaca_free_clk", + .name = "emaca_free_clk", }, +@@ -312,8 +305,6 @@ static const struct stratix10_gate_clock agilex_gate_clks[] = { + 4, 0x44, 28, 1, 0, 0, 0}, + { AGILEX_CS_TIMER_CLK, "cs_timer_clk", NULL, noc_mux, ARRAY_SIZE(noc_mux), 0, 0x24, + 5, 0, 0, 0, 0x30, 1, 0}, +- { AGILEX_S2F_USER0_CLK, "s2f_user0_clk", NULL, s2f_usr0_mux, ARRAY_SIZE(s2f_usr0_mux), 0, 0x24, +- 6, 0, 0, 0, 0, 0, 0}, + { AGILEX_EMAC0_CLK, "emac0_clk", NULL, emac_mux, ARRAY_SIZE(emac_mux), 0, 0x7C, + 0, 0, 0, 0, 0x94, 26, 0}, + { AGILEX_EMAC1_CLK, "emac1_clk", NULL, emac_mux, ARRAY_SIZE(emac_mux), 0, 0x7C, +diff --git a/drivers/edac/armada_xp_edac.c b/drivers/edac/armada_xp_edac.c +index e3e757513d1bc..b1f46a974b9e0 100644 +--- a/drivers/edac/armada_xp_edac.c ++++ b/drivers/edac/armada_xp_edac.c +@@ -178,7 +178,7 @@ static void axp_mc_check(struct mem_ctl_info *mci) + "details unavailable (multiple errors)"); + if (cnt_dbe) + edac_mc_handle_error(HW_EVENT_ERR_UNCORRECTED, mci, +- cnt_sbe, /* error count */ ++ cnt_dbe, /* error count */ + 0, 0, 0, /* pfn, offset, syndrome */ + -1, -1, -1, /* top, mid, low layer */ + mci->ctl_name, +diff --git a/drivers/firmware/arm_ffa/bus.c b/drivers/firmware/arm_ffa/bus.c +index 00fe595a5bc89..fca1e311ea6c7 100644 +--- a/drivers/firmware/arm_ffa/bus.c ++++ b/drivers/firmware/arm_ffa/bus.c +@@ -49,6 +49,15 @@ static int ffa_device_probe(struct device *dev) + return ffa_drv->probe(ffa_dev); + } + ++static int ffa_device_remove(struct device *dev) ++{ ++ struct ffa_driver *ffa_drv = to_ffa_driver(dev->driver); ++ ++ ffa_drv->remove(to_ffa_dev(dev)); ++ ++ return 0; ++} ++ + static int ffa_device_uevent(struct device *dev, struct kobj_uevent_env *env) + { + struct ffa_device *ffa_dev = to_ffa_dev(dev); +@@ -86,6 +95,7 @@ struct bus_type ffa_bus_type = { + .name = "arm_ffa", + .match = ffa_device_match, + .probe = ffa_device_probe, ++ .remove = ffa_device_remove, + .uevent = ffa_device_uevent, + .dev_groups = ffa_device_attributes_groups, + }; +@@ -127,7 +137,7 @@ static void ffa_release_device(struct device *dev) + + static int __ffa_devices_unregister(struct device *dev, void *data) + { +- ffa_release_device(dev); ++ device_unregister(dev); + + return 0; + } +diff --git a/drivers/firmware/efi/cper.c b/drivers/firmware/efi/cper.c +index ea7ca74fc1730..232c092c4c970 100644 +--- a/drivers/firmware/efi/cper.c ++++ b/drivers/firmware/efi/cper.c +@@ -25,8 +25,6 @@ + #include + #include + +-static char rcd_decode_str[CPER_REC_LEN]; +- + /* + * CPER record ID need to be unique even after reboot, because record + * ID is used as index for ERST storage, while CPER records from +@@ -313,6 +311,7 @@ const char *cper_mem_err_unpack(struct trace_seq *p, + struct cper_mem_err_compact *cmem) + { + const char *ret = trace_seq_buffer_ptr(p); ++ char rcd_decode_str[CPER_REC_LEN]; + + if (cper_mem_err_location(cmem, rcd_decode_str)) + trace_seq_printf(p, "%s", rcd_decode_str); +@@ -327,6 +326,7 @@ static void cper_print_mem(const char *pfx, const struct cper_sec_mem_err *mem, + int len) + { + struct cper_mem_err_compact cmem; ++ char rcd_decode_str[CPER_REC_LEN]; + + /* Don't trust UEFI 2.1/2.2 structure with bad validation bits */ + if (len == sizeof(struct cper_sec_mem_err_old) && +diff --git a/drivers/firmware/efi/runtime-wrappers.c b/drivers/firmware/efi/runtime-wrappers.c +index 1410beaef5c30..f3e54f6616f02 100644 +--- a/drivers/firmware/efi/runtime-wrappers.c ++++ b/drivers/firmware/efi/runtime-wrappers.c +@@ -414,7 +414,7 @@ static void virt_efi_reset_system(int reset_type, + unsigned long data_size, + efi_char16_t *data) + { +- if (down_interruptible(&efi_runtime_lock)) { ++ if (down_trylock(&efi_runtime_lock)) { + pr_warn("failed to invoke the reset_system() runtime service:\n" + "could not get exclusive access to the firmware\n"); + return; +diff --git a/drivers/fpga/ice40-spi.c b/drivers/fpga/ice40-spi.c +index 69dec5af23c36..029d3cdb918d1 100644 +--- a/drivers/fpga/ice40-spi.c ++++ b/drivers/fpga/ice40-spi.c +@@ -192,12 +192,19 @@ static const struct of_device_id ice40_fpga_of_match[] = { + }; + MODULE_DEVICE_TABLE(of, ice40_fpga_of_match); + ++static const struct spi_device_id ice40_fpga_spi_ids[] = { ++ { .name = "ice40-fpga-mgr", }, ++ {}, ++}; ++MODULE_DEVICE_TABLE(spi, ice40_fpga_spi_ids); ++ + static struct spi_driver ice40_fpga_driver = { + .probe = ice40_fpga_probe, + .driver = { + .name = "ice40spi", + .of_match_table = of_match_ptr(ice40_fpga_of_match), + }, ++ .id_table = ice40_fpga_spi_ids, + }; + + module_spi_driver(ice40_fpga_driver); +diff --git a/drivers/gpio/gpio-74x164.c b/drivers/gpio/gpio-74x164.c +index 05637d5851526..4a55cdf089d62 100644 +--- a/drivers/gpio/gpio-74x164.c ++++ b/drivers/gpio/gpio-74x164.c +@@ -174,6 +174,13 @@ static int gen_74x164_remove(struct spi_device *spi) + return 0; + } + ++static const struct spi_device_id gen_74x164_spi_ids[] = { ++ { .name = "74hc595" }, ++ { .name = "74lvc594" }, ++ {}, ++}; ++MODULE_DEVICE_TABLE(spi, gen_74x164_spi_ids); ++ + static const struct of_device_id gen_74x164_dt_ids[] = { + { .compatible = "fairchild,74hc595" }, + { .compatible = "nxp,74lvc594" }, +@@ -188,6 +195,7 @@ static struct spi_driver gen_74x164_driver = { + }, + .probe = gen_74x164_probe, + .remove = gen_74x164_remove, ++ .id_table = gen_74x164_spi_ids, + }; + module_spi_driver(gen_74x164_driver); + +diff --git a/drivers/gpio/gpio-pca953x.c b/drivers/gpio/gpio-pca953x.c +index 8ebf369b3ba0f..d2fe76f3f34fd 100644 +--- a/drivers/gpio/gpio-pca953x.c ++++ b/drivers/gpio/gpio-pca953x.c +@@ -559,21 +559,21 @@ static int pca953x_gpio_set_pull_up_down(struct pca953x_chip *chip, + + mutex_lock(&chip->i2c_lock); + +- /* Disable pull-up/pull-down */ +- ret = regmap_write_bits(chip->regmap, pull_en_reg, bit, 0); +- if (ret) +- goto exit; +- + /* Configure pull-up/pull-down */ + if (config == PIN_CONFIG_BIAS_PULL_UP) + ret = regmap_write_bits(chip->regmap, pull_sel_reg, bit, bit); + else if (config == PIN_CONFIG_BIAS_PULL_DOWN) + ret = regmap_write_bits(chip->regmap, pull_sel_reg, bit, 0); ++ else ++ ret = 0; + if (ret) + goto exit; + +- /* Enable pull-up/pull-down */ +- ret = regmap_write_bits(chip->regmap, pull_en_reg, bit, bit); ++ /* Disable/Enable pull-up/pull-down */ ++ if (config == PIN_CONFIG_BIAS_DISABLE) ++ ret = regmap_write_bits(chip->regmap, pull_en_reg, bit, 0); ++ else ++ ret = regmap_write_bits(chip->regmap, pull_en_reg, bit, bit); + + exit: + mutex_unlock(&chip->i2c_lock); +@@ -587,7 +587,9 @@ static int pca953x_gpio_set_config(struct gpio_chip *gc, unsigned int offset, + + switch (pinconf_to_config_param(config)) { + case PIN_CONFIG_BIAS_PULL_UP: ++ case PIN_CONFIG_BIAS_PULL_PIN_DEFAULT: + case PIN_CONFIG_BIAS_PULL_DOWN: ++ case PIN_CONFIG_BIAS_DISABLE: + return pca953x_gpio_set_pull_up_down(chip, offset, config); + default: + return -ENOTSUPP; +diff --git a/drivers/gpu/drm/drm_edid.c b/drivers/gpu/drm/drm_edid.c +index 81d5f25242469..1dfb2efac6c25 100644 +--- a/drivers/gpu/drm/drm_edid.c ++++ b/drivers/gpu/drm/drm_edid.c +@@ -1834,11 +1834,20 @@ static void connector_bad_edid(struct drm_connector *connector, + u8 *edid, int num_blocks) + { + int i; +- u8 num_of_ext = edid[0x7e]; ++ u8 last_block; ++ ++ /* ++ * 0x7e in the EDID is the number of extension blocks. The EDID ++ * is 1 (base block) + num_ext_blocks big. That means we can think ++ * of 0x7e in the EDID of the _index_ of the last block in the ++ * combined chunk of memory. ++ */ ++ last_block = edid[0x7e]; + + /* Calculate real checksum for the last edid extension block data */ +- connector->real_edid_checksum = +- drm_edid_block_checksum(edid + num_of_ext * EDID_LENGTH); ++ if (last_block < num_blocks) ++ connector->real_edid_checksum = ++ drm_edid_block_checksum(edid + last_block * EDID_LENGTH); + + if (connector->bad_edid_counter++ && !drm_debug_enabled(DRM_UT_KMS)) + return; +diff --git a/drivers/gpu/drm/drm_fb_helper.c b/drivers/gpu/drm/drm_fb_helper.c +index d77a24507d309..c2257a761e38e 100644 +--- a/drivers/gpu/drm/drm_fb_helper.c ++++ b/drivers/gpu/drm/drm_fb_helper.c +@@ -1506,6 +1506,7 @@ static int drm_fb_helper_single_fb_probe(struct drm_fb_helper *fb_helper, + { + struct drm_client_dev *client = &fb_helper->client; + struct drm_device *dev = fb_helper->dev; ++ struct drm_mode_config *config = &dev->mode_config; + int ret = 0; + int crtc_count = 0; + struct drm_connector_list_iter conn_iter; +@@ -1663,6 +1664,11 @@ static int drm_fb_helper_single_fb_probe(struct drm_fb_helper *fb_helper, + /* Handle our overallocation */ + sizes.surface_height *= drm_fbdev_overalloc; + sizes.surface_height /= 100; ++ if (sizes.surface_height > config->max_height) { ++ drm_dbg_kms(dev, "Fbdev over-allocation too large; clamping height to %d\n", ++ config->max_height); ++ sizes.surface_height = config->max_height; ++ } + + /* push down into drivers */ + ret = (*fb_helper->funcs->fb_probe)(fb_helper, &sizes); +diff --git a/drivers/gpu/drm/msm/adreno/a3xx_gpu.c b/drivers/gpu/drm/msm/adreno/a3xx_gpu.c +index 4534633fe7cdb..8fb847c174ff8 100644 +--- a/drivers/gpu/drm/msm/adreno/a3xx_gpu.c ++++ b/drivers/gpu/drm/msm/adreno/a3xx_gpu.c +@@ -571,13 +571,14 @@ struct msm_gpu *a3xx_gpu_init(struct drm_device *dev) + } + + icc_path = devm_of_icc_get(&pdev->dev, "gfx-mem"); +- ret = IS_ERR(icc_path); +- if (ret) ++ if (IS_ERR(icc_path)) { ++ ret = PTR_ERR(icc_path); + goto fail; ++ } + + ocmem_icc_path = devm_of_icc_get(&pdev->dev, "ocmem"); +- ret = IS_ERR(ocmem_icc_path); +- if (ret) { ++ if (IS_ERR(ocmem_icc_path)) { ++ ret = PTR_ERR(ocmem_icc_path); + /* allow -ENODATA, ocmem icc is optional */ + if (ret != -ENODATA) + goto fail; +diff --git a/drivers/gpu/drm/msm/adreno/a4xx_gpu.c b/drivers/gpu/drm/msm/adreno/a4xx_gpu.c +index 82bebb40234de..a96ee79cc5e08 100644 +--- a/drivers/gpu/drm/msm/adreno/a4xx_gpu.c ++++ b/drivers/gpu/drm/msm/adreno/a4xx_gpu.c +@@ -699,13 +699,14 @@ struct msm_gpu *a4xx_gpu_init(struct drm_device *dev) + } + + icc_path = devm_of_icc_get(&pdev->dev, "gfx-mem"); +- ret = IS_ERR(icc_path); +- if (ret) ++ if (IS_ERR(icc_path)) { ++ ret = PTR_ERR(icc_path); + goto fail; ++ } + + ocmem_icc_path = devm_of_icc_get(&pdev->dev, "ocmem"); +- ret = IS_ERR(ocmem_icc_path); +- if (ret) { ++ if (IS_ERR(ocmem_icc_path)) { ++ ret = PTR_ERR(ocmem_icc_path); + /* allow -ENODATA, ocmem icc is optional */ + if (ret != -ENODATA) + goto fail; +diff --git a/drivers/gpu/drm/msm/adreno/a6xx_gpu.c b/drivers/gpu/drm/msm/adreno/a6xx_gpu.c +index 183b9f9c1b315..1b3519b821a3f 100644 +--- a/drivers/gpu/drm/msm/adreno/a6xx_gpu.c ++++ b/drivers/gpu/drm/msm/adreno/a6xx_gpu.c +@@ -102,7 +102,7 @@ static void a6xx_set_pagetable(struct a6xx_gpu *a6xx_gpu, + u32 asid; + u64 memptr = rbmemptr(ring, ttbr0); + +- if (ctx == a6xx_gpu->cur_ctx) ++ if (ctx->seqno == a6xx_gpu->cur_ctx_seqno) + return; + + if (msm_iommu_pagetable_params(ctx->aspace->mmu, &ttbr, &asid)) +@@ -135,7 +135,7 @@ static void a6xx_set_pagetable(struct a6xx_gpu *a6xx_gpu, + OUT_PKT7(ring, CP_EVENT_WRITE, 1); + OUT_RING(ring, 0x31); + +- a6xx_gpu->cur_ctx = ctx; ++ a6xx_gpu->cur_ctx_seqno = ctx->seqno; + } + + static void a6xx_submit(struct msm_gpu *gpu, struct msm_gem_submit *submit) +@@ -1053,7 +1053,7 @@ static int a6xx_hw_init(struct msm_gpu *gpu) + /* Always come up on rb 0 */ + a6xx_gpu->cur_ring = gpu->rb[0]; + +- a6xx_gpu->cur_ctx = NULL; ++ a6xx_gpu->cur_ctx_seqno = 0; + + /* Enable the SQE_to start the CP engine */ + gpu_write(gpu, REG_A6XX_CP_SQE_CNTL, 1); +diff --git a/drivers/gpu/drm/msm/adreno/a6xx_gpu.h b/drivers/gpu/drm/msm/adreno/a6xx_gpu.h +index 0bc2d062f54ab..8e5527c881b1e 100644 +--- a/drivers/gpu/drm/msm/adreno/a6xx_gpu.h ++++ b/drivers/gpu/drm/msm/adreno/a6xx_gpu.h +@@ -19,7 +19,16 @@ struct a6xx_gpu { + uint64_t sqe_iova; + + struct msm_ringbuffer *cur_ring; +- struct msm_file_private *cur_ctx; ++ ++ /** ++ * cur_ctx_seqno: ++ * ++ * The ctx->seqno value of the context with current pgtables ++ * installed. Tracked by seqno rather than pointer value to ++ * avoid dangling pointers, and cases where a ctx can be freed ++ * and a new one created with the same address. ++ */ ++ int cur_ctx_seqno; + + struct a6xx_gmu gmu; + +diff --git a/drivers/gpu/drm/msm/disp/mdp5/mdp5_crtc.c b/drivers/gpu/drm/msm/disp/mdp5/mdp5_crtc.c +index f482e0911d039..bb7d066618e64 100644 +--- a/drivers/gpu/drm/msm/disp/mdp5/mdp5_crtc.c ++++ b/drivers/gpu/drm/msm/disp/mdp5/mdp5_crtc.c +@@ -1125,6 +1125,20 @@ static void mdp5_crtc_reset(struct drm_crtc *crtc) + __drm_atomic_helper_crtc_reset(crtc, &mdp5_cstate->base); + } + ++static const struct drm_crtc_funcs mdp5_crtc_no_lm_cursor_funcs = { ++ .set_config = drm_atomic_helper_set_config, ++ .destroy = mdp5_crtc_destroy, ++ .page_flip = drm_atomic_helper_page_flip, ++ .reset = mdp5_crtc_reset, ++ .atomic_duplicate_state = mdp5_crtc_duplicate_state, ++ .atomic_destroy_state = mdp5_crtc_destroy_state, ++ .atomic_print_state = mdp5_crtc_atomic_print_state, ++ .get_vblank_counter = mdp5_crtc_get_vblank_counter, ++ .enable_vblank = msm_crtc_enable_vblank, ++ .disable_vblank = msm_crtc_disable_vblank, ++ .get_vblank_timestamp = drm_crtc_vblank_helper_get_vblank_timestamp, ++}; ++ + static const struct drm_crtc_funcs mdp5_crtc_funcs = { + .set_config = drm_atomic_helper_set_config, + .destroy = mdp5_crtc_destroy, +@@ -1313,6 +1327,8 @@ struct drm_crtc *mdp5_crtc_init(struct drm_device *dev, + mdp5_crtc->lm_cursor_enabled = cursor_plane ? false : true; + + drm_crtc_init_with_planes(dev, crtc, plane, cursor_plane, ++ cursor_plane ? ++ &mdp5_crtc_no_lm_cursor_funcs : + &mdp5_crtc_funcs, NULL); + + drm_flip_work_init(&mdp5_crtc->unref_cursor_work, +diff --git a/drivers/gpu/drm/msm/dsi/dsi.c b/drivers/gpu/drm/msm/dsi/dsi.c +index 29d11f1cb79b0..4ccf27f66d025 100644 +--- a/drivers/gpu/drm/msm/dsi/dsi.c ++++ b/drivers/gpu/drm/msm/dsi/dsi.c +@@ -208,8 +208,10 @@ int msm_dsi_modeset_init(struct msm_dsi *msm_dsi, struct drm_device *dev, + goto fail; + } + +- if (!msm_dsi_manager_validate_current_config(msm_dsi->id)) ++ if (!msm_dsi_manager_validate_current_config(msm_dsi->id)) { ++ ret = -EINVAL; + goto fail; ++ } + + msm_dsi->encoder = encoder; + +diff --git a/drivers/gpu/drm/msm/dsi/dsi_host.c b/drivers/gpu/drm/msm/dsi/dsi_host.c +index ed504fe5074f6..52826ba350af7 100644 +--- a/drivers/gpu/drm/msm/dsi/dsi_host.c ++++ b/drivers/gpu/drm/msm/dsi/dsi_host.c +@@ -463,7 +463,7 @@ static int dsi_bus_clk_enable(struct msm_dsi_host *msm_host) + + return 0; + err: +- for (; i > 0; i--) ++ while (--i >= 0) + clk_disable_unprepare(msm_host->bus_clks[i]); + + return ret; +diff --git a/drivers/gpu/drm/msm/dsi/phy/dsi_phy_14nm.c b/drivers/gpu/drm/msm/dsi/phy/dsi_phy_14nm.c +index bb31230721bdd..3e1101451c8ac 100644 +--- a/drivers/gpu/drm/msm/dsi/phy/dsi_phy_14nm.c ++++ b/drivers/gpu/drm/msm/dsi/phy/dsi_phy_14nm.c +@@ -110,14 +110,13 @@ static struct dsi_pll_14nm *pll_14nm_list[DSI_MAX]; + static bool pll_14nm_poll_for_ready(struct dsi_pll_14nm *pll_14nm, + u32 nb_tries, u32 timeout_us) + { +- bool pll_locked = false; ++ bool pll_locked = false, pll_ready = false; + void __iomem *base = pll_14nm->phy->pll_base; + u32 tries, val; + + tries = nb_tries; + while (tries--) { +- val = dsi_phy_read(base + +- REG_DSI_14nm_PHY_PLL_RESET_SM_READY_STATUS); ++ val = dsi_phy_read(base + REG_DSI_14nm_PHY_PLL_RESET_SM_READY_STATUS); + pll_locked = !!(val & BIT(5)); + + if (pll_locked) +@@ -126,23 +125,24 @@ static bool pll_14nm_poll_for_ready(struct dsi_pll_14nm *pll_14nm, + udelay(timeout_us); + } + +- if (!pll_locked) { +- tries = nb_tries; +- while (tries--) { +- val = dsi_phy_read(base + +- REG_DSI_14nm_PHY_PLL_RESET_SM_READY_STATUS); +- pll_locked = !!(val & BIT(0)); ++ if (!pll_locked) ++ goto out; + +- if (pll_locked) +- break; ++ tries = nb_tries; ++ while (tries--) { ++ val = dsi_phy_read(base + REG_DSI_14nm_PHY_PLL_RESET_SM_READY_STATUS); ++ pll_ready = !!(val & BIT(0)); + +- udelay(timeout_us); +- } ++ if (pll_ready) ++ break; ++ ++ udelay(timeout_us); + } + +- DBG("DSI PLL is %slocked", pll_locked ? "" : "*not* "); ++out: ++ DBG("DSI PLL is %slocked, %sready", pll_locked ? "" : "*not* ", pll_ready ? "" : "*not* "); + +- return pll_locked; ++ return pll_locked && pll_ready; + } + + static void dsi_pll_14nm_config_init(struct dsi_pll_config *pconf) +diff --git a/drivers/gpu/drm/msm/edp/edp_ctrl.c b/drivers/gpu/drm/msm/edp/edp_ctrl.c +index 4fb397ee7c842..fe1366b4c49f5 100644 +--- a/drivers/gpu/drm/msm/edp/edp_ctrl.c ++++ b/drivers/gpu/drm/msm/edp/edp_ctrl.c +@@ -1116,7 +1116,7 @@ void msm_edp_ctrl_power(struct edp_ctrl *ctrl, bool on) + int msm_edp_ctrl_init(struct msm_edp *edp) + { + struct edp_ctrl *ctrl = NULL; +- struct device *dev = &edp->pdev->dev; ++ struct device *dev; + int ret; + + if (!edp) { +@@ -1124,6 +1124,7 @@ int msm_edp_ctrl_init(struct msm_edp *edp) + return -EINVAL; + } + ++ dev = &edp->pdev->dev; + ctrl = devm_kzalloc(dev, sizeof(*ctrl), GFP_KERNEL); + if (!ctrl) + return -ENOMEM; +diff --git a/drivers/gpu/drm/msm/msm_drv.c b/drivers/gpu/drm/msm/msm_drv.c +index 729ab68d02034..bcb24810905fd 100644 +--- a/drivers/gpu/drm/msm/msm_drv.c ++++ b/drivers/gpu/drm/msm/msm_drv.c +@@ -566,10 +566,11 @@ static int msm_drm_init(struct device *dev, const struct drm_driver *drv) + if (ret) + goto err_msm_uninit; + +- ret = msm_disp_snapshot_init(ddev); +- if (ret) +- DRM_DEV_ERROR(dev, "msm_disp_snapshot_init failed ret = %d\n", ret); +- ++ if (kms) { ++ ret = msm_disp_snapshot_init(ddev); ++ if (ret) ++ DRM_DEV_ERROR(dev, "msm_disp_snapshot_init failed ret = %d\n", ret); ++ } + drm_mode_config_reset(ddev); + + #ifdef CONFIG_DRM_FBDEV_EMULATION +@@ -618,6 +619,7 @@ static void load_gpu(struct drm_device *dev) + + static int context_init(struct drm_device *dev, struct drm_file *file) + { ++ static atomic_t ident = ATOMIC_INIT(0); + struct msm_drm_private *priv = dev->dev_private; + struct msm_file_private *ctx; + +@@ -631,6 +633,8 @@ static int context_init(struct drm_device *dev, struct drm_file *file) + ctx->aspace = msm_gpu_create_private_address_space(priv->gpu, current); + file->driver_priv = ctx; + ++ ctx->seqno = atomic_inc_return(&ident); ++ + return 0; + } + +diff --git a/drivers/gpu/drm/msm/msm_drv.h b/drivers/gpu/drm/msm/msm_drv.h +index 1a48a709ffb36..183d837dcea32 100644 +--- a/drivers/gpu/drm/msm/msm_drv.h ++++ b/drivers/gpu/drm/msm/msm_drv.h +@@ -59,6 +59,7 @@ struct msm_file_private { + int queueid; + struct msm_gem_address_space *aspace; + struct kref ref; ++ int seqno; + }; + + enum msm_mdp_plane_property { +@@ -535,7 +536,7 @@ static inline int align_pitch(int width, int bpp) + static inline unsigned long timeout_to_jiffies(const ktime_t *timeout) + { + ktime_t now = ktime_get(); +- unsigned long remaining_jiffies; ++ s64 remaining_jiffies; + + if (ktime_compare(*timeout, now) < 0) { + remaining_jiffies = 0; +@@ -544,7 +545,7 @@ static inline unsigned long timeout_to_jiffies(const ktime_t *timeout) + remaining_jiffies = ktime_divns(rem, NSEC_PER_SEC / HZ); + } + +- return remaining_jiffies; ++ return clamp(remaining_jiffies, 0LL, (s64)INT_MAX); + } + + #endif /* __MSM_DRV_H__ */ +diff --git a/drivers/gpu/drm/msm/msm_gem_submit.c b/drivers/gpu/drm/msm/msm_gem_submit.c +index 44f84bfd0c0e7..a10b79f9729ef 100644 +--- a/drivers/gpu/drm/msm/msm_gem_submit.c ++++ b/drivers/gpu/drm/msm/msm_gem_submit.c +@@ -161,7 +161,8 @@ out: + static int submit_lookup_cmds(struct msm_gem_submit *submit, + struct drm_msm_gem_submit *args, struct drm_file *file) + { +- unsigned i, sz; ++ unsigned i; ++ size_t sz; + int ret = 0; + + for (i = 0; i < args->nr_cmds; i++) { +diff --git a/drivers/gpu/drm/nouveau/nvkm/engine/fifo/chang84.c b/drivers/gpu/drm/nouveau/nvkm/engine/fifo/chang84.c +index 353b77d9b3dcf..3492c561f2cfc 100644 +--- a/drivers/gpu/drm/nouveau/nvkm/engine/fifo/chang84.c ++++ b/drivers/gpu/drm/nouveau/nvkm/engine/fifo/chang84.c +@@ -82,7 +82,7 @@ g84_fifo_chan_engine_fini(struct nvkm_fifo_chan *base, + if (offset < 0) + return 0; + +- engn = fifo->base.func->engine_id(&fifo->base, engine); ++ engn = fifo->base.func->engine_id(&fifo->base, engine) - 1; + save = nvkm_mask(device, 0x002520, 0x0000003f, 1 << engn); + nvkm_wr32(device, 0x0032fc, chan->base.inst->addr >> 12); + done = nvkm_msec(device, 2000, +diff --git a/drivers/gpu/drm/panel/Kconfig b/drivers/gpu/drm/panel/Kconfig +index ef87d92cdf496..a9c8e05355aa6 100644 +--- a/drivers/gpu/drm/panel/Kconfig ++++ b/drivers/gpu/drm/panel/Kconfig +@@ -273,6 +273,7 @@ config DRM_PANEL_OLIMEX_LCD_OLINUXINO + depends on OF + depends on I2C + depends on BACKLIGHT_CLASS_DEVICE ++ select CRC32 + help + The panel is used with different sizes LCDs, from 480x272 to + 1280x800, and 24 bit per pixel. +diff --git a/drivers/iio/accel/fxls8962af-core.c b/drivers/iio/accel/fxls8962af-core.c +index 0019f1ea7df27..f41db9e0249a7 100644 +--- a/drivers/iio/accel/fxls8962af-core.c ++++ b/drivers/iio/accel/fxls8962af-core.c +@@ -738,7 +738,7 @@ static irqreturn_t fxls8962af_interrupt(int irq, void *p) + + if (reg & FXLS8962AF_INT_STATUS_SRC_BUF) { + ret = fxls8962af_fifo_flush(indio_dev); +- if (ret) ++ if (ret < 0) + return IRQ_NONE; + + return IRQ_HANDLED; +diff --git a/drivers/iio/adc/ad7192.c b/drivers/iio/adc/ad7192.c +index ee8ed9481025d..2121a812b0c31 100644 +--- a/drivers/iio/adc/ad7192.c ++++ b/drivers/iio/adc/ad7192.c +@@ -293,6 +293,7 @@ static const struct ad_sigma_delta_info ad7192_sigma_delta_info = { + .has_registers = true, + .addr_shift = 3, + .read_mask = BIT(6), ++ .irq_flags = IRQF_TRIGGER_FALLING, + }; + + static const struct ad_sd_calib_data ad7192_calib_arr[8] = { +diff --git a/drivers/iio/adc/ad7780.c b/drivers/iio/adc/ad7780.c +index 42bb952f47388..b6e8c8abf6f4c 100644 +--- a/drivers/iio/adc/ad7780.c ++++ b/drivers/iio/adc/ad7780.c +@@ -203,7 +203,7 @@ static const struct ad_sigma_delta_info ad7780_sigma_delta_info = { + .set_mode = ad7780_set_mode, + .postprocess_sample = ad7780_postprocess_sample, + .has_registers = false, +- .irq_flags = IRQF_TRIGGER_LOW, ++ .irq_flags = IRQF_TRIGGER_FALLING, + }; + + #define _AD7780_CHANNEL(_bits, _wordsize, _mask_all) \ +diff --git a/drivers/iio/adc/ad7793.c b/drivers/iio/adc/ad7793.c +index ef3e2d3ecb0c6..0e7ab3fb072a9 100644 +--- a/drivers/iio/adc/ad7793.c ++++ b/drivers/iio/adc/ad7793.c +@@ -206,7 +206,7 @@ static const struct ad_sigma_delta_info ad7793_sigma_delta_info = { + .has_registers = true, + .addr_shift = 3, + .read_mask = BIT(6), +- .irq_flags = IRQF_TRIGGER_LOW, ++ .irq_flags = IRQF_TRIGGER_FALLING, + }; + + static const struct ad_sd_calib_data ad7793_calib_arr[6] = { +diff --git a/drivers/iio/adc/aspeed_adc.c b/drivers/iio/adc/aspeed_adc.c +index 19efaa41bc344..34ec0c28b2dff 100644 +--- a/drivers/iio/adc/aspeed_adc.c ++++ b/drivers/iio/adc/aspeed_adc.c +@@ -183,6 +183,7 @@ static int aspeed_adc_probe(struct platform_device *pdev) + + data = iio_priv(indio_dev); + data->dev = &pdev->dev; ++ platform_set_drvdata(pdev, indio_dev); + + data->base = devm_platform_ioremap_resource(pdev, 0); + if (IS_ERR(data->base)) +diff --git a/drivers/iio/adc/max1027.c b/drivers/iio/adc/max1027.c +index 655ab02d03d84..b753658bb41ec 100644 +--- a/drivers/iio/adc/max1027.c ++++ b/drivers/iio/adc/max1027.c +@@ -103,7 +103,7 @@ MODULE_DEVICE_TABLE(of, max1027_adc_dt_ids); + .sign = 'u', \ + .realbits = depth, \ + .storagebits = 16, \ +- .shift = 2, \ ++ .shift = (depth == 10) ? 2 : 0, \ + .endianness = IIO_BE, \ + }, \ + } +@@ -142,7 +142,6 @@ MODULE_DEVICE_TABLE(of, max1027_adc_dt_ids); + MAX1027_V_CHAN(11, depth) + + #define MAX1X31_CHANNELS(depth) \ +- MAX1X27_CHANNELS(depth), \ + MAX1X29_CHANNELS(depth), \ + MAX1027_V_CHAN(12, depth), \ + MAX1027_V_CHAN(13, depth), \ +diff --git a/drivers/iio/adc/mt6577_auxadc.c b/drivers/iio/adc/mt6577_auxadc.c +index 79c1dd68b9092..d4fccd52ef08b 100644 +--- a/drivers/iio/adc/mt6577_auxadc.c ++++ b/drivers/iio/adc/mt6577_auxadc.c +@@ -82,6 +82,10 @@ static const struct iio_chan_spec mt6577_auxadc_iio_channels[] = { + MT6577_AUXADC_CHANNEL(15), + }; + ++/* For Voltage calculation */ ++#define VOLTAGE_FULL_RANGE 1500 /* VA voltage */ ++#define AUXADC_PRECISE 4096 /* 12 bits */ ++ + static int mt_auxadc_get_cali_data(int rawdata, bool enable_cali) + { + return rawdata; +@@ -191,6 +195,10 @@ static int mt6577_auxadc_read_raw(struct iio_dev *indio_dev, + } + if (adc_dev->dev_comp->sample_data_cali) + *val = mt_auxadc_get_cali_data(*val, true); ++ ++ /* Convert adc raw data to voltage: 0 - 1500 mV */ ++ *val = *val * VOLTAGE_FULL_RANGE / AUXADC_PRECISE; ++ + return IIO_VAL_INT; + + default: +diff --git a/drivers/iio/adc/ti-adc128s052.c b/drivers/iio/adc/ti-adc128s052.c +index 3143f35a6509a..83c1ae07b3e9a 100644 +--- a/drivers/iio/adc/ti-adc128s052.c ++++ b/drivers/iio/adc/ti-adc128s052.c +@@ -171,7 +171,13 @@ static int adc128_probe(struct spi_device *spi) + mutex_init(&adc->lock); + + ret = iio_device_register(indio_dev); ++ if (ret) ++ goto err_disable_regulator; + ++ return 0; ++ ++err_disable_regulator: ++ regulator_disable(adc->reg); + return ret; + } + +diff --git a/drivers/iio/common/ssp_sensors/ssp_spi.c b/drivers/iio/common/ssp_sensors/ssp_spi.c +index 4864c38b8d1c2..769bd9280524a 100644 +--- a/drivers/iio/common/ssp_sensors/ssp_spi.c ++++ b/drivers/iio/common/ssp_sensors/ssp_spi.c +@@ -137,7 +137,7 @@ static int ssp_print_mcu_debug(char *data_frame, int *data_index, + if (length > received_len - *data_index || length <= 0) { + ssp_dbg("[SSP]: MSG From MCU-invalid debug length(%d/%d)\n", + length, received_len); +- return length ? length : -EPROTO; ++ return -EPROTO; + } + + ssp_dbg("[SSP]: MSG From MCU - %s\n", &data_frame[*data_index]); +@@ -273,6 +273,8 @@ static int ssp_parse_dataframe(struct ssp_data *data, char *dataframe, int len) + for (idx = 0; idx < len;) { + switch (dataframe[idx++]) { + case SSP_MSG2AP_INST_BYPASS_DATA: ++ if (idx >= len) ++ return -EPROTO; + sd = dataframe[idx++]; + if (sd < 0 || sd >= SSP_SENSOR_MAX) { + dev_err(SSP_DEV, +@@ -282,10 +284,13 @@ static int ssp_parse_dataframe(struct ssp_data *data, char *dataframe, int len) + + if (indio_devs[sd]) { + spd = iio_priv(indio_devs[sd]); +- if (spd->process_data) ++ if (spd->process_data) { ++ if (idx >= len) ++ return -EPROTO; + spd->process_data(indio_devs[sd], + &dataframe[idx], + data->timestamp); ++ } + } else { + dev_err(SSP_DEV, "no client for frame\n"); + } +@@ -293,6 +298,8 @@ static int ssp_parse_dataframe(struct ssp_data *data, char *dataframe, int len) + idx += ssp_offset_map[sd]; + break; + case SSP_MSG2AP_INST_DEBUG_DATA: ++ if (idx >= len) ++ return -EPROTO; + sd = ssp_print_mcu_debug(dataframe, &idx, len); + if (sd) { + dev_err(SSP_DEV, +diff --git a/drivers/iio/dac/ti-dac5571.c b/drivers/iio/dac/ti-dac5571.c +index 2a5ba1b08a1d0..546a4cf6c5ef8 100644 +--- a/drivers/iio/dac/ti-dac5571.c ++++ b/drivers/iio/dac/ti-dac5571.c +@@ -350,6 +350,7 @@ static int dac5571_probe(struct i2c_client *client, + data->dac5571_pwrdwn = dac5571_pwrdwn_quad; + break; + default: ++ ret = -EINVAL; + goto err; + } + +diff --git a/drivers/iio/imu/adis16475.c b/drivers/iio/imu/adis16475.c +index eb48102f94243..287fff39a927a 100644 +--- a/drivers/iio/imu/adis16475.c ++++ b/drivers/iio/imu/adis16475.c +@@ -353,10 +353,11 @@ static int adis16475_set_freq(struct adis16475 *st, const u32 freq) + if (dec > st->info->max_dec) + dec = st->info->max_dec; + +- ret = adis_write_reg_16(&st->adis, ADIS16475_REG_DEC_RATE, dec); ++ ret = __adis_write_reg_16(&st->adis, ADIS16475_REG_DEC_RATE, dec); + if (ret) + goto error; + ++ adis_dev_unlock(&st->adis); + /* + * If decimation is used, then gyro and accel data will have meaningful + * bits on the LSB registers. This info is used on the trigger handler. +diff --git a/drivers/iio/imu/adis16480.c b/drivers/iio/imu/adis16480.c +index a869a6e52a16b..ed129321a14da 100644 +--- a/drivers/iio/imu/adis16480.c ++++ b/drivers/iio/imu/adis16480.c +@@ -144,6 +144,7 @@ struct adis16480_chip_info { + unsigned int max_dec_rate; + const unsigned int *filter_freqs; + bool has_pps_clk_mode; ++ bool has_sleep_cnt; + const struct adis_data adis_data; + }; + +@@ -939,6 +940,7 @@ static const struct adis16480_chip_info adis16480_chip_info[] = { + .temp_scale = 5650, /* 5.65 milli degree Celsius */ + .int_clk = 2460000, + .max_dec_rate = 2048, ++ .has_sleep_cnt = true, + .filter_freqs = adis16480_def_filter_freqs, + .adis_data = ADIS16480_DATA(16375, &adis16485_timeouts, 0), + }, +@@ -952,6 +954,7 @@ static const struct adis16480_chip_info adis16480_chip_info[] = { + .temp_scale = 5650, /* 5.65 milli degree Celsius */ + .int_clk = 2460000, + .max_dec_rate = 2048, ++ .has_sleep_cnt = true, + .filter_freqs = adis16480_def_filter_freqs, + .adis_data = ADIS16480_DATA(16480, &adis16480_timeouts, 0), + }, +@@ -965,6 +968,7 @@ static const struct adis16480_chip_info adis16480_chip_info[] = { + .temp_scale = 5650, /* 5.65 milli degree Celsius */ + .int_clk = 2460000, + .max_dec_rate = 2048, ++ .has_sleep_cnt = true, + .filter_freqs = adis16480_def_filter_freqs, + .adis_data = ADIS16480_DATA(16485, &adis16485_timeouts, 0), + }, +@@ -978,6 +982,7 @@ static const struct adis16480_chip_info adis16480_chip_info[] = { + .temp_scale = 5650, /* 5.65 milli degree Celsius */ + .int_clk = 2460000, + .max_dec_rate = 2048, ++ .has_sleep_cnt = true, + .filter_freqs = adis16480_def_filter_freqs, + .adis_data = ADIS16480_DATA(16488, &adis16485_timeouts, 0), + }, +@@ -1425,9 +1430,12 @@ static int adis16480_probe(struct spi_device *spi) + if (ret) + return ret; + +- ret = devm_add_action_or_reset(&spi->dev, adis16480_stop, indio_dev); +- if (ret) +- return ret; ++ if (st->chip_info->has_sleep_cnt) { ++ ret = devm_add_action_or_reset(&spi->dev, adis16480_stop, ++ indio_dev); ++ if (ret) ++ return ret; ++ } + + ret = adis16480_config_irq_pin(spi->dev.of_node, st); + if (ret) +diff --git a/drivers/iio/light/opt3001.c b/drivers/iio/light/opt3001.c +index 52963da401a78..1880bd5bb2586 100644 +--- a/drivers/iio/light/opt3001.c ++++ b/drivers/iio/light/opt3001.c +@@ -276,6 +276,8 @@ static int opt3001_get_lux(struct opt3001 *opt, int *val, int *val2) + ret = wait_event_timeout(opt->result_ready_queue, + opt->result_ready, + msecs_to_jiffies(OPT3001_RESULT_READY_LONG)); ++ if (ret == 0) ++ return -ETIMEDOUT; + } else { + /* Sleep for result ready time */ + timeout = (opt->int_time == OPT3001_INT_TIME_SHORT) ? +@@ -312,9 +314,7 @@ err: + /* Disallow IRQ to access the device while lock is active */ + opt->ok_to_ignore_lock = false; + +- if (ret == 0) +- return -ETIMEDOUT; +- else if (ret < 0) ++ if (ret < 0) + return ret; + + if (opt->use_irq) { +diff --git a/drivers/input/joystick/xpad.c b/drivers/input/joystick/xpad.c +index 29de8412e4165..4c914f75a9027 100644 +--- a/drivers/input/joystick/xpad.c ++++ b/drivers/input/joystick/xpad.c +@@ -334,6 +334,7 @@ static const struct xpad_device { + { 0x24c6, 0x5b03, "Thrustmaster Ferrari 458 Racing Wheel", 0, XTYPE_XBOX360 }, + { 0x24c6, 0x5d04, "Razer Sabertooth", 0, XTYPE_XBOX360 }, + { 0x24c6, 0xfafe, "Rock Candy Gamepad for Xbox 360", 0, XTYPE_XBOX360 }, ++ { 0x3285, 0x0607, "Nacon GC-100", 0, XTYPE_XBOX360 }, + { 0x3767, 0x0101, "Fanatec Speedster 3 Forceshock Wheel", 0, XTYPE_XBOX }, + { 0xffff, 0xffff, "Chinese-made Xbox Controller", 0, XTYPE_XBOX }, + { 0x0000, 0x0000, "Generic X-Box pad", 0, XTYPE_UNKNOWN } +@@ -451,6 +452,7 @@ static const struct usb_device_id xpad_table[] = { + XPAD_XBOXONE_VENDOR(0x24c6), /* PowerA Controllers */ + XPAD_XBOXONE_VENDOR(0x2e24), /* Hyperkin Duke X-Box One pad */ + XPAD_XBOX360_VENDOR(0x2f24), /* GameSir Controllers */ ++ XPAD_XBOX360_VENDOR(0x3285), /* Nacon GC-100 */ + { } + }; + +diff --git a/drivers/input/touchscreen/resistive-adc-touch.c b/drivers/input/touchscreen/resistive-adc-touch.c +index 744544a723b77..6f754a8d30b11 100644 +--- a/drivers/input/touchscreen/resistive-adc-touch.c ++++ b/drivers/input/touchscreen/resistive-adc-touch.c +@@ -71,19 +71,22 @@ static int grts_cb(const void *data, void *private) + unsigned int z2 = touch_info[st->ch_map[GRTS_CH_Z2]]; + unsigned int Rt; + +- Rt = z2; +- Rt -= z1; +- Rt *= st->x_plate_ohms; +- Rt = DIV_ROUND_CLOSEST(Rt, 16); +- Rt *= x; +- Rt /= z1; +- Rt = DIV_ROUND_CLOSEST(Rt, 256); +- /* +- * On increased pressure the resistance (Rt) is decreasing +- * so, convert values to make it looks as real pressure. +- */ +- if (Rt < GRTS_DEFAULT_PRESSURE_MAX) +- press = GRTS_DEFAULT_PRESSURE_MAX - Rt; ++ if (likely(x && z1)) { ++ Rt = z2; ++ Rt -= z1; ++ Rt *= st->x_plate_ohms; ++ Rt = DIV_ROUND_CLOSEST(Rt, 16); ++ Rt *= x; ++ Rt /= z1; ++ Rt = DIV_ROUND_CLOSEST(Rt, 256); ++ /* ++ * On increased pressure the resistance (Rt) is ++ * decreasing so, convert values to make it looks as ++ * real pressure. ++ */ ++ if (Rt < GRTS_DEFAULT_PRESSURE_MAX) ++ press = GRTS_DEFAULT_PRESSURE_MAX - Rt; ++ } + } + + if ((!x && !y) || (st->pressure && (press < st->pressure_min))) { +diff --git a/drivers/md/dm-rq.c b/drivers/md/dm-rq.c +index 0dbd48cbdff95..231efbe38c214 100644 +--- a/drivers/md/dm-rq.c ++++ b/drivers/md/dm-rq.c +@@ -490,6 +490,14 @@ static blk_status_t dm_mq_queue_rq(struct blk_mq_hw_ctx *hctx, + struct mapped_device *md = tio->md; + struct dm_target *ti = md->immutable_target; + ++ /* ++ * blk-mq's unquiesce may come from outside events, such as ++ * elevator switch, updating nr_requests or others, and request may ++ * come during suspend, so simply ask for blk-mq to requeue it. ++ */ ++ if (unlikely(test_bit(DMF_BLOCK_IO_FOR_SUSPEND, &md->flags))) ++ return BLK_STS_RESOURCE; ++ + if (unlikely(!ti)) { + int srcu_idx; + struct dm_table *map = dm_get_live_table(md, &srcu_idx); +diff --git a/drivers/md/dm.c b/drivers/md/dm.c +index 2c5f9e5852117..bb895430981f2 100644 +--- a/drivers/md/dm.c ++++ b/drivers/md/dm.c +@@ -492,18 +492,17 @@ static void start_io_acct(struct dm_io *io) + false, 0, &io->stats_aux); + } + +-static void end_io_acct(struct dm_io *io) ++static void end_io_acct(struct mapped_device *md, struct bio *bio, ++ unsigned long start_time, struct dm_stats_aux *stats_aux) + { +- struct mapped_device *md = io->md; +- struct bio *bio = io->orig_bio; +- unsigned long duration = jiffies - io->start_time; ++ unsigned long duration = jiffies - start_time; + +- bio_end_io_acct(bio, io->start_time); ++ bio_end_io_acct(bio, start_time); + + if (unlikely(dm_stats_used(&md->stats))) + dm_stats_account_io(&md->stats, bio_data_dir(bio), + bio->bi_iter.bi_sector, bio_sectors(bio), +- true, duration, &io->stats_aux); ++ true, duration, stats_aux); + + /* nudge anyone waiting on suspend queue */ + if (unlikely(wq_has_sleeper(&md->wait))) +@@ -786,6 +785,8 @@ void dm_io_dec_pending(struct dm_io *io, blk_status_t error) + blk_status_t io_error; + struct bio *bio; + struct mapped_device *md = io->md; ++ unsigned long start_time = 0; ++ struct dm_stats_aux stats_aux; + + /* Push-back supersedes any I/O errors */ + if (unlikely(error)) { +@@ -817,8 +818,10 @@ void dm_io_dec_pending(struct dm_io *io, blk_status_t error) + } + + io_error = io->status; +- end_io_acct(io); ++ start_time = io->start_time; ++ stats_aux = io->stats_aux; + free_io(md, io); ++ end_io_acct(md, bio, start_time, &stats_aux); + + if (io_error == BLK_STS_DM_REQUEUE) + return; +diff --git a/drivers/misc/cb710/sgbuf2.c b/drivers/misc/cb710/sgbuf2.c +index e5a4ed3701eb8..a798fad5f03c2 100644 +--- a/drivers/misc/cb710/sgbuf2.c ++++ b/drivers/misc/cb710/sgbuf2.c +@@ -47,7 +47,7 @@ static inline bool needs_unaligned_copy(const void *ptr) + #ifdef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS + return false; + #else +- return ((ptr - NULL) & 3) != 0; ++ return ((uintptr_t)ptr & 3) != 0; + #endif + } + +diff --git a/drivers/misc/eeprom/at25.c b/drivers/misc/eeprom/at25.c +index 4d09b672ac3c8..632325474233a 100644 +--- a/drivers/misc/eeprom/at25.c ++++ b/drivers/misc/eeprom/at25.c +@@ -366,6 +366,13 @@ static const struct of_device_id at25_of_match[] = { + }; + MODULE_DEVICE_TABLE(of, at25_of_match); + ++static const struct spi_device_id at25_spi_ids[] = { ++ { .name = "at25",}, ++ { .name = "fm25",}, ++ { } ++}; ++MODULE_DEVICE_TABLE(spi, at25_spi_ids); ++ + static int at25_probe(struct spi_device *spi) + { + struct at25_data *at25 = NULL; +@@ -491,6 +498,7 @@ static struct spi_driver at25_driver = { + .dev_groups = sernum_groups, + }, + .probe = at25_probe, ++ .id_table = at25_spi_ids, + }; + + module_spi_driver(at25_driver); +diff --git a/drivers/misc/eeprom/eeprom_93xx46.c b/drivers/misc/eeprom/eeprom_93xx46.c +index 29d8971ec558b..1f15399e5cb49 100644 +--- a/drivers/misc/eeprom/eeprom_93xx46.c ++++ b/drivers/misc/eeprom/eeprom_93xx46.c +@@ -406,6 +406,23 @@ static const struct of_device_id eeprom_93xx46_of_table[] = { + }; + MODULE_DEVICE_TABLE(of, eeprom_93xx46_of_table); + ++static const struct spi_device_id eeprom_93xx46_spi_ids[] = { ++ { .name = "eeprom-93xx46", ++ .driver_data = (kernel_ulong_t)&at93c46_data, }, ++ { .name = "at93c46", ++ .driver_data = (kernel_ulong_t)&at93c46_data, }, ++ { .name = "at93c46d", ++ .driver_data = (kernel_ulong_t)&atmel_at93c46d_data, }, ++ { .name = "at93c56", ++ .driver_data = (kernel_ulong_t)&at93c56_data, }, ++ { .name = "at93c66", ++ .driver_data = (kernel_ulong_t)&at93c66_data, }, ++ { .name = "93lc46b", ++ .driver_data = (kernel_ulong_t)µchip_93lc46b_data, }, ++ {} ++}; ++MODULE_DEVICE_TABLE(spi, eeprom_93xx46_spi_ids); ++ + static int eeprom_93xx46_probe_dt(struct spi_device *spi) + { + const struct of_device_id *of_id = +@@ -555,6 +572,7 @@ static struct spi_driver eeprom_93xx46_driver = { + }, + .probe = eeprom_93xx46_probe, + .remove = eeprom_93xx46_remove, ++ .id_table = eeprom_93xx46_spi_ids, + }; + + module_spi_driver(eeprom_93xx46_driver); +diff --git a/drivers/misc/fastrpc.c b/drivers/misc/fastrpc.c +index beda610e6b30d..ad6ced4546556 100644 +--- a/drivers/misc/fastrpc.c ++++ b/drivers/misc/fastrpc.c +@@ -814,10 +814,12 @@ static int fastrpc_get_args(u32 kernel, struct fastrpc_invoke_ctx *ctx) + rpra[i].pv = (u64) ctx->args[i].ptr; + pages[i].addr = ctx->maps[i]->phys; + ++ mmap_read_lock(current->mm); + vma = find_vma(current->mm, ctx->args[i].ptr); + if (vma) + pages[i].addr += ctx->args[i].ptr - + vma->vm_start; ++ mmap_read_unlock(current->mm); + + pg_start = (ctx->args[i].ptr & PAGE_MASK) >> PAGE_SHIFT; + pg_end = ((ctx->args[i].ptr + len - 1) & PAGE_MASK) >> +diff --git a/drivers/misc/mei/hbm.c b/drivers/misc/mei/hbm.c +index 99b5c1ecc4441..be41843df75bc 100644 +--- a/drivers/misc/mei/hbm.c ++++ b/drivers/misc/mei/hbm.c +@@ -1298,7 +1298,8 @@ int mei_hbm_dispatch(struct mei_device *dev, struct mei_msg_hdr *hdr) + + if (dev->dev_state != MEI_DEV_INIT_CLIENTS || + dev->hbm_state != MEI_HBM_STARTING) { +- if (dev->dev_state == MEI_DEV_POWER_DOWN) { ++ if (dev->dev_state == MEI_DEV_POWER_DOWN || ++ dev->dev_state == MEI_DEV_POWERING_DOWN) { + dev_dbg(dev->dev, "hbm: start: on shutdown, ignoring\n"); + return 0; + } +@@ -1381,7 +1382,8 @@ int mei_hbm_dispatch(struct mei_device *dev, struct mei_msg_hdr *hdr) + + if (dev->dev_state != MEI_DEV_INIT_CLIENTS || + dev->hbm_state != MEI_HBM_DR_SETUP) { +- if (dev->dev_state == MEI_DEV_POWER_DOWN) { ++ if (dev->dev_state == MEI_DEV_POWER_DOWN || ++ dev->dev_state == MEI_DEV_POWERING_DOWN) { + dev_dbg(dev->dev, "hbm: dma setup response: on shutdown, ignoring\n"); + return 0; + } +@@ -1448,7 +1450,8 @@ int mei_hbm_dispatch(struct mei_device *dev, struct mei_msg_hdr *hdr) + + if (dev->dev_state != MEI_DEV_INIT_CLIENTS || + dev->hbm_state != MEI_HBM_CLIENT_PROPERTIES) { +- if (dev->dev_state == MEI_DEV_POWER_DOWN) { ++ if (dev->dev_state == MEI_DEV_POWER_DOWN || ++ dev->dev_state == MEI_DEV_POWERING_DOWN) { + dev_dbg(dev->dev, "hbm: properties response: on shutdown, ignoring\n"); + return 0; + } +@@ -1490,7 +1493,8 @@ int mei_hbm_dispatch(struct mei_device *dev, struct mei_msg_hdr *hdr) + + if (dev->dev_state != MEI_DEV_INIT_CLIENTS || + dev->hbm_state != MEI_HBM_ENUM_CLIENTS) { +- if (dev->dev_state == MEI_DEV_POWER_DOWN) { ++ if (dev->dev_state == MEI_DEV_POWER_DOWN || ++ dev->dev_state == MEI_DEV_POWERING_DOWN) { + dev_dbg(dev->dev, "hbm: enumeration response: on shutdown, ignoring\n"); + return 0; + } +diff --git a/drivers/misc/mei/hw-me-regs.h b/drivers/misc/mei/hw-me-regs.h +index cb34925e10f15..67bb6a25fd0a0 100644 +--- a/drivers/misc/mei/hw-me-regs.h ++++ b/drivers/misc/mei/hw-me-regs.h +@@ -92,6 +92,7 @@ + #define MEI_DEV_ID_CDF 0x18D3 /* Cedar Fork */ + + #define MEI_DEV_ID_ICP_LP 0x34E0 /* Ice Lake Point LP */ ++#define MEI_DEV_ID_ICP_N 0x38E0 /* Ice Lake Point N */ + + #define MEI_DEV_ID_JSP_N 0x4DE0 /* Jasper Lake Point N */ + +diff --git a/drivers/misc/mei/pci-me.c b/drivers/misc/mei/pci-me.c +index c3393b383e598..3a45aaf002ac8 100644 +--- a/drivers/misc/mei/pci-me.c ++++ b/drivers/misc/mei/pci-me.c +@@ -96,6 +96,7 @@ static const struct pci_device_id mei_me_pci_tbl[] = { + {MEI_PCI_DEVICE(MEI_DEV_ID_CMP_H_3, MEI_ME_PCH8_ITOUCH_CFG)}, + + {MEI_PCI_DEVICE(MEI_DEV_ID_ICP_LP, MEI_ME_PCH12_CFG)}, ++ {MEI_PCI_DEVICE(MEI_DEV_ID_ICP_N, MEI_ME_PCH12_CFG)}, + + {MEI_PCI_DEVICE(MEI_DEV_ID_TGP_LP, MEI_ME_PCH15_CFG)}, + {MEI_PCI_DEVICE(MEI_DEV_ID_TGP_H, MEI_ME_PCH15_SPS_CFG)}, +diff --git a/drivers/mtd/nand/raw/qcom_nandc.c b/drivers/mtd/nand/raw/qcom_nandc.c +index ef0badea4f415..04e6f7b267064 100644 +--- a/drivers/mtd/nand/raw/qcom_nandc.c ++++ b/drivers/mtd/nand/raw/qcom_nandc.c +@@ -1676,13 +1676,17 @@ qcom_nandc_read_cw_raw(struct mtd_info *mtd, struct nand_chip *chip, + struct nand_ecc_ctrl *ecc = &chip->ecc; + int data_size1, data_size2, oob_size1, oob_size2; + int ret, reg_off = FLASH_BUF_ACC, read_loc = 0; ++ int raw_cw = cw; + + nand_read_page_op(chip, page, 0, NULL, 0); + host->use_ecc = false; + ++ if (nandc->props->qpic_v2) ++ raw_cw = ecc->steps - 1; ++ + clear_bam_transaction(nandc); + set_address(host, host->cw_size * cw, page); +- update_rw_regs(host, 1, true, cw); ++ update_rw_regs(host, 1, true, raw_cw); + config_nand_page_read(chip); + + data_size1 = mtd->writesize - host->cw_size * (ecc->steps - 1); +@@ -1711,7 +1715,7 @@ qcom_nandc_read_cw_raw(struct mtd_info *mtd, struct nand_chip *chip, + nandc_set_read_loc(chip, cw, 3, read_loc, oob_size2, 1); + } + +- config_nand_cw_read(chip, false, cw); ++ config_nand_cw_read(chip, false, raw_cw); + + read_data_dma(nandc, reg_off, data_buf, data_size1, 0); + reg_off += data_size1; +diff --git a/drivers/net/dsa/microchip/ksz_common.c b/drivers/net/dsa/microchip/ksz_common.c +index 1542bfb8b5e54..7c2968a639eba 100644 +--- a/drivers/net/dsa/microchip/ksz_common.c ++++ b/drivers/net/dsa/microchip/ksz_common.c +@@ -449,8 +449,10 @@ EXPORT_SYMBOL(ksz_switch_register); + void ksz_switch_remove(struct ksz_device *dev) + { + /* timer started */ +- if (dev->mib_read_interval) ++ if (dev->mib_read_interval) { ++ dev->mib_read_interval = 0; + cancel_delayed_work_sync(&dev->mib_read); ++ } + + dev->dev_ops->exit(dev); + dsa_unregister_switch(dev->ds); +diff --git a/drivers/net/dsa/mv88e6xxx/chip.c b/drivers/net/dsa/mv88e6xxx/chip.c +index 66b4f4a9832a4..f5b2e5e87da43 100644 +--- a/drivers/net/dsa/mv88e6xxx/chip.c ++++ b/drivers/net/dsa/mv88e6xxx/chip.c +@@ -749,7 +749,11 @@ static void mv88e6xxx_mac_link_down(struct dsa_switch *ds, int port, + ops = chip->info->ops; + + mv88e6xxx_reg_lock(chip); +- if ((!mv88e6xxx_port_ppu_updates(chip, port) || ++ /* Internal PHYs propagate their configuration directly to the MAC. ++ * External PHYs depend on whether the PPU is enabled for this port. ++ */ ++ if (((!mv88e6xxx_phy_is_internal(ds, port) && ++ !mv88e6xxx_port_ppu_updates(chip, port)) || + mode == MLO_AN_FIXED) && ops->port_sync_link) + err = ops->port_sync_link(chip, port, mode, false); + mv88e6xxx_reg_unlock(chip); +@@ -772,7 +776,12 @@ static void mv88e6xxx_mac_link_up(struct dsa_switch *ds, int port, + ops = chip->info->ops; + + mv88e6xxx_reg_lock(chip); +- if (!mv88e6xxx_port_ppu_updates(chip, port) || mode == MLO_AN_FIXED) { ++ /* Internal PHYs propagate their configuration directly to the MAC. ++ * External PHYs depend on whether the PPU is enabled for this port. ++ */ ++ if ((!mv88e6xxx_phy_is_internal(ds, port) && ++ !mv88e6xxx_port_ppu_updates(chip, port)) || ++ mode == MLO_AN_FIXED) { + /* FIXME: for an automedia port, should we force the link + * down here - what if the link comes up due to "other" media + * while we're bringing the port up, how is the exclusivity +diff --git a/drivers/net/dsa/ocelot/felix.c b/drivers/net/dsa/ocelot/felix.c +index a2a15919b9606..0ba3762d5c219 100644 +--- a/drivers/net/dsa/ocelot/felix.c ++++ b/drivers/net/dsa/ocelot/felix.c +@@ -271,12 +271,12 @@ static void felix_8021q_cpu_port_deinit(struct ocelot *ocelot, int port) + */ + static int felix_setup_mmio_filtering(struct felix *felix) + { +- unsigned long user_ports = 0, cpu_ports = 0; ++ unsigned long user_ports = dsa_user_ports(felix->ds); + struct ocelot_vcap_filter *redirect_rule; + struct ocelot_vcap_filter *tagging_rule; + struct ocelot *ocelot = &felix->ocelot; + struct dsa_switch *ds = felix->ds; +- int port, ret; ++ int cpu = -1, port, ret; + + tagging_rule = kzalloc(sizeof(struct ocelot_vcap_filter), GFP_KERNEL); + if (!tagging_rule) +@@ -289,12 +289,15 @@ static int felix_setup_mmio_filtering(struct felix *felix) + } + + for (port = 0; port < ocelot->num_phys_ports; port++) { +- if (dsa_is_user_port(ds, port)) +- user_ports |= BIT(port); +- if (dsa_is_cpu_port(ds, port)) +- cpu_ports |= BIT(port); ++ if (dsa_is_cpu_port(ds, port)) { ++ cpu = port; ++ break; ++ } + } + ++ if (cpu < 0) ++ return -EINVAL; ++ + tagging_rule->key_type = OCELOT_VCAP_KEY_ETYPE; + *(__be16 *)tagging_rule->key.etype.etype.value = htons(ETH_P_1588); + *(__be16 *)tagging_rule->key.etype.etype.mask = htons(0xffff); +@@ -330,7 +333,7 @@ static int felix_setup_mmio_filtering(struct felix *felix) + * the CPU port module + */ + redirect_rule->action.mask_mode = OCELOT_MASK_MODE_REDIRECT; +- redirect_rule->action.port_mask = cpu_ports; ++ redirect_rule->action.port_mask = BIT(cpu); + } else { + /* Trap PTP packets only to the CPU port module (which is + * redirected to the NPI port) +@@ -1241,6 +1244,7 @@ static int felix_setup(struct dsa_switch *ds) + * there's no real point in checking for errors. + */ + felix_set_tag_protocol(ds, port, felix->tag_proto); ++ break; + } + + ds->mtu_enforcement_ingress = true; +@@ -1277,6 +1281,7 @@ static void felix_teardown(struct dsa_switch *ds) + continue; + + felix_del_tag_protocol(ds, port, felix->tag_proto); ++ break; + } + + ocelot_devlink_sb_unregister(ocelot); +@@ -1406,8 +1411,12 @@ static void felix_txtstamp(struct dsa_switch *ds, int port, + if (!ocelot->ptp) + return; + +- if (ocelot_port_txtstamp_request(ocelot, port, skb, &clone)) ++ if (ocelot_port_txtstamp_request(ocelot, port, skb, &clone)) { ++ dev_err_ratelimited(ds->dev, ++ "port %d delivering skb without TX timestamp\n", ++ port); + return; ++ } + + if (clone) + OCELOT_SKB_CB(skb)->clone = clone; +diff --git a/drivers/net/ethernet/Kconfig b/drivers/net/ethernet/Kconfig +index 1cdff1dca790c..17d3da4605ec0 100644 +--- a/drivers/net/ethernet/Kconfig ++++ b/drivers/net/ethernet/Kconfig +@@ -100,6 +100,7 @@ config JME + config KORINA + tristate "Korina (IDT RC32434) Ethernet support" + depends on MIKROTIK_RB532 || COMPILE_TEST ++ select CRC32 + select MII + help + If you have a Mikrotik RouterBoard 500 or IDT RC32434 +diff --git a/drivers/net/ethernet/arc/Kconfig b/drivers/net/ethernet/arc/Kconfig +index 37a41773dd435..92a79c4ffa2c7 100644 +--- a/drivers/net/ethernet/arc/Kconfig ++++ b/drivers/net/ethernet/arc/Kconfig +@@ -21,6 +21,7 @@ config ARC_EMAC_CORE + depends on ARC || ARCH_ROCKCHIP || COMPILE_TEST + select MII + select PHYLIB ++ select CRC32 + + config ARC_EMAC + tristate "ARC EMAC support" +diff --git a/drivers/net/ethernet/intel/ice/ice_ptp.c b/drivers/net/ethernet/intel/ice/ice_ptp.c +index 234bc68e79f96..c2465b9d80567 100644 +--- a/drivers/net/ethernet/intel/ice/ice_ptp.c ++++ b/drivers/net/ethernet/intel/ice/ice_ptp.c +@@ -1324,22 +1324,21 @@ ice_ptp_flush_tx_tracker(struct ice_pf *pf, struct ice_ptp_tx *tx) + { + u8 idx; + +- spin_lock(&tx->lock); +- + for (idx = 0; idx < tx->len; idx++) { + u8 phy_idx = idx + tx->quad_offset; + +- /* Clear any potential residual timestamp in the PHY block */ +- if (!pf->hw.reset_ongoing) +- ice_clear_phy_tstamp(&pf->hw, tx->quad, phy_idx); +- ++ spin_lock(&tx->lock); + if (tx->tstamps[idx].skb) { + dev_kfree_skb_any(tx->tstamps[idx].skb); + tx->tstamps[idx].skb = NULL; + } +- } ++ clear_bit(idx, tx->in_use); ++ spin_unlock(&tx->lock); + +- spin_unlock(&tx->lock); ++ /* Clear any potential residual timestamp in the PHY block */ ++ if (!pf->hw.reset_ongoing) ++ ice_clear_phy_tstamp(&pf->hw, tx->quad, phy_idx); ++ } + } + + /** +diff --git a/drivers/net/ethernet/mellanox/mlx5/core/cq.c b/drivers/net/ethernet/mellanox/mlx5/core/cq.c +index 360e093874d4f..c74600be570ed 100644 +--- a/drivers/net/ethernet/mellanox/mlx5/core/cq.c ++++ b/drivers/net/ethernet/mellanox/mlx5/core/cq.c +@@ -154,6 +154,8 @@ int mlx5_core_destroy_cq(struct mlx5_core_dev *dev, struct mlx5_core_cq *cq) + u32 in[MLX5_ST_SZ_DW(destroy_cq_in)] = {}; + int err; + ++ mlx5_debug_cq_remove(dev, cq); ++ + mlx5_eq_del_cq(mlx5_get_async_eq(dev), cq); + mlx5_eq_del_cq(&cq->eq->core, cq); + +@@ -161,16 +163,13 @@ int mlx5_core_destroy_cq(struct mlx5_core_dev *dev, struct mlx5_core_cq *cq) + MLX5_SET(destroy_cq_in, in, cqn, cq->cqn); + MLX5_SET(destroy_cq_in, in, uid, cq->uid); + err = mlx5_cmd_exec_in(dev, destroy_cq, in); +- if (err) +- return err; + + synchronize_irq(cq->irqn); + +- mlx5_debug_cq_remove(dev, cq); + mlx5_cq_put(cq); + wait_for_completion(&cq->free); + +- return 0; ++ return err; + } + EXPORT_SYMBOL(mlx5_core_destroy_cq); + +diff --git a/drivers/net/ethernet/mellanox/mlx5/core/en_main.c b/drivers/net/ethernet/mellanox/mlx5/core/en_main.c +index 548e8e7fc956e..56fdcd487b9d7 100644 +--- a/drivers/net/ethernet/mellanox/mlx5/core/en_main.c ++++ b/drivers/net/ethernet/mellanox/mlx5/core/en_main.c +@@ -3724,20 +3724,67 @@ static int set_feature_rx_all(struct net_device *netdev, bool enable) + return mlx5_set_port_fcs(mdev, !enable); + } + ++static int mlx5e_set_rx_port_ts(struct mlx5_core_dev *mdev, bool enable) ++{ ++ u32 in[MLX5_ST_SZ_DW(pcmr_reg)] = {}; ++ bool supported, curr_state; ++ int err; ++ ++ if (!MLX5_CAP_GEN(mdev, ports_check)) ++ return 0; ++ ++ err = mlx5_query_ports_check(mdev, in, sizeof(in)); ++ if (err) ++ return err; ++ ++ supported = MLX5_GET(pcmr_reg, in, rx_ts_over_crc_cap); ++ curr_state = MLX5_GET(pcmr_reg, in, rx_ts_over_crc); ++ ++ if (!supported || enable == curr_state) ++ return 0; ++ ++ MLX5_SET(pcmr_reg, in, local_port, 1); ++ MLX5_SET(pcmr_reg, in, rx_ts_over_crc, enable); ++ ++ return mlx5_set_ports_check(mdev, in, sizeof(in)); ++} ++ + static int set_feature_rx_fcs(struct net_device *netdev, bool enable) + { + struct mlx5e_priv *priv = netdev_priv(netdev); ++ struct mlx5e_channels *chs = &priv->channels; ++ struct mlx5_core_dev *mdev = priv->mdev; + int err; + + mutex_lock(&priv->state_lock); + +- priv->channels.params.scatter_fcs_en = enable; +- err = mlx5e_modify_channels_scatter_fcs(&priv->channels, enable); +- if (err) +- priv->channels.params.scatter_fcs_en = !enable; ++ if (enable) { ++ err = mlx5e_set_rx_port_ts(mdev, false); ++ if (err) ++ goto out; + +- mutex_unlock(&priv->state_lock); ++ chs->params.scatter_fcs_en = true; ++ err = mlx5e_modify_channels_scatter_fcs(chs, true); ++ if (err) { ++ chs->params.scatter_fcs_en = false; ++ mlx5e_set_rx_port_ts(mdev, true); ++ } ++ } else { ++ chs->params.scatter_fcs_en = false; ++ err = mlx5e_modify_channels_scatter_fcs(chs, false); ++ if (err) { ++ chs->params.scatter_fcs_en = true; ++ goto out; ++ } ++ err = mlx5e_set_rx_port_ts(mdev, true); ++ if (err) { ++ mlx5_core_warn(mdev, "Failed to set RX port timestamp %d\n", err); ++ err = 0; ++ } ++ } + ++out: ++ mutex_unlock(&priv->state_lock); + return err; + } + +diff --git a/drivers/net/ethernet/mellanox/mlx5/core/en_rep.c b/drivers/net/ethernet/mellanox/mlx5/core/en_rep.c +index bec1d344481cd..8b757d790f560 100644 +--- a/drivers/net/ethernet/mellanox/mlx5/core/en_rep.c ++++ b/drivers/net/ethernet/mellanox/mlx5/core/en_rep.c +@@ -611,7 +611,6 @@ static void mlx5e_build_rep_netdev(struct net_device *netdev, + netdev->hw_features |= NETIF_F_RXCSUM; + + netdev->features |= netdev->hw_features; +- netdev->features |= NETIF_F_VLAN_CHALLENGED; + netdev->features |= NETIF_F_NETNS_LOCAL; + } + +diff --git a/drivers/net/ethernet/mellanox/mlxsw/core_thermal.c b/drivers/net/ethernet/mellanox/mlxsw/core_thermal.c +index 0998dcc9cac04..b29824448aa85 100644 +--- a/drivers/net/ethernet/mellanox/mlxsw/core_thermal.c ++++ b/drivers/net/ethernet/mellanox/mlxsw/core_thermal.c +@@ -24,16 +24,8 @@ + #define MLXSW_THERMAL_ZONE_MAX_NAME 16 + #define MLXSW_THERMAL_TEMP_SCORE_MAX GENMASK(31, 0) + #define MLXSW_THERMAL_MAX_STATE 10 ++#define MLXSW_THERMAL_MIN_STATE 2 + #define MLXSW_THERMAL_MAX_DUTY 255 +-/* Minimum and maximum fan allowed speed in percent: from 20% to 100%. Values +- * MLXSW_THERMAL_MAX_STATE + x, where x is between 2 and 10 are used for +- * setting fan speed dynamic minimum. For example, if value is set to 14 (40%) +- * cooling levels vector will be set to 4, 4, 4, 4, 4, 5, 6, 7, 8, 9, 10 to +- * introduce PWM speed in percent: 40, 40, 40, 40, 40, 50, 60. 70, 80, 90, 100. +- */ +-#define MLXSW_THERMAL_SPEED_MIN (MLXSW_THERMAL_MAX_STATE + 2) +-#define MLXSW_THERMAL_SPEED_MAX (MLXSW_THERMAL_MAX_STATE * 2) +-#define MLXSW_THERMAL_SPEED_MIN_LEVEL 2 /* 20% */ + + /* External cooling devices, allowed for binding to mlxsw thermal zones. */ + static char * const mlxsw_thermal_external_allowed_cdev[] = { +@@ -646,49 +638,16 @@ static int mlxsw_thermal_set_cur_state(struct thermal_cooling_device *cdev, + struct mlxsw_thermal *thermal = cdev->devdata; + struct device *dev = thermal->bus_info->dev; + char mfsc_pl[MLXSW_REG_MFSC_LEN]; +- unsigned long cur_state, i; + int idx; +- u8 duty; + int err; + ++ if (state > MLXSW_THERMAL_MAX_STATE) ++ return -EINVAL; ++ + idx = mlxsw_get_cooling_device_idx(thermal, cdev); + if (idx < 0) + return idx; + +- /* Verify if this request is for changing allowed fan dynamical +- * minimum. If it is - update cooling levels accordingly and update +- * state, if current state is below the newly requested minimum state. +- * For example, if current state is 5, and minimal state is to be +- * changed from 4 to 6, thermal->cooling_levels[0 to 5] will be changed +- * all from 4 to 6. And state 5 (thermal->cooling_levels[4]) should be +- * overwritten. +- */ +- if (state >= MLXSW_THERMAL_SPEED_MIN && +- state <= MLXSW_THERMAL_SPEED_MAX) { +- state -= MLXSW_THERMAL_MAX_STATE; +- for (i = 0; i <= MLXSW_THERMAL_MAX_STATE; i++) +- thermal->cooling_levels[i] = max(state, i); +- +- mlxsw_reg_mfsc_pack(mfsc_pl, idx, 0); +- err = mlxsw_reg_query(thermal->core, MLXSW_REG(mfsc), mfsc_pl); +- if (err) +- return err; +- +- duty = mlxsw_reg_mfsc_pwm_duty_cycle_get(mfsc_pl); +- cur_state = mlxsw_duty_to_state(duty); +- +- /* If current fan state is lower than requested dynamical +- * minimum, increase fan speed up to dynamical minimum. +- */ +- if (state < cur_state) +- return 0; +- +- state = cur_state; +- } +- +- if (state > MLXSW_THERMAL_MAX_STATE) +- return -EINVAL; +- + /* Normalize the state to the valid speed range. */ + state = thermal->cooling_levels[state]; + mlxsw_reg_mfsc_pack(mfsc_pl, idx, mlxsw_state_to_duty(state)); +@@ -998,8 +957,7 @@ int mlxsw_thermal_init(struct mlxsw_core *core, + + /* Initialize cooling levels per PWM state. */ + for (i = 0; i < MLXSW_THERMAL_MAX_STATE; i++) +- thermal->cooling_levels[i] = max(MLXSW_THERMAL_SPEED_MIN_LEVEL, +- i); ++ thermal->cooling_levels[i] = max(MLXSW_THERMAL_MIN_STATE, i); + + thermal->polling_delay = bus_info->low_frequency ? + MLXSW_THERMAL_SLOW_POLL_INT : +diff --git a/drivers/net/ethernet/microchip/encx24j600-regmap.c b/drivers/net/ethernet/microchip/encx24j600-regmap.c +index 796e46a539269..81a8ccca7e5e0 100644 +--- a/drivers/net/ethernet/microchip/encx24j600-regmap.c ++++ b/drivers/net/ethernet/microchip/encx24j600-regmap.c +@@ -497,13 +497,19 @@ static struct regmap_bus phymap_encx24j600 = { + .reg_read = regmap_encx24j600_phy_reg_read, + }; + +-void devm_regmap_init_encx24j600(struct device *dev, +- struct encx24j600_context *ctx) ++int devm_regmap_init_encx24j600(struct device *dev, ++ struct encx24j600_context *ctx) + { + mutex_init(&ctx->mutex); + regcfg.lock_arg = ctx; + ctx->regmap = devm_regmap_init(dev, ®map_encx24j600, ctx, ®cfg); ++ if (IS_ERR(ctx->regmap)) ++ return PTR_ERR(ctx->regmap); + ctx->phymap = devm_regmap_init(dev, &phymap_encx24j600, ctx, &phycfg); ++ if (IS_ERR(ctx->phymap)) ++ return PTR_ERR(ctx->phymap); ++ ++ return 0; + } + EXPORT_SYMBOL_GPL(devm_regmap_init_encx24j600); + +diff --git a/drivers/net/ethernet/microchip/encx24j600.c b/drivers/net/ethernet/microchip/encx24j600.c +index ee921a99e439a..0bc6b3176fbf0 100644 +--- a/drivers/net/ethernet/microchip/encx24j600.c ++++ b/drivers/net/ethernet/microchip/encx24j600.c +@@ -1023,10 +1023,13 @@ static int encx24j600_spi_probe(struct spi_device *spi) + priv->speed = SPEED_100; + + priv->ctx.spi = spi; +- devm_regmap_init_encx24j600(&spi->dev, &priv->ctx); + ndev->irq = spi->irq; + ndev->netdev_ops = &encx24j600_netdev_ops; + ++ ret = devm_regmap_init_encx24j600(&spi->dev, &priv->ctx); ++ if (ret) ++ goto out_free; ++ + mutex_init(&priv->lock); + + /* Reset device and check if it is connected */ +diff --git a/drivers/net/ethernet/microchip/encx24j600_hw.h b/drivers/net/ethernet/microchip/encx24j600_hw.h +index fac61a8fbd020..34c5a289898c9 100644 +--- a/drivers/net/ethernet/microchip/encx24j600_hw.h ++++ b/drivers/net/ethernet/microchip/encx24j600_hw.h +@@ -15,8 +15,8 @@ struct encx24j600_context { + int bank; + }; + +-void devm_regmap_init_encx24j600(struct device *dev, +- struct encx24j600_context *ctx); ++int devm_regmap_init_encx24j600(struct device *dev, ++ struct encx24j600_context *ctx); + + /* Single-byte instructions */ + #define BANK_SELECT(bank) (0xC0 | ((bank & (BANK_MASK >> BANK_SHIFT)) << 1)) +diff --git a/drivers/net/ethernet/mscc/ocelot.c b/drivers/net/ethernet/mscc/ocelot.c +index 512dff9551669..acfbe94b52918 100644 +--- a/drivers/net/ethernet/mscc/ocelot.c ++++ b/drivers/net/ethernet/mscc/ocelot.c +@@ -536,20 +536,36 @@ void ocelot_port_disable(struct ocelot *ocelot, int port) + } + EXPORT_SYMBOL(ocelot_port_disable); + +-static void ocelot_port_add_txtstamp_skb(struct ocelot *ocelot, int port, +- struct sk_buff *clone) ++static int ocelot_port_add_txtstamp_skb(struct ocelot *ocelot, int port, ++ struct sk_buff *clone) + { + struct ocelot_port *ocelot_port = ocelot->ports[port]; ++ unsigned long flags; + +- spin_lock(&ocelot_port->ts_id_lock); ++ spin_lock_irqsave(&ocelot->ts_id_lock, flags); ++ ++ if (ocelot_port->ptp_skbs_in_flight == OCELOT_MAX_PTP_ID || ++ ocelot->ptp_skbs_in_flight == OCELOT_PTP_FIFO_SIZE) { ++ spin_unlock_irqrestore(&ocelot->ts_id_lock, flags); ++ return -EBUSY; ++ } + + skb_shinfo(clone)->tx_flags |= SKBTX_IN_PROGRESS; + /* Store timestamp ID in OCELOT_SKB_CB(clone)->ts_id */ + OCELOT_SKB_CB(clone)->ts_id = ocelot_port->ts_id; +- ocelot_port->ts_id = (ocelot_port->ts_id + 1) % 4; ++ ++ ocelot_port->ts_id++; ++ if (ocelot_port->ts_id == OCELOT_MAX_PTP_ID) ++ ocelot_port->ts_id = 0; ++ ++ ocelot_port->ptp_skbs_in_flight++; ++ ocelot->ptp_skbs_in_flight++; ++ + skb_queue_tail(&ocelot_port->tx_skbs, clone); + +- spin_unlock(&ocelot_port->ts_id_lock); ++ spin_unlock_irqrestore(&ocelot->ts_id_lock, flags); ++ ++ return 0; + } + + u32 ocelot_ptp_rew_op(struct sk_buff *skb) +@@ -569,16 +585,12 @@ u32 ocelot_ptp_rew_op(struct sk_buff *skb) + } + EXPORT_SYMBOL(ocelot_ptp_rew_op); + +-static bool ocelot_ptp_is_onestep_sync(struct sk_buff *skb) ++static bool ocelot_ptp_is_onestep_sync(struct sk_buff *skb, ++ unsigned int ptp_class) + { + struct ptp_header *hdr; +- unsigned int ptp_class; + u8 msgtype, twostep; + +- ptp_class = ptp_classify_raw(skb); +- if (ptp_class == PTP_CLASS_NONE) +- return false; +- + hdr = ptp_parse_header(skb, ptp_class); + if (!hdr) + return false; +@@ -598,10 +610,20 @@ int ocelot_port_txtstamp_request(struct ocelot *ocelot, int port, + { + struct ocelot_port *ocelot_port = ocelot->ports[port]; + u8 ptp_cmd = ocelot_port->ptp_cmd; ++ unsigned int ptp_class; ++ int err; ++ ++ /* Don't do anything if PTP timestamping not enabled */ ++ if (!ptp_cmd) ++ return 0; ++ ++ ptp_class = ptp_classify_raw(skb); ++ if (ptp_class == PTP_CLASS_NONE) ++ return -EINVAL; + + /* Store ptp_cmd in OCELOT_SKB_CB(skb)->ptp_cmd */ + if (ptp_cmd == IFH_REW_OP_ORIGIN_PTP) { +- if (ocelot_ptp_is_onestep_sync(skb)) { ++ if (ocelot_ptp_is_onestep_sync(skb, ptp_class)) { + OCELOT_SKB_CB(skb)->ptp_cmd = ptp_cmd; + return 0; + } +@@ -615,8 +637,12 @@ int ocelot_port_txtstamp_request(struct ocelot *ocelot, int port, + if (!(*clone)) + return -ENOMEM; + +- ocelot_port_add_txtstamp_skb(ocelot, port, *clone); ++ err = ocelot_port_add_txtstamp_skb(ocelot, port, *clone); ++ if (err) ++ return err; ++ + OCELOT_SKB_CB(skb)->ptp_cmd = ptp_cmd; ++ OCELOT_SKB_CB(*clone)->ptp_class = ptp_class; + } + + return 0; +@@ -650,6 +676,17 @@ static void ocelot_get_hwtimestamp(struct ocelot *ocelot, + spin_unlock_irqrestore(&ocelot->ptp_clock_lock, flags); + } + ++static bool ocelot_validate_ptp_skb(struct sk_buff *clone, u16 seqid) ++{ ++ struct ptp_header *hdr; ++ ++ hdr = ptp_parse_header(clone, OCELOT_SKB_CB(clone)->ptp_class); ++ if (WARN_ON(!hdr)) ++ return false; ++ ++ return seqid == ntohs(hdr->sequence_id); ++} ++ + void ocelot_get_txtstamp(struct ocelot *ocelot) + { + int budget = OCELOT_PTP_QUEUE_SZ; +@@ -657,10 +694,10 @@ void ocelot_get_txtstamp(struct ocelot *ocelot) + while (budget--) { + struct sk_buff *skb, *skb_tmp, *skb_match = NULL; + struct skb_shared_hwtstamps shhwtstamps; ++ u32 val, id, seqid, txport; + struct ocelot_port *port; + struct timespec64 ts; + unsigned long flags; +- u32 val, id, txport; + + val = ocelot_read(ocelot, SYS_PTP_STATUS); + +@@ -673,10 +710,17 @@ void ocelot_get_txtstamp(struct ocelot *ocelot) + /* Retrieve the ts ID and Tx port */ + id = SYS_PTP_STATUS_PTP_MESS_ID_X(val); + txport = SYS_PTP_STATUS_PTP_MESS_TXPORT_X(val); ++ seqid = SYS_PTP_STATUS_PTP_MESS_SEQ_ID(val); + +- /* Retrieve its associated skb */ + port = ocelot->ports[txport]; + ++ spin_lock(&ocelot->ts_id_lock); ++ port->ptp_skbs_in_flight--; ++ ocelot->ptp_skbs_in_flight--; ++ spin_unlock(&ocelot->ts_id_lock); ++ ++ /* Retrieve its associated skb */ ++try_again: + spin_lock_irqsave(&port->tx_skbs.lock, flags); + + skb_queue_walk_safe(&port->tx_skbs, skb, skb_tmp) { +@@ -689,12 +733,20 @@ void ocelot_get_txtstamp(struct ocelot *ocelot) + + spin_unlock_irqrestore(&port->tx_skbs.lock, flags); + ++ if (WARN_ON(!skb_match)) ++ continue; ++ ++ if (!ocelot_validate_ptp_skb(skb_match, seqid)) { ++ dev_err_ratelimited(ocelot->dev, ++ "port %d received stale TX timestamp for seqid %d, discarding\n", ++ txport, seqid); ++ dev_kfree_skb_any(skb); ++ goto try_again; ++ } ++ + /* Get the h/w timestamp */ + ocelot_get_hwtimestamp(ocelot, &ts); + +- if (unlikely(!skb_match)) +- continue; +- + /* Set the timestamp into the skb */ + memset(&shhwtstamps, 0, sizeof(shhwtstamps)); + shhwtstamps.hwtstamp = ktime_set(ts.tv_sec, ts.tv_nsec); +@@ -1915,7 +1967,6 @@ void ocelot_init_port(struct ocelot *ocelot, int port) + struct ocelot_port *ocelot_port = ocelot->ports[port]; + + skb_queue_head_init(&ocelot_port->tx_skbs); +- spin_lock_init(&ocelot_port->ts_id_lock); + + /* Basic L2 initialization */ + +@@ -2039,6 +2090,7 @@ int ocelot_init(struct ocelot *ocelot) + mutex_init(&ocelot->stats_lock); + mutex_init(&ocelot->ptp_lock); + spin_lock_init(&ocelot->ptp_clock_lock); ++ spin_lock_init(&ocelot->ts_id_lock); + snprintf(queue_name, sizeof(queue_name), "%s-stats", + dev_name(ocelot->dev)); + ocelot->stats_queue = create_singlethread_workqueue(queue_name); +diff --git a/drivers/net/ethernet/neterion/s2io.c b/drivers/net/ethernet/neterion/s2io.c +index 0b017d4f5c085..a988ed360185b 100644 +--- a/drivers/net/ethernet/neterion/s2io.c ++++ b/drivers/net/ethernet/neterion/s2io.c +@@ -8566,7 +8566,7 @@ static void s2io_io_resume(struct pci_dev *pdev) + return; + } + +- if (s2io_set_mac_addr(netdev, netdev->dev_addr) == FAILURE) { ++ if (do_s2io_prog_unicast(netdev, netdev->dev_addr) == FAILURE) { + s2io_card_down(sp); + pr_err("Can't restore mac addr after reset.\n"); + return; +diff --git a/drivers/net/ethernet/netronome/nfp/flower/main.c b/drivers/net/ethernet/netronome/nfp/flower/main.c +index c029950a81e20..ac1dcfa1d1790 100644 +--- a/drivers/net/ethernet/netronome/nfp/flower/main.c ++++ b/drivers/net/ethernet/netronome/nfp/flower/main.c +@@ -830,10 +830,6 @@ static int nfp_flower_init(struct nfp_app *app) + if (err) + goto err_cleanup; + +- err = flow_indr_dev_register(nfp_flower_indr_setup_tc_cb, app); +- if (err) +- goto err_cleanup; +- + if (app_priv->flower_ext_feats & NFP_FL_FEATS_VF_RLIM) + nfp_flower_qos_init(app); + +@@ -942,7 +938,20 @@ static int nfp_flower_start(struct nfp_app *app) + return err; + } + +- return nfp_tunnel_config_start(app); ++ err = flow_indr_dev_register(nfp_flower_indr_setup_tc_cb, app); ++ if (err) ++ return err; ++ ++ err = nfp_tunnel_config_start(app); ++ if (err) ++ goto err_tunnel_config; ++ ++ return 0; ++ ++err_tunnel_config: ++ flow_indr_dev_unregister(nfp_flower_indr_setup_tc_cb, app, ++ nfp_flower_setup_indr_tc_release); ++ return err; + } + + static void nfp_flower_stop(struct nfp_app *app) +diff --git a/drivers/net/ethernet/pensando/ionic/ionic_lif.c b/drivers/net/ethernet/pensando/ionic/ionic_lif.c +index e795fa63ca12e..14429d2900f2f 100644 +--- a/drivers/net/ethernet/pensando/ionic/ionic_lif.c ++++ b/drivers/net/ethernet/pensando/ionic/ionic_lif.c +@@ -1357,6 +1357,10 @@ static int ionic_addr_add(struct net_device *netdev, const u8 *addr) + + static int ionic_addr_del(struct net_device *netdev, const u8 *addr) + { ++ /* Don't delete our own address from the uc list */ ++ if (ether_addr_equal(addr, netdev->dev_addr)) ++ return 0; ++ + return ionic_lif_addr(netdev_priv(netdev), addr, DEL_ADDR); + } + +diff --git a/drivers/net/ethernet/qlogic/qed/qed_main.c b/drivers/net/ethernet/qlogic/qed/qed_main.c +index 6bb9ec98a12b5..41bc31e3f9356 100644 +--- a/drivers/net/ethernet/qlogic/qed/qed_main.c ++++ b/drivers/net/ethernet/qlogic/qed/qed_main.c +@@ -1295,6 +1295,7 @@ static int qed_slowpath_start(struct qed_dev *cdev, + } else { + DP_NOTICE(cdev, + "Failed to acquire PTT for aRFS\n"); ++ rc = -EINVAL; + goto err; + } + } +diff --git a/drivers/net/ethernet/stmicro/stmmac/dwmac1000_dma.c b/drivers/net/ethernet/stmicro/stmmac/dwmac1000_dma.c +index 90383abafa66a..f5581db0ba9ba 100644 +--- a/drivers/net/ethernet/stmicro/stmmac/dwmac1000_dma.c ++++ b/drivers/net/ethernet/stmicro/stmmac/dwmac1000_dma.c +@@ -218,11 +218,18 @@ static void dwmac1000_dump_dma_regs(void __iomem *ioaddr, u32 *reg_space) + readl(ioaddr + DMA_BUS_MODE + i * 4); + } + +-static void dwmac1000_get_hw_feature(void __iomem *ioaddr, +- struct dma_features *dma_cap) ++static int dwmac1000_get_hw_feature(void __iomem *ioaddr, ++ struct dma_features *dma_cap) + { + u32 hw_cap = readl(ioaddr + DMA_HW_FEATURE); + ++ if (!hw_cap) { ++ /* 0x00000000 is the value read on old hardware that does not ++ * implement this register ++ */ ++ return -EOPNOTSUPP; ++ } ++ + dma_cap->mbps_10_100 = (hw_cap & DMA_HW_FEAT_MIISEL); + dma_cap->mbps_1000 = (hw_cap & DMA_HW_FEAT_GMIISEL) >> 1; + dma_cap->half_duplex = (hw_cap & DMA_HW_FEAT_HDSEL) >> 2; +@@ -252,6 +259,8 @@ static void dwmac1000_get_hw_feature(void __iomem *ioaddr, + dma_cap->number_tx_channel = (hw_cap & DMA_HW_FEAT_TXCHCNT) >> 22; + /* Alternate (enhanced) DESC mode */ + dma_cap->enh_desc = (hw_cap & DMA_HW_FEAT_ENHDESSEL) >> 24; ++ ++ return 0; + } + + static void dwmac1000_rx_watchdog(void __iomem *ioaddr, u32 riwt, +diff --git a/drivers/net/ethernet/stmicro/stmmac/dwmac4_dma.c b/drivers/net/ethernet/stmicro/stmmac/dwmac4_dma.c +index 5be8e6a631d9b..d99fa028c6468 100644 +--- a/drivers/net/ethernet/stmicro/stmmac/dwmac4_dma.c ++++ b/drivers/net/ethernet/stmicro/stmmac/dwmac4_dma.c +@@ -347,8 +347,8 @@ static void dwmac4_dma_tx_chan_op_mode(void __iomem *ioaddr, int mode, + writel(mtl_tx_op, ioaddr + MTL_CHAN_TX_OP_MODE(channel)); + } + +-static void dwmac4_get_hw_feature(void __iomem *ioaddr, +- struct dma_features *dma_cap) ++static int dwmac4_get_hw_feature(void __iomem *ioaddr, ++ struct dma_features *dma_cap) + { + u32 hw_cap = readl(ioaddr + GMAC_HW_FEATURE0); + +@@ -437,6 +437,8 @@ static void dwmac4_get_hw_feature(void __iomem *ioaddr, + dma_cap->frpbs = (hw_cap & GMAC_HW_FEAT_FRPBS) >> 11; + dma_cap->frpsel = (hw_cap & GMAC_HW_FEAT_FRPSEL) >> 10; + dma_cap->dvlan = (hw_cap & GMAC_HW_FEAT_DVLAN) >> 5; ++ ++ return 0; + } + + /* Enable/disable TSO feature and set MSS */ +diff --git a/drivers/net/ethernet/stmicro/stmmac/dwxgmac2_dma.c b/drivers/net/ethernet/stmicro/stmmac/dwxgmac2_dma.c +index 906e985441a93..5e98355f422b3 100644 +--- a/drivers/net/ethernet/stmicro/stmmac/dwxgmac2_dma.c ++++ b/drivers/net/ethernet/stmicro/stmmac/dwxgmac2_dma.c +@@ -371,8 +371,8 @@ static int dwxgmac2_dma_interrupt(void __iomem *ioaddr, + return ret; + } + +-static void dwxgmac2_get_hw_feature(void __iomem *ioaddr, +- struct dma_features *dma_cap) ++static int dwxgmac2_get_hw_feature(void __iomem *ioaddr, ++ struct dma_features *dma_cap) + { + u32 hw_cap; + +@@ -445,6 +445,8 @@ static void dwxgmac2_get_hw_feature(void __iomem *ioaddr, + dma_cap->frpes = (hw_cap & XGMAC_HWFEAT_FRPES) >> 11; + dma_cap->frpbs = (hw_cap & XGMAC_HWFEAT_FRPPB) >> 9; + dma_cap->frpsel = (hw_cap & XGMAC_HWFEAT_FRPSEL) >> 3; ++ ++ return 0; + } + + static void dwxgmac2_rx_watchdog(void __iomem *ioaddr, u32 riwt, u32 queue) +diff --git a/drivers/net/ethernet/stmicro/stmmac/hwif.h b/drivers/net/ethernet/stmicro/stmmac/hwif.h +index 6dc1c98ebec82..fe2660d5694d7 100644 +--- a/drivers/net/ethernet/stmicro/stmmac/hwif.h ++++ b/drivers/net/ethernet/stmicro/stmmac/hwif.h +@@ -203,8 +203,8 @@ struct stmmac_dma_ops { + int (*dma_interrupt) (void __iomem *ioaddr, + struct stmmac_extra_stats *x, u32 chan, u32 dir); + /* If supported then get the optional core features */ +- void (*get_hw_feature)(void __iomem *ioaddr, +- struct dma_features *dma_cap); ++ int (*get_hw_feature)(void __iomem *ioaddr, ++ struct dma_features *dma_cap); + /* Program the HW RX Watchdog */ + void (*rx_watchdog)(void __iomem *ioaddr, u32 riwt, u32 queue); + void (*set_tx_ring_len)(void __iomem *ioaddr, u32 len, u32 chan); +@@ -255,7 +255,7 @@ struct stmmac_dma_ops { + #define stmmac_dma_interrupt_status(__priv, __args...) \ + stmmac_do_callback(__priv, dma, dma_interrupt, __args) + #define stmmac_get_hw_feature(__priv, __args...) \ +- stmmac_do_void_callback(__priv, dma, get_hw_feature, __args) ++ stmmac_do_callback(__priv, dma, get_hw_feature, __args) + #define stmmac_rx_watchdog(__priv, __args...) \ + stmmac_do_void_callback(__priv, dma, rx_watchdog, __args) + #define stmmac_set_tx_ring_len(__priv, __args...) \ +diff --git a/drivers/net/phy/phy_device.c b/drivers/net/phy/phy_device.c +index 5d5f9a9ee768a..787462310aae3 100644 +--- a/drivers/net/phy/phy_device.c ++++ b/drivers/net/phy/phy_device.c +@@ -3112,6 +3112,9 @@ static void phy_shutdown(struct device *dev) + { + struct phy_device *phydev = to_phy_device(dev); + ++ if (phydev->state == PHY_READY || !phydev->attached_dev) ++ return; ++ + phy_disable_interrupts(phydev); + } + +diff --git a/drivers/net/usb/Kconfig b/drivers/net/usb/Kconfig +index 4c5d69732a7e1..f87f175033731 100644 +--- a/drivers/net/usb/Kconfig ++++ b/drivers/net/usb/Kconfig +@@ -99,6 +99,10 @@ config USB_RTL8150 + config USB_RTL8152 + tristate "Realtek RTL8152/RTL8153 Based USB Ethernet Adapters" + select MII ++ select CRC32 ++ select CRYPTO ++ select CRYPTO_HASH ++ select CRYPTO_SHA256 + help + This option adds support for Realtek RTL8152 based USB 2.0 + 10/100 Ethernet adapters and RTL8153 based USB 3.0 10/100/1000 +diff --git a/drivers/nvme/host/pci.c b/drivers/nvme/host/pci.c +index 4f22fbafe964f..1f41619018c16 100644 +--- a/drivers/nvme/host/pci.c ++++ b/drivers/nvme/host/pci.c +@@ -1331,7 +1331,7 @@ static enum blk_eh_timer_return nvme_timeout(struct request *req, bool reserved) + iod->aborted = 1; + + cmd.abort.opcode = nvme_admin_abort_cmd; +- cmd.abort.cid = req->tag; ++ cmd.abort.cid = nvme_cid(req); + cmd.abort.sqid = cpu_to_le16(nvmeq->qid); + + dev_warn(nvmeq->dev->ctrl.device, +diff --git a/drivers/nvmem/core.c b/drivers/nvmem/core.c +index 3d87fadaa160d..8976da38b375a 100644 +--- a/drivers/nvmem/core.c ++++ b/drivers/nvmem/core.c +@@ -1383,7 +1383,8 @@ static void nvmem_shift_read_buffer_in_place(struct nvmem_cell *cell, void *buf) + *p-- = 0; + + /* clear msb bits if any leftover in the last byte */ +- *p &= GENMASK((cell->nbits%BITS_PER_BYTE) - 1, 0); ++ if (cell->nbits % BITS_PER_BYTE) ++ *p &= GENMASK((cell->nbits % BITS_PER_BYTE) - 1, 0); + } + + static int __nvmem_cell_read(struct nvmem_device *nvmem, +diff --git a/drivers/platform/mellanox/mlxreg-io.c b/drivers/platform/mellanox/mlxreg-io.c +index 7646708d57e42..a916cd89cbbed 100644 +--- a/drivers/platform/mellanox/mlxreg-io.c ++++ b/drivers/platform/mellanox/mlxreg-io.c +@@ -98,7 +98,7 @@ mlxreg_io_get_reg(void *regmap, struct mlxreg_core_data *data, u32 in_val, + if (ret) + goto access_error; + +- *regval |= rol32(val, regsize * i); ++ *regval |= rol32(val, regsize * i * 8); + } + } + +@@ -141,7 +141,7 @@ mlxreg_io_attr_store(struct device *dev, struct device_attribute *attr, + return -EINVAL; + + /* Convert buffer to input value. */ +- ret = kstrtou32(buf, len, &input_val); ++ ret = kstrtou32(buf, 0, &input_val); + if (ret) + return ret; + +diff --git a/drivers/platform/x86/amd-pmc.c b/drivers/platform/x86/amd-pmc.c +index d6a7c896ac866..fc95620101e85 100644 +--- a/drivers/platform/x86/amd-pmc.c ++++ b/drivers/platform/x86/amd-pmc.c +@@ -476,6 +476,7 @@ static const struct acpi_device_id amd_pmc_acpi_ids[] = { + {"AMDI0006", 0}, + {"AMDI0007", 0}, + {"AMD0004", 0}, ++ {"AMD0005", 0}, + { } + }; + MODULE_DEVICE_TABLE(acpi, amd_pmc_acpi_ids); +diff --git a/drivers/platform/x86/gigabyte-wmi.c b/drivers/platform/x86/gigabyte-wmi.c +index d53634c8a6e09..658bab4b79648 100644 +--- a/drivers/platform/x86/gigabyte-wmi.c ++++ b/drivers/platform/x86/gigabyte-wmi.c +@@ -141,6 +141,7 @@ static u8 gigabyte_wmi_detect_sensor_usability(struct wmi_device *wdev) + + static const struct dmi_system_id gigabyte_wmi_known_working_platforms[] = { + DMI_EXACT_MATCH_GIGABYTE_BOARD_NAME("B450M S2H V2"), ++ DMI_EXACT_MATCH_GIGABYTE_BOARD_NAME("B550 AORUS ELITE AX V2"), + DMI_EXACT_MATCH_GIGABYTE_BOARD_NAME("B550 AORUS ELITE"), + DMI_EXACT_MATCH_GIGABYTE_BOARD_NAME("B550 AORUS ELITE V2"), + DMI_EXACT_MATCH_GIGABYTE_BOARD_NAME("B550 GAMING X V2"), +diff --git a/drivers/platform/x86/intel_scu_ipc.c b/drivers/platform/x86/intel_scu_ipc.c +index 9171a46a9e3fe..25b98b12439f1 100644 +--- a/drivers/platform/x86/intel_scu_ipc.c ++++ b/drivers/platform/x86/intel_scu_ipc.c +@@ -232,7 +232,7 @@ static inline u32 ipc_data_readl(struct intel_scu_ipc_dev *scu, u32 offset) + /* Wait till scu status is busy */ + static inline int busy_loop(struct intel_scu_ipc_dev *scu) + { +- unsigned long end = jiffies + msecs_to_jiffies(IPC_TIMEOUT); ++ unsigned long end = jiffies + IPC_TIMEOUT; + + do { + u32 status; +diff --git a/drivers/spi/spi-atmel.c b/drivers/spi/spi-atmel.c +index 788dcdf25f003..f872cf196c2f3 100644 +--- a/drivers/spi/spi-atmel.c ++++ b/drivers/spi/spi-atmel.c +@@ -1301,7 +1301,7 @@ static int atmel_spi_one_transfer(struct spi_master *master, + * DMA map early, for performance (empties dcache ASAP) and + * better fault reporting. + */ +- if ((!master->cur_msg_mapped) ++ if ((!master->cur_msg->is_dma_mapped) + && as->use_pdc) { + if (atmel_spi_dma_map_xfer(as, xfer) < 0) + return -ENOMEM; +@@ -1381,7 +1381,7 @@ static int atmel_spi_one_transfer(struct spi_master *master, + } + } + +- if (!master->cur_msg_mapped ++ if (!master->cur_msg->is_dma_mapped + && as->use_pdc) + atmel_spi_dma_unmap_xfer(master, xfer); + +diff --git a/drivers/spi/spi-bcm-qspi.c b/drivers/spi/spi-bcm-qspi.c +index a78e56f566dd8..3043677ba2226 100644 +--- a/drivers/spi/spi-bcm-qspi.c ++++ b/drivers/spi/spi-bcm-qspi.c +@@ -1250,10 +1250,14 @@ static void bcm_qspi_hw_init(struct bcm_qspi *qspi) + + static void bcm_qspi_hw_uninit(struct bcm_qspi *qspi) + { ++ u32 status = bcm_qspi_read(qspi, MSPI, MSPI_MSPI_STATUS); ++ + bcm_qspi_write(qspi, MSPI, MSPI_SPCR2, 0); + if (has_bspi(qspi)) + bcm_qspi_write(qspi, MSPI, MSPI_WRITE_LOCK, 0); + ++ /* clear interrupt */ ++ bcm_qspi_write(qspi, MSPI, MSPI_MSPI_STATUS, status & ~1); + } + + static const struct spi_controller_mem_ops bcm_qspi_mem_ops = { +@@ -1397,6 +1401,47 @@ int bcm_qspi_probe(struct platform_device *pdev, + if (!qspi->dev_ids) + return -ENOMEM; + ++ /* ++ * Some SoCs integrate spi controller (e.g., its interrupt bits) ++ * in specific ways ++ */ ++ if (soc_intc) { ++ qspi->soc_intc = soc_intc; ++ soc_intc->bcm_qspi_int_set(soc_intc, MSPI_DONE, true); ++ } else { ++ qspi->soc_intc = NULL; ++ } ++ ++ if (qspi->clk) { ++ ret = clk_prepare_enable(qspi->clk); ++ if (ret) { ++ dev_err(dev, "failed to prepare clock\n"); ++ goto qspi_probe_err; ++ } ++ qspi->base_clk = clk_get_rate(qspi->clk); ++ } else { ++ qspi->base_clk = MSPI_BASE_FREQ; ++ } ++ ++ if (data->has_mspi_rev) { ++ rev = bcm_qspi_read(qspi, MSPI, MSPI_REV); ++ /* some older revs do not have a MSPI_REV register */ ++ if ((rev & 0xff) == 0xff) ++ rev = 0; ++ } ++ ++ qspi->mspi_maj_rev = (rev >> 4) & 0xf; ++ qspi->mspi_min_rev = rev & 0xf; ++ qspi->mspi_spcr3_sysclk = data->has_spcr3_sysclk; ++ ++ qspi->max_speed_hz = qspi->base_clk / (bcm_qspi_spbr_min(qspi) * 2); ++ ++ /* ++ * On SW resets it is possible to have the mask still enabled ++ * Need to disable the mask and clear the status while we init ++ */ ++ bcm_qspi_hw_uninit(qspi); ++ + for (val = 0; val < num_irqs; val++) { + irq = -1; + name = qspi_irq_tab[val].irq_name; +@@ -1433,38 +1478,6 @@ int bcm_qspi_probe(struct platform_device *pdev, + goto qspi_probe_err; + } + +- /* +- * Some SoCs integrate spi controller (e.g., its interrupt bits) +- * in specific ways +- */ +- if (soc_intc) { +- qspi->soc_intc = soc_intc; +- soc_intc->bcm_qspi_int_set(soc_intc, MSPI_DONE, true); +- } else { +- qspi->soc_intc = NULL; +- } +- +- ret = clk_prepare_enable(qspi->clk); +- if (ret) { +- dev_err(dev, "failed to prepare clock\n"); +- goto qspi_probe_err; +- } +- +- qspi->base_clk = clk_get_rate(qspi->clk); +- +- if (data->has_mspi_rev) { +- rev = bcm_qspi_read(qspi, MSPI, MSPI_REV); +- /* some older revs do not have a MSPI_REV register */ +- if ((rev & 0xff) == 0xff) +- rev = 0; +- } +- +- qspi->mspi_maj_rev = (rev >> 4) & 0xf; +- qspi->mspi_min_rev = rev & 0xf; +- qspi->mspi_spcr3_sysclk = data->has_spcr3_sysclk; +- +- qspi->max_speed_hz = qspi->base_clk / (bcm_qspi_spbr_min(qspi) * 2); +- + bcm_qspi_hw_init(qspi); + init_completion(&qspi->mspi_done); + init_completion(&qspi->bspi_done); +diff --git a/drivers/spi/spidev.c b/drivers/spi/spidev.c +index 24e9469ea35bb..515466c60f77f 100644 +--- a/drivers/spi/spidev.c ++++ b/drivers/spi/spidev.c +@@ -673,6 +673,19 @@ static const struct file_operations spidev_fops = { + + static struct class *spidev_class; + ++static const struct spi_device_id spidev_spi_ids[] = { ++ { .name = "dh2228fv" }, ++ { .name = "ltc2488" }, ++ { .name = "sx1301" }, ++ { .name = "bk4" }, ++ { .name = "dhcom-board" }, ++ { .name = "m53cpld" }, ++ { .name = "spi-petra" }, ++ { .name = "spi-authenta" }, ++ {}, ++}; ++MODULE_DEVICE_TABLE(spi, spidev_spi_ids); ++ + #ifdef CONFIG_OF + static const struct of_device_id spidev_dt_ids[] = { + { .compatible = "rohm,dh2228fv" }, +@@ -819,6 +832,7 @@ static struct spi_driver spidev_spi_driver = { + }, + .probe = spidev_probe, + .remove = spidev_remove, ++ .id_table = spidev_spi_ids, + + /* NOTE: suspend/resume methods are not necessary here. + * We don't do anything except pass the requests to/from +diff --git a/drivers/tee/optee/core.c b/drivers/tee/optee/core.c +index 5ce13b099d7dc..5363ebebfc357 100644 +--- a/drivers/tee/optee/core.c ++++ b/drivers/tee/optee/core.c +@@ -585,6 +585,9 @@ static int optee_remove(struct platform_device *pdev) + { + struct optee *optee = platform_get_drvdata(pdev); + ++ /* Unregister OP-TEE specific client devices on TEE bus */ ++ optee_unregister_devices(); ++ + /* + * Ask OP-TEE to free all cached shared memory objects to decrease + * reference counters and also avoid wild pointers in secure world +diff --git a/drivers/tee/optee/device.c b/drivers/tee/optee/device.c +index ec1d24693ebaa..128a2d2a50a16 100644 +--- a/drivers/tee/optee/device.c ++++ b/drivers/tee/optee/device.c +@@ -53,6 +53,13 @@ static int get_devices(struct tee_context *ctx, u32 session, + return 0; + } + ++static void optee_release_device(struct device *dev) ++{ ++ struct tee_client_device *optee_device = to_tee_client_device(dev); ++ ++ kfree(optee_device); ++} ++ + static int optee_register_device(const uuid_t *device_uuid) + { + struct tee_client_device *optee_device = NULL; +@@ -63,6 +70,7 @@ static int optee_register_device(const uuid_t *device_uuid) + return -ENOMEM; + + optee_device->dev.bus = &tee_bus_type; ++ optee_device->dev.release = optee_release_device; + if (dev_set_name(&optee_device->dev, "optee-ta-%pUb", device_uuid)) { + kfree(optee_device); + return -ENOMEM; +@@ -154,3 +162,17 @@ int optee_enumerate_devices(u32 func) + { + return __optee_enumerate_devices(func); + } ++ ++static int __optee_unregister_device(struct device *dev, void *data) ++{ ++ if (!strncmp(dev_name(dev), "optee-ta", strlen("optee-ta"))) ++ device_unregister(dev); ++ ++ return 0; ++} ++ ++void optee_unregister_devices(void) ++{ ++ bus_for_each_dev(&tee_bus_type, NULL, NULL, ++ __optee_unregister_device); ++} +diff --git a/drivers/tee/optee/optee_private.h b/drivers/tee/optee/optee_private.h +index dbdd367be1568..f6bb4a763ba94 100644 +--- a/drivers/tee/optee/optee_private.h ++++ b/drivers/tee/optee/optee_private.h +@@ -184,6 +184,7 @@ void optee_fill_pages_list(u64 *dst, struct page **pages, int num_pages, + #define PTA_CMD_GET_DEVICES 0x0 + #define PTA_CMD_GET_DEVICES_SUPP 0x1 + int optee_enumerate_devices(u32 func); ++void optee_unregister_devices(void); + + /* + * Small helpers +diff --git a/drivers/usb/host/xhci-dbgtty.c b/drivers/usb/host/xhci-dbgtty.c +index bef104511352c..509b597e30edb 100644 +--- a/drivers/usb/host/xhci-dbgtty.c ++++ b/drivers/usb/host/xhci-dbgtty.c +@@ -408,40 +408,38 @@ static int xhci_dbc_tty_register_device(struct xhci_dbc *dbc) + return -EBUSY; + + xhci_dbc_tty_init_port(dbc, port); +- tty_dev = tty_port_register_device(&port->port, +- dbc_tty_driver, 0, NULL); +- if (IS_ERR(tty_dev)) { +- ret = PTR_ERR(tty_dev); +- goto register_fail; +- } + + ret = kfifo_alloc(&port->write_fifo, DBC_WRITE_BUF_SIZE, GFP_KERNEL); + if (ret) +- goto buf_alloc_fail; ++ goto err_exit_port; + + ret = xhci_dbc_alloc_requests(dbc, BULK_IN, &port->read_pool, + dbc_read_complete); + if (ret) +- goto request_fail; ++ goto err_free_fifo; + + ret = xhci_dbc_alloc_requests(dbc, BULK_OUT, &port->write_pool, + dbc_write_complete); + if (ret) +- goto request_fail; ++ goto err_free_requests; ++ ++ tty_dev = tty_port_register_device(&port->port, ++ dbc_tty_driver, 0, NULL); ++ if (IS_ERR(tty_dev)) { ++ ret = PTR_ERR(tty_dev); ++ goto err_free_requests; ++ } + + port->registered = true; + + return 0; + +-request_fail: ++err_free_requests: + xhci_dbc_free_requests(&port->read_pool); + xhci_dbc_free_requests(&port->write_pool); ++err_free_fifo: + kfifo_free(&port->write_fifo); +- +-buf_alloc_fail: +- tty_unregister_device(dbc_tty_driver, 0); +- +-register_fail: ++err_exit_port: + xhci_dbc_tty_exit_port(port); + + dev_err(dbc->dev, "can't register tty port, err %d\n", ret); +diff --git a/drivers/usb/host/xhci-pci.c b/drivers/usb/host/xhci-pci.c +index 1c9a7957c45c5..003c5f0a8760f 100644 +--- a/drivers/usb/host/xhci-pci.c ++++ b/drivers/usb/host/xhci-pci.c +@@ -30,6 +30,7 @@ + #define PCI_VENDOR_ID_FRESCO_LOGIC 0x1b73 + #define PCI_DEVICE_ID_FRESCO_LOGIC_PDK 0x1000 + #define PCI_DEVICE_ID_FRESCO_LOGIC_FL1009 0x1009 ++#define PCI_DEVICE_ID_FRESCO_LOGIC_FL1100 0x1100 + #define PCI_DEVICE_ID_FRESCO_LOGIC_FL1400 0x1400 + + #define PCI_VENDOR_ID_ETRON 0x1b6f +@@ -113,6 +114,7 @@ static void xhci_pci_quirks(struct device *dev, struct xhci_hcd *xhci) + /* Look for vendor-specific quirks */ + if (pdev->vendor == PCI_VENDOR_ID_FRESCO_LOGIC && + (pdev->device == PCI_DEVICE_ID_FRESCO_LOGIC_PDK || ++ pdev->device == PCI_DEVICE_ID_FRESCO_LOGIC_FL1100 || + pdev->device == PCI_DEVICE_ID_FRESCO_LOGIC_FL1400)) { + if (pdev->device == PCI_DEVICE_ID_FRESCO_LOGIC_PDK && + pdev->revision == 0x0) { +@@ -279,8 +281,10 @@ static void xhci_pci_quirks(struct device *dev, struct xhci_hcd *xhci) + pdev->device == 0x3432) + xhci->quirks |= XHCI_BROKEN_STREAMS; + +- if (pdev->vendor == PCI_VENDOR_ID_VIA && pdev->device == 0x3483) ++ if (pdev->vendor == PCI_VENDOR_ID_VIA && pdev->device == 0x3483) { + xhci->quirks |= XHCI_LPM_SUPPORT; ++ xhci->quirks |= XHCI_EP_CTX_BROKEN_DCS; ++ } + + if (pdev->vendor == PCI_VENDOR_ID_ASMEDIA && + pdev->device == PCI_DEVICE_ID_ASMEDIA_1042_XHCI) +diff --git a/drivers/usb/host/xhci-ring.c b/drivers/usb/host/xhci-ring.c +index 9017986241f51..8fedf1bf292ba 100644 +--- a/drivers/usb/host/xhci-ring.c ++++ b/drivers/usb/host/xhci-ring.c +@@ -366,16 +366,22 @@ static void xhci_handle_stopped_cmd_ring(struct xhci_hcd *xhci, + /* Must be called with xhci->lock held, releases and aquires lock back */ + static int xhci_abort_cmd_ring(struct xhci_hcd *xhci, unsigned long flags) + { +- u64 temp_64; ++ u32 temp_32; + int ret; + + xhci_dbg(xhci, "Abort command ring\n"); + + reinit_completion(&xhci->cmd_ring_stop_completion); + +- temp_64 = xhci_read_64(xhci, &xhci->op_regs->cmd_ring); +- xhci_write_64(xhci, temp_64 | CMD_RING_ABORT, +- &xhci->op_regs->cmd_ring); ++ /* ++ * The control bits like command stop, abort are located in lower ++ * dword of the command ring control register. Limit the write ++ * to the lower dword to avoid corrupting the command ring pointer ++ * in case if the command ring is stopped by the time upper dword ++ * is written. ++ */ ++ temp_32 = readl(&xhci->op_regs->cmd_ring); ++ writel(temp_32 | CMD_RING_ABORT, &xhci->op_regs->cmd_ring); + + /* Section 4.6.1.2 of xHCI 1.0 spec says software should also time the + * completion of the Command Abort operation. If CRR is not negated in 5 +@@ -559,8 +565,11 @@ static int xhci_move_dequeue_past_td(struct xhci_hcd *xhci, + struct xhci_ring *ep_ring; + struct xhci_command *cmd; + struct xhci_segment *new_seg; ++ struct xhci_segment *halted_seg = NULL; + union xhci_trb *new_deq; + int new_cycle; ++ union xhci_trb *halted_trb; ++ int index = 0; + dma_addr_t addr; + u64 hw_dequeue; + bool cycle_found = false; +@@ -598,7 +607,27 @@ static int xhci_move_dequeue_past_td(struct xhci_hcd *xhci, + hw_dequeue = xhci_get_hw_deq(xhci, dev, ep_index, stream_id); + new_seg = ep_ring->deq_seg; + new_deq = ep_ring->dequeue; +- new_cycle = hw_dequeue & 0x1; ++ ++ /* ++ * Quirk: xHC write-back of the DCS field in the hardware dequeue ++ * pointer is wrong - use the cycle state of the TRB pointed to by ++ * the dequeue pointer. ++ */ ++ if (xhci->quirks & XHCI_EP_CTX_BROKEN_DCS && ++ !(ep->ep_state & EP_HAS_STREAMS)) ++ halted_seg = trb_in_td(xhci, td->start_seg, ++ td->first_trb, td->last_trb, ++ hw_dequeue & ~0xf, false); ++ if (halted_seg) { ++ index = ((dma_addr_t)(hw_dequeue & ~0xf) - halted_seg->dma) / ++ sizeof(*halted_trb); ++ halted_trb = &halted_seg->trbs[index]; ++ new_cycle = halted_trb->generic.field[3] & 0x1; ++ xhci_dbg(xhci, "Endpoint DCS = %d TRB index = %d cycle = %d\n", ++ (u8)(hw_dequeue & 0x1), index, new_cycle); ++ } else { ++ new_cycle = hw_dequeue & 0x1; ++ } + + /* + * We want to find the pointer, segment and cycle state of the new trb +diff --git a/drivers/usb/host/xhci.c b/drivers/usb/host/xhci.c +index 4a1346e3de1b2..cb730683f898f 100644 +--- a/drivers/usb/host/xhci.c ++++ b/drivers/usb/host/xhci.c +@@ -3212,10 +3212,13 @@ static void xhci_endpoint_reset(struct usb_hcd *hcd, + return; + + /* Bail out if toggle is already being cleared by a endpoint reset */ ++ spin_lock_irqsave(&xhci->lock, flags); + if (ep->ep_state & EP_HARD_CLEAR_TOGGLE) { + ep->ep_state &= ~EP_HARD_CLEAR_TOGGLE; ++ spin_unlock_irqrestore(&xhci->lock, flags); + return; + } ++ spin_unlock_irqrestore(&xhci->lock, flags); + /* Only interrupt and bulk ep's use data toggle, USB2 spec 5.5.4-> */ + if (usb_endpoint_xfer_control(&host_ep->desc) || + usb_endpoint_xfer_isoc(&host_ep->desc)) +@@ -3301,8 +3304,10 @@ static void xhci_endpoint_reset(struct usb_hcd *hcd, + xhci_free_command(xhci, cfg_cmd); + cleanup: + xhci_free_command(xhci, stop_cmd); ++ spin_lock_irqsave(&xhci->lock, flags); + if (ep->ep_state & EP_SOFT_CLEAR_TOGGLE) + ep->ep_state &= ~EP_SOFT_CLEAR_TOGGLE; ++ spin_unlock_irqrestore(&xhci->lock, flags); + } + + static int xhci_check_streams_endpoint(struct xhci_hcd *xhci, +diff --git a/drivers/usb/host/xhci.h b/drivers/usb/host/xhci.h +index dca6181c33fdb..5a75fe5631238 100644 +--- a/drivers/usb/host/xhci.h ++++ b/drivers/usb/host/xhci.h +@@ -1899,6 +1899,7 @@ struct xhci_hcd { + #define XHCI_SG_TRB_CACHE_SIZE_QUIRK BIT_ULL(39) + #define XHCI_NO_SOFT_RETRY BIT_ULL(40) + #define XHCI_BROKEN_D3COLD BIT_ULL(41) ++#define XHCI_EP_CTX_BROKEN_DCS BIT_ULL(42) + + unsigned int num_active_eps; + unsigned int limit_active_eps; +diff --git a/drivers/usb/musb/musb_dsps.c b/drivers/usb/musb/musb_dsps.c +index ce9fc46c92661..b5935834f9d24 100644 +--- a/drivers/usb/musb/musb_dsps.c ++++ b/drivers/usb/musb/musb_dsps.c +@@ -899,11 +899,13 @@ static int dsps_probe(struct platform_device *pdev) + if (usb_get_dr_mode(&pdev->dev) == USB_DR_MODE_PERIPHERAL) { + ret = dsps_setup_optional_vbus_irq(pdev, glue); + if (ret) +- goto err; ++ goto unregister_pdev; + } + + return 0; + ++unregister_pdev: ++ platform_device_unregister(glue->musb); + err: + pm_runtime_disable(&pdev->dev); + iounmap(glue->usbss_base); +diff --git a/drivers/usb/serial/option.c b/drivers/usb/serial/option.c +index 6cfb5d33609fb..a484ff5e4ebf8 100644 +--- a/drivers/usb/serial/option.c ++++ b/drivers/usb/serial/option.c +@@ -246,11 +246,13 @@ static void option_instat_callback(struct urb *urb); + /* These Quectel products use Quectel's vendor ID */ + #define QUECTEL_PRODUCT_EC21 0x0121 + #define QUECTEL_PRODUCT_EC25 0x0125 ++#define QUECTEL_PRODUCT_EG91 0x0191 + #define QUECTEL_PRODUCT_EG95 0x0195 + #define QUECTEL_PRODUCT_BG96 0x0296 + #define QUECTEL_PRODUCT_EP06 0x0306 + #define QUECTEL_PRODUCT_EM12 0x0512 + #define QUECTEL_PRODUCT_RM500Q 0x0800 ++#define QUECTEL_PRODUCT_EC200S_CN 0x6002 + #define QUECTEL_PRODUCT_EC200T 0x6026 + + #define CMOTECH_VENDOR_ID 0x16d8 +@@ -1111,6 +1113,9 @@ static const struct usb_device_id option_ids[] = { + { 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_EG91, 0xff, 0xff, 0xff), ++ .driver_info = NUMEP2 }, ++ { USB_DEVICE_AND_INTERFACE_INFO(QUECTEL_VENDOR_ID, QUECTEL_PRODUCT_EG91, 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) }, +@@ -1128,6 +1133,7 @@ static const struct usb_device_id option_ids[] = { + { USB_DEVICE_AND_INTERFACE_INFO(QUECTEL_VENDOR_ID, QUECTEL_PRODUCT_RM500Q, 0xff, 0, 0) }, + { USB_DEVICE_AND_INTERFACE_INFO(QUECTEL_VENDOR_ID, QUECTEL_PRODUCT_RM500Q, 0xff, 0xff, 0x10), + .driver_info = ZLP }, ++ { USB_DEVICE_AND_INTERFACE_INFO(QUECTEL_VENDOR_ID, QUECTEL_PRODUCT_EC200S_CN, 0xff, 0, 0) }, + { USB_DEVICE_AND_INTERFACE_INFO(QUECTEL_VENDOR_ID, QUECTEL_PRODUCT_EC200T, 0xff, 0, 0) }, + + { USB_DEVICE(CMOTECH_VENDOR_ID, CMOTECH_PRODUCT_6001) }, +@@ -1227,6 +1233,8 @@ static const struct usb_device_id option_ids[] = { + .driver_info = NCTRL(0) | RSVD(1) | RSVD(2) }, + { USB_DEVICE_INTERFACE_CLASS(TELIT_VENDOR_ID, 0x1203, 0xff), /* Telit LE910Cx (RNDIS) */ + .driver_info = NCTRL(2) | RSVD(3) }, ++ { USB_DEVICE_INTERFACE_CLASS(TELIT_VENDOR_ID, 0x1204, 0xff), /* Telit LE910Cx (MBIM) */ ++ .driver_info = NCTRL(0) | RSVD(1) }, + { USB_DEVICE(TELIT_VENDOR_ID, TELIT_PRODUCT_LE910_USBCFG4), + .driver_info = NCTRL(0) | RSVD(1) | RSVD(2) | RSVD(3) }, + { USB_DEVICE(TELIT_VENDOR_ID, TELIT_PRODUCT_LE920), +diff --git a/drivers/usb/serial/qcserial.c b/drivers/usb/serial/qcserial.c +index 83da8236e3c8b..c18bf8164bc2e 100644 +--- a/drivers/usb/serial/qcserial.c ++++ b/drivers/usb/serial/qcserial.c +@@ -165,6 +165,7 @@ static const struct usb_device_id id_table[] = { + {DEVICE_SWI(0x1199, 0x907b)}, /* Sierra Wireless EM74xx */ + {DEVICE_SWI(0x1199, 0x9090)}, /* Sierra Wireless EM7565 QDL */ + {DEVICE_SWI(0x1199, 0x9091)}, /* Sierra Wireless EM7565 */ ++ {DEVICE_SWI(0x1199, 0x90d2)}, /* Sierra Wireless EM9191 QDL */ + {DEVICE_SWI(0x413c, 0x81a2)}, /* Dell Wireless 5806 Gobi(TM) 4G LTE Mobile Broadband Card */ + {DEVICE_SWI(0x413c, 0x81a3)}, /* Dell Wireless 5570 HSPA+ (42Mbps) Mobile Broadband Card */ + {DEVICE_SWI(0x413c, 0x81a4)}, /* Dell Wireless 5570e HSPA+ (42Mbps) Mobile Broadband Card */ +diff --git a/drivers/vhost/vdpa.c b/drivers/vhost/vdpa.c +index 9479f7f792173..55ec22f4ef901 100644 +--- a/drivers/vhost/vdpa.c ++++ b/drivers/vhost/vdpa.c +@@ -316,7 +316,7 @@ static long vhost_vdpa_set_config_call(struct vhost_vdpa *v, u32 __user *argp) + struct eventfd_ctx *ctx; + + cb.callback = vhost_vdpa_config_cb; +- cb.private = v->vdpa; ++ cb.private = v; + if (copy_from_user(&fd, argp, sizeof(fd))) + return -EFAULT; + +diff --git a/drivers/virtio/virtio.c b/drivers/virtio/virtio.c +index 49984d2cba246..581871e707eb2 100644 +--- a/drivers/virtio/virtio.c ++++ b/drivers/virtio/virtio.c +@@ -238,6 +238,17 @@ static int virtio_dev_probe(struct device *_d) + driver_features_legacy = driver_features; + } + ++ /* ++ * Some devices detect legacy solely via F_VERSION_1. Write ++ * F_VERSION_1 to force LE config space accesses before FEATURES_OK for ++ * these when needed. ++ */ ++ if (drv->validate && !virtio_legacy_is_little_endian() ++ && device_features & BIT_ULL(VIRTIO_F_VERSION_1)) { ++ dev->features = BIT_ULL(VIRTIO_F_VERSION_1); ++ dev->config->finalize_features(dev); ++ } ++ + if (device_features & (1ULL << VIRTIO_F_VERSION_1)) + dev->features = driver_features & device_features; + else +diff --git a/fs/btrfs/extent-tree.c b/fs/btrfs/extent-tree.c +index 268ce58d45697..5fec2706490ca 100644 +--- a/fs/btrfs/extent-tree.c ++++ b/fs/btrfs/extent-tree.c +@@ -4859,6 +4859,7 @@ struct extent_buffer *btrfs_alloc_tree_block(struct btrfs_trans_handle *trans, + out_free_delayed: + btrfs_free_delayed_extent_op(extent_op); + out_free_buf: ++ btrfs_tree_unlock(buf); + free_extent_buffer(buf); + out_free_reserved: + btrfs_free_reserved_extent(fs_info, ins.objectid, ins.offset, 0); +diff --git a/fs/btrfs/file.c b/fs/btrfs/file.c +index ee34497500e16..ba44039071e5b 100644 +--- a/fs/btrfs/file.c ++++ b/fs/btrfs/file.c +@@ -733,8 +733,7 @@ int btrfs_drop_extents(struct btrfs_trans_handle *trans, + if (args->start >= inode->disk_i_size && !args->replace_extent) + modify_tree = 0; + +- update_refs = (test_bit(BTRFS_ROOT_SHAREABLE, &root->state) || +- root == fs_info->tree_root); ++ update_refs = (root->root_key.objectid != BTRFS_TREE_LOG_OBJECTID); + while (1) { + recow = 0; + ret = btrfs_lookup_file_extent(trans, root, path, ino, +@@ -2692,14 +2691,16 @@ int btrfs_replace_file_extents(struct btrfs_inode *inode, + drop_args.bytes_found); + if (ret != -ENOSPC) { + /* +- * When cloning we want to avoid transaction aborts when +- * nothing was done and we are attempting to clone parts +- * of inline extents, in such cases -EOPNOTSUPP is +- * returned by __btrfs_drop_extents() without having +- * changed anything in the file. ++ * The only time we don't want to abort is if we are ++ * attempting to clone a partial inline extent, in which ++ * case we'll get EOPNOTSUPP. However if we aren't ++ * clone we need to abort no matter what, because if we ++ * got EOPNOTSUPP via prealloc then we messed up and ++ * need to abort. + */ +- if (extent_info && !extent_info->is_new_extent && +- ret && ret != -EOPNOTSUPP) ++ if (ret && ++ (ret != -EOPNOTSUPP || ++ (extent_info && extent_info->is_new_extent))) + btrfs_abort_transaction(trans, ret); + break; + } +diff --git a/fs/btrfs/tree-log.c b/fs/btrfs/tree-log.c +index 7037e5855d2a8..17f0de5bb8733 100644 +--- a/fs/btrfs/tree-log.c ++++ b/fs/btrfs/tree-log.c +@@ -1182,7 +1182,10 @@ next: + /* look for a conflicting sequence number */ + di = btrfs_lookup_dir_index_item(trans, root, path, btrfs_ino(dir), + ref_index, name, namelen, 0); +- if (di && !IS_ERR(di)) { ++ if (IS_ERR(di)) { ++ if (PTR_ERR(di) != -ENOENT) ++ return PTR_ERR(di); ++ } else if (di) { + ret = drop_one_dir_item(trans, root, path, dir, di); + if (ret) + return ret; +@@ -1192,7 +1195,9 @@ next: + /* look for a conflicting name */ + di = btrfs_lookup_dir_item(trans, root, path, btrfs_ino(dir), + name, namelen, 0); +- if (di && !IS_ERR(di)) { ++ if (IS_ERR(di)) { ++ return PTR_ERR(di); ++ } else if (di) { + ret = drop_one_dir_item(trans, root, path, dir, di); + if (ret) + return ret; +@@ -1936,8 +1941,8 @@ static noinline int replay_one_name(struct btrfs_trans_handle *trans, + struct btrfs_key log_key; + struct inode *dir; + u8 log_type; +- int exists; +- int ret = 0; ++ bool exists; ++ int ret; + bool update_size = (key->type == BTRFS_DIR_INDEX_KEY); + bool name_added = false; + +@@ -1957,12 +1962,12 @@ static noinline int replay_one_name(struct btrfs_trans_handle *trans, + name_len); + + btrfs_dir_item_key_to_cpu(eb, di, &log_key); +- exists = btrfs_lookup_inode(trans, root, path, &log_key, 0); +- if (exists == 0) +- exists = 1; +- else +- exists = 0; ++ ret = btrfs_lookup_inode(trans, root, path, &log_key, 0); + btrfs_release_path(path); ++ if (ret < 0) ++ goto out; ++ exists = (ret == 0); ++ ret = 0; + + if (key->type == BTRFS_DIR_ITEM_KEY) { + dst_di = btrfs_lookup_dir_item(trans, root, path, key->objectid, +@@ -1977,7 +1982,14 @@ static noinline int replay_one_name(struct btrfs_trans_handle *trans, + ret = -EINVAL; + goto out; + } +- if (IS_ERR_OR_NULL(dst_di)) { ++ ++ if (dst_di == ERR_PTR(-ENOENT)) ++ dst_di = NULL; ++ ++ if (IS_ERR(dst_di)) { ++ ret = PTR_ERR(dst_di); ++ goto out; ++ } else if (!dst_di) { + /* we need a sequence number to insert, so we only + * do inserts for the BTRFS_DIR_INDEX_KEY types + */ +diff --git a/include/linux/mlx5/mlx5_ifc.h b/include/linux/mlx5/mlx5_ifc.h +index 6bbae0c3bc0b9..681bea6716dde 100644 +--- a/include/linux/mlx5/mlx5_ifc.h ++++ b/include/linux/mlx5/mlx5_ifc.h +@@ -9467,16 +9467,22 @@ struct mlx5_ifc_pcmr_reg_bits { + u8 reserved_at_0[0x8]; + u8 local_port[0x8]; + u8 reserved_at_10[0x10]; ++ + u8 entropy_force_cap[0x1]; + u8 entropy_calc_cap[0x1]; + u8 entropy_gre_calc_cap[0x1]; +- u8 reserved_at_23[0x1b]; ++ u8 reserved_at_23[0xf]; ++ u8 rx_ts_over_crc_cap[0x1]; ++ u8 reserved_at_33[0xb]; + u8 fcs_cap[0x1]; + u8 reserved_at_3f[0x1]; ++ + u8 entropy_force[0x1]; + u8 entropy_calc[0x1]; + u8 entropy_gre_calc[0x1]; +- u8 reserved_at_43[0x1b]; ++ u8 reserved_at_43[0xf]; ++ u8 rx_ts_over_crc[0x1]; ++ u8 reserved_at_53[0xb]; + u8 fcs_chk[0x1]; + u8 reserved_at_5f[0x1]; + }; +diff --git a/include/soc/mscc/ocelot.h b/include/soc/mscc/ocelot.h +index 2f5ce4d4fdbff..4984093882372 100644 +--- a/include/soc/mscc/ocelot.h ++++ b/include/soc/mscc/ocelot.h +@@ -600,10 +600,10 @@ struct ocelot_port { + /* The VLAN ID that will be transmitted as untagged, on egress */ + struct ocelot_vlan native_vlan; + ++ unsigned int ptp_skbs_in_flight; + u8 ptp_cmd; + struct sk_buff_head tx_skbs; + u8 ts_id; +- spinlock_t ts_id_lock; + + phy_interface_t phy_mode; + +@@ -677,6 +677,9 @@ struct ocelot { + struct ptp_clock *ptp_clock; + struct ptp_clock_info ptp_info; + struct hwtstamp_config hwtstamp_config; ++ unsigned int ptp_skbs_in_flight; ++ /* Protects the 2-step TX timestamp ID logic */ ++ spinlock_t ts_id_lock; + /* Protects the PTP interface state */ + struct mutex ptp_lock; + /* Protects the PTP clock */ +@@ -691,6 +694,7 @@ struct ocelot_policer { + + struct ocelot_skb_cb { + struct sk_buff *clone; ++ unsigned int ptp_class; /* valid only for clones */ + u8 ptp_cmd; + u8 ts_id; + }; +diff --git a/include/soc/mscc/ocelot_ptp.h b/include/soc/mscc/ocelot_ptp.h +index ded497d72bdbb..f085884b1fa27 100644 +--- a/include/soc/mscc/ocelot_ptp.h ++++ b/include/soc/mscc/ocelot_ptp.h +@@ -13,6 +13,9 @@ + #include + #include + ++#define OCELOT_MAX_PTP_ID 63 ++#define OCELOT_PTP_FIFO_SIZE 128 ++ + #define PTP_PIN_CFG_RSZ 0x20 + #define PTP_PIN_TOD_SEC_MSB_RSZ PTP_PIN_CFG_RSZ + #define PTP_PIN_TOD_SEC_LSB_RSZ PTP_PIN_CFG_RSZ +diff --git a/kernel/module.c b/kernel/module.c +index ed13917ea5f39..d184be24b9eac 100644 +--- a/kernel/module.c ++++ b/kernel/module.c +@@ -4484,8 +4484,10 @@ static void cfi_init(struct module *mod) + /* Fix init/exit functions to point to the CFI jump table */ + if (init) + mod->init = *init; ++#ifdef CONFIG_MODULE_UNLOAD + if (exit) + mod->exit = *exit; ++#endif + + cfi_module_add(mod, module_addr_min); + #endif +diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c +index a1adb29ef5c18..f4aa00a58f3c6 100644 +--- a/kernel/trace/trace.c ++++ b/kernel/trace/trace.c +@@ -1744,16 +1744,15 @@ void latency_fsnotify(struct trace_array *tr) + irq_work_queue(&tr->fsnotify_irqwork); + } + +-/* +- * (defined(CONFIG_TRACER_MAX_TRACE) || defined(CONFIG_HWLAT_TRACER)) && \ +- * defined(CONFIG_FSNOTIFY) +- */ +-#else ++#elif defined(CONFIG_TRACER_MAX_TRACE) || defined(CONFIG_HWLAT_TRACER) \ ++ || defined(CONFIG_OSNOISE_TRACER) + + #define trace_create_maxlat_file(tr, d_tracer) \ + trace_create_file("tracing_max_latency", 0644, d_tracer, \ + &tr->max_latency, &tracing_max_lat_fops) + ++#else ++#define trace_create_maxlat_file(tr, d_tracer) do { } while (0) + #endif + + #ifdef CONFIG_TRACER_MAX_TRACE +@@ -9457,9 +9456,7 @@ init_tracer_tracefs(struct trace_array *tr, struct dentry *d_tracer) + + create_trace_options_dir(tr); + +-#if defined(CONFIG_TRACER_MAX_TRACE) || defined(CONFIG_HWLAT_TRACER) + trace_create_maxlat_file(tr, d_tracer); +-#endif + + if (ftrace_create_function_files(tr, d_tracer)) + MEM_FAIL(1, "Could not allocate function filter files"); +diff --git a/net/dsa/switch.c b/net/dsa/switch.c +index 5ece05dfd8f2c..9ef9125713321 100644 +--- a/net/dsa/switch.c ++++ b/net/dsa/switch.c +@@ -148,7 +148,7 @@ static int dsa_switch_bridge_leave(struct dsa_switch *ds, + if (extack._msg) + dev_err(ds->dev, "port %d: %s\n", info->port, + extack._msg); +- if (err && err != EOPNOTSUPP) ++ if (err && err != -EOPNOTSUPP) + return err; + } + return 0; +diff --git a/net/mptcp/protocol.c b/net/mptcp/protocol.c +index 4d2abdd3cd3b1..e7ea062876f7c 100644 +--- a/net/mptcp/protocol.c ++++ b/net/mptcp/protocol.c +@@ -515,7 +515,6 @@ static bool mptcp_check_data_fin(struct sock *sk) + + sk->sk_shutdown |= RCV_SHUTDOWN; + smp_mb__before_atomic(); /* SHUTDOWN must be visible first */ +- set_bit(MPTCP_DATA_READY, &msk->flags); + + switch (sk->sk_state) { + case TCP_ESTABLISHED: +@@ -730,10 +729,9 @@ void mptcp_data_ready(struct sock *sk, struct sock *ssk) + + /* Wake-up the reader only for in-sequence data */ + mptcp_data_lock(sk); +- if (move_skbs_to_msk(msk, ssk)) { +- set_bit(MPTCP_DATA_READY, &msk->flags); ++ if (move_skbs_to_msk(msk, ssk)) + sk->sk_data_ready(sk); +- } ++ + mptcp_data_unlock(sk); + } + +@@ -838,7 +836,6 @@ static void mptcp_check_for_eof(struct mptcp_sock *msk) + sk->sk_shutdown |= RCV_SHUTDOWN; + + smp_mb__before_atomic(); /* SHUTDOWN must be visible first */ +- set_bit(MPTCP_DATA_READY, &msk->flags); + sk->sk_data_ready(sk); + } + +@@ -1701,21 +1698,6 @@ out: + return copied ? : ret; + } + +-static void mptcp_wait_data(struct sock *sk, long *timeo) +-{ +- DEFINE_WAIT_FUNC(wait, woken_wake_function); +- struct mptcp_sock *msk = mptcp_sk(sk); +- +- add_wait_queue(sk_sleep(sk), &wait); +- sk_set_bit(SOCKWQ_ASYNC_WAITDATA, sk); +- +- sk_wait_event(sk, timeo, +- test_bit(MPTCP_DATA_READY, &msk->flags), &wait); +- +- sk_clear_bit(SOCKWQ_ASYNC_WAITDATA, sk); +- remove_wait_queue(sk_sleep(sk), &wait); +-} +- + static int __mptcp_recvmsg_mskq(struct mptcp_sock *msk, + struct msghdr *msg, + size_t len, int flags, +@@ -2019,19 +2001,7 @@ static int mptcp_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, + } + + pr_debug("block timeout %ld", timeo); +- mptcp_wait_data(sk, &timeo); +- } +- +- if (skb_queue_empty_lockless(&sk->sk_receive_queue) && +- skb_queue_empty(&msk->receive_queue)) { +- /* entire backlog drained, clear DATA_READY. */ +- clear_bit(MPTCP_DATA_READY, &msk->flags); +- +- /* .. race-breaker: ssk might have gotten new data +- * after last __mptcp_move_skbs() returned false. +- */ +- if (unlikely(__mptcp_move_skbs(msk))) +- set_bit(MPTCP_DATA_READY, &msk->flags); ++ sk_wait_data(sk, &timeo, NULL); + } + + out_err: +@@ -2040,9 +2010,9 @@ out_err: + tcp_recv_timestamp(msg, sk, &tss); + } + +- pr_debug("msk=%p data_ready=%d rx queue empty=%d copied=%d", +- msk, test_bit(MPTCP_DATA_READY, &msk->flags), +- skb_queue_empty_lockless(&sk->sk_receive_queue), copied); ++ pr_debug("msk=%p rx queue empty=%d:%d copied=%d", ++ msk, skb_queue_empty_lockless(&sk->sk_receive_queue), ++ skb_queue_empty(&msk->receive_queue), copied); + if (!(flags & MSG_PEEK)) + mptcp_rcv_space_adjust(msk, copied); + +@@ -2255,7 +2225,6 @@ static void mptcp_check_fastclose(struct mptcp_sock *msk) + inet_sk_state_store(sk, TCP_CLOSE); + sk->sk_shutdown = SHUTDOWN_MASK; + smp_mb__before_atomic(); /* SHUTDOWN must be visible first */ +- set_bit(MPTCP_DATA_READY, &msk->flags); + set_bit(MPTCP_WORK_CLOSE_SUBFLOW, &msk->flags); + + mptcp_close_wake_up(sk); +@@ -3272,8 +3241,14 @@ unlock_fail: + + static __poll_t mptcp_check_readable(struct mptcp_sock *msk) + { +- return test_bit(MPTCP_DATA_READY, &msk->flags) ? EPOLLIN | EPOLLRDNORM : +- 0; ++ /* Concurrent splices from sk_receive_queue into receive_queue will ++ * always show at least one non-empty queue when checked in this order. ++ */ ++ if (skb_queue_empty_lockless(&((struct sock *)msk)->sk_receive_queue) && ++ skb_queue_empty_lockless(&msk->receive_queue)) ++ return 0; ++ ++ return EPOLLIN | EPOLLRDNORM; + } + + static __poll_t mptcp_check_writeable(struct mptcp_sock *msk) +@@ -3308,7 +3283,7 @@ static __poll_t mptcp_poll(struct file *file, struct socket *sock, + state = inet_sk_state_load(sk); + pr_debug("msk=%p state=%d flags=%lx", msk, state, msk->flags); + if (state == TCP_LISTEN) +- return mptcp_check_readable(msk); ++ return test_bit(MPTCP_DATA_READY, &msk->flags) ? EPOLLIN | EPOLLRDNORM : 0; + + if (state != TCP_SYN_SENT && state != TCP_SYN_RECV) { + mask |= mptcp_check_readable(msk); +diff --git a/net/nfc/af_nfc.c b/net/nfc/af_nfc.c +index 4a9e72073564a..581358dcbdf8d 100644 +--- a/net/nfc/af_nfc.c ++++ b/net/nfc/af_nfc.c +@@ -60,6 +60,9 @@ int nfc_proto_register(const struct nfc_protocol *nfc_proto) + proto_tab[nfc_proto->id] = nfc_proto; + write_unlock(&proto_tab_lock); + ++ if (rc) ++ proto_unregister(nfc_proto->proto); ++ + return rc; + } + EXPORT_SYMBOL(nfc_proto_register); +diff --git a/net/nfc/digital_core.c b/net/nfc/digital_core.c +index 5044c7db577eb..c8fc9fcbb0a72 100644 +--- a/net/nfc/digital_core.c ++++ b/net/nfc/digital_core.c +@@ -277,6 +277,7 @@ int digital_tg_configure_hw(struct nfc_digital_dev *ddev, int type, int param) + static int digital_tg_listen_mdaa(struct nfc_digital_dev *ddev, u8 rf_tech) + { + struct digital_tg_mdaa_params *params; ++ int rc; + + params = kzalloc(sizeof(*params), GFP_KERNEL); + if (!params) +@@ -291,8 +292,12 @@ static int digital_tg_listen_mdaa(struct nfc_digital_dev *ddev, u8 rf_tech) + get_random_bytes(params->nfcid2 + 2, NFC_NFCID2_MAXSIZE - 2); + params->sc = DIGITAL_SENSF_FELICA_SC; + +- return digital_send_cmd(ddev, DIGITAL_CMD_TG_LISTEN_MDAA, NULL, params, +- 500, digital_tg_recv_atr_req, NULL); ++ rc = digital_send_cmd(ddev, DIGITAL_CMD_TG_LISTEN_MDAA, NULL, params, ++ 500, digital_tg_recv_atr_req, NULL); ++ if (rc) ++ kfree(params); ++ ++ return rc; + } + + static int digital_tg_listen_md(struct nfc_digital_dev *ddev, u8 rf_tech) +diff --git a/net/nfc/digital_technology.c b/net/nfc/digital_technology.c +index 84d2345c75a3f..3adf4589852af 100644 +--- a/net/nfc/digital_technology.c ++++ b/net/nfc/digital_technology.c +@@ -465,8 +465,12 @@ static int digital_in_send_sdd_req(struct nfc_digital_dev *ddev, + skb_put_u8(skb, sel_cmd); + skb_put_u8(skb, DIGITAL_SDD_REQ_SEL_PAR); + +- return digital_in_send_cmd(ddev, skb, 30, digital_in_recv_sdd_res, +- target); ++ rc = digital_in_send_cmd(ddev, skb, 30, digital_in_recv_sdd_res, ++ target); ++ if (rc) ++ kfree_skb(skb); ++ ++ return rc; + } + + static void digital_in_recv_sens_res(struct nfc_digital_dev *ddev, void *arg, +diff --git a/net/sched/sch_mqprio.c b/net/sched/sch_mqprio.c +index 8766ab5b87880..5eb3b1b7ae5e7 100644 +--- a/net/sched/sch_mqprio.c ++++ b/net/sched/sch_mqprio.c +@@ -529,22 +529,28 @@ static int mqprio_dump_class_stats(struct Qdisc *sch, unsigned long cl, + for (i = tc.offset; i < tc.offset + tc.count; i++) { + struct netdev_queue *q = netdev_get_tx_queue(dev, i); + struct Qdisc *qdisc = rtnl_dereference(q->qdisc); +- struct gnet_stats_basic_cpu __percpu *cpu_bstats = NULL; +- struct gnet_stats_queue __percpu *cpu_qstats = NULL; + + spin_lock_bh(qdisc_lock(qdisc)); ++ + if (qdisc_is_percpu_stats(qdisc)) { +- cpu_bstats = qdisc->cpu_bstats; +- cpu_qstats = qdisc->cpu_qstats; ++ qlen = qdisc_qlen_sum(qdisc); ++ ++ __gnet_stats_copy_basic(NULL, &bstats, ++ qdisc->cpu_bstats, ++ &qdisc->bstats); ++ __gnet_stats_copy_queue(&qstats, ++ qdisc->cpu_qstats, ++ &qdisc->qstats, ++ qlen); ++ } else { ++ qlen += qdisc->q.qlen; ++ bstats.bytes += qdisc->bstats.bytes; ++ bstats.packets += qdisc->bstats.packets; ++ qstats.backlog += qdisc->qstats.backlog; ++ qstats.drops += qdisc->qstats.drops; ++ qstats.requeues += qdisc->qstats.requeues; ++ qstats.overlimits += qdisc->qstats.overlimits; + } +- +- qlen = qdisc_qlen_sum(qdisc); +- __gnet_stats_copy_basic(NULL, &sch->bstats, +- cpu_bstats, &qdisc->bstats); +- __gnet_stats_copy_queue(&sch->qstats, +- cpu_qstats, +- &qdisc->qstats, +- qlen); + spin_unlock_bh(qdisc_lock(qdisc)); + } + +diff --git a/net/sctp/sm_make_chunk.c b/net/sctp/sm_make_chunk.c +index b8fa8f1a72770..c7503fd649159 100644 +--- a/net/sctp/sm_make_chunk.c ++++ b/net/sctp/sm_make_chunk.c +@@ -3697,7 +3697,7 @@ struct sctp_chunk *sctp_make_strreset_req( + outlen = (sizeof(outreq) + stream_len) * out; + inlen = (sizeof(inreq) + stream_len) * in; + +- retval = sctp_make_reconf(asoc, outlen + inlen); ++ retval = sctp_make_reconf(asoc, SCTP_PAD4(outlen) + SCTP_PAD4(inlen)); + if (!retval) + return NULL; + +diff --git a/net/smc/smc_cdc.c b/net/smc/smc_cdc.c +index f23f558054a7c..99acd337ba90d 100644 +--- a/net/smc/smc_cdc.c ++++ b/net/smc/smc_cdc.c +@@ -150,9 +150,11 @@ static int smcr_cdc_get_slot_and_msg_send(struct smc_connection *conn) + + again: + link = conn->lnk; ++ if (!smc_wr_tx_link_hold(link)) ++ return -ENOLINK; + rc = smc_cdc_get_free_slot(conn, link, &wr_buf, NULL, &pend); + if (rc) +- return rc; ++ goto put_out; + + spin_lock_bh(&conn->send_lock); + if (link != conn->lnk) { +@@ -160,6 +162,7 @@ again: + spin_unlock_bh(&conn->send_lock); + smc_wr_tx_put_slot(link, + (struct smc_wr_tx_pend_priv *)pend); ++ smc_wr_tx_link_put(link); + if (again) + return -ENOLINK; + again = true; +@@ -167,6 +170,8 @@ again: + } + rc = smc_cdc_msg_send(conn, wr_buf, pend); + spin_unlock_bh(&conn->send_lock); ++put_out: ++ smc_wr_tx_link_put(link); + return rc; + } + +diff --git a/net/smc/smc_core.c b/net/smc/smc_core.c +index 116cfd6fac1ff..fa53b2146d8c0 100644 +--- a/net/smc/smc_core.c ++++ b/net/smc/smc_core.c +@@ -949,7 +949,7 @@ struct smc_link *smc_switch_conns(struct smc_link_group *lgr, + to_lnk = &lgr->lnk[i]; + break; + } +- if (!to_lnk) { ++ if (!to_lnk || !smc_wr_tx_link_hold(to_lnk)) { + smc_lgr_terminate_sched(lgr); + return NULL; + } +@@ -981,24 +981,26 @@ again: + read_unlock_bh(&lgr->conns_lock); + /* pre-fetch buffer outside of send_lock, might sleep */ + rc = smc_cdc_get_free_slot(conn, to_lnk, &wr_buf, NULL, &pend); +- if (rc) { +- smcr_link_down_cond_sched(to_lnk); +- return NULL; +- } ++ if (rc) ++ goto err_out; + /* avoid race with smcr_tx_sndbuf_nonempty() */ + spin_lock_bh(&conn->send_lock); + smc_switch_link_and_count(conn, to_lnk); + rc = smc_switch_cursor(smc, pend, wr_buf); + spin_unlock_bh(&conn->send_lock); + sock_put(&smc->sk); +- if (rc) { +- smcr_link_down_cond_sched(to_lnk); +- return NULL; +- } ++ if (rc) ++ goto err_out; + goto again; + } + read_unlock_bh(&lgr->conns_lock); ++ smc_wr_tx_link_put(to_lnk); + return to_lnk; ++ ++err_out: ++ smcr_link_down_cond_sched(to_lnk); ++ smc_wr_tx_link_put(to_lnk); ++ return NULL; + } + + static void smcr_buf_unuse(struct smc_buf_desc *rmb_desc, +diff --git a/net/smc/smc_llc.c b/net/smc/smc_llc.c +index 2e7560eba9812..72f4b72eb1753 100644 +--- a/net/smc/smc_llc.c ++++ b/net/smc/smc_llc.c +@@ -383,9 +383,11 @@ int smc_llc_send_confirm_link(struct smc_link *link, + struct smc_wr_buf *wr_buf; + int rc; + ++ if (!smc_wr_tx_link_hold(link)) ++ return -ENOLINK; + rc = smc_llc_add_pending_send(link, &wr_buf, &pend); + if (rc) +- return rc; ++ goto put_out; + confllc = (struct smc_llc_msg_confirm_link *)wr_buf; + memset(confllc, 0, sizeof(*confllc)); + confllc->hd.common.type = SMC_LLC_CONFIRM_LINK; +@@ -402,6 +404,8 @@ int smc_llc_send_confirm_link(struct smc_link *link, + confllc->max_links = SMC_LLC_ADD_LNK_MAX_LINKS; + /* send llc message */ + rc = smc_wr_tx_send(link, pend); ++put_out: ++ smc_wr_tx_link_put(link); + return rc; + } + +@@ -415,9 +419,11 @@ static int smc_llc_send_confirm_rkey(struct smc_link *send_link, + struct smc_link *link; + int i, rc, rtok_ix; + ++ if (!smc_wr_tx_link_hold(send_link)) ++ return -ENOLINK; + rc = smc_llc_add_pending_send(send_link, &wr_buf, &pend); + if (rc) +- return rc; ++ goto put_out; + rkeyllc = (struct smc_llc_msg_confirm_rkey *)wr_buf; + memset(rkeyllc, 0, sizeof(*rkeyllc)); + rkeyllc->hd.common.type = SMC_LLC_CONFIRM_RKEY; +@@ -444,6 +450,8 @@ static int smc_llc_send_confirm_rkey(struct smc_link *send_link, + (u64)sg_dma_address(rmb_desc->sgt[send_link->link_idx].sgl)); + /* send llc message */ + rc = smc_wr_tx_send(send_link, pend); ++put_out: ++ smc_wr_tx_link_put(send_link); + return rc; + } + +@@ -456,9 +464,11 @@ static int smc_llc_send_delete_rkey(struct smc_link *link, + struct smc_wr_buf *wr_buf; + int rc; + ++ if (!smc_wr_tx_link_hold(link)) ++ return -ENOLINK; + rc = smc_llc_add_pending_send(link, &wr_buf, &pend); + if (rc) +- return rc; ++ goto put_out; + rkeyllc = (struct smc_llc_msg_delete_rkey *)wr_buf; + memset(rkeyllc, 0, sizeof(*rkeyllc)); + rkeyllc->hd.common.type = SMC_LLC_DELETE_RKEY; +@@ -467,6 +477,8 @@ static int smc_llc_send_delete_rkey(struct smc_link *link, + rkeyllc->rkey[0] = htonl(rmb_desc->mr_rx[link->link_idx]->rkey); + /* send llc message */ + rc = smc_wr_tx_send(link, pend); ++put_out: ++ smc_wr_tx_link_put(link); + return rc; + } + +@@ -480,9 +492,11 @@ int smc_llc_send_add_link(struct smc_link *link, u8 mac[], u8 gid[], + struct smc_wr_buf *wr_buf; + int rc; + ++ if (!smc_wr_tx_link_hold(link)) ++ return -ENOLINK; + rc = smc_llc_add_pending_send(link, &wr_buf, &pend); + if (rc) +- return rc; ++ goto put_out; + addllc = (struct smc_llc_msg_add_link *)wr_buf; + + memset(addllc, 0, sizeof(*addllc)); +@@ -504,6 +518,8 @@ int smc_llc_send_add_link(struct smc_link *link, u8 mac[], u8 gid[], + } + /* send llc message */ + rc = smc_wr_tx_send(link, pend); ++put_out: ++ smc_wr_tx_link_put(link); + return rc; + } + +@@ -517,9 +533,11 @@ int smc_llc_send_delete_link(struct smc_link *link, u8 link_del_id, + struct smc_wr_buf *wr_buf; + int rc; + ++ if (!smc_wr_tx_link_hold(link)) ++ return -ENOLINK; + rc = smc_llc_add_pending_send(link, &wr_buf, &pend); + if (rc) +- return rc; ++ goto put_out; + delllc = (struct smc_llc_msg_del_link *)wr_buf; + + memset(delllc, 0, sizeof(*delllc)); +@@ -536,6 +554,8 @@ int smc_llc_send_delete_link(struct smc_link *link, u8 link_del_id, + delllc->reason = htonl(reason); + /* send llc message */ + rc = smc_wr_tx_send(link, pend); ++put_out: ++ smc_wr_tx_link_put(link); + return rc; + } + +@@ -547,9 +567,11 @@ static int smc_llc_send_test_link(struct smc_link *link, u8 user_data[16]) + struct smc_wr_buf *wr_buf; + int rc; + ++ if (!smc_wr_tx_link_hold(link)) ++ return -ENOLINK; + rc = smc_llc_add_pending_send(link, &wr_buf, &pend); + if (rc) +- return rc; ++ goto put_out; + testllc = (struct smc_llc_msg_test_link *)wr_buf; + memset(testllc, 0, sizeof(*testllc)); + testllc->hd.common.type = SMC_LLC_TEST_LINK; +@@ -557,6 +579,8 @@ static int smc_llc_send_test_link(struct smc_link *link, u8 user_data[16]) + memcpy(testllc->user_data, user_data, sizeof(testllc->user_data)); + /* send llc message */ + rc = smc_wr_tx_send(link, pend); ++put_out: ++ smc_wr_tx_link_put(link); + return rc; + } + +@@ -567,13 +591,16 @@ static int smc_llc_send_message(struct smc_link *link, void *llcbuf) + struct smc_wr_buf *wr_buf; + int rc; + +- if (!smc_link_usable(link)) ++ if (!smc_wr_tx_link_hold(link)) + return -ENOLINK; + rc = smc_llc_add_pending_send(link, &wr_buf, &pend); + if (rc) +- return rc; ++ goto put_out; + memcpy(wr_buf, llcbuf, sizeof(union smc_llc_msg)); +- return smc_wr_tx_send(link, pend); ++ rc = smc_wr_tx_send(link, pend); ++put_out: ++ smc_wr_tx_link_put(link); ++ return rc; + } + + /* schedule an llc send on link, may wait for buffers, +@@ -586,13 +613,16 @@ static int smc_llc_send_message_wait(struct smc_link *link, void *llcbuf) + struct smc_wr_buf *wr_buf; + int rc; + +- if (!smc_link_usable(link)) ++ if (!smc_wr_tx_link_hold(link)) + return -ENOLINK; + rc = smc_llc_add_pending_send(link, &wr_buf, &pend); + if (rc) +- return rc; ++ goto put_out; + memcpy(wr_buf, llcbuf, sizeof(union smc_llc_msg)); +- return smc_wr_tx_send_wait(link, pend, SMC_LLC_WAIT_TIME); ++ rc = smc_wr_tx_send_wait(link, pend, SMC_LLC_WAIT_TIME); ++put_out: ++ smc_wr_tx_link_put(link); ++ return rc; + } + + /********************************* receive ***********************************/ +@@ -672,9 +702,11 @@ static int smc_llc_add_link_cont(struct smc_link *link, + struct smc_buf_desc *rmb; + u8 n; + ++ if (!smc_wr_tx_link_hold(link)) ++ return -ENOLINK; + rc = smc_llc_add_pending_send(link, &wr_buf, &pend); + if (rc) +- return rc; ++ goto put_out; + addc_llc = (struct smc_llc_msg_add_link_cont *)wr_buf; + memset(addc_llc, 0, sizeof(*addc_llc)); + +@@ -706,7 +738,10 @@ static int smc_llc_add_link_cont(struct smc_link *link, + addc_llc->hd.length = sizeof(struct smc_llc_msg_add_link_cont); + if (lgr->role == SMC_CLNT) + addc_llc->hd.flags |= SMC_LLC_FLAG_RESP; +- return smc_wr_tx_send(link, pend); ++ rc = smc_wr_tx_send(link, pend); ++put_out: ++ smc_wr_tx_link_put(link); ++ return rc; + } + + static int smc_llc_cli_rkey_exchange(struct smc_link *link, +diff --git a/net/smc/smc_tx.c b/net/smc/smc_tx.c +index c79361dfcdfb9..738a4a99c8279 100644 +--- a/net/smc/smc_tx.c ++++ b/net/smc/smc_tx.c +@@ -496,7 +496,7 @@ static int smc_tx_rdma_writes(struct smc_connection *conn, + /* Wakeup sndbuf consumers from any context (IRQ or process) + * since there is more data to transmit; usable snd_wnd as max transmit + */ +-static int _smcr_tx_sndbuf_nonempty(struct smc_connection *conn) ++static int smcr_tx_sndbuf_nonempty(struct smc_connection *conn) + { + struct smc_cdc_producer_flags *pflags = &conn->local_tx_ctrl.prod_flags; + struct smc_link *link = conn->lnk; +@@ -505,8 +505,11 @@ static int _smcr_tx_sndbuf_nonempty(struct smc_connection *conn) + struct smc_wr_buf *wr_buf; + int rc; + ++ if (!link || !smc_wr_tx_link_hold(link)) ++ return -ENOLINK; + rc = smc_cdc_get_free_slot(conn, link, &wr_buf, &wr_rdma_buf, &pend); + if (rc < 0) { ++ smc_wr_tx_link_put(link); + if (rc == -EBUSY) { + struct smc_sock *smc = + container_of(conn, struct smc_sock, conn); +@@ -547,22 +550,7 @@ static int _smcr_tx_sndbuf_nonempty(struct smc_connection *conn) + + out_unlock: + spin_unlock_bh(&conn->send_lock); +- return rc; +-} +- +-static int smcr_tx_sndbuf_nonempty(struct smc_connection *conn) +-{ +- struct smc_link *link = conn->lnk; +- int rc = -ENOLINK; +- +- if (!link) +- return rc; +- +- atomic_inc(&link->wr_tx_refcnt); +- if (smc_link_usable(link)) +- rc = _smcr_tx_sndbuf_nonempty(conn); +- if (atomic_dec_and_test(&link->wr_tx_refcnt)) +- wake_up_all(&link->wr_tx_wait); ++ smc_wr_tx_link_put(link); + return rc; + } + +diff --git a/net/smc/smc_wr.h b/net/smc/smc_wr.h +index 423b8709f1c9e..2bc626f230a56 100644 +--- a/net/smc/smc_wr.h ++++ b/net/smc/smc_wr.h +@@ -60,6 +60,20 @@ static inline void smc_wr_tx_set_wr_id(atomic_long_t *wr_tx_id, long val) + atomic_long_set(wr_tx_id, val); + } + ++static inline bool smc_wr_tx_link_hold(struct smc_link *link) ++{ ++ if (!smc_link_usable(link)) ++ return false; ++ atomic_inc(&link->wr_tx_refcnt); ++ return true; ++} ++ ++static inline void smc_wr_tx_link_put(struct smc_link *link) ++{ ++ if (atomic_dec_and_test(&link->wr_tx_refcnt)) ++ wake_up_all(&link->wr_tx_wait); ++} ++ + static inline void smc_wr_wakeup_tx_wait(struct smc_link *lnk) + { + wake_up_all(&lnk->wr_tx_wait); +diff --git a/scripts/recordmcount.pl b/scripts/recordmcount.pl +index 8f6b13ae46bfc..7d631aaa0ae11 100755 +--- a/scripts/recordmcount.pl ++++ b/scripts/recordmcount.pl +@@ -189,7 +189,7 @@ if ($arch =~ /(x86(_64)?)|(i386)/) { + $local_regex = "^[0-9a-fA-F]+\\s+t\\s+(\\S+)"; + $weak_regex = "^[0-9a-fA-F]+\\s+([wW])\\s+(\\S+)"; + $section_regex = "Disassembly of section\\s+(\\S+):"; +-$function_regex = "^([0-9a-fA-F]+)\\s+<(.*?)>:"; ++$function_regex = "^([0-9a-fA-F]+)\\s+<([^^]*?)>:"; + $mcount_regex = "^\\s*([0-9a-fA-F]+):.*\\s(mcount|__fentry__)\$"; + $section_type = '@progbits'; + $mcount_adjust = 0; +diff --git a/sound/core/pcm_compat.c b/sound/core/pcm_compat.c +index a59de24695ec9..dfe5a64e19d2e 100644 +--- a/sound/core/pcm_compat.c ++++ b/sound/core/pcm_compat.c +@@ -468,6 +468,76 @@ static int snd_pcm_ioctl_sync_ptr_x32(struct snd_pcm_substream *substream, + } + #endif /* CONFIG_X86_X32 */ + ++#ifdef __BIG_ENDIAN ++typedef char __pad_before_u32[4]; ++typedef char __pad_after_u32[0]; ++#else ++typedef char __pad_before_u32[0]; ++typedef char __pad_after_u32[4]; ++#endif ++ ++/* PCM 2.0.15 API definition had a bug in mmap control; it puts the avail_min ++ * at the wrong offset due to a typo in padding type. ++ * The bug hits only 32bit. ++ * A workaround for incorrect read/write is needed only in 32bit compat mode. ++ */ ++struct __snd_pcm_mmap_control64_buggy { ++ __pad_before_u32 __pad1; ++ __u32 appl_ptr; ++ __pad_before_u32 __pad2; /* SiC! here is the bug */ ++ __pad_before_u32 __pad3; ++ __u32 avail_min; ++ __pad_after_uframe __pad4; ++}; ++ ++static int snd_pcm_ioctl_sync_ptr_buggy(struct snd_pcm_substream *substream, ++ struct snd_pcm_sync_ptr __user *_sync_ptr) ++{ ++ struct snd_pcm_runtime *runtime = substream->runtime; ++ struct snd_pcm_sync_ptr sync_ptr; ++ struct __snd_pcm_mmap_control64_buggy *sync_cp; ++ volatile struct snd_pcm_mmap_status *status; ++ volatile struct snd_pcm_mmap_control *control; ++ int err; ++ ++ memset(&sync_ptr, 0, sizeof(sync_ptr)); ++ sync_cp = (struct __snd_pcm_mmap_control64_buggy *)&sync_ptr.c.control; ++ if (get_user(sync_ptr.flags, (unsigned __user *)&(_sync_ptr->flags))) ++ return -EFAULT; ++ if (copy_from_user(sync_cp, &(_sync_ptr->c.control), sizeof(*sync_cp))) ++ return -EFAULT; ++ status = runtime->status; ++ control = runtime->control; ++ if (sync_ptr.flags & SNDRV_PCM_SYNC_PTR_HWSYNC) { ++ err = snd_pcm_hwsync(substream); ++ if (err < 0) ++ return err; ++ } ++ snd_pcm_stream_lock_irq(substream); ++ if (!(sync_ptr.flags & SNDRV_PCM_SYNC_PTR_APPL)) { ++ err = pcm_lib_apply_appl_ptr(substream, sync_cp->appl_ptr); ++ if (err < 0) { ++ snd_pcm_stream_unlock_irq(substream); ++ return err; ++ } ++ } else { ++ sync_cp->appl_ptr = control->appl_ptr; ++ } ++ if (!(sync_ptr.flags & SNDRV_PCM_SYNC_PTR_AVAIL_MIN)) ++ control->avail_min = sync_cp->avail_min; ++ else ++ sync_cp->avail_min = control->avail_min; ++ sync_ptr.s.status.state = status->state; ++ sync_ptr.s.status.hw_ptr = status->hw_ptr; ++ sync_ptr.s.status.tstamp = status->tstamp; ++ sync_ptr.s.status.suspended_state = status->suspended_state; ++ sync_ptr.s.status.audio_tstamp = status->audio_tstamp; ++ snd_pcm_stream_unlock_irq(substream); ++ if (copy_to_user(_sync_ptr, &sync_ptr, sizeof(sync_ptr))) ++ return -EFAULT; ++ return 0; ++} ++ + /* + */ + enum { +@@ -537,7 +607,7 @@ static long snd_pcm_ioctl_compat(struct file *file, unsigned int cmd, unsigned l + if (in_x32_syscall()) + return snd_pcm_ioctl_sync_ptr_x32(substream, argp); + #endif /* CONFIG_X86_X32 */ +- return snd_pcm_common_ioctl(file, substream, cmd, argp); ++ return snd_pcm_ioctl_sync_ptr_buggy(substream, argp); + case SNDRV_PCM_IOCTL_HW_REFINE32: + return snd_pcm_ioctl_hw_params_compat(substream, 1, argp); + case SNDRV_PCM_IOCTL_HW_PARAMS32: +diff --git a/sound/core/seq_device.c b/sound/core/seq_device.c +index 382275c5b1937..7f3fd8eb016fe 100644 +--- a/sound/core/seq_device.c ++++ b/sound/core/seq_device.c +@@ -156,6 +156,8 @@ static int snd_seq_device_dev_free(struct snd_device *device) + struct snd_seq_device *dev = device->device_data; + + cancel_autoload_drivers(); ++ if (dev->private_free) ++ dev->private_free(dev); + put_device(&dev->dev); + return 0; + } +@@ -183,11 +185,7 @@ static int snd_seq_device_dev_disconnect(struct snd_device *device) + + static void snd_seq_dev_release(struct device *dev) + { +- struct snd_seq_device *sdev = to_seq_dev(dev); +- +- if (sdev->private_free) +- sdev->private_free(sdev); +- kfree(sdev); ++ kfree(to_seq_dev(dev)); + } + + /* +diff --git a/sound/pci/hda/patch_realtek.c b/sound/pci/hda/patch_realtek.c +index 0b9230a274b0a..8e6ff50f0f94f 100644 +--- a/sound/pci/hda/patch_realtek.c ++++ b/sound/pci/hda/patch_realtek.c +@@ -527,6 +527,8 @@ static void alc_shutup_pins(struct hda_codec *codec) + struct alc_spec *spec = codec->spec; + + switch (codec->core.vendor_id) { ++ case 0x10ec0236: ++ case 0x10ec0256: + case 0x10ec0283: + case 0x10ec0286: + case 0x10ec0288: +@@ -2549,7 +2551,8 @@ static const struct snd_pci_quirk alc882_fixup_tbl[] = { + SND_PCI_QUIRK(0x1558, 0x67e1, "Clevo PB71[DE][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS), + SND_PCI_QUIRK(0x1558, 0x67e5, "Clevo PC70D[PRS](?:-D|-G)?", ALC1220_FIXUP_CLEVO_PB51ED_PINS), + SND_PCI_QUIRK(0x1558, 0x70d1, "Clevo PC70[ER][CDF]", ALC1220_FIXUP_CLEVO_PB51ED_PINS), +- SND_PCI_QUIRK(0x1558, 0x7714, "Clevo X170", ALC1220_FIXUP_CLEVO_PB51ED_PINS), ++ SND_PCI_QUIRK(0x1558, 0x7714, "Clevo X170SM", ALC1220_FIXUP_CLEVO_PB51ED_PINS), ++ SND_PCI_QUIRK(0x1558, 0x7715, "Clevo X170KM-G", ALC1220_FIXUP_CLEVO_PB51ED), + SND_PCI_QUIRK(0x1558, 0x9501, "Clevo P950HR", ALC1220_FIXUP_CLEVO_P950), + SND_PCI_QUIRK(0x1558, 0x9506, "Clevo P955HQ", ALC1220_FIXUP_CLEVO_P950), + SND_PCI_QUIRK(0x1558, 0x950a, "Clevo P955H[PR]", ALC1220_FIXUP_CLEVO_P950), +@@ -3540,7 +3543,8 @@ static void alc256_shutup(struct hda_codec *codec) + /* If disable 3k pulldown control for alc257, the Mic detection will not work correctly + * when booting with headset plugged. So skip setting it for the codec alc257 + */ +- if (codec->core.vendor_id != 0x10ec0257) ++ if (spec->codec_variant != ALC269_TYPE_ALC257 && ++ spec->codec_variant != ALC269_TYPE_ALC256) + alc_update_coef_idx(codec, 0x46, 0, 3 << 12); + + if (!spec->no_shutup_pins) +@@ -6462,6 +6466,24 @@ static void alc287_fixup_legion_15imhg05_speakers(struct hda_codec *codec, + /* for alc285_fixup_ideapad_s740_coef() */ + #include "ideapad_s740_helper.c" + ++static void alc256_fixup_tongfang_reset_persistent_settings(struct hda_codec *codec, ++ const struct hda_fixup *fix, ++ int action) ++{ ++ /* ++ * A certain other OS sets these coeffs to different values. On at least one TongFang ++ * barebone these settings might survive even a cold reboot. So to restore a clean slate the ++ * values are explicitly reset to default here. Without this, the external microphone is ++ * always in a plugged-in state, while the internal microphone is always in an unplugged ++ * state, breaking the ability to use the internal microphone. ++ */ ++ alc_write_coef_idx(codec, 0x24, 0x0000); ++ alc_write_coef_idx(codec, 0x26, 0x0000); ++ alc_write_coef_idx(codec, 0x29, 0x3000); ++ alc_write_coef_idx(codec, 0x37, 0xfe05); ++ alc_write_coef_idx(codec, 0x45, 0x5089); ++} ++ + enum { + ALC269_FIXUP_GPIO2, + ALC269_FIXUP_SONY_VAIO, +@@ -6676,7 +6698,8 @@ enum { + ALC287_FIXUP_LEGION_15IMHG05_SPEAKERS, + ALC287_FIXUP_LEGION_15IMHG05_AUTOMUTE, + ALC287_FIXUP_YOGA7_14ITL_SPEAKERS, +- ALC287_FIXUP_13S_GEN2_SPEAKERS ++ ALC287_FIXUP_13S_GEN2_SPEAKERS, ++ ALC256_FIXUP_TONGFANG_RESET_PERSISTENT_SETTINGS, + }; + + static const struct hda_fixup alc269_fixups[] = { +@@ -8357,7 +8380,7 @@ static const struct hda_fixup alc269_fixups[] = { + .v.verbs = (const struct hda_verb[]) { + { 0x20, AC_VERB_SET_COEF_INDEX, 0x24 }, + { 0x20, AC_VERB_SET_PROC_COEF, 0x41 }, +- { 0x20, AC_VERB_SET_PROC_COEF, 0xb020 }, ++ { 0x20, AC_VERB_SET_COEF_INDEX, 0x26 }, + { 0x20, AC_VERB_SET_PROC_COEF, 0x2 }, + { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, + { 0x20, AC_VERB_SET_PROC_COEF, 0x0 }, +@@ -8374,6 +8397,10 @@ static const struct hda_fixup alc269_fixups[] = { + .chained = true, + .chain_id = ALC269_FIXUP_HEADSET_MODE, + }, ++ [ALC256_FIXUP_TONGFANG_RESET_PERSISTENT_SETTINGS] = { ++ .type = HDA_FIXUP_FUNC, ++ .v.func = alc256_fixup_tongfang_reset_persistent_settings, ++ }, + }; + + static const struct snd_pci_quirk alc269_fixup_tbl[] = { +@@ -8465,6 +8492,9 @@ static const struct snd_pci_quirk alc269_fixup_tbl[] = { + SND_PCI_QUIRK(0x1028, 0x0a30, "Dell", ALC236_FIXUP_DELL_AIO_HEADSET_MIC), + SND_PCI_QUIRK(0x1028, 0x0a58, "Dell", ALC255_FIXUP_DELL_HEADSET_MIC), + SND_PCI_QUIRK(0x1028, 0x0a61, "Dell XPS 15 9510", ALC289_FIXUP_DUAL_SPK), ++ SND_PCI_QUIRK(0x1028, 0x0a62, "Dell Precision 5560", ALC289_FIXUP_DUAL_SPK), ++ SND_PCI_QUIRK(0x1028, 0x0a9d, "Dell Latitude 5430", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE), ++ SND_PCI_QUIRK(0x1028, 0x0a9e, "Dell Latitude 5430", ALC269_FIXUP_DELL4_MIC_NO_PRESENCE), + SND_PCI_QUIRK(0x1028, 0x164a, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE), + SND_PCI_QUIRK(0x1028, 0x164b, "Dell", ALC293_FIXUP_DELL1_MIC_NO_PRESENCE), + SND_PCI_QUIRK(0x103c, 0x1586, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC2), +@@ -8802,6 +8832,7 @@ static const struct snd_pci_quirk alc269_fixup_tbl[] = { + SND_PCI_QUIRK(0x1b7d, 0xa831, "Ordissimo EVE2 ", ALC269VB_FIXUP_ORDISSIMO_EVE2), /* Also known as Malata PC-B1303 */ + SND_PCI_QUIRK(0x1c06, 0x2013, "Lemote A1802", ALC269_FIXUP_LEMOTE_A1802), + SND_PCI_QUIRK(0x1c06, 0x2015, "Lemote A190X", ALC269_FIXUP_LEMOTE_A190X), ++ SND_PCI_QUIRK(0x1d05, 0x1132, "TongFang PHxTxX1", ALC256_FIXUP_TONGFANG_RESET_PERSISTENT_SETTINGS), + SND_PCI_QUIRK(0x1d72, 0x1602, "RedmiBook", ALC255_FIXUP_XIAOMI_HEADSET_MIC), + SND_PCI_QUIRK(0x1d72, 0x1701, "XiaomiNotebook Pro", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE), + SND_PCI_QUIRK(0x1d72, 0x1901, "RedmiBook 14", ALC256_FIXUP_ASUS_HEADSET_MIC), +@@ -10179,6 +10210,9 @@ enum { + ALC671_FIXUP_HP_HEADSET_MIC2, + ALC662_FIXUP_ACER_X2660G_HEADSET_MODE, + ALC662_FIXUP_ACER_NITRO_HEADSET_MODE, ++ ALC668_FIXUP_ASUS_NO_HEADSET_MIC, ++ ALC668_FIXUP_HEADSET_MIC, ++ ALC668_FIXUP_MIC_DET_COEF, + }; + + static const struct hda_fixup alc662_fixups[] = { +@@ -10562,6 +10596,29 @@ static const struct hda_fixup alc662_fixups[] = { + .chained = true, + .chain_id = ALC662_FIXUP_USI_FUNC + }, ++ [ALC668_FIXUP_ASUS_NO_HEADSET_MIC] = { ++ .type = HDA_FIXUP_PINS, ++ .v.pins = (const struct hda_pintbl[]) { ++ { 0x1b, 0x04a1112c }, ++ { } ++ }, ++ .chained = true, ++ .chain_id = ALC668_FIXUP_HEADSET_MIC ++ }, ++ [ALC668_FIXUP_HEADSET_MIC] = { ++ .type = HDA_FIXUP_FUNC, ++ .v.func = alc269_fixup_headset_mic, ++ .chained = true, ++ .chain_id = ALC668_FIXUP_MIC_DET_COEF ++ }, ++ [ALC668_FIXUP_MIC_DET_COEF] = { ++ .type = HDA_FIXUP_VERBS, ++ .v.verbs = (const struct hda_verb[]) { ++ { 0x20, AC_VERB_SET_COEF_INDEX, 0x15 }, ++ { 0x20, AC_VERB_SET_PROC_COEF, 0x0d60 }, ++ {} ++ }, ++ }, + }; + + static const struct snd_pci_quirk alc662_fixup_tbl[] = { +@@ -10597,6 +10654,7 @@ static const struct snd_pci_quirk alc662_fixup_tbl[] = { + SND_PCI_QUIRK(0x1043, 0x15a7, "ASUS UX51VZH", ALC662_FIXUP_BASS_16), + SND_PCI_QUIRK(0x1043, 0x177d, "ASUS N551", ALC668_FIXUP_ASUS_Nx51), + SND_PCI_QUIRK(0x1043, 0x17bd, "ASUS N751", ALC668_FIXUP_ASUS_Nx51), ++ SND_PCI_QUIRK(0x1043, 0x185d, "ASUS G551JW", ALC668_FIXUP_ASUS_NO_HEADSET_MIC), + SND_PCI_QUIRK(0x1043, 0x1963, "ASUS X71SL", ALC662_FIXUP_ASUS_MODE8), + SND_PCI_QUIRK(0x1043, 0x1b73, "ASUS N55SF", ALC662_FIXUP_BASS_16), + SND_PCI_QUIRK(0x1043, 0x1bf3, "ASUS N76VZ", ALC662_FIXUP_BASS_MODE4_CHMAP), +diff --git a/sound/usb/mixer_scarlett_gen2.c b/sound/usb/mixer_scarlett_gen2.c +index 3d5848d5481be..53ebabf424722 100644 +--- a/sound/usb/mixer_scarlett_gen2.c ++++ b/sound/usb/mixer_scarlett_gen2.c +@@ -2450,6 +2450,8 @@ static int scarlett2_update_monitor_other(struct usb_mixer_interface *mixer) + err = scarlett2_usb_get_config(mixer, + SCARLETT2_CONFIG_TALKBACK_MAP, + 1, &bitmap); ++ if (err < 0) ++ return err; + for (i = 0; i < num_mixes; i++, bitmap >>= 1) + private->talkback_map[i] = bitmap & 1; + } +diff --git a/sound/usb/quirks-table.h b/sound/usb/quirks-table.h +index 19bb499c17daa..147b831e1a82d 100644 +--- a/sound/usb/quirks-table.h ++++ b/sound/usb/quirks-table.h +@@ -77,6 +77,48 @@ + /* E-Mu 0204 USB */ + { USB_DEVICE_VENDOR_SPEC(0x041e, 0x3f19) }, + ++/* ++ * Creative Technology, Ltd Live! Cam Sync HD [VF0770] ++ * The device advertises 8 formats, but only a rate of 48kHz is honored by the ++ * hardware and 24 bits give chopped audio, so only report the one working ++ * combination. ++ */ ++{ ++ USB_DEVICE(0x041e, 0x4095), ++ .driver_info = (unsigned long) &(const struct snd_usb_audio_quirk) { ++ .ifnum = QUIRK_ANY_INTERFACE, ++ .type = QUIRK_COMPOSITE, ++ .data = &(const struct snd_usb_audio_quirk[]) { ++ { ++ .ifnum = 2, ++ .type = QUIRK_AUDIO_STANDARD_MIXER, ++ }, ++ { ++ .ifnum = 3, ++ .type = QUIRK_AUDIO_FIXED_ENDPOINT, ++ .data = &(const struct audioformat) { ++ .formats = SNDRV_PCM_FMTBIT_S16_LE, ++ .channels = 2, ++ .fmt_bits = 16, ++ .iface = 3, ++ .altsetting = 4, ++ .altset_idx = 4, ++ .endpoint = 0x82, ++ .ep_attr = 0x05, ++ .rates = SNDRV_PCM_RATE_48000, ++ .rate_min = 48000, ++ .rate_max = 48000, ++ .nr_rates = 1, ++ .rate_table = (unsigned int[]) { 48000 }, ++ }, ++ }, ++ { ++ .ifnum = -1 ++ }, ++ }, ++ }, ++}, ++ + /* + * HP Wireless Audio + * When not ignored, causes instability issues for some users, forcing them to