commit: 26fef560e07e6b1481f3dfc07e97794ca542aec1 Author: Mike Pagano <mpagano <AT> gentoo <DOT> org> AuthorDate: Wed Jan 27 11:14:44 2021 +0000 Commit: Mike Pagano <mpagano <AT> gentoo <DOT> org> CommitDate: Wed Jan 27 11:14:44 2021 +0000 URL: https://gitweb.gentoo.org/proj/linux-patches.git/commit/?id=26fef560
Linux patch 4.19.171 Signed-off-by: Mike Pagano <mpagano <AT> gentoo.org> 0000_README | 4 + 1170_linux-4.19.171.patch | 1370 +++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 1374 insertions(+) diff --git a/0000_README b/0000_README index a166692..1c1a372 100644 --- a/0000_README +++ b/0000_README @@ -719,6 +719,10 @@ Patch: 1169_linux-4.19.170.patch From: https://www.kernel.org Desc: Linux 4.19.170 +Patch: 1170_linux-4.19.171.patch +From: https://www.kernel.org +Desc: Linux 4.19.171 + 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/1170_linux-4.19.171.patch b/1170_linux-4.19.171.patch new file mode 100644 index 0000000..6c726b2 --- /dev/null +++ b/1170_linux-4.19.171.patch @@ -0,0 +1,1370 @@ +diff --git a/Makefile b/Makefile +index 7f56c62d31e8a..335b015c5c9ba 100644 +--- a/Makefile ++++ b/Makefile +@@ -1,7 +1,7 @@ + # SPDX-License-Identifier: GPL-2.0 + VERSION = 4 + PATCHLEVEL = 19 +-SUBLEVEL = 170 ++SUBLEVEL = 171 + EXTRAVERSION = + NAME = "People's Front" + +diff --git a/arch/arm/xen/enlighten.c b/arch/arm/xen/enlighten.c +index 07060e5b58641..8aa901e20ca8e 100644 +--- a/arch/arm/xen/enlighten.c ++++ b/arch/arm/xen/enlighten.c +@@ -405,7 +405,7 @@ static int __init xen_guest_init(void) + } + gnttab_init(); + if (!xen_initial_domain()) +- xenbus_probe(NULL); ++ xenbus_probe(); + + /* + * Making sure board specific code will not set up ops for +diff --git a/arch/riscv/kernel/time.c b/arch/riscv/kernel/time.c +index 1911c8f6b8a69..15f4ab40e2221 100644 +--- a/arch/riscv/kernel/time.c ++++ b/arch/riscv/kernel/time.c +@@ -12,6 +12,7 @@ + * GNU General Public License for more details. + */ + ++#include <linux/of_clk.h> + #include <linux/clocksource.h> + #include <linux/delay.h> + #include <asm/sbi.h> +@@ -29,5 +30,7 @@ void __init time_init(void) + riscv_timebase = prop; + + lpj_fine = riscv_timebase / HZ; ++ ++ of_clk_init(NULL); + timer_probe(); + } +diff --git a/arch/sh/drivers/dma/Kconfig b/arch/sh/drivers/dma/Kconfig +index d0de378beefe5..7d54f284ce10f 100644 +--- a/arch/sh/drivers/dma/Kconfig ++++ b/arch/sh/drivers/dma/Kconfig +@@ -63,8 +63,7 @@ config PVR2_DMA + + config G2_DMA + tristate "G2 Bus DMA support" +- depends on SH_DREAMCAST +- select SH_DMA_API ++ depends on SH_DREAMCAST && SH_DMA_API + help + This enables support for the DMA controller for the Dreamcast's + G2 bus. Drivers that want this will generally enable this on +diff --git a/drivers/acpi/scan.c b/drivers/acpi/scan.c +index de9dc041d703e..d614cb72041e1 100644 +--- a/drivers/acpi/scan.c ++++ b/drivers/acpi/scan.c +@@ -586,6 +586,8 @@ static int acpi_get_device_data(acpi_handle handle, struct acpi_device **device, + if (!device) + return -EINVAL; + ++ *device = NULL; ++ + status = acpi_get_data_full(handle, acpi_scan_drop_device, + (void **)device, callback); + if (ACPI_FAILURE(status) || !*device) { +diff --git a/drivers/base/core.c b/drivers/base/core.c +index 4818aaddd712e..f7f601858f10d 100644 +--- a/drivers/base/core.c ++++ b/drivers/base/core.c +@@ -93,6 +93,16 @@ void device_links_read_unlock(int not_used) + } + #endif /* !CONFIG_SRCU */ + ++static bool device_is_ancestor(struct device *dev, struct device *target) ++{ ++ while (target->parent) { ++ target = target->parent; ++ if (dev == target) ++ return true; ++ } ++ return false; ++} ++ + /** + * device_is_dependent - Check if one device depends on another one + * @dev: Device to check dependencies for. +@@ -106,7 +116,12 @@ static int device_is_dependent(struct device *dev, void *target) + struct device_link *link; + int ret; + +- if (dev == target) ++ /* ++ * The "ancestors" check is needed to catch the case when the target ++ * device has not been completely initialized yet and it is still ++ * missing from the list of children of its parent device. ++ */ ++ if (dev == target || device_is_ancestor(dev, target)) + return 1; + + ret = device_for_each_child(dev, target, device_is_dependent); +diff --git a/drivers/clk/tegra/clk-tegra30.c b/drivers/clk/tegra/clk-tegra30.c +index e0aaecd98fbff..678019f86bc7a 100644 +--- a/drivers/clk/tegra/clk-tegra30.c ++++ b/drivers/clk/tegra/clk-tegra30.c +@@ -1274,6 +1274,8 @@ static struct tegra_clk_init_table init_table[] __initdata = { + { TEGRA30_CLK_I2S3_SYNC, TEGRA30_CLK_CLK_MAX, 24000000, 0 }, + { TEGRA30_CLK_I2S4_SYNC, TEGRA30_CLK_CLK_MAX, 24000000, 0 }, + { TEGRA30_CLK_VIMCLK_SYNC, TEGRA30_CLK_CLK_MAX, 24000000, 0 }, ++ { TEGRA30_CLK_HDA, TEGRA30_CLK_PLL_P, 102000000, 0 }, ++ { TEGRA30_CLK_HDA2CODEC_2X, TEGRA30_CLK_PLL_P, 48000000, 0 }, + /* must be the last entry */ + { TEGRA30_CLK_CLK_MAX, TEGRA30_CLK_CLK_MAX, 0, 0 }, + }; +diff --git a/drivers/gpu/drm/drm_atomic_helper.c b/drivers/gpu/drm/drm_atomic_helper.c +index d24a15484e31c..6060b69fa6182 100644 +--- a/drivers/gpu/drm/drm_atomic_helper.c ++++ b/drivers/gpu/drm/drm_atomic_helper.c +@@ -2938,7 +2938,7 @@ int drm_atomic_helper_set_config(struct drm_mode_set *set, + + ret = handle_conflicting_encoders(state, true); + if (ret) +- return ret; ++ goto fail; + + ret = drm_atomic_commit(state); + +diff --git a/drivers/gpu/drm/nouveau/dispnv50/disp.c b/drivers/gpu/drm/nouveau/dispnv50/disp.c +index 1bb0a9f6fa730..fbe156302ee86 100644 +--- a/drivers/gpu/drm/nouveau/dispnv50/disp.c ++++ b/drivers/gpu/drm/nouveau/dispnv50/disp.c +@@ -131,7 +131,7 @@ nv50_dmac_destroy(struct nv50_dmac *dmac) + + int + nv50_dmac_create(struct nvif_device *device, struct nvif_object *disp, +- const s32 *oclass, u8 head, void *data, u32 size, u64 syncbuf, ++ const s32 *oclass, u8 head, void *data, u32 size, s64 syncbuf, + struct nv50_dmac *dmac) + { + struct nouveau_cli *cli = (void *)device->object.client; +@@ -166,7 +166,7 @@ nv50_dmac_create(struct nvif_device *device, struct nvif_object *disp, + if (ret) + return ret; + +- if (!syncbuf) ++ if (syncbuf < 0) + return 0; + + ret = nvif_object_init(&dmac->base.user, 0xf0000000, NV_DMA_IN_MEMORY, +diff --git a/drivers/gpu/drm/nouveau/dispnv50/disp.h b/drivers/gpu/drm/nouveau/dispnv50/disp.h +index 66c125a6b0b3c..55205d23360c8 100644 +--- a/drivers/gpu/drm/nouveau/dispnv50/disp.h ++++ b/drivers/gpu/drm/nouveau/dispnv50/disp.h +@@ -68,7 +68,7 @@ struct nv50_dmac { + + int nv50_dmac_create(struct nvif_device *device, struct nvif_object *disp, + const s32 *oclass, u8 head, void *data, u32 size, +- u64 syncbuf, struct nv50_dmac *dmac); ++ s64 syncbuf, struct nv50_dmac *dmac); + void nv50_dmac_destroy(struct nv50_dmac *); + + u32 *evo_wait(struct nv50_dmac *, int nr); +diff --git a/drivers/gpu/drm/nouveau/dispnv50/wimmc37b.c b/drivers/gpu/drm/nouveau/dispnv50/wimmc37b.c +index f7dbd965e4e72..b49a212af4d8d 100644 +--- a/drivers/gpu/drm/nouveau/dispnv50/wimmc37b.c ++++ b/drivers/gpu/drm/nouveau/dispnv50/wimmc37b.c +@@ -68,7 +68,7 @@ wimmc37b_init_(const struct nv50_wimm_func *func, struct nouveau_drm *drm, + int ret; + + ret = nv50_dmac_create(&drm->client.device, &disp->disp->object, +- &oclass, 0, &args, sizeof(args), 0, ++ &oclass, 0, &args, sizeof(args), -1, + &wndw->wimm); + if (ret) { + NV_ERROR(drm, "wimm%04x allocation failed: %d\n", oclass, ret); +diff --git a/drivers/gpu/drm/nouveau/nvkm/subdev/bios/shadow.c b/drivers/gpu/drm/nouveau/nvkm/subdev/bios/shadow.c +index 7deb81b6dbac6..4b571cc6bc70f 100644 +--- a/drivers/gpu/drm/nouveau/nvkm/subdev/bios/shadow.c ++++ b/drivers/gpu/drm/nouveau/nvkm/subdev/bios/shadow.c +@@ -75,7 +75,7 @@ shadow_image(struct nvkm_bios *bios, int idx, u32 offset, struct shadow *mthd) + nvkm_debug(subdev, "%08x: type %02x, %d bytes\n", + image.base, image.type, image.size); + +- if (!shadow_fetch(bios, mthd, image.size)) { ++ if (!shadow_fetch(bios, mthd, image.base + image.size)) { + nvkm_debug(subdev, "%08x: fetch failed\n", image.base); + return 0; + } +diff --git a/drivers/gpu/drm/nouveau/nvkm/subdev/i2c/auxgm200.c b/drivers/gpu/drm/nouveau/nvkm/subdev/i2c/auxgm200.c +index edb6148cbca04..d0e80ad526845 100644 +--- a/drivers/gpu/drm/nouveau/nvkm/subdev/i2c/auxgm200.c ++++ b/drivers/gpu/drm/nouveau/nvkm/subdev/i2c/auxgm200.c +@@ -33,7 +33,7 @@ static void + gm200_i2c_aux_fini(struct gm200_i2c_aux *aux) + { + struct nvkm_device *device = aux->base.pad->i2c->subdev.device; +- nvkm_mask(device, 0x00d954 + (aux->ch * 0x50), 0x00310000, 0x00000000); ++ nvkm_mask(device, 0x00d954 + (aux->ch * 0x50), 0x00710000, 0x00000000); + } + + static int +@@ -54,10 +54,10 @@ gm200_i2c_aux_init(struct gm200_i2c_aux *aux) + AUX_ERR(&aux->base, "begin idle timeout %08x", ctrl); + return -EBUSY; + } +- } while (ctrl & 0x03010000); ++ } while (ctrl & 0x07010000); + + /* set some magic, and wait up to 1ms for it to appear */ +- nvkm_mask(device, 0x00d954 + (aux->ch * 0x50), 0x00300000, ureq); ++ nvkm_mask(device, 0x00d954 + (aux->ch * 0x50), 0x00700000, ureq); + timeout = 1000; + do { + ctrl = nvkm_rd32(device, 0x00d954 + (aux->ch * 0x50)); +@@ -67,7 +67,7 @@ gm200_i2c_aux_init(struct gm200_i2c_aux *aux) + gm200_i2c_aux_fini(aux); + return -EBUSY; + } +- } while ((ctrl & 0x03000000) != urep); ++ } while ((ctrl & 0x07000000) != urep); + + return 0; + } +diff --git a/drivers/gpu/drm/nouveau/nvkm/subdev/ibus/gf100.c b/drivers/gpu/drm/nouveau/nvkm/subdev/ibus/gf100.c +index d80dbc8f09b20..55a4ea4393c62 100644 +--- a/drivers/gpu/drm/nouveau/nvkm/subdev/ibus/gf100.c ++++ b/drivers/gpu/drm/nouveau/nvkm/subdev/ibus/gf100.c +@@ -22,6 +22,7 @@ + * Authors: Ben Skeggs + */ + #include "priv.h" ++#include <subdev/timer.h> + + static void + gf100_ibus_intr_hub(struct nvkm_subdev *ibus, int i) +@@ -31,7 +32,6 @@ gf100_ibus_intr_hub(struct nvkm_subdev *ibus, int i) + u32 data = nvkm_rd32(device, 0x122124 + (i * 0x0400)); + u32 stat = nvkm_rd32(device, 0x122128 + (i * 0x0400)); + nvkm_debug(ibus, "HUB%d: %06x %08x (%08x)\n", i, addr, data, stat); +- nvkm_mask(device, 0x122128 + (i * 0x0400), 0x00000200, 0x00000000); + } + + static void +@@ -42,7 +42,6 @@ gf100_ibus_intr_rop(struct nvkm_subdev *ibus, int i) + u32 data = nvkm_rd32(device, 0x124124 + (i * 0x0400)); + u32 stat = nvkm_rd32(device, 0x124128 + (i * 0x0400)); + nvkm_debug(ibus, "ROP%d: %06x %08x (%08x)\n", i, addr, data, stat); +- nvkm_mask(device, 0x124128 + (i * 0x0400), 0x00000200, 0x00000000); + } + + static void +@@ -53,7 +52,6 @@ gf100_ibus_intr_gpc(struct nvkm_subdev *ibus, int i) + u32 data = nvkm_rd32(device, 0x128124 + (i * 0x0400)); + u32 stat = nvkm_rd32(device, 0x128128 + (i * 0x0400)); + nvkm_debug(ibus, "GPC%d: %06x %08x (%08x)\n", i, addr, data, stat); +- nvkm_mask(device, 0x128128 + (i * 0x0400), 0x00000200, 0x00000000); + } + + void +@@ -90,6 +88,12 @@ gf100_ibus_intr(struct nvkm_subdev *ibus) + intr1 &= ~stat; + } + } ++ ++ nvkm_mask(device, 0x121c4c, 0x0000003f, 0x00000002); ++ nvkm_msec(device, 2000, ++ if (!(nvkm_rd32(device, 0x121c4c) & 0x0000003f)) ++ break; ++ ); + } + + static int +diff --git a/drivers/gpu/drm/nouveau/nvkm/subdev/ibus/gk104.c b/drivers/gpu/drm/nouveau/nvkm/subdev/ibus/gk104.c +index 9025ed1bd2a99..4caf3ef087e1d 100644 +--- a/drivers/gpu/drm/nouveau/nvkm/subdev/ibus/gk104.c ++++ b/drivers/gpu/drm/nouveau/nvkm/subdev/ibus/gk104.c +@@ -22,6 +22,7 @@ + * Authors: Ben Skeggs + */ + #include "priv.h" ++#include <subdev/timer.h> + + static void + gk104_ibus_intr_hub(struct nvkm_subdev *ibus, int i) +@@ -31,7 +32,6 @@ gk104_ibus_intr_hub(struct nvkm_subdev *ibus, int i) + u32 data = nvkm_rd32(device, 0x122124 + (i * 0x0800)); + u32 stat = nvkm_rd32(device, 0x122128 + (i * 0x0800)); + nvkm_debug(ibus, "HUB%d: %06x %08x (%08x)\n", i, addr, data, stat); +- nvkm_mask(device, 0x122128 + (i * 0x0800), 0x00000200, 0x00000000); + } + + static void +@@ -42,7 +42,6 @@ gk104_ibus_intr_rop(struct nvkm_subdev *ibus, int i) + u32 data = nvkm_rd32(device, 0x124124 + (i * 0x0800)); + u32 stat = nvkm_rd32(device, 0x124128 + (i * 0x0800)); + nvkm_debug(ibus, "ROP%d: %06x %08x (%08x)\n", i, addr, data, stat); +- nvkm_mask(device, 0x124128 + (i * 0x0800), 0x00000200, 0x00000000); + } + + static void +@@ -53,7 +52,6 @@ gk104_ibus_intr_gpc(struct nvkm_subdev *ibus, int i) + u32 data = nvkm_rd32(device, 0x128124 + (i * 0x0800)); + u32 stat = nvkm_rd32(device, 0x128128 + (i * 0x0800)); + nvkm_debug(ibus, "GPC%d: %06x %08x (%08x)\n", i, addr, data, stat); +- nvkm_mask(device, 0x128128 + (i * 0x0800), 0x00000200, 0x00000000); + } + + void +@@ -90,6 +88,12 @@ gk104_ibus_intr(struct nvkm_subdev *ibus) + intr1 &= ~stat; + } + } ++ ++ nvkm_mask(device, 0x12004c, 0x0000003f, 0x00000002); ++ nvkm_msec(device, 2000, ++ if (!(nvkm_rd32(device, 0x12004c) & 0x0000003f)) ++ break; ++ ); + } + + static int +diff --git a/drivers/gpu/drm/nouveau/nvkm/subdev/mmu/base.c b/drivers/gpu/drm/nouveau/nvkm/subdev/mmu/base.c +index ee11ccaf0563c..cb51e248cb41b 100644 +--- a/drivers/gpu/drm/nouveau/nvkm/subdev/mmu/base.c ++++ b/drivers/gpu/drm/nouveau/nvkm/subdev/mmu/base.c +@@ -316,9 +316,9 @@ nvkm_mmu_vram(struct nvkm_mmu *mmu) + { + struct nvkm_device *device = mmu->subdev.device; + struct nvkm_mm *mm = &device->fb->ram->vram; +- const u32 sizeN = nvkm_mm_heap_size(mm, NVKM_RAM_MM_NORMAL); +- const u32 sizeU = nvkm_mm_heap_size(mm, NVKM_RAM_MM_NOMAP); +- const u32 sizeM = nvkm_mm_heap_size(mm, NVKM_RAM_MM_MIXED); ++ const u64 sizeN = nvkm_mm_heap_size(mm, NVKM_RAM_MM_NORMAL); ++ const u64 sizeU = nvkm_mm_heap_size(mm, NVKM_RAM_MM_NOMAP); ++ const u64 sizeM = nvkm_mm_heap_size(mm, NVKM_RAM_MM_MIXED); + u8 type = NVKM_MEM_KIND * !!mmu->func->kind; + u8 heap = NVKM_MEM_VRAM; + int heapM, heapN, heapU; +diff --git a/drivers/hid/hid-ids.h b/drivers/hid/hid-ids.h +index 6d118da1615d4..ab2be7a115d8f 100644 +--- a/drivers/hid/hid-ids.h ++++ b/drivers/hid/hid-ids.h +@@ -386,6 +386,7 @@ + #define USB_DEVICE_ID_TOSHIBA_CLICK_L9W 0x0401 + #define USB_DEVICE_ID_HP_X2 0x074d + #define USB_DEVICE_ID_HP_X2_10_COVER 0x0755 ++#define USB_DEVICE_ID_ASUS_UX550_TOUCHSCREEN 0x2706 + + #define USB_VENDOR_ID_ELECOM 0x056e + #define USB_DEVICE_ID_ELECOM_BM084 0x0061 +diff --git a/drivers/hid/hid-input.c b/drivers/hid/hid-input.c +index 13deb9a676855..4dd151b2924e2 100644 +--- a/drivers/hid/hid-input.c ++++ b/drivers/hid/hid-input.c +@@ -334,6 +334,8 @@ static const struct hid_device_id hid_battery_quirks[] = { + { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, + USB_DEVICE_ID_LOGITECH_DINOVO_EDGE_KBD), + HID_BATTERY_QUIRK_IGNORE }, ++ { HID_USB_DEVICE(USB_VENDOR_ID_ELAN, USB_DEVICE_ID_ASUS_UX550_TOUCHSCREEN), ++ HID_BATTERY_QUIRK_IGNORE }, + {} + }; + +diff --git a/drivers/hwtracing/intel_th/pci.c b/drivers/hwtracing/intel_th/pci.c +index a775d7acfa470..2a16171033941 100644 +--- a/drivers/hwtracing/intel_th/pci.c ++++ b/drivers/hwtracing/intel_th/pci.c +@@ -230,6 +230,11 @@ static const struct pci_device_id intel_th_pci_id_table[] = { + PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x4b26), + .driver_data = (kernel_ulong_t)&intel_th_2x, + }, ++ { ++ /* Alder Lake-P */ ++ PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x51a6), ++ .driver_data = (kernel_ulong_t)&intel_th_2x, ++ }, + { + /* Emmitsburg PCH */ + PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x1bcc), +diff --git a/drivers/hwtracing/stm/heartbeat.c b/drivers/hwtracing/stm/heartbeat.c +index 7db42395e1316..825c59a77a0e0 100644 +--- a/drivers/hwtracing/stm/heartbeat.c ++++ b/drivers/hwtracing/stm/heartbeat.c +@@ -64,7 +64,7 @@ static void stm_heartbeat_unlink(struct stm_source_data *data) + + static int stm_heartbeat_init(void) + { +- int i, ret = -ENOMEM; ++ int i, ret; + + if (nr_devs < 0 || nr_devs > STM_HEARTBEAT_MAX) + return -EINVAL; +@@ -72,8 +72,10 @@ static int stm_heartbeat_init(void) + for (i = 0; i < nr_devs; i++) { + stm_heartbeat[i].data.name = + kasprintf(GFP_KERNEL, "heartbeat.%d", i); +- if (!stm_heartbeat[i].data.name) ++ if (!stm_heartbeat[i].data.name) { ++ ret = -ENOMEM; + goto fail_unregister; ++ } + + stm_heartbeat[i].data.nr_chans = 1; + stm_heartbeat[i].data.link = stm_heartbeat_link; +diff --git a/drivers/i2c/busses/i2c-octeon-core.c b/drivers/i2c/busses/i2c-octeon-core.c +index d9607905dc2f1..845eda70b8cab 100644 +--- a/drivers/i2c/busses/i2c-octeon-core.c ++++ b/drivers/i2c/busses/i2c-octeon-core.c +@@ -347,7 +347,7 @@ static int octeon_i2c_read(struct octeon_i2c *i2c, int target, + if (result) + return result; + if (recv_len && i == 0) { +- if (data[i] > I2C_SMBUS_BLOCK_MAX + 1) ++ if (data[i] > I2C_SMBUS_BLOCK_MAX) + return -EPROTO; + length += data[i]; + } +diff --git a/drivers/i2c/busses/i2c-tegra-bpmp.c b/drivers/i2c/busses/i2c-tegra-bpmp.c +index f6cd35d0a2ac0..240bd1e908927 100644 +--- a/drivers/i2c/busses/i2c-tegra-bpmp.c ++++ b/drivers/i2c/busses/i2c-tegra-bpmp.c +@@ -91,7 +91,7 @@ static int tegra_bpmp_xlate_flags(u16 flags, u16 *out) + flags &= ~I2C_M_RECV_LEN; + } + +- return (flags != 0) ? -EINVAL : 0; ++ return 0; + } + + /** +diff --git a/drivers/iio/dac/ad5504.c b/drivers/iio/dac/ad5504.c +index d9037ea59168e..97b9ce305a687 100644 +--- a/drivers/iio/dac/ad5504.c ++++ b/drivers/iio/dac/ad5504.c +@@ -189,9 +189,9 @@ static ssize_t ad5504_write_dac_powerdown(struct iio_dev *indio_dev, + return ret; + + if (pwr_down) +- st->pwr_down_mask |= (1 << chan->channel); +- else + st->pwr_down_mask &= ~(1 << chan->channel); ++ else ++ st->pwr_down_mask |= (1 << chan->channel); + + ret = ad5504_spi_write(st, AD5504_ADDR_CTRL, + AD5504_DAC_PWRDWN_MODE(st->pwr_down_mode) | +diff --git a/drivers/irqchip/irq-mips-cpu.c b/drivers/irqchip/irq-mips-cpu.c +index 66f97fde13d80..51e09f6c653c3 100644 +--- a/drivers/irqchip/irq-mips-cpu.c ++++ b/drivers/irqchip/irq-mips-cpu.c +@@ -201,6 +201,13 @@ static int mips_cpu_ipi_alloc(struct irq_domain *domain, unsigned int virq, + if (ret) + return ret; + ++ ret = irq_domain_set_hwirq_and_chip(domain->parent, virq + i, hwirq, ++ &mips_mt_cpu_irq_controller, ++ NULL); ++ ++ if (ret) ++ return ret; ++ + ret = irq_set_irq_type(virq + i, IRQ_TYPE_LEVEL_HIGH); + if (ret) + return ret; +diff --git a/drivers/md/dm-integrity.c b/drivers/md/dm-integrity.c +index bb99b599de770..1917051b512f5 100644 +--- a/drivers/md/dm-integrity.c ++++ b/drivers/md/dm-integrity.c +@@ -3515,6 +3515,12 @@ try_smaller_buffer: + r = -ENOMEM; + goto bad; + } ++ } else { ++ if (ic->sb->flags & cpu_to_le32(SB_FLAG_RECALCULATING)) { ++ ti->error = "Recalculate can only be specified with internal_hash"; ++ r = -EINVAL; ++ goto bad; ++ } + } + + ic->bufio = dm_bufio_client_create(ic->meta_dev ? ic->meta_dev->bdev : ic->dev->bdev, +diff --git a/drivers/md/dm-table.c b/drivers/md/dm-table.c +index f849db3035a05..9164337424856 100644 +--- a/drivers/md/dm-table.c ++++ b/drivers/md/dm-table.c +@@ -431,14 +431,23 @@ int dm_get_device(struct dm_target *ti, const char *path, fmode_t mode, + { + int r; + dev_t dev; ++ unsigned int major, minor; ++ char dummy; + struct dm_dev_internal *dd; + struct dm_table *t = ti->table; + + BUG_ON(!t); + +- dev = dm_get_dev_t(path); +- if (!dev) +- return -ENODEV; ++ if (sscanf(path, "%u:%u%c", &major, &minor, &dummy) == 2) { ++ /* Extract the major/minor numbers */ ++ dev = MKDEV(major, minor); ++ if (MAJOR(dev) != major || MINOR(dev) != minor) ++ return -EOVERFLOW; ++ } else { ++ dev = dm_get_dev_t(path); ++ if (!dev) ++ return -ENODEV; ++ } + + dd = find_device(&t->devices, dev); + if (!dd) { +diff --git a/drivers/mmc/core/queue.c b/drivers/mmc/core/queue.c +index 9b31cd6b6062b..9aaf5a2d83c3b 100644 +--- a/drivers/mmc/core/queue.c ++++ b/drivers/mmc/core/queue.c +@@ -364,8 +364,10 @@ static void mmc_setup_queue(struct mmc_queue *mq, struct mmc_card *card) + min(host->max_blk_count, host->max_req_size / 512)); + blk_queue_max_segments(mq->queue, host->max_segs); + +- if (mmc_card_mmc(card)) ++ if (mmc_card_mmc(card) && card->ext_csd.data_sector_size) { + block_size = card->ext_csd.data_sector_size; ++ WARN_ON(block_size != 512 && block_size != 4096); ++ } + + blk_queue_logical_block_size(mq->queue, block_size); + blk_queue_max_segment_size(mq->queue, +diff --git a/drivers/mmc/host/sdhci-xenon.c b/drivers/mmc/host/sdhci-xenon.c +index fafb02644efde..ca34fa424634f 100644 +--- a/drivers/mmc/host/sdhci-xenon.c ++++ b/drivers/mmc/host/sdhci-xenon.c +@@ -170,7 +170,12 @@ static void xenon_reset_exit(struct sdhci_host *host, + /* Disable tuning request and auto-retuning again */ + xenon_retune_setup(host); + +- xenon_set_acg(host, true); ++ /* ++ * The ACG should be turned off at the early init time, in order ++ * to solve a possible issues with the 1.8V regulator stabilization. ++ * The feature is enabled in later stage. ++ */ ++ xenon_set_acg(host, false); + + xenon_set_sdclk_off_idle(host, sdhc_id, false); + +diff --git a/drivers/net/can/dev.c b/drivers/net/can/dev.c +index f88590074569e..953c6fdc75cc4 100644 +--- a/drivers/net/can/dev.c ++++ b/drivers/net/can/dev.c +@@ -579,11 +579,11 @@ static void can_restart(struct net_device *dev) + } + cf->can_id |= CAN_ERR_RESTARTED; + +- netif_rx_ni(skb); +- + stats->rx_packets++; + stats->rx_bytes += cf->can_dlc; + ++ netif_rx_ni(skb); ++ + restart: + netdev_dbg(dev, "restarted\n"); + priv->can_stats.restarts++; +diff --git a/drivers/net/can/usb/peak_usb/pcan_usb_fd.c b/drivers/net/can/usb/peak_usb/pcan_usb_fd.c +index 19600d35aac55..40ac37fe9dcde 100644 +--- a/drivers/net/can/usb/peak_usb/pcan_usb_fd.c ++++ b/drivers/net/can/usb/peak_usb/pcan_usb_fd.c +@@ -520,11 +520,11 @@ static int pcan_usb_fd_decode_canmsg(struct pcan_usb_fd_if *usb_if, + else + memcpy(cfd->data, rm->d, cfd->len); + +- peak_usb_netif_rx(skb, &usb_if->time_ref, le32_to_cpu(rm->ts_low)); +- + netdev->stats.rx_packets++; + netdev->stats.rx_bytes += cfd->len; + ++ peak_usb_netif_rx(skb, &usb_if->time_ref, le32_to_cpu(rm->ts_low)); ++ + return 0; + } + +@@ -586,11 +586,11 @@ static int pcan_usb_fd_decode_status(struct pcan_usb_fd_if *usb_if, + if (!skb) + return -ENOMEM; + +- peak_usb_netif_rx(skb, &usb_if->time_ref, le32_to_cpu(sm->ts_low)); +- + netdev->stats.rx_packets++; + netdev->stats.rx_bytes += cf->can_dlc; + ++ peak_usb_netif_rx(skb, &usb_if->time_ref, le32_to_cpu(sm->ts_low)); ++ + return 0; + } + +diff --git a/drivers/net/can/vxcan.c b/drivers/net/can/vxcan.c +index ed6828821fbd3..ccd758ba3fb09 100644 +--- a/drivers/net/can/vxcan.c ++++ b/drivers/net/can/vxcan.c +@@ -49,6 +49,7 @@ static netdev_tx_t vxcan_xmit(struct sk_buff *skb, struct net_device *dev) + struct net_device *peer; + struct canfd_frame *cfd = (struct canfd_frame *)skb->data; + struct net_device_stats *peerstats, *srcstats = &dev->stats; ++ u8 len; + + if (can_dropped_invalid_skb(dev, skb)) + return NETDEV_TX_OK; +@@ -71,12 +72,13 @@ static netdev_tx_t vxcan_xmit(struct sk_buff *skb, struct net_device *dev) + skb->dev = peer; + skb->ip_summed = CHECKSUM_UNNECESSARY; + ++ len = cfd->len; + if (netif_rx_ni(skb) == NET_RX_SUCCESS) { + srcstats->tx_packets++; +- srcstats->tx_bytes += cfd->len; ++ srcstats->tx_bytes += len; + peerstats = &peer->stats; + peerstats->rx_packets++; +- peerstats->rx_bytes += cfd->len; ++ peerstats->rx_bytes += len; + } + + out_unlock: +diff --git a/drivers/net/dsa/b53/b53_common.c b/drivers/net/dsa/b53/b53_common.c +index 294be86420b6d..335ce1e849044 100644 +--- a/drivers/net/dsa/b53/b53_common.c ++++ b/drivers/net/dsa/b53/b53_common.c +@@ -1142,7 +1142,7 @@ int b53_vlan_prepare(struct dsa_switch *ds, int port, + if ((is5325(dev) || is5365(dev)) && vlan->vid_begin == 0) + return -EOPNOTSUPP; + +- if (vlan->vid_end > dev->num_vlans) ++ if (vlan->vid_end >= dev->num_vlans) + return -ERANGE; + + b53_enable_vlan(dev, true, dev->vlan_filtering_enabled); +diff --git a/drivers/net/ethernet/mscc/ocelot.c b/drivers/net/ethernet/mscc/ocelot.c +index a29a6a618110e..ea30da1c53f0f 100644 +--- a/drivers/net/ethernet/mscc/ocelot.c ++++ b/drivers/net/ethernet/mscc/ocelot.c +@@ -1549,10 +1549,8 @@ static int ocelot_netdevice_event(struct notifier_block *unused, + struct net_device *dev = netdev_notifier_info_to_dev(ptr); + int ret = 0; + +- if (!ocelot_netdevice_dev_check(dev)) +- return 0; +- + if (event == NETDEV_PRECHANGEUPPER && ++ ocelot_netdevice_dev_check(dev) && + netif_is_lag_master(info->upper_dev)) { + struct netdev_lag_upper_info *lag_upper_info = info->upper_info; + struct netlink_ext_ack *extack; +diff --git a/drivers/net/ethernet/renesas/sh_eth.c b/drivers/net/ethernet/renesas/sh_eth.c +index 441643670ac0e..9ac7b09badca6 100644 +--- a/drivers/net/ethernet/renesas/sh_eth.c ++++ b/drivers/net/ethernet/renesas/sh_eth.c +@@ -2620,10 +2620,10 @@ static int sh_eth_close(struct net_device *ndev) + /* Free all the skbuffs in the Rx queue and the DMA buffer. */ + sh_eth_ring_free(ndev); + +- pm_runtime_put_sync(&mdp->pdev->dev); +- + mdp->is_opened = 0; + ++ pm_runtime_put(&mdp->pdev->dev); ++ + return 0; + } + +diff --git a/drivers/platform/x86/intel-vbtn.c b/drivers/platform/x86/intel-vbtn.c +index 36d6e72f50735..f5774372c3871 100644 +--- a/drivers/platform/x86/intel-vbtn.c ++++ b/drivers/platform/x86/intel-vbtn.c +@@ -191,12 +191,6 @@ static const struct dmi_system_id dmi_switches_allow_list[] = { + DMI_MATCH(DMI_PRODUCT_NAME, "Venue 11 Pro 7130"), + }, + }, +- { +- .matches = { +- DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"), +- DMI_MATCH(DMI_PRODUCT_NAME, "HP Stream x360 Convertible PC 11"), +- }, +- }, + { + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"), +diff --git a/drivers/scsi/megaraid/megaraid_sas_base.c b/drivers/scsi/megaraid/megaraid_sas_base.c +index 83d25ee88f028..8877a21102f1d 100644 +--- a/drivers/scsi/megaraid/megaraid_sas_base.c ++++ b/drivers/scsi/megaraid/megaraid_sas_base.c +@@ -7323,11 +7323,9 @@ megasas_mgmt_fw_ioctl(struct megasas_instance *instance, + goto out; + } + ++ /* always store 64 bits regardless of addressing */ + sense_ptr = (void *)cmd->frame + ioc->sense_off; +- if (instance->consistent_mask_64bit) +- put_unaligned_le64(sense_handle, sense_ptr); +- else +- put_unaligned_le32(sense_handle, sense_ptr); ++ put_unaligned_le64(sense_handle, sense_ptr); + } + + /* +diff --git a/drivers/scsi/qedi/qedi_main.c b/drivers/scsi/qedi/qedi_main.c +index eaa50328de90c..e201c163ea1c8 100644 +--- a/drivers/scsi/qedi/qedi_main.c ++++ b/drivers/scsi/qedi/qedi_main.c +@@ -2129,7 +2129,7 @@ qedi_show_boot_tgt_info(struct qedi_ctx *qedi, int type, + chap_name); + break; + case ISCSI_BOOT_TGT_CHAP_SECRET: +- rc = sprintf(buf, "%.*s\n", NVM_ISCSI_CFG_CHAP_NAME_MAX_LEN, ++ rc = sprintf(buf, "%.*s\n", NVM_ISCSI_CFG_CHAP_PWD_MAX_LEN, + chap_secret); + break; + case ISCSI_BOOT_TGT_REV_CHAP_NAME: +@@ -2137,7 +2137,7 @@ qedi_show_boot_tgt_info(struct qedi_ctx *qedi, int type, + mchap_name); + break; + case ISCSI_BOOT_TGT_REV_CHAP_SECRET: +- rc = sprintf(buf, "%.*s\n", NVM_ISCSI_CFG_CHAP_NAME_MAX_LEN, ++ rc = sprintf(buf, "%.*s\n", NVM_ISCSI_CFG_CHAP_PWD_MAX_LEN, + mchap_secret); + break; + case ISCSI_BOOT_TGT_FLAGS: +diff --git a/drivers/scsi/ufs/ufshcd.c b/drivers/scsi/ufs/ufshcd.c +index 40f478c4d118f..b18430efb00fb 100644 +--- a/drivers/scsi/ufs/ufshcd.c ++++ b/drivers/scsi/ufs/ufshcd.c +@@ -5772,19 +5772,16 @@ static int ufshcd_eh_device_reset_handler(struct scsi_cmnd *cmd) + { + struct Scsi_Host *host; + struct ufs_hba *hba; +- unsigned int tag; + u32 pos; + int err; +- u8 resp = 0xF; +- struct ufshcd_lrb *lrbp; ++ u8 resp = 0xF, lun; + unsigned long flags; + + host = cmd->device->host; + hba = shost_priv(host); +- tag = cmd->request->tag; + +- lrbp = &hba->lrb[tag]; +- err = ufshcd_issue_tm_cmd(hba, lrbp->lun, 0, UFS_LOGICAL_RESET, &resp); ++ lun = ufshcd_scsi_to_upiu_lun(cmd->device->lun); ++ err = ufshcd_issue_tm_cmd(hba, lun, 0, UFS_LOGICAL_RESET, &resp); + if (err || resp != UPIU_TASK_MANAGEMENT_FUNC_COMPL) { + if (!err) + err = resp; +@@ -5793,7 +5790,7 @@ static int ufshcd_eh_device_reset_handler(struct scsi_cmnd *cmd) + + /* clear the commands that were pending for corresponding LUN */ + for_each_set_bit(pos, &hba->outstanding_reqs, hba->nutrs) { +- if (hba->lrb[pos].lun == lrbp->lun) { ++ if (hba->lrb[pos].lun == lun) { + err = ufshcd_clear_cmd(hba, pos); + if (err) + break; +diff --git a/drivers/tty/serial/mvebu-uart.c b/drivers/tty/serial/mvebu-uart.c +index fb9d369e0f50c..330522be708fa 100644 +--- a/drivers/tty/serial/mvebu-uart.c ++++ b/drivers/tty/serial/mvebu-uart.c +@@ -637,6 +637,14 @@ static void wait_for_xmitr(struct uart_port *port) + (val & STAT_TX_RDY(port)), 1, 10000); + } + ++static void wait_for_xmite(struct uart_port *port) ++{ ++ u32 val; ++ ++ readl_poll_timeout_atomic(port->membase + UART_STAT, val, ++ (val & STAT_TX_EMP), 1, 10000); ++} ++ + static void mvebu_uart_console_putchar(struct uart_port *port, int ch) + { + wait_for_xmitr(port); +@@ -664,7 +672,7 @@ static void mvebu_uart_console_write(struct console *co, const char *s, + + uart_console_write(port, s, count, mvebu_uart_console_putchar); + +- wait_for_xmitr(port); ++ wait_for_xmite(port); + + if (ier) + writel(ier, port->membase + UART_CTRL(port)); +diff --git a/drivers/usb/gadget/udc/aspeed-vhub/epn.c b/drivers/usb/gadget/udc/aspeed-vhub/epn.c +index 5939eb1e97f20..ae853cf369662 100644 +--- a/drivers/usb/gadget/udc/aspeed-vhub/epn.c ++++ b/drivers/usb/gadget/udc/aspeed-vhub/epn.c +@@ -420,7 +420,10 @@ static void ast_vhub_stop_active_req(struct ast_vhub_ep *ep, + u32 state, reg, loops; + + /* Stop DMA activity */ +- writel(0, ep->epn.regs + AST_VHUB_EP_DMA_CTLSTAT); ++ if (ep->epn.desc_mode) ++ writel(VHUB_EP_DMA_CTRL_RESET, ep->epn.regs + AST_VHUB_EP_DMA_CTLSTAT); ++ else ++ writel(0, ep->epn.regs + AST_VHUB_EP_DMA_CTLSTAT); + + /* Wait for it to complete */ + for (loops = 0; loops < 1000; loops++) { +diff --git a/drivers/usb/gadget/udc/bdc/Kconfig b/drivers/usb/gadget/udc/bdc/Kconfig +index c74ac25dddcd0..051091bd265bc 100644 +--- a/drivers/usb/gadget/udc/bdc/Kconfig ++++ b/drivers/usb/gadget/udc/bdc/Kconfig +@@ -15,7 +15,7 @@ if USB_BDC_UDC + comment "Platform Support" + config USB_BDC_PCI + tristate "BDC support for PCIe based platforms" +- depends on USB_PCI ++ depends on USB_PCI && BROKEN + default USB_BDC_UDC + help + Enable support for platforms which have BDC connected through PCIe, such as Lego3 FPGA platform. +diff --git a/drivers/usb/gadget/udc/core.c b/drivers/usb/gadget/udc/core.c +index 1a79a99551871..87a417d878b8a 100644 +--- a/drivers/usb/gadget/udc/core.c ++++ b/drivers/usb/gadget/udc/core.c +@@ -1471,10 +1471,13 @@ static ssize_t soft_connect_store(struct device *dev, + struct device_attribute *attr, const char *buf, size_t n) + { + struct usb_udc *udc = container_of(dev, struct usb_udc, dev); ++ ssize_t ret; + ++ mutex_lock(&udc_lock); + if (!udc->driver) { + dev_err(dev, "soft-connect without a gadget driver\n"); +- return -EOPNOTSUPP; ++ ret = -EOPNOTSUPP; ++ goto out; + } + + if (sysfs_streq(buf, "connect")) { +@@ -1486,10 +1489,14 @@ static ssize_t soft_connect_store(struct device *dev, + usb_gadget_udc_stop(udc); + } else { + dev_err(dev, "unsupported command '%s'\n", buf); +- return -EINVAL; ++ ret = -EINVAL; ++ goto out; + } + +- return n; ++ ret = n; ++out: ++ mutex_unlock(&udc_lock); ++ return ret; + } + static DEVICE_ATTR_WO(soft_connect); + +diff --git a/drivers/usb/host/ehci-hcd.c b/drivers/usb/host/ehci-hcd.c +index caf9f6b1cd346..d9282ca7ae8c5 100644 +--- a/drivers/usb/host/ehci-hcd.c ++++ b/drivers/usb/host/ehci-hcd.c +@@ -574,6 +574,7 @@ static int ehci_run (struct usb_hcd *hcd) + struct ehci_hcd *ehci = hcd_to_ehci (hcd); + u32 temp; + u32 hcc_params; ++ int rc; + + hcd->uses_new_polling = 1; + +@@ -629,9 +630,20 @@ static int ehci_run (struct usb_hcd *hcd) + down_write(&ehci_cf_port_reset_rwsem); + ehci->rh_state = EHCI_RH_RUNNING; + ehci_writel(ehci, FLAG_CF, &ehci->regs->configured_flag); ++ ++ /* Wait until HC become operational */ + ehci_readl(ehci, &ehci->regs->command); /* unblock posted writes */ + msleep(5); ++ rc = ehci_handshake(ehci, &ehci->regs->status, STS_HALT, 0, 100 * 1000); ++ + up_write(&ehci_cf_port_reset_rwsem); ++ ++ if (rc) { ++ ehci_err(ehci, "USB %x.%x, controller refused to start: %d\n", ++ ((ehci->sbrn & 0xf0)>>4), (ehci->sbrn & 0x0f), rc); ++ return rc; ++ } ++ + ehci->last_periodic_enable = ktime_get_real(); + + temp = HC_VERSION(ehci, ehci_readl(ehci, &ehci->caps->hc_capbase)); +diff --git a/drivers/usb/host/ehci-hub.c b/drivers/usb/host/ehci-hub.c +index 087402aec5cbe..9f9ab5ccea889 100644 +--- a/drivers/usb/host/ehci-hub.c ++++ b/drivers/usb/host/ehci-hub.c +@@ -345,6 +345,9 @@ static int ehci_bus_suspend (struct usb_hcd *hcd) + + unlink_empty_async_suspended(ehci); + ++ /* Some Synopsys controllers mistakenly leave IAA turned on */ ++ ehci_writel(ehci, STS_IAA, &ehci->regs->status); ++ + /* Any IAA cycle that started before the suspend is now invalid */ + end_iaa_cycle(ehci); + ehci_handle_start_intr_unlinks(ehci); +diff --git a/drivers/usb/host/xhci-ring.c b/drivers/usb/host/xhci-ring.c +index 2a19d9a37a6aa..537bbcd47c463 100644 +--- a/drivers/usb/host/xhci-ring.c ++++ b/drivers/usb/host/xhci-ring.c +@@ -2835,6 +2835,8 @@ static void queue_trb(struct xhci_hcd *xhci, struct xhci_ring *ring, + trb->field[0] = cpu_to_le32(field1); + trb->field[1] = cpu_to_le32(field2); + trb->field[2] = cpu_to_le32(field3); ++ /* make sure TRB is fully written before giving it to the controller */ ++ wmb(); + trb->field[3] = cpu_to_le32(field4); + + trace_xhci_queue_trb(ring, trb); +diff --git a/drivers/usb/host/xhci-tegra.c b/drivers/usb/host/xhci-tegra.c +index fe37dacc695fc..dc9cd8c519cf2 100644 +--- a/drivers/usb/host/xhci-tegra.c ++++ b/drivers/usb/host/xhci-tegra.c +@@ -578,6 +578,13 @@ static void tegra_xusb_mbox_handle(struct tegra_xusb *tegra, + enable); + if (err < 0) + break; ++ ++ /* ++ * wait 500us for LFPS detector to be disabled before ++ * sending ACK ++ */ ++ if (!enable) ++ usleep_range(500, 1000); + } + + if (err < 0) { +diff --git a/drivers/xen/events/events_base.c b/drivers/xen/events/events_base.c +index aca8456752797..8c08c7d46d3d0 100644 +--- a/drivers/xen/events/events_base.c ++++ b/drivers/xen/events/events_base.c +@@ -1987,16 +1987,6 @@ static struct irq_chip xen_percpu_chip __read_mostly = { + .irq_ack = ack_dynirq, + }; + +-int xen_set_callback_via(uint64_t via) +-{ +- struct xen_hvm_param a; +- a.domid = DOMID_SELF; +- a.index = HVM_PARAM_CALLBACK_IRQ; +- a.value = via; +- return HYPERVISOR_hvm_op(HVMOP_set_param, &a); +-} +-EXPORT_SYMBOL_GPL(xen_set_callback_via); +- + #ifdef CONFIG_XEN_PVHVM + /* Vector callbacks are better than PCI interrupts to receive event + * channel notifications because we can receive vector callbacks on any +diff --git a/drivers/xen/platform-pci.c b/drivers/xen/platform-pci.c +index 5d7dcad0b0a0d..4cec8146609ad 100644 +--- a/drivers/xen/platform-pci.c ++++ b/drivers/xen/platform-pci.c +@@ -162,7 +162,6 @@ static int platform_pci_probe(struct pci_dev *pdev, + ret = gnttab_init(); + if (ret) + goto grant_out; +- xenbus_probe(NULL); + return 0; + grant_out: + gnttab_free_auto_xlat_frames(); +diff --git a/drivers/xen/xenbus/xenbus.h b/drivers/xen/xenbus/xenbus.h +index 88516a8a9f932..a9bb5f91082d3 100644 +--- a/drivers/xen/xenbus/xenbus.h ++++ b/drivers/xen/xenbus/xenbus.h +@@ -115,6 +115,7 @@ int xenbus_probe_node(struct xen_bus_type *bus, + const char *type, + const char *nodename); + int xenbus_probe_devices(struct xen_bus_type *bus); ++void xenbus_probe(void); + + void xenbus_dev_changed(const char *node, struct xen_bus_type *bus); + +diff --git a/drivers/xen/xenbus/xenbus_comms.c b/drivers/xen/xenbus/xenbus_comms.c +index eb5151fc8efab..e5fda0256feb3 100644 +--- a/drivers/xen/xenbus/xenbus_comms.c ++++ b/drivers/xen/xenbus/xenbus_comms.c +@@ -57,16 +57,8 @@ DEFINE_MUTEX(xs_response_mutex); + static int xenbus_irq; + static struct task_struct *xenbus_task; + +-static DECLARE_WORK(probe_work, xenbus_probe); +- +- + static irqreturn_t wake_waiting(int irq, void *unused) + { +- if (unlikely(xenstored_ready == 0)) { +- xenstored_ready = 1; +- schedule_work(&probe_work); +- } +- + wake_up(&xb_waitq); + return IRQ_HANDLED; + } +diff --git a/drivers/xen/xenbus/xenbus_probe.c b/drivers/xen/xenbus/xenbus_probe.c +index e6d0903459e11..14ccf13ab8fa1 100644 +--- a/drivers/xen/xenbus/xenbus_probe.c ++++ b/drivers/xen/xenbus/xenbus_probe.c +@@ -683,29 +683,76 @@ void unregister_xenstore_notifier(struct notifier_block *nb) + } + EXPORT_SYMBOL_GPL(unregister_xenstore_notifier); + +-void xenbus_probe(struct work_struct *unused) ++void xenbus_probe(void) + { + xenstored_ready = 1; + ++ /* ++ * In the HVM case, xenbus_init() deferred its call to ++ * xs_init() in case callbacks were not operational yet. ++ * So do it now. ++ */ ++ if (xen_store_domain_type == XS_HVM) ++ xs_init(); ++ + /* Notify others that xenstore is up */ + blocking_notifier_call_chain(&xenstore_chain, 0, NULL); + } +-EXPORT_SYMBOL_GPL(xenbus_probe); + +-static int __init xenbus_probe_initcall(void) ++/* ++ * Returns true when XenStore init must be deferred in order to ++ * allow the PCI platform device to be initialised, before we ++ * can actually have event channel interrupts working. ++ */ ++static bool xs_hvm_defer_init_for_callback(void) + { +- if (!xen_domain()) +- return -ENODEV; ++#ifdef CONFIG_XEN_PVHVM ++ return xen_store_domain_type == XS_HVM && ++ !xen_have_vector_callback; ++#else ++ return false; ++#endif ++} + +- if (xen_initial_domain() || xen_hvm_domain()) +- return 0; ++static int __init xenbus_probe_initcall(void) ++{ ++ /* ++ * Probe XenBus here in the XS_PV case, and also XS_HVM unless we ++ * need to wait for the platform PCI device to come up. ++ */ ++ if (xen_store_domain_type == XS_PV || ++ (xen_store_domain_type == XS_HVM && ++ !xs_hvm_defer_init_for_callback())) ++ xenbus_probe(); + +- xenbus_probe(NULL); + return 0; + } +- + device_initcall(xenbus_probe_initcall); + ++int xen_set_callback_via(uint64_t via) ++{ ++ struct xen_hvm_param a; ++ int ret; ++ ++ a.domid = DOMID_SELF; ++ a.index = HVM_PARAM_CALLBACK_IRQ; ++ a.value = via; ++ ++ ret = HYPERVISOR_hvm_op(HVMOP_set_param, &a); ++ if (ret) ++ return ret; ++ ++ /* ++ * If xenbus_probe_initcall() deferred the xenbus_probe() ++ * due to the callback not functioning yet, we can do it now. ++ */ ++ if (!xenstored_ready && xs_hvm_defer_init_for_callback()) ++ xenbus_probe(); ++ ++ return ret; ++} ++EXPORT_SYMBOL_GPL(xen_set_callback_via); ++ + /* Set up event channel for xenstored which is run as a local process + * (this is normally used only in dom0) + */ +@@ -818,11 +865,17 @@ static int __init xenbus_init(void) + break; + } + +- /* Initialize the interface to xenstore. */ +- err = xs_init(); +- if (err) { +- pr_warn("Error initializing xenstore comms: %i\n", err); +- goto out_error; ++ /* ++ * HVM domains may not have a functional callback yet. In that ++ * case let xs_init() be called from xenbus_probe(), which will ++ * get invoked at an appropriate time. ++ */ ++ if (xen_store_domain_type != XS_HVM) { ++ err = xs_init(); ++ if (err) { ++ pr_warn("Error initializing xenstore comms: %i\n", err); ++ goto out_error; ++ } + } + + if ((xen_store_domain_type != XS_LOCAL) && +diff --git a/fs/btrfs/volumes.c b/fs/btrfs/volumes.c +index 95b6a4ea18f7a..662711200eeba 100644 +--- a/fs/btrfs/volumes.c ++++ b/fs/btrfs/volumes.c +@@ -4011,6 +4011,8 @@ int btrfs_recover_balance(struct btrfs_fs_info *fs_info) + btrfs_warn(fs_info, + "balance: cannot set exclusive op status, resume manually"); + ++ btrfs_release_path(path); ++ + mutex_lock(&fs_info->balance_mutex); + BUG_ON(fs_info->balance_ctl); + spin_lock(&fs_info->balance_lock); +diff --git a/include/xen/xenbus.h b/include/xen/xenbus.h +index eba01ab5a55e0..fe9a9fa2ebc45 100644 +--- a/include/xen/xenbus.h ++++ b/include/xen/xenbus.h +@@ -187,7 +187,7 @@ void xs_suspend_cancel(void); + + struct work_struct; + +-void xenbus_probe(struct work_struct *); ++void xenbus_probe(void); + + #define XENBUS_IS_ERR_READ(str) ({ \ + if (!IS_ERR(str) && strlen(str) == 0) { \ +diff --git a/mm/kasan/kasan_init.c b/mm/kasan/kasan_init.c +index 7a2a2f13f86f5..7a731c74be7da 100644 +--- a/mm/kasan/kasan_init.c ++++ b/mm/kasan/kasan_init.c +@@ -372,9 +372,10 @@ static void kasan_remove_pmd_table(pmd_t *pmd, unsigned long addr, + + if (kasan_pte_table(*pmd)) { + if (IS_ALIGNED(addr, PMD_SIZE) && +- IS_ALIGNED(next, PMD_SIZE)) ++ IS_ALIGNED(next, PMD_SIZE)) { + pmd_clear(pmd); +- continue; ++ continue; ++ } + } + pte = pte_offset_kernel(pmd, addr); + kasan_remove_pte_table(pte, addr, next); +@@ -397,9 +398,10 @@ static void kasan_remove_pud_table(pud_t *pud, unsigned long addr, + + if (kasan_pmd_table(*pud)) { + if (IS_ALIGNED(addr, PUD_SIZE) && +- IS_ALIGNED(next, PUD_SIZE)) ++ IS_ALIGNED(next, PUD_SIZE)) { + pud_clear(pud); +- continue; ++ continue; ++ } + } + pmd = pmd_offset(pud, addr); + pmd_base = pmd_offset(pud, 0); +@@ -423,9 +425,10 @@ static void kasan_remove_p4d_table(p4d_t *p4d, unsigned long addr, + + if (kasan_pud_table(*p4d)) { + if (IS_ALIGNED(addr, P4D_SIZE) && +- IS_ALIGNED(next, P4D_SIZE)) ++ IS_ALIGNED(next, P4D_SIZE)) { + p4d_clear(p4d); +- continue; ++ continue; ++ } + } + pud = pud_offset(p4d, addr); + kasan_remove_pud_table(pud, addr, next); +@@ -457,9 +460,10 @@ void kasan_remove_zero_shadow(void *start, unsigned long size) + + if (kasan_p4d_table(*pgd)) { + if (IS_ALIGNED(addr, PGDIR_SIZE) && +- IS_ALIGNED(next, PGDIR_SIZE)) ++ IS_ALIGNED(next, PGDIR_SIZE)) { + pgd_clear(pgd); +- continue; ++ continue; ++ } + } + + p4d = p4d_offset(pgd, addr); +@@ -483,7 +487,6 @@ int kasan_add_zero_shadow(void *start, unsigned long size) + + ret = kasan_populate_zero_shadow(shadow_start, shadow_end); + if (ret) +- kasan_remove_zero_shadow(shadow_start, +- size >> KASAN_SHADOW_SCALE_SHIFT); ++ kasan_remove_zero_shadow(start, size); + return ret; + } +diff --git a/net/core/dev.c b/net/core/dev.c +index c77d12a35f923..5d9800804d4a4 100644 +--- a/net/core/dev.c ++++ b/net/core/dev.c +@@ -8351,6 +8351,11 @@ static netdev_features_t netdev_fix_features(struct net_device *dev, + } + } + ++ if ((features & NETIF_F_HW_TLS_RX) && !(features & NETIF_F_RXCSUM)) { ++ netdev_dbg(dev, "Dropping TLS RX HW offload feature since no RXCSUM feature.\n"); ++ features &= ~NETIF_F_HW_TLS_RX; ++ } ++ + return features; + } + +diff --git a/net/core/skbuff.c b/net/core/skbuff.c +index 73f208466363b..4a9ab2596e782 100644 +--- a/net/core/skbuff.c ++++ b/net/core/skbuff.c +@@ -398,7 +398,11 @@ struct sk_buff *__netdev_alloc_skb(struct net_device *dev, unsigned int len, + + len += NET_SKB_PAD; + +- if ((len > SKB_WITH_OVERHEAD(PAGE_SIZE)) || ++ /* If requested length is either too small or too big, ++ * we use kmalloc() for skb->head allocation. ++ */ ++ if (len <= SKB_WITH_OVERHEAD(1024) || ++ len > SKB_WITH_OVERHEAD(PAGE_SIZE) || + (gfp_mask & (__GFP_DIRECT_RECLAIM | GFP_DMA))) { + skb = __alloc_skb(len, gfp_mask, SKB_ALLOC_RX, NUMA_NO_NODE); + if (!skb) +diff --git a/net/ipv4/netfilter/ipt_rpfilter.c b/net/ipv4/netfilter/ipt_rpfilter.c +index 74b19a5c572e9..088320ce77a1b 100644 +--- a/net/ipv4/netfilter/ipt_rpfilter.c ++++ b/net/ipv4/netfilter/ipt_rpfilter.c +@@ -94,7 +94,7 @@ static bool rpfilter_mt(const struct sk_buff *skb, struct xt_action_param *par) + flow.daddr = iph->saddr; + flow.saddr = rpfilter_get_saddr(iph->daddr); + flow.flowi4_mark = info->flags & XT_RPFILTER_VALID_MARK ? skb->mark : 0; +- flow.flowi4_tos = RT_TOS(iph->tos); ++ flow.flowi4_tos = iph->tos & IPTOS_RT_MASK; + flow.flowi4_scope = RT_SCOPE_UNIVERSE; + flow.flowi4_oif = l3mdev_master_ifindex_rcu(xt_in(par)); + +diff --git a/net/ipv4/udp.c b/net/ipv4/udp.c +index 2aacf2b348348..110af0e7dc7b6 100644 +--- a/net/ipv4/udp.c ++++ b/net/ipv4/udp.c +@@ -2416,7 +2416,8 @@ int udp_v4_early_demux(struct sk_buff *skb) + */ + if (!inet_sk(sk)->inet_daddr && in_dev) + return ip_mc_validate_source(skb, iph->daddr, +- iph->saddr, iph->tos, ++ iph->saddr, ++ iph->tos & IPTOS_RT_MASK, + skb->dev, in_dev, &itag); + } + return 0; +diff --git a/net/ipv6/addrconf.c b/net/ipv6/addrconf.c +index 627cd24b7c0d0..76c097552ea74 100644 +--- a/net/ipv6/addrconf.c ++++ b/net/ipv6/addrconf.c +@@ -2395,8 +2395,9 @@ static void addrconf_add_mroute(struct net_device *dev) + .fc_ifindex = dev->ifindex, + .fc_dst_len = 8, + .fc_flags = RTF_UP, +- .fc_type = RTN_UNICAST, ++ .fc_type = RTN_MULTICAST, + .fc_nlinfo.nl_net = dev_net(dev), ++ .fc_protocol = RTPROT_KERNEL, + }; + + ipv6_addr_set(&cfg.fc_dst, htonl(0xFF000000), 0, 0, 0); +diff --git a/net/sched/cls_tcindex.c b/net/sched/cls_tcindex.c +index 0d7a0aac8dbb1..e41bc5ecaa092 100644 +--- a/net/sched/cls_tcindex.c ++++ b/net/sched/cls_tcindex.c +@@ -339,9 +339,13 @@ tcindex_set_parms(struct net *net, struct tcf_proto *tp, unsigned long base, + if (tb[TCA_TCINDEX_MASK]) + cp->mask = nla_get_u16(tb[TCA_TCINDEX_MASK]); + +- if (tb[TCA_TCINDEX_SHIFT]) ++ if (tb[TCA_TCINDEX_SHIFT]) { + cp->shift = nla_get_u32(tb[TCA_TCINDEX_SHIFT]); +- ++ if (cp->shift > 16) { ++ err = -EINVAL; ++ goto errout; ++ } ++ } + if (!cp->hash) { + /* Hash not specified, use perfect hash if the upper limit + * of the hashing index is below the threshold. +diff --git a/net/sched/sch_api.c b/net/sched/sch_api.c +index 39e319d04bb87..ed065c3432e5f 100644 +--- a/net/sched/sch_api.c ++++ b/net/sched/sch_api.c +@@ -398,7 +398,8 @@ struct qdisc_rate_table *qdisc_get_rtab(struct tc_ratespec *r, + { + struct qdisc_rate_table *rtab; + +- if (tab == NULL || r->rate == 0 || r->cell_log == 0 || ++ if (tab == NULL || r->rate == 0 || ++ r->cell_log == 0 || r->cell_log >= 32 || + nla_len(tab) != TC_RTAB_SIZE) { + NL_SET_ERR_MSG(extack, "Invalid rate table parameters for searching"); + return NULL; +diff --git a/sound/core/seq/oss/seq_oss_synth.c b/sound/core/seq/oss/seq_oss_synth.c +index c939459172353..247b68790a522 100644 +--- a/sound/core/seq/oss/seq_oss_synth.c ++++ b/sound/core/seq/oss/seq_oss_synth.c +@@ -624,7 +624,8 @@ snd_seq_oss_synth_make_info(struct seq_oss_devinfo *dp, int dev, struct synth_in + + if (info->is_midi) { + struct midi_info minf; +- snd_seq_oss_midi_make_info(dp, info->midi_mapped, &minf); ++ if (snd_seq_oss_midi_make_info(dp, info->midi_mapped, &minf)) ++ return -ENXIO; + inf->synth_type = SYNTH_TYPE_MIDI; + inf->synth_subtype = 0; + inf->nr_voices = 16; +diff --git a/sound/pci/hda/patch_via.c b/sound/pci/hda/patch_via.c +index 11bf7ace5ab2d..efba9057b2b61 100644 +--- a/sound/pci/hda/patch_via.c ++++ b/sound/pci/hda/patch_via.c +@@ -126,6 +126,7 @@ static struct via_spec *via_new_spec(struct hda_codec *codec) + spec->codec_type = VT1708S; + spec->gen.indep_hp = 1; + spec->gen.keep_eapd_on = 1; ++ spec->gen.dac_min_mute = 1; + spec->gen.pcm_playback_hook = via_playback_pcm_hook; + spec->gen.add_stereo_mix_input = HDA_HINT_STEREO_MIX_AUTO; + codec->power_save_node = 1; +diff --git a/sound/soc/intel/boards/haswell.c b/sound/soc/intel/boards/haswell.c +index a4022983a7ce0..67eb4a446c3cb 100644 +--- a/sound/soc/intel/boards/haswell.c ++++ b/sound/soc/intel/boards/haswell.c +@@ -198,6 +198,7 @@ static struct platform_driver haswell_audio = { + .probe = haswell_audio_probe, + .driver = { + .name = "haswell-audio", ++ .pm = &snd_soc_pm_ops, + }, + }; + +diff --git a/tools/testing/selftests/net/fib_tests.sh b/tools/testing/selftests/net/fib_tests.sh +index 67048f922ff20..a5ba149761bf9 100755 +--- a/tools/testing/selftests/net/fib_tests.sh ++++ b/tools/testing/selftests/net/fib_tests.sh +@@ -987,7 +987,6 @@ ipv6_addr_metric_test() + + check_route6 "2001:db8:104::1 dev dummy2 proto kernel metric 260" + log_test $? 0 "Set metric with peer route on local side" +- log_test $? 0 "User specified metric on local address" + check_route6 "2001:db8:104::2 dev dummy2 proto kernel metric 260" + log_test $? 0 "Set metric with peer route on peer side" +
