lael-labs/linux

Documentation/admin-guide/kernel-parameters.txt+2−0

@@ -4713,6 +4713,8 @@ · 4712 unmodified lines
4713	prevent spurious wakeup);	4713	prevent spurious wakeup);
4714	n = USB_QUIRK_DELAY_CTRL_MSG (Device needs a	4714	n = USB_QUIRK_DELAY_CTRL_MSG (Device needs a
4715	pause after every control message);	4715	pause after every control message);
		4716	o = USB_QUIRK_HUB_SLOW_RESET (Hub needs extra
		4717	delay after resetting its port);
4716	Example: quirks=0781:5580:bk,0a5c:5834:gij	4718	Example: quirks=0781:5580:bk,0a5c:5834:gij
4717		4719
4718	usbhid.mousepoll=	4720	usbhid.mousepoll=

Documentation/admin-guide/security-bugs.rst+11−10

@@ -32,16 +32,17 @@ Disclosure and embargoed information · 31 unmodified lines
32	The security list is not a disclosure channel. For that, see Coordination	32	The security list is not a disclosure channel. For that, see Coordination
33	below.	33	below.
34		34
35	Once a robust fix has been developed, our preference is to release the	35	Once a robust fix has been developed, the release process starts. Fixes
36	fix in a timely fashion, treating it no differently than any of the other	36	for publicly known bugs are released immediately.
37	thousands of changes and fixes the Linux kernel project releases every	37
38	month.	38	Although our preference is to release fixes for publicly undisclosed bugs
39		39	as soon as they become available, this may be postponed at the request of
40	However, at the request of the reporter, we will postpone releasing the	40	the reporter or an affected party for up to 7 calendar days from the start
41	fix for up to 5 business days after the date of the report or after the	41	of the release process, with an exceptional extension to 14 calendar days
42	embargo has lifted; whichever comes first. The only exception to that	42	if it is agreed that the criticality of the bug requires more time. The
43	rule is if the bug is publicly known, in which case the preference is to	43	only valid reason for deferring the publication of a fix is to accommodate
44	release the fix as soon as it's available.	44	the logistics of QA and large scale rollouts which require release
		45	coordination.
45		46
46	Whilst embargoed information may be shared with trusted individuals in	47	Whilst embargoed information may be shared with trusted individuals in
47	order to develop a fix, such information will not be published alongside	48	order to develop a fix, such information will not be published alongside

Documentation/devicetree/bindings/net/dsa/dsa.txt+1−1

@@ -7,7 +7,7 @@ limitations. · 6 unmodified lines
7	Current Binding	7	Current Binding
8	---------------	8	---------------
9		9
10	Switches are true Linux devices and can be probes by any means. Once	10	Switches are true Linux devices and can be probed by any means. Once
11	probed, they register to the DSA framework, passing a node	11	probed, they register to the DSA framework, passing a node
12	pointer. This node is expected to fulfil the following binding, and	12	pointer. This node is expected to fulfil the following binding, and
13	may contain additional properties as required by the device it is	13	may contain additional properties as required by the device it is

Documentation/media/uapi/v4l/dev-meta.rst+1−1

@@ -40,7 +40,7 @@ To use the :ref:`format` ioctls applications set the ``type`` field of the · 39 unmodified lines
40	the desired operation. Both drivers and applications must set the remainder of	40	the desired operation. Both drivers and applications must set the remainder of
41	the :c:type:`v4l2_format` structure to 0.	41	the :c:type:`v4l2_format` structure to 0.
42		42
43	.. _v4l2-meta-format:	43	.. c:type:: v4l2_meta_format
44		44
45	.. tabularcolumns:: \|p{1.4cm}\|p{2.2cm}\|p{13.9cm}\|	45	.. tabularcolumns:: \|p{1.4cm}\|p{2.2cm}\|p{13.9cm}\|
46		46

Documentation/media/uapi/v4l/vidioc-g-fmt.rst+5−0

       - ``sdr``
       - Definition of a data format, see :ref:`pixfmt`, used by SDR
 	capture and output devices.
+    * -
+      - struct :c:type:`v4l2_meta_format`
+      - ``meta``
+      - Definition of a metadata format, see :ref:`meta-formats`, used by
+	metadata capture devices.
     * -
       - __u8
       - ``raw_data``\ [200]

MAINTAINERS+25−12

 8169 10/100/1000 GIGABIT ETHERNET DRIVER
 M:	Realtek linux nic maintainers <nic_swsd@realtek.com>
+M:	Heiner Kallweit <hkallweit1@gmail.com>
 L:	netdev@vger.kernel.org
 S:	Maintained
 F:	drivers/net/ethernet/realtek/r8169.c
 ETHERNET PHY LIBRARY
 M:	Andrew Lunn <andrew@lunn.ch>
 M:	Florian Fainelli <f.fainelli@gmail.com>
+M:	Heiner Kallweit <hkallweit1@gmail.com>
 L:	netdev@vger.kernel.org
 S:	Maintained
 F:	Documentation/ABI/testing/sysfs-bus-mdio
 GPIO SUBSYSTEM
 M:	Linus Walleij <linus.walleij@linaro.org>
+M:	Bartosz Golaszewski <bgolaszewski@baylibre.com>
 L:	linux-gpio@vger.kernel.org
 T:	git git://git.kernel.org/pub/scm/linux/kernel/git/linusw/linux-gpio.git
 S:	Maintained
 F:	Documentation/fb/intelfb.txt
 F:	drivers/video/fbdev/intelfb/
+INTEL GPIO DRIVERS
+M:	Andy Shevchenko <andriy.shevchenko@linux.intel.com>
+L:	linux-gpio@vger.kernel.org
+S:	Maintained
+T:	git git://git.kernel.org/pub/scm/linux/kernel/git/andy/linux-gpio-intel.git
+F:	drivers/gpio/gpio-ich.c
+F:	drivers/gpio/gpio-intel-mid.c
+F:	drivers/gpio/gpio-lynxpoint.c
+F:	drivers/gpio/gpio-merrifield.c
+F:	drivers/gpio/gpio-ml-ioh.c
+F:	drivers/gpio/gpio-pch.c
+F:	drivers/gpio/gpio-sch.c
+F:	drivers/gpio/gpio-sodaville.c
 INTEL GVT-g DRIVERS (Intel GPU Virtualization)
 M:	Zhenyu Wang <zhenyuw@linux.intel.com>
 M:	Zhi Wang <zhi.a.wang@intel.com>
 S:	Supported
 F:	drivers/gpu/drm/i915/gvt/
-INTEL PMIC GPIO DRIVER
-R:	Andy Shevchenko <andriy.shevchenko@linux.intel.com>
-S:	Maintained
-F:	drivers/gpio/gpio-*cove.c
-F:	drivers/gpio/gpio-msic.c
 INTEL HID EVENT DRIVER
 M:	Alex Hung <alex.hung@canonical.com>
 L:	platform-driver-x86@vger.kernel.org
 S:	Supported
 F:	drivers/platform/x86/intel_menlow.c
-INTEL MERRIFIELD GPIO DRIVER
-M:	Andy Shevchenko <andriy.shevchenko@linux.intel.com>
-L:	linux-gpio@vger.kernel.org
-S:	Maintained
-F:	drivers/gpio/gpio-merrifield.c
 INTEL MIC DRIVERS (mic)
 M:	Sudeep Dutt <sudeep.dutt@intel.com>
 M:	Ashutosh Dixit <ashutosh.dixit@intel.com>
 F:	arch/x86/include/asm/intel_pmc_ipc.h
 F:	arch/x86/include/asm/intel_punit_ipc.h
+INTEL PMIC GPIO DRIVERS
+M:	Andy Shevchenko <andriy.shevchenko@linux.intel.com>
+S:	Maintained
+T:	git git://git.kernel.org/pub/scm/linux/kernel/git/andy/linux-gpio-intel.git
+F:	drivers/gpio/gpio-*cove.c
+F:	drivers/gpio/gpio-msic.c
 INTEL MULTIFUNCTION PMIC DEVICE DRIVERS
 R:	Andy Shevchenko <andriy.shevchenko@linux.intel.com>
 S:	Maintained
 STABLE BRANCH
 M:	Greg Kroah-Hartman <gregkh@linuxfoundation.org>
+M:	Sasha Levin <sashal@kernel.org>
 L:	stable@vger.kernel.org
 S:	Supported
 F:	Documentation/process/stable-kernel-rules.rst

arch/arm64/include/asm/sysreg.h+2−2

@@ -468,7 +468,7 @@ · 467 unmodified lines
468	SCTLR_ELx_SA \| SCTLR_ELx_I \| SCTLR_ELx_WXN \| \	468	SCTLR_ELx_SA \| SCTLR_ELx_I \| SCTLR_ELx_WXN \| \
469	SCTLR_ELx_DSSBS \| ENDIAN_CLEAR_EL2 \| SCTLR_EL2_RES0)	469	SCTLR_ELx_DSSBS \| ENDIAN_CLEAR_EL2 \| SCTLR_EL2_RES0)
470		470
471	#if (SCTLR_EL2_SET ^ SCTLR_EL2_CLEAR) != 0xffffffffffffffff	471	#if (SCTLR_EL2_SET ^ SCTLR_EL2_CLEAR) != 0xffffffffffffffffUL
472	#error "Inconsistent SCTLR_EL2 set/clear bits"	472	#error "Inconsistent SCTLR_EL2 set/clear bits"
473	#endif	473	#endif
474		474
@@ -509,7 +509,7 @@ · 34 unmodified lines
509	SCTLR_EL1_UMA \| SCTLR_ELx_WXN \| ENDIAN_CLEAR_EL1 \|\	509	SCTLR_EL1_UMA \| SCTLR_ELx_WXN \| ENDIAN_CLEAR_EL1 \|\
510	SCTLR_ELx_DSSBS \| SCTLR_EL1_NTWI \| SCTLR_EL1_RES0)	510	SCTLR_ELx_DSSBS \| SCTLR_EL1_NTWI \| SCTLR_EL1_RES0)
511		511
512	#if (SCTLR_EL1_SET ^ SCTLR_EL1_CLEAR) != 0xffffffffffffffff	512	#if (SCTLR_EL1_SET ^ SCTLR_EL1_CLEAR) != 0xffffffffffffffffUL
513	#error "Inconsistent SCTLR_EL1 set/clear bits"	513	#error "Inconsistent SCTLR_EL1 set/clear bits"
514	#endif	514	#endif
515		515

arch/arm64/kernel/cpufeature.c+1−1

 		.cpu_enable = cpu_enable_hw_dbm,
 	},
 #endif
-#ifdef CONFIG_ARM64_SSBD
 	{
 		.desc = "CRC32 instructions",
 		.capability = ARM64_HAS_CRC32,
 		.field_pos = ID_AA64ISAR0_CRC32_SHIFT,
 		.min_field_value = 1,
 	},
+#ifdef CONFIG_ARM64_SSBD
 	{
 		.desc = "Speculative Store Bypassing Safe (SSBS)",
 		.capability = ARM64_SSBS,

arch/mips/configs/cavium_octeon_defconfig+1−0

@@ -140,6 +140,7 @@ CONFIG_RTC_CLASS=y · 139 unmodified lines
140	CONFIG_RTC_DRV_DS1307=y	140	CONFIG_RTC_DRV_DS1307=y
141	CONFIG_STAGING=y	141	CONFIG_STAGING=y
142	CONFIG_OCTEON_ETHERNET=y	142	CONFIG_OCTEON_ETHERNET=y
		143	CONFIG_OCTEON_USB=y
143	# CONFIG_IOMMU_SUPPORT is not set	144	# CONFIG_IOMMU_SUPPORT is not set
144	CONFIG_RAS=y	145	CONFIG_RAS=y
145	CONFIG_EXT4_FS=y	146	CONFIG_EXT4_FS=y

arch/mips/kernel/setup.c+1−0

@@ -794,6 +794,7 @@ static void __init arch_mem_init(char **cmdline_p) · 793 unmodified lines
794		794
795	/* call board setup routine */	795	/* call board setup routine */
796	plat_mem_setup();	796	plat_mem_setup();
		797	memblock_set_bottom_up(true);
797		798
798	/*	799	/*
799	* Make sure all kernel memory is in the maps. The "UP" and	800	* Make sure all kernel memory is in the maps. The "UP" and

arch/mips/kernel/traps.c+1−2

 		unsigned long size = 0x200 + VECTORSPACING*64;
 		phys_addr_t ebase_pa;
-		memblock_set_bottom_up(true);
 		ebase = (unsigned long)
 			memblock_alloc_from(size, 1 << fls(size), 0);
-		memblock_set_bottom_up(false);
 		/*
 		 * Try to ensure ebase resides in KSeg0 if possible.
 	if (board_ebase_setup)
 		board_ebase_setup();
 	per_cpu_trap_init(true);
+	memblock_set_bottom_up(false);
 	/*
 	 * Copy the generic exception handlers to their final destination.

arch/mips/loongson64/loongson-3/numa.c+2−10

 			cpumask_clear(&__node_data[(node)]->cpumask);
 		}
 	}
+	max_low_pfn = PHYS_PFN(memblock_end_of_DRAM());
 	for (cpu = 0; cpu < loongson_sysconf.nr_cpus; cpu++) {
 		node = cpu / loongson_sysconf.cores_per_node;
 		if (node >= num_online_nodes())
 void __init paging_init(void)
 {
-	unsigned node;
 	unsigned long zones_size[MAX_NR_ZONES] = {0, };
 	pagetable_init();
-	for_each_online_node(node) {
-		unsigned long  start_pfn, end_pfn;
-		get_pfn_range_for_nid(node, &start_pfn, &end_pfn);
-		if (end_pfn > max_low_pfn)
-			max_low_pfn = end_pfn;
-	}
 #ifdef CONFIG_ZONE_DMA32
 	zones_size[ZONE_DMA32] = MAX_DMA32_PFN;
 #endif

arch/mips/sgi-ip27/ip27-memory.c+1−10

 	mlreset();
 	szmem();
+	max_low_pfn = PHYS_PFN(memblock_end_of_DRAM());
 	for (node = 0; node < MAX_COMPACT_NODES; node++) {
 		if (node_online(node)) {
 void __init paging_init(void)
 {
 	unsigned long zones_size[MAX_NR_ZONES] = {0, };
-	unsigned node;
 	pagetable_init();
-	for_each_online_node(node) {
-		unsigned long start_pfn, end_pfn;
-		get_pfn_range_for_nid(node, &start_pfn, &end_pfn);
-		if (end_pfn > max_low_pfn)
-			max_low_pfn = end_pfn;
-	}
 	zones_size[ZONE_NORMAL] = max_low_pfn;
 	free_area_init_nodes(zones_size);
 }

arch/riscv/Makefile+14−1

@@ -71,6 +71,10 @@ KBUILD_CFLAGS += $(call cc-option,-mstrict-align) · 70 unmodified lines
71	# arch specific predefines for sparse	71	# arch specific predefines for sparse
72	CHECKFLAGS += -D__riscv -D__riscv_xlen=$(BITS)	72	CHECKFLAGS += -D__riscv -D__riscv_xlen=$(BITS)
73		73
		74	# Default target when executing plain make
		75	boot := arch/riscv/boot
		76	KBUILD_IMAGE := $(boot)/Image.gz
		77
74	head-y := arch/riscv/kernel/head.o	78	head-y := arch/riscv/kernel/head.o
75		79
76	core-y += arch/riscv/kernel/ arch/riscv/mm/	80	core-y += arch/riscv/kernel/ arch/riscv/mm/
@@ -81,4 +85,13 @@ PHONY += vdso_install · 4 unmodified lines
81	vdso_install:	85	vdso_install:
82	$(Q)$(MAKE) $(build)=arch/riscv/kernel/vdso $@	86	$(Q)$(MAKE) $(build)=arch/riscv/kernel/vdso $@
83		87
84	all: vmlinux	88	all: Image.gz
		89
		90	Image: vmlinux
		91	$(Q)$(MAKE) $(build)=$(boot) $(boot)/$@
		92
		93	Image.%: Image
		94	$(Q)$(MAKE) $(build)=$(boot) $(boot)/$@
		95
		96	zinstall install:
		97	$(Q)$(MAKE) $(build)=$(boot) $@

arch/riscv/boot/.gitignore+2−0

@@ -0,0 +1,2 @@
	1	Image
	2	Image.gz

arch/riscv/boot/Makefile+33−0

@@ -0,0 +1,33 @@
	1	#
	2	# arch/riscv/boot/Makefile
	3	#
	4	# This file is included by the global makefile so that you can add your own
	5	# architecture-specific flags and dependencies.
	6	#
	7	# This file is subject to the terms and conditions of the GNU General Public
	8	# License. See the file "COPYING" in the main directory of this archive
	9	# for more details.
	10	#
	11	# Copyright (C) 2018, Anup Patel.
	12	# Author: Anup Patel <anup@brainfault.org>
	13	#
	14	# Based on the ia64 and arm64 boot/Makefile.
	15	#
	16
	17	OBJCOPYFLAGS_Image :=-O binary -R .note -R .note.gnu.build-id -R .comment -S
	18
	19	targets := Image
	20
	21	$(obj)/Image: vmlinux FORCE
	22	$(call if_changed,objcopy)
	23
	24	$(obj)/Image.gz: $(obj)/Image FORCE
	25	$(call if_changed,gzip)
	26
	27	install:
	28	$(CONFIG_SHELL) $(srctree)/$(src)/install.sh $(KERNELRELEASE) \
	29	$(obj)/Image System.map "$(INSTALL_PATH)"
	30
	31	zinstall:
	32	$(CONFIG_SHELL) $(srctree)/$(src)/install.sh $(KERNELRELEASE) \
	33	$(obj)/Image.gz System.map "$(INSTALL_PATH)"

arch/riscv/boot/install.sh+60−0

@@ -0,0 +1,60 @@
	1	#!/bin/sh
	2	#
	3	# arch/riscv/boot/install.sh
	4	#
	5	# This file is subject to the terms and conditions of the GNU General Public
	6	# License. See the file "COPYING" in the main directory of this archive
	7	# for more details.
	8	#
	9	# Copyright (C) 1995 by Linus Torvalds
	10	#
	11	# Adapted from code in arch/i386/boot/Makefile by H. Peter Anvin
	12	# Adapted from code in arch/i386/boot/install.sh by Russell King
	13	#
	14	# "make install" script for the RISC-V Linux port
	15	#
	16	# Arguments:
	17	# $1 - kernel version
	18	# $2 - kernel image file
	19	# $3 - kernel map file
	20	# $4 - default install path (blank if root directory)
	21	#
	22
	23	verify () {
	24	if [ ! -f "$1" ]; then
	25	echo "" 1>&2
	26	echo " *** Missing file: $1" 1>&2
	27	echo ' *** You need to run "make" before "make install".' 1>&2
	28	echo "" 1>&2
	29	exit 1
	30	fi
	31	}
	32
	33	# Make sure the files actually exist
	34	verify "$2"
	35	verify "$3"
	36
	37	# User may have a custom install script
	38	if [ -x ~/bin/${INSTALLKERNEL} ]; then exec ~/bin/${INSTALLKERNEL} "$@"; fi
	39	if [ -x /sbin/${INSTALLKERNEL} ]; then exec /sbin/${INSTALLKERNEL} "$@"; fi
	40
	41	if [ "$(basename $2)" = "Image.gz" ]; then
	42	# Compressed install
	43	echo "Installing compressed kernel"
	44	base=vmlinuz
	45	else
	46	# Normal install
	47	echo "Installing normal kernel"
	48	base=vmlinux
	49	fi
	50
	51	if [ -f $4/$base-$1 ]; then
	52	mv $4/$base-$1 $4/$base-$1.old
	53	fi
	54	cat $2 > $4/$base-$1
	55
	56	# Install system map file
	57	if [ -f $4/System.map-$1 ]; then
	58	mv $4/System.map-$1 $4/System.map-$1.old
	59	fi
	60	cp $3 $4/System.map-$1

arch/riscv/include/asm/module.h+1−0

@@ -8,6 +8,7 @@ · 7 unmodified lines
8		8
9	#define MODULE_ARCH_VERMAGIC "riscv"	9	#define MODULE_ARCH_VERMAGIC "riscv"
10		10
		11	struct module;
11	u64 module_emit_got_entry(struct module *mod, u64 val);	12	u64 module_emit_got_entry(struct module *mod, u64 val);
12	u64 module_emit_plt_entry(struct module *mod, u64 val);	13	u64 module_emit_plt_entry(struct module *mod, u64 val);
13		14

arch/riscv/include/asm/uaccess.h+2−2

@@ -400,13 +400,13 @@ extern unsigned long __must_check __asm_copy_from_user(void *to, · 399 unmodified lines
400	static inline unsigned long	400	static inline unsigned long
401	raw_copy_from_user(void to, const void __user from, unsigned long n)	401	raw_copy_from_user(void to, const void __user from, unsigned long n)
402	{	402	{
403	return __asm_copy_to_user(to, from, n);	403	return __asm_copy_from_user(to, from, n);
404	}	404	}
405		405
406	static inline unsigned long	406	static inline unsigned long
407	raw_copy_to_user(void __user to, const void from, unsigned long n)	407	raw_copy_to_user(void __user to, const void from, unsigned long n)
408	{	408	{
409	return __asm_copy_from_user(to, from, n);	409	return __asm_copy_to_user(to, from, n);
410	}	410	}
411		411
412	extern long strncpy_from_user(char dest, const char __user src, long count);	412	extern long strncpy_from_user(char dest, const char __user src, long count);

arch/riscv/include/asm/unistd.h+2−3

 /*
  * There is explicitly no include guard here because this file is expected to
- * be included multiple times.  See uapi/asm/syscalls.h for more info.
+ * be included multiple times.
  */
-#define __ARCH_WANT_NEW_STAT
 #define __ARCH_WANT_SYS_CLONE
 #include <uapi/asm/unistd.h>
-#include <uapi/asm/syscalls.h>

arch/riscv/include/uapi/asm/unistd.hrenamed from arch/riscv/include/uapi/asm/syscalls.h+19−7

@@ -1,13 +1,25 @@
1	/* SPDX-License-Identifier: GPL-2.0 */	1	/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
2	/*	2	/*
3	* Copyright (C) 2017-2018 SiFive	3	* Copyright (C) 2018 David Abdurachmanov <david.abdurachmanov@gmail.com>
		4	*
		5	* This program is free software; you can redistribute it and/or modify
		6	* it under the terms of the GNU General Public License version 2 as
		7	* published by the Free Software Foundation.
		8	*
		9	* This program is distributed in the hope that it will be useful,
		10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
		11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		12	* GNU General Public License for more details.
		13	*
		14	* You should have received a copy of the GNU General Public License
		15	* along with this program. If not, see <http://www.gnu.org/licenses/>.
4	*/	16	*/
5		17
6	/*	18	#ifdef __LP64__
7	* There is explicitly no include guard here because this file is expected to	19	#define __ARCH_WANT_NEW_STAT
8	* be included multiple times in order to define the syscall macros via	20	#endif /* __LP64__ */
9	* __SYSCALL.	21
10	*/	22	#include <asm-generic/unistd.h>
11		23
12	/*	24	/*
13	* Allows the instruction cache to be flushed from userspace. Despite RISC-V	25	* Allows the instruction cache to be flushed from userspace. Despite RISC-V

arch/riscv/kernel/cpu.c+6−3

 static void print_isa(struct seq_file *f, const char *orig_isa)
 {
-	static const char *ext = "mafdc";
+	static const char *ext = "mafdcsu";
 	const char *isa = orig_isa;
 	const char *e;
 	/*
 	 * Check the rest of the ISA string for valid extensions, printing those
 	 * we find.  RISC-V ISA strings define an order, so we only print the
-	 * extension bits when they're in order.
+	 * extension bits when they're in order. Hide the supervisor (S)
+	 * extension from userspace as it's not accessible from there.
 	 */
 	for (e = ext; *e != '\0'; ++e) {
 		if (isa[0] == e[0]) {
-			seq_write(f, isa, 1);
+			if (isa[0] != 's')
+				seq_write(f, isa, 1);
 			isa++;
 		}
 	}

arch/riscv/kernel/head.S+10−0

@@ -44,6 +44,16 @@ ENTRY(_start) · 43 unmodified lines
44	amoadd.w a3, a2, (a3)	44	amoadd.w a3, a2, (a3)
45	bnez a3, .Lsecondary_start	45	bnez a3, .Lsecondary_start
46		46
		47	/* Clear BSS for flat non-ELF images */
		48	la a3, __bss_start
		49	la a4, __bss_stop
		50	ble a4, a3, clear_bss_done
		51	clear_bss:
		52	REG_S zero, (a3)
		53	add a3, a3, RISCV_SZPTR
		54	blt a3, a4, clear_bss
		55	clear_bss_done:
		56
47	/* Save hart ID and DTB physical address */	57	/* Save hart ID and DTB physical address */
48	mv s0, a0	58	mv s0, a0
49	mv s1, a1	59	mv s1, a1

arch/riscv/kernel/vmlinux.lds.S+1−1

@@ -74,7 +74,7 @@ SECTIONS · 73 unmodified lines
74	(.sbss)	74	(.sbss)
75	}	75	}
76		76
77	BSS_SECTION(0, 0, 0)	77	BSS_SECTION(PAGE_SIZE, PAGE_SIZE, 0)
78		78
79	EXCEPTION_TABLE(0x10)	79	EXCEPTION_TABLE(0x10)
80	NOTES	80	NOTES

drivers/acpi/acpi_platform.c+1−0

@@ -30,6 +30,7 @@ static const struct acpi_device_id forbidden_id_list[] = { · 29 unmodified lines
30	{"PNP0200", 0}, /* AT DMA Controller */	30	{"PNP0200", 0}, /* AT DMA Controller */
31	{"ACPI0009", 0}, /* IOxAPIC */	31	{"ACPI0009", 0}, /* IOxAPIC */
32	{"ACPI000A", 0}, /* IOAPIC */	32	{"ACPI000A", 0}, /* IOAPIC */
		33	{"SMB0001", 0}, /* ACPI SMBUS virtual device */
33	{"", 0},	34	{"", 0},
34	};	35	};
35		36

drivers/cpufreq/ti-cpufreq.c+21−5

 	{},
 };
+static const struct of_device_id *ti_cpufreq_match_node(void)
+{
+	struct device_node *np;
+	const struct of_device_id *match;
+	np = of_find_node_by_path("/");
+	match = of_match_node(ti_cpufreq_of_match, np);
+	of_node_put(np);
+	return match;
+}
 static int ti_cpufreq_probe(struct platform_device *pdev)
 {
 	u32 version[VERSION_COUNT];
-	struct device_node *np;
 	const struct of_device_id *match;
 	struct opp_table *ti_opp_table;
 	struct ti_cpufreq_data *opp_data;
 	const char * const reg_names[] = {"vdd", "vbb"};
 	int ret;
-	np = of_find_node_by_path("/");
+	match = dev_get_platdata(&pdev->dev);
-	match = of_match_node(ti_cpufreq_of_match, np);
-	of_node_put(np);
 	if (!match)
 		return -ENODEV;
 static int ti_cpufreq_init(void)
 {
-	platform_device_register_simple("ti-cpufreq", -1, NULL, 0);
+	const struct of_device_id *match;
+	/* Check to ensure we are on a compatible platform */
+	match = ti_cpufreq_match_node();
+	if (match)
+		platform_device_register_data(NULL, "ti-cpufreq", -1, match,
+					      sizeof(*match));
 	return 0;
 }
 module_init(ti_cpufreq_init);

drivers/dma-buf/udmabuf.c+1−0

@@ -184,6 +184,7 @@ static long udmabuf_create(const struct udmabuf_create_list *head, · 183 unmodified lines
184	exp_info.ops = &udmabuf_ops;	184	exp_info.ops = &udmabuf_ops;
185	exp_info.size = ubuf->pagecount << PAGE_SHIFT;	185	exp_info.size = ubuf->pagecount << PAGE_SHIFT;
186	exp_info.priv = ubuf;	186	exp_info.priv = ubuf;
		187	exp_info.flags = O_RDWR;
187		188
188	buf = dma_buf_export(&exp_info);	189	buf = dma_buf_export(&exp_info);
189	if (IS_ERR(buf)) {	190	if (IS_ERR(buf)) {

drivers/gnss/serial.c+2−1

 #include <linux/of.h>
 #include <linux/pm.h>
 #include <linux/pm_runtime.h>
+#include <linux/sched.h>
 #include <linux/serdev.h>
 #include <linux/slab.h>
 	int ret;
 	/* write is only buffered synchronously */
-	ret = serdev_device_write(serdev, buf, count, 0);
+	ret = serdev_device_write(serdev, buf, count, MAX_SCHEDULE_TIMEOUT);
 	if (ret < 0)
 		return ret;

drivers/gnss/sirf.c+2−1

 #include <linux/pm.h>
 #include <linux/pm_runtime.h>
 #include <linux/regulator/consumer.h>
+#include <linux/sched.h>
 #include <linux/serdev.h>
 #include <linux/slab.h>
 #include <linux/wait.h>
 	int ret;
 	/* write is only buffered synchronously */
-	ret = serdev_device_write(serdev, buf, count, 0);
+	ret = serdev_device_write(serdev, buf, count, MAX_SCHEDULE_TIMEOUT);
 	if (ret < 0)
 		return ret;

drivers/gpio/gpio-mockup.c+3−3

@@ -35,8 +35,8 @@ · 34 unmodified lines
35	#define gpio_mockup_err(...) pr_err(GPIO_MOCKUP_NAME ": " __VA_ARGS__)	35	#define gpio_mockup_err(...) pr_err(GPIO_MOCKUP_NAME ": " __VA_ARGS__)
36		36
37	enum {	37	enum {
38	GPIO_MOCKUP_DIR_OUT = 0,	38	GPIO_MOCKUP_DIR_IN = 0,
39	GPIO_MOCKUP_DIR_IN = 1,	39	GPIO_MOCKUP_DIR_OUT = 1,
40	};	40	};
41		41
42	/*	42	/*
@@ -131,7 +131,7 @@ static int gpio_mockup_get_direction(struct gpio_chip *gc, unsigned int offset) · 88 unmodified lines
131	{	131	{
132	struct gpio_mockup_chip *chip = gpiochip_get_data(gc);	132	struct gpio_mockup_chip *chip = gpiochip_get_data(gc);
133		133
134	return chip->lines[offset].dir;	134	return !chip->lines[offset].dir;
135	}	135	}
136		136
137	static int gpio_mockup_to_irq(struct gpio_chip *gc, unsigned int offset)	137	static int gpio_mockup_to_irq(struct gpio_chip *gc, unsigned int offset)

drivers/gpio/gpio-pxa.c+2−2

@@ -268,8 +268,8 @@ static int pxa_gpio_direction_input(struct gpio_chip *chip, unsigned offset) · 267 unmodified lines
268		268
269	if (pxa_gpio_has_pinctrl()) {	269	if (pxa_gpio_has_pinctrl()) {
270	ret = pinctrl_gpio_direction_input(chip->base + offset);	270	ret = pinctrl_gpio_direction_input(chip->base + offset);
271	if (!ret)	271	if (ret)
272	return 0;	272	return ret;
273	}	273	}
274		274
275	spin_lock_irqsave(&gpio_lock, flags);	275	spin_lock_irqsave(&gpio_lock, flags);

drivers/gpio/gpiolib.c+3−2

 	gdev->descs = kcalloc(chip->ngpio, sizeof(gdev->descs[0]), GFP_KERNEL);
 	if (!gdev->descs) {
 		status = -ENOMEM;
-		goto err_free_gdev;
+		goto err_free_ida;
 	}
 	if (chip->ngpio == 0) {
 	kfree_const(gdev->label);
 err_free_descs:
 	kfree(gdev->descs);
-err_free_gdev:
+err_free_ida:
 	ida_simple_remove(&gpio_ida, gdev->id);
+err_free_gdev:
 	/* failures here can mean systems won't boot... */
 	pr_err("%s: GPIOs %d..%d (%s) failed to register, %d\n", __func__,
 	       gdev->base, gdev->base + gdev->ngpio - 1,

drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd.c+5−2

 {
 	struct amdgpu_device *adev = (struct amdgpu_device *)kgd;
-	amdgpu_dpm_switch_power_profile(adev,
+	if (adev->powerplay.pp_funcs &&
-					PP_SMC_POWER_PROFILE_COMPUTE, !idle);
+	    adev->powerplay.pp_funcs->switch_power_profile)
+		amdgpu_dpm_switch_power_profile(adev,
+						PP_SMC_POWER_PROFILE_COMPUTE,
+						!idle);
 }
 bool amdgpu_amdkfd_is_kfd_vmid(struct amdgpu_device *adev, u32 vmid)

drivers/gpu/drm/amd/amdgpu/amdgpu_display.c+7−0

@@ -626,6 +626,13 @@ int amdgpu_display_modeset_create_props(struct amdgpu_device *adev) · 625 unmodified lines
626	"dither",	626	"dither",
627	amdgpu_dither_enum_list, sz);	627	amdgpu_dither_enum_list, sz);
628		628
		629	if (amdgpu_device_has_dc_support(adev)) {
		630	adev->mode_info.max_bpc_property =
		631	drm_property_create_range(adev->ddev, 0, "max bpc", 8, 16);
		632	if (!adev->mode_info.max_bpc_property)
		633	return -ENOMEM;
		634	}
		635
629	return 0;	636	return 0;
630	}	637	}
631		638

drivers/gpu/drm/amd/amdgpu/amdgpu_mode.h+2−0

 	struct drm_property *audio_property;
 	/* FMT dithering */
 	struct drm_property *dither_property;
+	/* maximum number of bits per channel for monitor color */
+	struct drm_property *max_bpc_property;
 	/* hardcoded DFP edid from BIOS */
 	struct edid *bios_hardcoded_edid;
 	int bios_hardcoded_edid_size;

drivers/gpu/drm/amd/amdgpu/gmc_v6_0.c+1−0

@@ -46,6 +46,7 @@ MODULE_FIRMWARE("amdgpu/tahiti_mc.bin"); · 45 unmodified lines
46	MODULE_FIRMWARE("amdgpu/pitcairn_mc.bin");	46	MODULE_FIRMWARE("amdgpu/pitcairn_mc.bin");
47	MODULE_FIRMWARE("amdgpu/verde_mc.bin");	47	MODULE_FIRMWARE("amdgpu/verde_mc.bin");
48	MODULE_FIRMWARE("amdgpu/oland_mc.bin");	48	MODULE_FIRMWARE("amdgpu/oland_mc.bin");
		49	MODULE_FIRMWARE("amdgpu/hainan_mc.bin");
49	MODULE_FIRMWARE("amdgpu/si58_mc.bin");	50	MODULE_FIRMWARE("amdgpu/si58_mc.bin");
50		51
51	#define MC_SEQ_MISC0__MT__MASK 0xf0000000	52	#define MC_SEQ_MISC0__MT__MASK 0xf0000000

drivers/gpu/drm/amd/amdgpu/soc15.c+32−7

@@ -65,6 +65,13 @@ · 64 unmodified lines
65	#define mmMP0_MISC_LIGHT_SLEEP_CTRL 0x01ba	65	#define mmMP0_MISC_LIGHT_SLEEP_CTRL 0x01ba
66	#define mmMP0_MISC_LIGHT_SLEEP_CTRL_BASE_IDX 0	66	#define mmMP0_MISC_LIGHT_SLEEP_CTRL_BASE_IDX 0
67		67
		68	/* for Vega20 register name change */
		69	#define mmHDP_MEM_POWER_CTRL 0x00d4
		70	#define HDP_MEM_POWER_CTRL__IPH_MEM_POWER_CTRL_EN_MASK 0x00000001L
		71	#define HDP_MEM_POWER_CTRL__IPH_MEM_POWER_LS_EN_MASK 0x00000002L
		72	#define HDP_MEM_POWER_CTRL__RC_MEM_POWER_CTRL_EN_MASK 0x00010000L
		73	#define HDP_MEM_POWER_CTRL__RC_MEM_POWER_LS_EN_MASK 0x00020000L
		74	#define mmHDP_MEM_POWER_CTRL_BASE_IDX 0
68	/*	75	/*
69	* Indirect registers accessor	76	* Indirect registers accessor
70	*/	77	*/
@@ -870,15 +877,33 @@ static void soc15_update_hdp_light_sleep(struct amdgpu_device *adev, bool enable · 799 unmodified lines
870	{	877	{
871	uint32_t def, data;	878	uint32_t def, data;
872		879
873	def = data = RREG32(SOC15_REG_OFFSET(HDP, 0, mmHDP_MEM_POWER_LS));	880	if (adev->asic_type == CHIP_VEGA20) {
		881	def = data = RREG32(SOC15_REG_OFFSET(HDP, 0, mmHDP_MEM_POWER_CTRL));
874		882
875	if (enable && (adev->cg_flags & AMD_CG_SUPPORT_HDP_LS))	883	if (enable && (adev->cg_flags & AMD_CG_SUPPORT_HDP_LS))
876	data \|= HDP_MEM_POWER_LS__LS_ENABLE_MASK;	884	data \|= HDP_MEM_POWER_CTRL__IPH_MEM_POWER_CTRL_EN_MASK \|
877	else	885	HDP_MEM_POWER_CTRL__IPH_MEM_POWER_LS_EN_MASK \|
878	data &= ~HDP_MEM_POWER_LS__LS_ENABLE_MASK;	886	HDP_MEM_POWER_CTRL__RC_MEM_POWER_CTRL_EN_MASK \|
		887	HDP_MEM_POWER_CTRL__RC_MEM_POWER_LS_EN_MASK;
		888	else
		889	data &= ~(HDP_MEM_POWER_CTRL__IPH_MEM_POWER_CTRL_EN_MASK \|
		890	HDP_MEM_POWER_CTRL__IPH_MEM_POWER_LS_EN_MASK \|
		891	HDP_MEM_POWER_CTRL__RC_MEM_POWER_CTRL_EN_MASK \|
		892	HDP_MEM_POWER_CTRL__RC_MEM_POWER_LS_EN_MASK);
879		893
880	if (def != data)	894	if (def != data)
881	WREG32(SOC15_REG_OFFSET(HDP, 0, mmHDP_MEM_POWER_LS), data);	895	WREG32(SOC15_REG_OFFSET(HDP, 0, mmHDP_MEM_POWER_CTRL), data);
		896	} else {
		897	def = data = RREG32(SOC15_REG_OFFSET(HDP, 0, mmHDP_MEM_POWER_LS));
		898
		899	if (enable && (adev->cg_flags & AMD_CG_SUPPORT_HDP_LS))
		900	data \|= HDP_MEM_POWER_LS__LS_ENABLE_MASK;
		901	else
		902	data &= ~HDP_MEM_POWER_LS__LS_ENABLE_MASK;
		903
		904	if (def != data)
		905	WREG32(SOC15_REG_OFFSET(HDP, 0, mmHDP_MEM_POWER_LS), data);
		906	}
882	}	907	}
883		908
884	static void soc15_update_drm_clock_gating(struct amdgpu_device *adev, bool enable)	909	static void soc15_update_drm_clock_gating(struct amdgpu_device *adev, bool enable)

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c+16−0

 static enum dc_color_depth
 convert_color_depth_from_display_info(const struct drm_connector *connector)
 {
+	struct dm_connector_state *dm_conn_state =
+		to_dm_connector_state(connector->state);
 	uint32_t bpc = connector->display_info.bpc;
+	/* TODO: Remove this when there's support for max_bpc in drm */
+	if (dm_conn_state && bpc > dm_conn_state->max_bpc)
+		/* Round down to nearest even number. */
+		bpc = dm_conn_state->max_bpc - (dm_conn_state->max_bpc & 1);
 	switch (bpc) {
 	case 0:
 		/*
 	} else if (property == adev->mode_info.underscan_property) {
 		dm_new_state->underscan_enable = val;
 		ret = 0;
+	} else if (property == adev->mode_info.max_bpc_property) {
+		dm_new_state->max_bpc = val;
+		ret = 0;
 	}
 	return ret;
 	} else if (property == adev->mode_info.underscan_property) {
 		*val = dm_state->underscan_enable;
 		ret = 0;
+	} else if (property == adev->mode_info.max_bpc_property) {
+		*val = dm_state->max_bpc;
+		ret = 0;
 	}
 	return ret;
 }
 	drm_object_attach_property(&aconnector->base.base,
 				adev->mode_info.underscan_vborder_property,
 				0);
+	drm_object_attach_property(&aconnector->base.base,
+				adev->mode_info.max_bpc_property,
+				0);
 }

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.h+1−0

@@ -204,6 +204,7 @@ struct dm_connector_state { · 203 unmodified lines
204	enum amdgpu_rmx_type scaling;	204	enum amdgpu_rmx_type scaling;
205	uint8_t underscan_vborder;	205	uint8_t underscan_vborder;
206	uint8_t underscan_hborder;	206	uint8_t underscan_hborder;
		207	uint8_t max_bpc;
207	bool underscan_enable;	208	bool underscan_enable;
208	bool freesync_enable;	209	bool freesync_enable;
209	bool freesync_capable;	210	bool freesync_capable;

drivers/gpu/drm/amd/powerplay/hwmgr/smu7_hwmgr.c+10−10

 	struct smu7_single_dpm_table *sclk_table = &(data->dpm_table.sclk_table);
 	struct smu7_single_dpm_table *golden_sclk_table =
 			&(data->golden_dpm_table.sclk_table);
-	int value;
+	int value = sclk_table->dpm_levels[sclk_table->count - 1].value;
+	int golden_value = golden_sclk_table->dpm_levels
+			[golden_sclk_table->count - 1].value;
-	value = (sclk_table->dpm_levels[sclk_table->count - 1].value -
+	value -= golden_value;
-			golden_sclk_table->dpm_levels[golden_sclk_table->count - 1].value) *
+	value = DIV_ROUND_UP(value * 100, golden_value);
-			100 /
-			golden_sclk_table->dpm_levels[golden_sclk_table->count - 1].value;
 	return value;
 }
 	struct smu7_single_dpm_table *mclk_table = &(data->dpm_table.mclk_table);
 	struct smu7_single_dpm_table *golden_mclk_table =
 			&(data->golden_dpm_table.mclk_table);
-	int value;
+        int value = mclk_table->dpm_levels[mclk_table->count - 1].value;
+	int golden_value = golden_mclk_table->dpm_levels
+			[golden_mclk_table->count - 1].value;
-	value = (mclk_table->dpm_levels[mclk_table->count - 1].value -
+	value -= golden_value;
-			golden_mclk_table->dpm_levels[golden_mclk_table->count - 1].value) *
+	value = DIV_ROUND_UP(value * 100, golden_value);
-			100 /
-			golden_mclk_table->dpm_levels[golden_mclk_table->count - 1].value;
 	return value;
 }

drivers/gpu/drm/amd/powerplay/hwmgr/vega10_hwmgr.c+10−15

@@ -4522,15 +4522,13 @@ static int vega10_get_sclk_od(struct pp_hwmgr *hwmgr) · 4521 unmodified lines
4522	struct vega10_single_dpm_table *sclk_table = &(data->dpm_table.gfx_table);	4522	struct vega10_single_dpm_table *sclk_table = &(data->dpm_table.gfx_table);
4523	struct vega10_single_dpm_table *golden_sclk_table =	4523	struct vega10_single_dpm_table *golden_sclk_table =
4524	&(data->golden_dpm_table.gfx_table);	4524	&(data->golden_dpm_table.gfx_table);
4525	int value;	4525	int value = sclk_table->dpm_levels[sclk_table->count - 1].value;
4526		4526	int golden_value = golden_sclk_table->dpm_levels
4527	value = (sclk_table->dpm_levels[sclk_table->count - 1].value -
4528	golden_sclk_table->dpm_levels
4529	[golden_sclk_table->count - 1].value) *
4530	100 /
4531	golden_sclk_table->dpm_levels
4532	[golden_sclk_table->count - 1].value;	4527	[golden_sclk_table->count - 1].value;
4533		4528
		4529	value -= golden_value;
		4530	value = DIV_ROUND_UP(value * 100, golden_value);
		4531
4534	return value;	4532	return value;
4535	}	4533	}
4536		4534
@@ -4575,16 +4573,13 @@ static int vega10_get_mclk_od(struct pp_hwmgr *hwmgr) · 38 unmodified lines
4575	struct vega10_single_dpm_table *mclk_table = &(data->dpm_table.mem_table);	4573	struct vega10_single_dpm_table *mclk_table = &(data->dpm_table.mem_table);
4576	struct vega10_single_dpm_table *golden_mclk_table =	4574	struct vega10_single_dpm_table *golden_mclk_table =
4577	&(data->golden_dpm_table.mem_table);	4575	&(data->golden_dpm_table.mem_table);
4578	int value;	4576	int value = mclk_table->dpm_levels[mclk_table->count - 1].value;
4579		4577	int golden_value = golden_mclk_table->dpm_levels
4580	value = (mclk_table->dpm_levels
4581	[mclk_table->count - 1].value -
4582	golden_mclk_table->dpm_levels
4583	[golden_mclk_table->count - 1].value) *
4584	100 /
4585	golden_mclk_table->dpm_levels
4586	[golden_mclk_table->count - 1].value;	4578	[golden_mclk_table->count - 1].value;
4587		4579
		4580	value -= golden_value;
		4581	value = DIV_ROUND_UP(value * 100, golden_value);
		4582
4588	return value;	4583	return value;
4589	}	4584	}
4590		4585

drivers/gpu/drm/amd/powerplay/hwmgr/vega12_hwmgr.c+10−13

@@ -2243,12 +2243,12 @@ static int vega12_get_sclk_od(struct pp_hwmgr *hwmgr) · 2242 unmodified lines
2243	struct vega12_single_dpm_table *sclk_table = &(data->dpm_table.gfx_table);	2243	struct vega12_single_dpm_table *sclk_table = &(data->dpm_table.gfx_table);
2244	struct vega12_single_dpm_table *golden_sclk_table =	2244	struct vega12_single_dpm_table *golden_sclk_table =
2245	&(data->golden_dpm_table.gfx_table);	2245	&(data->golden_dpm_table.gfx_table);
2246	int value;	2246	int value = sclk_table->dpm_levels[sclk_table->count - 1].value;
		2247	int golden_value = golden_sclk_table->dpm_levels
		2248	[golden_sclk_table->count - 1].value;
2247		2249
2248	value = (sclk_table->dpm_levels[sclk_table->count - 1].value -	2250	value -= golden_value;
2249	golden_sclk_table->dpm_levels[golden_sclk_table->count - 1].value) *	2251	value = DIV_ROUND_UP(value * 100, golden_value);
2250	100 /
2251	golden_sclk_table->dpm_levels[golden_sclk_table->count - 1].value;
2252		2252
2253	return value;	2253	return value;
2254	}	2254	}
@@ -2264,16 +2264,13 @@ static int vega12_get_mclk_od(struct pp_hwmgr *hwmgr) · 9 unmodified lines
2264	struct vega12_single_dpm_table *mclk_table = &(data->dpm_table.mem_table);	2264	struct vega12_single_dpm_table *mclk_table = &(data->dpm_table.mem_table);
2265	struct vega12_single_dpm_table *golden_mclk_table =	2265	struct vega12_single_dpm_table *golden_mclk_table =
2266	&(data->golden_dpm_table.mem_table);	2266	&(data->golden_dpm_table.mem_table);
2267	int value;	2267	int value = mclk_table->dpm_levels[mclk_table->count - 1].value;
2268		2268	int golden_value = golden_mclk_table->dpm_levels
2269	value = (mclk_table->dpm_levels
2270	[mclk_table->count - 1].value -
2271	golden_mclk_table->dpm_levels
2272	[golden_mclk_table->count - 1].value) *
2273	100 /
2274	golden_mclk_table->dpm_levels
2275	[golden_mclk_table->count - 1].value;	2269	[golden_mclk_table->count - 1].value;
2276		2270
		2271	value -= golden_value;
		2272	value = DIV_ROUND_UP(value * 100, golden_value);
		2273
2277	return value;	2274	return value;
2278	}	2275	}
2279		2276

drivers/gpu/drm/amd/powerplay/hwmgr/vega20_hwmgr.c+21−9

 	data->phy_clk_quad_eqn_b = PPREGKEY_VEGA20QUADRATICEQUATION_DFLT;
 	data->phy_clk_quad_eqn_c = PPREGKEY_VEGA20QUADRATICEQUATION_DFLT;
-	data->registry_data.disallowed_features = 0x0;
+	/*
+	 * Disable the following features for now:
+	 *   GFXCLK DS
+	 *   SOCLK DS
+	 *   LCLK DS
+	 *   DCEFCLK DS
+	 *   FCLK DS
+	 *   MP1CLK DS
+	 *   MP0CLK DS
+	 */
+	data->registry_data.disallowed_features = 0xE0041C00;
 	data->registry_data.od_state_in_dc_support = 0;
 	data->registry_data.thermal_support = 1;
 	data->registry_data.skip_baco_hardware = 0;
 			&(data->dpm_table.gfx_table);
 	struct vega20_single_dpm_table *golden_sclk_table =
 			&(data->golden_dpm_table.gfx_table);
-	int value;
+	int value = sclk_table->dpm_levels[sclk_table->count - 1].value;
+	int golden_value = golden_sclk_table->dpm_levels
+			[golden_sclk_table->count - 1].value;
 	/* od percentage */
-	value = DIV_ROUND_UP((sclk_table->dpm_levels[sclk_table->count - 1].value -
+	value -= golden_value;
-		golden_sclk_table->dpm_levels[golden_sclk_table->count - 1].value) * 100,
+	value = DIV_ROUND_UP(value * 100, golden_value);
-		golden_sclk_table->dpm_levels[golden_sclk_table->count - 1].value);
 	return value;
 }
 			&(data->dpm_table.mem_table);
 	struct vega20_single_dpm_table *golden_mclk_table =
 			&(data->golden_dpm_table.mem_table);
-	int value;
+	int value = mclk_table->dpm_levels[mclk_table->count - 1].value;
+	int golden_value = golden_mclk_table->dpm_levels
+			[golden_mclk_table->count - 1].value;
 	/* od percentage */
-	value = DIV_ROUND_UP((mclk_table->dpm_levels[mclk_table->count - 1].value -
+	value -= golden_value;
-		golden_mclk_table->dpm_levels[golden_mclk_table->count - 1].value) * 100,
+	value = DIV_ROUND_UP(value * 100, golden_value);
-		golden_mclk_table->dpm_levels[golden_mclk_table->count - 1].value);
 	return value;
 }

drivers/gpu/drm/ast/ast_drv.c+21−0

@@ -60,8 +60,29 @@ static const struct pci_device_id pciidlist[] = { · 59 unmodified lines
60		60
61	MODULE_DEVICE_TABLE(pci, pciidlist);	61	MODULE_DEVICE_TABLE(pci, pciidlist);
62		62
		63	static void ast_kick_out_firmware_fb(struct pci_dev *pdev)
		64	{
		65	struct apertures_struct *ap;
		66	bool primary = false;
		67
		68	ap = alloc_apertures(1);
		69	if (!ap)
		70	return;
		71
		72	ap->ranges[0].base = pci_resource_start(pdev, 0);
		73	ap->ranges[0].size = pci_resource_len(pdev, 0);
		74
		75	#ifdef CONFIG_X86
		76	primary = pdev->resource[PCI_ROM_RESOURCE].flags & IORESOURCE_ROM_SHADOW;
		77	#endif
		78	drm_fb_helper_remove_conflicting_framebuffers(ap, "astdrmfb", primary);
		79	kfree(ap);
		80	}
		81
63	static int ast_pci_probe(struct pci_dev pdev, const struct pci_device_id ent)	82	static int ast_pci_probe(struct pci_dev pdev, const struct pci_device_id ent)
64	{	83	{
		84	ast_kick_out_firmware_fb(pdev);
		85
65	return drm_get_pci_dev(pdev, ent, &driver);	86	return drm_get_pci_dev(pdev, ent, &driver);
66	}	87	}
67		88

drivers/gpu/drm/ast/ast_mode.c+2−1

 	}
 	ast_bo_unreserve(bo);
+	ast_set_offset_reg(crtc);
 	ast_set_start_address_crt1(crtc, (u32)gpu_addr);
 	return 0;
 	ast_set_index_reg(ast, AST_IO_CRTC_PORT, 0xc7, ((y >> 8) & 0x07));
 	/* dummy write to fire HWC */
-	ast_set_index_reg_mask(ast, AST_IO_CRTC_PORT, 0xCB, 0xFF, 0x00);
+	ast_show_cursor(crtc);
 	return 0;
 }

drivers/gpu/drm/drm_fb_helper.c+3−0

 	mutex_lock(&fb_helper->lock);
 	drm_connector_list_iter_begin(dev, &conn_iter);
 	drm_for_each_connector_iter(connector, &conn_iter) {
+		if (connector->connector_type == DRM_MODE_CONNECTOR_WRITEBACK)
+			continue;
 		ret = __drm_fb_helper_add_one_connector(fb_helper, connector);
 		if (ret)
 			goto fail;

drivers/gpu/drm/i915/i915_gem_execbuffer.c+6−1

 		else if (gen >= 4)
 			len = 4;
 		else
-			len = 3;
+			len = 6;
 		batch = reloc_gpu(eb, vma, len);
 		if (IS_ERR(batch))
 			*batch++ = MI_STORE_DWORD_IMM | MI_MEM_VIRTUAL;
 			*batch++ = addr;
 			*batch++ = target_offset;
+			/* And again for good measure (blb/pnv) */
+			*batch++ = MI_STORE_DWORD_IMM | MI_MEM_VIRTUAL;
+			*batch++ = addr;
+			*batch++ = target_offset;
 		}
 		goto out;

drivers/gpu/drm/i915/i915_gem_gtt.c+5−0

 		ggtt->vm.insert_page    = bxt_vtd_ggtt_insert_page__BKL;
 		if (ggtt->vm.clear_range != nop_clear_range)
 			ggtt->vm.clear_range = bxt_vtd_ggtt_clear_range__BKL;
+		/* Prevent recursively calling stop_machine() and deadlocks. */
+		dev_info(dev_priv->drm.dev,
+			 "Disabling error capture for VT-d workaround\n");
+		i915_disable_error_state(dev_priv, -ENODEV);
 	}
 	ggtt->invalidate = gen6_ggtt_invalidate;

drivers/gpu/drm/i915/i915_gpu_error.c+14−1

 		return 0;
 	}
+	if (IS_ERR(error))
+		return PTR_ERR(error);
 	if (*error->error_msg)
 		err_printf(m, "%s\n", error->error_msg);
 	err_printf(m, "Kernel: " UTS_RELEASE "\n");
 	error = i915_capture_gpu_state(i915);
 	if (!error) {
 		DRM_DEBUG_DRIVER("out of memory, not capturing error state\n");
+		i915_disable_error_state(i915, -ENOMEM);
 		return;
 	}
 	i915->gpu_error.first_error = NULL;
 	spin_unlock_irq(&i915->gpu_error.lock);
-	i915_gpu_state_put(error);
+	if (!IS_ERR(error))
+		i915_gpu_state_put(error);
+}
+void i915_disable_error_state(struct drm_i915_private *i915, int err)
+{
+	spin_lock_irq(&i915->gpu_error.lock);
+	if (!i915->gpu_error.first_error)
+		i915->gpu_error.first_error = ERR_PTR(err);
+	spin_unlock_irq(&i915->gpu_error.lock);
 }

drivers/gpu/drm/i915/i915_gpu_error.h+7−1

 struct i915_gpu_state *i915_first_error_state(struct drm_i915_private *i915);
 void i915_reset_error_state(struct drm_i915_private *i915);
+void i915_disable_error_state(struct drm_i915_private *i915, int err);
 #else
 static inline struct i915_gpu_state *
 i915_first_error_state(struct drm_i915_private *i915)
 {
-	return NULL;
+	return ERR_PTR(-ENODEV);
 }
 static inline void i915_reset_error_state(struct drm_i915_private *i915)
 {
 }
+static inline void i915_disable_error_state(struct drm_i915_private *i915,
+					    int err)
+{
+}
 #endif /* IS_ENABLED(CONFIG_DRM_I915_CAPTURE_ERROR) */
 #endif /* _I915_GPU_ERROR_H_ */

drivers/gpu/drm/i915/intel_display.c+39−0

@@ -2890,6 +2890,7 @@ intel_find_initial_plane_obj(struct intel_crtc *intel_crtc, · 2889 unmodified lines
2890	return;	2890	return;
2891		2891
2892	valid_fb:	2892	valid_fb:
		2893	intel_state->base.rotation = plane_config->rotation;
2893	intel_fill_fb_ggtt_view(&intel_state->view, fb,	2894	intel_fill_fb_ggtt_view(&intel_state->view, fb,
2894	intel_state->base.rotation);	2895	intel_state->base.rotation);
2895	intel_state->color_plane[0].stride =	2896	intel_state->color_plane[0].stride =
@@ -7882,8 +7883,15 @@ i9xx_get_initial_plane_config(struct intel_crtc *crtc, · 4986 unmodified lines
7882	plane_config->tiling = I915_TILING_X;	7883	plane_config->tiling = I915_TILING_X;
7883	fb->modifier = I915_FORMAT_MOD_X_TILED;	7884	fb->modifier = I915_FORMAT_MOD_X_TILED;
7884	}	7885	}
		7886
		7887	if (val & DISPPLANE_ROTATE_180)
		7888	plane_config->rotation = DRM_MODE_ROTATE_180;
7885	}	7889	}
7886		7890
		7891	if (IS_CHERRYVIEW(dev_priv) && pipe == PIPE_B &&
		7892	val & DISPPLANE_MIRROR)
		7893	plane_config->rotation \|= DRM_MODE_REFLECT_X;
		7894
7887	pixel_format = val & DISPPLANE_PIXFORMAT_MASK;	7895	pixel_format = val & DISPPLANE_PIXFORMAT_MASK;
7888	fourcc = i9xx_format_to_fourcc(pixel_format);	7896	fourcc = i9xx_format_to_fourcc(pixel_format);
7889	fb->format = drm_format_info(fourcc);	7897	fb->format = drm_format_info(fourcc);
@@ -8952,6 +8960,29 @@ skylake_get_initial_plane_config(struct intel_crtc *crtc, · 1062 unmodified lines
8952	goto error;	8960	goto error;
8953	}	8961	}
8954		8962
		8963	/*
		8964	* DRM_MODE_ROTATE_ is counter clockwise to stay compatible with Xrandr
		8965	* while i915 HW rotation is clockwise, thats why this swapping.
		8966	*/
		8967	switch (val & PLANE_CTL_ROTATE_MASK) {
		8968	case PLANE_CTL_ROTATE_0:
		8969	plane_config->rotation = DRM_MODE_ROTATE_0;
		8970	break;
		8971	case PLANE_CTL_ROTATE_90:
		8972	plane_config->rotation = DRM_MODE_ROTATE_270;
		8973	break;
		8974	case PLANE_CTL_ROTATE_180:
		8975	plane_config->rotation = DRM_MODE_ROTATE_180;
		8976	break;
		8977	case PLANE_CTL_ROTATE_270:
		8978	plane_config->rotation = DRM_MODE_ROTATE_90;
		8979	break;
		8980	}
		8981
		8982	if (INTEL_GEN(dev_priv) >= 10 &&
		8983	val & PLANE_CTL_FLIP_HORIZONTAL)
		8984	plane_config->rotation \|= DRM_MODE_REFLECT_X;
		8985
8955	base = I915_READ(PLANE_SURF(pipe, plane_id)) & 0xfffff000;	8986	base = I915_READ(PLANE_SURF(pipe, plane_id)) & 0xfffff000;
8956	plane_config->base = base;	8987	plane_config->base = base;
8957		8988
@@ -15267,6 +15298,14 @@ retry: · 6309 unmodified lines
15267	ret = drm_atomic_add_affected_planes(state, crtc);	15298	ret = drm_atomic_add_affected_planes(state, crtc);
15268	if (ret)	15299	if (ret)
15269	goto out;	15300	goto out;
		15301
		15302	/*
		15303	* FIXME hack to force a LUT update to avoid the
		15304	* plane update forcing the pipe gamma on without
		15305	* having a proper LUT loaded. Remove once we
		15306	* have readout for pipe gamma enable.
		15307	*/
		15308	crtc_state->color_mgmt_changed = true;
15270	}	15309	}
15271	}	15310	}
15272		15311

drivers/gpu/drm/i915/intel_drv.h+1−0

@@ -547,6 +547,7 @@ struct intel_initial_plane_config { · 546 unmodified lines
547	unsigned int tiling;	547	unsigned int tiling;
548	int size;	548	int size;
549	u32 base;	549	u32 base;
		550	u8 rotation;
550	};	551	};
551		552
552	#define SKL_MIN_SRC_W 8	553	#define SKL_MIN_SRC_W 8

drivers/gpu/drm/i915/intel_pm.c+40−1

@@ -2493,6 +2493,9 @@ static uint32_t ilk_compute_pri_wm(const struct intel_crtc_state *cstate, · 2492 unmodified lines
2493	uint32_t method1, method2;	2493	uint32_t method1, method2;
2494	int cpp;	2494	int cpp;
2495		2495
		2496	if (mem_value == 0)
		2497	return U32_MAX;
		2498
2496	if (!intel_wm_plane_visible(cstate, pstate))	2499	if (!intel_wm_plane_visible(cstate, pstate))
2497	return 0;	2500	return 0;
2498		2501
@@ -2522,6 +2525,9 @@ static uint32_t ilk_compute_spr_wm(const struct intel_crtc_state *cstate, · 23 unmodified lines
2522	uint32_t method1, method2;	2525	uint32_t method1, method2;
2523	int cpp;	2526	int cpp;
2524		2527
		2528	if (mem_value == 0)
		2529	return U32_MAX;
		2530
2525	if (!intel_wm_plane_visible(cstate, pstate))	2531	if (!intel_wm_plane_visible(cstate, pstate))
2526	return 0;	2532	return 0;
2527		2533
@@ -2545,6 +2551,9 @@ static uint32_t ilk_compute_cur_wm(const struct intel_crtc_state *cstate, · 17 unmodified lines
2545	{	2551	{
2546	int cpp;	2552	int cpp;
2547		2553
		2554	if (mem_value == 0)
		2555	return U32_MAX;
		2556
2548	if (!intel_wm_plane_visible(cstate, pstate))	2557	if (!intel_wm_plane_visible(cstate, pstate))
2549	return 0;	2558	return 0;
2550		2559
@@ -3008,6 +3017,34 @@ static void snb_wm_latency_quirk(struct drm_i915_private *dev_priv) · 457 unmodified lines
3008	intel_print_wm_latency(dev_priv, "Cursor", dev_priv->wm.cur_latency);	3017	intel_print_wm_latency(dev_priv, "Cursor", dev_priv->wm.cur_latency);
3009	}	3018	}
3010		3019
		3020	static void snb_wm_lp3_irq_quirk(struct drm_i915_private *dev_priv)
		3021	{
		3022	/*
		3023	* On some SNB machines (Thinkpad X220 Tablet at least)
		3024	* LP3 usage can cause vblank interrupts to be lost.
		3025	* The DEIIR bit will go high but it looks like the CPU
		3026	* never gets interrupted.
		3027	*
		3028	* It's not clear whether other interrupt source could
		3029	* be affected or if this is somehow limited to vblank
		3030	* interrupts only. To play it safe we disable LP3
		3031	* watermarks entirely.
		3032	*/
		3033	if (dev_priv->wm.pri_latency[3] == 0 &&
		3034	dev_priv->wm.spr_latency[3] == 0 &&
		3035	dev_priv->wm.cur_latency[3] == 0)
		3036	return;
		3037
		3038	dev_priv->wm.pri_latency[3] = 0;
		3039	dev_priv->wm.spr_latency[3] = 0;
		3040	dev_priv->wm.cur_latency[3] = 0;
		3041
		3042	DRM_DEBUG_KMS("LP3 watermarks disabled due to potential for lost interrupts\n");
		3043	intel_print_wm_latency(dev_priv, "Primary", dev_priv->wm.pri_latency);
		3044	intel_print_wm_latency(dev_priv, "Sprite", dev_priv->wm.spr_latency);
		3045	intel_print_wm_latency(dev_priv, "Cursor", dev_priv->wm.cur_latency);
		3046	}
		3047
3011	static void ilk_setup_wm_latency(struct drm_i915_private *dev_priv)	3048	static void ilk_setup_wm_latency(struct drm_i915_private *dev_priv)
3012	{	3049	{
3013	intel_read_wm_latency(dev_priv, dev_priv->wm.pri_latency);	3050	intel_read_wm_latency(dev_priv, dev_priv->wm.pri_latency);
@@ -3024,8 +3061,10 @@ static void ilk_setup_wm_latency(struct drm_i915_private *dev_priv) · 10 unmodified lines
3024	intel_print_wm_latency(dev_priv, "Sprite", dev_priv->wm.spr_latency);	3061	intel_print_wm_latency(dev_priv, "Sprite", dev_priv->wm.spr_latency);
3025	intel_print_wm_latency(dev_priv, "Cursor", dev_priv->wm.cur_latency);	3062	intel_print_wm_latency(dev_priv, "Cursor", dev_priv->wm.cur_latency);
3026		3063
3027	if (IS_GEN6(dev_priv))	3064	if (IS_GEN6(dev_priv)) {
3028	snb_wm_latency_quirk(dev_priv);	3065	snb_wm_latency_quirk(dev_priv);
		3066	snb_wm_lp3_irq_quirk(dev_priv);
		3067	}
3029	}	3068	}
3030		3069
3031	static void skl_setup_wm_latency(struct drm_i915_private *dev_priv)	3070	static void skl_setup_wm_latency(struct drm_i915_private *dev_priv)

drivers/gpu/drm/vc4/vc4_kms.c+6−0

 		return 0;
 	}
+	/* We know for sure we don't want an async update here. Set
+	 * state->legacy_cursor_update to false to prevent
+	 * drm_atomic_helper_setup_commit() from auto-completing
+	 * commit->flip_done.
+	 */
+	state->legacy_cursor_update = false;
 	ret = drm_atomic_helper_setup_commit(state, nonblock);
 	if (ret)
 		return ret;

drivers/gpu/drm/vc4/vc4_plane.c+13−2

 static void vc4_plane_atomic_async_update(struct drm_plane *plane,
 					  struct drm_plane_state *state)
 {
-	struct vc4_plane_state *vc4_state = to_vc4_plane_state(plane->state);
+	struct vc4_plane_state *vc4_state, *new_vc4_state;
 	if (plane->state->fb != state->fb) {
 		vc4_plane_async_set_fb(plane, state->fb);
 	plane->state->src_y = state->src_y;
 	/* Update the display list based on the new crtc_x/y. */
-	vc4_plane_atomic_check(plane, plane->state);
+	vc4_plane_atomic_check(plane, state);
+	new_vc4_state = to_vc4_plane_state(state);
+	vc4_state = to_vc4_plane_state(plane->state);
+	/* Update the current vc4_state pos0, pos2 and ptr0 dlist entries. */
+	vc4_state->dlist[vc4_state->pos0_offset] =
+		new_vc4_state->dlist[vc4_state->pos0_offset];
+	vc4_state->dlist[vc4_state->pos2_offset] =
+		new_vc4_state->dlist[vc4_state->pos2_offset];
+	vc4_state->dlist[vc4_state->ptr0_offset] =
+		new_vc4_state->dlist[vc4_state->ptr0_offset];
 	/* Note that we can't just call vc4_plane_write_dlist()
 	 * because that would smash the context data that the HVS is

drivers/hv/hv_kvp.c+22−4

@@ -353,6 +353,9 @@ static void process_ib_ipinfo(void in_msg, void out_msg, int op) · 352 unmodified lines
353		353
354	out->body.kvp_ip_val.dhcp_enabled = in->kvp_ip_val.dhcp_enabled;	354	out->body.kvp_ip_val.dhcp_enabled = in->kvp_ip_val.dhcp_enabled;
355		355
		356	/* fallthrough */
		357
		358	case KVP_OP_GET_IP_INFO:
356	utf16s_to_utf8s((wchar_t *)in->kvp_ip_val.adapter_id,	359	utf16s_to_utf8s((wchar_t *)in->kvp_ip_val.adapter_id,
357	MAX_ADAPTER_ID_SIZE,	360	MAX_ADAPTER_ID_SIZE,
358	UTF16_LITTLE_ENDIAN,	361	UTF16_LITTLE_ENDIAN,
@@ -405,7 +408,11 @@ kvp_send_key(struct work_struct *dummy) · 46 unmodified lines
405	process_ib_ipinfo(in_msg, message, KVP_OP_SET_IP_INFO);	408	process_ib_ipinfo(in_msg, message, KVP_OP_SET_IP_INFO);
406	break;	409	break;
407	case KVP_OP_GET_IP_INFO:	410	case KVP_OP_GET_IP_INFO:
408	/* We only need to pass on message->kvp_hdr.operation. */	411	/*
		412	* We only need to pass on the info of operation, adapter_id
		413	* and addr_family to the userland kvp daemon.
		414	*/
		415	process_ib_ipinfo(in_msg, message, KVP_OP_GET_IP_INFO);
409	break;	416	break;
410	case KVP_OP_SET:	417	case KVP_OP_SET:
411	switch (in_msg->body.kvp_set.data.value_type) {	418	switch (in_msg->body.kvp_set.data.value_type) {
@@ -446,9 +453,9 @@ kvp_send_key(struct work_struct *dummy) · 34 unmodified lines
446		453
447	}	454	}
448		455
449	break;	456	/*
450		457	* The key is always a string - utf16 encoding.
451	case KVP_OP_GET:	458	*/
452	message->body.kvp_set.data.key_size =	459	message->body.kvp_set.data.key_size =
453	utf16s_to_utf8s(	460	utf16s_to_utf8s(
454	(wchar_t *)in_msg->body.kvp_set.data.key,	461	(wchar_t *)in_msg->body.kvp_set.data.key,
@@ -456,6 +463,17 @@ kvp_send_key(struct work_struct *dummy) · 1 unmodified line
456	UTF16_LITTLE_ENDIAN,	463	UTF16_LITTLE_ENDIAN,
457	message->body.kvp_set.data.key,	464	message->body.kvp_set.data.key,
458	HV_KVP_EXCHANGE_MAX_KEY_SIZE - 1) + 1;	465	HV_KVP_EXCHANGE_MAX_KEY_SIZE - 1) + 1;
		466
		467	break;
		468
		469	case KVP_OP_GET:
		470	message->body.kvp_get.data.key_size =
		471	utf16s_to_utf8s(
		472	(wchar_t *)in_msg->body.kvp_get.data.key,
		473	in_msg->body.kvp_get.data.key_size,
		474	UTF16_LITTLE_ENDIAN,
		475	message->body.kvp_get.data.key,
		476	HV_KVP_EXCHANGE_MAX_KEY_SIZE - 1) + 1;
459	break;	477	break;
460		478
461	case KVP_OP_DELETE:	479	case KVP_OP_DELETE:

drivers/iommu/amd_iommu_init.c+2−1

 	entry = iommu_virt_to_phys(iommu->ga_log) | GA_LOG_SIZE_512;
 	memcpy_toio(iommu->mmio_base + MMIO_GA_LOG_BASE_OFFSET,
 		    &entry, sizeof(entry));
-	entry = (iommu_virt_to_phys(iommu->ga_log) & 0xFFFFFFFFFFFFFULL) & ~7ULL;
+	entry = (iommu_virt_to_phys(iommu->ga_log_tail) &
+		 (BIT_ULL(52)-1)) & ~7ULL;
 	memcpy_toio(iommu->mmio_base + MMIO_GA_LOG_TAIL_OFFSET,
 		    &entry, sizeof(entry));
 	writel(0x00, iommu->mmio_base + MMIO_GA_HEAD_OFFSET);

drivers/iommu/intel-iommu.c+1−1

@@ -3075,7 +3075,7 @@ static int copy_context_table(struct intel_iommu *iommu, · 3074 unmodified lines
3075	}	3075	}
3076		3076
3077	if (old_ce)	3077	if (old_ce)
3078	iounmap(old_ce);	3078	memunmap(old_ce);
3079		3079
3080	ret = 0;	3080	ret = 0;
3081	if (devfn < 0x80)	3081	if (devfn < 0x80)

drivers/iommu/intel-svm.c+1−1

@@ -595,7 +595,7 @@ static irqreturn_t prq_event_thread(int irq, void *d) · 594 unmodified lines
595	pr_err("%s: Page request without PASID: %08llx %08llx\n",	595	pr_err("%s: Page request without PASID: %08llx %08llx\n",
596	iommu->name, ((unsigned long long *)req)[0],	596	iommu->name, ((unsigned long long *)req)[0],
597	((unsigned long long *)req)[1]);	597	((unsigned long long *)req)[1]);
598	goto bad_req;	598	goto no_pasid;
599	}	599	}
600		600
601	if (!svm \|\| svm->pasid != req->pasid) {	601	if (!svm \|\| svm->pasid != req->pasid) {

drivers/iommu/ipmmu-vmsa.c+3−0

@@ -498,6 +498,9 @@ static int ipmmu_domain_init_context(struct ipmmu_vmsa_domain *domain) · 497 unmodified lines
498		498
499	static void ipmmu_domain_destroy_context(struct ipmmu_vmsa_domain *domain)	499	static void ipmmu_domain_destroy_context(struct ipmmu_vmsa_domain *domain)
500	{	500	{
		501	if (!domain->mmu)
		502	return;
		503
501	/*	504	/*
502	* Disable the context. Flush the TLB as required when modifying the	505	* Disable the context. Flush the TLB as required when modifying the
503	* context registers.	506	* context registers.

drivers/media/cec/cec-adap.c+38−11

 	}
 	if (adap->transmit_queue_sz >= CEC_MAX_MSG_TX_QUEUE_SZ) {
-		dprintk(1, "%s: transmit queue full\n", __func__);
+		dprintk(2, "%s: transmit queue full\n", __func__);
 		return -EBUSY;
 	}
 {
 	struct cec_log_addrs *las = &adap->log_addrs;
 	struct cec_msg msg = { };
+	const unsigned int max_retries = 2;
+	unsigned int i;
 	int err;
 	if (cec_has_log_addr(adap, log_addr))
 	/* Send poll message */
 	msg.len = 1;
 	msg.msg[0] = (log_addr << 4) | log_addr;
-	err = cec_transmit_msg_fh(adap, &msg, NULL, true);
-	/*
+	for (i = 0; i < max_retries; i++) {
-	 * While trying to poll the physical address was reset
+		err = cec_transmit_msg_fh(adap, &msg, NULL, true);
-	 * and the adapter was unconfigured, so bail out.
-	 */
-	if (!adap->is_configuring)
-		return -EINTR;
-	if (err)
+		/*
-		return err;
+		 * While trying to poll the physical address was reset
+		 * and the adapter was unconfigured, so bail out.
+		 */
+		if (!adap->is_configuring)
+			return -EINTR;
+		if (err)
+			return err;
-	if (msg.tx_status & CEC_TX_STATUS_OK)
+		/*
+		 * The message was aborted due to a disconnect or
+		 * unconfigure, just bail out.
+		 */
+		if (msg.tx_status & CEC_TX_STATUS_ABORTED)
+			return -EINTR;
+		if (msg.tx_status & CEC_TX_STATUS_OK)
+			return 0;
+		if (msg.tx_status & CEC_TX_STATUS_NACK)
+			break;
+		/*
+		 * Retry up to max_retries times if the message was neither
+		 * OKed or NACKed. This can happen due to e.g. a Lost
+		 * Arbitration condition.
+		 */
+	}
+	/*
+	 * If we are unable to get an OK or a NACK after max_retries attempts
+	 * (and note that each attempt already consists of four polls), then
+	 * then we assume that something is really weird and that it is not a
+	 * good idea to try and claim this logical address.
+	 */
+	if (i == max_retries)
 		return 0;
 	/*

drivers/media/i2c/tc358743.c+0−1

@@ -1918,7 +1918,6 @@ static int tc358743_probe_of(struct tc358743_state *state) · 1917 unmodified lines
1918	ret = v4l2_fwnode_endpoint_alloc_parse(of_fwnode_handle(ep), &endpoint);	1918	ret = v4l2_fwnode_endpoint_alloc_parse(of_fwnode_handle(ep), &endpoint);
1919	if (ret) {	1919	if (ret) {
1920	dev_err(dev, "failed to parse endpoint\n");	1920	dev_err(dev, "failed to parse endpoint\n");
1921	ret = ret;
1922	goto put_node;	1921	goto put_node;
1923	}	1922	}
1924		1923

drivers/media/pci/intel/ipu3/ipu3-cio2.c+2−4

 static void cio2_pci_remove(struct pci_dev *pci_dev)
 {
 	struct cio2_device *cio2 = pci_get_drvdata(pci_dev);
-	unsigned int i;
+	media_device_unregister(&cio2->media_dev);
 	cio2_notifier_exit(cio2);
+	cio2_queues_exit(cio2);
 	cio2_fbpt_exit_dummy(cio2);
-	for (i = 0; i < CIO2_QUEUES; i++)
-		cio2_queue_exit(cio2, &cio2->queue[i]);
 	v4l2_device_unregister(&cio2->v4l2_dev);
-	media_device_unregister(&cio2->media_dev);
 	media_device_cleanup(&cio2->media_dev);
 	mutex_destroy(&cio2->lock);
 }

drivers/media/platform/omap3isp/isp.c+2−1

 static void isp_unregister_entities(struct isp_device *isp)
 {
+	media_device_unregister(&isp->media_dev);
 	omap3isp_csi2_unregister_entities(&isp->isp_csi2a);
 	omap3isp_ccp2_unregister_entities(&isp->isp_ccp2);
 	omap3isp_ccdc_unregister_entities(&isp->isp_ccdc);
 	omap3isp_stat_unregister_entities(&isp->isp_hist);
 	v4l2_device_unregister(&isp->v4l2_dev);
-	media_device_unregister(&isp->media_dev);
 	media_device_cleanup(&isp->media_dev);
 }

drivers/media/platform/vicodec/vicodec-core.c+1−1

@@ -42,7 +42,7 @@ MODULE_PARM_DESC(debug, " activates debug info"); · 41 unmodified lines
42	#define MAX_WIDTH 4096U	42	#define MAX_WIDTH 4096U
43	#define MIN_WIDTH 640U	43	#define MIN_WIDTH 640U
44	#define MAX_HEIGHT 2160U	44	#define MAX_HEIGHT 2160U
45	#define MIN_HEIGHT 480U	45	#define MIN_HEIGHT 360U
46		46
47	#define dprintk(dev, fmt, arg...) \	47	#define dprintk(dev, fmt, arg...) \
48	v4l2_dbg(1, debug, &dev->v4l2_dev, "%s: " fmt, __func__, ## arg)	48	v4l2_dbg(1, debug, &dev->v4l2_dev, "%s: " fmt, __func__, ## arg)

drivers/media/platform/vim2m.c+1−1

@@ -1009,7 +1009,7 @@ static const struct v4l2_m2m_ops m2m_ops = { · 1008 unmodified lines
1009		1009
1010	static const struct media_device_ops m2m_media_ops = {	1010	static const struct media_device_ops m2m_media_ops = {
1011	.req_validate = vb2_request_validate,	1011	.req_validate = vb2_request_validate,
1012	.req_queue = vb2_m2m_request_queue,	1012	.req_queue = v4l2_m2m_request_queue,
1013	};	1013	};
1014		1014
1015	static int vim2m_probe(struct platform_device *pdev)	1015	static int vim2m_probe(struct platform_device *pdev)

drivers/media/v4l2-core/v4l2-ctrls.c+5−0

 		    p_mpeg2_slice_params->forward_ref_index >= VIDEO_MAX_FRAME)
 			return -EINVAL;
+		if (p_mpeg2_slice_params->pad ||
+		    p_mpeg2_slice_params->picture.pad ||
+		    p_mpeg2_slice_params->sequence.pad)
+			return -EINVAL;
 		return 0;
 	case V4L2_CTRL_TYPE_MPEG2_QUANTIZATION:

drivers/media/v4l2-core/v4l2-event.c+24−19

 }
 EXPORT_SYMBOL_GPL(v4l2_event_pending);
+static void __v4l2_event_unsubscribe(struct v4l2_subscribed_event *sev)
+{
+	struct v4l2_fh *fh = sev->fh;
+	unsigned int i;
+	lockdep_assert_held(&fh->subscribe_lock);
+	assert_spin_locked(&fh->vdev->fh_lock);
+	/* Remove any pending events for this subscription */
+	for (i = 0; i < sev->in_use; i++) {
+		list_del(&sev->events[sev_pos(sev, i)].list);
+		fh->navailable--;
+	}
+	list_del(&sev->list);
+}
 int v4l2_event_subscribe(struct v4l2_fh *fh,
 			 const struct v4l2_event_subscription *sub, unsigned elems,
 			 const struct v4l2_subscribed_event_ops *ops)
 	spin_lock_irqsave(&fh->vdev->fh_lock, flags);
 	found_ev = v4l2_event_subscribed(fh, sub->type, sub->id);
+	if (!found_ev)
+		list_add(&sev->list, &fh->subscribed);
 	spin_unlock_irqrestore(&fh->vdev->fh_lock, flags);
 	if (found_ev) {
 		/* Already listening */
 		kvfree(sev);
-		goto out_unlock;
+	} else if (sev->ops && sev->ops->add) {
-	}
-	if (sev->ops && sev->ops->add) {
 		ret = sev->ops->add(sev, elems);
 		if (ret) {
+			spin_lock_irqsave(&fh->vdev->fh_lock, flags);
+			__v4l2_event_unsubscribe(sev);
+			spin_unlock_irqrestore(&fh->vdev->fh_lock, flags);
 			kvfree(sev);
-			goto out_unlock;
 		}
 	}
-	spin_lock_irqsave(&fh->vdev->fh_lock, flags);
-	list_add(&sev->list, &fh->subscribed);
-	spin_unlock_irqrestore(&fh->vdev->fh_lock, flags);
-out_unlock:
 	mutex_unlock(&fh->subscribe_lock);
 	return ret;
 {
 	struct v4l2_subscribed_event *sev;
 	unsigned long flags;
-	int i;
 	if (sub->type == V4L2_EVENT_ALL) {
 		v4l2_event_unsubscribe_all(fh);
 	spin_lock_irqsave(&fh->vdev->fh_lock, flags);
 	sev = v4l2_event_subscribed(fh, sub->type, sub->id);
-	if (sev != NULL) {
+	if (sev != NULL)
-		/* Remove any pending events for this subscription */
+		__v4l2_event_unsubscribe(sev);
-		for (i = 0; i < sev->in_use; i++) {
-			list_del(&sev->events[sev_pos(sev, i)].list);
-			fh->navailable--;
-		}
-		list_del(&sev->list);
-	}
 	spin_unlock_irqrestore(&fh->vdev->fh_lock, flags);

drivers/media/v4l2-core/v4l2-mem2mem.c+2−2

@@ -953,7 +953,7 @@ void v4l2_m2m_buf_queue(struct v4l2_m2m_ctx *m2m_ctx, · 952 unmodified lines
953	}	953	}
954	EXPORT_SYMBOL_GPL(v4l2_m2m_buf_queue);	954	EXPORT_SYMBOL_GPL(v4l2_m2m_buf_queue);
955		955
956	void vb2_m2m_request_queue(struct media_request *req)	956	void v4l2_m2m_request_queue(struct media_request *req)
957	{	957	{
958	struct media_request_object obj, obj_safe;	958	struct media_request_object obj, obj_safe;
959	struct v4l2_m2m_ctx *m2m_ctx = NULL;	959	struct v4l2_m2m_ctx *m2m_ctx = NULL;
@@ -997,7 +997,7 @@ void vb2_m2m_request_queue(struct media_request *req) · 37 unmodified lines
997	if (m2m_ctx)	997	if (m2m_ctx)
998	v4l2_m2m_try_schedule(m2m_ctx);	998	v4l2_m2m_try_schedule(m2m_ctx);
999	}	999	}
1000	EXPORT_SYMBOL_GPL(vb2_m2m_request_queue);	1000	EXPORT_SYMBOL_GPL(v4l2_m2m_request_queue);
1001		1001
1002	/* Videobuf2 ioctl helpers */	1002	/* Videobuf2 ioctl helpers */
1003		1003

drivers/misc/atmel-ssc.c+1−1

@@ -132,7 +132,7 @@ static const struct of_device_id atmel_ssc_dt_ids[] = { · 131 unmodified lines
132	MODULE_DEVICE_TABLE(of, atmel_ssc_dt_ids);	132	MODULE_DEVICE_TABLE(of, atmel_ssc_dt_ids);
133	#endif	133	#endif
134		134
135	static inline const struct atmel_ssc_platform_data * __init	135	static inline const struct atmel_ssc_platform_data *
136	atmel_ssc_get_driver_data(struct platform_device *pdev)	136	atmel_ssc_get_driver_data(struct platform_device *pdev)
137	{	137	{
138	if (pdev->dev.of_node) {	138	if (pdev->dev.of_node) {

drivers/misc/sgi-gru/grukdump.c+4−0

 #include <linux/delay.h>
 #include <linux/bitops.h>
 #include <asm/uv/uv_hub.h>
+#include <linux/nospec.h>
 #include "gru.h"
 #include "grutables.h"
 #include "gruhandles.h"
 	/* Currently, only dump by gid is implemented */
 	if (req.gid >= gru_max_gids)
 		return -EINVAL;
+	req.gid = array_index_nospec(req.gid, gru_max_gids);
 	gru = GID_TO_GRU(req.gid);
 	ubuf = req.buf;

drivers/mmc/host/sdhci-pci-core.c+83−3

@@ -12,6 +12,7 @@ · 11 unmodified lines
12	* - JMicron (hardware and technical support)	12	* - JMicron (hardware and technical support)
13	*/	13	*/
14		14
		15	#include <linux/bitfield.h>
15	#include <linux/string.h>	16	#include <linux/string.h>
16	#include <linux/delay.h>	17	#include <linux/delay.h>
17	#include <linux/highmem.h>	18	#include <linux/highmem.h>
@@ -462,6 +463,9 @@ struct intel_host { · 444 unmodified lines
462	u32 dsm_fns;	463	u32 dsm_fns;
463	int drv_strength;	464	int drv_strength;
464	bool d3_retune;	465	bool d3_retune;
		466	bool rpm_retune_ok;
		467	u32 glk_rx_ctrl1;
		468	u32 glk_tun_val;
465	};	469	};
466		470
467	static const guid_t intel_dsm_guid =	471	static const guid_t intel_dsm_guid =
@@ -791,6 +795,77 @@ cleanup: · 323 unmodified lines
791	return ret;	795	return ret;
792	}	796	}
793		797
		798	#ifdef CONFIG_PM
		799	#define GLK_RX_CTRL1 0x834
		800	#define GLK_TUN_VAL 0x840
		801	#define GLK_PATH_PLL GENMASK(13, 8)
		802	#define GLK_DLY GENMASK(6, 0)
		803	/* Workaround firmware failing to restore the tuning value */
		804	static void glk_rpm_retune_wa(struct sdhci_pci_chip *chip, bool susp)
		805	{
		806	struct sdhci_pci_slot *slot = chip->slots[0];
		807	struct intel_host *intel_host = sdhci_pci_priv(slot);
		808	struct sdhci_host *host = slot->host;
		809	u32 glk_rx_ctrl1;
		810	u32 glk_tun_val;
		811	u32 dly;
		812
		813	if (intel_host->rpm_retune_ok \|\| !mmc_can_retune(host->mmc))
		814	return;
		815
		816	glk_rx_ctrl1 = sdhci_readl(host, GLK_RX_CTRL1);
		817	glk_tun_val = sdhci_readl(host, GLK_TUN_VAL);
		818
		819	if (susp) {
		820	intel_host->glk_rx_ctrl1 = glk_rx_ctrl1;
		821	intel_host->glk_tun_val = glk_tun_val;
		822	return;
		823	}
		824
		825	if (!intel_host->glk_tun_val)
		826	return;
		827
		828	if (glk_rx_ctrl1 != intel_host->glk_rx_ctrl1) {
		829	intel_host->rpm_retune_ok = true;
		830	return;
		831	}
		832
		833	dly = FIELD_PREP(GLK_DLY, FIELD_GET(GLK_PATH_PLL, glk_rx_ctrl1) +
		834	(intel_host->glk_tun_val << 1));
		835	if (dly == FIELD_GET(GLK_DLY, glk_rx_ctrl1))
		836	return;
		837
		838	glk_rx_ctrl1 = (glk_rx_ctrl1 & ~GLK_DLY) \| dly;
		839	sdhci_writel(host, glk_rx_ctrl1, GLK_RX_CTRL1);
		840
		841	intel_host->rpm_retune_ok = true;
		842	chip->rpm_retune = true;
		843	mmc_retune_needed(host->mmc);
		844	pr_info("%s: Requiring re-tune after rpm resume", mmc_hostname(host->mmc));
		845	}
		846
		847	static void glk_rpm_retune_chk(struct sdhci_pci_chip *chip, bool susp)
		848	{
		849	if (chip->pdev->device == PCI_DEVICE_ID_INTEL_GLK_EMMC &&
		850	!chip->rpm_retune)
		851	glk_rpm_retune_wa(chip, susp);
		852	}
		853
		854	static int glk_runtime_suspend(struct sdhci_pci_chip *chip)
		855	{
		856	glk_rpm_retune_chk(chip, true);
		857
		858	return sdhci_cqhci_runtime_suspend(chip);
		859	}
		860
		861	static int glk_runtime_resume(struct sdhci_pci_chip *chip)
		862	{
		863	glk_rpm_retune_chk(chip, false);
		864
		865	return sdhci_cqhci_runtime_resume(chip);
		866	}
		867	#endif
		868
794	#ifdef CONFIG_ACPI	869	#ifdef CONFIG_ACPI
795	static int ni_set_max_freq(struct sdhci_pci_slot *slot)	870	static int ni_set_max_freq(struct sdhci_pci_slot *slot)
796	{	871	{
@@ -879,8 +954,8 @@ static const struct sdhci_pci_fixes sdhci_intel_glk_emmc = { · 82 unmodified lines
879	.resume = sdhci_cqhci_resume,	954	.resume = sdhci_cqhci_resume,
880	#endif	955	#endif
881	#ifdef CONFIG_PM	956	#ifdef CONFIG_PM
882	.runtime_suspend = sdhci_cqhci_runtime_suspend,	957	.runtime_suspend = glk_runtime_suspend,
883	.runtime_resume = sdhci_cqhci_runtime_resume,	958	.runtime_resume = glk_runtime_resume,
884	#endif	959	#endif
885	.quirks = SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC,	960	.quirks = SDHCI_QUIRK_NO_ENDATTR_IN_NOPDESC,
886	.quirks2 = SDHCI_QUIRK2_PRESET_VALUE_BROKEN \|	961	.quirks2 = SDHCI_QUIRK2_PRESET_VALUE_BROKEN \|
@@ -1762,8 +1837,13 @@ static struct sdhci_pci_slot *sdhci_pci_probe_slot( · 875 unmodified lines
1762	device_init_wakeup(&pdev->dev, true);	1837	device_init_wakeup(&pdev->dev, true);
1763		1838
1764	if (slot->cd_idx >= 0) {	1839	if (slot->cd_idx >= 0) {
1765	ret = mmc_gpiod_request_cd(host->mmc, NULL, slot->cd_idx,	1840	ret = mmc_gpiod_request_cd(host->mmc, "cd", slot->cd_idx,
1766	slot->cd_override_level, 0, NULL);	1841	slot->cd_override_level, 0, NULL);
		1842	if (ret && ret != -EPROBE_DEFER)
		1843	ret = mmc_gpiod_request_cd(host->mmc, NULL,
		1844	slot->cd_idx,
		1845	slot->cd_override_level,
		1846	0, NULL);
1767	if (ret == -EPROBE_DEFER)	1847	if (ret == -EPROBE_DEFER)
1768	goto remove;	1848	goto remove;
1769		1849

drivers/mtd/nand/raw/atmel/nand-controller.c+7−4

 	int ret;
 	nand_np = dev->of_node;
-	nfc_np = of_find_compatible_node(dev->of_node, NULL,
+	nfc_np = of_get_compatible_child(dev->of_node, "atmel,sama5d3-nfc");
-					 "atmel,sama5d3-nfc");
 	if (!nfc_np) {
 		dev_err(dev, "Could not find device node for sama5d3-nfc\n");
 		return -ENODEV;
 	}
 	if (caps->legacy_of_bindings) {
+		struct device_node *nfc_node;
 		u32 ale_offs = 21;
 		/*
 		 * If we are parsing legacy DT props and the DT contains a
 		 * valid NFC node, forward the request to the sama5 logic.
 		 */
-		if (of_find_compatible_node(pdev->dev.of_node, NULL,
+		nfc_node = of_get_compatible_child(pdev->dev.of_node,
-					    "atmel,sama5d3-nfc"))
+						   "atmel,sama5d3-nfc");
+		if (nfc_node) {
 			caps = &atmel_sama5_nand_caps;
+			of_node_put(nfc_node);
+		}
 		/*
 		 * Even if the compatible says we are dealing with an

drivers/mtd/nand/raw/qcom_nandc.c+16−16

@@ -150,15 +150,15 @@ · 149 unmodified lines
150	#define NAND_VERSION_MINOR_SHIFT 16	150	#define NAND_VERSION_MINOR_SHIFT 16
151		151
152	/* NAND OP_CMDs */	152	/* NAND OP_CMDs */
153	#define PAGE_READ 0x2	153	#define OP_PAGE_READ 0x2
154	#define PAGE_READ_WITH_ECC 0x3	154	#define OP_PAGE_READ_WITH_ECC 0x3
155	#define PAGE_READ_WITH_ECC_SPARE 0x4	155	#define OP_PAGE_READ_WITH_ECC_SPARE 0x4
156	#define PROGRAM_PAGE 0x6	156	#define OP_PROGRAM_PAGE 0x6
157	#define PAGE_PROGRAM_WITH_ECC 0x7	157	#define OP_PAGE_PROGRAM_WITH_ECC 0x7
158	#define PROGRAM_PAGE_SPARE 0x9	158	#define OP_PROGRAM_PAGE_SPARE 0x9
159	#define BLOCK_ERASE 0xa	159	#define OP_BLOCK_ERASE 0xa
160	#define FETCH_ID 0xb	160	#define OP_FETCH_ID 0xb
161	#define RESET_DEVICE 0xd	161	#define OP_RESET_DEVICE 0xd
162		162
163	/* Default Value for NAND_DEV_CMD_VLD */	163	/* Default Value for NAND_DEV_CMD_VLD */
164	#define NAND_DEV_CMD_VLD_VAL (READ_START_VLD \| WRITE_START_VLD \| \	164	#define NAND_DEV_CMD_VLD_VAL (READ_START_VLD \| WRITE_START_VLD \| \
@@ -692,11 +692,11 @@ static void update_rw_regs(struct qcom_nand_host *host, int num_cw, bool read) · 527 unmodified lines
692		692
693	if (read) {	693	if (read) {
694	if (host->use_ecc)	694	if (host->use_ecc)
695	cmd = PAGE_READ_WITH_ECC \| PAGE_ACC \| LAST_PAGE;	695	cmd = OP_PAGE_READ_WITH_ECC \| PAGE_ACC \| LAST_PAGE;
696	else	696	else
697	cmd = PAGE_READ \| PAGE_ACC \| LAST_PAGE;	697	cmd = OP_PAGE_READ \| PAGE_ACC \| LAST_PAGE;
698	} else {	698	} else {
699	cmd = PROGRAM_PAGE \| PAGE_ACC \| LAST_PAGE;	699	cmd = OP_PROGRAM_PAGE \| PAGE_ACC \| LAST_PAGE;
700	}	700	}
701		701
702	if (host->use_ecc) {	702	if (host->use_ecc) {
@@ -1170,7 +1170,7 @@ static int nandc_param(struct qcom_nand_host *host) · 467 unmodified lines
1170	* in use. we configure the controller to perform a raw read of 512	1170	* in use. we configure the controller to perform a raw read of 512
1171	* bytes to read onfi params	1171	* bytes to read onfi params
1172	*/	1172	*/
1173	nandc_set_reg(nandc, NAND_FLASH_CMD, PAGE_READ \| PAGE_ACC \| LAST_PAGE);	1173	nandc_set_reg(nandc, NAND_FLASH_CMD, OP_PAGE_READ \| PAGE_ACC \| LAST_PAGE);
1174	nandc_set_reg(nandc, NAND_ADDR0, 0);	1174	nandc_set_reg(nandc, NAND_ADDR0, 0);
1175	nandc_set_reg(nandc, NAND_ADDR1, 0);	1175	nandc_set_reg(nandc, NAND_ADDR1, 0);
1176	nandc_set_reg(nandc, NAND_DEV0_CFG0, 0 << CW_PER_PAGE	1176	nandc_set_reg(nandc, NAND_DEV0_CFG0, 0 << CW_PER_PAGE
@@ -1224,7 +1224,7 @@ static int erase_block(struct qcom_nand_host *host, int page_addr) · 47 unmodified lines
1224	struct qcom_nand_controller *nandc = get_qcom_nand_controller(chip);	1224	struct qcom_nand_controller *nandc = get_qcom_nand_controller(chip);
1225		1225
1226	nandc_set_reg(nandc, NAND_FLASH_CMD,	1226	nandc_set_reg(nandc, NAND_FLASH_CMD,
1227	BLOCK_ERASE \| PAGE_ACC \| LAST_PAGE);	1227	OP_BLOCK_ERASE \| PAGE_ACC \| LAST_PAGE);
1228	nandc_set_reg(nandc, NAND_ADDR0, page_addr);	1228	nandc_set_reg(nandc, NAND_ADDR0, page_addr);
1229	nandc_set_reg(nandc, NAND_ADDR1, 0);	1229	nandc_set_reg(nandc, NAND_ADDR1, 0);
1230	nandc_set_reg(nandc, NAND_DEV0_CFG0,	1230	nandc_set_reg(nandc, NAND_DEV0_CFG0,
@@ -1255,7 +1255,7 @@ static int read_id(struct qcom_nand_host *host, int column) · 24 unmodified lines
1255	if (column == -1)	1255	if (column == -1)
1256	return 0;	1256	return 0;
1257		1257
1258	nandc_set_reg(nandc, NAND_FLASH_CMD, FETCH_ID);	1258	nandc_set_reg(nandc, NAND_FLASH_CMD, OP_FETCH_ID);
1259	nandc_set_reg(nandc, NAND_ADDR0, column);	1259	nandc_set_reg(nandc, NAND_ADDR0, column);
1260	nandc_set_reg(nandc, NAND_ADDR1, 0);	1260	nandc_set_reg(nandc, NAND_ADDR1, 0);
1261	nandc_set_reg(nandc, NAND_FLASH_CHIP_SELECT,	1261	nandc_set_reg(nandc, NAND_FLASH_CHIP_SELECT,
@@ -1276,7 +1276,7 @@ static int reset(struct qcom_nand_host *host) · 14 unmodified lines
1276	struct nand_chip *chip = &host->chip;	1276	struct nand_chip *chip = &host->chip;
1277	struct qcom_nand_controller *nandc = get_qcom_nand_controller(chip);	1277	struct qcom_nand_controller *nandc = get_qcom_nand_controller(chip);
1278		1278
1279	nandc_set_reg(nandc, NAND_FLASH_CMD, RESET_DEVICE);	1279	nandc_set_reg(nandc, NAND_FLASH_CMD, OP_RESET_DEVICE);
1280	nandc_set_reg(nandc, NAND_EXEC_CMD, 1);	1280	nandc_set_reg(nandc, NAND_EXEC_CMD, 1);
1281		1281
1282	write_reg_dma(nandc, NAND_FLASH_CMD, 1, NAND_BAM_NEXT_SGL);	1282	write_reg_dma(nandc, NAND_FLASH_CMD, 1, NAND_BAM_NEXT_SGL);

drivers/mtd/spi-nor/cadence-quadspi.c+16−3

 		ndelay(cqspi->wr_delay);
 	while (remaining > 0) {
+		size_t write_words, mod_bytes;
 		write_bytes = remaining > page_size ? page_size : remaining;
-		iowrite32_rep(cqspi->ahb_base, txbuf,
+		write_words = write_bytes / 4;
-			      DIV_ROUND_UP(write_bytes, 4));
+		mod_bytes = write_bytes % 4;
+		/* Write 4 bytes at a time then single bytes. */
+		if (write_words) {
+			iowrite32_rep(cqspi->ahb_base, txbuf, write_words);
+			txbuf += (write_words * 4);
+		}
+		if (mod_bytes) {
+			unsigned int temp = 0xFFFFFFFF;
+			memcpy(&temp, txbuf, mod_bytes);
+			iowrite32(temp, cqspi->ahb_base);
+			txbuf += mod_bytes;
+		}
 		if (!wait_for_completion_timeout(&cqspi->transfer_complete,
 					msecs_to_jiffies(CQSPI_TIMEOUT_MS))) {
 			goto failwr;
 		}
-		txbuf += write_bytes;
 		remaining -= write_bytes;
 		if (remaining > 0)

drivers/mtd/spi-nor/spi-nor.c+98−32

  * @nor:	pointer to a 'struct spi_nor'
  * @addr:	offset in the serial flash memory
  * @len:	number of bytes to read
- * @buf:	buffer where the data is copied into
+ * @buf:	buffer where the data is copied into (dma-safe memory)
  *
  * Return: 0 on success, -errno otherwise.
  */
 	return left->size - right->size;
 }
+/**
+ * spi_nor_sort_erase_mask() - sort erase mask
+ * @map:	the erase map of the SPI NOR
+ * @erase_mask:	the erase type mask to be sorted
+ *
+ * Replicate the sort done for the map's erase types in BFPT: sort the erase
+ * mask in ascending order with the smallest erase type size starting from
+ * BIT(0) in the sorted erase mask.
+ *
+ * Return: sorted erase mask.
+ */
+static u8 spi_nor_sort_erase_mask(struct spi_nor_erase_map *map, u8 erase_mask)
+{
+	struct spi_nor_erase_type *erase_type = map->erase_type;
+	int i;
+	u8 sorted_erase_mask = 0;
+	if (!erase_mask)
+		return 0;
+	/* Replicate the sort done for the map's erase types. */
+	for (i = 0; i < SNOR_ERASE_TYPE_MAX; i++)
+		if (erase_type[i].size && erase_mask & BIT(erase_type[i].idx))
+			sorted_erase_mask |= BIT(i);
+	return sorted_erase_mask;
+}
 /**
  * spi_nor_regions_sort_erase_types() - sort erase types in each region
  * @map:	the erase map of the SPI NOR
 static void spi_nor_regions_sort_erase_types(struct spi_nor_erase_map *map)
 {
 	struct spi_nor_erase_region *region = map->regions;
-	struct spi_nor_erase_type *erase_type = map->erase_type;
-	int i;
 	u8 region_erase_mask, sorted_erase_mask;
 	while (region) {
 		region_erase_mask = region->offset & SNOR_ERASE_TYPE_MASK;
-		/* Replicate the sort done for the map's erase types. */
+		sorted_erase_mask = spi_nor_sort_erase_mask(map,
-		sorted_erase_mask = 0;
+							    region_erase_mask);
-		for (i = 0; i < SNOR_ERASE_TYPE_MAX; i++)
-			if (erase_type[i].size &&
-			    region_erase_mask & BIT(erase_type[i].idx))
-				sorted_erase_mask |= BIT(i);
 		/* Overwrite erase mask. */
 		region->offset = (region->offset & ~SNOR_ERASE_TYPE_MASK) |
  * spi_nor_get_map_in_use() - get the configuration map in use
  * @nor:	pointer to a 'struct spi_nor'
  * @smpt:	pointer to the sector map parameter table
+ * @smpt_len:	sector map parameter table length
+ *
+ * Return: pointer to the map in use, ERR_PTR(-errno) otherwise.
  */
-static const u32 *spi_nor_get_map_in_use(struct spi_nor *nor, const u32 *smpt)
+static const u32 *spi_nor_get_map_in_use(struct spi_nor *nor, const u32 *smpt,
+					 u8 smpt_len)
 {
-	const u32 *ret = NULL;
+	const u32 *ret;
-	u32 i, addr;
+	u8 *buf;
+	u32 addr;
 	int err;
+	u8 i;
 	u8 addr_width, read_opcode, read_dummy;
-	u8 read_data_mask, data_byte, map_id;
+	u8 read_data_mask, map_id;
+	/* Use a kmalloc'ed bounce buffer to guarantee it is DMA-able. */
+	buf = kmalloc(sizeof(*buf), GFP_KERNEL);
+	if (!buf)
+		return ERR_PTR(-ENOMEM);
 	addr_width = nor->addr_width;
 	read_dummy = nor->read_dummy;
 	read_opcode = nor->read_opcode;
 	map_id = 0;
-	i = 0;
 	/* Determine if there are any optional Detection Command Descriptors */
-	while (!(smpt[i] & SMPT_DESC_TYPE_MAP)) {
+	for (i = 0; i < smpt_len; i += 2) {
+		if (smpt[i] & SMPT_DESC_TYPE_MAP)
+			break;
 		read_data_mask = SMPT_CMD_READ_DATA(smpt[i]);
 		nor->addr_width = spi_nor_smpt_addr_width(nor, smpt[i]);
 		nor->read_dummy = spi_nor_smpt_read_dummy(nor, smpt[i]);
 		nor->read_opcode = SMPT_CMD_OPCODE(smpt[i]);
 		addr = smpt[i + 1];
-		err = spi_nor_read_raw(nor, addr, 1, &data_byte);
+		err = spi_nor_read_raw(nor, addr, 1, buf);
-		if (err)
+		if (err) {
+			ret = ERR_PTR(err);
 			goto out;
+		}
 		/*
 		 * Build an index value that is used to select the Sector Map
 		 * Configuration that is currently in use.
 		 */
-		map_id = map_id << 1 | !!(data_byte & read_data_mask);
+		map_id = map_id << 1 | !!(*buf & read_data_mask);
-		i = i + 2;
 	}
-	/* Find the matching configuration map */
+	/*
-	while (SMPT_MAP_ID(smpt[i]) != map_id) {
+	 * If command descriptors are provided, they always precede map
+	 * descriptors in the table. There is no need to start the iteration
+	 * over smpt array all over again.
+	 *
+	 * Find the matching configuration map.
+	 */
+	ret = ERR_PTR(-EINVAL);
+	while (i < smpt_len) {
+		if (SMPT_MAP_ID(smpt[i]) == map_id) {
+			ret = smpt + i;
+			break;
+		}
+		/*
+		 * If there are no more configuration map descriptors and no
+		 * configuration ID matched the configuration identifier, the
+		 * sector address map is unknown.
+		 */
 		if (smpt[i] & SMPT_DESC_END)
-			goto out;
+			break;
 		/* increment the table index to the next map */
 		i += SMPT_MAP_REGION_COUNT(smpt[i]) + 1;
 	}
-	ret = smpt + i;
 	/* fall through */
 out:
+	kfree(buf);
 	nor->addr_width = addr_width;
 	nor->read_dummy = read_dummy;
 	nor->read_opcode = read_opcode;
 	u64 offset;
 	u32 region_count;
 	int i, j;
-	u8 erase_type;
+	u8 erase_type, uniform_erase_type;
 	region_count = SMPT_MAP_REGION_COUNT(*smpt);
 	/*
 		return -ENOMEM;
 	map->regions = region;
-	map->uniform_erase_type = 0xff;
+	uniform_erase_type = 0xff;
 	offset = 0;
 	/* Populate regions. */
 	for (i = 0; i < region_count; i++) {
 		 * Save the erase types that are supported in all regions and
 		 * can erase the entire flash memory.
 		 */
-		map->uniform_erase_type &= erase_type;
+		uniform_erase_type &= erase_type;
 		offset = (region[i].offset & ~SNOR_ERASE_FLAGS_MASK) +
 			 region[i].size;
 	}
+	map->uniform_erase_type = spi_nor_sort_erase_mask(map,
+							  uniform_erase_type);
 	spi_nor_region_mark_end(&region[i - 1]);
 	return 0;
 	for (i = 0; i < smpt_header->length; i++)
 		smpt[i] = le32_to_cpu(smpt[i]);
-	sector_map = spi_nor_get_map_in_use(nor, smpt);
+	sector_map = spi_nor_get_map_in_use(nor, smpt, smpt_header->length);
-	if (!sector_map) {
+	if (IS_ERR(sector_map)) {
-		ret = -EINVAL;
+		ret = PTR_ERR(sector_map);
 		goto out;
 	}
 	if (err)
 		goto exit;
-	/* Parse other parameter headers. */
+	/* Parse optional parameter tables. */
 	for (i = 0; i < header.nph; i++) {
 		param_header = &param_headers[i];
 			break;
 		}
-		if (err)
+		if (err) {
-			goto exit;
+			dev_warn(dev, "Failed to parse optional parameter table: %04x\n",
+				 SFDP_PARAM_HEADER_ID(param_header));
+			/*
+			 * Let's not drop all information we extracted so far
+			 * if optional table parsers fail. In case of failing,
+			 * each optional parser is responsible to roll back to
+			 * the previously known spi_nor data.
+			 */
+			err = 0;
+		}
 	}
 exit:

drivers/net/ethernet/amazon/ena/ena_netdev.c+11−12

 		rc = ena_com_dev_reset(adapter->ena_dev, adapter->reset_reason);
 		if (rc)
 			dev_err(&adapter->pdev->dev, "Device reset failed\n");
+		/* stop submitting admin commands on a device that was reset */
+		ena_com_set_admin_running_state(adapter->ena_dev, false);
 	}
 	ena_destroy_all_io_queues(adapter);
 	netif_dbg(adapter, ifdown, netdev, "%s\n", __func__);
+	if (!test_bit(ENA_FLAG_DEVICE_RUNNING, &adapter->flags))
+		return 0;
 	if (test_bit(ENA_FLAG_DEV_UP, &adapter->flags))
 		ena_down(adapter);
 		ena_down(adapter);
 	/* Stop the device from sending AENQ events (in case reset flag is set
-	 *  and device is up, ena_close already reset the device
+	 *  and device is up, ena_down() already reset the device.
-	 * In case the reset flag is set and the device is up, ena_down()
-	 * already perform the reset, so it can be skipped.
 	 */
 	if (!(test_bit(ENA_FLAG_TRIGGER_RESET, &adapter->flags) && dev_up))
 		ena_com_dev_reset(adapter->ena_dev, adapter->reset_reason);
 	ena_com_abort_admin_commands(ena_dev);
 	ena_com_wait_for_abort_completion(ena_dev);
 	ena_com_admin_destroy(ena_dev);
-	ena_com_mmio_reg_read_request_destroy(ena_dev);
 	ena_com_dev_reset(ena_dev, ENA_REGS_RESET_DRIVER_INVALID_STATE);
+	ena_com_mmio_reg_read_request_destroy(ena_dev);
 err:
 	clear_bit(ENA_FLAG_DEVICE_RUNNING, &adapter->flags);
 	clear_bit(ENA_FLAG_ONGOING_RESET, &adapter->flags);
 	ena_com_rss_destroy(ena_dev);
 err_free_msix:
 	ena_com_dev_reset(ena_dev, ENA_REGS_RESET_INIT_ERR);
+	/* stop submitting admin commands on a device that was reset */
+	ena_com_set_admin_running_state(ena_dev, false);
 	ena_free_mgmnt_irq(adapter);
 	ena_disable_msix(adapter);
 err_worker_destroy:
 	cancel_work_sync(&adapter->reset_task);
-	unregister_netdev(netdev);
-	/* If the device is running then we want to make sure the device will be
-	 * reset to make sure no more events will be issued by the device.
-	 */
-	if (test_bit(ENA_FLAG_DEVICE_RUNNING, &adapter->flags))
-		set_bit(ENA_FLAG_TRIGGER_RESET, &adapter->flags);
 	rtnl_lock();
 	ena_destroy_device(adapter, true);
 	rtnl_unlock();
+	unregister_netdev(netdev);
 	free_netdev(netdev);
 	ena_com_rss_destroy(ena_dev);

drivers/net/ethernet/amazon/ena/ena_netdev.h+1−1

@@ -45,7 +45,7 @@ · 44 unmodified lines
45		45
46	#define DRV_MODULE_VER_MAJOR 2	46	#define DRV_MODULE_VER_MAJOR 2
47	#define DRV_MODULE_VER_MINOR 0	47	#define DRV_MODULE_VER_MINOR 0
48	#define DRV_MODULE_VER_SUBMINOR 1	48	#define DRV_MODULE_VER_SUBMINOR 2
49		49
50	#define DRV_MODULE_NAME "ena"	50	#define DRV_MODULE_NAME "ena"
51	#ifndef DRV_MODULE_VERSION	51	#ifndef DRV_MODULE_VERSION

drivers/net/ethernet/amd/sunlance.c+3−1

 			prop = of_get_property(nd, "tpe-link-test?", NULL);
 			if (!prop)
-				goto no_link_test;
+				goto node_put;
 			if (strcmp(prop, "true")) {
 				printk(KERN_NOTICE "SunLance: warning: overriding option "
 				       "to ecd@skynet.be\n");
 				auxio_set_lte(AUXIO_LTE_ON);
 			}
+node_put:
+			of_node_put(nd);
 no_link_test:
 			lp->auto_select = 1;
 			lp->tpe = 0;

drivers/net/ethernet/broadcom/tg3.c+16−2

 {
 	struct tg3 *tp = netdev_priv(dev);
 	int i, irq_sync = 0, err = 0;
+	bool reset_phy = false;
 	if ((ering->rx_pending > tp->rx_std_ring_mask) ||
 	    (ering->rx_jumbo_pending > tp->rx_jmb_ring_mask) ||
 	if (netif_running(dev)) {
 		tg3_halt(tp, RESET_KIND_SHUTDOWN, 1);
-		err = tg3_restart_hw(tp, false);
+		/* Reset PHY to avoid PHY lock up */
+		if (tg3_asic_rev(tp) == ASIC_REV_5717 ||
+		    tg3_asic_rev(tp) == ASIC_REV_5719 ||
+		    tg3_asic_rev(tp) == ASIC_REV_5720)
+			reset_phy = true;
+		err = tg3_restart_hw(tp, reset_phy);
 		if (!err)
 			tg3_netif_start(tp);
 	}
 {
 	struct tg3 *tp = netdev_priv(dev);
 	int err = 0;
+	bool reset_phy = false;
 	if (tp->link_config.autoneg == AUTONEG_ENABLE)
 		tg3_warn_mgmt_link_flap(tp);
 		if (netif_running(dev)) {
 			tg3_halt(tp, RESET_KIND_SHUTDOWN, 1);
-			err = tg3_restart_hw(tp, false);
+			/* Reset PHY to avoid PHY lock up */
+			if (tg3_asic_rev(tp) == ASIC_REV_5717 ||
+			    tg3_asic_rev(tp) == ASIC_REV_5719 ||
+			    tg3_asic_rev(tp) == ASIC_REV_5720)
+				reset_phy = true;
+			err = tg3_restart_hw(tp, reset_phy);
 			if (!err)
 				tg3_netif_start(tp);
 		}

drivers/net/ethernet/cavium/thunder/nicvf_main.c+7−2

 	bool if_up = netif_running(nic->netdev);
 	struct bpf_prog *old_prog;
 	bool bpf_attached = false;
+	int ret = 0;
 	/* For now just support only the usual MTU sized frames */
 	if (prog && (dev->mtu > 1500)) {
 	if (nic->xdp_prog) {
 		/* Attach BPF program */
 		nic->xdp_prog = bpf_prog_add(nic->xdp_prog, nic->rx_queues - 1);
-		if (!IS_ERR(nic->xdp_prog))
+		if (!IS_ERR(nic->xdp_prog)) {
 			bpf_attached = true;
+		} else {
+			ret = PTR_ERR(nic->xdp_prog);
+			nic->xdp_prog = NULL;
+		}
 	}
 	/* Calculate Tx queues needed for XDP and network stack */
 		netif_trans_update(nic->netdev);
 	}
-	return 0;
+	return ret;
 }
 static int nicvf_xdp(struct net_device *netdev, struct netdev_bpf *xdp)

drivers/net/ethernet/cavium/thunder/nicvf_queues.c+3−1

 	if (!sq->dmem.base)
 		return;
-	if (sq->tso_hdrs)
+	if (sq->tso_hdrs) {
 		dma_free_coherent(&nic->pdev->dev,
 				  sq->dmem.q_len * TSO_HEADER_SIZE,
 				  sq->tso_hdrs, sq->tso_hdrs_phys);
+		sq->tso_hdrs = NULL;
+	}
 	/* Free pending skbs in the queue */
 	smp_rmb();

drivers/net/ethernet/cortina/gemini.c+1−1

@@ -660,7 +660,7 @@ static void gmac_clean_txq(struct net_device netdev, struct gmac_txq txq, · 659 unmodified lines
660		660
661	u64_stats_update_begin(&port->tx_stats_syncp);	661	u64_stats_update_begin(&port->tx_stats_syncp);
662	port->tx_frag_stats[nfrags]++;	662	port->tx_frag_stats[nfrags]++;
663	u64_stats_update_end(&port->ir_stats_syncp);	663	u64_stats_update_end(&port->tx_stats_syncp);
664	}	664	}
665	}	665	}
666		666

drivers/net/ethernet/faraday/ftmac100.c+3−4

 	struct net_device *netdev = dev_id;
 	struct ftmac100 *priv = netdev_priv(netdev);
-	if (likely(netif_running(netdev))) {
+	/* Disable interrupts for polling */
-		/* Disable interrupts for polling */
+	ftmac100_disable_all_int(priv);
-		ftmac100_disable_all_int(priv);
+	if (likely(netif_running(netdev)))
 		napi_schedule(&priv->napi);
-	}
 	return IRQ_HANDLED;
 }

drivers/net/ethernet/ibm/ibmvnic.c+31−41

@@ -485,8 +485,8 @@ static void release_rx_pools(struct ibmvnic_adapter *adapter) · 484 unmodified lines
485		485
486	for (j = 0; j < rx_pool->size; j++) {	486	for (j = 0; j < rx_pool->size; j++) {
487	if (rx_pool->rx_buff[j].skb) {	487	if (rx_pool->rx_buff[j].skb) {
488	dev_kfree_skb_any(rx_pool->rx_buff[i].skb);	488	dev_kfree_skb_any(rx_pool->rx_buff[j].skb);
489	rx_pool->rx_buff[i].skb = NULL;	489	rx_pool->rx_buff[j].skb = NULL;
490	}	490	}
491	}	491	}
492		492
@@ -1103,20 +1103,15 @@ static int ibmvnic_open(struct net_device *netdev) · 610 unmodified lines
1103	return 0;	1103	return 0;
1104	}	1104	}
1105		1105
1106	mutex_lock(&adapter->reset_lock);
1107
1108	if (adapter->state != VNIC_CLOSED) {	1106	if (adapter->state != VNIC_CLOSED) {
1109	rc = ibmvnic_login(netdev);	1107	rc = ibmvnic_login(netdev);
1110	if (rc) {	1108	if (rc)
1111	mutex_unlock(&adapter->reset_lock);
1112	return rc;	1109	return rc;
1113	}
1114		1110
1115	rc = init_resources(adapter);	1111	rc = init_resources(adapter);
1116	if (rc) {	1112	if (rc) {
1117	netdev_err(netdev, "failed to initialize resources\n");	1113	netdev_err(netdev, "failed to initialize resources\n");
1118	release_resources(adapter);	1114	release_resources(adapter);
1119	mutex_unlock(&adapter->reset_lock);
1120	return rc;	1115	return rc;
1121	}	1116	}
1122	}	1117	}
@@ -1124,8 +1119,6 @@ static int ibmvnic_open(struct net_device *netdev) · 1 unmodified line
1124	rc = __ibmvnic_open(netdev);	1119	rc = __ibmvnic_open(netdev);
1125	netif_carrier_on(netdev);	1120	netif_carrier_on(netdev);
1126		1121
1127	mutex_unlock(&adapter->reset_lock);
1128
1129	return rc;	1122	return rc;
1130	}	1123	}
1131		1124
@@ -1269,10 +1262,8 @@ static int ibmvnic_close(struct net_device *netdev) · 137 unmodified lines
1269	return 0;	1262	return 0;
1270	}	1263	}
1271		1264
1272	mutex_lock(&adapter->reset_lock);
1273	rc = __ibmvnic_close(netdev);	1265	rc = __ibmvnic_close(netdev);
1274	ibmvnic_cleanup(netdev);	1266	ibmvnic_cleanup(netdev);
1275	mutex_unlock(&adapter->reset_lock);
1276		1267
1277	return rc;	1268	return rc;
1278	}	1269	}
@@ -1746,6 +1737,7 @@ static int do_reset(struct ibmvnic_adapter *adapter, · 467 unmodified lines
1746	struct ibmvnic_rwi *rwi, u32 reset_state)	1737	struct ibmvnic_rwi *rwi, u32 reset_state)
1747	{	1738	{
1748	u64 old_num_rx_queues, old_num_tx_queues;	1739	u64 old_num_rx_queues, old_num_tx_queues;
		1740	u64 old_num_rx_slots, old_num_tx_slots;
1749	struct net_device *netdev = adapter->netdev;	1741	struct net_device *netdev = adapter->netdev;
1750	int i, rc;	1742	int i, rc;
1751		1743
@@ -1757,6 +1749,8 @@ static int do_reset(struct ibmvnic_adapter *adapter, · 5 unmodified lines
1757		1749
1758	old_num_rx_queues = adapter->req_rx_queues;	1750	old_num_rx_queues = adapter->req_rx_queues;
1759	old_num_tx_queues = adapter->req_tx_queues;	1751	old_num_tx_queues = adapter->req_tx_queues;
		1752	old_num_rx_slots = adapter->req_rx_add_entries_per_subcrq;
		1753	old_num_tx_slots = adapter->req_tx_entries_per_subcrq;
1760		1754
1761	ibmvnic_cleanup(netdev);	1755	ibmvnic_cleanup(netdev);
1762		1756
@@ -1819,21 +1813,20 @@ static int do_reset(struct ibmvnic_adapter *adapter, · 56 unmodified lines
1819	if (rc)	1813	if (rc)
1820	return rc;	1814	return rc;
1821	} else if (adapter->req_rx_queues != old_num_rx_queues \|\|	1815	} else if (adapter->req_rx_queues != old_num_rx_queues \|\|
1822	adapter->req_tx_queues != old_num_tx_queues) {	1816	adapter->req_tx_queues != old_num_tx_queues \|\|
1823	adapter->map_id = 1;	1817	adapter->req_rx_add_entries_per_subcrq !=
		1818	old_num_rx_slots \|\|
		1819	adapter->req_tx_entries_per_subcrq !=
		1820	old_num_tx_slots) {
1824	release_rx_pools(adapter);	1821	release_rx_pools(adapter);
1825	release_tx_pools(adapter);	1822	release_tx_pools(adapter);
1826	rc = init_rx_pools(netdev);
1827	if (rc)
1828	return rc;
1829	rc = init_tx_pools(netdev);
1830	if (rc)
1831	return rc;
1832
1833	release_napi(adapter);	1823	release_napi(adapter);
1834	rc = init_napi(adapter);	1824	release_vpd_data(adapter);
		1825
		1826	rc = init_resources(adapter);
1835	if (rc)	1827	if (rc)
1836	return rc;	1828	return rc;
		1829
1837	} else {	1830	} else {
1838	rc = reset_tx_pools(adapter);	1831	rc = reset_tx_pools(adapter);
1839	if (rc)	1832	if (rc)
@@ -1917,17 +1910,8 @@ static int do_hard_reset(struct ibmvnic_adapter *adapter, · 77 unmodified lines
1917	adapter->state = VNIC_PROBED;	1910	adapter->state = VNIC_PROBED;
1918	return 0;	1911	return 0;
1919	}	1912	}
1920	/* netif_set_real_num_xx_queues needs to take rtnl lock here	1913
1921	* unless wait_for_reset is set, in which case the rtnl lock	1914	rc = init_resources(adapter);
1922	* has already been taken before initializing the reset
1923	*/
1924	if (!adapter->wait_for_reset) {
1925	rtnl_lock();
1926	rc = init_resources(adapter);
1927	rtnl_unlock();
1928	} else {
1929	rc = init_resources(adapter);
1930	}
1931	if (rc)	1915	if (rc)
1932	return rc;	1916	return rc;
1933		1917
@@ -1986,13 +1970,21 @@ static void __ibmvnic_reset(struct work_struct *work) · 52 unmodified lines
1986	struct ibmvnic_rwi *rwi;	1970	struct ibmvnic_rwi *rwi;
1987	struct ibmvnic_adapter *adapter;	1971	struct ibmvnic_adapter *adapter;
1988	struct net_device *netdev;	1972	struct net_device *netdev;
		1973	bool we_lock_rtnl = false;
1989	u32 reset_state;	1974	u32 reset_state;
1990	int rc = 0;	1975	int rc = 0;
1991		1976
1992	adapter = container_of(work, struct ibmvnic_adapter, ibmvnic_reset);	1977	adapter = container_of(work, struct ibmvnic_adapter, ibmvnic_reset);
1993	netdev = adapter->netdev;	1978	netdev = adapter->netdev;
1994		1979
1995	mutex_lock(&adapter->reset_lock);	1980	/* netif_set_real_num_xx_queues needs to take rtnl lock here
		1981	* unless wait_for_reset is set, in which case the rtnl lock
		1982	* has already been taken before initializing the reset
		1983	*/
		1984	if (!adapter->wait_for_reset) {
		1985	rtnl_lock();
		1986	we_lock_rtnl = true;
		1987	}
1996	reset_state = adapter->state;	1988	reset_state = adapter->state;
1997		1989
1998	rwi = get_next_rwi(adapter);	1990	rwi = get_next_rwi(adapter);
@@ -2020,12 +2012,11 @@ static void __ibmvnic_reset(struct work_struct *work) · 21 unmodified lines
2020	if (rc) {	2012	if (rc) {
2021	netdev_dbg(adapter->netdev, "Reset failed\n");	2013	netdev_dbg(adapter->netdev, "Reset failed\n");
2022	free_all_rwi(adapter);	2014	free_all_rwi(adapter);
2023	mutex_unlock(&adapter->reset_lock);
2024	return;
2025	}	2015	}
2026		2016
2027	adapter->resetting = false;	2017	adapter->resetting = false;
2028	mutex_unlock(&adapter->reset_lock);	2018	if (we_lock_rtnl)
		2019	rtnl_unlock();
2029	}	2020	}
2030		2021
2031	static int ibmvnic_reset(struct ibmvnic_adapter *adapter,	2022	static int ibmvnic_reset(struct ibmvnic_adapter *adapter,
@@ -4768,7 +4759,6 @@ static int ibmvnic_probe(struct vio_dev dev, const struct vio_device_id id) · 2736 unmodified lines
4768		4759
4769	INIT_WORK(&adapter->ibmvnic_reset, __ibmvnic_reset);	4760	INIT_WORK(&adapter->ibmvnic_reset, __ibmvnic_reset);
4770	INIT_LIST_HEAD(&adapter->rwi_list);	4761	INIT_LIST_HEAD(&adapter->rwi_list);
4771	mutex_init(&adapter->reset_lock);
4772	mutex_init(&adapter->rwi_lock);	4762	mutex_init(&adapter->rwi_lock);
4773	adapter->resetting = false;	4763	adapter->resetting = false;
4774		4764
@@ -4840,8 +4830,8 @@ static int ibmvnic_remove(struct vio_dev *dev) · 65 unmodified lines
4840	struct ibmvnic_adapter *adapter = netdev_priv(netdev);	4830	struct ibmvnic_adapter *adapter = netdev_priv(netdev);
4841		4831
4842	adapter->state = VNIC_REMOVING;	4832	adapter->state = VNIC_REMOVING;
4843	unregister_netdev(netdev);	4833	rtnl_lock();
4844	mutex_lock(&adapter->reset_lock);	4834	unregister_netdevice(netdev);
4845		4835
4846	release_resources(adapter);	4836	release_resources(adapter);
4847	release_sub_crqs(adapter, 1);	4837	release_sub_crqs(adapter, 1);
@@ -4852,7 +4842,7 @@ static int ibmvnic_remove(struct vio_dev *dev) · 4 unmodified lines
4852		4842
4853	adapter->state = VNIC_REMOVED;	4843	adapter->state = VNIC_REMOVED;
4854		4844
4855	mutex_unlock(&adapter->reset_lock);	4845	rtnl_unlock();
4856	device_remove_file(&dev->dev, &dev_attr_failover);	4846	device_remove_file(&dev->dev, &dev_attr_failover);
4857	free_netdev(netdev);	4847	free_netdev(netdev);
4858	dev_set_drvdata(&dev->dev, NULL);	4848	dev_set_drvdata(&dev->dev, NULL);

drivers/net/ethernet/ibm/ibmvnic.h+1−1

@@ -1075,7 +1075,7 @@ struct ibmvnic_adapter { · 1074 unmodified lines
1075	struct tasklet_struct tasklet;	1075	struct tasklet_struct tasklet;
1076	enum vnic_state state;	1076	enum vnic_state state;
1077	enum ibmvnic_reset_reason reset_reason;	1077	enum ibmvnic_reset_reason reset_reason;
1078	struct mutex reset_lock, rwi_lock;	1078	struct mutex rwi_lock;
1079	struct list_head rwi_list;	1079	struct list_head rwi_list;
1080	struct work_struct ibmvnic_reset;	1080	struct work_struct ibmvnic_reset;
1081	bool resetting;	1081	bool resetting;

drivers/net/ethernet/mellanox/mlx5/core/en.h+1−0

@@ -569,6 +569,7 @@ struct mlx5e_rq { · 568 unmodified lines
569		569
570	unsigned long state;	570	unsigned long state;
571	int ix;	571	int ix;
		572	unsigned int hw_mtu;
572		573
573	struct net_dim dim; /* Dynamic Interrupt Moderation */	574	struct net_dim dim; /* Dynamic Interrupt Moderation */
574		575

drivers/net/ethernet/mellanox/mlx5/core/en/port.c+15−21

 	eth_proto_oper = MLX5_GET(ptys_reg, out, eth_proto_oper);
 	*speed = mlx5e_port_ptys2speed(eth_proto_oper);
-	if (!(*speed)) {
+	if (!(*speed))
-		mlx5_core_warn(mdev, "cannot get port speed\n");
 		err = -EINVAL;
-	}
 	return err;
 }
 	case 40000:
 		if (!write)
 			*fec_policy = MLX5_GET(pplm_reg, pplm,
-					       fec_override_cap_10g_40g);
+					       fec_override_admin_10g_40g);
 		else
 			MLX5_SET(pplm_reg, pplm,
 				 fec_override_admin_10g_40g, *fec_policy);
 	case 10000:
 	case 40000:
 		*fec_cap = MLX5_GET(pplm_reg, pplm,
-				    fec_override_admin_10g_40g);
+				    fec_override_cap_10g_40g);
 		break;
 	case 25000:
 		*fec_cap = MLX5_GET(pplm_reg, pplm,
 int mlx5e_set_fec_mode(struct mlx5_core_dev *dev, u8 fec_policy)
 {
+	u8 fec_policy_nofec = BIT(MLX5E_FEC_NOFEC);
 	bool fec_mode_not_supp_in_speed = false;
-	u8 no_fec_policy = BIT(MLX5E_FEC_NOFEC);
 	u32 out[MLX5_ST_SZ_DW(pplm_reg)] = {};
 	u32 in[MLX5_ST_SZ_DW(pplm_reg)] = {};
 	int sz = MLX5_ST_SZ_BYTES(pplm_reg);
-	u32 current_fec_speed;
+	u8 fec_policy_auto = 0;
 	u8 fec_caps = 0;
 	int err;
 	int i;
 	if (err)
 		return err;
-	err = mlx5e_port_linkspeed(dev, &current_fec_speed);
+	MLX5_SET(pplm_reg, out, local_port, 1);
-	if (err)
-		return err;
-	memset(in, 0, sz);
+	for (i = 0; i < MLX5E_FEC_SUPPORTED_SPEEDS; i++) {
-	MLX5_SET(pplm_reg, in, local_port, 1);
-	for (i = 0; i < MLX5E_FEC_SUPPORTED_SPEEDS && !!fec_policy; i++) {
 		mlx5e_get_fec_cap_field(out, &fec_caps, fec_supported_speeds[i]);
-		/* policy supported for link speed */
+		/* policy supported for link speed, or policy is auto */
-		if (!!(fec_caps & fec_policy)) {
+		if (fec_caps & fec_policy || fec_policy == fec_policy_auto) {
-			mlx5e_fec_admin_field(in, &fec_policy, 1,
+			mlx5e_fec_admin_field(out, &fec_policy, 1,
 					      fec_supported_speeds[i]);
 		} else {
-			if (fec_supported_speeds[i] == current_fec_speed)
+			/* turn off FEC if supported. Else, leave it the same */
-				return -EOPNOTSUPP;
+			if (fec_caps & fec_policy_nofec)
-			mlx5e_fec_admin_field(in, &no_fec_policy, 1,
+				mlx5e_fec_admin_field(out, &fec_policy_nofec, 1,
-					      fec_supported_speeds[i]);
+						      fec_supported_speeds[i]);
 			fec_mode_not_supp_in_speed = true;
 		}
 	}
 			      "FEC policy 0x%x is not supported for some speeds",
 			      fec_policy);
-	return mlx5_core_access_reg(dev, in, sz, out, sz, MLX5_REG_PPLM, 0, 1);
+	return mlx5_core_access_reg(dev, out, sz, out, sz, MLX5_REG_PPLM, 0, 1);
 }

drivers/net/ethernet/mellanox/mlx5/core/en/port_buffer.c+3−1

@@ -130,8 +130,10 @@ static u32 calculate_xoff(struct mlx5e_priv *priv, unsigned int mtu) · 129 unmodified lines
130	int err;	130	int err;
131		131
132	err = mlx5e_port_linkspeed(priv->mdev, &speed);	132	err = mlx5e_port_linkspeed(priv->mdev, &speed);
133	if (err)	133	if (err) {
		134	mlx5_core_warn(priv->mdev, "cannot get port speed\n");
134	return 0;	135	return 0;
		136	}
135		137
136	xoff = (301 + 216 * priv->dcbx.cable_len / 100) * speed / 1000 + 272 * mtu / 100;	138	xoff = (301 + 216 * priv->dcbx.cable_len / 100) * speed / 1000 + 272 * mtu / 100;
137		139

drivers/net/ethernet/mellanox/mlx5/core/en_ethtool.c+1−2

@@ -843,8 +843,7 @@ static int mlx5e_get_link_ksettings(struct net_device *netdev, · 842 unmodified lines
843	ethtool_link_ksettings_add_link_mode(link_ksettings, supported,	843	ethtool_link_ksettings_add_link_mode(link_ksettings, supported,
844	Autoneg);	844	Autoneg);
845		845
846	err = get_fec_supported_advertised(mdev, link_ksettings);	846	if (get_fec_supported_advertised(mdev, link_ksettings))
847	if (err)
848	netdev_dbg(netdev, "%s: FEC caps query failed: %d\n",	847	netdev_dbg(netdev, "%s: FEC caps query failed: %d\n",
849	__func__, err);	848	__func__, err);
850		849

drivers/net/ethernet/mellanox/mlx5/core/en_main.c+31−6

 	rq->channel = c;
 	rq->ix      = c->ix;
 	rq->mdev    = mdev;
+	rq->hw_mtu  = MLX5E_SW2HW_MTU(params, params->sw_mtu);
 	rq->stats   = &c->priv->channel_stats[c->ix].rq;
 	rq->xdp_prog = params->xdp_prog ? bpf_prog_inc(params->xdp_prog) : NULL;
 	int err;
 	u32 i;
+	err = mlx5_vector2eqn(mdev, param->eq_ix, &eqn_not_used, &irqn);
+	if (err)
+		return err;
 	err = mlx5_cqwq_create(mdev, &param->wq, param->cqc, &cq->wq,
 			       &cq->wq_ctrl);
 	if (err)
 		return err;
-	mlx5_vector2eqn(mdev, param->eq_ix, &eqn_not_used, &irqn);
 	mcq->cqe_sz     = 64;
 	mcq->set_ci_db  = cq->wq_ctrl.db.db;
 	mcq->arm_db     = cq->wq_ctrl.db.db + 1;
 	int eqn;
 	int err;
+	err = mlx5_vector2eqn(mdev, param->eq_ix, &eqn, &irqn_not_used);
+	if (err)
+		return err;
 	inlen = MLX5_ST_SZ_BYTES(create_cq_in) +
 		sizeof(u64) * cq->wq_ctrl.buf.npages;
 	in = kvzalloc(inlen, GFP_KERNEL);
 	mlx5_fill_page_frag_array(&cq->wq_ctrl.buf,
 				  (__be64 *)MLX5_ADDR_OF(create_cq_in, in, pas));
-	mlx5_vector2eqn(mdev, param->eq_ix, &eqn, &irqn_not_used);
 	MLX5_SET(cqc,   cqc, cq_period_mode, param->cq_period_mode);
 	MLX5_SET(cqc,   cqc, c_eqn,         eqn);
 	MLX5_SET(cqc,   cqc, uar_page,      mdev->priv.uar->index);
 	int err;
 	int eqn;
+	err = mlx5_vector2eqn(priv->mdev, ix, &eqn, &irq);
+	if (err)
+		return err;
 	c = kvzalloc_node(sizeof(*c), GFP_KERNEL, cpu_to_node(cpu));
 	if (!c)
 		return -ENOMEM;
 	c->xdp      = !!params->xdp_prog;
 	c->stats    = &priv->channel_stats[ix].ch;
-	mlx5_vector2eqn(priv->mdev, ix, &eqn, &irq);
 	c->irq_desc = irq_to_desc(irq);
 	netif_napi_add(netdev, &c->napi, mlx5e_napi_poll, 64);
 	return 0;
 }
+#ifdef CONFIG_MLX5_ESWITCH
 static int set_feature_tc_num_filters(struct net_device *netdev, bool enable)
 {
 	struct mlx5e_priv *priv = netdev_priv(netdev);
 	return 0;
 }
+#endif
 static int set_feature_rx_all(struct net_device *netdev, bool enable)
 {
 	err |= MLX5E_HANDLE_FEATURE(NETIF_F_LRO, set_feature_lro);
 	err |= MLX5E_HANDLE_FEATURE(NETIF_F_HW_VLAN_CTAG_FILTER,
 				    set_feature_cvlan_filter);
+#ifdef CONFIG_MLX5_ESWITCH
 	err |= MLX5E_HANDLE_FEATURE(NETIF_F_HW_TC, set_feature_tc_num_filters);
+#endif
 	err |= MLX5E_HANDLE_FEATURE(NETIF_F_RXALL, set_feature_rx_all);
 	err |= MLX5E_HANDLE_FEATURE(NETIF_F_RXFCS, set_feature_rx_fcs);
 	err |= MLX5E_HANDLE_FEATURE(NETIF_F_HW_VLAN_CTAG_RX, set_feature_rx_vlan);
 	}
 	if (params->rq_wq_type == MLX5_WQ_TYPE_LINKED_LIST_STRIDING_RQ) {
+		bool is_linear = mlx5e_rx_mpwqe_is_linear_skb(priv->mdev, &new_channels.params);
 		u8 ppw_old = mlx5e_mpwqe_log_pkts_per_wqe(params);
 		u8 ppw_new = mlx5e_mpwqe_log_pkts_per_wqe(&new_channels.params);
-		reset = reset && (ppw_old != ppw_new);
+		reset = reset && (is_linear || (ppw_old != ppw_new));
 	}
 	if (!reset) {
 	    FT_CAP(modify_root) &&
 	    FT_CAP(identified_miss_table_mode) &&
 	    FT_CAP(flow_table_modify)) {
+#ifdef CONFIG_MLX5_ESWITCH
 		netdev->hw_features      |= NETIF_F_HW_TC;
+#endif
 #ifdef CONFIG_MLX5_EN_ARFS
 		netdev->hw_features	 |= NETIF_F_NTUPLE;
 #endif
 int mlx5e_attach_netdev(struct mlx5e_priv *priv)
 {
 	const struct mlx5e_profile *profile;
+	int max_nch;
 	int err;
 	profile = priv->profile;
 	clear_bit(MLX5E_STATE_DESTROYING, &priv->state);
+	/* max number of channels may have changed */
+	max_nch = mlx5e_get_max_num_channels(priv->mdev);
+	if (priv->channels.params.num_channels > max_nch) {
+		mlx5_core_warn(priv->mdev, "MLX5E: Reducing number of channels to %d\n", max_nch);
+		priv->channels.params.num_channels = max_nch;
+		mlx5e_build_default_indir_rqt(priv->channels.params.indirection_rqt,
+					      MLX5E_INDIR_RQT_SIZE, max_nch);
+	}
 	err = profile->init_tx(priv);
 	if (err)
 		goto out;

drivers/net/ethernet/mellanox/mlx5/core/en_rx.c+6−0

 	u32 frag_size;
 	bool consumed;
+	/* Check packet size. Note LRO doesn't use linear SKB */
+	if (unlikely(cqe_bcnt > rq->hw_mtu)) {
+		rq->stats->oversize_pkts_sw_drop++;
+		return NULL;
+	}
 	va             = page_address(di->page) + head_offset;
 	data           = va + rx_headroom;
 	frag_size      = MLX5_SKB_FRAG_SZ(rx_headroom + cqe_bcnt32);

drivers/net/ethernet/mellanox/mlx5/core/en_selftest.c+10−16

 	return 1;
 }
-#ifdef CONFIG_INET
-/* loopback test */
-#define MLX5E_TEST_PKT_SIZE (MLX5E_RX_MAX_HEAD - NET_IP_ALIGN)
-static const char mlx5e_test_text[ETH_GSTRING_LEN] = "MLX5E SELF TEST";
-#define MLX5E_TEST_MAGIC 0x5AEED15C001ULL
 struct mlx5ehdr {
 	__be32 version;
 	__be64 magic;
-	char   text[ETH_GSTRING_LEN];
 };
+#ifdef CONFIG_INET
+/* loopback test */
+#define MLX5E_TEST_PKT_SIZE (sizeof(struct ethhdr) + sizeof(struct iphdr) +\
+			     sizeof(struct udphdr) + sizeof(struct mlx5ehdr))
+#define MLX5E_TEST_MAGIC 0x5AEED15C001ULL
 static struct sk_buff *mlx5e_test_get_udp_skb(struct mlx5e_priv *priv)
 {
 	struct sk_buff *skb = NULL;
 	struct ethhdr *ethh;
 	struct udphdr *udph;
 	struct iphdr *iph;
-	int datalen, iplen;
+	int    iplen;
-	datalen = MLX5E_TEST_PKT_SIZE -
-		  (sizeof(*ethh) + sizeof(*iph) + sizeof(*udph));
 	skb = netdev_alloc_skb(priv->netdev, MLX5E_TEST_PKT_SIZE);
 	if (!skb) {
 	/* Fill UDP header */
 	udph->source = htons(9);
 	udph->dest = htons(9); /* Discard Protocol */
-	udph->len = htons(datalen + sizeof(struct udphdr));
+	udph->len = htons(sizeof(struct mlx5ehdr) + sizeof(struct udphdr));
 	udph->check = 0;
 	/* Fill IP header */
 	iph->ttl = 32;
 	iph->version = 4;
 	iph->protocol = IPPROTO_UDP;
-	iplen = sizeof(struct iphdr) + sizeof(struct udphdr) + datalen;
+	iplen = sizeof(struct iphdr) + sizeof(struct udphdr) +
+		sizeof(struct mlx5ehdr);
 	iph->tot_len = htons(iplen);
 	iph->frag_off = 0;
 	iph->saddr = 0;
 	mlxh = skb_put(skb, sizeof(*mlxh));
 	mlxh->version = 0;
 	mlxh->magic = cpu_to_be64(MLX5E_TEST_MAGIC);
-	strlcpy(mlxh->text, mlx5e_test_text, sizeof(mlxh->text));
-	datalen -= sizeof(*mlxh);
-	skb_put_zero(skb, datalen);
 	skb->csum = 0;
 	skb->ip_summed = CHECKSUM_PARTIAL;

drivers/net/ethernet/mellanox/mlx5/core/en_stats.c+3−0

 	{ MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, rx_wqe_err) },
 	{ MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, rx_mpwqe_filler_cqes) },
 	{ MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, rx_mpwqe_filler_strides) },
+	{ MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, rx_oversize_pkts_sw_drop) },
 	{ MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, rx_buff_alloc_err) },
 	{ MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, rx_cqe_compress_blks) },
 	{ MLX5E_DECLARE_STAT(struct mlx5e_sw_stats, rx_cqe_compress_pkts) },
 		s->rx_wqe_err   += rq_stats->wqe_err;
 		s->rx_mpwqe_filler_cqes    += rq_stats->mpwqe_filler_cqes;
 		s->rx_mpwqe_filler_strides += rq_stats->mpwqe_filler_strides;
+		s->rx_oversize_pkts_sw_drop += rq_stats->oversize_pkts_sw_drop;
 		s->rx_buff_alloc_err += rq_stats->buff_alloc_err;
 		s->rx_cqe_compress_blks += rq_stats->cqe_compress_blks;
 		s->rx_cqe_compress_pkts += rq_stats->cqe_compress_pkts;
 	{ MLX5E_DECLARE_RX_STAT(struct mlx5e_rq_stats, wqe_err) },
 	{ MLX5E_DECLARE_RX_STAT(struct mlx5e_rq_stats, mpwqe_filler_cqes) },
 	{ MLX5E_DECLARE_RX_STAT(struct mlx5e_rq_stats, mpwqe_filler_strides) },
+	{ MLX5E_DECLARE_RX_STAT(struct mlx5e_rq_stats, oversize_pkts_sw_drop) },
 	{ MLX5E_DECLARE_RX_STAT(struct mlx5e_rq_stats, buff_alloc_err) },
 	{ MLX5E_DECLARE_RX_STAT(struct mlx5e_rq_stats, cqe_compress_blks) },
 	{ MLX5E_DECLARE_RX_STAT(struct mlx5e_rq_stats, cqe_compress_pkts) },

drivers/net/ethernet/mellanox/mlx5/core/en_stats.h+2−0

 	u64 rx_wqe_err;
 	u64 rx_mpwqe_filler_cqes;
 	u64 rx_mpwqe_filler_strides;
+	u64 rx_oversize_pkts_sw_drop;
 	u64 rx_buff_alloc_err;
 	u64 rx_cqe_compress_blks;
 	u64 rx_cqe_compress_pkts;
 	u64 wqe_err;
 	u64 mpwqe_filler_cqes;
 	u64 mpwqe_filler_strides;
+	u64 oversize_pkts_sw_drop;
 	u64 buff_alloc_err;
 	u64 cqe_compress_blks;
 	u64 cqe_compress_pkts;

drivers/net/ethernet/mellanox/mlx5/core/en_tc.c+35−34

 					 inner_headers);
 	}
-	if (dissector_uses_key(f->dissector, FLOW_DISSECTOR_KEY_ETH_ADDRS)) {
+	if (dissector_uses_key(f->dissector, FLOW_DISSECTOR_KEY_BASIC)) {
-		struct flow_dissector_key_eth_addrs *key =
+		struct flow_dissector_key_basic *key =
 			skb_flow_dissector_target(f->dissector,
-						  FLOW_DISSECTOR_KEY_ETH_ADDRS,
+						  FLOW_DISSECTOR_KEY_BASIC,
 						  f->key);
-		struct flow_dissector_key_eth_addrs *mask =
+		struct flow_dissector_key_basic *mask =
 			skb_flow_dissector_target(f->dissector,
-						  FLOW_DISSECTOR_KEY_ETH_ADDRS,
+						  FLOW_DISSECTOR_KEY_BASIC,
 						  f->mask);
+		MLX5_SET(fte_match_set_lyr_2_4, headers_c, ethertype,
+			 ntohs(mask->n_proto));
+		MLX5_SET(fte_match_set_lyr_2_4, headers_v, ethertype,
+			 ntohs(key->n_proto));
-		ether_addr_copy(MLX5_ADDR_OF(fte_match_set_lyr_2_4, headers_c,
+		if (mask->n_proto)
-					     dmac_47_16),
-				mask->dst);
-		ether_addr_copy(MLX5_ADDR_OF(fte_match_set_lyr_2_4, headers_v,
-					     dmac_47_16),
-				key->dst);
-		ether_addr_copy(MLX5_ADDR_OF(fte_match_set_lyr_2_4, headers_c,
-					     smac_47_16),
-				mask->src);
-		ether_addr_copy(MLX5_ADDR_OF(fte_match_set_lyr_2_4, headers_v,
-					     smac_47_16),
-				key->src);
-		if (!is_zero_ether_addr(mask->src) || !is_zero_ether_addr(mask->dst))
 			*match_level = MLX5_MATCH_L2;
 	}
 			*match_level = MLX5_MATCH_L2;
 		}
-	} else {
+	} else if (*match_level != MLX5_MATCH_NONE) {
 		MLX5_SET(fte_match_set_lyr_2_4, headers_c, svlan_tag, 1);
 		MLX5_SET(fte_match_set_lyr_2_4, headers_c, cvlan_tag, 1);
+		*match_level = MLX5_MATCH_L2;
 	}
 	if (dissector_uses_key(f->dissector, FLOW_DISSECTOR_KEY_CVLAN)) {
 		}
 	}
-	if (dissector_uses_key(f->dissector, FLOW_DISSECTOR_KEY_BASIC)) {
+	if (dissector_uses_key(f->dissector, FLOW_DISSECTOR_KEY_ETH_ADDRS)) {
-		struct flow_dissector_key_basic *key =
+		struct flow_dissector_key_eth_addrs *key =
 			skb_flow_dissector_target(f->dissector,
-						  FLOW_DISSECTOR_KEY_BASIC,
+						  FLOW_DISSECTOR_KEY_ETH_ADDRS,
 						  f->key);
-		struct flow_dissector_key_basic *mask =
+		struct flow_dissector_key_eth_addrs *mask =
 			skb_flow_dissector_target(f->dissector,
-						  FLOW_DISSECTOR_KEY_BASIC,
+						  FLOW_DISSECTOR_KEY_ETH_ADDRS,
 						  f->mask);
-		MLX5_SET(fte_match_set_lyr_2_4, headers_c, ethertype,
-			 ntohs(mask->n_proto));
-		MLX5_SET(fte_match_set_lyr_2_4, headers_v, ethertype,
-			 ntohs(key->n_proto));
-		if (mask->n_proto)
+		ether_addr_copy(MLX5_ADDR_OF(fte_match_set_lyr_2_4, headers_c,
+					     dmac_47_16),
+				mask->dst);
+		ether_addr_copy(MLX5_ADDR_OF(fte_match_set_lyr_2_4, headers_v,
+					     dmac_47_16),
+				key->dst);
+		ether_addr_copy(MLX5_ADDR_OF(fte_match_set_lyr_2_4, headers_c,
+					     smac_47_16),
+				mask->src);
+		ether_addr_copy(MLX5_ADDR_OF(fte_match_set_lyr_2_4, headers_v,
+					     smac_47_16),
+				key->src);
+		if (!is_zero_ether_addr(mask->src) || !is_zero_ether_addr(mask->dst))
 			*match_level = MLX5_MATCH_L2;
 	}
 			/* the HW doesn't need L3 inline to match on frag=no */
 			if (!(key->flags & FLOW_DIS_IS_FRAGMENT))
-				*match_level = MLX5_INLINE_MODE_L2;
+				*match_level = MLX5_MATCH_L2;
 	/* ***  L2 attributes parsing up to here *** */
 			else
-				*match_level = MLX5_INLINE_MODE_IP;
+				*match_level = MLX5_MATCH_L3;
 		}
 	}
 	if (!actions_match_supported(priv, exts, parse_attr, flow, extack))
 		return -EOPNOTSUPP;
-	if (attr->out_count > 1 && !mlx5_esw_has_fwd_fdb(priv->mdev)) {
+	if (attr->mirror_count > 0 && !mlx5_esw_has_fwd_fdb(priv->mdev)) {
 		NL_SET_ERR_MSG_MOD(extack,
 				   "current firmware doesn't support split rule for port mirroring");
 		netdev_warn_once(priv->netdev, "current firmware doesn't support split rule for port mirroring\n");

drivers/net/ethernet/mellanox/mlx5/core/fpga/ipsec.c+8−2

 };
 static const struct rhashtable_params rhash_sa = {
-	.key_len = FIELD_SIZEOF(struct mlx5_fpga_ipsec_sa_ctx, hw_sa),
+	/* Keep out "cmd" field from the key as it's
-	.key_offset = offsetof(struct mlx5_fpga_ipsec_sa_ctx, hw_sa),
+	 * value is not constant during the lifetime
+	 * of the key object.
+	 */
+	.key_len = FIELD_SIZEOF(struct mlx5_fpga_ipsec_sa_ctx, hw_sa) -
+		   FIELD_SIZEOF(struct mlx5_ifc_fpga_ipsec_sa_v1, cmd),
+	.key_offset = offsetof(struct mlx5_fpga_ipsec_sa_ctx, hw_sa) +
+		      FIELD_SIZEOF(struct mlx5_ifc_fpga_ipsec_sa_v1, cmd),
 	.head_offset = offsetof(struct mlx5_fpga_ipsec_sa_ctx, hash),
 	.automatic_shrinking = true,
 	.min_size = 1,

drivers/net/ethernet/mellanox/mlx5/core/ipoib/ipoib.c+1−1

 	netif_carrier_off(epriv->netdev);
 	mlx5_fs_remove_rx_underlay_qpn(mdev, ipriv->qp.qpn);
-	mlx5i_uninit_underlay_qp(epriv);
 	mlx5e_deactivate_priv_channels(epriv);
 	mlx5e_close_channels(&epriv->channels);
+	mlx5i_uninit_underlay_qp(epriv);
 unlock:
 	mutex_unlock(&epriv->state_lock);
 	return 0;

drivers/net/ethernet/qlogic/qed/qed_dev.c+24−5

 	struct qed_qm_info *qm_info = &p_hwfn->qm_info;
 	/* Can't have multiple flags set here */
-	if (bitmap_weight((unsigned long *)&pq_flags, sizeof(pq_flags)) > 1)
+	if (bitmap_weight((unsigned long *)&pq_flags,
+			  sizeof(pq_flags) * BITS_PER_BYTE) > 1) {
+		DP_ERR(p_hwfn, "requested multiple pq flags 0x%x\n", pq_flags);
 		goto err;
+	}
+	if (!(qed_get_pq_flags(p_hwfn) & pq_flags)) {
+		DP_ERR(p_hwfn, "pq flag 0x%x is not set\n", pq_flags);
+		goto err;
+	}
 	switch (pq_flags) {
 	case PQ_FLAGS_RLS:
 	}
 err:
-	DP_ERR(p_hwfn, "BAD pq flags %d\n", pq_flags);
+	return &qm_info->start_pq;
-	return NULL;
 }
 /* save pq index in qm info */
 {
 	u8 max_tc = qed_init_qm_get_num_tcs(p_hwfn);
+	if (max_tc == 0) {
+		DP_ERR(p_hwfn, "pq with flag 0x%lx do not exist\n",
+		       PQ_FLAGS_MCOS);
+		return p_hwfn->qm_info.start_pq;
+	}
 	if (tc > max_tc)
 		DP_ERR(p_hwfn, "tc %d must be smaller than %d\n", tc, max_tc);
-	return qed_get_cm_pq_idx(p_hwfn, PQ_FLAGS_MCOS) + tc;
+	return qed_get_cm_pq_idx(p_hwfn, PQ_FLAGS_MCOS) + (tc % max_tc);
 }
 u16 qed_get_cm_pq_idx_vf(struct qed_hwfn *p_hwfn, u16 vf)
 {
 	u16 max_vf = qed_init_qm_get_num_vfs(p_hwfn);
+	if (max_vf == 0) {
+		DP_ERR(p_hwfn, "pq with flag 0x%lx do not exist\n",
+		       PQ_FLAGS_VFS);
+		return p_hwfn->qm_info.start_pq;
+	}
 	if (vf > max_vf)
 		DP_ERR(p_hwfn, "vf %d must be smaller than %d\n", vf, max_vf);
-	return qed_get_cm_pq_idx(p_hwfn, PQ_FLAGS_VFS) + vf;
+	return qed_get_cm_pq_idx(p_hwfn, PQ_FLAGS_VFS) + (vf % max_vf);
 }
 u16 qed_get_cm_pq_idx_ofld_mtc(struct qed_hwfn *p_hwfn, u8 tc)

drivers/net/phy/mscc.c+5−9

@@ -810,17 +810,13 @@ static int vsc85xx_default_config(struct phy_device *phydev) · 809 unmodified lines
810		810
811	phydev->mdix_ctrl = ETH_TP_MDI_AUTO;	811	phydev->mdix_ctrl = ETH_TP_MDI_AUTO;
812	mutex_lock(&phydev->lock);	812	mutex_lock(&phydev->lock);
813	rc = phy_select_page(phydev, MSCC_PHY_PAGE_EXTENDED_2);
814	if (rc < 0)
815	goto out_unlock;
816		813
817	reg_val = phy_read(phydev, MSCC_PHY_RGMII_CNTL);	814	reg_val = RGMII_RX_CLK_DELAY_1_1_NS << RGMII_RX_CLK_DELAY_POS;
818	reg_val &= ~(RGMII_RX_CLK_DELAY_MASK);	815
819	reg_val \|= (RGMII_RX_CLK_DELAY_1_1_NS << RGMII_RX_CLK_DELAY_POS);	816	rc = phy_modify_paged(phydev, MSCC_PHY_PAGE_EXTENDED_2,
820	phy_write(phydev, MSCC_PHY_RGMII_CNTL, reg_val);	817	MSCC_PHY_RGMII_CNTL, RGMII_RX_CLK_DELAY_MASK,
		818	reg_val);
821		819
822	out_unlock:
823	rc = phy_restore_page(phydev, rc, rc > 0 ? 0 : rc);
824	mutex_unlock(&phydev->lock);	820	mutex_unlock(&phydev->lock);
825		821
826	return rc;	822	return rc;

drivers/net/team/team.c+0−2

@@ -985,8 +985,6 @@ static void team_port_disable(struct team *team, · 984 unmodified lines
985	team->en_port_count--;	985	team->en_port_count--;
986	team_queue_override_port_del(team, port);	986	team_queue_override_port_del(team, port);
987	team_adjust_ops(team);	987	team_adjust_ops(team);
988	team_notify_peers(team);
989	team_mcast_rejoin(team);
990	team_lower_state_changed(port);	988	team_lower_state_changed(port);
991	}	989	}
992		990

drivers/net/virtio_net.c+5−8

 	VIRTIO_NET_F_GUEST_TSO4,
 	VIRTIO_NET_F_GUEST_TSO6,
 	VIRTIO_NET_F_GUEST_ECN,
-	VIRTIO_NET_F_GUEST_UFO
+	VIRTIO_NET_F_GUEST_UFO,
+	VIRTIO_NET_F_GUEST_CSUM
 };
 struct virtnet_stat_desc {
 	if (!vi->guest_offloads)
 		return 0;
-	if (virtio_has_feature(vi->vdev, VIRTIO_NET_F_GUEST_CSUM))
-		offloads = 1ULL << VIRTIO_NET_F_GUEST_CSUM;
 	return virtnet_set_guest_offloads(vi, offloads);
 }
 	if (!vi->guest_offloads)
 		return 0;
-	if (virtio_has_feature(vi->vdev, VIRTIO_NET_F_GUEST_CSUM))
-		offloads |= 1ULL << VIRTIO_NET_F_GUEST_CSUM;
 	return virtnet_set_guest_offloads(vi, offloads);
 }
 	    && (virtio_has_feature(vi->vdev, VIRTIO_NET_F_GUEST_TSO4) ||
 	        virtio_has_feature(vi->vdev, VIRTIO_NET_F_GUEST_TSO6) ||
 	        virtio_has_feature(vi->vdev, VIRTIO_NET_F_GUEST_ECN) ||
-		virtio_has_feature(vi->vdev, VIRTIO_NET_F_GUEST_UFO))) {
+		virtio_has_feature(vi->vdev, VIRTIO_NET_F_GUEST_UFO) ||
-		NL_SET_ERR_MSG_MOD(extack, "Can't set XDP while host is implementing LRO, disable LRO first");
+		virtio_has_feature(vi->vdev, VIRTIO_NET_F_GUEST_CSUM))) {
+		NL_SET_ERR_MSG_MOD(extack, "Can't set XDP while host is implementing LRO/CSUM, disable LRO/CSUM first");
 		return -EOPNOTSUPP;
 	}

drivers/net/wireless/ath/ath10k/mac.c+1−1

@@ -6867,7 +6867,7 @@ static void ath10k_flush(struct ieee80211_hw hw, struct ieee80211_vif vif, · 6866 unmodified lines
6867	u32 bitmap;	6867	u32 bitmap;
6868		6868
6869	if (drop) {	6869	if (drop) {
6870	if (vif->type == NL80211_IFTYPE_STATION) {	6870	if (vif && vif->type == NL80211_IFTYPE_STATION) {
6871	bitmap = ~(1 << WMI_MGMT_TID);	6871	bitmap = ~(1 << WMI_MGMT_TID);
6872	list_for_each_entry(arvif, &ar->arvifs, list) {	6872	list_for_each_entry(arvif, &ar->arvifs, list) {
6873	if (arvif->vdev_type == WMI_VDEV_TYPE_STA)	6873	if (arvif->vdev_type == WMI_VDEV_TYPE_STA)

drivers/net/wireless/ath/ath9k/main.c+1−2

 	struct ath_vif *avp = (void *)vif->drv_priv;
 	struct ath_node *an = &avp->mcast_node;
+	mutex_lock(&sc->mutex);
 	if (IS_ENABLED(CONFIG_ATH9K_TX99)) {
 		if (sc->cur_chan->nvifs >= 1) {
 			mutex_unlock(&sc->mutex);
 		sc->tx99_vif = vif;
 	}
-	mutex_lock(&sc->mutex);
 	ath_dbg(common, CONFIG, "Attach a VIF of type: %d\n", vif->type);
 	sc->cur_chan->nvifs++;

drivers/net/wireless/broadcom/brcm80211/brcmfmac/cfg80211.c+2−1

 			 * for subsequent chanspecs.
 			 */
 			channel->flags = IEEE80211_CHAN_NO_HT40 |
-					 IEEE80211_CHAN_NO_80MHZ;
+					 IEEE80211_CHAN_NO_80MHZ |
+					 IEEE80211_CHAN_NO_160MHZ;
 			ch.bw = BRCMU_CHAN_BW_20;
 			cfg->d11inf.encchspec(&ch);
 			chaninfo = ch.chspec;

drivers/net/wireless/broadcom/brcm80211/brcmutil/d11.c+3−0

 		}
 		break;
 	case BRCMU_CHSPEC_D11AC_BW_160:
+		ch->bw = BRCMU_CHAN_BW_160;
+		ch->sb = brcmu_maskget16(ch->chspec, BRCMU_CHSPEC_D11AC_SB_MASK,
+					 BRCMU_CHSPEC_D11AC_SB_SHIFT);
 		switch (ch->sb) {
 		case BRCMU_CHAN_SB_LLL:
 			ch->control_ch_num -= CH_70MHZ_APART;

drivers/net/wireless/intel/iwlwifi/fw/acpi.h+3−1

  * GPL LICENSE SUMMARY
  *
  * Copyright(c) 2017        Intel Deutschland GmbH
+ * Copyright(c) 2018        Intel Corporation
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of version 2 of the GNU General Public License as
  * BSD LICENSE
  *
  * Copyright(c) 2017        Intel Deutschland GmbH
+ * Copyright(c) 2018        Intel Corporation
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
 #define ACPI_WRDS_WIFI_DATA_SIZE	(ACPI_SAR_TABLE_SIZE + 2)
 #define ACPI_EWRD_WIFI_DATA_SIZE	((ACPI_SAR_PROFILE_NUM - 1) * \
 					 ACPI_SAR_TABLE_SIZE + 3)
-#define ACPI_WGDS_WIFI_DATA_SIZE	18
+#define ACPI_WGDS_WIFI_DATA_SIZE	19
 #define ACPI_WRDD_WIFI_DATA_SIZE	2
 #define ACPI_SPLC_WIFI_DATA_SIZE	2

drivers/net/wireless/intel/iwlwifi/fw/runtime.h+5−1

 			const struct iwl_fw_runtime_ops *ops, void *ops_ctx,
 			struct dentry *dbgfs_dir);
-void iwl_fw_runtime_exit(struct iwl_fw_runtime *fwrt);
+static inline void iwl_fw_runtime_free(struct iwl_fw_runtime *fwrt)
+{
+	kfree(fwrt->dump.d3_debug_data);
+	fwrt->dump.d3_debug_data = NULL;
+}
 void iwl_fw_runtime_suspend(struct iwl_fw_runtime *fwrt);

drivers/net/wireless/intel/iwlwifi/mvm/fw.c+29−9

 	IWL_DEBUG_RADIO(mvm, "Sending GEO_TX_POWER_LIMIT\n");
 	BUILD_BUG_ON(ACPI_NUM_GEO_PROFILES * ACPI_WGDS_NUM_BANDS *
-		     ACPI_WGDS_TABLE_SIZE !=  ACPI_WGDS_WIFI_DATA_SIZE);
+		     ACPI_WGDS_TABLE_SIZE + 1 !=  ACPI_WGDS_WIFI_DATA_SIZE);
 	BUILD_BUG_ON(ACPI_NUM_GEO_PROFILES > IWL_NUM_GEO_PROFILES);
 	return -ENOENT;
 }
+static int iwl_mvm_sar_get_wgds_table(struct iwl_mvm *mvm)
+{
+	return -ENOENT;
+}
 static int iwl_mvm_sar_geo_init(struct iwl_mvm *mvm)
 {
 	return 0;
 		IWL_DEBUG_RADIO(mvm,
 				"WRDS SAR BIOS table invalid or unavailable. (%d)\n",
 				ret);
-		/* if not available, don't fail and don't bother with EWRD */
+		/*
-		return 0;
+		 * If not available, don't fail and don't bother with EWRD.
+		 * Return 1 to tell that we can't use WGDS either.
+		 */
+		return 1;
 	}
 	ret = iwl_mvm_sar_get_ewrd_table(mvm);
 	/* choose profile 1 (WRDS) as default for both chains */
 	ret = iwl_mvm_sar_select_profile(mvm, 1, 1);
-	/* if we don't have profile 0 from BIOS, just skip it */
+	/*
+	 * If we don't have profile 0 from BIOS, just skip it.  This
+	 * means that SAR Geo will not be enabled either, even if we
+	 * have other valid profiles.
+	 */
 	if (ret == -ENOENT)
-		return 0;
+		return 1;
 	return ret;
 }
 		iwl_mvm_unref(mvm, IWL_MVM_REF_UCODE_DOWN);
 	ret = iwl_mvm_sar_init(mvm);
-	if (ret)
+	if (ret == 0) {
-		goto error;
+		ret = iwl_mvm_sar_geo_init(mvm);
+	} else if (ret > 0 && !iwl_mvm_sar_get_wgds_table(mvm)) {
+		/*
+		 * If basic SAR is not available, we check for WGDS,
+		 * which should *not* be available either.  If it is
+		 * available, issue an error, because we can't use SAR
+		 * Geo without basic SAR.
+		 */
+		IWL_ERR(mvm, "BIOS contains WGDS but no WRDS\n");
+	}
-	ret = iwl_mvm_sar_geo_init(mvm);
+	if (ret < 0)
-	if (ret)
 		goto error;
 	iwl_mvm_leds_sync(mvm);

drivers/net/wireless/intel/iwlwifi/mvm/mac80211.c+6−6

 		goto out;
 	}
-	if (changed)
+	if (changed) {
-		*changed = (resp->status == MCC_RESP_NEW_CHAN_PROFILE);
+		u32 status = le32_to_cpu(resp->status);
+		*changed = (status == MCC_RESP_NEW_CHAN_PROFILE ||
+			    status == MCC_RESP_ILLEGAL);
+	}
 	regd = iwl_parse_nvm_mcc_info(mvm->trans->dev, mvm->cfg,
 				      __le32_to_cpu(resp->n_channels),
 		sinfo->filled |= BIT_ULL(NL80211_STA_INFO_SIGNAL_AVG);
 	}
-	if (!fw_has_capa(&mvm->fw->ucode_capa,
-			 IWL_UCODE_TLV_CAPA_RADIO_BEACON_STATS))
-		return;
 	/* if beacon filtering isn't on mac80211 does it anyway */
 	if (!(vif->driver_flags & IEEE80211_VIF_BEACON_FILTER))
 		return;

drivers/net/wireless/intel/iwlwifi/mvm/nvm.c+2−3

@@ -539,9 +539,8 @@ iwl_mvm_update_mcc(struct iwl_mvm mvm, const char alpha2, · 538 unmodified lines
539	}	539	}
540		540
541	IWL_DEBUG_LAR(mvm,	541	IWL_DEBUG_LAR(mvm,
542	"MCC response status: 0x%x. new MCC: 0x%x ('%c%c') change: %d n_chans: %d\n",	542	"MCC response status: 0x%x. new MCC: 0x%x ('%c%c') n_chans: %d\n",
543	status, mcc, mcc >> 8, mcc & 0xff,	543	status, mcc, mcc >> 8, mcc & 0xff, n_channels);
544	!!(status == MCC_RESP_NEW_CHAN_PROFILE), n_channels);
545		544
546	exit:	545	exit:
547	iwl_free_resp(&cmd);	546	iwl_free_resp(&cmd);

drivers/net/wireless/intel/iwlwifi/mvm/ops.c+2−0

 	iwl_mvm_thermal_exit(mvm);
  out_free:
 	iwl_fw_flush_dump(&mvm->fwrt);
+	iwl_fw_runtime_free(&mvm->fwrt);
 	if (iwlmvm_mod_params.init_dbg)
 		return op_mode;
 	iwl_mvm_tof_clean(mvm);
+	iwl_fw_runtime_free(&mvm->fwrt);
 	mutex_destroy(&mvm->mutex);
 	mutex_destroy(&mvm->d0i3_suspend_mutex);

drivers/net/wireless/mediatek/mt76/Kconfig+6−0

 config MT76_CORE
 	tristate
+config MT76_LEDS
+	bool
+	depends on MT76_CORE
+	depends on LEDS_CLASS=y || MT76_CORE=LEDS_CLASS
+	default y
 config MT76_USB
 	tristate
 	depends on MT76_CORE

drivers/net/wireless/mediatek/mt76/mac80211.c+5−3

 	mt76_check_sband(dev, NL80211_BAND_2GHZ);
 	mt76_check_sband(dev, NL80211_BAND_5GHZ);
-	ret = mt76_led_init(dev);
+	if (IS_ENABLED(CONFIG_MT76_LEDS)) {
-	if (ret)
+		ret = mt76_led_init(dev);
-		return ret;
+		if (ret)
+			return ret;
+	}
 	return ieee80211_register_hw(hw);
 }

drivers/net/wireless/mediatek/mt76/mt76x02.h+0−1

@@ -71,7 +71,6 @@ struct mt76x02_dev { · 70 unmodified lines
71	struct mac_address macaddr_list[8];	71	struct mac_address macaddr_list[8];
72		72
73	struct mutex phy_mutex;	73	struct mutex phy_mutex;
74	struct mutex mutex;
75		74
76	u8 txdone_seq;	75	u8 txdone_seq;
77	DECLARE_KFIFO_PTR(txstatus_fifo, struct mt76x02_tx_status);	76	DECLARE_KFIFO_PTR(txstatus_fifo, struct mt76x02_tx_status);

drivers/net/wireless/mediatek/mt76/mt76x2/pci_init.c+4−2

 	mt76x2_dfs_init_detector(dev);
 	/* init led callbacks */
-	dev->mt76.led_cdev.brightness_set = mt76x2_led_set_brightness;
+	if (IS_ENABLED(CONFIG_MT76_LEDS)) {
-	dev->mt76.led_cdev.blink_set = mt76x2_led_set_blink;
+		dev->mt76.led_cdev.brightness_set = mt76x2_led_set_brightness;
+		dev->mt76.led_cdev.blink_set = mt76x2_led_set_blink;
+	}
 	ret = mt76_register_device(&dev->mt76, true, mt76x02_rates,
 				   ARRAY_SIZE(mt76x02_rates));

drivers/net/wireless/mediatek/mt76/mt76x2/pci_main.c+2−2

@@ -272,9 +272,9 @@ mt76x2_set_rts_threshold(struct ieee80211_hw *hw, u32 val) · 271 unmodified lines
272	if (val != ~0 && val > 0xffff)	272	if (val != ~0 && val > 0xffff)
273	return -EINVAL;	273	return -EINVAL;
274		274
275	mutex_lock(&dev->mutex);	275	mutex_lock(&dev->mt76.mutex);
276	mt76x2_mac_set_tx_protection(dev, val);	276	mt76x2_mac_set_tx_protection(dev, val);
277	mutex_unlock(&dev->mutex);	277	mutex_unlock(&dev->mt76.mutex);
278		278
279	return 0;	279	return 0;
280	}	280	}

drivers/net/wireless/ti/wlcore/sdio.c+11−6

 	struct resource res[2];
 	mmc_pm_flag_t mmcflags;
 	int ret = -ENOMEM;
-	int irq, wakeirq;
+	int irq, wakeirq, num_irqs;
 	const char *chip_family;
 	/* We are only able to handle the wlan function */
 		       irqd_get_trigger_type(irq_get_irq_data(irq));
 	res[0].name = "irq";
-	res[1].start = wakeirq;
-	res[1].flags = IORESOURCE_IRQ |
-		       irqd_get_trigger_type(irq_get_irq_data(wakeirq));
-	res[1].name = "wakeirq";
-	ret = platform_device_add_resources(glue->core, res, ARRAY_SIZE(res));
+	if (wakeirq > 0) {
+		res[1].start = wakeirq;
+		res[1].flags = IORESOURCE_IRQ |
+			       irqd_get_trigger_type(irq_get_irq_data(wakeirq));
+		res[1].name = "wakeirq";
+		num_irqs = 2;
+	} else {
+		num_irqs = 1;
+	}
+	ret = platform_device_add_resources(glue->core, res, num_irqs);
 	if (ret) {
 		dev_err(glue->dev, "can't add resources\n");
 		goto out_dev_put;

drivers/nvme/host/fc.c+63−10

@@ -152,6 +152,7 @@ struct nvme_fc_ctrl { · 151 unmodified lines
152		152
153	bool ioq_live;	153	bool ioq_live;
154	bool assoc_active;	154	bool assoc_active;
		155	atomic_t err_work_active;
155	u64 association_id;	156	u64 association_id;
156		157
157	struct list_head ctrl_list; /* rport->ctrl_list */	158	struct list_head ctrl_list; /* rport->ctrl_list */
@@ -160,6 +161,7 @@ struct nvme_fc_ctrl { · 2 unmodified lines
160	struct blk_mq_tag_set tag_set;	161	struct blk_mq_tag_set tag_set;
161		162
162	struct delayed_work connect_work;	163	struct delayed_work connect_work;
		164	struct work_struct err_work;
163		165
164	struct kref ref;	166	struct kref ref;
165	u32 flags;	167	u32 flags;
@@ -1531,6 +1533,10 @@ nvme_fc_abort_aen_ops(struct nvme_fc_ctrl *ctrl) · 1365 unmodified lines
1531	struct nvme_fc_fcp_op *aen_op = ctrl->aen_ops;	1533	struct nvme_fc_fcp_op *aen_op = ctrl->aen_ops;
1532	int i;	1534	int i;
1533		1535
		1536	/* ensure we've initialized the ops once */
		1537	if (!(aen_op->flags & FCOP_FLAGS_AEN))
		1538	return;
		1539
1534	for (i = 0; i < NVME_NR_AEN_COMMANDS; i++, aen_op++)	1540	for (i = 0; i < NVME_NR_AEN_COMMANDS; i++, aen_op++)
1535	__nvme_fc_abort_op(ctrl, aen_op);	1541	__nvme_fc_abort_op(ctrl, aen_op);
1536	}	1542	}
@@ -2049,7 +2055,25 @@ nvme_fc_nvme_ctrl_freed(struct nvme_ctrl *nctrl) · 512 unmodified lines
2049	static void	2055	static void
2050	nvme_fc_error_recovery(struct nvme_fc_ctrl ctrl, char errmsg)	2056	nvme_fc_error_recovery(struct nvme_fc_ctrl ctrl, char errmsg)
2051	{	2057	{
2052	/* only proceed if in LIVE state - e.g. on first error */	2058	int active;
		2059
		2060	/*
		2061	* if an error (io timeout, etc) while (re)connecting,
		2062	* it's an error on creating the new association.
		2063	* Start the error recovery thread if it hasn't already
		2064	* been started. It is expected there could be multiple
		2065	* ios hitting this path before things are cleaned up.
		2066	*/
		2067	if (ctrl->ctrl.state == NVME_CTRL_CONNECTING) {
		2068	active = atomic_xchg(&ctrl->err_work_active, 1);
		2069	if (!active && !schedule_work(&ctrl->err_work)) {
		2070	atomic_set(&ctrl->err_work_active, 0);
		2071	WARN_ON(1);
		2072	}
		2073	return;
		2074	}
		2075
		2076	/* Otherwise, only proceed if in LIVE state - e.g. on first error */
2053	if (ctrl->ctrl.state != NVME_CTRL_LIVE)	2077	if (ctrl->ctrl.state != NVME_CTRL_LIVE)
2054	return;	2078	return;
2055		2079
@@ -2814,6 +2838,7 @@ nvme_fc_delete_ctrl(struct nvme_ctrl *nctrl) · 758 unmodified lines
2814	{	2838	{
2815	struct nvme_fc_ctrl *ctrl = to_fc_ctrl(nctrl);	2839	struct nvme_fc_ctrl *ctrl = to_fc_ctrl(nctrl);
2816		2840
		2841	cancel_work_sync(&ctrl->err_work);
2817	cancel_delayed_work_sync(&ctrl->connect_work);	2842	cancel_delayed_work_sync(&ctrl->connect_work);
2818	/*	2843	/*
2819	* kill the association on the link side. this will block	2844	* kill the association on the link side. this will block
@@ -2866,23 +2891,30 @@ nvme_fc_reconnect_or_delete(struct nvme_fc_ctrl *ctrl, int status) · 46 unmodified lines
2866	}	2891	}
2867		2892
2868	static void	2893	static void
2869	nvme_fc_reset_ctrl_work(struct work_struct *work)	2894	__nvme_fc_terminate_io(struct nvme_fc_ctrl *ctrl)
2870	{	2895	{
2871	struct nvme_fc_ctrl *ctrl =	2896	nvme_stop_keep_alive(&ctrl->ctrl);
2872	container_of(work, struct nvme_fc_ctrl, ctrl.reset_work);
2873	int ret;
2874
2875	nvme_stop_ctrl(&ctrl->ctrl);
2876		2897
2877	/* will block will waiting for io to terminate */	2898	/* will block will waiting for io to terminate */
2878	nvme_fc_delete_association(ctrl);	2899	nvme_fc_delete_association(ctrl);
2879		2900
2880	if (!nvme_change_ctrl_state(&ctrl->ctrl, NVME_CTRL_CONNECTING)) {	2901	if (ctrl->ctrl.state != NVME_CTRL_CONNECTING &&
		2902	!nvme_change_ctrl_state(&ctrl->ctrl, NVME_CTRL_CONNECTING))
2881	dev_err(ctrl->ctrl.device,	2903	dev_err(ctrl->ctrl.device,
2882	"NVME-FC{%d}: error_recovery: Couldn't change state "	2904	"NVME-FC{%d}: error_recovery: Couldn't change state "
2883	"to CONNECTING\n", ctrl->cnum);	2905	"to CONNECTING\n", ctrl->cnum);
2884	return;	2906	}
2885	}	2907
		2908	static void
		2909	nvme_fc_reset_ctrl_work(struct work_struct *work)
		2910	{
		2911	struct nvme_fc_ctrl *ctrl =
		2912	container_of(work, struct nvme_fc_ctrl, ctrl.reset_work);
		2913	int ret;
		2914
		2915	__nvme_fc_terminate_io(ctrl);
		2916
		2917	nvme_stop_ctrl(&ctrl->ctrl);
2886		2918
2887	if (ctrl->rport->remoteport.port_state == FC_OBJSTATE_ONLINE)	2919	if (ctrl->rport->remoteport.port_state == FC_OBJSTATE_ONLINE)
2888	ret = nvme_fc_create_association(ctrl);	2920	ret = nvme_fc_create_association(ctrl);
@@ -2897,6 +2929,24 @@ nvme_fc_reset_ctrl_work(struct work_struct *work) · 8 unmodified lines
2897	ctrl->cnum);	2929	ctrl->cnum);
2898	}	2930	}
2899		2931
		2932	static void
		2933	nvme_fc_connect_err_work(struct work_struct *work)
		2934	{
		2935	struct nvme_fc_ctrl *ctrl =
		2936	container_of(work, struct nvme_fc_ctrl, err_work);
		2937
		2938	__nvme_fc_terminate_io(ctrl);
		2939
		2940	atomic_set(&ctrl->err_work_active, 0);
		2941
		2942	/*
		2943	* Rescheduling the connection after recovering
		2944	* from the io error is left to the reconnect work
		2945	* item, which is what should have stalled waiting on
		2946	* the io that had the error that scheduled this work.
		2947	*/
		2948	}
		2949
2900	static const struct nvme_ctrl_ops nvme_fc_ctrl_ops = {	2950	static const struct nvme_ctrl_ops nvme_fc_ctrl_ops = {
2901	.name = "fc",	2951	.name = "fc",
2902	.module = THIS_MODULE,	2952	.module = THIS_MODULE,
@@ -3007,6 +3057,7 @@ nvme_fc_init_ctrl(struct device dev, struct nvmf_ctrl_options opts, · 104 unmodified lines
3007	ctrl->cnum = idx;	3057	ctrl->cnum = idx;
3008	ctrl->ioq_live = false;	3058	ctrl->ioq_live = false;
3009	ctrl->assoc_active = false;	3059	ctrl->assoc_active = false;
		3060	atomic_set(&ctrl->err_work_active, 0);
3010	init_waitqueue_head(&ctrl->ioabort_wait);	3061	init_waitqueue_head(&ctrl->ioabort_wait);
3011		3062
3012	get_device(ctrl->dev);	3063	get_device(ctrl->dev);
@@ -3014,6 +3065,7 @@ nvme_fc_init_ctrl(struct device dev, struct nvmf_ctrl_options opts, · 1 unmodified line
3014		3065
3015	INIT_WORK(&ctrl->ctrl.reset_work, nvme_fc_reset_ctrl_work);	3066	INIT_WORK(&ctrl->ctrl.reset_work, nvme_fc_reset_ctrl_work);
3016	INIT_DELAYED_WORK(&ctrl->connect_work, nvme_fc_connect_ctrl_work);	3067	INIT_DELAYED_WORK(&ctrl->connect_work, nvme_fc_connect_ctrl_work);
		3068	INIT_WORK(&ctrl->err_work, nvme_fc_connect_err_work);
3017	spin_lock_init(&ctrl->lock);	3069	spin_lock_init(&ctrl->lock);
3018		3070
3019	/* io queue count */	3071	/* io queue count */
@@ -3103,6 +3155,7 @@ nvme_fc_init_ctrl(struct device dev, struct nvmf_ctrl_options opts, · 83 unmodified lines
3103	fail_ctrl:	3155	fail_ctrl:
3104	nvme_change_ctrl_state(&ctrl->ctrl, NVME_CTRL_DELETING);	3156	nvme_change_ctrl_state(&ctrl->ctrl, NVME_CTRL_DELETING);
3105	cancel_work_sync(&ctrl->ctrl.reset_work);	3157	cancel_work_sync(&ctrl->ctrl.reset_work);
		3158	cancel_work_sync(&ctrl->err_work);
3106	cancel_delayed_work_sync(&ctrl->connect_work);	3159	cancel_delayed_work_sync(&ctrl->connect_work);
3107		3160
3108	ctrl->ctrl.opts = NULL;	3161	ctrl->ctrl.opts = NULL;

drivers/nvmem/core.c+6−4

 	int			bytes;
 	int			bit_offset;
 	int			nbits;
+	struct device_node	*np;
 	struct nvmem_device	*nvmem;
 	struct list_head	node;
 };
 	mutex_lock(&nvmem_mutex);
 	list_del(&cell->node);
 	mutex_unlock(&nvmem_mutex);
+	of_node_put(cell->np);
 	kfree(cell->name);
 	kfree(cell);
 }
 			return -ENOMEM;
 		cell->nvmem = nvmem;
+		cell->np = of_node_get(child);
 		cell->offset = be32_to_cpup(addr++);
 		cell->bytes = be32_to_cpup(addr);
 		cell->name = kasprintf(GFP_KERNEL, "%pOFn", child);
 #if IS_ENABLED(CONFIG_OF)
 static struct nvmem_cell *
-nvmem_find_cell_by_index(struct nvmem_device *nvmem, int index)
+nvmem_find_cell_by_node(struct nvmem_device *nvmem, struct device_node *np)
 {
 	struct nvmem_cell *cell = NULL;
-	int i = 0;
 	mutex_lock(&nvmem_mutex);
 	list_for_each_entry(cell, &nvmem->cells, node) {
-		if (index == i++)
+		if (np == cell->np)
 			break;
 	}
 	mutex_unlock(&nvmem_mutex);
 	if (IS_ERR(nvmem))
 		return ERR_CAST(nvmem);
-	cell = nvmem_find_cell_by_index(nvmem, index);
+	cell = nvmem_find_cell_by_node(nvmem, cell_np);
 	if (!cell) {
 		__nvmem_device_put(nvmem);
 		return ERR_PTR(-ENOENT);

drivers/opp/ti-opp-supply.c+4−1

@@ -288,7 +288,10 @@ static int ti_opp_supply_set_opp(struct dev_pm_set_opp_data *data) · 287 unmodified lines
288	int ret;	288	int ret;
289		289
290	vdd_uv = _get_optimal_vdd_voltage(dev, &opp_data,	290	vdd_uv = _get_optimal_vdd_voltage(dev, &opp_data,
291	new_supply_vbb->u_volt);	291	new_supply_vdd->u_volt);
		292
		293	if (new_supply_vdd->u_volt_min < vdd_uv)
		294	new_supply_vdd->u_volt_min = vdd_uv;
292		295
293	/* Scaling up? Scale voltage before frequency */	296	/* Scaling up? Scale voltage before frequency */
294	if (freq > old_freq) {	297	if (freq > old_freq) {

drivers/scsi/qla2xxx/qla_os.c+8−2

 static void
 __qla2x00_abort_all_cmds(struct qla_qpair *qp, int res)
 {
-	int cnt;
+	int cnt, status;
 	unsigned long flags;
 	srb_t *sp;
 	scsi_qla_host_t *vha = qp->vha;
 					if (!sp_get(sp)) {
 						spin_unlock_irqrestore
 							(qp->qp_lock_ptr, flags);
-						qla2xxx_eh_abort(
+						status = qla2xxx_eh_abort(
 							GET_CMD_SP(sp));
 						spin_lock_irqsave
 							(qp->qp_lock_ptr, flags);
+						/*
+						 * Get rid of extra reference caused
+						 * by early exit from qla2xxx_eh_abort
+						 */
+						if (status == FAST_IO_FAIL)
+							atomic_dec(&sp->ref_count);
 					}
 				}
 				sp->done(sp, res);

drivers/scsi/ufs/ufs-hisi.c+9−0

 #include "unipro.h"
 #include "ufs-hisi.h"
 #include "ufshci.h"
+#include "ufs_quirks.h"
 static int ufs_hisi_check_hibern8(struct ufs_hba *hba)
 {
 static void ufs_hisi_pwr_change_pre_change(struct ufs_hba *hba)
 {
+	if (hba->dev_quirks & UFS_DEVICE_QUIRK_HOST_VS_DEBUGSAVECONFIGTIME) {
+		pr_info("ufs flash device must set VS_DebugSaveConfigTime 0x10\n");
+		/* VS_DebugSaveConfigTime */
+		ufshcd_dme_set(hba, UIC_ARG_MIB(0xD0A0), 0x10);
+		/* sync length */
+		ufshcd_dme_set(hba, UIC_ARG_MIB(0x1556), 0x48);
+	}
 	/* update */
 	ufshcd_dme_set(hba, UIC_ARG_MIB(0x15A8), 0x1);
 	/* PA_TxSkip */

drivers/scsi/ufs/ufs_quirks.h+6−0

@@ -131,4 +131,10 @@ struct ufs_dev_fix { · 130 unmodified lines
131	*/	131	*/
132	#define UFS_DEVICE_QUIRK_HOST_PA_SAVECONFIGTIME (1 << 8)	132	#define UFS_DEVICE_QUIRK_HOST_PA_SAVECONFIGTIME (1 << 8)
133		133
		134	/*
		135	* Some UFS devices require VS_DebugSaveConfigTime is 0x10,
		136	* enabling this quirk ensure this.
		137	*/
		138	#define UFS_DEVICE_QUIRK_HOST_VS_DEBUGSAVECONFIGTIME (1 << 9)
		139
134	#endif /* UFS_QUIRKS_H_ */	140	#endif /* UFS_QUIRKS_H_ */

drivers/scsi/ufs/ufshcd.c+2−0

@@ -231,6 +231,8 @@ static struct ufs_dev_fix ufs_fixups[] = { · 230 unmodified lines
231	UFS_FIX(UFS_VENDOR_SKHYNIX, UFS_ANY_MODEL, UFS_DEVICE_NO_VCCQ),	231	UFS_FIX(UFS_VENDOR_SKHYNIX, UFS_ANY_MODEL, UFS_DEVICE_NO_VCCQ),
232	UFS_FIX(UFS_VENDOR_SKHYNIX, UFS_ANY_MODEL,	232	UFS_FIX(UFS_VENDOR_SKHYNIX, UFS_ANY_MODEL,
233	UFS_DEVICE_QUIRK_HOST_PA_SAVECONFIGTIME),	233	UFS_DEVICE_QUIRK_HOST_PA_SAVECONFIGTIME),
		234	UFS_FIX(UFS_VENDOR_SKHYNIX, "hB8aL1" /H28U62301AMR/,
		235	UFS_DEVICE_QUIRK_HOST_VS_DEBUGSAVECONFIGTIME),
234		236
235	END_FIX	237	END_FIX
236	};	238	};

drivers/slimbus/qcom-ngd-ctrl.c+0−3

@@ -777,9 +777,6 @@ static int qcom_slim_ngd_xfer_msg(struct slim_controller *sctrl, · 776 unmodified lines
777	u8 la = txn->la;	777	u8 la = txn->la;
778	bool usr_msg = false;	778	bool usr_msg = false;
779		779
780	if (txn->mc & SLIM_MSG_CLK_PAUSE_SEQ_FLG)
781	return -EPROTONOSUPPORT;
782
783	if (txn->mt == SLIM_MSG_MT_CORE &&	780	if (txn->mt == SLIM_MSG_MT_CORE &&
784	(txn->mc >= SLIM_MSG_MC_BEGIN_RECONFIGURATION &&	781	(txn->mc >= SLIM_MSG_MC_BEGIN_RECONFIGURATION &&
785	txn->mc <= SLIM_MSG_MC_RECONFIGURE_NOW))	782	txn->mc <= SLIM_MSG_MC_RECONFIGURE_NOW))

drivers/slimbus/slimbus.h+0−6

 #define SLIM_MSG_MC_NEXT_REMOVE_CHANNEL          0x58
 #define SLIM_MSG_MC_RECONFIGURE_NOW              0x5F
-/*
- * Clock pause flag to indicate that the reconfig message
- * corresponds to clock pause sequence
- */
-#define SLIM_MSG_CLK_PAUSE_SEQ_FLG		(1U << 8)
 /* Clock pause values per SLIMbus spec */
 #define SLIM_CLK_FAST				0
 #define SLIM_CLK_CONST_PHASE			1

drivers/staging/media/davinci_vpfe/dm365_ipipeif.c+1−0

@@ -310,6 +310,7 @@ static int ipipeif_hw_setup(struct v4l2_subdev *sd) · 309 unmodified lines
310	ipipeif_write(val, ipipeif_base_addr, IPIPEIF_CFG2);	310	ipipeif_write(val, ipipeif_base_addr, IPIPEIF_CFG2);
311	break;	311	break;
312	}	312	}
		313	/* fall through */
313		314
314	case IPIPEIF_SDRAM_YUV:	315	case IPIPEIF_SDRAM_YUV:
315	/* Set clock divider */	316	/* Set clock divider */

drivers/staging/media/sunxi/cedrus/cedrus.c+1−1

@@ -253,7 +253,7 @@ static const struct v4l2_m2m_ops cedrus_m2m_ops = { · 252 unmodified lines
253		253
254	static const struct media_device_ops cedrus_m2m_media_ops = {	254	static const struct media_device_ops cedrus_m2m_media_ops = {
255	.req_validate = cedrus_request_validate,	255	.req_validate = cedrus_request_validate,
256	.req_queue = vb2_m2m_request_queue,	256	.req_queue = v4l2_m2m_request_queue,
257	};	257	};
258		258
259	static int cedrus_probe(struct platform_device *pdev)	259	static int cedrus_probe(struct platform_device *pdev)

drivers/uio/uio.c+5−2

 	if (ret)
 		goto err_uio_dev_add_attributes;
+	info->uio_dev = idev;
 	if (info->irq && (info->irq != UIO_IRQ_CUSTOM)) {
 		/*
 		 * Note that we deliberately don't use devm_request_irq
 		 */
 		ret = request_irq(info->irq, uio_interrupt,
 				  info->irq_flags, info->name, idev);
-		if (ret)
+		if (ret) {
+			info->uio_dev = NULL;
 			goto err_request_irq;
+		}
 	}
-	info->uio_dev = idev;
 	return 0;
 err_request_irq:

drivers/usb/class/cdc-acm.c+3−0

 	{ USB_DEVICE(0x0572, 0x1328), /* Shiro / Aztech USB MODEM UM-3100 */
 	.driver_info = NO_UNION_NORMAL, /* has no union descriptor */
 	},
+	{ USB_DEVICE(0x0572, 0x1349), /* Hiro (Conexant) USB MODEM H50228 */
+	.driver_info = NO_UNION_NORMAL, /* has no union descriptor */
+	},
 	{ USB_DEVICE(0x20df, 0x0001), /* Simtec Electronics Entropy Key */
 	.driver_info = QUIRK_CONTROL_LINE_STATE, },
 	{ USB_DEVICE(0x2184, 0x001c) },	/* GW Instek AFG-2225 */

drivers/usb/core/hub.c+14−4

@@ -2794,6 +2794,7 @@ static int hub_port_reset(struct usb_hub *hub, int port1, · 2793 unmodified lines
2794	int i, status;	2794	int i, status;
2795	u16 portchange, portstatus;	2795	u16 portchange, portstatus;
2796	struct usb_port *port_dev = hub->ports[port1 - 1];	2796	struct usb_port *port_dev = hub->ports[port1 - 1];
		2797	int reset_recovery_time;
2797		2798
2798	if (!hub_is_superspeed(hub->hdev)) {	2799	if (!hub_is_superspeed(hub->hdev)) {
2799	if (warm) {	2800	if (warm) {
@@ -2849,7 +2850,9 @@ static int hub_port_reset(struct usb_hub *hub, int port1, · 49 unmodified lines
2849	USB_PORT_FEAT_C_BH_PORT_RESET);	2850	USB_PORT_FEAT_C_BH_PORT_RESET);
2850	usb_clear_port_feature(hub->hdev, port1,	2851	usb_clear_port_feature(hub->hdev, port1,
2851	USB_PORT_FEAT_C_PORT_LINK_STATE);	2852	USB_PORT_FEAT_C_PORT_LINK_STATE);
2852	usb_clear_port_feature(hub->hdev, port1,	2853
		2854	if (udev)
		2855	usb_clear_port_feature(hub->hdev, port1,
2853	USB_PORT_FEAT_C_CONNECTION);	2856	USB_PORT_FEAT_C_CONNECTION);
2854		2857
2855	/*	2858	/*
@@ -2885,11 +2888,18 @@ static int hub_port_reset(struct usb_hub *hub, int port1, · 29 unmodified lines
2885		2888
2886	done:	2889	done:
2887	if (status == 0) {	2890	if (status == 0) {
2888	/* TRSTRCY = 10 ms; plus some extra */
2889	if (port_dev->quirks & USB_PORT_QUIRK_FAST_ENUM)	2891	if (port_dev->quirks & USB_PORT_QUIRK_FAST_ENUM)
2890	usleep_range(10000, 12000);	2892	usleep_range(10000, 12000);
2891	else	2893	else {
2892	msleep(10 + 40);	2894	/* TRSTRCY = 10 ms; plus some extra */
		2895	reset_recovery_time = 10 + 40;
		2896
		2897	/* Hub needs extra delay after resetting its port. */
		2898	if (hub->hdev->quirks & USB_QUIRK_HUB_SLOW_RESET)
		2899	reset_recovery_time += 100;
		2900
		2901	msleep(reset_recovery_time);
		2902	}
2893		2903
2894	if (udev) {	2904	if (udev) {
2895	struct usb_hcd *hcd = bus_to_hcd(udev->bus);	2905	struct usb_hcd *hcd = bus_to_hcd(udev->bus);

drivers/usb/core/quirks.c+14−0

 			case 'n':
 				flags |= USB_QUIRK_DELAY_CTRL_MSG;
 				break;
+			case 'o':
+				flags |= USB_QUIRK_HUB_SLOW_RESET;
+				break;
 			/* Ignore unrecognized flag characters */
 			}
 		}
 	{ USB_DEVICE(0x1a0a, 0x0200), .driver_info =
 			USB_QUIRK_LINEAR_UFRAME_INTR_BINTERVAL },
+	/* Terminus Technology Inc. Hub */
+	{ USB_DEVICE(0x1a40, 0x0101), .driver_info = USB_QUIRK_HUB_SLOW_RESET },
 	/* Corsair K70 RGB */
 	{ USB_DEVICE(0x1b1c, 0x1b13), .driver_info = USB_QUIRK_DELAY_INIT },
 	{ USB_DEVICE(0x1b1c, 0x1b20), .driver_info = USB_QUIRK_DELAY_INIT |
 	  USB_QUIRK_DELAY_CTRL_MSG },
+	/* Corsair K70 LUX RGB */
+	{ USB_DEVICE(0x1b1c, 0x1b33), .driver_info = USB_QUIRK_DELAY_INIT },
 	/* Corsair K70 LUX */
 	{ USB_DEVICE(0x1b1c, 0x1b36), .driver_info = USB_QUIRK_DELAY_INIT },
 	{ USB_DEVICE(0x2040, 0x7200), .driver_info =
 			USB_QUIRK_CONFIG_INTF_STRINGS },
+	/* Raydium Touchscreen */
+	{ USB_DEVICE(0x2386, 0x3114), .driver_info = USB_QUIRK_NO_LPM },
+	{ USB_DEVICE(0x2386, 0x3119), .driver_info = USB_QUIRK_NO_LPM },
 	/* DJI CineSSD */
 	{ USB_DEVICE(0x2ca3, 0x0031), .driver_info = USB_QUIRK_NO_LPM },

drivers/usb/dwc2/pci.c+1−0

@@ -120,6 +120,7 @@ static int dwc2_pci_probe(struct pci_dev *pci, · 119 unmodified lines
120	dwc2 = platform_device_alloc("dwc2", PLATFORM_DEVID_AUTO);	120	dwc2 = platform_device_alloc("dwc2", PLATFORM_DEVID_AUTO);
121	if (!dwc2) {	121	if (!dwc2) {
122	dev_err(dev, "couldn't allocate dwc2 device\n");	122	dev_err(dev, "couldn't allocate dwc2 device\n");
		123	ret = -ENOMEM;
123	goto err;	124	goto err;
124	}	125	}
125		126

drivers/usb/dwc3/core.c+1−0

@@ -1499,6 +1499,7 @@ static int dwc3_probe(struct platform_device *pdev) · 1498 unmodified lines
1499		1499
1500	err5:	1500	err5:
1501	dwc3_event_buffers_cleanup(dwc);	1501	dwc3_event_buffers_cleanup(dwc);
		1502	dwc3_ulpi_exit(dwc);
1502		1503
1503	err4:	1504	err4:
1504	dwc3_free_scratch_buffers(dwc);	1505	dwc3_free_scratch_buffers(dwc);

drivers/usb/dwc3/dwc3-pci.c+3−1

 static void dwc3_pci_remove(struct pci_dev *pci)
 {
 	struct dwc3_pci		*dwc = pci_get_drvdata(pci);
+	struct pci_dev		*pdev = dwc->pci;
-	gpiod_remove_lookup_table(&platform_bytcr_gpios);
+	if (pdev->device == PCI_DEVICE_ID_INTEL_BYT)
+		gpiod_remove_lookup_table(&platform_bytcr_gpios);
 #ifdef CONFIG_PM
 	cancel_work_sync(&dwc->wakeup_work);
 #endif

drivers/usb/dwc3/gadget.c+4−4

@@ -1081,7 +1081,7 @@ static void dwc3_prepare_one_trb_sg(struct dwc3_ep *dep, · 1080 unmodified lines
1081	/* Now prepare one extra TRB to align transfer size */	1081	/* Now prepare one extra TRB to align transfer size */
1082	trb = &dep->trb_pool[dep->trb_enqueue];	1082	trb = &dep->trb_pool[dep->trb_enqueue];
1083	__dwc3_prepare_one_trb(dep, trb, dwc->bounce_addr,	1083	__dwc3_prepare_one_trb(dep, trb, dwc->bounce_addr,
1084	maxp - rem, false, 0,	1084	maxp - rem, false, 1,
1085	req->request.stream_id,	1085	req->request.stream_id,
1086	req->request.short_not_ok,	1086	req->request.short_not_ok,
1087	req->request.no_interrupt);	1087	req->request.no_interrupt);
@@ -1125,7 +1125,7 @@ static void dwc3_prepare_one_trb_linear(struct dwc3_ep *dep, · 37 unmodified lines
1125	/* Now prepare one extra TRB to align transfer size */	1125	/* Now prepare one extra TRB to align transfer size */
1126	trb = &dep->trb_pool[dep->trb_enqueue];	1126	trb = &dep->trb_pool[dep->trb_enqueue];
1127	__dwc3_prepare_one_trb(dep, trb, dwc->bounce_addr, maxp - rem,	1127	__dwc3_prepare_one_trb(dep, trb, dwc->bounce_addr, maxp - rem,
1128	false, 0, req->request.stream_id,	1128	false, 1, req->request.stream_id,
1129	req->request.short_not_ok,	1129	req->request.short_not_ok,
1130	req->request.no_interrupt);	1130	req->request.no_interrupt);
1131	} else if (req->request.zero && req->request.length &&	1131	} else if (req->request.zero && req->request.length &&
@@ -1141,7 +1141,7 @@ static void dwc3_prepare_one_trb_linear(struct dwc3_ep *dep, · 9 unmodified lines
1141	/* Now prepare one extra TRB to handle ZLP */	1141	/* Now prepare one extra TRB to handle ZLP */
1142	trb = &dep->trb_pool[dep->trb_enqueue];	1142	trb = &dep->trb_pool[dep->trb_enqueue];
1143	__dwc3_prepare_one_trb(dep, trb, dwc->bounce_addr, 0,	1143	__dwc3_prepare_one_trb(dep, trb, dwc->bounce_addr, 0,
1144	false, 0, req->request.stream_id,	1144	false, 1, req->request.stream_id,
1145	req->request.short_not_ok,	1145	req->request.short_not_ok,
1146	req->request.no_interrupt);	1146	req->request.no_interrupt);
1147	} else {	1147	} else {
@@ -2259,7 +2259,7 @@ static int dwc3_gadget_ep_reclaim_completed_trb(struct dwc3_ep *dep, · 1111 unmodified lines
2259	* with one TRB pending in the ring. We need to manually clear HWO bit	2259	* with one TRB pending in the ring. We need to manually clear HWO bit
2260	* from that TRB.	2260	* from that TRB.
2261	*/	2261	*/
2262	if ((req->zero \|\| req->unaligned) && (trb->ctrl & DWC3_TRB_CTRL_HWO)) {	2262	if ((req->zero \|\| req->unaligned) && !(trb->ctrl & DWC3_TRB_CTRL_CHN)) {
2263	trb->ctrl &= ~DWC3_TRB_CTRL_HWO;	2263	trb->ctrl &= ~DWC3_TRB_CTRL_HWO;
2264	return 1;	2264	return 1;
2265	}	2265	}

drivers/usb/gadget/function/f_fs.c+8−18

@@ -215,7 +215,6 @@ struct ffs_io_data { · 214 unmodified lines
215		215
216	struct mm_struct *mm;	216	struct mm_struct *mm;
217	struct work_struct work;	217	struct work_struct work;
218	struct work_struct cancellation_work;
219		218
220	struct usb_ep *ep;	219	struct usb_ep *ep;
221	struct usb_request *req;	220	struct usb_request *req;
@@ -1073,31 +1072,22 @@ ffs_epfile_open(struct inode inode, struct file file) · 851 unmodified lines
1073	return 0;	1072	return 0;
1074	}	1073	}
1075		1074
1076	static void ffs_aio_cancel_worker(struct work_struct *work)
1077	{
1078	struct ffs_io_data *io_data = container_of(work, struct ffs_io_data,
1079	cancellation_work);
1080
1081	ENTER();
1082
1083	usb_ep_dequeue(io_data->ep, io_data->req);
1084	}
1085
1086	static int ffs_aio_cancel(struct kiocb *kiocb)	1075	static int ffs_aio_cancel(struct kiocb *kiocb)
1087	{	1076	{
1088	struct ffs_io_data *io_data = kiocb->private;	1077	struct ffs_io_data *io_data = kiocb->private;
1089	struct ffs_data *ffs = io_data->ffs;	1078	struct ffs_epfile *epfile = kiocb->ki_filp->private_data;
1090	int value;	1079	int value;
1091		1080
1092	ENTER();	1081	ENTER();
1093		1082
1094	if (likely(io_data && io_data->ep && io_data->req)) {	1083	spin_lock_irq(&epfile->ffs->eps_lock);
1095	INIT_WORK(&io_data->cancellation_work, ffs_aio_cancel_worker);	1084
1096	queue_work(ffs->io_completion_wq, &io_data->cancellation_work);	1085	if (likely(io_data && io_data->ep && io_data->req))
1097	value = -EINPROGRESS;	1086	value = usb_ep_dequeue(io_data->ep, io_data->req);
1098	} else {	1087	else
1099	value = -EINVAL;	1088	value = -EINVAL;
1100	}	1089
		1090	spin_unlock_irq(&epfile->ffs->eps_lock);
1101		1091
1102	return value;	1092	return value;
1103	}	1093	}

drivers/usb/host/xhci-histb.c+4−2

 	struct xhci_hcd_histb *histb = platform_get_drvdata(dev);
 	struct usb_hcd *hcd = histb->hcd;
 	struct xhci_hcd	*xhci = hcd_to_xhci(hcd);
+	struct usb_hcd *shared_hcd = xhci->shared_hcd;
 	xhci->xhc_state |= XHCI_STATE_REMOVING;
-	usb_remove_hcd(xhci->shared_hcd);
+	usb_remove_hcd(shared_hcd);
+	xhci->shared_hcd = NULL;
 	device_wakeup_disable(&dev->dev);
 	usb_remove_hcd(hcd);
-	usb_put_hcd(xhci->shared_hcd);
+	usb_put_hcd(shared_hcd);
 	xhci_histb_host_disable(histb);
 	usb_put_hcd(hcd);

drivers/usb/host/xhci-hub.c+49−17

@@ -876,7 +876,7 @@ static u32 xhci_get_port_status(struct usb_hcd *hcd, · 875 unmodified lines
876	status \|= USB_PORT_STAT_SUSPEND;	876	status \|= USB_PORT_STAT_SUSPEND;
877	}	877	}
878	if ((raw_port_status & PORT_PLS_MASK) == XDEV_RESUME &&	878	if ((raw_port_status & PORT_PLS_MASK) == XDEV_RESUME &&
879	!DEV_SUPERSPEED_ANY(raw_port_status)) {	879	!DEV_SUPERSPEED_ANY(raw_port_status) && hcd->speed < HCD_USB3) {
880	if ((raw_port_status & PORT_RESET) \|\|	880	if ((raw_port_status & PORT_RESET) \|\|
881	!(raw_port_status & PORT_PE))	881	!(raw_port_status & PORT_PE))
882	return 0xffffffff;	882	return 0xffffffff;
@@ -921,7 +921,7 @@ static u32 xhci_get_port_status(struct usb_hcd *hcd, · 38 unmodified lines
921	time_left = wait_for_completion_timeout(	921	time_left = wait_for_completion_timeout(
922	&bus_state->rexit_done[wIndex],	922	&bus_state->rexit_done[wIndex],
923	msecs_to_jiffies(	923	msecs_to_jiffies(
924	XHCI_MAX_REXIT_TIMEOUT));	924	XHCI_MAX_REXIT_TIMEOUT_MS));
925	spin_lock_irqsave(&xhci->lock, flags);	925	spin_lock_irqsave(&xhci->lock, flags);
926		926
927	if (time_left) {	927	if (time_left) {
@@ -935,7 +935,7 @@ static u32 xhci_get_port_status(struct usb_hcd *hcd, · 7 unmodified lines
935	} else {	935	} else {
936	int port_status = readl(port->addr);	936	int port_status = readl(port->addr);
937	xhci_warn(xhci, "Port resume took longer than %i msec, port status = 0x%x\n",	937	xhci_warn(xhci, "Port resume took longer than %i msec, port status = 0x%x\n",
938	XHCI_MAX_REXIT_TIMEOUT,	938	XHCI_MAX_REXIT_TIMEOUT_MS,
939	port_status);	939	port_status);
940	status \|= USB_PORT_STAT_SUSPEND;	940	status \|= USB_PORT_STAT_SUSPEND;
941	clear_bit(wIndex, &bus_state->rexit_ports);	941	clear_bit(wIndex, &bus_state->rexit_ports);
@@ -1474,15 +1474,18 @@ int xhci_bus_suspend(struct usb_hcd *hcd) · 532 unmodified lines
1474	unsigned long flags;	1474	unsigned long flags;
1475	struct xhci_hub *rhub;	1475	struct xhci_hub *rhub;
1476	struct xhci_port **ports;	1476	struct xhci_port **ports;
		1477	u32 portsc_buf[USB_MAXCHILDREN];
		1478	bool wake_enabled;
1477		1479
1478	rhub = xhci_get_rhub(hcd);	1480	rhub = xhci_get_rhub(hcd);
1479	ports = rhub->ports;	1481	ports = rhub->ports;
1480	max_ports = rhub->num_ports;	1482	max_ports = rhub->num_ports;
1481	bus_state = &xhci->bus_state[hcd_index(hcd)];	1483	bus_state = &xhci->bus_state[hcd_index(hcd)];
		1484	wake_enabled = hcd->self.root_hub->do_remote_wakeup;
1482		1485
1483	spin_lock_irqsave(&xhci->lock, flags);	1486	spin_lock_irqsave(&xhci->lock, flags);
1484		1487
1485	if (hcd->self.root_hub->do_remote_wakeup) {	1488	if (wake_enabled) {
1486	if (bus_state->resuming_ports \|\| /* USB2 */	1489	if (bus_state->resuming_ports \|\| /* USB2 */
1487	bus_state->port_remote_wakeup) { /* USB3 */	1490	bus_state->port_remote_wakeup) { /* USB3 */
1488	spin_unlock_irqrestore(&xhci->lock, flags);	1491	spin_unlock_irqrestore(&xhci->lock, flags);
@@ -1490,26 +1493,36 @@ int xhci_bus_suspend(struct usb_hcd *hcd) · 1 unmodified line
1490	return -EBUSY;	1493	return -EBUSY;
1491	}	1494	}
1492	}	1495	}
1493		1496	/*
1494	port_index = max_ports;	1497	* Prepare ports for suspend, but don't write anything before all ports
		1498	* are checked and we know bus suspend can proceed
		1499	*/
1495	bus_state->bus_suspended = 0;	1500	bus_state->bus_suspended = 0;
		1501	port_index = max_ports;
1496	while (port_index--) {	1502	while (port_index--) {
1497	/* suspend the port if the port is not suspended */
1498	u32 t1, t2;	1503	u32 t1, t2;
1499	int slot_id;
1500		1504
1501	t1 = readl(ports[port_index]->addr);	1505	t1 = readl(ports[port_index]->addr);
1502	t2 = xhci_port_state_to_neutral(t1);	1506	t2 = xhci_port_state_to_neutral(t1);
		1507	portsc_buf[port_index] = 0;
1503		1508
1504	if ((t1 & PORT_PE) && !(t1 & PORT_PLS_MASK)) {	1509	/* Bail out if a USB3 port has a new device in link training */
1505	xhci_dbg(xhci, "port %d not suspended\n", port_index);	1510	if ((t1 & PORT_PLS_MASK) == XDEV_POLLING) {
1506	slot_id = xhci_find_slot_id_by_port(hcd, xhci,	1511	bus_state->bus_suspended = 0;
1507	port_index + 1);	1512	spin_unlock_irqrestore(&xhci->lock, flags);
1508	if (slot_id) {	1513	xhci_dbg(xhci, "Bus suspend bailout, port in polling\n");
		1514	return -EBUSY;
		1515	}
		1516
		1517	/* suspend ports in U0, or bail out for new connect changes */
		1518	if ((t1 & PORT_PE) && (t1 & PORT_PLS_MASK) == XDEV_U0) {
		1519	if ((t1 & PORT_CSC) && wake_enabled) {
		1520	bus_state->bus_suspended = 0;
1509	spin_unlock_irqrestore(&xhci->lock, flags);	1521	spin_unlock_irqrestore(&xhci->lock, flags);
1510	xhci_stop_device(xhci, slot_id, 1);	1522	xhci_dbg(xhci, "Bus suspend bailout, port connect change\n");
1511	spin_lock_irqsave(&xhci->lock, flags);	1523	return -EBUSY;
1512	}	1524	}
		1525	xhci_dbg(xhci, "port %d not suspended\n", port_index);
1513	t2 &= ~PORT_PLS_MASK;	1526	t2 &= ~PORT_PLS_MASK;
1514	t2 \|= PORT_LINK_STROBE \| XDEV_U3;	1527	t2 \|= PORT_LINK_STROBE \| XDEV_U3;
1515	set_bit(port_index, &bus_state->bus_suspended);	1528	set_bit(port_index, &bus_state->bus_suspended);
@@ -1518,7 +1531,7 @@ int xhci_bus_suspend(struct usb_hcd *hcd) · 2 unmodified lines
1518	* including the USB 3.0 roothub, but only if CONFIG_PM	1531	* including the USB 3.0 roothub, but only if CONFIG_PM
1519	* is enabled, so also enable remote wake here.	1532	* is enabled, so also enable remote wake here.
1520	*/	1533	*/
1521	if (hcd->self.root_hub->do_remote_wakeup) {	1534	if (wake_enabled) {
1522	if (t1 & PORT_CONNECT) {	1535	if (t1 & PORT_CONNECT) {
1523	t2 \|= PORT_WKOC_E \| PORT_WKDISC_E;	1536	t2 \|= PORT_WKOC_E \| PORT_WKDISC_E;
1524	t2 &= ~PORT_WKCONN_E;	1537	t2 &= ~PORT_WKCONN_E;
@@ -1538,7 +1551,26 @@ int xhci_bus_suspend(struct usb_hcd *hcd) · 13 unmodified lines
1538		1551
1539	t1 = xhci_port_state_to_neutral(t1);	1552	t1 = xhci_port_state_to_neutral(t1);
1540	if (t1 != t2)	1553	if (t1 != t2)
1541	writel(t2, ports[port_index]->addr);	1554	portsc_buf[port_index] = t2;
		1555	}
		1556
		1557	/* write port settings, stopping and suspending ports if needed */
		1558	port_index = max_ports;
		1559	while (port_index--) {
		1560	if (!portsc_buf[port_index])
		1561	continue;
		1562	if (test_bit(port_index, &bus_state->bus_suspended)) {
		1563	int slot_id;
		1564
		1565	slot_id = xhci_find_slot_id_by_port(hcd, xhci,
		1566	port_index + 1);
		1567	if (slot_id) {
		1568	spin_unlock_irqrestore(&xhci->lock, flags);
		1569	xhci_stop_device(xhci, slot_id, 1);
		1570	spin_lock_irqsave(&xhci->lock, flags);
		1571	}
		1572	}
		1573	writel(portsc_buf[port_index], ports[port_index]->addr);
1542	}	1574	}
1543	hcd->state = HC_STATE_SUSPENDED;	1575	hcd->state = HC_STATE_SUSPENDED;
1544	bus_state->next_statechange = jiffies + msecs_to_jiffies(10);	1576	bus_state->next_statechange = jiffies + msecs_to_jiffies(10);

drivers/usb/host/xhci-mtk.c+4−2

 	struct xhci_hcd_mtk *mtk = platform_get_drvdata(dev);
 	struct usb_hcd	*hcd = mtk->hcd;
 	struct xhci_hcd	*xhci = hcd_to_xhci(hcd);
+	struct usb_hcd  *shared_hcd = xhci->shared_hcd;
-	usb_remove_hcd(xhci->shared_hcd);
+	usb_remove_hcd(shared_hcd);
+	xhci->shared_hcd = NULL;
 	device_init_wakeup(&dev->dev, false);
 	usb_remove_hcd(hcd);
-	usb_put_hcd(xhci->shared_hcd);
+	usb_put_hcd(shared_hcd);
 	usb_put_hcd(hcd);
 	xhci_mtk_sch_exit(mtk);
 	xhci_mtk_clks_disable(mtk);

drivers/usb/host/xhci-pci.c+6−0

 	if (pdev->vendor == PCI_VENDOR_ID_TI && pdev->device == 0x8241)
 		xhci->quirks |= XHCI_LIMIT_ENDPOINT_INTERVAL_7;
+	if ((pdev->vendor == PCI_VENDOR_ID_BROADCOM ||
+	     pdev->vendor == PCI_VENDOR_ID_CAVIUM) &&
+	     pdev->device == 0x9026)
+		xhci->quirks |= XHCI_RESET_PLL_ON_DISCONNECT;
 	if (xhci->quirks & XHCI_RESET_ON_RESUME)
 		xhci_dbg_trace(xhci, trace_xhci_dbg_quirks,
 				"QUIRK: Resetting on resume");
 	if (xhci->shared_hcd) {
 		usb_remove_hcd(xhci->shared_hcd);
 		usb_put_hcd(xhci->shared_hcd);
+		xhci->shared_hcd = NULL;
 	}
 	/* Workaround for spurious wakeups at shutdown with HSW */

drivers/usb/host/xhci-plat.c+4−2

 	struct xhci_hcd	*xhci = hcd_to_xhci(hcd);
 	struct clk *clk = xhci->clk;
 	struct clk *reg_clk = xhci->reg_clk;
+	struct usb_hcd *shared_hcd = xhci->shared_hcd;
 	xhci->xhc_state |= XHCI_STATE_REMOVING;
-	usb_remove_hcd(xhci->shared_hcd);
+	usb_remove_hcd(shared_hcd);
+	xhci->shared_hcd = NULL;
 	usb_phy_shutdown(hcd->usb_phy);
 	usb_remove_hcd(hcd);
-	usb_put_hcd(xhci->shared_hcd);
+	usb_put_hcd(shared_hcd);
 	clk_disable_unprepare(clk);
 	clk_disable_unprepare(reg_clk);

drivers/usb/host/xhci-ring.c+43−2

@@ -1521,6 +1521,35 @@ static void handle_device_notification(struct xhci_hcd *xhci, · 1520 unmodified lines
1521	usb_wakeup_notification(udev->parent, udev->portnum);	1521	usb_wakeup_notification(udev->parent, udev->portnum);
1522	}	1522	}
1523		1523
		1524	/*
		1525	* Quirk hanlder for errata seen on Cavium ThunderX2 processor XHCI
		1526	* Controller.
		1527	* As per ThunderX2errata-129 USB 2 device may come up as USB 1
		1528	* If a connection to a USB 1 device is followed by another connection
		1529	* to a USB 2 device.
		1530	*
		1531	* Reset the PHY after the USB device is disconnected if device speed
		1532	* is less than HCD_USB3.
		1533	* Retry the reset sequence max of 4 times checking the PLL lock status.
		1534	*
		1535	*/
		1536	static void xhci_cavium_reset_phy_quirk(struct xhci_hcd *xhci)
		1537	{
		1538	struct usb_hcd *hcd = xhci_to_hcd(xhci);
		1539	u32 pll_lock_check;
		1540	u32 retry_count = 4;
		1541
		1542	do {
		1543	/* Assert PHY reset */
		1544	writel(0x6F, hcd->regs + 0x1048);
		1545	udelay(10);
		1546	/* De-assert the PHY reset */
		1547	writel(0x7F, hcd->regs + 0x1048);
		1548	udelay(200);
		1549	pll_lock_check = readl(hcd->regs + 0x1070);
		1550	} while (!(pll_lock_check & 0x1) && --retry_count);
		1551	}
		1552
1524	static void handle_port_status(struct xhci_hcd *xhci,	1553	static void handle_port_status(struct xhci_hcd *xhci,
1525	union xhci_trb *event)	1554	union xhci_trb *event)
1526	{	1555	{
@@ -1556,6 +1585,13 @@ static void handle_port_status(struct xhci_hcd *xhci, · 29 unmodified lines
1556	goto cleanup;	1585	goto cleanup;
1557	}	1586	}
1558		1587
		1588	/* We might get interrupts after shared_hcd is removed */
		1589	if (port->rhub == &xhci->usb3_rhub && xhci->shared_hcd == NULL) {
		1590	xhci_dbg(xhci, "ignore port event for removed USB3 hcd\n");
		1591	bogus_port_status = true;
		1592	goto cleanup;
		1593	}
		1594
1559	hcd = port->rhub->hcd;	1595	hcd = port->rhub->hcd;
1560	bus_state = &xhci->bus_state[hcd_index(hcd)];	1596	bus_state = &xhci->bus_state[hcd_index(hcd)];
1561	hcd_portnum = port->hcd_portnum;	1597	hcd_portnum = port->hcd_portnum;
@@ -1639,7 +1675,7 @@ static void handle_port_status(struct xhci_hcd *xhci, · 77 unmodified lines
1639	* RExit to a disconnect state). If so, let the the driver know it's	1675	* RExit to a disconnect state). If so, let the the driver know it's
1640	* out of the RExit state.	1676	* out of the RExit state.
1641	*/	1677	*/
1642	if (!DEV_SUPERSPEED_ANY(portsc) &&	1678	if (!DEV_SUPERSPEED_ANY(portsc) && hcd->speed < HCD_USB3 &&
1643	test_and_clear_bit(hcd_portnum,	1679	test_and_clear_bit(hcd_portnum,
1644	&bus_state->rexit_ports)) {	1680	&bus_state->rexit_ports)) {
1645	complete(&bus_state->rexit_done[hcd_portnum]);	1681	complete(&bus_state->rexit_done[hcd_portnum]);
@@ -1647,8 +1683,12 @@ static void handle_port_status(struct xhci_hcd *xhci, · 1 unmodified line
1647	goto cleanup;	1683	goto cleanup;
1648	}	1684	}
1649		1685
1650	if (hcd->speed < HCD_USB3)	1686	if (hcd->speed < HCD_USB3) {
1651	xhci_test_and_clear_bit(xhci, port, PORT_PLC);	1687	xhci_test_and_clear_bit(xhci, port, PORT_PLC);
		1688	if ((xhci->quirks & XHCI_RESET_PLL_ON_DISCONNECT) &&
		1689	(portsc & PORT_CSC) && !(portsc & PORT_CONNECT))
		1690	xhci_cavium_reset_phy_quirk(xhci);
		1691	}
1652		1692
1653	cleanup:	1693	cleanup:
1654	/* Update event ring dequeue pointer before dropping the lock */	1694	/* Update event ring dequeue pointer before dropping the lock */
@@ -2266,6 +2306,7 @@ static int handle_tx_event(struct xhci_hcd *xhci, · 611 unmodified lines
2266	goto cleanup;	2306	goto cleanup;
2267	case COMP_RING_UNDERRUN:	2307	case COMP_RING_UNDERRUN:
2268	case COMP_RING_OVERRUN:	2308	case COMP_RING_OVERRUN:
		2309	case COMP_STOPPED_LENGTH_INVALID:
2269	goto cleanup;	2310	goto cleanup;
2270	default:	2311	default:
2271	xhci_err(xhci, "ERROR Transfer event for unknown stream ring slot %u ep %u\n",	2312	xhci_err(xhci, "ERROR Transfer event for unknown stream ring slot %u ep %u\n",

drivers/usb/host/xhci-tegra.c+1−0

@@ -1303,6 +1303,7 @@ static int tegra_xusb_remove(struct platform_device *pdev) · 1302 unmodified lines
1303		1303
1304	usb_remove_hcd(xhci->shared_hcd);	1304	usb_remove_hcd(xhci->shared_hcd);
1305	usb_put_hcd(xhci->shared_hcd);	1305	usb_put_hcd(xhci->shared_hcd);
		1306	xhci->shared_hcd = NULL;
1306	usb_remove_hcd(tegra->hcd);	1307	usb_remove_hcd(tegra->hcd);
1307	usb_put_hcd(tegra->hcd);	1308	usb_put_hcd(tegra->hcd);
1308		1309

drivers/usb/host/xhci.c+0−2

@@ -719,8 +719,6 @@ static void xhci_stop(struct usb_hcd *hcd) · 718 unmodified lines
719		719
720	/* Only halt host and free memory after both hcds are removed */	720	/* Only halt host and free memory after both hcds are removed */
721	if (!usb_hcd_is_primary_hcd(hcd)) {	721	if (!usb_hcd_is_primary_hcd(hcd)) {
722	/* usb core will free this hcd shortly, unset pointer */
723	xhci->shared_hcd = NULL;
724	mutex_unlock(&xhci->mutex);	722	mutex_unlock(&xhci->mutex);
725	return;	723	return;
726	}	724	}

drivers/usb/host/xhci.h+2−1

  * It can take up to 20 ms to transition from RExit to U0 on the
  * Intel Lynx Point LP xHCI host.
  */
-#define	XHCI_MAX_REXIT_TIMEOUT	(20 * 1000)
+#define	XHCI_MAX_REXIT_TIMEOUT_MS	20
 static inline unsigned int hcd_index(struct usb_hcd *hcd)
 {
 #define XHCI_INTEL_USB_ROLE_SW	BIT_ULL(31)
 #define XHCI_ZERO_64B_REGS	BIT_ULL(32)
 #define XHCI_DEFAULT_PM_RUNTIME_ALLOW	BIT_ULL(33)
+#define XHCI_RESET_PLL_ON_DISCONNECT	BIT_ULL(34)
 	unsigned int		num_active_eps;
 	unsigned int		limit_active_eps;

drivers/usb/misc/appledisplay.c+1−0

@@ -50,6 +50,7 @@ static const struct usb_device_id appledisplay_table[] = { · 49 unmodified lines
50	{ APPLEDISPLAY_DEVICE(0x9219) },	50	{ APPLEDISPLAY_DEVICE(0x9219) },
51	{ APPLEDISPLAY_DEVICE(0x921c) },	51	{ APPLEDISPLAY_DEVICE(0x921c) },
52	{ APPLEDISPLAY_DEVICE(0x921d) },	52	{ APPLEDISPLAY_DEVICE(0x921d) },
		53	{ APPLEDISPLAY_DEVICE(0x9222) },
53	{ APPLEDISPLAY_DEVICE(0x9236) },	54	{ APPLEDISPLAY_DEVICE(0x9236) },
54		55
55	/* Terminating entry */	56	/* Terminating entry */

fs/exec.c+3−2

 #include <linux/oom.h>
 #include <linux/compat.h>
 #include <linux/vmalloc.h>
+#include <linux/freezer.h>
 #include <linux/uaccess.h>
 #include <asm/mmu_context.h>
 	while (sig->notify_count) {
 		__set_current_state(TASK_KILLABLE);
 		spin_unlock_irq(lock);
-		schedule();
+		freezable_schedule();
 		if (unlikely(__fatal_signal_pending(tsk)))
 			goto killed;
 		spin_lock_irq(lock);
 			__set_current_state(TASK_KILLABLE);
 			write_unlock_irq(&tasklist_lock);
 			cgroup_threadgroup_change_end(tsk);
-			schedule();
+			freezable_schedule();
 			if (unlikely(__fatal_signal_pending(tsk)))
 				goto killed;
 		}

fs/iomap.c+41−12

 iomap_adjust_read_range(struct inode *inode, struct iomap_page *iop,
 		loff_t *pos, loff_t length, unsigned *offp, unsigned *lenp)
 {
+	loff_t orig_pos = *pos;
+	loff_t isize = i_size_read(inode);
 	unsigned block_bits = inode->i_blkbits;
 	unsigned block_size = (1 << block_bits);
 	unsigned poff = offset_in_page(*pos);
 	unsigned plen = min_t(loff_t, PAGE_SIZE - poff, length);
 	unsigned first = poff >> block_bits;
 	unsigned last = (poff + plen - 1) >> block_bits;
-	unsigned end = offset_in_page(i_size_read(inode)) >> block_bits;
 	/*
 	 * If the block size is smaller than the page size we need to check the
 	 * handle both halves separately so that we properly zero data in the
 	 * page cache for blocks that are entirely outside of i_size.
 	 */
-	if (first <= end && last > end)
+	if (orig_pos <= isize && orig_pos + length > isize) {
-		plen -= (last - end) * block_size;
+		unsigned end = offset_in_page(isize - 1) >> block_bits;
+		if (first <= end && last > end)
+			plen -= (last - end) * block_size;
+	}
 	*offp = poff;
 	*lenp = plen;
 	struct bio *bio;
 	bool need_zeroout = false;
 	bool use_fua = false;
-	int nr_pages, ret;
+	int nr_pages, ret = 0;
 	size_t copied = 0;
 	if ((pos | length | align) & ((1 << blkbits) - 1))
 	if (iomap->flags & IOMAP_F_NEW) {
 		need_zeroout = true;
-	} else {
+	} else if (iomap->type == IOMAP_MAPPED) {
 		/*
-		 * Use a FUA write if we need datasync semantics, this
+		 * Use a FUA write if we need datasync semantics, this is a pure
-		 * is a pure data IO that doesn't require any metadata
+		 * data IO that doesn't require any metadata updates (including
-		 * updates and the underlying device supports FUA. This
+		 * after IO completion such as unwritten extent conversion) and
-		 * allows us to avoid cache flushes on IO completion.
+		 * the underlying device supports FUA. This allows us to avoid
+		 * cache flushes on IO completion.
 		 */
 		if (!(iomap->flags & (IOMAP_F_SHARED|IOMAP_F_DIRTY)) &&
 		    (dio->flags & IOMAP_DIO_WRITE_FUA) &&
 		ret = bio_iov_iter_get_pages(bio, &iter);
 		if (unlikely(ret)) {
+			/*
+			 * We have to stop part way through an IO. We must fall
+			 * through to the sub-block tail zeroing here, otherwise
+			 * this short IO may expose stale data in the tail of
+			 * the block we haven't written data to.
+			 */
 			bio_put(bio);
-			return copied ? copied : ret;
+			goto zero_tail;
 		}
 		n = bio->bi_iter.bi_size;
 		dio->submit.cookie = submit_bio(bio);
 	} while (nr_pages);
-	if (need_zeroout) {
+	/*
+	 * We need to zeroout the tail of a sub-block write if the extent type
+	 * requires zeroing or the write extends beyond EOF. If we don't zero
+	 * the block tail in the latter case, we can expose stale data via mmap
+	 * reads of the EOF block.
+	 */
+zero_tail:
+	if (need_zeroout ||
+	    ((dio->flags & IOMAP_DIO_WRITE) && pos >= i_size_read(inode))) {
 		/* zero out from the end of the write to the end of the block */
 		pad = pos & (fs_block_size - 1);
 		if (pad)
 			iomap_dio_zero(dio, iomap, pos, fs_block_size - pad);
 	}
-	return copied;
+	return copied ? copied : ret;
 }
 static loff_t
 				dio->wait_for_completion = true;
 				ret = 0;
 			}
+			/*
+			 * Splicing to pipes can fail on a full pipe. We have to
+			 * swallow this to make it look like a short IO
+			 * otherwise the higher splice layers will completely
+			 * mishandle the error and stop moving data.
+			 */
+			if (ret == -EFAULT)
+				ret = 0;
 			break;
 		}
 		pos += ret;

fs/read_write.c+7−8

 	off = same->src_offset;
 	len = same->src_length;
-	ret = -EISDIR;
 	if (S_ISDIR(src->i_mode))
-		goto out;
+		return -EISDIR;
-	ret = -EINVAL;
 	if (!S_ISREG(src->i_mode))
-		goto out;
+		return -EINVAL;
+	if (!file->f_op->remap_file_range)
+		return -EOPNOTSUPP;
 	ret = remap_verify_area(file, off, len, false);
 	if (ret < 0)
-		goto out;
+		return ret;
 	ret = 0;
 	if (off + len > i_size_read(src))
 		fdput(dst_fd);
 next_loop:
 		if (fatal_signal_pending(current))
-			goto out;
+			break;
 	}
-out:
 	return ret;
 }
 EXPORT_SYMBOL(vfs_dedupe_file_range);

fs/xfs/libxfs/xfs_bmap.c+4−1

 	case BMAP_LEFT_FILLING | BMAP_RIGHT_FILLING | BMAP_RIGHT_CONTIG:
 		/*
 		 * Filling in all of a previously delayed allocation extent.
-		 * The right neighbor is contiguous, the left is not.
+		 * The right neighbor is contiguous, the left is not. Take care
+		 * with delay -> unwritten extent allocation here because the
+		 * delalloc record we are overwriting is always written.
 		 */
 		PREV.br_startblock = new->br_startblock;
 		PREV.br_blockcount += RIGHT.br_blockcount;
+		PREV.br_state = new->br_state;
 		xfs_iext_next(ifp, &bma->icur);
 		xfs_iext_remove(bma->ip, &bma->icur, state);

fs/xfs/libxfs/xfs_ialloc_btree.c+7−4

 static xfs_extlen_t
 xfs_inobt_max_size(
-	struct xfs_mount	*mp)
+	struct xfs_mount	*mp,
+	xfs_agnumber_t		agno)
 {
+	xfs_agblock_t		agblocks = xfs_ag_block_count(mp, agno);
 	/* Bail out if we're uninitialized, which can happen in mkfs. */
 	if (mp->m_inobt_mxr[0] == 0)
 		return 0;
 	return xfs_btree_calc_size(mp->m_inobt_mnr,
-		(uint64_t)mp->m_sb.sb_agblocks * mp->m_sb.sb_inopblock /
+				(uint64_t)agblocks * mp->m_sb.sb_inopblock /
-				XFS_INODES_PER_CHUNK);
+					XFS_INODES_PER_CHUNK);
 }
 static int
 	if (error)
 		return error;
-	*ask += xfs_inobt_max_size(mp);
+	*ask += xfs_inobt_max_size(mp, agno);
 	*used += tree_len;
 	return 0;
 }

fs/xfs/xfs_bmap_util.c+2−8

 	goto out_unlock;
 }
-static int
+int
 xfs_flush_unmap_range(
 	struct xfs_inode	*ip,
 	xfs_off_t		offset,
 	 * Writeback and invalidate cache for the remainder of the file as we're
 	 * about to shift down every extent from offset to EOF.
 	 */
-	error = filemap_write_and_wait_range(VFS_I(ip)->i_mapping, offset, -1);
+	error = xfs_flush_unmap_range(ip, offset, XFS_ISIZE(ip));
-	if (error)
-		return error;
-	error = invalidate_inode_pages2_range(VFS_I(ip)->i_mapping,
-					offset >> PAGE_SHIFT, -1);
-	if (error)
-		return error;
 	/*
 	 * Clean out anything hanging around in the cow fork now that

fs/xfs/xfs_bmap_util.h+3−0

@@ -80,4 +80,7 @@ int xfs_bmap_count_blocks(struct xfs_trans tp, struct xfs_inode ip, · 79 unmodified lines
80	int whichfork, xfs_extnum_t *nextents,	80	int whichfork, xfs_extnum_t *nextents,
81	xfs_filblks_t *count);	81	xfs_filblks_t *count);
82		82
		83	int xfs_flush_unmap_range(struct xfs_inode *ip, xfs_off_t offset,
		84	xfs_off_t len);
		85
83	#endif /* __XFS_BMAP_UTIL_H__ */	86	#endif /* __XFS_BMAP_UTIL_H__ */

fs/xfs/xfs_buf_item.c+21−7

 }
 /*
- * Requeue a failed buffer for writeback
+ * Requeue a failed buffer for writeback.
  *
- * Return true if the buffer has been re-queued properly, false otherwise
+ * We clear the log item failed state here as well, but we have to be careful
+ * about reference counts because the only active reference counts on the buffer
+ * may be the failed log items. Hence if we clear the log item failed state
+ * before queuing the buffer for IO we can release all active references to
+ * the buffer and free it, leading to use after free problems in
+ * xfs_buf_delwri_queue. It makes no difference to the buffer or log items which
+ * order we process them in - the buffer is locked, and we own the buffer list
+ * so nothing on them is going to change while we are performing this action.
+ *
+ * Hence we can safely queue the buffer for IO before we clear the failed log
+ * item state, therefore  always having an active reference to the buffer and
+ * avoiding the transient zero-reference state that leads to use-after-free.
+ *
+ * Return true if the buffer was added to the buffer list, false if it was
+ * already on the buffer list.
  */
 bool
 xfs_buf_resubmit_failed_buffers(
 	struct list_head	*buffer_list)
 {
 	struct xfs_log_item	*lip;
+	bool			ret;
+	ret = xfs_buf_delwri_queue(bp, buffer_list);
 	/*
-	 * Clear XFS_LI_FAILED flag from all items before resubmit
+	 * XFS_LI_FAILED set/clear is protected by ail_lock, caller of this
-	 *
-	 * XFS_LI_FAILED set/clear is protected by ail_lock, caller  this
 	 * function already have it acquired
 	 */
 	list_for_each_entry(lip, &bp->b_li_list, li_bio_list)
 		xfs_clear_li_failed(lip);
-	/* Add this buffer back to the delayed write list */
+	return ret;
-	return xfs_buf_delwri_queue(bp, buffer_list);
 }

fs/xfs/xfs_file.c+1−1

@@ -920,7 +920,7 @@ out_unlock: · 919 unmodified lines
920	}	920	}
921		921
922		922
923	loff_t	923	STATIC loff_t
924	xfs_file_remap_range(	924	xfs_file_remap_range(
925	struct file *file_in,	925	struct file *file_in,
926	loff_t pos_in,	926	loff_t pos_in,

fs/xfs/xfs_reflink.c+14−4

 	if (error)
 		return error;
+	xfs_trim_extent(imap, got.br_startoff, got.br_blockcount);
 	trace_xfs_reflink_cow_alloc(ip, &got);
 	return 0;
 }
 	if (ret)
 		goto out_unlock;
-	/* Zap any page cache for the destination file's range. */
+	/*
-	truncate_inode_pages_range(&inode_out->i_data,
+	 * If pos_out > EOF, we may have dirtied blocks between EOF and
-			round_down(pos_out, PAGE_SIZE),
+	 * pos_out. In that case, we need to extend the flush and unmap to cover
-			round_up(pos_out + *len, PAGE_SIZE) - 1);
+	 * from EOF to the end of the copy length.
+	 */
+	if (pos_out > XFS_ISIZE(dest)) {
+		loff_t	flen = *len + (pos_out - XFS_ISIZE(dest));
+		ret = xfs_flush_unmap_range(dest, XFS_ISIZE(dest), flen);
+	} else {
+		ret = xfs_flush_unmap_range(dest, pos_out, *len);
+	}
+	if (ret)
+		goto out_unlock;
 	return 1;
 out_unlock:

fs/xfs/xfs_trace.h+4−1

 	),
 	TP_fast_assign(
 		__entry->dev = bp->b_target->bt_dev;
-		__entry->bno = bp->b_bn;
+		if (bp->b_bn == XFS_BUF_DADDR_NULL)
+			__entry->bno = bp->b_maps[0].bm_bn;
+		else
+			__entry->bno = bp->b_bn;
 		__entry->nblks = bp->b_length;
 		__entry->hold = atomic_read(&bp->b_hold);
 		__entry->pincount = atomic_read(&bp->b_pin_count);

include/linux/net_dim.h+2−0

 		}
 		/* fall through */
 	case NET_DIM_START_MEASURE:
+		net_dim_sample(end_sample.event_ctr, end_sample.pkt_ctr, end_sample.byte_ctr,
+			       &dim->start_sample);
 		dim->state = NET_DIM_MEASURE_IN_PROGRESS;
 		break;
 	case NET_DIM_APPLY_NEW_PROFILE:

include/linux/skbuff.h+17−1

@@ -1334,6 +1334,22 @@ static inline void skb_zcopy_set(struct sk_buff skb, struct ubuf_info uarg) · 1333 unmodified lines
1334	}	1334	}
1335	}	1335	}
1336		1336
		1337	static inline void skb_zcopy_set_nouarg(struct sk_buff skb, void val)
		1338	{
		1339	skb_shinfo(skb)->destructor_arg = (void *)((uintptr_t) val \| 0x1UL);
		1340	skb_shinfo(skb)->tx_flags \|= SKBTX_ZEROCOPY_FRAG;
		1341	}
		1342
		1343	static inline bool skb_zcopy_is_nouarg(struct sk_buff *skb)
		1344	{
		1345	return (uintptr_t) skb_shinfo(skb)->destructor_arg & 0x1UL;
		1346	}
		1347
		1348	static inline void skb_zcopy_get_nouarg(struct sk_buff skb)
		1349	{
		1350	return (void *)((uintptr_t) skb_shinfo(skb)->destructor_arg & ~0x1UL);
		1351	}
		1352
1337	/* Release a reference on a zerocopy structure */	1353	/* Release a reference on a zerocopy structure */
1338	static inline void skb_zcopy_clear(struct sk_buff *skb, bool zerocopy)	1354	static inline void skb_zcopy_clear(struct sk_buff *skb, bool zerocopy)
1339	{	1355	{
@@ -1343,7 +1359,7 @@ static inline void skb_zcopy_clear(struct sk_buff *skb, bool zerocopy) · 3 unmodified lines
1343	if (uarg->callback == sock_zerocopy_callback) {	1359	if (uarg->callback == sock_zerocopy_callback) {
1344	uarg->zerocopy = uarg->zerocopy && zerocopy;	1360	uarg->zerocopy = uarg->zerocopy && zerocopy;
1345	sock_zerocopy_put(uarg);	1361	sock_zerocopy_put(uarg);
1346	} else {	1362	} else if (!skb_zcopy_is_nouarg(skb)) {
1347	uarg->callback(uarg, zerocopy);	1363	uarg->callback(uarg, zerocopy);
1348	}	1364	}
1349		1365

include/linux/tcp.h+1−0

@@ -196,6 +196,7 @@ struct tcp_sock { · 195 unmodified lines
196	u32 rcv_tstamp; /* timestamp of last received ACK (for keepalives) */	196	u32 rcv_tstamp; /* timestamp of last received ACK (for keepalives) */
197	u32 lsndtime; /* timestamp of last sent data packet (for restart window) */	197	u32 lsndtime; /* timestamp of last sent data packet (for restart window) */
198	u32 last_oow_ack_time; /* timestamp of last out-of-window ACK */	198	u32 last_oow_ack_time; /* timestamp of last out-of-window ACK */
		199	u32 compressed_ack_rcv_nxt;
199		200
200	u32 tsoffset; /* timestamp offset */	201	u32 tsoffset; /* timestamp offset */
201		202

include/linux/usb/quirks.h+3−0

@@ -66,4 +66,7 @@ · 65 unmodified lines
66	/* Device needs a pause after every control message. */	66	/* Device needs a pause after every control message. */
67	#define USB_QUIRK_DELAY_CTRL_MSG BIT(13)	67	#define USB_QUIRK_DELAY_CTRL_MSG BIT(13)
68		68
		69	/* Hub needs extra delay after resetting its port. */
		70	#define USB_QUIRK_HUB_SLOW_RESET BIT(14)
		71
69	#endif /* __LINUX_USB_QUIRKS_H */	72	#endif /* __LINUX_USB_QUIRKS_H */

include/media/v4l2-mem2mem.h+1−1

@@ -624,7 +624,7 @@ v4l2_m2m_dst_buf_remove_by_idx(struct v4l2_m2m_ctx *m2m_ctx, unsigned int idx) · 623 unmodified lines
624		624
625	/* v4l2 request helper */	625	/* v4l2 request helper */
626		626
627	void vb2_m2m_request_queue(struct media_request *req);	627	void v4l2_m2m_request_queue(struct media_request *req);
628		628
629	/* v4l2 ioctl helpers */	629	/* v4l2 ioctl helpers */
630		630

include/net/sctp/sctp.h+12−0

@@ -608,4 +608,16 @@ static inline __u32 sctp_dst_mtu(const struct dst_entry *dst) · 607 unmodified lines
608	SCTP_DEFAULT_MINSEGMENT));	608	SCTP_DEFAULT_MINSEGMENT));
609	}	609	}
610		610
		611	static inline bool sctp_transport_pmtu_check(struct sctp_transport *t)
		612	{
		613	__u32 pmtu = sctp_dst_mtu(t->dst);
		614
		615	if (t->pathmtu == pmtu)
		616	return true;
		617
		618	t->pathmtu = pmtu;
		619
		620	return false;
		621	}
		622
611	#endif /* __net_sctp_h__ */	623	#endif /* __net_sctp_h__ */

include/uapi/linux/v4l2-controls.h+5−0

 #ifndef __LINUX_V4L2_CONTROLS_H
 #define __LINUX_V4L2_CONTROLS_H
+#include <linux/types.h>
 /* Control classes */
 #define V4L2_CTRL_CLASS_USER		0x00980000	/* Old-style 'user' controls */
 #define V4L2_CTRL_CLASS_MPEG		0x00990000	/* MPEG-compression controls */
 	__u8	profile_and_level_indication;
 	__u8	progressive_sequence;
 	__u8	chroma_format;
+	__u8	pad;
 };
 struct v4l2_mpeg2_picture {
 	__u8	alternate_scan;
 	__u8	repeat_first_field;
 	__u8	progressive_frame;
+	__u8	pad;
 };
 struct v4l2_ctrl_mpeg2_slice_params {
 	__u8	backward_ref_index;
 	__u8	forward_ref_index;
+	__u8	pad;
 };
 struct v4l2_ctrl_mpeg2_quantization {

lib/test_firmware.c+1−0

@@ -837,6 +837,7 @@ static ssize_t read_firmware_show(struct device *dev, · 836 unmodified lines
837	if (req->fw->size > PAGE_SIZE) {	837	if (req->fw->size > PAGE_SIZE) {
838	pr_err("Testing interface must use PAGE_SIZE firmware for now\n");	838	pr_err("Testing interface must use PAGE_SIZE firmware for now\n");
839	rc = -EINVAL;	839	rc = -EINVAL;
		840	goto out;
840	}	841	}
841	memcpy(buf, req->fw->data, req->fw->size);	842	memcpy(buf, req->fw->data, req->fw->size);
842		843

net/ceph/messenger.c+9−3

 	struct bio_vec bvec;
 	int ret;
-	/* sendpage cannot properly handle pages with page_count == 0,
+	/*
-	 * we need to fallback to sendmsg if that's the case */
+	 * sendpage cannot properly handle pages with page_count == 0,
-	if (page_count(page) >= 1)
+	 * we need to fall back to sendmsg if that's the case.
+	 *
+	 * Same goes for slab pages: skb_can_coalesce() allows
+	 * coalescing neighboring slab objects into a single frag which
+	 * triggers one of hardened usercopy checks.
+	 */
+	if (page_count(page) >= 1 && !PageSlab(page))
 		return __ceph_tcp_sendpage(sock, page, offset, size, more);
 	bvec.bv_page = page;

net/core/dev.c+5−2

 		if (work_done)
 			timeout = n->dev->gro_flush_timeout;
+		/* When the NAPI instance uses a timeout and keeps postponing
+		 * it, we need to bound somehow the time packets are kept in
+		 * the GRO layer
+		 */
+		napi_gro_flush(n, !!timeout);
 		if (timeout)
 			hrtimer_start(&n->timer, ns_to_ktime(timeout),
 				      HRTIMER_MODE_REL_PINNED);
-		else
-			napi_gro_flush(n, false);
 	}
 	if (unlikely(!list_empty(&n->poll_list))) {
 		/* If n->poll_list is not empty, we need to mask irqs */

net/ipv4/tcp_input.c+13−2

@@ -4269,7 +4269,7 @@ static void tcp_sack_new_ofo_skb(struct sock *sk, u32 seq, u32 end_seq) · 4268 unmodified lines
4269	* If the sack array is full, forget about the last one.	4269	* If the sack array is full, forget about the last one.
4270	*/	4270	*/
4271	if (this_sack >= TCP_NUM_SACKS) {	4271	if (this_sack >= TCP_NUM_SACKS) {
4272	if (tp->compressed_ack)	4272	if (tp->compressed_ack > TCP_FASTRETRANS_THRESH)
4273	tcp_send_ack(sk);	4273	tcp_send_ack(sk);
4274	this_sack--;	4274	this_sack--;
4275	tp->rx_opt.num_sacks--;	4275	tp->rx_opt.num_sacks--;
@@ -4364,6 +4364,7 @@ static bool tcp_try_coalesce(struct sock *sk, · 88 unmodified lines
4364	if (TCP_SKB_CB(from)->has_rxtstamp) {	4364	if (TCP_SKB_CB(from)->has_rxtstamp) {
4365	TCP_SKB_CB(to)->has_rxtstamp = true;	4365	TCP_SKB_CB(to)->has_rxtstamp = true;
4366	to->tstamp = from->tstamp;	4366	to->tstamp = from->tstamp;
		4367	skb_hwtstamps(to)->hwtstamp = skb_hwtstamps(from)->hwtstamp;
4367	}	4368	}
4368		4369
4369	return true;	4370	return true;
@@ -5189,7 +5190,17 @@ send_now: · 819 unmodified lines
5189	if (!tcp_is_sack(tp) \|\|	5190	if (!tcp_is_sack(tp) \|\|
5190	tp->compressed_ack >= sock_net(sk)->ipv4.sysctl_tcp_comp_sack_nr)	5191	tp->compressed_ack >= sock_net(sk)->ipv4.sysctl_tcp_comp_sack_nr)
5191	goto send_now;	5192	goto send_now;
5192	tp->compressed_ack++;	5193
		5194	if (tp->compressed_ack_rcv_nxt != tp->rcv_nxt) {
		5195	tp->compressed_ack_rcv_nxt = tp->rcv_nxt;
		5196	if (tp->compressed_ack > TCP_FASTRETRANS_THRESH)
		5197	NET_ADD_STATS(sock_net(sk), LINUX_MIB_TCPACKCOMPRESSED,
		5198	tp->compressed_ack - TCP_FASTRETRANS_THRESH);
		5199	tp->compressed_ack = 0;
		5200	}
		5201
		5202	if (++tp->compressed_ack <= TCP_FASTRETRANS_THRESH)
		5203	goto send_now;
5193		5204
5194	if (hrtimer_is_queued(&tp->compressed_ack_timer))	5205	if (hrtimer_is_queued(&tp->compressed_ack_timer))
5195	return;	5206	return;

net/ipv4/tcp_output.c+3−3

@@ -180,10 +180,10 @@ static inline void tcp_event_ack_sent(struct sock *sk, unsigned int pkts, · 179 unmodified lines
180	{	180	{
181	struct tcp_sock *tp = tcp_sk(sk);	181	struct tcp_sock *tp = tcp_sk(sk);
182		182
183	if (unlikely(tp->compressed_ack)) {	183	if (unlikely(tp->compressed_ack > TCP_FASTRETRANS_THRESH)) {
184	NET_ADD_STATS(sock_net(sk), LINUX_MIB_TCPACKCOMPRESSED,	184	NET_ADD_STATS(sock_net(sk), LINUX_MIB_TCPACKCOMPRESSED,
185	tp->compressed_ack);	185	tp->compressed_ack - TCP_FASTRETRANS_THRESH);
186	tp->compressed_ack = 0;	186	tp->compressed_ack = TCP_FASTRETRANS_THRESH;
187	if (hrtimer_try_to_cancel(&tp->compressed_ack_timer) == 1)	187	if (hrtimer_try_to_cancel(&tp->compressed_ack_timer) == 1)
188	__sock_put(sk);	188	__sock_put(sk);
189	}	189	}

net/ipv4/tcp_timer.c+1−1

@@ -740,7 +740,7 @@ static enum hrtimer_restart tcp_compressed_ack_kick(struct hrtimer *timer) · 739 unmodified lines
740		740
741	bh_lock_sock(sk);	741	bh_lock_sock(sk);
742	if (!sock_owned_by_user(sk)) {	742	if (!sock_owned_by_user(sk)) {
743	if (tp->compressed_ack)	743	if (tp->compressed_ack > TCP_FASTRETRANS_THRESH)
744	tcp_send_ack(sk);	744	tcp_send_ack(sk);
745	} else {	745	} else {
746	if (!test_and_set_bit(TCP_DELACK_TIMER_DEFERRED,	746	if (!test_and_set_bit(TCP_DELACK_TIMER_DEFERRED,

net/ipv6/addrconf.c+13−6

 static void addrconf_dad_work(struct work_struct *w);
 static void addrconf_dad_completed(struct inet6_ifaddr *ifp, bool bump_id,
 				   bool send_na);
-static void addrconf_dad_run(struct inet6_dev *idev);
+static void addrconf_dad_run(struct inet6_dev *idev, bool restart);
 static void addrconf_rs_timer(struct timer_list *t);
 static void __ipv6_ifa_notify(int event, struct inet6_ifaddr *ifa);
 static void ipv6_ifa_notify(int event, struct inet6_ifaddr *ifa);
 			   void *ptr)
 {
 	struct net_device *dev = netdev_notifier_info_to_dev(ptr);
+	struct netdev_notifier_change_info *change_info;
 	struct netdev_notifier_changeupper_info *info;
 	struct inet6_dev *idev = __in6_dev_get(dev);
 	struct net *net = dev_net(dev);
 				break;
 			}
-			if (idev) {
+			if (!IS_ERR_OR_NULL(idev)) {
 				if (idev->if_flags & IF_READY) {
 					/* device is already configured -
 					 * but resend MLD reports, we might
 					 * multicast snooping switches
 					 */
 					ipv6_mc_up(idev);
+					change_info = ptr;
+					if (change_info->flags_changed & IFF_NOARP)
+						addrconf_dad_run(idev, true);
 					rt6_sync_up(dev, RTNH_F_LINKDOWN);
 					break;
 				}
 		if (!IS_ERR_OR_NULL(idev)) {
 			if (run_pending)
-				addrconf_dad_run(idev);
+				addrconf_dad_run(idev, false);
 			/* Device has an address by now */
 			rt6_sync_up(dev, RTNH_F_DEAD);
 		addrconf_verify_rtnl();
 }
-static void addrconf_dad_run(struct inet6_dev *idev)
+static void addrconf_dad_run(struct inet6_dev *idev, bool restart)
 {
 	struct inet6_ifaddr *ifp;
 	read_lock_bh(&idev->lock);
 	list_for_each_entry(ifp, &idev->addr_list, if_list) {
 		spin_lock(&ifp->lock);
-		if (ifp->flags & IFA_F_TENTATIVE &&
+		if ((ifp->flags & IFA_F_TENTATIVE &&
-		    ifp->state == INET6_IFADDR_STATE_DAD)
+		     ifp->state == INET6_IFADDR_STATE_DAD) || restart) {
+			if (restart)
+				ifp->state = INET6_IFADDR_STATE_PREDAD;
 			addrconf_dad_kick(ifp);
+		}
 		spin_unlock(&ifp->lock);
 	}
 	read_unlock_bh(&idev->lock);

net/packet/af_packet.c+2−2

@@ -2394,7 +2394,7 @@ static void tpacket_destruct_skb(struct sk_buff *skb) · 2393 unmodified lines
2394	void *ph;	2394	void *ph;
2395	__u32 ts;	2395	__u32 ts;
2396		2396
2397	ph = skb_shinfo(skb)->destructor_arg;	2397	ph = skb_zcopy_get_nouarg(skb);
2398	packet_dec_pending(&po->tx_ring);	2398	packet_dec_pending(&po->tx_ring);
2399		2399
2400	ts = __packet_set_timestamp(po, ph, skb);	2400	ts = __packet_set_timestamp(po, ph, skb);
@@ -2461,7 +2461,7 @@ static int tpacket_fill_skb(struct packet_sock po, struct sk_buff skb, · 60 unmodified lines
2461	skb->mark = po->sk.sk_mark;	2461	skb->mark = po->sk.sk_mark;
2462	skb->tstamp = sockc->transmit_time;	2462	skb->tstamp = sockc->transmit_time;
2463	sock_tx_timestamp(&po->sk, sockc->tsflags, &skb_shinfo(skb)->tx_flags);	2463	sock_tx_timestamp(&po->sk, sockc->tsflags, &skb_shinfo(skb)->tx_flags);
2464	skb_shinfo(skb)->destructor_arg = ph.raw;	2464	skb_zcopy_set_nouarg(skb, ph.raw);
2465		2465
2466	skb_reserve(skb, hlen);	2466	skb_reserve(skb, hlen);
2467	skb_reset_network_header(skb);	2467	skb_reset_network_header(skb);

net/sched/act_police.c+22−14

 	u32			tcfp_ewma_rate;
 	s64			tcfp_burst;
 	u32			tcfp_mtu;
-	s64			tcfp_toks;
-	s64			tcfp_ptoks;
 	s64			tcfp_mtu_ptoks;
-	s64			tcfp_t_c;
 	struct psched_ratecfg	rate;
 	bool			rate_present;
 	struct psched_ratecfg	peak;
 struct tcf_police {
 	struct tc_action	common;
 	struct tcf_police_params __rcu *params;
+	spinlock_t		tcfp_lock ____cacheline_aligned_in_smp;
+	s64			tcfp_toks;
+	s64			tcfp_ptoks;
+	s64			tcfp_t_c;
 };
 #define to_police(pc) ((struct tcf_police *)pc)
 			return ret;
 		}
 		ret = ACT_P_CREATED;
+		spin_lock_init(&(to_police(*a)->tcfp_lock));
 	} else if (!ovr) {
 		tcf_idr_release(*a, bind);
 		return -EEXIST;
 	}
 	new->tcfp_burst = PSCHED_TICKS2NS(parm->burst);
-	new->tcfp_toks = new->tcfp_burst;
+	if (new->peak_present)
-	if (new->peak_present) {
 		new->tcfp_mtu_ptoks = (s64)psched_l2t_ns(&new->peak,
 							 new->tcfp_mtu);
-		new->tcfp_ptoks = new->tcfp_mtu_ptoks;
-	}
 	if (tb[TCA_POLICE_AVRATE])
 		new->tcfp_ewma_rate = nla_get_u32(tb[TCA_POLICE_AVRATE]);
 	}
 	spin_lock_bh(&police->tcf_lock);
-	new->tcfp_t_c = ktime_get_ns();
+	spin_lock_bh(&police->tcfp_lock);
+	police->tcfp_t_c = ktime_get_ns();
+	police->tcfp_toks = new->tcfp_burst;
+	if (new->peak_present)
+		police->tcfp_ptoks = new->tcfp_mtu_ptoks;
+	spin_unlock_bh(&police->tcfp_lock);
 	police->tcf_action = parm->action;
 	rcu_swap_protected(police->params,
 			   new,
 		}
 		now = ktime_get_ns();
-		toks = min_t(s64, now - p->tcfp_t_c, p->tcfp_burst);
+		spin_lock_bh(&police->tcfp_lock);
+		toks = min_t(s64, now - police->tcfp_t_c, p->tcfp_burst);
 		if (p->peak_present) {
-			ptoks = toks + p->tcfp_ptoks;
+			ptoks = toks + police->tcfp_ptoks;
 			if (ptoks > p->tcfp_mtu_ptoks)
 				ptoks = p->tcfp_mtu_ptoks;
 			ptoks -= (s64)psched_l2t_ns(&p->peak,
 						    qdisc_pkt_len(skb));
 		}
-		toks += p->tcfp_toks;
+		toks += police->tcfp_toks;
 		if (toks > p->tcfp_burst)
 			toks = p->tcfp_burst;
 		toks -= (s64)psched_l2t_ns(&p->rate, qdisc_pkt_len(skb));
 		if ((toks|ptoks) >= 0) {
-			p->tcfp_t_c = now;
+			police->tcfp_t_c = now;
-			p->tcfp_toks = toks;
+			police->tcfp_toks = toks;
-			p->tcfp_ptoks = ptoks;
+			police->tcfp_ptoks = ptoks;
+			spin_unlock_bh(&police->tcfp_lock);
 			ret = p->tcfp_result;
 			goto inc_drops;
 		}
+		spin_unlock_bh(&police->tcfp_lock);
 	}
 inc_overlimits:

net/sctp/output.c+4−20

 		sctp_transport_route(tp, NULL, sp);
 		if (asoc->param_flags & SPP_PMTUD_ENABLE)
 			sctp_assoc_sync_pmtu(asoc);
+	} else if (!sctp_transport_pmtu_check(tp)) {
+		if (asoc->param_flags & SPP_PMTUD_ENABLE)
+			sctp_assoc_sync_pmtu(asoc);
 	}
 	if (asoc->pmtu_pending) {
 	return retval;
 }
-static void sctp_packet_release_owner(struct sk_buff *skb)
-{
-	sk_free(skb->sk);
-}
-static void sctp_packet_set_owner_w(struct sk_buff *skb, struct sock *sk)
-{
-	skb_orphan(skb);
-	skb->sk = sk;
-	skb->destructor = sctp_packet_release_owner;
-	/*
-	 * The data chunks have already been accounted for in sctp_sendmsg(),
-	 * therefore only reserve a single byte to keep socket around until
-	 * the packet has been transmitted.
-	 */
-	refcount_inc(&sk->sk_wmem_alloc);
-}
 static void sctp_packet_gso_append(struct sk_buff *head, struct sk_buff *skb)
 {
 	if (SCTP_OUTPUT_CB(head)->last == head)
 	if (!head)
 		goto out;
 	skb_reserve(head, packet->overhead + MAX_HEADER);
-	sctp_packet_set_owner_w(head, sk);
+	skb_set_owner_w(head, sk);
 	/* set sctp header */
 	sh = skb_push(head, sizeof(struct sctphdr));

net/sctp/socket.c+5−21

 					unsigned int optlen)
 {
 	struct sctp_assoc_value params;
-	struct sctp_association *asoc;
-	int retval = -EINVAL;
 	if (optlen != sizeof(params))
-		goto out;
+		return -EINVAL;
-	if (copy_from_user(&params, optval, optlen)) {
-		retval = -EFAULT;
-		goto out;
-	}
-	asoc = sctp_id2assoc(sk, params.assoc_id);
-	if (asoc) {
-		asoc->prsctp_enable = !!params.assoc_value;
-	} else if (!params.assoc_id) {
-		struct sctp_sock *sp = sctp_sk(sk);
-		sp->ep->prsctp_enable = !!params.assoc_value;
+	if (copy_from_user(&params, optval, optlen))
-	} else {
+		return -EFAULT;
-		goto out;
-	}
-	retval = 0;
+	sctp_sk(sk)->ep->prsctp_enable = !!params.assoc_value;
-out:
+	return 0;
-	return retval;
 }
 static int sctp_setsockopt_default_prinfo(struct sock *sk,

net/sctp/stream.c+0−1

@@ -535,7 +535,6 @@ int sctp_send_add_streams(struct sctp_association *asoc, · 534 unmodified lines
535	goto out;	535	goto out;
536	}	536	}
537		537
538	stream->incnt = incnt;
539	stream->outcnt = outcnt;	538	stream->outcnt = outcnt;
540		539
541	asoc->strreset_outstanding = !!out + !!in;	540	asoc->strreset_outstanding = !!out + !!in;

net/smc/af_smc.c+7−4

 	smc = smc_sk(sk);
 	/* cleanup for a dangling non-blocking connect */
+	if (smc->connect_info && sk->sk_state == SMC_INIT)
+		tcp_abort(smc->clcsock->sk, ECONNABORTED);
 	flush_work(&smc->connect_work);
 	kfree(smc->connect_info);
 	smc->connect_info = NULL;
 	mutex_lock(&smc_create_lgr_pending);
 	local_contact = smc_conn_create(smc, false, aclc->hdr.flag, ibdev,
-					ibport, &aclc->lcl, NULL, 0);
+					ibport, ntoh24(aclc->qpn), &aclc->lcl,
+					NULL, 0);
 	if (local_contact < 0) {
 		if (local_contact == -ENOMEM)
 			reason_code = SMC_CLC_DECL_MEM;/* insufficient memory*/
 	int rc = 0;
 	mutex_lock(&smc_create_lgr_pending);
-	local_contact = smc_conn_create(smc, true, aclc->hdr.flag, NULL, 0,
+	local_contact = smc_conn_create(smc, true, aclc->hdr.flag, NULL, 0, 0,
 					NULL, ismdev, aclc->gid);
 	if (local_contact < 0)
 		return smc_connect_abort(smc, SMC_CLC_DECL_MEM, 0);
 				int *local_contact)
 {
 	/* allocate connection / link group */
-	*local_contact = smc_conn_create(new_smc, false, 0, ibdev, ibport,
+	*local_contact = smc_conn_create(new_smc, false, 0, ibdev, ibport, 0,
 					 &pclc->lcl, NULL, 0);
 	if (*local_contact < 0) {
 		if (*local_contact == -ENOMEM)
 	struct smc_clc_msg_smcd *pclc_smcd;
 	pclc_smcd = smc_get_clc_msg_smcd(pclc);
-	*local_contact = smc_conn_create(new_smc, true, 0, NULL, 0, NULL,
+	*local_contact = smc_conn_create(new_smc, true, 0, NULL, 0, 0, NULL,
 					 ismdev, pclc_smcd->gid);
 	if (*local_contact < 0) {
 		if (*local_contact == -ENOMEM)

net/smc/smc_cdc.c+15−11

@@ -81,7 +81,7 @@ static inline void smc_cdc_add_pending_send(struct smc_connection *conn, · 80 unmodified lines
81	sizeof(struct smc_cdc_msg) > SMC_WR_BUF_SIZE,	81	sizeof(struct smc_cdc_msg) > SMC_WR_BUF_SIZE,
82	"must increase SMC_WR_BUF_SIZE to at least sizeof(struct smc_cdc_msg)");	82	"must increase SMC_WR_BUF_SIZE to at least sizeof(struct smc_cdc_msg)");
83	BUILD_BUG_ON_MSG(	83	BUILD_BUG_ON_MSG(
84	sizeof(struct smc_cdc_msg) != SMC_WR_TX_SIZE,	84	offsetofend(struct smc_cdc_msg, reserved) > SMC_WR_TX_SIZE,
85	"must adapt SMC_WR_TX_SIZE to sizeof(struct smc_cdc_msg); if not all smc_wr upper layer protocols use the same message size any more, must start to set link->wr_tx_sges[i].length on each individual smc_wr_tx_send()");	85	"must adapt SMC_WR_TX_SIZE to sizeof(struct smc_cdc_msg); if not all smc_wr upper layer protocols use the same message size any more, must start to set link->wr_tx_sges[i].length on each individual smc_wr_tx_send()");
86	BUILD_BUG_ON_MSG(	86	BUILD_BUG_ON_MSG(
87	sizeof(struct smc_cdc_tx_pend) > SMC_WR_TX_PEND_PRIV_SIZE,	87	sizeof(struct smc_cdc_tx_pend) > SMC_WR_TX_PEND_PRIV_SIZE,
@@ -177,23 +177,24 @@ void smc_cdc_tx_dismiss_slots(struct smc_connection *conn) · 89 unmodified lines
177	int smcd_cdc_msg_send(struct smc_connection *conn)	177	int smcd_cdc_msg_send(struct smc_connection *conn)
178	{	178	{
179	struct smc_sock *smc = container_of(conn, struct smc_sock, conn);	179	struct smc_sock *smc = container_of(conn, struct smc_sock, conn);
		180	union smc_host_cursor curs;
180	struct smcd_cdc_msg cdc;	181	struct smcd_cdc_msg cdc;
181	int rc, diff;	182	int rc, diff;
182		183
183	memset(&cdc, 0, sizeof(cdc));	184	memset(&cdc, 0, sizeof(cdc));
184	cdc.common.type = SMC_CDC_MSG_TYPE;	185	cdc.common.type = SMC_CDC_MSG_TYPE;
185	cdc.prod_wrap = conn->local_tx_ctrl.prod.wrap;	186	curs.acurs.counter = atomic64_read(&conn->local_tx_ctrl.prod.acurs);
186	cdc.prod_count = conn->local_tx_ctrl.prod.count;	187	cdc.prod.wrap = curs.wrap;
187		188	cdc.prod.count = curs.count;
188	cdc.cons_wrap = conn->local_tx_ctrl.cons.wrap;	189	curs.acurs.counter = atomic64_read(&conn->local_tx_ctrl.cons.acurs);
189	cdc.cons_count = conn->local_tx_ctrl.cons.count;	190	cdc.cons.wrap = curs.wrap;
190	cdc.prod_flags = conn->local_tx_ctrl.prod_flags;	191	cdc.cons.count = curs.count;
191	cdc.conn_state_flags = conn->local_tx_ctrl.conn_state_flags;	192	cdc.cons.prod_flags = conn->local_tx_ctrl.prod_flags;
		193	cdc.cons.conn_state_flags = conn->local_tx_ctrl.conn_state_flags;
192	rc = smcd_tx_ism_write(conn, &cdc, sizeof(cdc), 0, 1);	194	rc = smcd_tx_ism_write(conn, &cdc, sizeof(cdc), 0, 1);
193	if (rc)	195	if (rc)
194	return rc;	196	return rc;
195	smc_curs_copy(&conn->rx_curs_confirmed, &conn->local_tx_ctrl.cons,	197	smc_curs_copy(&conn->rx_curs_confirmed, &curs, conn);
196	conn);
197	/* Calculate transmitted data and increment free send buffer space */	198	/* Calculate transmitted data and increment free send buffer space */
198	diff = smc_curs_diff(conn->sndbuf_desc->len, &conn->tx_curs_fin,	199	diff = smc_curs_diff(conn->sndbuf_desc->len, &conn->tx_curs_fin,
199	&conn->tx_curs_sent);	200	&conn->tx_curs_sent);
@@ -331,13 +332,16 @@ static void smc_cdc_msg_recv(struct smc_sock smc, struct smc_cdc_msg cdc) · 131 unmodified lines
331	static void smcd_cdc_rx_tsklet(unsigned long data)	332	static void smcd_cdc_rx_tsklet(unsigned long data)
332	{	333	{
333	struct smc_connection conn = (struct smc_connection )data;	334	struct smc_connection conn = (struct smc_connection )data;
		335	struct smcd_cdc_msg *data_cdc;
334	struct smcd_cdc_msg cdc;	336	struct smcd_cdc_msg cdc;
335	struct smc_sock *smc;	337	struct smc_sock *smc;
336		338
337	if (!conn)	339	if (!conn)
338	return;	340	return;
339		341
340	memcpy(&cdc, conn->rmb_desc->cpu_addr, sizeof(cdc));	342	data_cdc = (struct smcd_cdc_msg *)conn->rmb_desc->cpu_addr;
		343	smcd_curs_copy(&cdc.prod, &data_cdc->prod, conn);
		344	smcd_curs_copy(&cdc.cons, &data_cdc->cons, conn);
341	smc = container_of(conn, struct smc_sock, conn);	345	smc = container_of(conn, struct smc_sock, conn);
342	smc_cdc_msg_recv(smc, (struct smc_cdc_msg *)&cdc);	346	smc_cdc_msg_recv(smc, (struct smc_cdc_msg *)&cdc);
343	}	347	}

net/smc/smc_cdc.h+45−15

@@ -48,21 +48,31 @@ struct smc_cdc_msg { · 47 unmodified lines
48	struct smc_cdc_producer_flags prod_flags;	48	struct smc_cdc_producer_flags prod_flags;
49	struct smc_cdc_conn_state_flags conn_state_flags;	49	struct smc_cdc_conn_state_flags conn_state_flags;
50	u8 reserved[18];	50	u8 reserved[18];
51	} __packed; /* format defined in RFC7609 */	51	};
		52
		53	/* SMC-D cursor format */
		54	union smcd_cdc_cursor {
		55	struct {
		56	u16 wrap;
		57	u32 count;
		58	struct smc_cdc_producer_flags prod_flags;
		59	struct smc_cdc_conn_state_flags conn_state_flags;
		60	} __packed;
		61	#ifdef KERNEL_HAS_ATOMIC64
		62	atomic64_t acurs; /* for atomic processing */
		63	#else
		64	u64 acurs; /* for atomic processing */
		65	#endif
		66	} __aligned(8);
52		67
53	/* CDC message for SMC-D */	68	/* CDC message for SMC-D */
54	struct smcd_cdc_msg {	69	struct smcd_cdc_msg {
55	struct smc_wr_rx_hdr common; /* Type = 0xFE */	70	struct smc_wr_rx_hdr common; /* Type = 0xFE */
56	u8 res1[7];	71	u8 res1[7];
57	u16 prod_wrap;	72	union smcd_cdc_cursor prod;
58	u32 prod_count;	73	union smcd_cdc_cursor cons;
59	u8 res2[2];
60	u16 cons_wrap;
61	u32 cons_count;
62	struct smc_cdc_producer_flags prod_flags;
63	struct smc_cdc_conn_state_flags conn_state_flags;
64	u8 res3[8];	74	u8 res3[8];
65	} __packed;	75	} __aligned(8);
66		76
67	static inline bool smc_cdc_rxed_any_close(struct smc_connection *conn)	77	static inline bool smc_cdc_rxed_any_close(struct smc_connection *conn)
68	{	78	{
@@ -135,6 +145,21 @@ static inline void smc_curs_copy_net(union smc_cdc_cursor *tgt, · 66 unmodified lines
135	#endif	145	#endif
136	}	146	}
137		147
		148	static inline void smcd_curs_copy(union smcd_cdc_cursor *tgt,
		149	union smcd_cdc_cursor *src,
		150	struct smc_connection *conn)
		151	{
		152	#ifndef KERNEL_HAS_ATOMIC64
		153	unsigned long flags;
		154
		155	spin_lock_irqsave(&conn->acurs_lock, flags);
		156	tgt->acurs = src->acurs;
		157	spin_unlock_irqrestore(&conn->acurs_lock, flags);
		158	#else
		159	atomic64_set(&tgt->acurs, atomic64_read(&src->acurs));
		160	#endif
		161	}
		162
138	/* calculate cursor difference between old and new, where old <= new */	163	/* calculate cursor difference between old and new, where old <= new */
139	static inline int smc_curs_diff(unsigned int size,	164	static inline int smc_curs_diff(unsigned int size,
140	union smc_host_cursor *old,	165	union smc_host_cursor *old,
@@ -222,12 +247,17 @@ static inline void smcr_cdc_msg_to_host(struct smc_host_cdc_msg *local, · 81 unmodified lines
222	static inline void smcd_cdc_msg_to_host(struct smc_host_cdc_msg *local,	247	static inline void smcd_cdc_msg_to_host(struct smc_host_cdc_msg *local,
223	struct smcd_cdc_msg *peer)	248	struct smcd_cdc_msg *peer)
224	{	249	{
225	local->prod.wrap = peer->prod_wrap;	250	union smc_host_cursor temp;
226	local->prod.count = peer->prod_count;	251
227	local->cons.wrap = peer->cons_wrap;	252	temp.wrap = peer->prod.wrap;
228	local->cons.count = peer->cons_count;	253	temp.count = peer->prod.count;
229	local->prod_flags = peer->prod_flags;	254	atomic64_set(&local->prod.acurs, atomic64_read(&temp.acurs));
230	local->conn_state_flags = peer->conn_state_flags;	255
		256	temp.wrap = peer->cons.wrap;
		257	temp.count = peer->cons.count;
		258	atomic64_set(&local->cons.acurs, atomic64_read(&temp.acurs));
		259	local->prod_flags = peer->cons.prod_flags;
		260	local->conn_state_flags = peer->cons.conn_state_flags;
231	}	261	}
232		262
233	static inline void smc_cdc_msg_to_host(struct smc_host_cdc_msg *local,	263	static inline void smc_cdc_msg_to_host(struct smc_host_cdc_msg *local,

net/smc/smc_core.c+14−6

 		if (!lgr->is_smcd && lnk->state != SMC_LNK_INACTIVE)
 			smc_llc_link_inactive(lnk);
+		if (lgr->is_smcd)
+			smc_ism_signal_shutdown(lgr);
 		smc_lgr_free(lgr);
 	}
 }
 }
 /* Called when SMC-D device is terminated or peer is lost */
-void smc_smcd_terminate(struct smcd_dev *dev, u64 peer_gid)
+void smc_smcd_terminate(struct smcd_dev *dev, u64 peer_gid, unsigned short vlan)
 {
 	struct smc_link_group *lgr, *l;
 	LIST_HEAD(lgr_free_list);
 	list_for_each_entry_safe(lgr, l, &smc_lgr_list.list, list) {
 		if (lgr->is_smcd && lgr->smcd == dev &&
 		    (!peer_gid || lgr->peer_gid == peer_gid) &&
-		    !list_empty(&lgr->list)) {
+		    (vlan == VLAN_VID_MASK || lgr->vlan_id == vlan)) {
 			__smc_lgr_terminate(lgr);
 			list_move(&lgr->list, &lgr_free_list);
 		}
 	list_for_each_entry_safe(lgr, l, &lgr_free_list, list) {
 		list_del_init(&lgr->list);
 		cancel_delayed_work_sync(&lgr->free_work);
+		if (!peer_gid && vlan == VLAN_VID_MASK) /* dev terminated? */
+			smc_ism_signal_shutdown(lgr);
 		smc_lgr_free(lgr);
 	}
 }
 static bool smcr_lgr_match(struct smc_link_group *lgr,
 			   struct smc_clc_msg_local *lcl,
-			   enum smc_lgr_role role)
+			   enum smc_lgr_role role, u32 clcqpn)
 {
 	return !memcmp(lgr->peer_systemid, lcl->id_for_peer,
 		       SMC_SYSTEMID_LEN) &&
 			SMC_GID_SIZE) &&
 		!memcmp(lgr->lnk[SMC_SINGLE_LINK].peer_mac, lcl->mac,
 			sizeof(lcl->mac)) &&
-		lgr->role == role;
+		lgr->role == role &&
+		(lgr->role == SMC_SERV ||
+		 lgr->lnk[SMC_SINGLE_LINK].peer_qpn == clcqpn);
 }
 static bool smcd_lgr_match(struct smc_link_group *lgr,
 /* create a new SMC connection (and a new link group if necessary) */
 int smc_conn_create(struct smc_sock *smc, bool is_smcd, int srv_first_contact,
-		    struct smc_ib_device *smcibdev, u8 ibport,
+		    struct smc_ib_device *smcibdev, u8 ibport, u32 clcqpn,
 		    struct smc_clc_msg_local *lcl, struct smcd_dev *smcd,
 		    u64 peer_gid)
 {
 	list_for_each_entry(lgr, &smc_lgr_list.list, list) {
 		write_lock_bh(&lgr->conns_lock);
 		if ((is_smcd ? smcd_lgr_match(lgr, smcd, peer_gid) :
-		     smcr_lgr_match(lgr, lcl, role)) &&
+		     smcr_lgr_match(lgr, lcl, role, clcqpn)) &&
 		    !lgr->sync_err &&
 		    lgr->vlan_id == vlan_id &&
 		    (role == SMC_CLNT ||
 			smc_llc_link_inactive(lnk);
 		}
 		cancel_delayed_work_sync(&lgr->free_work);
+		if (lgr->is_smcd)
+			smc_ism_signal_shutdown(lgr);
 		smc_lgr_free(lgr); /* free link group */
 	}
 }

net/smc/smc_core.h+3−2

 void smc_lgr_forget(struct smc_link_group *lgr);
 void smc_lgr_terminate(struct smc_link_group *lgr);
 void smc_port_terminate(struct smc_ib_device *smcibdev, u8 ibport);
-void smc_smcd_terminate(struct smcd_dev *dev, u64 peer_gid);
+void smc_smcd_terminate(struct smcd_dev *dev, u64 peer_gid,
+			unsigned short vlan);
 int smc_buf_create(struct smc_sock *smc, bool is_smcd);
 int smc_uncompress_bufsize(u8 compressed);
 int smc_rmb_rtoken_handling(struct smc_connection *conn,
 void smc_conn_free(struct smc_connection *conn);
 int smc_conn_create(struct smc_sock *smc, bool is_smcd, int srv_first_contact,
-		    struct smc_ib_device *smcibdev, u8 ibport,
+		    struct smc_ib_device *smcibdev, u8 ibport, u32 clcqpn,
 		    struct smc_clc_msg_local *lcl, struct smcd_dev *smcd,
 		    u64 peer_gid);
 void smcd_conn_free(struct smc_connection *conn);

net/smc/smc_ism.c+32−11

 #define ISM_EVENT_REQUEST		0x0001
 #define ISM_EVENT_RESPONSE		0x0002
 #define ISM_EVENT_REQUEST_IR		0x00000001
+#define ISM_EVENT_CODE_SHUTDOWN		0x80
 #define ISM_EVENT_CODE_TESTLINK		0x83
+union smcd_sw_event_info {
+	u64	info;
+	struct {
+		u8		uid[SMC_LGR_ID_SIZE];
+		unsigned short	vlan_id;
+		u16		code;
+	};
+};
 static void smcd_handle_sw_event(struct smc_ism_event_work *wrk)
 {
-	union {
+	union smcd_sw_event_info ev_info;
-		u64	info;
-		struct {
-			u32		uid;
-			unsigned short	vlanid;
-			u16		code;
-		};
-	} ev_info;
+	ev_info.info = wrk->event.info;
 	switch (wrk->event.code) {
+	case ISM_EVENT_CODE_SHUTDOWN:	/* Peer shut down DMBs */
+		smc_smcd_terminate(wrk->smcd, wrk->event.tok, ev_info.vlan_id);
+		break;
 	case ISM_EVENT_CODE_TESTLINK:	/* Activity timer */
-		ev_info.info = wrk->event.info;
 		if (ev_info.code == ISM_EVENT_REQUEST) {
 			ev_info.code = ISM_EVENT_RESPONSE;
 			wrk->smcd->ops->signal_event(wrk->smcd,
 	}
 }
+int smc_ism_signal_shutdown(struct smc_link_group *lgr)
+{
+	int rc;
+	union smcd_sw_event_info ev_info;
+	memcpy(ev_info.uid, lgr->id, SMC_LGR_ID_SIZE);
+	ev_info.vlan_id = lgr->vlan_id;
+	ev_info.code = ISM_EVENT_REQUEST;
+	rc = lgr->smcd->ops->signal_event(lgr->smcd, lgr->peer_gid,
+					  ISM_EVENT_REQUEST_IR,
+					  ISM_EVENT_CODE_SHUTDOWN,
+					  ev_info.info);
+	return rc;
+}
 /* worker for SMC-D events */
 static void smc_ism_event_work(struct work_struct *work)
 {
 	switch (wrk->event.type) {
 	case ISM_EVENT_GID:	/* GID event, token is peer GID */
-		smc_smcd_terminate(wrk->smcd, wrk->event.tok);
+		smc_smcd_terminate(wrk->smcd, wrk->event.tok, VLAN_VID_MASK);
 		break;
 	case ISM_EVENT_DMB:
 		break;
 	spin_unlock(&smcd_dev_list.lock);
 	flush_workqueue(smcd->event_wq);
 	destroy_workqueue(smcd->event_wq);
-	smc_smcd_terminate(smcd, 0);
+	smc_smcd_terminate(smcd, 0, VLAN_VID_MASK);
 	device_del(&smcd->dev);
 }

net/smc/smc_ism.h+1−0

@@ -45,4 +45,5 @@ int smc_ism_register_dmb(struct smc_link_group *lgr, int buf_size, · 44 unmodified lines
45	int smc_ism_unregister_dmb(struct smcd_dev dev, struct smc_buf_desc dmb_desc);	45	int smc_ism_unregister_dmb(struct smcd_dev dev, struct smc_buf_desc dmb_desc);
46	int smc_ism_write(struct smcd_dev dev, const struct smc_ism_position pos,	46	int smc_ism_write(struct smcd_dev dev, const struct smc_ism_position pos,
47	void *data, size_t len);	47	void *data, size_t len);
		48	int smc_ism_signal_shutdown(struct smc_link_group *lgr);
48	#endif	49	#endif

net/smc/smc_wr.c+3−1

 	pend = container_of(wr_pend_priv, struct smc_wr_tx_pend, priv);
 	if (pend->idx < link->wr_tx_cnt) {
+		u32 idx = pend->idx;
 		/* clear the full struct smc_wr_tx_pend including .priv */
 		memset(&link->wr_tx_pends[pend->idx], 0,
 		       sizeof(link->wr_tx_pends[pend->idx]));
 		memset(&link->wr_tx_bufs[pend->idx], 0,
 		       sizeof(link->wr_tx_bufs[pend->idx]));
-		test_and_clear_bit(pend->idx, link->wr_tx_mask);
+		test_and_clear_bit(idx, link->wr_tx_mask);
 		return 1;
 	}

sound/core/oss/pcm_oss.c+3−3

@@ -1062,8 +1062,8 @@ static int snd_pcm_oss_change_params_locked(struct snd_pcm_substream *substream) · 1061 unmodified lines
1062	runtime->oss.channels = params_channels(params);	1062	runtime->oss.channels = params_channels(params);
1063	runtime->oss.rate = params_rate(params);	1063	runtime->oss.rate = params_rate(params);
1064		1064
1065	vfree(runtime->oss.buffer);	1065	kvfree(runtime->oss.buffer);
1066	runtime->oss.buffer = vmalloc(runtime->oss.period_bytes);	1066	runtime->oss.buffer = kvzalloc(runtime->oss.period_bytes, GFP_KERNEL);
1067	if (!runtime->oss.buffer) {	1067	if (!runtime->oss.buffer) {
1068	err = -ENOMEM;	1068	err = -ENOMEM;
1069	goto failure;	1069	goto failure;
@@ -2328,7 +2328,7 @@ static void snd_pcm_oss_release_substream(struct snd_pcm_substream *substream) · 1258 unmodified lines
2328	{	2328	{
2329	struct snd_pcm_runtime *runtime;	2329	struct snd_pcm_runtime *runtime;
2330	runtime = substream->runtime;	2330	runtime = substream->runtime;
2331	vfree(runtime->oss.buffer);	2331	kvfree(runtime->oss.buffer);
2332	runtime->oss.buffer = NULL;	2332	runtime->oss.buffer = NULL;
2333	#ifdef CONFIG_SND_PCM_OSS_PLUGINS	2333	#ifdef CONFIG_SND_PCM_OSS_PLUGINS
2334	snd_pcm_oss_plugin_clear(substream);	2334	snd_pcm_oss_plugin_clear(substream);

sound/core/oss/pcm_plugin.c+3−3

@@ -66,8 +66,8 @@ static int snd_pcm_plugin_alloc(struct snd_pcm_plugin *plugin, snd_pcm_uframes_t · 65 unmodified lines
66	return -ENXIO;	66	return -ENXIO;
67	size /= 8;	67	size /= 8;
68	if (plugin->buf_frames < frames) {	68	if (plugin->buf_frames < frames) {
69	vfree(plugin->buf);	69	kvfree(plugin->buf);
70	plugin->buf = vmalloc(size);	70	plugin->buf = kvzalloc(size, GFP_KERNEL);
71	plugin->buf_frames = frames;	71	plugin->buf_frames = frames;
72	}	72	}
73	if (!plugin->buf) {	73	if (!plugin->buf) {
@@ -191,7 +191,7 @@ int snd_pcm_plugin_free(struct snd_pcm_plugin *plugin) · 117 unmodified lines
191	if (plugin->private_free)	191	if (plugin->private_free)
192	plugin->private_free(plugin);	192	plugin->private_free(plugin);
193	kfree(plugin->buf_channels);	193	kfree(plugin->buf_channels);
194	vfree(plugin->buf);	194	kvfree(plugin->buf);
195	kfree(plugin);	195	kfree(plugin);
196	return 0;	196	return 0;
197	}	197	}

sound/pci/hda/patch_ca0132.c+3−2

 	SND_PCI_QUIRK(0x1028, 0x0708, "Alienware 15 R2 2016", QUIRK_ALIENWARE),
 	SND_PCI_QUIRK(0x1102, 0x0010, "Sound Blaster Z", QUIRK_SBZ),
 	SND_PCI_QUIRK(0x1102, 0x0023, "Sound Blaster Z", QUIRK_SBZ),
+	SND_PCI_QUIRK(0x1102, 0x0033, "Sound Blaster ZxR", QUIRK_SBZ),
 	SND_PCI_QUIRK(0x1458, 0xA016, "Recon3Di", QUIRK_R3DI),
 	SND_PCI_QUIRK(0x1458, 0xA026, "Gigabyte G1.Sniper Z97", QUIRK_R3DI),
 	SND_PCI_QUIRK(0x1458, 0xA036, "Gigabyte GA-Z170X-Gaming 7", QUIRK_R3DI),
 	snd_hda_power_down(codec);
 	if (spec->mem_base)
-		iounmap(spec->mem_base);
+		pci_iounmap(codec->bus->pci, spec->mem_base);
 	kfree(spec->spec_init_verbs);
 	kfree(codec->spec);
 }
 		break;
 	case QUIRK_AE5:
 		codec_dbg(codec, "%s: QUIRK_AE5 applied.\n", __func__);
-		snd_hda_apply_pincfgs(codec, r3di_pincfgs);
+		snd_hda_apply_pincfgs(codec, ae5_pincfgs);
 		break;
 	}

sound/pci/hda/patch_realtek.c+1−0

@@ -6481,6 +6481,7 @@ static const struct snd_pci_quirk alc269_fixup_tbl[] = { · 6480 unmodified lines
6481	SND_PCI_QUIRK(0x103c, 0x2336, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),	6481	SND_PCI_QUIRK(0x103c, 0x2336, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
6482	SND_PCI_QUIRK(0x103c, 0x2337, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),	6482	SND_PCI_QUIRK(0x103c, 0x2337, "HP", ALC269_FIXUP_HP_MUTE_LED_MIC1),
6483	SND_PCI_QUIRK(0x103c, 0x221c, "HP EliteBook 755 G2", ALC280_FIXUP_HP_HEADSET_MIC),	6483	SND_PCI_QUIRK(0x103c, 0x221c, "HP EliteBook 755 G2", ALC280_FIXUP_HP_HEADSET_MIC),
		6484	SND_PCI_QUIRK(0x103c, 0x820d, "HP Pavilion 15", ALC269_FIXUP_HP_MUTE_LED_MIC3),
6484	SND_PCI_QUIRK(0x103c, 0x8256, "HP", ALC221_FIXUP_HP_FRONT_MIC),	6485	SND_PCI_QUIRK(0x103c, 0x8256, "HP", ALC221_FIXUP_HP_FRONT_MIC),
6485	SND_PCI_QUIRK(0x103c, 0x827e, "HP x360", ALC295_FIXUP_HP_X360),	6486	SND_PCI_QUIRK(0x103c, 0x827e, "HP x360", ALC295_FIXUP_HP_X360),
6486	SND_PCI_QUIRK(0x103c, 0x82bf, "HP", ALC221_FIXUP_HP_MIC_NO_PRESENCE),	6487	SND_PCI_QUIRK(0x103c, 0x82bf, "HP", ALC221_FIXUP_HP_MIC_NO_PRESENCE),

tools/power/cpupower/Makefile+6−6

@@ -129,7 +129,7 @@ WARNINGS += $(call cc-supports,-Wno-pointer-sign) · 128 unmodified lines
129	WARNINGS += $(call cc-supports,-Wdeclaration-after-statement)	129	WARNINGS += $(call cc-supports,-Wdeclaration-after-statement)
130	WARNINGS += -Wshadow	130	WARNINGS += -Wshadow
131		131
132	CFLAGS += -DVERSION=\"$(VERSION)\" -DPACKAGE=\"$(PACKAGE)\" \	132	override CFLAGS += -DVERSION=\"$(VERSION)\" -DPACKAGE=\"$(PACKAGE)\" \
133	-DPACKAGE_BUGREPORT=\"$(PACKAGE_BUGREPORT)\" -D_GNU_SOURCE	133	-DPACKAGE_BUGREPORT=\"$(PACKAGE_BUGREPORT)\" -D_GNU_SOURCE
134		134
135	UTIL_OBJS = utils/helpers/amd.o utils/helpers/msr.o \	135	UTIL_OBJS = utils/helpers/amd.o utils/helpers/msr.o \
@@ -156,12 +156,12 @@ LIB_SRC = lib/cpufreq.c lib/cpupower.c lib/cpuidle.c · 20 unmodified lines
156	LIB_OBJS = lib/cpufreq.o lib/cpupower.o lib/cpuidle.o	156	LIB_OBJS = lib/cpufreq.o lib/cpupower.o lib/cpuidle.o
157	LIB_OBJS := $(addprefix $(OUTPUT),$(LIB_OBJS))	157	LIB_OBJS := $(addprefix $(OUTPUT),$(LIB_OBJS))
158		158
159	CFLAGS += -pipe	159	override CFLAGS += -pipe
160		160
161	ifeq ($(strip $(NLS)),true)	161	ifeq ($(strip $(NLS)),true)
162	INSTALL_NLS += install-gmo	162	INSTALL_NLS += install-gmo
163	COMPILE_NLS += create-gmo	163	COMPILE_NLS += create-gmo
164	CFLAGS += -DNLS	164	override CFLAGS += -DNLS
165	endif	165	endif
166		166
167	ifeq ($(strip $(CPUFREQ_BENCH)),true)	167	ifeq ($(strip $(CPUFREQ_BENCH)),true)
@@ -175,7 +175,7 @@ ifeq ($(strip $(STATIC)),true) · 7 unmodified lines
175	UTIL_SRC += $(LIB_SRC)	175	UTIL_SRC += $(LIB_SRC)
176	endif	176	endif
177		177
178	CFLAGS += $(WARNINGS)	178	override CFLAGS += $(WARNINGS)
179		179
180	ifeq ($(strip $(V)),false)	180	ifeq ($(strip $(V)),false)
181	QUIET=@	181	QUIET=@
@@ -188,10 +188,10 @@ export QUIET ECHO · 6 unmodified lines
188		188
189	# if DEBUG is enabled, then we do not strip or optimize	189	# if DEBUG is enabled, then we do not strip or optimize
190	ifeq ($(strip $(DEBUG)),true)	190	ifeq ($(strip $(DEBUG)),true)
191	CFLAGS += -O1 -g -DDEBUG	191	override CFLAGS += -O1 -g -DDEBUG
192	STRIPCMD = /bin/true -Since_we_are_debugging	192	STRIPCMD = /bin/true -Since_we_are_debugging
193	else	193	else
194	CFLAGS += $(OPTIMIZATION) -fomit-frame-pointer	194	override CFLAGS += $(OPTIMIZATION) -fomit-frame-pointer
195	STRIPCMD = $(STRIP) -s --remove-section=.note --remove-section=.comment	195	STRIPCMD = $(STRIP) -s --remove-section=.note --remove-section=.comment
196	endif	196	endif
197		197

tools/power/cpupower/bench/Makefile+1−1

@@ -9,7 +9,7 @@ endif · 8 unmodified lines
9	ifeq ($(strip $(STATIC)),true)	9	ifeq ($(strip $(STATIC)),true)
10	LIBS = -L../ -L$(OUTPUT) -lm	10	LIBS = -L../ -L$(OUTPUT) -lm
11	OBJS = $(OUTPUT)main.o $(OUTPUT)parse.o $(OUTPUT)system.o $(OUTPUT)benchmark.o \	11	OBJS = $(OUTPUT)main.o $(OUTPUT)parse.o $(OUTPUT)system.o $(OUTPUT)benchmark.o \
12	$(OUTPUT)../lib/cpufreq.o $(OUTPUT)../lib/sysfs.o	12	$(OUTPUT)../lib/cpufreq.o $(OUTPUT)../lib/cpupower.o
13	else	13	else
14	LIBS = -L../ -L$(OUTPUT) -lm -lcpupower	14	LIBS = -L../ -L$(OUTPUT) -lm -lcpupower
15	OBJS = $(OUTPUT)main.o $(OUTPUT)parse.o $(OUTPUT)system.o $(OUTPUT)benchmark.o	15	OBJS = $(OUTPUT)main.o $(OUTPUT)parse.o $(OUTPUT)system.o $(OUTPUT)benchmark.o

tools/power/cpupower/debug/x86_64/Makefile+2−2

@@ -13,10 +13,10 @@ INSTALL = /usr/bin/install · 12 unmodified lines
13	default: all	13	default: all
14		14
15	$(OUTPUT)centrino-decode: ../i386/centrino-decode.c	15	$(OUTPUT)centrino-decode: ../i386/centrino-decode.c
16	$(CC) $(CFLAGS) -o $@ $<	16	$(CC) $(CFLAGS) -o $@ $(LDFLAGS) $<
17		17
18	$(OUTPUT)powernow-k8-decode: ../i386/powernow-k8-decode.c	18	$(OUTPUT)powernow-k8-decode: ../i386/powernow-k8-decode.c
19	$(CC) $(CFLAGS) -o $@ $<	19	$(CC) $(CFLAGS) -o $@ $(LDFLAGS) $<
20		20
21	all: $(OUTPUT)centrino-decode $(OUTPUT)powernow-k8-decode	21	all: $(OUTPUT)centrino-decode $(OUTPUT)powernow-k8-decode
22		22

tools/power/cpupower/lib/cpufreq.c+1−1

@@ -28,7 +28,7 @@ static unsigned int sysfs_cpufreq_read_file(unsigned int cpu, const char *fname, · 27 unmodified lines
28		28
29	snprintf(path, sizeof(path), PATH_TO_CPU "cpu%u/cpufreq/%s",	29	snprintf(path, sizeof(path), PATH_TO_CPU "cpu%u/cpufreq/%s",
30	cpu, fname);	30	cpu, fname);
31	return sysfs_read_file(path, buf, buflen);	31	return cpupower_read_sysfs(path, buf, buflen);
32	}	32	}
33		33
34	/* helper function to write a new value to a /sys file */	34	/* helper function to write a new value to a /sys file */

tools/power/cpupower/lib/cpuidle.c+1−1

@@ -319,7 +319,7 @@ static unsigned int sysfs_cpuidle_read_file(const char fname, char buf, · 318 unmodified lines
319		319
320	snprintf(path, sizeof(path), PATH_TO_CPU "cpuidle/%s", fname);	320	snprintf(path, sizeof(path), PATH_TO_CPU "cpuidle/%s", fname);
321		321
322	return sysfs_read_file(path, buf, buflen);	322	return cpupower_read_sysfs(path, buf, buflen);
323	}	323	}
324		324
325		325

tools/power/cpupower/lib/cpupower.c+2−2

@@ -15,7 +15,7 @@ · 14 unmodified lines
15	#include "cpupower.h"	15	#include "cpupower.h"
16	#include "cpupower_intern.h"	16	#include "cpupower_intern.h"
17		17
18	unsigned int sysfs_read_file(const char path, char buf, size_t buflen)	18	unsigned int cpupower_read_sysfs(const char path, char buf, size_t buflen)
19	{	19	{
20	int fd;	20	int fd;
21	ssize_t numread;	21	ssize_t numread;
@@ -95,7 +95,7 @@ static int sysfs_topology_read_file(unsigned int cpu, const char fname, int re · 73 unmodified lines
95		95
96	snprintf(path, sizeof(path), PATH_TO_CPU "cpu%u/topology/%s",	96	snprintf(path, sizeof(path), PATH_TO_CPU "cpu%u/topology/%s",
97	cpu, fname);	97	cpu, fname);
98	if (sysfs_read_file(path, linebuf, MAX_LINE_LEN) == 0)	98	if (cpupower_read_sysfs(path, linebuf, MAX_LINE_LEN) == 0)
99	return -1;	99	return -1;
100	*result = strtol(linebuf, &endp, 0);	100	*result = strtol(linebuf, &endp, 0);
101	if (endp == linebuf \|\| errno == ERANGE)	101	if (endp == linebuf \|\| errno == ERANGE)

tools/power/cpupower/lib/cpupower_intern.h+1−1

@@ -3,4 +3,4 @@ · 2 unmodified lines
3	#define MAX_LINE_LEN 4096	3	#define MAX_LINE_LEN 4096
4	#define SYSFS_PATH_MAX 255	4	#define SYSFS_PATH_MAX 255
5		5
6	unsigned int sysfs_read_file(const char path, char buf, size_t buflen);	6	unsigned int cpupower_read_sysfs(const char path, char buf, size_t buflen);