commit: 555c6226f41d9bb863aef0eee0db88f419e48695 Author: Alice Ferrazzi <alicef <AT> gentoo <DOT> org> AuthorDate: Wed Apr 28 11:44:02 2021 +0000 Commit: Alice Ferrazzi <alicef <AT> gentoo <DOT> org> CommitDate: Wed Apr 28 11:44:35 2021 +0000 URL: https://gitweb.gentoo.org/proj/linux-patches.git/commit/?id=555c6226
Linux patch 4.19.189 Signed-off-by: Alice Ferrazzi <alicef <AT> gentoo.org> 0000_README | 4 + 1188_linux-4.19.189.patch | 1590 +++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 1594 insertions(+) diff --git a/0000_README b/0000_README index 32b1ad4..a3a9c1c 100644 --- a/0000_README +++ b/0000_README @@ -791,6 +791,10 @@ Patch: 1187_linux-4.19.188.patch From: https://www.kernel.org Desc: Linux 4.19.188 +Patch: 1188_linux-4.19.189.patch +From: https://www.kernel.org +Desc: Linux 4.19.189 + 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/1188_linux-4.19.189.patch b/1188_linux-4.19.189.patch new file mode 100644 index 0000000..e63483d --- /dev/null +++ b/1188_linux-4.19.189.patch @@ -0,0 +1,1590 @@ +diff --git a/Makefile b/Makefile +index 85f071709a619..b19e0e7b7eb34 100644 +--- a/Makefile ++++ b/Makefile +@@ -1,7 +1,7 @@ + # SPDX-License-Identifier: GPL-2.0 + VERSION = 4 + PATCHLEVEL = 19 +-SUBLEVEL = 188 ++SUBLEVEL = 189 + EXTRAVERSION = + NAME = "People's Front" + +diff --git a/arch/arc/kernel/signal.c b/arch/arc/kernel/signal.c +index 48685445002e7..da243420bcb58 100644 +--- a/arch/arc/kernel/signal.c ++++ b/arch/arc/kernel/signal.c +@@ -99,7 +99,7 @@ stash_usr_regs(struct rt_sigframe __user *sf, struct pt_regs *regs, + sizeof(sf->uc.uc_mcontext.regs.scratch)); + err |= __copy_to_user(&sf->uc.uc_sigmask, set, sizeof(sigset_t)); + +- return err; ++ return err ? -EFAULT : 0; + } + + static int restore_usr_regs(struct pt_regs *regs, struct rt_sigframe __user *sf) +@@ -113,7 +113,7 @@ static int restore_usr_regs(struct pt_regs *regs, struct rt_sigframe __user *sf) + &(sf->uc.uc_mcontext.regs.scratch), + sizeof(sf->uc.uc_mcontext.regs.scratch)); + if (err) +- return err; ++ return -EFAULT; + + set_current_blocked(&set); + regs->bta = uregs.scratch.bta; +diff --git a/arch/arm/boot/dts/omap3.dtsi b/arch/arm/boot/dts/omap3.dtsi +index 4043ecb380168..0c8fcfb292bf9 100644 +--- a/arch/arm/boot/dts/omap3.dtsi ++++ b/arch/arm/boot/dts/omap3.dtsi +@@ -23,6 +23,9 @@ + i2c0 = &i2c1; + i2c1 = &i2c2; + i2c2 = &i2c3; ++ mmc0 = &mmc1; ++ mmc1 = &mmc2; ++ mmc2 = &mmc3; + serial0 = &uart1; + serial1 = &uart2; + serial2 = &uart3; +diff --git a/arch/arm/boot/dts/omap4.dtsi b/arch/arm/boot/dts/omap4.dtsi +index 8f907c235b02c..046e77024567b 100644 +--- a/arch/arm/boot/dts/omap4.dtsi ++++ b/arch/arm/boot/dts/omap4.dtsi +@@ -25,6 +25,11 @@ + i2c1 = &i2c2; + i2c2 = &i2c3; + i2c3 = &i2c4; ++ mmc0 = &mmc1; ++ mmc1 = &mmc2; ++ mmc2 = &mmc3; ++ mmc3 = &mmc4; ++ mmc4 = &mmc5; + serial0 = &uart1; + serial1 = &uart2; + serial2 = &uart3; +diff --git a/arch/arm/boot/dts/omap44xx-clocks.dtsi b/arch/arm/boot/dts/omap44xx-clocks.dtsi +index 279ff2f419df6..c654588f9e8cc 100644 +--- a/arch/arm/boot/dts/omap44xx-clocks.dtsi ++++ b/arch/arm/boot/dts/omap44xx-clocks.dtsi +@@ -773,14 +773,6 @@ + ti,max-div = <2>; + }; + +- sha2md5_fck: sha2md5_fck@15c8 { +- #clock-cells = <0>; +- compatible = "ti,gate-clock"; +- clocks = <&l3_div_ck>; +- ti,bit-shift = <1>; +- reg = <0x15c8>; +- }; +- + usb_phy_cm_clk32k: usb_phy_cm_clk32k@640 { + #clock-cells = <0>; + compatible = "ti,gate-clock"; +diff --git a/arch/arm/boot/dts/omap5.dtsi b/arch/arm/boot/dts/omap5.dtsi +index 3c0bafe0fb05f..cf66c374de4f2 100644 +--- a/arch/arm/boot/dts/omap5.dtsi ++++ b/arch/arm/boot/dts/omap5.dtsi +@@ -26,6 +26,11 @@ + i2c2 = &i2c3; + i2c3 = &i2c4; + i2c4 = &i2c5; ++ mmc0 = &mmc1; ++ mmc1 = &mmc2; ++ mmc2 = &mmc3; ++ mmc3 = &mmc4; ++ mmc4 = &mmc5; + serial0 = &uart1; + serial1 = &uart2; + serial2 = &uart3; +diff --git a/arch/arm/mach-footbridge/cats-pci.c b/arch/arm/mach-footbridge/cats-pci.c +index 0b2fd7e2e9b42..90b1e9be430e9 100644 +--- a/arch/arm/mach-footbridge/cats-pci.c ++++ b/arch/arm/mach-footbridge/cats-pci.c +@@ -15,14 +15,14 @@ + #include <asm/mach-types.h> + + /* cats host-specific stuff */ +-static int irqmap_cats[] __initdata = { IRQ_PCI, IRQ_IN0, IRQ_IN1, IRQ_IN3 }; ++static int irqmap_cats[] = { IRQ_PCI, IRQ_IN0, IRQ_IN1, IRQ_IN3 }; + + static u8 cats_no_swizzle(struct pci_dev *dev, u8 *pin) + { + return 0; + } + +-static int __init cats_map_irq(const struct pci_dev *dev, u8 slot, u8 pin) ++static int cats_map_irq(const struct pci_dev *dev, u8 slot, u8 pin) + { + if (dev->irq >= 255) + return -1; /* not a valid interrupt. */ +diff --git a/arch/arm/mach-footbridge/ebsa285-pci.c b/arch/arm/mach-footbridge/ebsa285-pci.c +index 6f28aaa9ca79b..c3f280d08fa7f 100644 +--- a/arch/arm/mach-footbridge/ebsa285-pci.c ++++ b/arch/arm/mach-footbridge/ebsa285-pci.c +@@ -14,9 +14,9 @@ + #include <asm/mach/pci.h> + #include <asm/mach-types.h> + +-static int irqmap_ebsa285[] __initdata = { IRQ_IN3, IRQ_IN1, IRQ_IN0, IRQ_PCI }; ++static int irqmap_ebsa285[] = { IRQ_IN3, IRQ_IN1, IRQ_IN0, IRQ_PCI }; + +-static int __init ebsa285_map_irq(const struct pci_dev *dev, u8 slot, u8 pin) ++static int ebsa285_map_irq(const struct pci_dev *dev, u8 slot, u8 pin) + { + if (dev->vendor == PCI_VENDOR_ID_CONTAQ && + dev->device == PCI_DEVICE_ID_CONTAQ_82C693) +diff --git a/arch/arm/mach-footbridge/netwinder-pci.c b/arch/arm/mach-footbridge/netwinder-pci.c +index 9473aa0305e5f..e8304392074b8 100644 +--- a/arch/arm/mach-footbridge/netwinder-pci.c ++++ b/arch/arm/mach-footbridge/netwinder-pci.c +@@ -18,7 +18,7 @@ + * We now use the slot ID instead of the device identifiers to select + * which interrupt is routed where. + */ +-static int __init netwinder_map_irq(const struct pci_dev *dev, u8 slot, u8 pin) ++static int netwinder_map_irq(const struct pci_dev *dev, u8 slot, u8 pin) + { + switch (slot) { + case 0: /* host bridge */ +diff --git a/arch/arm/mach-footbridge/personal-pci.c b/arch/arm/mach-footbridge/personal-pci.c +index 4391e433a4b2f..9d19aa98a663e 100644 +--- a/arch/arm/mach-footbridge/personal-pci.c ++++ b/arch/arm/mach-footbridge/personal-pci.c +@@ -14,13 +14,12 @@ + #include <asm/mach/pci.h> + #include <asm/mach-types.h> + +-static int irqmap_personal_server[] __initdata = { ++static int irqmap_personal_server[] = { + IRQ_IN0, IRQ_IN1, IRQ_IN2, IRQ_IN3, 0, 0, 0, + IRQ_DOORBELLHOST, IRQ_DMA1, IRQ_DMA2, IRQ_PCI + }; + +-static int __init personal_server_map_irq(const struct pci_dev *dev, u8 slot, +- u8 pin) ++static int personal_server_map_irq(const struct pci_dev *dev, u8 slot, u8 pin) + { + unsigned char line; + +diff --git a/arch/arm/mach-keystone/keystone.c b/arch/arm/mach-keystone/keystone.c +index 84613abf35a33..79ff5b9534313 100644 +--- a/arch/arm/mach-keystone/keystone.c ++++ b/arch/arm/mach-keystone/keystone.c +@@ -65,7 +65,7 @@ static void __init keystone_init(void) + static long long __init keystone_pv_fixup(void) + { + long long offset; +- phys_addr_t mem_start, mem_end; ++ u64 mem_start, mem_end; + + mem_start = memblock_start_of_DRAM(); + mem_end = memblock_end_of_DRAM(); +@@ -78,7 +78,7 @@ static long long __init keystone_pv_fixup(void) + if (mem_start < KEYSTONE_HIGH_PHYS_START || + mem_end > KEYSTONE_HIGH_PHYS_END) { + pr_crit("Invalid address space for memory (%08llx-%08llx)\n", +- (u64)mem_start, (u64)mem_end); ++ mem_start, mem_end); + return 0; + } + +diff --git a/arch/arm/probes/uprobes/core.c b/arch/arm/probes/uprobes/core.c +index bf992264060ef..b1b7b51c938c4 100644 +--- a/arch/arm/probes/uprobes/core.c ++++ b/arch/arm/probes/uprobes/core.c +@@ -207,7 +207,7 @@ unsigned long uprobe_get_swbp_addr(struct pt_regs *regs) + static struct undef_hook uprobes_arm_break_hook = { + .instr_mask = 0x0fffffff, + .instr_val = (UPROBE_SWBP_ARM_INSN & 0x0fffffff), +- .cpsr_mask = MODE_MASK, ++ .cpsr_mask = (PSR_T_BIT | MODE_MASK), + .cpsr_val = USR_MODE, + .fn = uprobe_trap_handler, + }; +@@ -215,7 +215,7 @@ static struct undef_hook uprobes_arm_break_hook = { + static struct undef_hook uprobes_arm_ss_hook = { + .instr_mask = 0x0fffffff, + .instr_val = (UPROBE_SS_ARM_INSN & 0x0fffffff), +- .cpsr_mask = MODE_MASK, ++ .cpsr_mask = (PSR_T_BIT | MODE_MASK), + .cpsr_val = USR_MODE, + .fn = uprobe_trap_handler, + }; +diff --git a/arch/arm64/include/asm/alternative.h b/arch/arm64/include/asm/alternative.h +index 844f05b23115a..4fbbcdda70d76 100644 +--- a/arch/arm64/include/asm/alternative.h ++++ b/arch/arm64/include/asm/alternative.h +@@ -119,9 +119,9 @@ static inline void apply_alternatives_module(void *start, size_t length) { } + .popsection + .subsection 1 + 663: \insn2 +-664: .previous +- .org . - (664b-663b) + (662b-661b) ++664: .org . - (664b-663b) + (662b-661b) + .org . - (662b-661b) + (664b-663b) ++ .previous + .endif + .endm + +@@ -191,11 +191,11 @@ static inline void apply_alternatives_module(void *start, size_t length) { } + */ + .macro alternative_endif + 664: ++ .org . - (664b-663b) + (662b-661b) ++ .org . - (662b-661b) + (664b-663b) + .if .Lasm_alt_mode==0 + .previous + .endif +- .org . - (664b-663b) + (662b-661b) +- .org . - (662b-661b) + (664b-663b) + .endm + + /* +diff --git a/arch/arm64/include/asm/word-at-a-time.h b/arch/arm64/include/asm/word-at-a-time.h +index b0d708ff7f4e5..a2601c1ccf435 100644 +--- a/arch/arm64/include/asm/word-at-a-time.h ++++ b/arch/arm64/include/asm/word-at-a-time.h +@@ -64,7 +64,7 @@ static inline unsigned long find_zero(unsigned long mask) + */ + static inline unsigned long load_unaligned_zeropad(const void *addr) + { +- unsigned long ret, offset; ++ unsigned long ret, tmp; + + /* Load word from unaligned pointer addr */ + asm( +@@ -72,9 +72,9 @@ static inline unsigned long load_unaligned_zeropad(const void *addr) + "2:\n" + " .pushsection .fixup,\"ax\"\n" + " .align 2\n" +- "3: and %1, %2, #0x7\n" +- " bic %2, %2, #0x7\n" +- " ldr %0, [%2]\n" ++ "3: bic %1, %2, #0x7\n" ++ " ldr %0, [%1]\n" ++ " and %1, %2, #0x7\n" + " lsl %1, %1, #0x3\n" + #ifndef __AARCH64EB__ + " lsr %0, %0, %1\n" +@@ -84,7 +84,7 @@ static inline unsigned long load_unaligned_zeropad(const void *addr) + " b 2b\n" + " .popsection\n" + _ASM_EXTABLE(1b, 3b) +- : "=&r" (ret), "=&r" (offset) ++ : "=&r" (ret), "=&r" (tmp) + : "r" (addr), "Q" (*(unsigned long *)addr)); + + return ret; +diff --git a/arch/ia64/mm/discontig.c b/arch/ia64/mm/discontig.c +index 1928d5719e417..db3104c9fac53 100644 +--- a/arch/ia64/mm/discontig.c ++++ b/arch/ia64/mm/discontig.c +@@ -96,7 +96,7 @@ static int __init build_node_maps(unsigned long start, unsigned long len, + * acpi_boot_init() (which builds the node_to_cpu_mask array) hasn't been + * called yet. Note that node 0 will also count all non-existent cpus. + */ +-static int __meminit early_nr_cpus_node(int node) ++static int early_nr_cpus_node(int node) + { + int cpu, n = 0; + +@@ -111,7 +111,7 @@ static int __meminit early_nr_cpus_node(int node) + * compute_pernodesize - compute size of pernode data + * @node: the node id. + */ +-static unsigned long __meminit compute_pernodesize(int node) ++static unsigned long compute_pernodesize(int node) + { + unsigned long pernodesize = 0, cpus; + +@@ -371,7 +371,7 @@ static void __init reserve_pernode_space(void) + } + } + +-static void __meminit scatter_node_data(void) ++static void scatter_node_data(void) + { + pg_data_t **dst; + int node; +diff --git a/arch/s390/kernel/entry.S b/arch/s390/kernel/entry.S +index 150130c897c39..7e6a9cf863c73 100644 +--- a/arch/s390/kernel/entry.S ++++ b/arch/s390/kernel/entry.S +@@ -949,6 +949,7 @@ ENTRY(ext_int_handler) + * Load idle PSW. The second "half" of this function is in .Lcleanup_idle. + */ + ENTRY(psw_idle) ++ stg %r14,(__SF_GPRS+8*8)(%r15) + stg %r3,__SF_EMPTY(%r15) + larl %r1,.Lpsw_idle_lpsw+4 + stg %r1,__SF_EMPTY+8(%r15) +diff --git a/arch/x86/events/intel/uncore_snbep.c b/arch/x86/events/intel/uncore_snbep.c +index 8e4e8e423839a..c06074b847fa6 100644 +--- a/arch/x86/events/intel/uncore_snbep.c ++++ b/arch/x86/events/intel/uncore_snbep.c +@@ -1030,7 +1030,6 @@ enum { + SNBEP_PCI_QPI_PORT0_FILTER, + SNBEP_PCI_QPI_PORT1_FILTER, + BDX_PCI_QPI_PORT2_FILTER, +- HSWEP_PCI_PCU_3, + }; + + static int snbep_qpi_hw_config(struct intel_uncore_box *box, struct perf_event *event) +@@ -2687,22 +2686,33 @@ static struct intel_uncore_type *hswep_msr_uncores[] = { + NULL, + }; + +-void hswep_uncore_cpu_init(void) ++#define HSWEP_PCU_DID 0x2fc0 ++#define HSWEP_PCU_CAPID4_OFFET 0x94 ++#define hswep_get_chop(_cap) (((_cap) >> 6) & 0x3) ++ ++static bool hswep_has_limit_sbox(unsigned int device) + { +- int pkg = boot_cpu_data.logical_proc_id; ++ struct pci_dev *dev = pci_get_device(PCI_VENDOR_ID_INTEL, device, NULL); ++ u32 capid4; ++ ++ if (!dev) ++ return false; ++ ++ pci_read_config_dword(dev, HSWEP_PCU_CAPID4_OFFET, &capid4); ++ if (!hswep_get_chop(capid4)) ++ return true; + ++ return false; ++} ++ ++void hswep_uncore_cpu_init(void) ++{ + if (hswep_uncore_cbox.num_boxes > boot_cpu_data.x86_max_cores) + hswep_uncore_cbox.num_boxes = boot_cpu_data.x86_max_cores; + + /* Detect 6-8 core systems with only two SBOXes */ +- if (uncore_extra_pci_dev[pkg].dev[HSWEP_PCI_PCU_3]) { +- u32 capid4; +- +- pci_read_config_dword(uncore_extra_pci_dev[pkg].dev[HSWEP_PCI_PCU_3], +- 0x94, &capid4); +- if (((capid4 >> 6) & 0x3) == 0) +- hswep_uncore_sbox.num_boxes = 2; +- } ++ if (hswep_has_limit_sbox(HSWEP_PCU_DID)) ++ hswep_uncore_sbox.num_boxes = 2; + + uncore_msr_uncores = hswep_msr_uncores; + } +@@ -2965,11 +2975,6 @@ static const struct pci_device_id hswep_uncore_pci_ids[] = { + .driver_data = UNCORE_PCI_DEV_DATA(UNCORE_EXTRA_PCI_DEV, + SNBEP_PCI_QPI_PORT1_FILTER), + }, +- { /* PCU.3 (for Capability registers) */ +- PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x2fc0), +- .driver_data = UNCORE_PCI_DEV_DATA(UNCORE_EXTRA_PCI_DEV, +- HSWEP_PCI_PCU_3), +- }, + { /* end: all zeroes */ } + }; + +@@ -3061,27 +3066,18 @@ static struct event_constraint bdx_uncore_pcu_constraints[] = { + EVENT_CONSTRAINT_END + }; + ++#define BDX_PCU_DID 0x6fc0 ++ + void bdx_uncore_cpu_init(void) + { +- int pkg = topology_phys_to_logical_pkg(boot_cpu_data.phys_proc_id); +- + if (bdx_uncore_cbox.num_boxes > boot_cpu_data.x86_max_cores) + bdx_uncore_cbox.num_boxes = boot_cpu_data.x86_max_cores; + uncore_msr_uncores = bdx_msr_uncores; + +- /* BDX-DE doesn't have SBOX */ +- if (boot_cpu_data.x86_model == 86) { +- uncore_msr_uncores[BDX_MSR_UNCORE_SBOX] = NULL; + /* Detect systems with no SBOXes */ +- } else if (uncore_extra_pci_dev[pkg].dev[HSWEP_PCI_PCU_3]) { +- struct pci_dev *pdev; +- u32 capid4; +- +- pdev = uncore_extra_pci_dev[pkg].dev[HSWEP_PCI_PCU_3]; +- pci_read_config_dword(pdev, 0x94, &capid4); +- if (((capid4 >> 6) & 0x3) == 0) +- bdx_msr_uncores[BDX_MSR_UNCORE_SBOX] = NULL; +- } ++ if ((boot_cpu_data.x86_model == 86) || hswep_has_limit_sbox(BDX_PCU_DID)) ++ uncore_msr_uncores[BDX_MSR_UNCORE_SBOX] = NULL; ++ + hswep_uncore_pcu.constraints = bdx_uncore_pcu_constraints; + } + +@@ -3302,11 +3298,6 @@ static const struct pci_device_id bdx_uncore_pci_ids[] = { + .driver_data = UNCORE_PCI_DEV_DATA(UNCORE_EXTRA_PCI_DEV, + BDX_PCI_QPI_PORT2_FILTER), + }, +- { /* PCU.3 (for Capability registers) */ +- PCI_DEVICE(PCI_VENDOR_ID_INTEL, 0x6fc0), +- .driver_data = UNCORE_PCI_DEV_DATA(UNCORE_EXTRA_PCI_DEV, +- HSWEP_PCI_PCU_3), +- }, + { /* end: all zeroes */ } + }; + +diff --git a/arch/x86/kernel/crash.c b/arch/x86/kernel/crash.c +index f631a3f155875..91b3483e5085f 100644 +--- a/arch/x86/kernel/crash.c ++++ b/arch/x86/kernel/crash.c +@@ -356,7 +356,7 @@ int crash_setup_memmap_entries(struct kimage *image, struct boot_params *params) + struct crash_memmap_data cmd; + struct crash_mem *cmem; + +- cmem = vzalloc(sizeof(struct crash_mem)); ++ cmem = vzalloc(struct_size(cmem, ranges, 1)); + if (!cmem) + return -ENOMEM; + +diff --git a/drivers/dma/dw/Kconfig b/drivers/dma/dw/Kconfig +index 04b9728c1d269..070860ec0ef1d 100644 +--- a/drivers/dma/dw/Kconfig ++++ b/drivers/dma/dw/Kconfig +@@ -8,6 +8,7 @@ config DW_DMAC_CORE + + config DW_DMAC + tristate "Synopsys DesignWare AHB DMA platform driver" ++ depends on HAS_IOMEM + select DW_DMAC_CORE + help + Support the Synopsys DesignWare AHB DMA controller. This +@@ -16,6 +17,7 @@ config DW_DMAC + config DW_DMAC_PCI + tristate "Synopsys DesignWare AHB DMA PCI driver" + depends on PCI ++ depends on HAS_IOMEM + select DW_DMAC_CORE + help + Support the Synopsys DesignWare AHB DMA controller on the +diff --git a/drivers/gpio/gpiolib-sysfs.c b/drivers/gpio/gpiolib-sysfs.c +index 3dbaf489a8a52..e0ccc79b239a5 100644 +--- a/drivers/gpio/gpiolib-sysfs.c ++++ b/drivers/gpio/gpiolib-sysfs.c +@@ -462,6 +462,8 @@ static ssize_t export_store(struct class *class, + long gpio; + struct gpio_desc *desc; + int status; ++ struct gpio_chip *gc; ++ int offset; + + status = kstrtol(buf, 0, &gpio); + if (status < 0) +@@ -473,6 +475,12 @@ static ssize_t export_store(struct class *class, + pr_warn("%s: invalid GPIO %ld\n", __func__, gpio); + return -EINVAL; + } ++ gc = desc->gdev->chip; ++ offset = gpio_chip_hwgpio(desc); ++ if (!gpiochip_line_is_valid(gc, offset)) { ++ pr_warn("%s: GPIO %ld masked\n", __func__, gpio); ++ return -EINVAL; ++ } + + /* No extra locking here; FLAG_SYSFS just signifies that the + * request and export were done by on behalf of userspace, so +diff --git a/drivers/gpu/drm/msm/adreno/a5xx_gpu.c b/drivers/gpu/drm/msm/adreno/a5xx_gpu.c +index 776bbe9775e9d..ba513018534e3 100644 +--- a/drivers/gpu/drm/msm/adreno/a5xx_gpu.c ++++ b/drivers/gpu/drm/msm/adreno/a5xx_gpu.c +@@ -1194,8 +1194,8 @@ static int a5xx_pm_suspend(struct msm_gpu *gpu) + + static int a5xx_get_timestamp(struct msm_gpu *gpu, uint64_t *value) + { +- *value = gpu_read64(gpu, REG_A5XX_RBBM_PERFCTR_CP_0_LO, +- REG_A5XX_RBBM_PERFCTR_CP_0_HI); ++ *value = gpu_read64(gpu, REG_A5XX_RBBM_ALWAYSON_COUNTER_LO, ++ REG_A5XX_RBBM_ALWAYSON_COUNTER_HI); + + return 0; + } +diff --git a/drivers/gpu/drm/msm/adreno/a6xx_gpu.c b/drivers/gpu/drm/msm/adreno/a6xx_gpu.c +index c629f742a1d19..c280fdc44939f 100644 +--- a/drivers/gpu/drm/msm/adreno/a6xx_gpu.c ++++ b/drivers/gpu/drm/msm/adreno/a6xx_gpu.c +@@ -713,8 +713,8 @@ static int a6xx_get_timestamp(struct msm_gpu *gpu, uint64_t *value) + /* Force the GPU power on so we can read this register */ + a6xx_gmu_set_oob(&a6xx_gpu->gmu, GMU_OOB_GPU_SET); + +- *value = gpu_read64(gpu, REG_A6XX_RBBM_PERFCTR_CP_0_LO, +- REG_A6XX_RBBM_PERFCTR_CP_0_HI); ++ *value = gpu_read64(gpu, REG_A6XX_CP_ALWAYS_ON_COUNTER_LO, ++ REG_A6XX_CP_ALWAYS_ON_COUNTER_HI); + + a6xx_gmu_clear_oob(&a6xx_gpu->gmu, GMU_OOB_GPU_SET); + return 0; +diff --git a/drivers/hid/hid-alps.c b/drivers/hid/hid-alps.c +index f4cf541d13e08..3eddd8f73b577 100644 +--- a/drivers/hid/hid-alps.c ++++ b/drivers/hid/hid-alps.c +@@ -766,6 +766,7 @@ static int alps_input_configured(struct hid_device *hdev, struct hid_input *hi) + + if (input_register_device(data->input2)) { + input_free_device(input2); ++ ret = -ENOENT; + goto exit; + } + } +diff --git a/drivers/hid/hid-google-hammer.c b/drivers/hid/hid-google-hammer.c +index fab8fd7082e04..3e58d4c3cf2c0 100644 +--- a/drivers/hid/hid-google-hammer.c ++++ b/drivers/hid/hid-google-hammer.c +@@ -118,6 +118,8 @@ static int hammer_input_configured(struct hid_device *hdev, + } + + static const struct hid_device_id hammer_devices[] = { ++ { HID_DEVICE(BUS_USB, HID_GROUP_GENERIC, ++ USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_DON) }, + { HID_DEVICE(BUS_USB, HID_GROUP_GENERIC, + USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_HAMMER) }, + { HID_DEVICE(BUS_USB, HID_GROUP_GENERIC, +diff --git a/drivers/hid/hid-ids.h b/drivers/hid/hid-ids.h +index 2f1516b328372..68908dac5835e 100644 +--- a/drivers/hid/hid-ids.h ++++ b/drivers/hid/hid-ids.h +@@ -478,6 +478,7 @@ + #define USB_DEVICE_ID_GOOGLE_MASTERBALL 0x503c + #define USB_DEVICE_ID_GOOGLE_MAGNEMITE 0x503d + #define USB_DEVICE_ID_GOOGLE_MOONBALL 0x5044 ++#define USB_DEVICE_ID_GOOGLE_DON 0x5050 + + #define USB_VENDOR_ID_GOTOP 0x08f2 + #define USB_DEVICE_ID_SUPER_Q2 0x007f +diff --git a/drivers/hid/wacom_wac.c b/drivers/hid/wacom_wac.c +index 274a55702784a..10524c93f8b62 100644 +--- a/drivers/hid/wacom_wac.c ++++ b/drivers/hid/wacom_wac.c +@@ -2496,7 +2496,7 @@ static void wacom_wac_finger_slot(struct wacom_wac *wacom_wac, + !wacom_wac->shared->is_touch_on) { + if (!wacom_wac->shared->touch_down) + return; +- prox = 0; ++ prox = false; + } + + wacom_wac->hid_data.num_received++; +@@ -3528,8 +3528,6 @@ int wacom_setup_pen_input_capabilities(struct input_dev *input_dev, + { + struct wacom_features *features = &wacom_wac->features; + +- input_dev->evbit[0] |= BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS); +- + if (!(features->device_type & WACOM_DEVICETYPE_PEN)) + return -ENODEV; + +@@ -3544,6 +3542,7 @@ int wacom_setup_pen_input_capabilities(struct input_dev *input_dev, + return 0; + } + ++ input_dev->evbit[0] |= BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS); + __set_bit(BTN_TOUCH, input_dev->keybit); + __set_bit(ABS_MISC, input_dev->absbit); + +@@ -3694,8 +3693,6 @@ int wacom_setup_touch_input_capabilities(struct input_dev *input_dev, + { + struct wacom_features *features = &wacom_wac->features; + +- input_dev->evbit[0] |= BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS); +- + if (!(features->device_type & WACOM_DEVICETYPE_TOUCH)) + return -ENODEV; + +@@ -3708,6 +3705,7 @@ int wacom_setup_touch_input_capabilities(struct input_dev *input_dev, + /* setup has already been done */ + return 0; + ++ input_dev->evbit[0] |= BIT_MASK(EV_KEY) | BIT_MASK(EV_ABS); + __set_bit(BTN_TOUCH, input_dev->keybit); + + if (features->touch_max == 1) { +diff --git a/drivers/input/keyboard/nspire-keypad.c b/drivers/input/keyboard/nspire-keypad.c +index c7f26fa3034ca..cf138d836eec6 100644 +--- a/drivers/input/keyboard/nspire-keypad.c ++++ b/drivers/input/keyboard/nspire-keypad.c +@@ -96,9 +96,15 @@ static irqreturn_t nspire_keypad_irq(int irq, void *dev_id) + return IRQ_HANDLED; + } + +-static int nspire_keypad_chip_init(struct nspire_keypad *keypad) ++static int nspire_keypad_open(struct input_dev *input) + { ++ struct nspire_keypad *keypad = input_get_drvdata(input); + unsigned long val = 0, cycles_per_us, delay_cycles, row_delay_cycles; ++ int error; ++ ++ error = clk_prepare_enable(keypad->clk); ++ if (error) ++ return error; + + cycles_per_us = (clk_get_rate(keypad->clk) / 1000000); + if (cycles_per_us == 0) +@@ -124,30 +130,6 @@ static int nspire_keypad_chip_init(struct nspire_keypad *keypad) + keypad->int_mask = 1 << 1; + writel(keypad->int_mask, keypad->reg_base + KEYPAD_INTMSK); + +- /* Disable GPIO interrupts to prevent hanging on touchpad */ +- /* Possibly used to detect touchpad events */ +- writel(0, keypad->reg_base + KEYPAD_UNKNOWN_INT); +- /* Acknowledge existing interrupts */ +- writel(~0, keypad->reg_base + KEYPAD_UNKNOWN_INT_STS); +- +- return 0; +-} +- +-static int nspire_keypad_open(struct input_dev *input) +-{ +- struct nspire_keypad *keypad = input_get_drvdata(input); +- int error; +- +- error = clk_prepare_enable(keypad->clk); +- if (error) +- return error; +- +- error = nspire_keypad_chip_init(keypad); +- if (error) { +- clk_disable_unprepare(keypad->clk); +- return error; +- } +- + return 0; + } + +@@ -155,6 +137,11 @@ static void nspire_keypad_close(struct input_dev *input) + { + struct nspire_keypad *keypad = input_get_drvdata(input); + ++ /* Disable interrupts */ ++ writel(0, keypad->reg_base + KEYPAD_INTMSK); ++ /* Acknowledge existing interrupts */ ++ writel(~0, keypad->reg_base + KEYPAD_INT); ++ + clk_disable_unprepare(keypad->clk); + } + +@@ -215,6 +202,25 @@ static int nspire_keypad_probe(struct platform_device *pdev) + return -ENOMEM; + } + ++ error = clk_prepare_enable(keypad->clk); ++ if (error) { ++ dev_err(&pdev->dev, "failed to enable clock\n"); ++ return error; ++ } ++ ++ /* Disable interrupts */ ++ writel(0, keypad->reg_base + KEYPAD_INTMSK); ++ /* Acknowledge existing interrupts */ ++ writel(~0, keypad->reg_base + KEYPAD_INT); ++ ++ /* Disable GPIO interrupts to prevent hanging on touchpad */ ++ /* Possibly used to detect touchpad events */ ++ writel(0, keypad->reg_base + KEYPAD_UNKNOWN_INT); ++ /* Acknowledge existing GPIO interrupts */ ++ writel(~0, keypad->reg_base + KEYPAD_UNKNOWN_INT_STS); ++ ++ clk_disable_unprepare(keypad->clk); ++ + input_set_drvdata(input, keypad); + + input->id.bustype = BUS_HOST; +diff --git a/drivers/input/serio/i8042-x86ia64io.h b/drivers/input/serio/i8042-x86ia64io.h +index 0463ab79160b7..f20e54f41dde9 100644 +--- a/drivers/input/serio/i8042-x86ia64io.h ++++ b/drivers/input/serio/i8042-x86ia64io.h +@@ -592,6 +592,7 @@ static const struct dmi_system_id i8042_dmi_noselftest_table[] = { + DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."), + DMI_MATCH(DMI_CHASSIS_TYPE, "10"), /* Notebook */ + }, ++ }, { + .matches = { + DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."), + DMI_MATCH(DMI_CHASSIS_TYPE, "31"), /* Convertible Notebook */ +diff --git a/drivers/input/touchscreen/s6sy761.c b/drivers/input/touchscreen/s6sy761.c +index b63d7fdf0cd20..85a1f465c097e 100644 +--- a/drivers/input/touchscreen/s6sy761.c ++++ b/drivers/input/touchscreen/s6sy761.c +@@ -145,8 +145,8 @@ static void s6sy761_report_coordinates(struct s6sy761_data *sdata, + u8 major = event[4]; + u8 minor = event[5]; + u8 z = event[6] & S6SY761_MASK_Z; +- u16 x = (event[1] << 3) | ((event[3] & S6SY761_MASK_X) >> 4); +- u16 y = (event[2] << 3) | (event[3] & S6SY761_MASK_Y); ++ u16 x = (event[1] << 4) | ((event[3] & S6SY761_MASK_X) >> 4); ++ u16 y = (event[2] << 4) | (event[3] & S6SY761_MASK_Y); + + input_mt_slot(sdata->input, tid); + +diff --git a/drivers/md/dm-verity-fec.c b/drivers/md/dm-verity-fec.c +index dd7684333d90a..a433f5824f188 100644 +--- a/drivers/md/dm-verity-fec.c ++++ b/drivers/md/dm-verity-fec.c +@@ -69,7 +69,7 @@ static u8 *fec_read_parity(struct dm_verity *v, u64 rsb, int index, + u8 *res; + + position = (index + rsb) * v->fec->roots; +- block = div64_u64_rem(position, v->fec->roots << SECTOR_SHIFT, &rem); ++ block = div64_u64_rem(position, v->fec->io_size, &rem); + *offset = (unsigned)rem; + + res = dm_bufio_read(v->fec->bufio, block, buf); +@@ -158,7 +158,7 @@ static int fec_decode_bufs(struct dm_verity *v, struct dm_verity_fec_io *fio, + + /* read the next block when we run out of parity bytes */ + offset += v->fec->roots; +- if (offset >= v->fec->roots << SECTOR_SHIFT) { ++ if (offset >= v->fec->io_size) { + dm_bufio_release(buf); + + par = fec_read_parity(v, rsb, block_offset, &offset, &buf); +@@ -743,8 +743,13 @@ int verity_fec_ctr(struct dm_verity *v) + return -E2BIG; + } + ++ if ((f->roots << SECTOR_SHIFT) & ((1 << v->data_dev_block_bits) - 1)) ++ f->io_size = 1 << v->data_dev_block_bits; ++ else ++ f->io_size = v->fec->roots << SECTOR_SHIFT; ++ + f->bufio = dm_bufio_client_create(f->dev->bdev, +- f->roots << SECTOR_SHIFT, ++ f->io_size, + 1, 0, NULL, NULL); + if (IS_ERR(f->bufio)) { + ti->error = "Cannot initialize FEC bufio client"; +diff --git a/drivers/md/dm-verity-fec.h b/drivers/md/dm-verity-fec.h +index 6ad803b2b36ca..b9f0bb0f63c42 100644 +--- a/drivers/md/dm-verity-fec.h ++++ b/drivers/md/dm-verity-fec.h +@@ -40,6 +40,7 @@ struct dm_verity_fec { + struct dm_dev *dev; /* parity data device */ + struct dm_bufio_client *data_bufio; /* for data dev access */ + struct dm_bufio_client *bufio; /* for parity data access */ ++ size_t io_size; /* IO size for roots */ + sector_t start; /* parity data start in blocks */ + sector_t blocks; /* number of blocks covered */ + sector_t rounds; /* number of interleaving rounds */ +diff --git a/drivers/net/dsa/mv88e6xxx/chip.c b/drivers/net/dsa/mv88e6xxx/chip.c +index e04b7fa068aff..67c0ad3b80795 100644 +--- a/drivers/net/dsa/mv88e6xxx/chip.c ++++ b/drivers/net/dsa/mv88e6xxx/chip.c +@@ -2634,10 +2634,17 @@ unlock: + return err; + } + ++/* prod_id for switch families which do not have a PHY model number */ ++static const u16 family_prod_id_table[] = { ++ [MV88E6XXX_FAMILY_6341] = MV88E6XXX_PORT_SWITCH_ID_PROD_6341, ++ [MV88E6XXX_FAMILY_6390] = MV88E6XXX_PORT_SWITCH_ID_PROD_6390, ++}; ++ + static int mv88e6xxx_mdio_read(struct mii_bus *bus, int phy, int reg) + { + struct mv88e6xxx_mdio_bus *mdio_bus = bus->priv; + struct mv88e6xxx_chip *chip = mdio_bus->chip; ++ u16 prod_id; + u16 val; + int err; + +@@ -2648,23 +2655,12 @@ static int mv88e6xxx_mdio_read(struct mii_bus *bus, int phy, int reg) + err = chip->info->ops->phy_read(chip, bus, phy, reg, &val); + mutex_unlock(&chip->reg_lock); + +- if (reg == MII_PHYSID2) { +- /* Some internal PHYs don't have a model number. */ +- if (chip->info->family != MV88E6XXX_FAMILY_6165) +- /* Then there is the 6165 family. It gets is +- * PHYs correct. But it can also have two +- * SERDES interfaces in the PHY address +- * space. And these don't have a model +- * number. But they are not PHYs, so we don't +- * want to give them something a PHY driver +- * will recognise. +- * +- * Use the mv88e6390 family model number +- * instead, for anything which really could be +- * a PHY, +- */ +- if (!(val & 0x3f0)) +- val |= MV88E6XXX_PORT_SWITCH_ID_PROD_6390 >> 4; ++ /* Some internal PHYs don't have a model number. */ ++ if (reg == MII_PHYSID2 && !(val & 0x3f0) && ++ chip->info->family < ARRAY_SIZE(family_prod_id_table)) { ++ prod_id = family_prod_id_table[chip->info->family]; ++ if (prod_id) ++ val |= prod_id >> 4; + } + + return err ? err : val; +diff --git a/drivers/net/ethernet/amd/pcnet32.c b/drivers/net/ethernet/amd/pcnet32.c +index f5ad12c109344..da84660ceae1f 100644 +--- a/drivers/net/ethernet/amd/pcnet32.c ++++ b/drivers/net/ethernet/amd/pcnet32.c +@@ -1548,8 +1548,7 @@ pcnet32_probe_pci(struct pci_dev *pdev, const struct pci_device_id *ent) + } + pci_set_master(pdev); + +- ioaddr = pci_resource_start(pdev, 0); +- if (!ioaddr) { ++ if (!pci_resource_len(pdev, 0)) { + if (pcnet32_debug & NETIF_MSG_PROBE) + pr_err("card has no PCI IO resources, aborting\n"); + err = -ENODEV; +@@ -1562,6 +1561,8 @@ pcnet32_probe_pci(struct pci_dev *pdev, const struct pci_device_id *ent) + pr_err("architecture does not support 32bit PCI busmaster DMA\n"); + goto err_disable_dev; + } ++ ++ ioaddr = pci_resource_start(pdev, 0); + if (!request_region(ioaddr, PCNET32_TOTAL_SIZE, "pcnet32_probe_pci")) { + if (pcnet32_debug & NETIF_MSG_PROBE) + pr_err("io address range already allocated\n"); +diff --git a/drivers/net/ethernet/cavium/liquidio/cn66xx_regs.h b/drivers/net/ethernet/cavium/liquidio/cn66xx_regs.h +index b248966837b4c..7aad40b2aa736 100644 +--- a/drivers/net/ethernet/cavium/liquidio/cn66xx_regs.h ++++ b/drivers/net/ethernet/cavium/liquidio/cn66xx_regs.h +@@ -412,7 +412,7 @@ + | CN6XXX_INTR_M0UNWI_ERR \ + | CN6XXX_INTR_M1UPB0_ERR \ + | CN6XXX_INTR_M1UPWI_ERR \ +- | CN6XXX_INTR_M1UPB0_ERR \ ++ | CN6XXX_INTR_M1UNB0_ERR \ + | CN6XXX_INTR_M1UNWI_ERR \ + | CN6XXX_INTR_INSTR_DB_OF_ERR \ + | CN6XXX_INTR_SLIST_DB_OF_ERR \ +diff --git a/drivers/net/ethernet/davicom/dm9000.c b/drivers/net/ethernet/davicom/dm9000.c +index a339ea2fd4961..8b07890b0b232 100644 +--- a/drivers/net/ethernet/davicom/dm9000.c ++++ b/drivers/net/ethernet/davicom/dm9000.c +@@ -1482,8 +1482,10 @@ dm9000_probe(struct platform_device *pdev) + + /* Init network device */ + ndev = alloc_etherdev(sizeof(struct board_info)); +- if (!ndev) +- return -ENOMEM; ++ if (!ndev) { ++ ret = -ENOMEM; ++ goto out_regulator_disable; ++ } + + SET_NETDEV_DEV(ndev, &pdev->dev); + +diff --git a/drivers/net/ethernet/ibm/ibmvnic.c b/drivers/net/ethernet/ibm/ibmvnic.c +index 0c7c0206b1be5..9f72cd3b1d244 100644 +--- a/drivers/net/ethernet/ibm/ibmvnic.c ++++ b/drivers/net/ethernet/ibm/ibmvnic.c +@@ -1092,19 +1092,13 @@ static int __ibmvnic_open(struct net_device *netdev) + + rc = set_link_state(adapter, IBMVNIC_LOGICAL_LNK_UP); + if (rc) { +- for (i = 0; i < adapter->req_rx_queues; i++) +- napi_disable(&adapter->napi[i]); ++ ibmvnic_napi_disable(adapter); + release_resources(adapter); + return rc; + } + + netif_tx_start_all_queues(netdev); + +- if (prev_state == VNIC_CLOSED) { +- for (i = 0; i < adapter->req_rx_queues; i++) +- napi_schedule(&adapter->napi[i]); +- } +- + adapter->state = VNIC_OPEN; + return rc; + } +@@ -1761,7 +1755,7 @@ static int do_reset(struct ibmvnic_adapter *adapter, + u64 old_num_rx_queues, old_num_tx_queues; + u64 old_num_rx_slots, old_num_tx_slots; + struct net_device *netdev = adapter->netdev; +- int i, rc; ++ int rc; + + netdev_dbg(adapter->netdev, "Re-setting driver (%d)\n", + rwi->reset_reason); +@@ -1879,10 +1873,6 @@ static int do_reset(struct ibmvnic_adapter *adapter, + /* refresh device's multicast list */ + ibmvnic_set_multi(netdev); + +- /* kick napi */ +- for (i = 0; i < adapter->req_rx_queues; i++) +- napi_schedule(&adapter->napi[i]); +- + if (adapter->reset_reason != VNIC_RESET_FAILOVER && + adapter->reset_reason != VNIC_RESET_CHANGE_PARAM) { + call_netdevice_notifiers(NETDEV_NOTIFY_PEERS, netdev); +diff --git a/drivers/net/ethernet/intel/i40e/i40e_main.c b/drivers/net/ethernet/intel/i40e/i40e_main.c +index 1591f81d8ae3b..fa0e7582159ff 100644 +--- a/drivers/net/ethernet/intel/i40e/i40e_main.c ++++ b/drivers/net/ethernet/intel/i40e/i40e_main.c +@@ -11211,6 +11211,7 @@ static int i40e_sw_init(struct i40e_pf *pf) + { + int err = 0; + int size; ++ u16 pow; + + /* Set default capability flags */ + pf->flags = I40E_FLAG_RX_CSUM_ENABLED | +@@ -11229,6 +11230,11 @@ static int i40e_sw_init(struct i40e_pf *pf) + pf->rss_table_size = pf->hw.func_caps.rss_table_size; + pf->rss_size_max = min_t(int, pf->rss_size_max, + pf->hw.func_caps.num_tx_qp); ++ ++ /* find the next higher power-of-2 of num cpus */ ++ pow = roundup_pow_of_two(num_online_cpus()); ++ pf->rss_size_max = min_t(int, pf->rss_size_max, pow); ++ + if (pf->hw.func_caps.rss) { + pf->flags |= I40E_FLAG_RSS_ENABLED; + pf->alloc_rss_size = min_t(int, pf->rss_size_max, +diff --git a/drivers/net/geneve.c b/drivers/net/geneve.c +index 2e2afc824a6a8..ce6fecf421f86 100644 +--- a/drivers/net/geneve.c ++++ b/drivers/net/geneve.c +@@ -839,6 +839,9 @@ static int geneve_xmit_skb(struct sk_buff *skb, struct net_device *dev, + __be16 df; + int err; + ++ if (!pskb_network_may_pull(skb, sizeof(struct iphdr))) ++ return -EINVAL; ++ + sport = udp_flow_src_port(geneve->net, skb, 1, USHRT_MAX, true); + rt = geneve_get_v4_rt(skb, dev, gs4, &fl4, info, + geneve->info.key.tp_dst, sport); +@@ -882,6 +885,9 @@ static int geneve6_xmit_skb(struct sk_buff *skb, struct net_device *dev, + __be16 sport; + int err; + ++ if (!pskb_network_may_pull(skb, sizeof(struct ipv6hdr))) ++ return -EINVAL; ++ + sport = udp_flow_src_port(geneve->net, skb, 1, USHRT_MAX, true); + dst = geneve_get_v6_dst(skb, dev, gs6, &fl6, info, + geneve->info.key.tp_dst, sport); +diff --git a/drivers/net/phy/marvell.c b/drivers/net/phy/marvell.c +index bb6107f3b947b..832a401c5fa56 100644 +--- a/drivers/net/phy/marvell.c ++++ b/drivers/net/phy/marvell.c +@@ -2329,9 +2329,30 @@ static struct phy_driver marvell_drivers[] = { + .get_stats = marvell_get_stats, + }, + { +- .phy_id = MARVELL_PHY_ID_88E6390, ++ .phy_id = MARVELL_PHY_ID_88E6341_FAMILY, + .phy_id_mask = MARVELL_PHY_ID_MASK, +- .name = "Marvell 88E6390", ++ .name = "Marvell 88E6341 Family", ++ .features = PHY_GBIT_FEATURES, ++ .flags = PHY_HAS_INTERRUPT, ++ .probe = m88e1510_probe, ++ .config_init = &marvell_config_init, ++ .config_aneg = &m88e6390_config_aneg, ++ .read_status = &marvell_read_status, ++ .ack_interrupt = &marvell_ack_interrupt, ++ .config_intr = &marvell_config_intr, ++ .did_interrupt = &m88e1121_did_interrupt, ++ .resume = &genphy_resume, ++ .suspend = &genphy_suspend, ++ .read_page = marvell_read_page, ++ .write_page = marvell_write_page, ++ .get_sset_count = marvell_get_sset_count, ++ .get_strings = marvell_get_strings, ++ .get_stats = marvell_get_stats, ++ }, ++ { ++ .phy_id = MARVELL_PHY_ID_88E6390_FAMILY, ++ .phy_id_mask = MARVELL_PHY_ID_MASK, ++ .name = "Marvell 88E6390 Family", + .features = PHY_GBIT_FEATURES, + .flags = PHY_HAS_INTERRUPT, + .probe = m88e6390_probe, +@@ -2368,7 +2389,8 @@ static struct mdio_device_id __maybe_unused marvell_tbl[] = { + { MARVELL_PHY_ID_88E1540, MARVELL_PHY_ID_MASK }, + { MARVELL_PHY_ID_88E1545, MARVELL_PHY_ID_MASK }, + { MARVELL_PHY_ID_88E3016, MARVELL_PHY_ID_MASK }, +- { MARVELL_PHY_ID_88E6390, MARVELL_PHY_ID_MASK }, ++ { MARVELL_PHY_ID_88E6341_FAMILY, MARVELL_PHY_ID_MASK }, ++ { MARVELL_PHY_ID_88E6390_FAMILY, MARVELL_PHY_ID_MASK }, + { } + }; + +diff --git a/drivers/net/usb/hso.c b/drivers/net/usb/hso.c +index 2eb33d2bb7ad4..94f1c2422f844 100644 +--- a/drivers/net/usb/hso.c ++++ b/drivers/net/usb/hso.c +@@ -3114,7 +3114,7 @@ static void hso_free_interface(struct usb_interface *interface) + cancel_work_sync(&serial_table[i]->async_put_intf); + cancel_work_sync(&serial_table[i]->async_get_intf); + hso_serial_tty_unregister(serial); +- kref_put(&serial_table[i]->ref, hso_serial_ref_free); ++ kref_put(&serial->parent->ref, hso_serial_ref_free); + } + } + +diff --git a/drivers/net/xen-netback/xenbus.c b/drivers/net/xen-netback/xenbus.c +index 107bbd4ae825e..78c56149559ce 100644 +--- a/drivers/net/xen-netback/xenbus.c ++++ b/drivers/net/xen-netback/xenbus.c +@@ -1043,11 +1043,15 @@ static void connect(struct backend_info *be) + xenvif_carrier_on(be->vif); + + unregister_hotplug_status_watch(be); +- err = xenbus_watch_pathfmt(dev, &be->hotplug_status_watch, NULL, +- hotplug_status_changed, +- "%s/%s", dev->nodename, "hotplug-status"); +- if (!err) ++ if (xenbus_exists(XBT_NIL, dev->nodename, "hotplug-status")) { ++ err = xenbus_watch_pathfmt(dev, &be->hotplug_status_watch, ++ NULL, hotplug_status_changed, ++ "%s/%s", dev->nodename, ++ "hotplug-status"); ++ if (err) ++ goto err; + be->have_hotplug_status_watch = 1; ++ } + + netif_tx_wake_all_queues(be->vif->dev); + +diff --git a/drivers/pinctrl/intel/pinctrl-lewisburg.c b/drivers/pinctrl/intel/pinctrl-lewisburg.c +index dc32c22bf19fa..8388aa671b21a 100644 +--- a/drivers/pinctrl/intel/pinctrl-lewisburg.c ++++ b/drivers/pinctrl/intel/pinctrl-lewisburg.c +@@ -297,9 +297,9 @@ static const struct pinctrl_pin_desc lbg_pins[] = { + static const struct intel_community lbg_communities[] = { + LBG_COMMUNITY(0, 0, 71), + LBG_COMMUNITY(1, 72, 132), +- LBG_COMMUNITY(3, 133, 144), +- LBG_COMMUNITY(4, 145, 180), +- LBG_COMMUNITY(5, 181, 246), ++ LBG_COMMUNITY(3, 133, 143), ++ LBG_COMMUNITY(4, 144, 178), ++ LBG_COMMUNITY(5, 179, 246), + }; + + static const struct intel_pinctrl_soc_data lbg_soc_data = { +diff --git a/drivers/scsi/libsas/sas_ata.c b/drivers/scsi/libsas/sas_ata.c +index d82698b7dfe6c..e032af6547334 100644 +--- a/drivers/scsi/libsas/sas_ata.c ++++ b/drivers/scsi/libsas/sas_ata.c +@@ -215,18 +215,17 @@ static unsigned int sas_ata_qc_issue(struct ata_queued_cmd *qc) + memcpy(task->ata_task.atapi_packet, qc->cdb, qc->dev->cdb_len); + task->total_xfer_len = qc->nbytes; + task->num_scatter = qc->n_elem; ++ task->data_dir = qc->dma_dir; ++ } else if (qc->tf.protocol == ATA_PROT_NODATA) { ++ task->data_dir = DMA_NONE; + } else { + for_each_sg(qc->sg, sg, qc->n_elem, si) + xfer += sg_dma_len(sg); + + task->total_xfer_len = xfer; + task->num_scatter = si; +- } +- +- if (qc->tf.protocol == ATA_PROT_NODATA) +- task->data_dir = DMA_NONE; +- else + task->data_dir = qc->dma_dir; ++ } + task->scatter = qc->sg; + task->ata_task.retry_count = 1; + task->task_state_flags = SAS_TASK_STATE_PENDING; +diff --git a/drivers/scsi/scsi_transport_srp.c b/drivers/scsi/scsi_transport_srp.c +index 2aaf1b7103981..9ac89462a8e02 100644 +--- a/drivers/scsi/scsi_transport_srp.c ++++ b/drivers/scsi/scsi_transport_srp.c +@@ -555,7 +555,7 @@ int srp_reconnect_rport(struct srp_rport *rport) + res = mutex_lock_interruptible(&rport->mutex); + if (res) + goto out; +- if (rport->state != SRP_RPORT_FAIL_FAST) ++ if (rport->state != SRP_RPORT_FAIL_FAST && rport->state != SRP_RPORT_LOST) + /* + * sdev state must be SDEV_TRANSPORT_OFFLINE, transition + * to SDEV_BLOCK is illegal. Calling scsi_target_unblock() +diff --git a/drivers/usb/class/cdc-acm.c b/drivers/usb/class/cdc-acm.c +index a1fa16a03ab9d..7f4f21ba8efcf 100644 +--- a/drivers/usb/class/cdc-acm.c ++++ b/drivers/usb/class/cdc-acm.c +@@ -1682,12 +1682,13 @@ static int acm_resume(struct usb_interface *intf) + struct urb *urb; + int rv = 0; + +- acm_unpoison_urbs(acm); + spin_lock_irq(&acm->write_lock); + + if (--acm->susp_count) + goto out; + ++ acm_unpoison_urbs(acm); ++ + if (tty_port_initialized(&acm->port)) { + rv = usb_submit_urb(acm->ctrlurb, GFP_ATOMIC); + +diff --git a/fs/readdir.c b/fs/readdir.c +index 443270f635f43..3c5ce8a0ddc99 100644 +--- a/fs/readdir.c ++++ b/fs/readdir.c +@@ -132,6 +132,9 @@ static int fillonedir(struct dir_context *ctx, const char *name, int namlen, + + if (buf->result) + return -EINVAL; ++ buf->result = verify_dirent_name(name, namlen); ++ if (buf->result < 0) ++ return buf->result; + d_ino = ino; + if (sizeof(d_ino) < sizeof(ino) && d_ino != ino) { + buf->result = -EOVERFLOW; +@@ -398,6 +401,9 @@ static int compat_fillonedir(struct dir_context *ctx, const char *name, + + if (buf->result) + return -EINVAL; ++ buf->result = verify_dirent_name(name, namlen); ++ if (buf->result < 0) ++ return buf->result; + d_ino = ino; + if (sizeof(d_ino) < sizeof(ino) && d_ino != ino) { + buf->result = -EOVERFLOW; +diff --git a/include/linux/marvell_phy.h b/include/linux/marvell_phy.h +index 1eb6f244588da..9a488497ebc29 100644 +--- a/include/linux/marvell_phy.h ++++ b/include/linux/marvell_phy.h +@@ -21,11 +21,12 @@ + #define MARVELL_PHY_ID_88E1545 0x01410ea0 + #define MARVELL_PHY_ID_88E3016 0x01410e60 + +-/* The MV88e6390 Ethernet switch contains embedded PHYs. These PHYs do ++/* These Ethernet switch families contain embedded PHYs, but they do + * not have a model ID. So the switch driver traps reads to the ID2 + * register and returns the switch family ID + */ +-#define MARVELL_PHY_ID_88E6390 0x01410f90 ++#define MARVELL_PHY_ID_88E6341_FAMILY 0x01410f41 ++#define MARVELL_PHY_ID_88E6390_FAMILY 0x01410f90 + + #define MARVELL_PHY_FAMILY_ID(id) ((id) >> 4) + +diff --git a/kernel/locking/lockdep.c b/kernel/locking/lockdep.c +index 8a1758b094b70..126c6d524a0f2 100644 +--- a/kernel/locking/lockdep.c ++++ b/kernel/locking/lockdep.c +@@ -722,7 +722,8 @@ static bool assign_lock_key(struct lockdep_map *lock) + /* Debug-check: all keys must be persistent! */ + debug_locks_off(); + pr_err("INFO: trying to register non-static key.\n"); +- pr_err("the code is fine but needs lockdep annotation.\n"); ++ pr_err("The code is fine but needs lockdep annotation, or maybe\n"); ++ pr_err("you didn't initialize this object before use?\n"); + pr_err("turning off the locking correctness validator.\n"); + dump_stack(); + return false; +diff --git a/kernel/locking/qrwlock.c b/kernel/locking/qrwlock.c +index c7471c3fb7989..16c09cda3b02e 100644 +--- a/kernel/locking/qrwlock.c ++++ b/kernel/locking/qrwlock.c +@@ -70,6 +70,8 @@ EXPORT_SYMBOL(queued_read_lock_slowpath); + */ + void queued_write_lock_slowpath(struct qrwlock *lock) + { ++ int cnts; ++ + /* Put the writer into the wait queue */ + arch_spin_lock(&lock->wait_lock); + +@@ -83,9 +85,8 @@ void queued_write_lock_slowpath(struct qrwlock *lock) + + /* When no more readers or writers, set the locked flag */ + do { +- atomic_cond_read_acquire(&lock->cnts, VAL == _QW_WAITING); +- } while (atomic_cmpxchg_relaxed(&lock->cnts, _QW_WAITING, +- _QW_LOCKED) != _QW_WAITING); ++ cnts = atomic_cond_read_relaxed(&lock->cnts, VAL == _QW_WAITING); ++ } while (!atomic_try_cmpxchg_acquire(&lock->cnts, &cnts, _QW_LOCKED)); + unlock: + arch_spin_unlock(&lock->wait_lock); + } +diff --git a/mm/gup.c b/mm/gup.c +index f3088d25bd926..44569927f0ea1 100644 +--- a/mm/gup.c ++++ b/mm/gup.c +@@ -61,13 +61,22 @@ static int follow_pfn_pte(struct vm_area_struct *vma, unsigned long address, + } + + /* +- * FOLL_FORCE can write to even unwritable pte's, but only +- * after we've gone through a COW cycle and they are dirty. ++ * FOLL_FORCE or a forced COW break can write even to unwritable pte's, ++ * but only after we've gone through a COW cycle and they are dirty. + */ + static inline bool can_follow_write_pte(pte_t pte, unsigned int flags) + { +- return pte_write(pte) || +- ((flags & FOLL_FORCE) && (flags & FOLL_COW) && pte_dirty(pte)); ++ return pte_write(pte) || ((flags & FOLL_COW) && pte_dirty(pte)); ++} ++ ++/* ++ * A (separate) COW fault might break the page the other way and ++ * get_user_pages() would return the page from what is now the wrong ++ * VM. So we need to force a COW break at GUP time even for reads. ++ */ ++static inline bool should_force_cow_break(struct vm_area_struct *vma, unsigned int flags) ++{ ++ return is_cow_mapping(vma->vm_flags) && (flags & FOLL_GET); + } + + static struct page *follow_page_pte(struct vm_area_struct *vma, +@@ -710,12 +719,18 @@ static long __get_user_pages(struct task_struct *tsk, struct mm_struct *mm, + if (!vma || check_vma_flags(vma, gup_flags)) + return i ? : -EFAULT; + if (is_vm_hugetlb_page(vma)) { ++ if (should_force_cow_break(vma, foll_flags)) ++ foll_flags |= FOLL_WRITE; + i = follow_hugetlb_page(mm, vma, pages, vmas, + &start, &nr_pages, i, +- gup_flags, nonblocking); ++ foll_flags, nonblocking); + continue; + } + } ++ ++ if (should_force_cow_break(vma, foll_flags)) ++ foll_flags |= FOLL_WRITE; ++ + retry: + /* + * If we have a pending SIGKILL, don't keep faulting pages and +@@ -1804,6 +1819,10 @@ bool gup_fast_permitted(unsigned long start, int nr_pages, int write) + * the regular GUP. + * Note a difference with get_user_pages_fast: this always returns the + * number of pages pinned, 0 if no pages were pinned. ++ * ++ * Careful, careful! COW breaking can go either way, so a non-write ++ * access can get ambiguous page results. If you call this function without ++ * 'write' set, you'd better be sure that you're ok with that ambiguity. + */ + int __get_user_pages_fast(unsigned long start, int nr_pages, int write, + struct page **pages) +@@ -1831,6 +1850,12 @@ int __get_user_pages_fast(unsigned long start, int nr_pages, int write, + * + * We do not adopt an rcu_read_lock(.) here as we also want to + * block IPIs that come from THPs splitting. ++ * ++ * NOTE! We allow read-only gup_fast() here, but you'd better be ++ * careful about possible COW pages. You'll get _a_ COW page, but ++ * not necessarily the one you intended to get depending on what ++ * COW event happens after this. COW may break the page copy in a ++ * random direction. + */ + + if (gup_fast_permitted(start, nr_pages, write)) { +@@ -1876,9 +1901,16 @@ int get_user_pages_fast(unsigned long start, int nr_pages, int write, + (void __user *)start, len))) + return -EFAULT; + ++ /* ++ * The FAST_GUP case requires FOLL_WRITE even for pure reads, ++ * because get_user_pages() may need to cause an early COW in ++ * order to avoid confusing the normal COW routines. So only ++ * targets that are already writable are safe to do by just ++ * looking at the page tables. ++ */ + if (gup_fast_permitted(start, nr_pages, write)) { + local_irq_disable(); +- gup_pgd_range(addr, end, write, pages, &nr); ++ gup_pgd_range(addr, end, 1, pages, &nr); + local_irq_enable(); + ret = nr; + } +diff --git a/mm/huge_memory.c b/mm/huge_memory.c +index cf9e2bbffdc1a..7c374c0fcf0c7 100644 +--- a/mm/huge_memory.c ++++ b/mm/huge_memory.c +@@ -1432,13 +1432,12 @@ out_unlock: + } + + /* +- * FOLL_FORCE can write to even unwritable pmd's, but only +- * after we've gone through a COW cycle and they are dirty. ++ * FOLL_FORCE or a forced COW break can write even to unwritable pmd's, ++ * but only after we've gone through a COW cycle and they are dirty. + */ + static inline bool can_follow_write_pmd(pmd_t pmd, unsigned int flags) + { +- return pmd_write(pmd) || +- ((flags & FOLL_FORCE) && (flags & FOLL_COW) && pmd_dirty(pmd)); ++ return pmd_write(pmd) || ((flags & FOLL_COW) && pmd_dirty(pmd)); + } + + struct page *follow_trans_huge_pmd(struct vm_area_struct *vma, +diff --git a/net/core/neighbour.c b/net/core/neighbour.c +index 6e890f51b7d86..e471c32e448f6 100644 +--- a/net/core/neighbour.c ++++ b/net/core/neighbour.c +@@ -1271,7 +1271,7 @@ int neigh_update(struct neighbour *neigh, const u8 *lladdr, u8 new, + * we can reinject the packet there. + */ + n2 = NULL; +- if (dst) { ++ if (dst && dst->obsolete != DST_OBSOLETE_DEAD) { + n2 = dst_neigh_lookup_skb(dst, skb); + if (n2) + n1 = n2; +diff --git a/net/ieee802154/nl802154.c b/net/ieee802154/nl802154.c +index b10b297e76b78..b1c55db737648 100644 +--- a/net/ieee802154/nl802154.c ++++ b/net/ieee802154/nl802154.c +@@ -1516,6 +1516,11 @@ nl802154_dump_llsec_key(struct sk_buff *skb, struct netlink_callback *cb) + if (err) + return err; + ++ if (wpan_dev->iftype == NL802154_IFTYPE_MONITOR) { ++ err = skb->len; ++ goto out_err; ++ } ++ + if (!wpan_dev->netdev) { + err = -EINVAL; + goto out_err; +@@ -1688,6 +1693,11 @@ nl802154_dump_llsec_dev(struct sk_buff *skb, struct netlink_callback *cb) + if (err) + return err; + ++ if (wpan_dev->iftype == NL802154_IFTYPE_MONITOR) { ++ err = skb->len; ++ goto out_err; ++ } ++ + if (!wpan_dev->netdev) { + err = -EINVAL; + goto out_err; +@@ -1775,6 +1785,9 @@ static int nl802154_add_llsec_dev(struct sk_buff *skb, struct genl_info *info) + struct wpan_dev *wpan_dev = dev->ieee802154_ptr; + struct ieee802154_llsec_device dev_desc; + ++ if (wpan_dev->iftype == NL802154_IFTYPE_MONITOR) ++ return -EOPNOTSUPP; ++ + if (ieee802154_llsec_parse_device(info->attrs[NL802154_ATTR_SEC_DEVICE], + &dev_desc) < 0) + return -EINVAL; +@@ -1861,6 +1874,11 @@ nl802154_dump_llsec_devkey(struct sk_buff *skb, struct netlink_callback *cb) + if (err) + return err; + ++ if (wpan_dev->iftype == NL802154_IFTYPE_MONITOR) { ++ err = skb->len; ++ goto out_err; ++ } ++ + if (!wpan_dev->netdev) { + err = -EINVAL; + goto out_err; +@@ -1918,6 +1936,9 @@ static int nl802154_add_llsec_devkey(struct sk_buff *skb, struct genl_info *info + struct ieee802154_llsec_device_key key; + __le64 extended_addr; + ++ if (wpan_dev->iftype == NL802154_IFTYPE_MONITOR) ++ return -EOPNOTSUPP; ++ + if (!info->attrs[NL802154_ATTR_SEC_DEVKEY] || + nla_parse_nested(attrs, NL802154_DEVKEY_ATTR_MAX, + info->attrs[NL802154_ATTR_SEC_DEVKEY], +@@ -2027,6 +2048,11 @@ nl802154_dump_llsec_seclevel(struct sk_buff *skb, struct netlink_callback *cb) + if (err) + return err; + ++ if (wpan_dev->iftype == NL802154_IFTYPE_MONITOR) { ++ err = skb->len; ++ goto out_err; ++ } ++ + if (!wpan_dev->netdev) { + err = -EINVAL; + goto out_err; +@@ -2112,6 +2138,9 @@ static int nl802154_add_llsec_seclevel(struct sk_buff *skb, + struct wpan_dev *wpan_dev = dev->ieee802154_ptr; + struct ieee802154_llsec_seclevel sl; + ++ if (wpan_dev->iftype == NL802154_IFTYPE_MONITOR) ++ return -EOPNOTSUPP; ++ + if (llsec_parse_seclevel(info->attrs[NL802154_ATTR_SEC_LEVEL], + &sl) < 0) + return -EINVAL; +diff --git a/net/ipv6/ip6_tunnel.c b/net/ipv6/ip6_tunnel.c +index b825ac025d5bd..28c4a693ab98d 100644 +--- a/net/ipv6/ip6_tunnel.c ++++ b/net/ipv6/ip6_tunnel.c +@@ -2222,6 +2222,16 @@ static void __net_exit ip6_tnl_destroy_tunnels(struct net *net, struct list_head + t = rtnl_dereference(t->next); + } + } ++ ++ t = rtnl_dereference(ip6n->tnls_wc[0]); ++ while (t) { ++ /* If dev is in the same netns, it has already ++ * been added to the list by the previous loop. ++ */ ++ if (!net_eq(dev_net(t->dev), net)) ++ unregister_netdevice_queue(t->dev, list); ++ t = rtnl_dereference(t->next); ++ } + } + + static int __net_init ip6_tnl_init_net(struct net *net) +diff --git a/net/ipv6/sit.c b/net/ipv6/sit.c +index bcf29201f87b3..ad737b68b8e96 100644 +--- a/net/ipv6/sit.c ++++ b/net/ipv6/sit.c +@@ -1818,9 +1818,9 @@ static void __net_exit sit_destroy_tunnels(struct net *net, + if (dev->rtnl_link_ops == &sit_link_ops) + unregister_netdevice_queue(dev, head); + +- for (prio = 1; prio < 4; prio++) { ++ for (prio = 0; prio < 4; prio++) { + int h; +- for (h = 0; h < IP6_SIT_HASH_SIZE; h++) { ++ for (h = 0; h < (prio ? IP6_SIT_HASH_SIZE : 1); h++) { + struct ip_tunnel *t; + + t = rtnl_dereference(sitn->tunnels[prio][h]); +diff --git a/net/mac80211/cfg.c b/net/mac80211/cfg.c +index f484f9fc62ca9..6804cdd43befc 100644 +--- a/net/mac80211/cfg.c ++++ b/net/mac80211/cfg.c +@@ -1548,8 +1548,10 @@ static int ieee80211_change_station(struct wiphy *wiphy, + } + + if (sta->sdata->vif.type == NL80211_IFTYPE_AP_VLAN && +- sta->sdata->u.vlan.sta) ++ sta->sdata->u.vlan.sta) { ++ ieee80211_clear_fast_rx(sta); + RCU_INIT_POINTER(sta->sdata->u.vlan.sta, NULL); ++ } + + if (test_sta_flag(sta, WLAN_STA_AUTHORIZED)) + ieee80211_vif_dec_num_mcast(sta->sdata); +diff --git a/net/netfilter/nf_conntrack_standalone.c b/net/netfilter/nf_conntrack_standalone.c +index dcd8e79229515..2e3ae494f3697 100644 +--- a/net/netfilter/nf_conntrack_standalone.c ++++ b/net/netfilter/nf_conntrack_standalone.c +@@ -262,6 +262,7 @@ static const char* l4proto_name(u16 proto) + case IPPROTO_GRE: return "gre"; + case IPPROTO_SCTP: return "sctp"; + case IPPROTO_UDPLITE: return "udplite"; ++ case IPPROTO_ICMPV6: return "icmpv6"; + } + + return "unknown"; +diff --git a/net/netfilter/nft_limit.c b/net/netfilter/nft_limit.c +index 72f13a1144dd6..a7bdc532479a3 100644 +--- a/net/netfilter/nft_limit.c ++++ b/net/netfilter/nft_limit.c +@@ -79,13 +79,13 @@ static int nft_limit_init(struct nft_limit *limit, + return -EOVERFLOW; + + if (pkts) { +- tokens = div_u64(limit->nsecs, limit->rate) * limit->burst; ++ tokens = div64_u64(limit->nsecs, limit->rate) * limit->burst; + } else { + /* The token bucket size limits the number of tokens can be + * accumulated. tokens_max specifies the bucket size. + * tokens_max = unit * (rate + burst) / rate. + */ +- tokens = div_u64(limit->nsecs * (limit->rate + limit->burst), ++ tokens = div64_u64(limit->nsecs * (limit->rate + limit->burst), + limit->rate); + } + +diff --git a/net/sctp/socket.c b/net/sctp/socket.c +index 4a2873f70b372..656bd15328836 100644 +--- a/net/sctp/socket.c ++++ b/net/sctp/socket.c +@@ -1569,11 +1569,9 @@ static void sctp_close(struct sock *sk, long timeout) + + /* Supposedly, no process has access to the socket, but + * the net layers still may. +- * Also, sctp_destroy_sock() needs to be called with addr_wq_lock +- * held and that should be grabbed before socket lock. + */ +- spin_lock_bh(&net->sctp.addr_wq_lock); +- bh_lock_sock_nested(sk); ++ local_bh_disable(); ++ bh_lock_sock(sk); + + /* Hold the sock, since sk_common_release() will put sock_put() + * and we have just a little more cleanup. +@@ -1582,7 +1580,7 @@ static void sctp_close(struct sock *sk, long timeout) + sk_common_release(sk); + + bh_unlock_sock(sk); +- spin_unlock_bh(&net->sctp.addr_wq_lock); ++ local_bh_enable(); + + sock_put(sk); + +@@ -4776,9 +4774,6 @@ static int sctp_init_sock(struct sock *sk) + sk_sockets_allocated_inc(sk); + sock_prot_inuse_add(net, sk->sk_prot, 1); + +- /* Nothing can fail after this block, otherwise +- * sctp_destroy_sock() will be called without addr_wq_lock held +- */ + if (net->sctp.default_auto_asconf) { + spin_lock(&sock_net(sk)->sctp.addr_wq_lock); + list_add_tail(&sp->auto_asconf_list, +@@ -4813,7 +4808,9 @@ static void sctp_destroy_sock(struct sock *sk) + + if (sp->do_auto_asconf) { + sp->do_auto_asconf = 0; ++ spin_lock_bh(&sock_net(sk)->sctp.addr_wq_lock); + list_del(&sp->auto_asconf_list); ++ spin_unlock_bh(&sock_net(sk)->sctp.addr_wq_lock); + } + sctp_endpoint_free(sp->ep); + local_bh_disable(); +diff --git a/sound/soc/fsl/fsl_esai.c b/sound/soc/fsl/fsl_esai.c +index ff96db91f818a..baa76337c33f3 100644 +--- a/sound/soc/fsl/fsl_esai.c ++++ b/sound/soc/fsl/fsl_esai.c +@@ -497,11 +497,13 @@ static int fsl_esai_startup(struct snd_pcm_substream *substream, + ESAI_SAICR_SYNC, esai_priv->synchronous ? + ESAI_SAICR_SYNC : 0); + +- /* Set a default slot number -- 2 */ ++ /* Set slots count */ + regmap_update_bits(esai_priv->regmap, REG_ESAI_TCCR, +- ESAI_xCCR_xDC_MASK, ESAI_xCCR_xDC(2)); ++ ESAI_xCCR_xDC_MASK, ++ ESAI_xCCR_xDC(esai_priv->slots)); + regmap_update_bits(esai_priv->regmap, REG_ESAI_RCCR, +- ESAI_xCCR_xDC_MASK, ESAI_xCCR_xDC(2)); ++ ESAI_xCCR_xDC_MASK, ++ ESAI_xCCR_xDC(esai_priv->slots)); + } + + return 0; +diff --git a/tools/arch/ia64/include/asm/barrier.h b/tools/arch/ia64/include/asm/barrier.h +index d808ee0e77b58..90f8bbd9aede7 100644 +--- a/tools/arch/ia64/include/asm/barrier.h ++++ b/tools/arch/ia64/include/asm/barrier.h +@@ -39,9 +39,6 @@ + * sequential memory pages only. + */ + +-/* XXX From arch/ia64/include/uapi/asm/gcc_intrin.h */ +-#define ia64_mf() asm volatile ("mf" ::: "memory") +- + #define mb() ia64_mf() + #define rmb() mb() + #define wmb() mb()
