lael-labs/linux

.mailmap+2−0

 Greg Kroah-Hartman <greg@kroah.com>
 Greg Kurz <groug@kaod.org> <gkurz@linux.vnet.ibm.com>
 Gregory CLEMENT <gregory.clement@bootlin.com> <gregory.clement@free-electrons.com>
+Guo Ren <guoren@kernel.org> <guoren@linux.alibaba.com>
+Guo Ren <guoren@kernel.org> <ren_guo@c-sky.com>
 Gustavo Padovan <gustavo@las.ic.unicamp.br>
 Gustavo Padovan <padovan@profusion.mobi>
 Hanjun Guo <guohanjun@huawei.com> <hanjun.guo@linaro.org>

Documentation/admin-guide/blockdev/drbd/figures.rst+2−2

@@ -25,6 +25,6 @@ Sub graphs of DRBD's state transitions · 24 unmodified lines
25	:alt: disk-states-8.dot	25	:alt: disk-states-8.dot
26	:align: center	26	:align: center
27		27
28	.. kernel-figure:: node-states-8.dot	28	.. kernel-figure:: peer-states-8.dot
29	:alt: node-states-8.dot	29	:alt: peer-states-8.dot
30	:align: center	30	:align: center

Documentation/admin-guide/blockdev/drbd/peer-states-8.dotrenamed from Documentation/admin-guide/blockdev/drbd/node-states-8.dot+0−5

@@ -1,8 +1,3 @@
1	digraph node_states {
2	Secondary -> Primary [ label = "ioctl_set_state()" ]
3	Primary -> Secondary [ label = "ioctl_set_state()" ]
4	}
5
6	digraph peer_states {	1	digraph peer_states {
7	Secondary -> Primary [ label = "recv state packet" ]	2	Secondary -> Primary [ label = "recv state packet" ]
8	Primary -> Secondary [ label = "recv state packet" ]	3	Primary -> Secondary [ label = "recv state packet" ]

Documentation/arm64/pointer-authentication.rst+4−5

@@ -53,11 +53,10 @@ The number of bits that the PAC occupies in a pointer is 55 minus the · 52 unmodified lines
53	virtual address size configured by the kernel. For example, with a	53	virtual address size configured by the kernel. For example, with a
54	virtual address size of 48, the PAC is 7 bits wide.	54	virtual address size of 48, the PAC is 7 bits wide.
55		55
56	Recent versions of GCC can compile code with APIAKey-based return	56	When ARM64_PTR_AUTH_KERNEL is selected, the kernel will be compiled
57	address protection when passed the -msign-return-address option. This	57	with HINT space pointer authentication instructions protecting
58	uses instructions in the HINT space (unless -march=armv8.3-a or higher	58	function returns. Kernels built with this option will work on hardware
59	is also passed), and such code can run on systems without the pointer	59	with or without pointer authentication support.
60	authentication extension.
61		60
62	In addition to exec(), keys can also be reinitialized to random values	61	In addition to exec(), keys can also be reinitialized to random values
63	using the PR_PAC_RESET_KEYS prctl. A bitmask of PR_PAC_APIAKEY,	62	using the PR_PAC_RESET_KEYS prctl. A bitmask of PR_PAC_APIAKEY,

Documentation/conf.py+10−5

@@ -249,11 +249,16 @@ except ImportError: · 248 unmodified lines
249		249
250	html_static_path = ['sphinx-static']	250	html_static_path = ['sphinx-static']
251		251
252	html_context = {	252	html_css_files = [
253	'css_files': [	253	'theme_overrides.css',
254	'_static/theme_overrides.css',	254	]
255	],	255
256	}	256	if major <= 1 and minor < 8:
		257	html_context = {
		258	'css_files': [
		259	'_static/theme_overrides.css',
		260	],
		261	}
257		262
258	# Add any extra paths that contain custom files (such as robots.txt or	263	# Add any extra paths that contain custom files (such as robots.txt or
259	# .htaccess) here, relative to this directory. These files are copied	264	# .htaccess) here, relative to this directory. These files are copied

Documentation/cpu-freq/core.rst+3−3

@@ -73,12 +73,12 @@ CPUFREQ_POSTCHANGE. · 72 unmodified lines
73	The third argument is a struct cpufreq_freqs with the following	73	The third argument is a struct cpufreq_freqs with the following
74	values:	74	values:
75		75
76	===== ===========================	76	====== ======================================
77	cpu number of the affected CPU	77	policy a pointer to the struct cpufreq_policy
78	old old frequency	78	old old frequency
79	new new frequency	79	new new frequency
80	flags flags of the cpufreq driver	80	flags flags of the cpufreq driver
81	===== ===========================	81	====== ======================================
82		82
83	3. CPUFreq Table Generation with Operating Performance Point (OPP)	83	3. CPUFreq Table Generation with Operating Performance Point (OPP)
84	==================================================================	84	==================================================================

Documentation/devicetree/bindings/iio/adc/samsung,exynos-adc.yaml+1−1

@@ -136,7 +136,7 @@ examples: · 135 unmodified lines
136	samsung,syscon-phandle = <&pmu_system_controller>;	136	samsung,syscon-phandle = <&pmu_system_controller>;
137		137
138	/* NTC thermistor is a hwmon device */	138	/* NTC thermistor is a hwmon device */
139	ncp15wb473 {	139	thermistor {
140	compatible = "murata,ncp15wb473";	140	compatible = "murata,ncp15wb473";
141	pullup-uv = <1800000>;	141	pullup-uv = <1800000>;
142	pullup-ohm = <47000>;	142	pullup-ohm = <47000>;

Documentation/devicetree/bindings/input/gpio-keys.yaml+1−1

@@ -142,7 +142,7 @@ examples: · 141 unmodified lines
142	down {	142	down {
143	label = "GPIO Key DOWN";	143	label = "GPIO Key DOWN";
144	linux,code = <108>;	144	linux,code = <108>;
145	interrupts = <1 IRQ_TYPE_LEVEL_HIGH 7>;	145	interrupts = <1 IRQ_TYPE_EDGE_FALLING>;
146	};	146	};
147	};	147	};
148		148

Documentation/devicetree/bindings/media/nxp,imx7-mipi-csi2.yaml+2−12

             properties:
               data-lanes:
+                description:
+                  Note that 'fsl,imx7-mipi-csi2' only supports up to 2 data lines.
                 items:
                   minItems: 1
                   maxItems: 4
             required:
               - data-lanes
-            allOf:
-              - if:
-                  properties:
-                    compatible:
-                      contains:
-                        const: fsl,imx7-mipi-csi2
-                then:
-                  properties:
-                    data-lanes:
-                      items:
-                        maxItems: 2
       port@1:
         $ref: /schemas/graph.yaml#/properties/port
         description:

Documentation/devicetree/bindings/net/ethernet-phy.yaml+8−0

@@ -91,6 +91,14 @@ properties: · 90 unmodified lines
91	compensate for the board being designed with the lanes	91	compensate for the board being designed with the lanes
92	swapped.	92	swapped.
93		93
		94	enet-phy-lane-no-swap:
		95	$ref: /schemas/types.yaml#/definitions/flag
		96	description:
		97	If set, indicates that PHY will disable swap of the
		98	TX/RX lanes. This property allows the PHY to work correcly after
		99	e.g. wrong bootstrap configuration caused by issues in PCB
		100	layout design.
		101
94	eee-broken-100tx:	102	eee-broken-100tx:
95	$ref: /schemas/types.yaml#/definitions/flag	103	$ref: /schemas/types.yaml#/definitions/flag
96	description:	104	description:

Documentation/devicetree/bindings/phy/xlnx,zynqmp-psgtr.yaml+1−1

@@ -29,7 +29,7 @@ properties: · 28 unmodified lines
29	- PHY_TYPE_PCIE	29	- PHY_TYPE_PCIE
30	- PHY_TYPE_SATA	30	- PHY_TYPE_SATA
31	- PHY_TYPE_SGMII	31	- PHY_TYPE_SGMII
32	- PHY_TYPE_USB	32	- PHY_TYPE_USB3
33	- description: The PHY instance	33	- description: The PHY instance
34	minimum: 0	34	minimum: 0
35	maximum: 1 # for DP, SATA or USB	35	maximum: 1 # for DP, SATA or USB

Documentation/devicetree/bindings/power/supply/bq25980.yaml+1−1

@@ -105,7 +105,7 @@ examples: · 104 unmodified lines
105	reg = <0x65>;	105	reg = <0x65>;
106	interrupt-parent = <&gpio1>;	106	interrupt-parent = <&gpio1>;
107	interrupts = <16 IRQ_TYPE_EDGE_FALLING>;	107	interrupts = <16 IRQ_TYPE_EDGE_FALLING>;
108	ti,watchdog-timer = <0>;	108	ti,watchdog-timeout-ms = <0>;
109	ti,sc-ocp-limit-microamp = <2000000>;	109	ti,sc-ocp-limit-microamp = <2000000>;
110	ti,sc-ovp-limit-microvolt = <17800000>;	110	ti,sc-ovp-limit-microvolt = <17800000>;
111	monitored-battery = <&bat>;	111	monitored-battery = <&bat>;

Documentation/devicetree/bindings/sound/wlf,wm8962.yaml+3−0

@@ -19,6 +19,9 @@ properties: · 18 unmodified lines
19	clocks:	19	clocks:
20	maxItems: 1	20	maxItems: 1
21		21
		22	interrupts:
		23	maxItems: 1
		24
22	"#sound-dai-cells":	25	"#sound-dai-cells":
23	const: 0	26	const: 0
24		27

Documentation/devicetree/bindings/spi/spi-rockchip.yaml+1−0

@@ -33,6 +33,7 @@ properties: · 32 unmodified lines
33	- rockchip,rk3328-spi	33	- rockchip,rk3328-spi
34	- rockchip,rk3368-spi	34	- rockchip,rk3368-spi
35	- rockchip,rk3399-spi	35	- rockchip,rk3399-spi
		36	- rockchip,rk3568-spi
36	- rockchip,rv1126-spi	37	- rockchip,rv1126-spi
37	- const: rockchip,rk3066-spi	38	- const: rockchip,rk3066-spi
38		39

Documentation/filesystems/netfs_library.rst+56−39

 .. SPDX-License-Identifier: GPL-2.0
 =================================
-NETWORK FILESYSTEM HELPER LIBRARY
+Network Filesystem Helper Library
 =================================
 .. Contents:
 The following services are provided:
- * Handles transparent huge pages (THPs).
+ * Handle folios that span multiple pages.
- * Insulates the netfs from VM interface changes.
+ * Insulate the netfs from VM interface changes.
- * Allows the netfs to arbitrarily split reads up into pieces, even ones that
+ * Allow the netfs to arbitrarily split reads up into pieces, even ones that
-   don't match page sizes or page alignments and that may cross pages.
+   don't match folio sizes or folio alignments and that may cross folios.
- * Allows the netfs to expand a readahead request in both directions to meet
+ * Allow the netfs to expand a readahead request in both directions to meet its
-   its needs.
+   needs.
- * Allows the netfs to partially fulfil a read, which will then be resubmitted.
+ * Allow the netfs to partially fulfil a read, which will then be resubmitted.
- * Handles local caching, allowing cached data and server-read data to be
+ * Handle local caching, allowing cached data and server-read data to be
    interleaved for a single request.
- * Handles clearing of bufferage that aren't on the server.
+ * Handle clearing of bufferage that aren't on the server.
  * Handle retrying of reads that failed, switching reads from the cache to the
    server as necessary.
 Three read helpers are provided::
- * void netfs_readahead(struct readahead_control *ractl,
+	void netfs_readahead(struct readahead_control *ractl,
-			const struct netfs_read_request_ops *ops,
+			     const struct netfs_read_request_ops *ops,
-			void *netfs_priv);``
+			     void *netfs_priv);
- * int netfs_readpage(struct file *file,
+	int netfs_readpage(struct file *file,
-		      struct page *page,
+			   struct folio *folio,
-		      const struct netfs_read_request_ops *ops,
+			   const struct netfs_read_request_ops *ops,
-		      void *netfs_priv);
+			   void *netfs_priv);
- * int netfs_write_begin(struct file *file,
+	int netfs_write_begin(struct file *file,
-			 struct address_space *mapping,
+			      struct address_space *mapping,
-			 loff_t pos,
+			      loff_t pos,
-			 unsigned int len,
+			      unsigned int len,
-			 unsigned int flags,
+			      unsigned int flags,
-			 struct page **_page,
+			      struct folio **_folio,
-			 void **_fsdata,
+			      void **_fsdata,
-			 const struct netfs_read_request_ops *ops,
+			      const struct netfs_read_request_ops *ops,
-			 void *netfs_priv);
+			      void *netfs_priv);
 Each corresponds to a VM operation, with the addition of a couple of parameters
 for the use of the read helpers:
 For ->readahead() and ->readpage(), the network filesystem should just jump
 into the corresponding read helper; whereas for ->write_begin(), it may be a
 little more complicated as the network filesystem might want to flush
-conflicting writes or track dirty data and needs to put the acquired page if an
+conflicting writes or track dirty data and needs to put the acquired folio if
-error occurs after calling the helper.
+an error occurs after calling the helper.
 The helpers manage the read request, calling back into the network filesystem
 through the suppplied table of operations.  Waits will be performed as
 		void (*issue_op)(struct netfs_read_subrequest *subreq);
 		bool (*is_still_valid)(struct netfs_read_request *rreq);
 		int (*check_write_begin)(struct file *file, loff_t pos, unsigned len,
-					 struct page *page, void **_fsdata);
+					 struct folio *folio, void **_fsdata);
 		void (*done)(struct netfs_read_request *rreq);
 		void (*cleanup)(struct address_space *mapping, void *netfs_priv);
 	};
    There is no return value; the netfs_subreq_terminated() function should be
    called to indicate whether or not the operation succeeded and how much data
-   it transferred.  The filesystem also should not deal with setting pages
+   it transferred.  The filesystem also should not deal with setting folios
    uptodate, unlocking them or dropping their refs - the helpers need to deal
    with this as they have to coordinate with copying to the local cache.
-   Note that the helpers have the pages locked, but not pinned.  It is possible
+   Note that the helpers have the folios locked, but not pinned.  It is
-   to use the ITER_XARRAY iov iterator to refer to the range of the inode that
+   possible to use the ITER_XARRAY iov iterator to refer to the range of the
-   is being operated upon without the need to allocate large bvec tables.
+   inode that is being operated upon without the need to allocate large bvec
+   tables.
  * ``is_still_valid()``
  * ``check_write_begin()``
    [Optional] This is called from the netfs_write_begin() helper once it has
-   allocated/grabbed the page to be modified to allow the filesystem to flush
+   allocated/grabbed the folio to be modified to allow the filesystem to flush
    conflicting state before allowing it to be modified.
-   It should return 0 if everything is now fine, -EAGAIN if the page should be
+   It should return 0 if everything is now fine, -EAGAIN if the folio should be
    regrabbed and any other error code to abort the operation.
  * ``done``
-   [Optional] This is called after the pages in the request have all been
+   [Optional] This is called after the folios in the request have all been
    unlocked (and marked uptodate if applicable).
  * ``cleanup``
      * If NETFS_SREQ_CLEAR_TAIL was set, a short read will be cleared to the
        end of the slice instead of reissuing.
- * Once the data is read, the pages that have been fully read/cleared:
+ * Once the data is read, the folios that have been fully read/cleared:
    * Will be marked uptodate.
    * Unlocked
- * Any pages that need writing to the cache will then have DIO writes issued.
+ * Any folios that need writing to the cache will then have DIO writes issued.
  * Synchronous operations will wait for reading to be complete.
- * Writes to the cache will proceed asynchronously and the pages will have the
+ * Writes to the cache will proceed asynchronously and the folios will have the
    PG_fscache mark removed when that completes.
  * The request structures will be cleaned up when everything has completed.
 			    netfs_io_terminated_t term_func,
 			    void *term_func_priv);
+		int (*prepare_write)(struct netfs_cache_resources *cres,
+				     loff_t *_start, size_t *_len, loff_t i_size);
 		int (*write)(struct netfs_cache_resources *cres,
 			     loff_t start_pos,
 			     struct iov_iter *iter,
    indicating whether the termination is definitely happening in the caller's
    context.
+ * ``prepare_write()``
+   [Required] Called to adjust a write to the cache and check that there is
+   sufficient space in the cache.  The start and length values indicate the
+   size of the write that netfslib is proposing, and this can be adjusted by
+   the cache to respect DIO boundaries.  The file size is passed for
+   information.
  * ``write()``
    [Required] Called to write to the cache.  The start file offset is given
 there isn't a read request structure as well, such as writing dirty data to the
 cache.
+API Function Reference
+======================
 .. kernel-doc:: include/linux/netfs.h
+.. kernel-doc:: fs/netfs/read_helper.c

Documentation/locking/locktypes.rst+3−6

   spin_lock(&p->lock);
   p->count += this_cpu_read(var2);
-On a non-PREEMPT_RT kernel migrate_disable() maps to preempt_disable()
-which makes the above code fully equivalent. On a PREEMPT_RT kernel
 migrate_disable() ensures that the task is pinned on the current CPU which
 in turn guarantees that the per-CPU access to var1 and var2 are staying on
-the same CPU.
+the same CPU while the task remains preemptible.
 The migrate_disable() substitution is not valid for the following
 scenario::
     p = this_cpu_ptr(&var1);
     p->val = func2();
-While correct on a non-PREEMPT_RT kernel, this breaks on PREEMPT_RT because
+This breaks because migrate_disable() does not protect against reentrancy from
-here migrate_disable() does not protect against reentrancy from a
+a preempting task. A correct substitution for this case is::
-preempting task. A correct substitution for this case is::
   func()
   {

Documentation/process/changes.rst+11−0

@@ -35,6 +35,7 @@ GNU make 3.81 make --version · 34 unmodified lines
35	binutils 2.23 ld -v	35	binutils 2.23 ld -v
36	flex 2.5.35 flex --version	36	flex 2.5.35 flex --version
37	bison 2.0 bison --version	37	bison 2.0 bison --version
		38	pahole 1.16 pahole --version
38	util-linux 2.10o fdformat --version	39	util-linux 2.10o fdformat --version
39	kmod 13 depmod -V	40	kmod 13 depmod -V
40	e2fsprogs 1.41.4 e2fsck -V	41	e2fsprogs 1.41.4 e2fsck -V
@@ -108,6 +109,16 @@ Bison · 67 unmodified lines
108	Since Linux 4.16, the build system generates parsers	109	Since Linux 4.16, the build system generates parsers
109	during build. This requires bison 2.0 or later.	110	during build. This requires bison 2.0 or later.
110		111
		112	pahole:
		113	-------
		114
		115	Since Linux 5.2, if CONFIG_DEBUG_INFO_BTF is selected, the build system
		116	generates BTF (BPF Type Format) from DWARF in vmlinux, a bit later from kernel
		117	modules as well. This requires pahole v1.16 or later.
		118
		119	It is found in the 'dwarves' or 'pahole' distro packages or from
		120	https://fedorapeople.org/~acme/dwarves/.
		121
111	Perl	122	Perl
112	----	123	----
113		124

Documentation/process/submitting-patches.rst+2−1

@@ -14,7 +14,8 @@ works, see Documentation/process/development-process.rst. Also, read · 13 unmodified lines
14	Documentation/process/submit-checklist.rst	14	Documentation/process/submit-checklist.rst
15	for a list of items to check before submitting code. If you are submitting	15	for a list of items to check before submitting code. If you are submitting
16	a driver, also read Documentation/process/submitting-drivers.rst; for device	16	a driver, also read Documentation/process/submitting-drivers.rst; for device
17	tree binding patches, read Documentation/process/submitting-patches.rst.	17	tree binding patches, read
		18	Documentation/devicetree/bindings/submitting-patches.rst.
18		19
19	This documentation assumes that you're using ``git`` to prepare your patches.	20	This documentation assumes that you're using ``git`` to prepare your patches.
20	If you're unfamiliar with ``git``, you would be well-advised to learn how to	21	If you're unfamiliar with ``git``, you would be well-advised to learn how to

MAINTAINERS+22−7

 F:	drivers/iio/pressure/dps310.c
 INFINIBAND SUBSYSTEM
-M:	Doug Ledford <dledford@redhat.com>
 M:	Jason Gunthorpe <jgg@nvidia.com>
 L:	linux-rdma@vger.kernel.org
 S:	Supported
 F:	scripts/Makefile.kcsan
 KDUMP
-M:	Dave Young <dyoung@redhat.com>
 M:	Baoquan He <bhe@redhat.com>
 R:	Vivek Goyal <vgoyal@redhat.com>
+R:	Dave Young <dyoung@redhat.com>
 L:	kexec@lists.infradead.org
 S:	Maintained
 W:	http://lse.sourceforge.net/kdump/
 F:	include/linux/mlx5/mlx5_ifc_fpga.h
 MELLANOX ETHERNET SWITCH DRIVERS
-M:	Jiri Pirko <jiri@nvidia.com>
 M:	Ido Schimmel <idosch@nvidia.com>
+M:	Petr Machata <petrm@nvidia.com>
 L:	netdev@vger.kernel.org
 S:	Supported
 W:	http://www.mellanox.com
 F:	Documentation/devicetree/bindings/net/qcom,ethqos.txt
 F:	drivers/net/ethernet/stmicro/stmmac/dwmac-qcom-ethqos.c
+QUALCOMM FASTRPC DRIVER
+M:	Srinivas Kandagatla <srinivas.kandagatla@linaro.org>
+M:	Amol Maheshwari <amahesh@qti.qualcomm.com>
+L:	linux-arm-msm@vger.kernel.org
+S:	Maintained
+F:	Documentation/devicetree/bindings/misc/qcom,fastrpc.txt
+F:	drivers/misc/fastrpc.c
+F:	include/uapi/misc/fastrpc.h
 QUALCOMM GENERIC INTERFACE I2C DRIVER
 M:	Akash Asthana <akashast@codeaurora.org>
 M:	Mukesh Savaliya <msavaliy@codeaurora.org>
 RANDOM NUMBER DRIVER
 M:	"Theodore Ts'o" <tytso@mit.edu>
+M:	Jason A. Donenfeld <Jason@zx2c4.com>
 S:	Maintained
 F:	drivers/char/random.c
 F:	Documentation/devicetree/bindings/media/allwinner,sun8i-a83t-de2-rotate.yaml
 F:	drivers/media/platform/sunxi/sun8i-rotate/
+RPMSG TTY DRIVER
+M:	Arnaud Pouliquen <arnaud.pouliquen@foss.st.com>
+L:	linux-remoteproc@vger.kernel.org
+S:	Maintained
+F:	drivers/tty/rpmsg_tty.c
 RTL2830 MEDIA DRIVER
 M:	Antti Palosaari <crope@iki.fi>
 L:	linux-media@vger.kernel.org
 F:	drivers/iommu/s390-iommu.c
 S390 IUCV NETWORK LAYER
-M:	Julian Wiedmann <jwi@linux.ibm.com>
+M:	Alexandra Winter <wintera@linux.ibm.com>
-M:	Karsten Graul <kgraul@linux.ibm.com>
+M:	Wenjia Zhang <wenjia@linux.ibm.com>
 L:	linux-s390@vger.kernel.org
 L:	netdev@vger.kernel.org
 S:	Supported
 F:	net/iucv/
 S390 NETWORK DRIVERS
-M:	Julian Wiedmann <jwi@linux.ibm.com>
+M:	Alexandra Winter <wintera@linux.ibm.com>
-M:	Karsten Graul <kgraul@linux.ibm.com>
+M:	Wenjia Zhang <wenjia@linux.ibm.com>
 L:	linux-s390@vger.kernel.org
 L:	netdev@vger.kernel.org
 S:	Supported

Makefile+7−7

@@ -2,7 +2,7 @@ · 1 unmodified line
2	VERSION = 5	2	VERSION = 5
3	PATCHLEVEL = 16	3	PATCHLEVEL = 16
4	SUBLEVEL = 0	4	SUBLEVEL = 0
5	EXTRAVERSION = -rc3	5	EXTRAVERSION = -rc5
6	NAME = Gobble Gobble	6	NAME = Gobble Gobble
7		7
8	# DOCUMENTATION	8	# DOCUMENTATION
@@ -789,7 +789,7 @@ stackp-flags-$(CONFIG_STACKPROTECTOR_STRONG) := -fstack-protector-strong · 780 unmodified lines
789	KBUILD_CFLAGS += $(stackp-flags-y)	789	KBUILD_CFLAGS += $(stackp-flags-y)
790		790
791	KBUILD_CFLAGS-$(CONFIG_WERROR) += -Werror	791	KBUILD_CFLAGS-$(CONFIG_WERROR) += -Werror
792	KBUILD_CFLAGS += $(KBUILD_CFLAGS-y) $(CONFIG_CC_IMPLICIT_FALLTHROUGH)	792	KBUILD_CFLAGS += $(KBUILD_CFLAGS-y) $(CONFIG_CC_IMPLICIT_FALLTHROUGH:"%"=%)
793		793
794	ifdef CONFIG_CC_IS_CLANG	794	ifdef CONFIG_CC_IS_CLANG
795	KBUILD_CPPFLAGS += -Qunused-arguments	795	KBUILD_CPPFLAGS += -Qunused-arguments
@@ -1374,17 +1374,17 @@ endif · 578 unmodified lines
1374		1374
1375	ifneq ($(dtstree),)	1375	ifneq ($(dtstree),)
1376		1376
1377	%.dtb: dt_binding_check include/config/kernel.release scripts_dtc	1377	%.dtb: include/config/kernel.release scripts_dtc
1378	$(Q)$(MAKE) $(build)=$(dtstree) $(dtstree)/$@ $(dtstree)/$*.dt.yaml	1378	$(Q)$(MAKE) $(build)=$(dtstree) $(dtstree)/$@
1379		1379
1380	%.dtbo: dt_binding_check include/config/kernel.release scripts_dtc	1380	%.dtbo: include/config/kernel.release scripts_dtc
1381	$(Q)$(MAKE) $(build)=$(dtstree) $(dtstree)/$@ $(dtstree)/$*.dt.yaml	1381	$(Q)$(MAKE) $(build)=$(dtstree) $(dtstree)/$@
1382		1382
1383	PHONY += dtbs dtbs_install dtbs_check	1383	PHONY += dtbs dtbs_install dtbs_check
1384	dtbs: include/config/kernel.release scripts_dtc	1384	dtbs: include/config/kernel.release scripts_dtc
1385	$(Q)$(MAKE) $(build)=$(dtstree)	1385	$(Q)$(MAKE) $(build)=$(dtstree)
1386		1386
1387	ifneq ($(filter dtbs_check %.dtb %.dtbo, $(MAKECMDGOALS)),)	1387	ifneq ($(filter dtbs_check, $(MAKECMDGOALS)),)
1388	export CHECK_DTBS=y	1388	export CHECK_DTBS=y
1389	dtbs: dt_binding_check	1389	dtbs: dt_binding_check
1390	endif	1390	endif

arch/arm64/boot/dts/apple/t8103.dtsi+4−3

  * Copyright The Asahi Linux Contributors
  */
+#include <dt-bindings/gpio/gpio.h>
 #include <dt-bindings/interrupt-controller/apple-aic.h>
 #include <dt-bindings/interrupt-controller/irq.h>
 #include <dt-bindings/pinctrl/apple.h>
 			port00: pci@0,0 {
 				device_type = "pci";
 				reg = <0x0 0x0 0x0 0x0 0x0>;
-				reset-gpios = <&pinctrl_ap 152 0>;
+				reset-gpios = <&pinctrl_ap 152 GPIO_ACTIVE_LOW>;
 				max-link-speed = <2>;
 				#address-cells = <3>;
 			port01: pci@1,0 {
 				device_type = "pci";
 				reg = <0x800 0x0 0x0 0x0 0x0>;
-				reset-gpios = <&pinctrl_ap 153 0>;
+				reset-gpios = <&pinctrl_ap 153 GPIO_ACTIVE_LOW>;
 				max-link-speed = <2>;
 				#address-cells = <3>;
 			port02: pci@2,0 {
 				device_type = "pci";
 				reg = <0x1000 0x0 0x0 0x0 0x0>;
-				reset-gpios = <&pinctrl_ap 33 0>;
+				reset-gpios = <&pinctrl_ap 33 GPIO_ACTIVE_LOW>;
 				max-link-speed = <1>;
 				#address-cells = <3>;

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

@@ -91,7 +91,7 @@ · 90 unmodified lines
91	#define HCR_HOST_VHE_FLAGS (HCR_RW \| HCR_TGE \| HCR_E2H)	91	#define HCR_HOST_VHE_FLAGS (HCR_RW \| HCR_TGE \| HCR_E2H)
92		92
93	/* TCR_EL2 Registers bits */	93	/* TCR_EL2 Registers bits */
94	#define TCR_EL2_RES1 ((1 << 31) \| (1 << 23))	94	#define TCR_EL2_RES1 ((1U << 31) \| (1 << 23))
95	#define TCR_EL2_TBI (1 << 20)	95	#define TCR_EL2_TBI (1 << 20)
96	#define TCR_EL2_PS_SHIFT 16	96	#define TCR_EL2_PS_SHIFT 16
97	#define TCR_EL2_PS_MASK (7 << TCR_EL2_PS_SHIFT)	97	#define TCR_EL2_PS_MASK (7 << TCR_EL2_PS_SHIFT)
@@ -276,7 +276,7 @@ · 178 unmodified lines
276	#define CPTR_EL2_TFP_SHIFT 10	276	#define CPTR_EL2_TFP_SHIFT 10
277		277
278	/* Hyp Coprocessor Trap Register */	278	/* Hyp Coprocessor Trap Register */
279	#define CPTR_EL2_TCPAC (1 << 31)	279	#define CPTR_EL2_TCPAC (1U << 31)
280	#define CPTR_EL2_TAM (1 << 30)	280	#define CPTR_EL2_TAM (1 << 30)
281	#define CPTR_EL2_TTA (1 << 20)	281	#define CPTR_EL2_TTA (1 << 20)
282	#define CPTR_EL2_TFP (1 << CPTR_EL2_TFP_SHIFT)	282	#define CPTR_EL2_TFP (1 << CPTR_EL2_TFP_SHIFT)

arch/arm64/kernel/entry-ftrace.S+6−0

 	.endm
 SYM_CODE_START(ftrace_regs_caller)
+#ifdef BTI_C
+	BTI_C
+#endif
 	ftrace_regs_entry	1
 	b	ftrace_common
 SYM_CODE_END(ftrace_regs_caller)
 SYM_CODE_START(ftrace_caller)
+#ifdef BTI_C
+	BTI_C
+#endif
 	ftrace_regs_entry	0
 	b	ftrace_common
 SYM_CODE_END(ftrace_caller)

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

@@ -147,7 +147,7 @@ int machine_kexec_post_load(struct kimage *kimage) · 146 unmodified lines
147	if (rc)	147	if (rc)
148	return rc;	148	return rc;
149	kimage->arch.ttbr1 = __pa(trans_pgd);	149	kimage->arch.ttbr1 = __pa(trans_pgd);
150	kimage->arch.zero_page = __pa(empty_zero_page);	150	kimage->arch.zero_page = __pa_symbol(empty_zero_page);
151		151
152	reloc_size = __relocate_new_kernel_end - __relocate_new_kernel_start;	152	reloc_size = __relocate_new_kernel_end - __relocate_new_kernel_start;
153	memcpy(reloc_code, __relocate_new_kernel_start, reloc_size);	153	memcpy(reloc_code, __relocate_new_kernel_start, reloc_size);

arch/arm64/kvm/hyp/include/hyp/switch.h+14−0

@@ -403,6 +403,8 @@ typedef bool (exit_handler_fn)(struct kvm_vcpu , u64 *); · 402 unmodified lines
403		403
404	static const exit_handler_fn kvm_get_exit_handler_array(struct kvm_vcpu vcpu);	404	static const exit_handler_fn kvm_get_exit_handler_array(struct kvm_vcpu vcpu);
405		405
		406	static void early_exit_filter(struct kvm_vcpu vcpu, u64 exit_code);
		407
406	/*	408	/*
407	* Allow the hypervisor to handle the exit with an exit handler if it has one.	409	* Allow the hypervisor to handle the exit with an exit handler if it has one.
408	*	410	*
@@ -429,6 +431,18 @@ static inline bool kvm_hyp_handle_exit(struct kvm_vcpu vcpu, u64 exit_code) · 20 unmodified lines
429	*/	431	*/
430	static inline bool fixup_guest_exit(struct kvm_vcpu vcpu, u64 exit_code)	432	static inline bool fixup_guest_exit(struct kvm_vcpu vcpu, u64 exit_code)
431	{	433	{
		434	/*
		435	* Save PSTATE early so that we can evaluate the vcpu mode
		436	* early on.
		437	*/
		438	vcpu->arch.ctxt.regs.pstate = read_sysreg_el2(SYS_SPSR);
		439
		440	/*
		441	* Check whether we want to repaint the state one way or
		442	* another.
		443	*/
		444	early_exit_filter(vcpu, exit_code);
		445
432	if (ARM_EXCEPTION_CODE(*exit_code) != ARM_EXCEPTION_IRQ)	446	if (ARM_EXCEPTION_CODE(*exit_code) != ARM_EXCEPTION_IRQ)
433	vcpu->arch.fault.esr_el2 = read_sysreg_el2(SYS_ESR);	447	vcpu->arch.fault.esr_el2 = read_sysreg_el2(SYS_ESR);
434		448

arch/arm64/kvm/hyp/include/hyp/sysreg-sr.h+6−1

 static inline void __sysreg_save_el2_return_state(struct kvm_cpu_context *ctxt)
 {
 	ctxt->regs.pc			= read_sysreg_el2(SYS_ELR);
-	ctxt->regs.pstate		= read_sysreg_el2(SYS_SPSR);
+	/*
+	 * Guest PSTATE gets saved at guest fixup time in all
+	 * cases. We still need to handle the nVHE host side here.
+	 */
+	if (!has_vhe() && ctxt->__hyp_running_vcpu)
+		ctxt->regs.pstate	= read_sysreg_el2(SYS_SPSR);
 	if (cpus_have_final_cap(ARM64_HAS_RAS_EXTN))
 		ctxt_sys_reg(ctxt, DISR_EL1) = read_sysreg_s(SYS_VDISR_EL2);

arch/arm64/kvm/hyp/nvhe/switch.c+1−7

  * Returns false if the guest ran in AArch32 when it shouldn't have, and
  * thus should exit to the host, or true if a the guest run loop can continue.
  */
-static bool handle_aarch32_guest(struct kvm_vcpu *vcpu, u64 *exit_code)
+static void early_exit_filter(struct kvm_vcpu *vcpu, u64 *exit_code)
 {
 	struct kvm *kvm = kern_hyp_va(vcpu->kvm);
 		vcpu->arch.target = -1;
 		*exit_code &= BIT(ARM_EXIT_WITH_SERROR_BIT);
 		*exit_code |= ARM_EXCEPTION_IL;
-		return false;
 	}
-	return true;
 }
 /* Switch to the guest for legacy non-VHE systems */
 		/* Jump in the fire! */
 		exit_code = __guest_enter(vcpu);
-		if (unlikely(!handle_aarch32_guest(vcpu, &exit_code)))
-			break;
 		/* And we're baaack! */
 	} while (fixup_guest_exit(vcpu, &exit_code));

arch/arm64/kvm/hyp/vhe/switch.c+4−0

 	return hyp_exit_handlers;
 }
+static void early_exit_filter(struct kvm_vcpu *vcpu, u64 *exit_code)
+{
+}
 /* Switch to the guest for VHE systems running in EL2 */
 static int __kvm_vcpu_run_vhe(struct kvm_vcpu *vcpu)
 {

arch/csky/kernel/traps.c+2−2

@@ -209,7 +209,7 @@ asmlinkage void do_trap_illinsn(struct pt_regs *regs) · 208 unmodified lines
209		209
210	asmlinkage void do_trap_fpe(struct pt_regs *regs)	210	asmlinkage void do_trap_fpe(struct pt_regs *regs)
211	{	211	{
212	#ifdef CONFIG_CPU_HAS_FP	212	#ifdef CONFIG_CPU_HAS_FPU
213	return fpu_fpe(regs);	213	return fpu_fpe(regs);
214	#else	214	#else
215	do_trap_error(regs, SIGILL, ILL_ILLOPC, regs->pc,	215	do_trap_error(regs, SIGILL, ILL_ILLOPC, regs->pc,
@@ -219,7 +219,7 @@ asmlinkage void do_trap_fpe(struct pt_regs *regs) · 3 unmodified lines
219		219
220	asmlinkage void do_trap_priv(struct pt_regs *regs)	220	asmlinkage void do_trap_priv(struct pt_regs *regs)
221	{	221	{
222	#ifdef CONFIG_CPU_HAS_FP	222	#ifdef CONFIG_CPU_HAS_FPU
223	if (user_mode(regs) && fpu_libc_helper(regs))	223	if (user_mode(regs) && fpu_libc_helper(regs))
224	return;	224	return;
225	#endif	225	#endif

arch/mips/net/bpf_jit_comp.h+1−1

@@ -98,7 +98,7 @@ do { \ · 97 unmodified lines
98	#define emit(...) __emit(__VA_ARGS__)	98	#define emit(...) __emit(__VA_ARGS__)
99		99
100	/* Workaround for R10000 ll/sc errata */	100	/* Workaround for R10000 ll/sc errata */
101	#ifdef CONFIG_WAR_R10000	101	#ifdef CONFIG_WAR_R10000_LLSC
102	#define LLSC_beqz beqzl	102	#define LLSC_beqz beqzl
103	#else	103	#else
104	#define LLSC_beqz beqz	104	#define LLSC_beqz beqz

arch/parisc/Makefile+5−0

 # Mike Shaver, Helge Deller and Martin K. Petersen
 #
+ifdef CONFIG_PARISC_SELF_EXTRACT
+boot := arch/parisc/boot
+KBUILD_IMAGE := $(boot)/bzImage
+else
 KBUILD_IMAGE := vmlinuz
+endif
 NM		= sh $(srctree)/arch/parisc/nm
 CHECKFLAGS	+= -D__hppa__=1

arch/parisc/configs/generic-64bit_defconfig+13−1

 CONFIG_LOCALVERSION="-64bit"
 # CONFIG_LOCALVERSION_AUTO is not set
+CONFIG_KERNEL_LZ4=y
 CONFIG_SYSVIPC=y
 CONFIG_POSIX_MQUEUE=y
+CONFIG_AUDIT=y
 CONFIG_BSD_PROCESS_ACCT=y
 CONFIG_BSD_PROCESS_ACCT_V3=y
 CONFIG_TASKSTATS=y
 CONFIG_BLK_DEV_INTEGRITY=y
 CONFIG_BINFMT_MISC=m
 # CONFIG_COMPACTION is not set
+CONFIG_MEMORY_FAILURE=y
 CONFIG_NET=y
 CONFIG_PACKET=y
 CONFIG_UNIX=y
 CONFIG_SCSI_SRP_ATTRS=y
 CONFIG_ISCSI_BOOT_SYSFS=y
 CONFIG_SCSI_MPT2SAS=y
-CONFIG_SCSI_LASI700=m
+CONFIG_SCSI_LASI700=y
 CONFIG_SCSI_SYM53C8XX_2=y
 CONFIG_SCSI_ZALON=y
 CONFIG_SCSI_QLA_ISCSI=m
 CONFIG_SCSI_DH=y
 CONFIG_ATA=y
+CONFIG_SATA_SIL=y
+CONFIG_SATA_SIS=y
+CONFIG_SATA_VIA=y
 CONFIG_PATA_NS87415=y
 CONFIG_PATA_SIL680=y
 CONFIG_ATA_GENERIC=y
 CONFIG_BLK_DEV_DM=m
 CONFIG_DM_RAID=m
 CONFIG_DM_UEVENT=y
+CONFIG_DM_AUDIT=y
 CONFIG_FUSION=y
 CONFIG_FUSION_SPI=y
 CONFIG_FUSION_SAS=y
 CONFIG_FB_MATROX_I2C=y
 CONFIG_FB_MATROX_MAVEN=y
 CONFIG_FB_RADEON=y
+CONFIG_LOGO=y
+# CONFIG_LOGO_LINUX_CLUT224 is not set
 CONFIG_HIDRAW=y
 CONFIG_HID_PID=y
 CONFIG_USB_HIDDEV=y
 CONFIG_USB=y
+CONFIG_USB_EHCI_HCD=y
+CONFIG_USB_OHCI_HCD=y
+CONFIG_USB_OHCI_HCD_PLATFORM=y
 CONFIG_UIO=y
 CONFIG_UIO_PDRV_GENIRQ=m
 CONFIG_UIO_AEC=m

arch/parisc/install.sh+1−0

@@ -39,6 +39,7 @@ verify "$3" · 38 unmodified lines
39	if [ -n "${INSTALLKERNEL}" ]; then	39	if [ -n "${INSTALLKERNEL}" ]; then
40	if [ -x ~/bin/${INSTALLKERNEL} ]; then exec ~/bin/${INSTALLKERNEL} "$@"; fi	40	if [ -x ~/bin/${INSTALLKERNEL} ]; then exec ~/bin/${INSTALLKERNEL} "$@"; fi
41	if [ -x /sbin/${INSTALLKERNEL} ]; then exec /sbin/${INSTALLKERNEL} "$@"; fi	41	if [ -x /sbin/${INSTALLKERNEL} ]; then exec /sbin/${INSTALLKERNEL} "$@"; fi
		42	if [ -x /usr/sbin/${INSTALLKERNEL} ]; then exec /usr/sbin/${INSTALLKERNEL} "$@"; fi
42	fi	43	fi
43		44
44	# Default install	45	# Default install

arch/parisc/kernel/time.c+8−22

@@ -249,30 +249,16 @@ void __init time_init(void) · 248 unmodified lines
249	static int __init init_cr16_clocksource(void)	249	static int __init init_cr16_clocksource(void)
250	{	250	{
251	/*	251	/*
252	* The cr16 interval timers are not syncronized across CPUs on	252	* The cr16 interval timers are not syncronized across CPUs, even if
253	* different sockets, so mark them unstable and lower rating on	253	* they share the same socket.
254	* multi-socket SMP systems.
255	*/	254	*/
256	if (num_online_cpus() > 1 && !running_on_qemu) {	255	if (num_online_cpus() > 1 && !running_on_qemu) {
257	int cpu;	256	/* mark sched_clock unstable */
258	unsigned long cpu0_loc;	257	clear_sched_clock_stable();
259	cpu0_loc = per_cpu(cpu_data, 0).cpu_loc;	258
260		259	clocksource_cr16.name = "cr16_unstable";
261	for_each_online_cpu(cpu) {	260	clocksource_cr16.flags = CLOCK_SOURCE_UNSTABLE;
262	if (cpu == 0)	261	clocksource_cr16.rating = 0;
263	continue;
264	if ((cpu0_loc != 0) &&
265	(cpu0_loc == per_cpu(cpu_data, cpu).cpu_loc))
266	continue;
267
268	/* mark sched_clock unstable */
269	clear_sched_clock_stable();
270
271	clocksource_cr16.name = "cr16_unstable";
272	clocksource_cr16.flags = CLOCK_SOURCE_UNSTABLE;
273	clocksource_cr16.rating = 0;
274	break;
275	}
276	}	262	}
277		263
278	/* register at clocksource framework */	264	/* register at clocksource framework */

arch/riscv/include/asm/kvm_host.h+3−5

 #include <linux/types.h>
 #include <linux/kvm.h>
 #include <linux/kvm_types.h>
+#include <asm/csr.h>
 #include <asm/kvm_vcpu_fp.h>
 #include <asm/kvm_vcpu_timer.h>
-#ifdef CONFIG_64BIT
+#define KVM_MAX_VCPUS			\
-#define KVM_MAX_VCPUS			(1U << 16)
+	((HGATP_VMID_MASK >> HGATP_VMID_SHIFT) + 1)
-#else
-#define KVM_MAX_VCPUS			(1U << 9)
-#endif
 #define KVM_HALT_POLL_NS_DEFAULT	500000

arch/riscv/kvm/mmu.c+6−0

 void kvm_arch_flush_shadow_memslot(struct kvm *kvm,
 				   struct kvm_memory_slot *slot)
 {
+	gpa_t gpa = slot->base_gfn << PAGE_SHIFT;
+	phys_addr_t size = slot->npages << PAGE_SHIFT;
+	spin_lock(&kvm->mmu_lock);
+	stage2_unmap_range(kvm, gpa, size, false);
+	spin_unlock(&kvm->mmu_lock);
 }
 void kvm_arch_commit_memory_region(struct kvm *kvm,

arch/s390/configs/debug_defconfig+8−2

 CONFIG_CONNECTOR=y
 CONFIG_ZRAM=y
 CONFIG_BLK_DEV_LOOP=m
-CONFIG_BLK_DEV_CRYPTOLOOP=m
 CONFIG_BLK_DEV_DRBD=m
 CONFIG_BLK_DEV_NBD=m
 CONFIG_BLK_DEV_RAM=y
 CONFIG_MACVTAP=m
 CONFIG_VXLAN=m
 CONFIG_BAREUDP=m
+CONFIG_AMT=m
 CONFIG_TUN=m
 CONFIG_VETH=m
 CONFIG_VIRTIO_NET=m
 # CONFIG_NET_VENDOR_AMD is not set
 # CONFIG_NET_VENDOR_AQUANTIA is not set
 # CONFIG_NET_VENDOR_ARC is not set
+# CONFIG_NET_VENDOR_ASIX is not set
 # CONFIG_NET_VENDOR_ATHEROS is not set
 # CONFIG_NET_VENDOR_BROADCOM is not set
 # CONFIG_NET_VENDOR_BROCADE is not set
 CONFIG_WATCHDOG_NOWAYOUT=y
 CONFIG_SOFT_WATCHDOG=m
 CONFIG_DIAG288_WATCHDOG=m
+# CONFIG_DRM_DEBUG_MODESET_LOCK is not set
 CONFIG_FB=y
 CONFIG_FRAMEBUFFER_CONSOLE=y
 CONFIG_FRAMEBUFFER_CONSOLE_DETECT_PRIMARY=y
 CONFIG_CRC7=m
 CONFIG_CRC8=m
 CONFIG_RANDOM32_SELFTEST=y
+CONFIG_XZ_DEC_MICROLZMA=y
 CONFIG_DMA_CMA=y
 CONFIG_CMA_SIZE_MBYTES=0
 CONFIG_PRINTK_TIME=y
 CONFIG_DYNAMIC_DEBUG=y
 CONFIG_DEBUG_INFO=y
 CONFIG_DEBUG_INFO_DWARF4=y
+CONFIG_DEBUG_INFO_BTF=y
 CONFIG_GDB_SCRIPTS=y
 CONFIG_HEADERS_INSTALL=y
 CONFIG_DEBUG_SECTION_MISMATCH=y
 CONFIG_MEMORY_NOTIFIER_ERROR_INJECT=m
 CONFIG_DEBUG_PER_CPU_MAPS=y
 CONFIG_KFENCE=y
+CONFIG_KFENCE_STATIC_KEYS=y
 CONFIG_DEBUG_SHIRQ=y
 CONFIG_PANIC_ON_OOPS=y
 CONFIG_DETECT_HUNG_TASK=y
 CONFIG_SAMPLES=y
 CONFIG_SAMPLE_TRACE_PRINTK=m
 CONFIG_SAMPLE_FTRACE_DIRECT=m
+CONFIG_SAMPLE_FTRACE_DIRECT_MULTI=m
 CONFIG_DEBUG_ENTRY=y
 CONFIG_CIO_INJECT=y
 CONFIG_KUNIT=m
 CONFIG_FAULT_INJECTION_STACKTRACE_FILTER=y
 CONFIG_LKDTM=m
 CONFIG_TEST_MIN_HEAP=y
-CONFIG_KPROBES_SANITY_TEST=y
+CONFIG_KPROBES_SANITY_TEST=m
 CONFIG_RBTREE_TEST=y
 CONFIG_INTERVAL_TREE_TEST=m
 CONFIG_PERCPU_TEST=m

arch/s390/configs/defconfig+6−1

 CONFIG_CONNECTOR=y
 CONFIG_ZRAM=y
 CONFIG_BLK_DEV_LOOP=m
-CONFIG_BLK_DEV_CRYPTOLOOP=m
 CONFIG_BLK_DEV_DRBD=m
 CONFIG_BLK_DEV_NBD=m
 CONFIG_BLK_DEV_RAM=y
 CONFIG_MACVTAP=m
 CONFIG_VXLAN=m
 CONFIG_BAREUDP=m
+CONFIG_AMT=m
 CONFIG_TUN=m
 CONFIG_VETH=m
 CONFIG_VIRTIO_NET=m
 # CONFIG_NET_VENDOR_AMD is not set
 # CONFIG_NET_VENDOR_AQUANTIA is not set
 # CONFIG_NET_VENDOR_ARC is not set
+# CONFIG_NET_VENDOR_ASIX is not set
 # CONFIG_NET_VENDOR_ATHEROS is not set
 # CONFIG_NET_VENDOR_BROADCOM is not set
 # CONFIG_NET_VENDOR_BROCADE is not set
 CONFIG_CRC4=m
 CONFIG_CRC7=m
 CONFIG_CRC8=m
+CONFIG_XZ_DEC_MICROLZMA=y
 CONFIG_DMA_CMA=y
 CONFIG_CMA_SIZE_MBYTES=0
 CONFIG_PRINTK_TIME=y
 CONFIG_DYNAMIC_DEBUG=y
 CONFIG_DEBUG_INFO=y
 CONFIG_DEBUG_INFO_DWARF4=y
+CONFIG_DEBUG_INFO_BTF=y
 CONFIG_GDB_SCRIPTS=y
 CONFIG_DEBUG_SECTION_MISMATCH=y
 CONFIG_MAGIC_SYSRQ=y
 CONFIG_SAMPLES=y
 CONFIG_SAMPLE_TRACE_PRINTK=m
 CONFIG_SAMPLE_FTRACE_DIRECT=m
+CONFIG_SAMPLE_FTRACE_DIRECT_MULTI=m
 CONFIG_KUNIT=m
 CONFIG_KUNIT_DEBUGFS=y
 CONFIG_LKDTM=m
+CONFIG_KPROBES_SANITY_TEST=m
 CONFIG_PERCPU_TEST=m
 CONFIG_ATOMIC64_SELFTEST=y
 CONFIG_TEST_BPF=m

arch/s390/configs/zfcpdump_defconfig+2−0

 # CONFIG_NETWORK_FILESYSTEMS is not set
 CONFIG_LSM="yama,loadpin,safesetid,integrity"
 # CONFIG_ZLIB_DFLTCC is not set
+CONFIG_XZ_DEC_MICROLZMA=y
 CONFIG_PRINTK_TIME=y
 # CONFIG_SYMBOLIC_ERRNAME is not set
 CONFIG_DEBUG_INFO=y
+CONFIG_DEBUG_INFO_BTF=y
 CONFIG_DEBUG_FS=y
 CONFIG_DEBUG_KERNEL=y
 CONFIG_PANIC_ON_OOPS=y

arch/s390/include/asm/pci_io.h+4−3

 /* I/O Map */
 #define ZPCI_IOMAP_SHIFT		48
-#define ZPCI_IOMAP_ADDR_BASE		0x8000000000000000UL
+#define ZPCI_IOMAP_ADDR_SHIFT		62
+#define ZPCI_IOMAP_ADDR_BASE		(1UL << ZPCI_IOMAP_ADDR_SHIFT)
 #define ZPCI_IOMAP_ADDR_OFF_MASK	((1UL << ZPCI_IOMAP_SHIFT) - 1)
 #define ZPCI_IOMAP_MAX_ENTRIES							\
-	((ULONG_MAX - ZPCI_IOMAP_ADDR_BASE + 1) / (1UL << ZPCI_IOMAP_SHIFT))
+	(1UL << (ZPCI_IOMAP_ADDR_SHIFT - ZPCI_IOMAP_SHIFT))
 #define ZPCI_IOMAP_ADDR_IDX_MASK						\
-	(~ZPCI_IOMAP_ADDR_OFF_MASK - ZPCI_IOMAP_ADDR_BASE)
+	((ZPCI_IOMAP_ADDR_BASE - 1) & ~ZPCI_IOMAP_ADDR_OFF_MASK)
 struct zpci_iomap_entry {
 	u32 fh;

arch/s390/lib/test_unwind.c+3−2

 		}
 		/*
-		 * trigger specification exception
+		 * Trigger operation exception; use insn notation to bypass
+		 * llvm's integrated assembler sanity checks.
 		 */
 		asm volatile(
-			"	mvcl	%%r1,%%r1\n"
+			"	.insn	e,0x0000\n"	/* illegal opcode */
 			"0:	nopr	%%r7\n"
 			EX_TABLE(0b, 0b)
 			:);

arch/x86/Kconfig+1−0

@@ -1932,6 +1932,7 @@ config EFI · 1931 unmodified lines
1932	depends on ACPI	1932	depends on ACPI
1933	select UCS2_STRING	1933	select UCS2_STRING
1934	select EFI_RUNTIME_WRAPPERS	1934	select EFI_RUNTIME_WRAPPERS
		1935	select ARCH_USE_MEMREMAP_PROT
1935	help	1936	help
1936	This enables the kernel to use EFI runtime services that are	1937	This enables the kernel to use EFI runtime services that are
1937	available (such as the EFI variable services).	1938	available (such as the EFI variable services).

arch/x86/entry/entry_64.S+17−18

@@ -574,6 +574,10 @@ SYM_INNER_LABEL(swapgs_restore_regs_and_return_to_usermode, SYM_L_GLOBAL) · 573 unmodified lines
574	ud2	574	ud2
575	1:	575	1:
576	#endif	576	#endif
		577	#ifdef CONFIG_XEN_PV
		578	ALTERNATIVE "", "jmp xenpv_restore_regs_and_return_to_usermode", X86_FEATURE_XENPV
		579	#endif
		580
577	POP_REGS pop_rdi=0	581	POP_REGS pop_rdi=0
578		582
579	/*	583	/*
@@ -890,6 +894,7 @@ SYM_CODE_START_LOCAL(paranoid_entry) · 310 unmodified lines
890	.Lparanoid_entry_checkgs:	894	.Lparanoid_entry_checkgs:
891	/* EBX = 1 -> kernel GSBASE active, no restore required */	895	/* EBX = 1 -> kernel GSBASE active, no restore required */
892	movl $1, %ebx	896	movl $1, %ebx
		897
893	/*	898	/*
894	* The kernel-enforced convention is a negative GSBASE indicates	899	* The kernel-enforced convention is a negative GSBASE indicates
895	* a kernel value. No SWAPGS needed on entry and exit.	900	* a kernel value. No SWAPGS needed on entry and exit.
@@ -897,21 +902,14 @@ SYM_CODE_START_LOCAL(paranoid_entry) · 1 unmodified line
897	movl $MSR_GS_BASE, %ecx	902	movl $MSR_GS_BASE, %ecx
898	rdmsr	903	rdmsr
899	testl %edx, %edx	904	testl %edx, %edx
900	jns .Lparanoid_entry_swapgs	905	js .Lparanoid_kernel_gsbase
901	ret
902		906
903	.Lparanoid_entry_swapgs:	907	/* EBX = 0 -> SWAPGS required on exit */
		908	xorl %ebx, %ebx
904	swapgs	909	swapgs
		910	.Lparanoid_kernel_gsbase:
905		911
906	/*
907	* The above SAVE_AND_SWITCH_TO_KERNEL_CR3 macro doesn't do an
908	* unconditional CR3 write, even in the PTI case. So do an lfence
909	* to prevent GS speculation, regardless of whether PTI is enabled.
910	*/
911	FENCE_SWAPGS_KERNEL_ENTRY	912	FENCE_SWAPGS_KERNEL_ENTRY
912
913	/* EBX = 0 -> SWAPGS required on exit */
914	xorl %ebx, %ebx
915	ret	913	ret
916	SYM_CODE_END(paranoid_entry)	914	SYM_CODE_END(paranoid_entry)
917		915
@@ -993,11 +991,6 @@ SYM_CODE_START_LOCAL(error_entry) · 75 unmodified lines
993	pushq %r12	991	pushq %r12
994	ret	992	ret
995		993
996	.Lerror_entry_done_lfence:
997	FENCE_SWAPGS_KERNEL_ENTRY
998	.Lerror_entry_done:
999	ret
1000
1001	/*	994	/*
1002	* There are two places in the kernel that can potentially fault with	995	* There are two places in the kernel that can potentially fault with
1003	* usergs. Handle them here. B stepping K8s sometimes report a	996	* usergs. Handle them here. B stepping K8s sometimes report a
@@ -1020,8 +1013,14 @@ SYM_CODE_START_LOCAL(error_entry) · 16 unmodified lines
1020	* .Lgs_change's error handler with kernel gsbase.	1013	* .Lgs_change's error handler with kernel gsbase.
1021	*/	1014	*/
1022	SWAPGS	1015	SWAPGS
1023	FENCE_SWAPGS_USER_ENTRY	1016
1024	jmp .Lerror_entry_done	1017	/*
		1018	* Issue an LFENCE to prevent GS speculation, regardless of whether it is a
		1019	* kernel or user gsbase.
		1020	*/
		1021	.Lerror_entry_done_lfence:
		1022	FENCE_SWAPGS_KERNEL_ENTRY
		1023	ret
1025		1024
1026	.Lbstep_iret:	1025	.Lbstep_iret:
1027	/* Fix truncated RIP */	1026	/* Fix truncated RIP */

arch/x86/include/asm/intel-family.h+1−1

@@ -108,7 +108,7 @@ · 107 unmodified lines
108	#define INTEL_FAM6_ALDERLAKE 0x97 /* Golden Cove / Gracemont */	108	#define INTEL_FAM6_ALDERLAKE 0x97 /* Golden Cove / Gracemont */
109	#define INTEL_FAM6_ALDERLAKE_L 0x9A /* Golden Cove / Gracemont */	109	#define INTEL_FAM6_ALDERLAKE_L 0x9A /* Golden Cove / Gracemont */
110		110
111	#define INTEL_FAM6_RAPTOR_LAKE 0xB7	111	#define INTEL_FAM6_RAPTORLAKE 0xB7
112		112
113	/* "Small Core" Processors (Atom) */	113	/* "Small Core" Processors (Atom) */
114		114

arch/x86/include/asm/kvm_host.h+2−1

 	KVM_ARCH_REQ_FLAGS(25, KVM_REQUEST_WAIT | KVM_REQUEST_NO_WAKEUP)
 #define KVM_REQ_TLB_FLUSH_CURRENT	KVM_ARCH_REQ(26)
 #define KVM_REQ_TLB_FLUSH_GUEST \
-	KVM_ARCH_REQ_FLAGS(27, KVM_REQUEST_NO_WAKEUP)
+	KVM_ARCH_REQ_FLAGS(27, KVM_REQUEST_WAIT | KVM_REQUEST_NO_WAKEUP)
 #define KVM_REQ_APF_READY		KVM_ARCH_REQ(28)
 #define KVM_REQ_MSR_FILTER_CHANGED	KVM_ARCH_REQ(29)
 #define KVM_REQ_UPDATE_CPU_DIRTY_LOGGING \
 #define APICV_INHIBIT_REASON_PIT_REINJ  4
 #define APICV_INHIBIT_REASON_X2APIC	5
 #define APICV_INHIBIT_REASON_BLOCKIRQ	6
+#define APICV_INHIBIT_REASON_ABSENT	7
 struct kvm_arch {
 	unsigned long n_used_mmu_pages;

arch/x86/include/asm/sev-common.h+11−0

@@ -73,4 +73,15 @@ · 72 unmodified lines
73		73
74	#define GHCB_RESP_CODE(v) ((v) & GHCB_MSR_INFO_MASK)	74	#define GHCB_RESP_CODE(v) ((v) & GHCB_MSR_INFO_MASK)
75		75
		76	/*
		77	* Error codes related to GHCB input that can be communicated back to the guest
		78	* by setting the lower 32-bits of the GHCB SW_EXITINFO1 field to 2.
		79	*/
		80	#define GHCB_ERR_NOT_REGISTERED 1
		81	#define GHCB_ERR_INVALID_USAGE 2
		82	#define GHCB_ERR_INVALID_SCRATCH_AREA 3
		83	#define GHCB_ERR_MISSING_INPUT 4
		84	#define GHCB_ERR_INVALID_INPUT 5
		85	#define GHCB_ERR_INVALID_EVENT 6
		86
76	#endif	87	#endif

arch/x86/kernel/fpu/signal.c+1−1

@@ -118,7 +118,7 @@ static inline bool save_xstate_epilog(void __user *buf, int ia32_frame, · 117 unmodified lines
118	struct fpstate *fpstate)	118	struct fpstate *fpstate)
119	{	119	{
120	struct xregs_state __user *x = buf;	120	struct xregs_state __user *x = buf;
121	struct _fpx_sw_bytes sw_bytes;	121	struct _fpx_sw_bytes sw_bytes = {};
122	u32 xfeatures;	122	u32 xfeatures;
123	int err;	123	int err;
124		124

arch/x86/kernel/sev.c+39−18

 				   char *dst, char *buf, size_t size)
 {
 	unsigned long error_code = X86_PF_PROT | X86_PF_WRITE;
-	char __user *target = (char __user *)dst;
-	u64 d8;
-	u32 d4;
-	u16 d2;
-	u8  d1;
 	/*
 	 * This function uses __put_user() independent of whether kernel or user
 	 * instructions here would cause infinite nesting.
 	 */
 	switch (size) {
-	case 1:
+	case 1: {
+		u8 d1;
+		u8 __user *target = (u8 __user *)dst;
 		memcpy(&d1, buf, 1);
 		if (__put_user(d1, target))
 			goto fault;
 		break;
-	case 2:
+	}
+	case 2: {
+		u16 d2;
+		u16 __user *target = (u16 __user *)dst;
 		memcpy(&d2, buf, 2);
 		if (__put_user(d2, target))
 			goto fault;
 		break;
-	case 4:
+	}
+	case 4: {
+		u32 d4;
+		u32 __user *target = (u32 __user *)dst;
 		memcpy(&d4, buf, 4);
 		if (__put_user(d4, target))
 			goto fault;
 		break;
-	case 8:
+	}
+	case 8: {
+		u64 d8;
+		u64 __user *target = (u64 __user *)dst;
 		memcpy(&d8, buf, 8);
 		if (__put_user(d8, target))
 			goto fault;
 		break;
+	}
 	default:
 		WARN_ONCE(1, "%s: Invalid size: %zu\n", __func__, size);
 		return ES_UNSUPPORTED;
 				  char *src, char *buf, size_t size)
 {
 	unsigned long error_code = X86_PF_PROT;
-	char __user *s = (char __user *)src;
-	u64 d8;
-	u32 d4;
-	u16 d2;
-	u8  d1;
 	/*
 	 * This function uses __get_user() independent of whether kernel or user
 	 * instructions here would cause infinite nesting.
 	 */
 	switch (size) {
-	case 1:
+	case 1: {
+		u8 d1;
+		u8 __user *s = (u8 __user *)src;
 		if (__get_user(d1, s))
 			goto fault;
 		memcpy(buf, &d1, 1);
 		break;
-	case 2:
+	}
+	case 2: {
+		u16 d2;
+		u16 __user *s = (u16 __user *)src;
 		if (__get_user(d2, s))
 			goto fault;
 		memcpy(buf, &d2, 2);
 		break;
-	case 4:
+	}
+	case 4: {
+		u32 d4;
+		u32 __user *s = (u32 __user *)src;
 		if (__get_user(d4, s))
 			goto fault;
 		memcpy(buf, &d4, 4);
 		break;
-	case 8:
+	}
+	case 8: {
+		u64 d8;
+		u64 __user *s = (u64 __user *)src;
 		if (__get_user(d8, s))
 			goto fault;
 		memcpy(buf, &d8, 8);
 		break;
+	}
 	default:
 		WARN_ONCE(1, "%s: Invalid size: %zu\n", __func__, size);
 		return ES_UNSUPPORTED;

arch/x86/kernel/smpboot.c+14−0

 	{ NULL, },
 };
+static struct sched_domain_topology_level x86_hybrid_topology[] = {
+#ifdef CONFIG_SCHED_SMT
+	{ cpu_smt_mask, x86_smt_flags, SD_INIT_NAME(SMT) },
+#endif
+#ifdef CONFIG_SCHED_MC
+	{ cpu_coregroup_mask, x86_core_flags, SD_INIT_NAME(MC) },
+#endif
+	{ cpu_cpu_mask, SD_INIT_NAME(DIE) },
+	{ NULL, },
+};
 static struct sched_domain_topology_level x86_topology[] = {
 #ifdef CONFIG_SCHED_SMT
 	{ cpu_smt_mask, x86_smt_flags, SD_INIT_NAME(SMT) },
 	calculate_max_logical_packages();
+	/* XXX for now assume numa-in-package and hybrid don't overlap */
 	if (x86_has_numa_in_package)
 		set_sched_topology(x86_numa_in_package_topology);
+	if (cpu_feature_enabled(X86_FEATURE_HYBRID_CPU))
+		set_sched_topology(x86_hybrid_topology);
 	nmi_selftest();
 	impress_friends();

arch/x86/kernel/tsc.c+24−4

 EXPORT_SYMBOL_GPL(mark_tsc_unstable);
+static void __init tsc_disable_clocksource_watchdog(void)
+{
+	clocksource_tsc_early.flags &= ~CLOCK_SOURCE_MUST_VERIFY;
+	clocksource_tsc.flags &= ~CLOCK_SOURCE_MUST_VERIFY;
+}
 static void __init check_system_tsc_reliable(void)
 {
 #if defined(CONFIG_MGEODEGX1) || defined(CONFIG_MGEODE_LX) || defined(CONFIG_X86_GENERIC)
 #endif
 	if (boot_cpu_has(X86_FEATURE_TSC_RELIABLE))
 		tsc_clocksource_reliable = 1;
+	/*
+	 * Disable the clocksource watchdog when the system has:
+	 *  - TSC running at constant frequency
+	 *  - TSC which does not stop in C-States
+	 *  - the TSC_ADJUST register which allows to detect even minimal
+	 *    modifications
+	 *  - not more than two sockets. As the number of sockets cannot be
+	 *    evaluated at the early boot stage where this has to be
+	 *    invoked, check the number of online memory nodes as a
+	 *    fallback solution which is an reasonable estimate.
+	 */
+	if (boot_cpu_has(X86_FEATURE_CONSTANT_TSC) &&
+	    boot_cpu_has(X86_FEATURE_NONSTOP_TSC) &&
+	    boot_cpu_has(X86_FEATURE_TSC_ADJUST) &&
+	    nr_online_nodes <= 2)
+		tsc_disable_clocksource_watchdog();
 }
 /*
 	if (tsc_unstable)
 		goto unreg;
-	if (tsc_clocksource_reliable || no_tsc_watchdog)
-		clocksource_tsc.flags &= ~CLOCK_SOURCE_MUST_VERIFY;
 	if (boot_cpu_has(X86_FEATURE_NONSTOP_TSC_S3))
 		clocksource_tsc.flags |= CLOCK_SOURCE_SUSPEND_NONSTOP;
 	}
 	if (tsc_clocksource_reliable || no_tsc_watchdog)
-		clocksource_tsc_early.flags &= ~CLOCK_SOURCE_MUST_VERIFY;
+		tsc_disable_clocksource_watchdog();
 	clocksource_register_khz(&clocksource_tsc_early, tsc_khz);
 	detect_art();

arch/x86/kernel/tsc_sync.c+41−0

@@ -30,6 +30,7 @@ struct tsc_adjust { · 29 unmodified lines
30	};	30	};
31		31
32	static DEFINE_PER_CPU(struct tsc_adjust, tsc_adjust);	32	static DEFINE_PER_CPU(struct tsc_adjust, tsc_adjust);
		33	static struct timer_list tsc_sync_check_timer;
33		34
34	/*	35	/*
35	* TSC's on different sockets may be reset asynchronously.	36	* TSC's on different sockets may be reset asynchronously.
@@ -77,6 +78,46 @@ void tsc_verify_tsc_adjust(bool resume) · 41 unmodified lines
77	}	78	}
78	}	79	}
79		80
		81	/*
		82	* Normally the tsc_sync will be checked every time system enters idle
		83	* state, but there is still caveat that a system won't enter idle,
		84	* either because it's too busy or configured purposely to not enter
		85	* idle.
		86	*
		87	* So setup a periodic timer (every 10 minutes) to make sure the check
		88	* is always on.
		89	*/
		90
		91	#define SYNC_CHECK_INTERVAL (HZ * 600)
		92
		93	static void tsc_sync_check_timer_fn(struct timer_list *unused)
		94	{
		95	int next_cpu;
		96
		97	tsc_verify_tsc_adjust(false);
		98
		99	/* Run the check for all onlined CPUs in turn */
		100	next_cpu = cpumask_next(raw_smp_processor_id(), cpu_online_mask);
		101	if (next_cpu >= nr_cpu_ids)
		102	next_cpu = cpumask_first(cpu_online_mask);
		103
		104	tsc_sync_check_timer.expires += SYNC_CHECK_INTERVAL;
		105	add_timer_on(&tsc_sync_check_timer, next_cpu);
		106	}
		107
		108	static int __init start_sync_check_timer(void)
		109	{
		110	if (!cpu_feature_enabled(X86_FEATURE_TSC_ADJUST) \|\| tsc_clocksource_reliable)
		111	return 0;
		112
		113	timer_setup(&tsc_sync_check_timer, tsc_sync_check_timer_fn, 0);
		114	tsc_sync_check_timer.expires = jiffies + SYNC_CHECK_INTERVAL;
		115	add_timer(&tsc_sync_check_timer);
		116
		117	return 0;
		118	}
		119	late_initcall(start_sync_check_timer);
		120
80	static void tsc_sanitize_first_cpu(struct tsc_adjust *cur, s64 bootval,	121	static void tsc_sanitize_first_cpu(struct tsc_adjust *cur, s64 bootval,
81	unsigned int cpu, bool bootcpu)	122	unsigned int cpu, bool bootcpu)
82	{	123	{

arch/x86/kvm/hyperv.c+5−2

 		all_cpus = send_ipi_ex.vp_set.format == HV_GENERIC_SET_ALL;
+		if (all_cpus)
+			goto check_and_send_ipi;
 		if (!sparse_banks_len)
 			goto ret_success;
-		if (!all_cpus &&
+		if (kvm_read_guest(kvm,
-		    kvm_read_guest(kvm,
 				   hc->ingpa + offsetof(struct hv_send_ipi_ex,
 							vp_set.bank_contents),
 				   sparse_banks,
 			return HV_STATUS_INVALID_HYPERCALL_INPUT;
 	}
+check_and_send_ipi:
 	if ((vector < HV_IPI_LOW_VECTOR) || (vector > HV_IPI_HIGH_VECTOR))
 		return HV_STATUS_INVALID_HYPERCALL_INPUT;

arch/x86/kvm/ioapic.h+0−1

@@ -81,7 +81,6 @@ struct kvm_ioapic { · 80 unmodified lines
81	unsigned long irq_states[IOAPIC_NUM_PINS];	81	unsigned long irq_states[IOAPIC_NUM_PINS];
82	struct kvm_io_device dev;	82	struct kvm_io_device dev;
83	struct kvm *kvm;	83	struct kvm *kvm;
84	void (ack_notifier)(void opaque, int irq);
85	spinlock_t lock;	84	spinlock_t lock;
86	struct rtc_status rtc_status;	85	struct rtc_status rtc_status;
87	struct delayed_work eoi_inject;	86	struct delayed_work eoi_inject;

arch/x86/kvm/irq.h+0−1

@@ -56,7 +56,6 @@ struct kvm_pic { · 55 unmodified lines
56	struct kvm_io_device dev_master;	56	struct kvm_io_device dev_master;
57	struct kvm_io_device dev_slave;	57	struct kvm_io_device dev_slave;
58	struct kvm_io_device dev_elcr;	58	struct kvm_io_device dev_elcr;
59	void (ack_notifier)(void opaque, int irq);
60	unsigned long irq_states[PIC_NUM_PINS];	59	unsigned long irq_states[PIC_NUM_PINS];
61	};	60	};
62		61

arch/x86/kvm/lapic.c+1−1

@@ -707,7 +707,7 @@ static void pv_eoi_clr_pending(struct kvm_vcpu *vcpu) · 706 unmodified lines
707	static int apic_has_interrupt_for_ppr(struct kvm_lapic *apic, u32 ppr)	707	static int apic_has_interrupt_for_ppr(struct kvm_lapic *apic, u32 ppr)
708	{	708	{
709	int highest_irr;	709	int highest_irr;
710	if (apic->vcpu->arch.apicv_active)	710	if (kvm_x86_ops.sync_pir_to_irr)
711	highest_irr = static_call(kvm_x86_sync_pir_to_irr)(apic->vcpu);	711	highest_irr = static_call(kvm_x86_sync_pir_to_irr)(apic->vcpu);
712	else	712	else
713	highest_irr = apic_find_highest_irr(apic);	713	highest_irr = apic_find_highest_irr(apic);

arch/x86/kvm/mmu/mmu.c+73−47

 		flush = kvm_handle_gfn_range(kvm, range, kvm_unmap_rmapp);
 	if (is_tdp_mmu_enabled(kvm))
-		flush |= kvm_tdp_mmu_unmap_gfn_range(kvm, range, flush);
+		flush = kvm_tdp_mmu_unmap_gfn_range(kvm, range, flush);
 	return flush;
 }
 static bool is_obsolete_sp(struct kvm *kvm, struct kvm_mmu_page *sp)
 {
-	return sp->role.invalid ||
+	if (sp->role.invalid)
+		return true;
+	/* TDP MMU pages due not use the MMU generation. */
+	return !sp->tdp_mmu_page &&
 	       unlikely(sp->mmu_valid_gen != kvm->arch.mmu_valid_gen);
 }
 	iterator->shadow_addr = root;
 	iterator->level = vcpu->arch.mmu->shadow_root_level;
-	if (iterator->level == PT64_ROOT_4LEVEL &&
+	if (iterator->level >= PT64_ROOT_4LEVEL &&
 	    vcpu->arch.mmu->root_level < PT64_ROOT_4LEVEL &&
 	    !vcpu->arch.mmu->direct_map)
-		--iterator->level;
+		iterator->level = PT32E_ROOT_LEVEL;
 	if (iterator->level == PT32E_ROOT_LEVEL) {
 		/*
 	return true;
 }
+/*
+ * Returns true if the page fault is stale and needs to be retried, i.e. if the
+ * root was invalidated by a memslot update or a relevant mmu_notifier fired.
+ */
+static bool is_page_fault_stale(struct kvm_vcpu *vcpu,
+				struct kvm_page_fault *fault, int mmu_seq)
+{
+	if (is_obsolete_sp(vcpu->kvm, to_shadow_page(vcpu->arch.mmu->root_hpa)))
+		return true;
+	return fault->slot &&
+	       mmu_notifier_retry_hva(vcpu->kvm, mmu_seq, fault->hva);
+}
 static int direct_page_fault(struct kvm_vcpu *vcpu, struct kvm_page_fault *fault)
 {
 	bool is_tdp_mmu_fault = is_tdp_mmu(vcpu->arch.mmu);
 	else
 		write_lock(&vcpu->kvm->mmu_lock);
-	if (fault->slot && mmu_notifier_retry_hva(vcpu->kvm, mmu_seq, fault->hva))
+	if (is_page_fault_stale(vcpu, fault, mmu_seq))
 		goto out_unlock;
 	r = make_mmu_pages_available(vcpu);
 	if (r)
 		goto out_unlock;
 	struct kvm_mmu *context = &vcpu->arch.guest_mmu;
 	struct kvm_mmu_role_regs regs = {
 		.cr0 = cr0,
-		.cr4 = cr4,
+		.cr4 = cr4 & ~X86_CR4_PKE,
 		.efer = efer,
 	};
 	union kvm_mmu_role new_role;
 	context->direct_map = false;
 	update_permission_bitmask(context, true);
-	update_pkru_bitmask(context);
+	context->pkru_mask = 0;
 	reset_rsvds_bits_mask_ept(vcpu, context, execonly);
 	reset_ept_shadow_zero_bits_mask(vcpu, context, execonly);
 }
 	/*
 	 * Invalidate all MMU roles to force them to reinitialize as CPUID
 	 * information is factored into reserved bit calculations.
+	 *
+	 * Correctly handling multiple vCPU models with respect to paging and
+	 * physical address properties) in a single VM would require tracking
+	 * all relevant CPUID information in kvm_mmu_page_role. That is very
+	 * undesirable as it would increase the memory requirements for
+	 * gfn_track (see struct kvm_mmu_page_role comments).  For now that
+	 * problem is swept under the rug; KVM's CPUID API is horrific and
+	 * it's all but impossible to solve it without introducing a new API.
 	 */
 	vcpu->arch.root_mmu.mmu_role.ext.valid = 0;
 	vcpu->arch.guest_mmu.mmu_role.ext.valid = 0;
 	kvm_mmu_reset_context(vcpu);
 	/*
-	 * KVM does not correctly handle changing guest CPUID after KVM_RUN, as
+	 * Changing guest CPUID after KVM_RUN is forbidden, see the comment in
-	 * MAXPHYADDR, GBPAGES support, AMD reserved bit behavior, etc.. aren't
+	 * kvm_arch_vcpu_ioctl().
-	 * tracked in kvm_mmu_page_role.  As a result, KVM may miss guest page
-	 * faults due to reusing SPs/SPTEs.  Alert userspace, but otherwise
-	 * sweep the problem under the rug.
-	 *
-	 * KVM's horrific CPUID ABI makes the problem all but impossible to
-	 * solve, as correctly handling multiple vCPU models (with respect to
-	 * paging and physical address properties) in a single VM would require
-	 * tracking all relevant CPUID information in kvm_mmu_page_role.  That
-	 * is very undesirable as it would double the memory requirements for
-	 * gfn_track (see struct kvm_mmu_page_role comments), and in practice
-	 * no sane VMM mucks with the core vCPU model on the fly.
 	 */
-	if (vcpu->arch.last_vmentry_cpu != -1) {
+	KVM_BUG_ON(vcpu->arch.last_vmentry_cpu != -1, vcpu->kvm);
-		pr_warn_ratelimited("KVM: KVM_SET_CPUID{,2} after KVM_RUN may cause guest instability\n");
-		pr_warn_ratelimited("KVM: KVM_SET_CPUID{,2} will fail after KVM_RUN starting with Linux 5.16\n");
-	}
 }
 void kvm_mmu_reset_context(struct kvm_vcpu *vcpu)
 void kvm_mmu_invlpg(struct kvm_vcpu *vcpu, gva_t gva)
 {
-	kvm_mmu_invalidate_gva(vcpu, vcpu->arch.mmu, gva, INVALID_PAGE);
+	kvm_mmu_invalidate_gva(vcpu, vcpu->arch.walk_mmu, gva, INVALID_PAGE);
 	++vcpu->stat.invlpg;
 }
 EXPORT_SYMBOL_GPL(kvm_mmu_invlpg);
 void kvm_mmu_zap_collapsible_sptes(struct kvm *kvm,
 				   const struct kvm_memory_slot *slot)
 {
-	bool flush = false;
 	if (kvm_memslots_have_rmaps(kvm)) {
 		write_lock(&kvm->mmu_lock);
 		/*
 		 * logging at a 4k granularity and never creates collapsible
 		 * 2m SPTEs during dirty logging.
 		 */
-		flush = slot_handle_level_4k(kvm, slot, kvm_mmu_zap_collapsible_spte, true);
+		if (slot_handle_level_4k(kvm, slot, kvm_mmu_zap_collapsible_spte, true))
-		if (flush)
 			kvm_arch_flush_remote_tlbs_memslot(kvm, slot);
 		write_unlock(&kvm->mmu_lock);
 	}
 	if (is_tdp_mmu_enabled(kvm)) {
 		read_lock(&kvm->mmu_lock);
-		flush = kvm_tdp_mmu_zap_collapsible_sptes(kvm, slot, flush);
+		kvm_tdp_mmu_zap_collapsible_sptes(kvm, slot);
-		if (flush)
-			kvm_arch_flush_remote_tlbs_memslot(kvm, slot);
 		read_unlock(&kvm->mmu_lock);
 	}
 }
 	mmu_audit_disable();
 }
+/*
+ * Calculate the effective recovery period, accounting for '0' meaning "let KVM
+ * select a halving time of 1 hour".  Returns true if recovery is enabled.
+ */
+static bool calc_nx_huge_pages_recovery_period(uint *period)
+{
+	/*
+	 * Use READ_ONCE to get the params, this may be called outside of the
+	 * param setters, e.g. by the kthread to compute its next timeout.
+	 */
+	bool enabled = READ_ONCE(nx_huge_pages);
+	uint ratio = READ_ONCE(nx_huge_pages_recovery_ratio);
+	if (!enabled || !ratio)
+		return false;
+	*period = READ_ONCE(nx_huge_pages_recovery_period_ms);
+	if (!*period) {
+		/* Make sure the period is not less than one second.  */
+		ratio = min(ratio, 3600u);
+		*period = 60 * 60 * 1000 / ratio;
+	}
+	return true;
+}
 static int set_nx_huge_pages_recovery_param(const char *val, const struct kernel_param *kp)
 {
 	bool was_recovery_enabled, is_recovery_enabled;
 	uint old_period, new_period;
 	int err;
-	was_recovery_enabled = nx_huge_pages_recovery_ratio;
+	was_recovery_enabled = calc_nx_huge_pages_recovery_period(&old_period);
-	old_period = nx_huge_pages_recovery_period_ms;
 	err = param_set_uint(val, kp);
 	if (err)
 		return err;
-	is_recovery_enabled = nx_huge_pages_recovery_ratio;
+	is_recovery_enabled = calc_nx_huge_pages_recovery_period(&new_period);
-	new_period = nx_huge_pages_recovery_period_ms;
-	if (READ_ONCE(nx_huge_pages) && is_recovery_enabled &&
+	if (is_recovery_enabled &&
 	    (!was_recovery_enabled || old_period > new_period)) {
 		struct kvm *kvm;
 static long get_nx_lpage_recovery_timeout(u64 start_time)
 {
-	uint ratio = READ_ONCE(nx_huge_pages_recovery_ratio);
+	bool enabled;
-	uint period = READ_ONCE(nx_huge_pages_recovery_period_ms);
+	uint period;
-	if (!period && ratio) {
+	enabled = calc_nx_huge_pages_recovery_period(&period);
-		/* Make sure the period is not less than one second.  */
-		ratio = min(ratio, 3600u);
-		period = 60 * 60 * 1000 / ratio;
-	}
-	return READ_ONCE(nx_huge_pages) && ratio
+	return enabled ? start_time + msecs_to_jiffies(period) - get_jiffies_64()
-		? start_time + msecs_to_jiffies(period) - get_jiffies_64()
+		       : MAX_SCHEDULE_TIMEOUT;
-		: MAX_SCHEDULE_TIMEOUT;
 }
 static int kvm_nx_lpage_recovery_worker(struct kvm *kvm, uintptr_t data)

arch/x86/kvm/mmu/paging_tmpl.h+2−1

@@ -911,7 +911,8 @@ static int FNAME(page_fault)(struct kvm_vcpu vcpu, struct kvm_page_fault fault · 910 unmodified lines
911		911
912	r = RET_PF_RETRY;	912	r = RET_PF_RETRY;
913	write_lock(&vcpu->kvm->mmu_lock);	913	write_lock(&vcpu->kvm->mmu_lock);
914	if (fault->slot && mmu_notifier_retry_hva(vcpu->kvm, mmu_seq, fault->hva))	914
		915	if (is_page_fault_stale(vcpu, fault, mmu_seq))
915	goto out_unlock;	916	goto out_unlock;
916		917
917	kvm_mmu_audit(vcpu, AUDIT_PRE_PAGE_FAULT);	918	kvm_mmu_audit(vcpu, AUDIT_PRE_PAGE_FAULT);

arch/x86/kvm/mmu/tdp_mmu.c+14−24

 	struct kvm_mmu_page *sp = sptep_to_sp(rcu_dereference(pt));
 	int level = sp->role.level;
 	gfn_t base_gfn = sp->gfn;
-	u64 old_child_spte;
-	u64 *sptep;
-	gfn_t gfn;
 	int i;
 	trace_kvm_mmu_prepare_zap_page(sp);
 	tdp_mmu_unlink_page(kvm, sp, shared);
 	for (i = 0; i < PT64_ENT_PER_PAGE; i++) {
-		sptep = rcu_dereference(pt) + i;
+		u64 *sptep = rcu_dereference(pt) + i;
-		gfn = base_gfn + i * KVM_PAGES_PER_HPAGE(level);
+		gfn_t gfn = base_gfn + i * KVM_PAGES_PER_HPAGE(level);
+		u64 old_child_spte;
 		if (shared) {
 			/*
 				    shared);
 	}
-	kvm_flush_remote_tlbs_with_address(kvm, gfn,
+	kvm_flush_remote_tlbs_with_address(kvm, base_gfn,
 					   KVM_PAGES_PER_HPAGE(level + 1));
 	call_rcu(&sp->rcu_head, tdp_mmu_free_sp_rcu_callback);
 {
 	struct kvm_mmu_page *root;
-	for_each_tdp_mmu_root(kvm, root, range->slot->as_id)
+	for_each_tdp_mmu_root_yield_safe(kvm, root, range->slot->as_id, false)
-		flush |= zap_gfn_range(kvm, root, range->start, range->end,
+		flush = zap_gfn_range(kvm, root, range->start, range->end,
-				       range->may_block, flush, false);
+				      range->may_block, flush, false);
 	return flush;
 }
  * Clear leaf entries which could be replaced by large mappings, for
  * GFNs within the slot.
  */
-static bool zap_collapsible_spte_range(struct kvm *kvm,
+static void zap_collapsible_spte_range(struct kvm *kvm,
 				       struct kvm_mmu_page *root,
-				       const struct kvm_memory_slot *slot,
+				       const struct kvm_memory_slot *slot)
-				       bool flush)
 {
 	gfn_t start = slot->base_gfn;
 	gfn_t end = start + slot->npages;
 	tdp_root_for_each_pte(iter, root, start, end) {
 retry:
-		if (tdp_mmu_iter_cond_resched(kvm, &iter, flush, true)) {
+		if (tdp_mmu_iter_cond_resched(kvm, &iter, false, true))
-			flush = false;
 			continue;
-		}
 		if (!is_shadow_present_pte(iter.old_spte) ||
 		    !is_last_spte(iter.old_spte, iter.level))
 							    pfn, PG_LEVEL_NUM))
 			continue;
+		/* Note, a successful atomic zap also does a remote TLB flush. */
 		if (!tdp_mmu_zap_spte_atomic(kvm, &iter)) {
 			/*
 			 * The iter must explicitly re-read the SPTE because
 			iter.old_spte = READ_ONCE(*rcu_dereference(iter.sptep));
 			goto retry;
 		}
-		flush = true;
 	}
 	rcu_read_unlock();
-	return flush;
 }
 /*
  * Clear non-leaf entries (and free associated page tables) which could
  * be replaced by large mappings, for GFNs within the slot.
  */
-bool kvm_tdp_mmu_zap_collapsible_sptes(struct kvm *kvm,
+void kvm_tdp_mmu_zap_collapsible_sptes(struct kvm *kvm,
-				       const struct kvm_memory_slot *slot,
+				       const struct kvm_memory_slot *slot)
-				       bool flush)
 {
 	struct kvm_mmu_page *root;
 	lockdep_assert_held_read(&kvm->mmu_lock);
 	for_each_tdp_mmu_root_yield_safe(kvm, root, slot->as_id, true)
-		flush = zap_collapsible_spte_range(kvm, root, slot, flush);
+		zap_collapsible_spte_range(kvm, root, slot);
-	return flush;
 }
 /*

arch/x86/kvm/mmu/tdp_mmu.h+2−3

 				       struct kvm_memory_slot *slot,
 				       gfn_t gfn, unsigned long mask,
 				       bool wrprot);
-bool kvm_tdp_mmu_zap_collapsible_sptes(struct kvm *kvm,
+void kvm_tdp_mmu_zap_collapsible_sptes(struct kvm *kvm,
-				       const struct kvm_memory_slot *slot,
+				       const struct kvm_memory_slot *slot);
-				       bool flush);
 bool kvm_tdp_mmu_write_protect_gfn(struct kvm *kvm,
 				   struct kvm_memory_slot *slot, gfn_t gfn,

arch/x86/kvm/svm/avic.c+10−7

@@ -900,6 +900,7 @@ out: · 899 unmodified lines
900	bool svm_check_apicv_inhibit_reasons(ulong bit)	900	bool svm_check_apicv_inhibit_reasons(ulong bit)
901	{	901	{
902	ulong supported = BIT(APICV_INHIBIT_REASON_DISABLE) \|	902	ulong supported = BIT(APICV_INHIBIT_REASON_DISABLE) \|
		903	BIT(APICV_INHIBIT_REASON_ABSENT) \|
903	BIT(APICV_INHIBIT_REASON_HYPERV) \|	904	BIT(APICV_INHIBIT_REASON_HYPERV) \|
904	BIT(APICV_INHIBIT_REASON_NESTED) \|	905	BIT(APICV_INHIBIT_REASON_NESTED) \|
905	BIT(APICV_INHIBIT_REASON_IRQWIN) \|	906	BIT(APICV_INHIBIT_REASON_IRQWIN) \|
@@ -989,16 +990,18 @@ void avic_vcpu_put(struct kvm_vcpu *vcpu) · 83 unmodified lines
989	static void avic_set_running(struct kvm_vcpu *vcpu, bool is_run)	990	static void avic_set_running(struct kvm_vcpu *vcpu, bool is_run)
990	{	991	{
991	struct vcpu_svm *svm = to_svm(vcpu);	992	struct vcpu_svm *svm = to_svm(vcpu);
		993	int cpu = get_cpu();
992		994
		995	WARN_ON(cpu != vcpu->cpu);
993	svm->avic_is_running = is_run;	996	svm->avic_is_running = is_run;
994		997
995	if (!kvm_vcpu_apicv_active(vcpu))	998	if (kvm_vcpu_apicv_active(vcpu)) {
996	return;	999	if (is_run)
997		1000	avic_vcpu_load(vcpu, cpu);
998	if (is_run)	1001	else
999	avic_vcpu_load(vcpu, vcpu->cpu);	1002	avic_vcpu_put(vcpu);
1000	else	1003	}
1001	avic_vcpu_put(vcpu);	1004	put_cpu();
1002	}	1005	}
1003		1006
1004	void svm_vcpu_blocking(struct kvm_vcpu *vcpu)	1007	void svm_vcpu_blocking(struct kvm_vcpu *vcpu)

arch/x86/kvm/svm/pmu.c+1−1

@@ -281,7 +281,7 @@ static void amd_pmu_refresh(struct kvm_vcpu *vcpu) · 280 unmodified lines
281	pmu->nr_arch_gp_counters = AMD64_NUM_COUNTERS;	281	pmu->nr_arch_gp_counters = AMD64_NUM_COUNTERS;
282		282
283	pmu->counter_bitmask[KVM_PMC_GP] = ((u64)1 << 48) - 1;	283	pmu->counter_bitmask[KVM_PMC_GP] = ((u64)1 << 48) - 1;
284	pmu->reserved_bits = 0xffffffff00200000ull;	284	pmu->reserved_bits = 0xfffffff000280000ull;
285	pmu->version = 1;	285	pmu->version = 1;
286	/* not applicable to AMD; but clean them to prevent any fall out */	286	/* not applicable to AMD; but clean them to prevent any fall out */
287	pmu->counter_bitmask[KVM_PMC_FIXED] = 0;	287	pmu->counter_bitmask[KVM_PMC_FIXED] = 0;

arch/x86/kvm/svm/sev.c+146−117

@@ -1543,28 +1543,50 @@ static bool is_cmd_allowed_from_mirror(u32 cmd_id) · 1542 unmodified lines
1543	return false;	1543	return false;
1544	}	1544	}
1545		1545
1546	static int sev_lock_for_migration(struct kvm *kvm)	1546	static int sev_lock_two_vms(struct kvm dst_kvm, struct kvm src_kvm)
1547	{	1547	{
1548	struct kvm_sev_info *sev = &to_kvm_svm(kvm)->sev_info;	1548	struct kvm_sev_info *dst_sev = &to_kvm_svm(dst_kvm)->sev_info;
		1549	struct kvm_sev_info *src_sev = &to_kvm_svm(src_kvm)->sev_info;
		1550	int r = -EBUSY;
		1551
		1552	if (dst_kvm == src_kvm)
		1553	return -EINVAL;
1549		1554
1550	/*	1555	/*
1551	* Bail if this VM is already involved in a migration to avoid deadlock	1556	* Bail if these VMs are already involved in a migration to avoid
1552	* between two VMs trying to migrate to/from each other.	1557	* deadlock between two VMs trying to migrate to/from each other.
1553	*/	1558	*/
1554	if (atomic_cmpxchg_acquire(&sev->migration_in_progress, 0, 1))	1559	if (atomic_cmpxchg_acquire(&dst_sev->migration_in_progress, 0, 1))
1555	return -EBUSY;	1560	return -EBUSY;
1556		1561
1557	mutex_lock(&kvm->lock);	1562	if (atomic_cmpxchg_acquire(&src_sev->migration_in_progress, 0, 1))
		1563	goto release_dst;
1558		1564
		1565	r = -EINTR;
		1566	if (mutex_lock_killable(&dst_kvm->lock))
		1567	goto release_src;
		1568	if (mutex_lock_killable(&src_kvm->lock))
		1569	goto unlock_dst;
1559	return 0;	1570	return 0;
		1571
		1572	unlock_dst:
		1573	mutex_unlock(&dst_kvm->lock);
		1574	release_src:
		1575	atomic_set_release(&src_sev->migration_in_progress, 0);
		1576	release_dst:
		1577	atomic_set_release(&dst_sev->migration_in_progress, 0);
		1578	return r;
1560	}	1579	}
1561		1580
1562	static void sev_unlock_after_migration(struct kvm *kvm)	1581	static void sev_unlock_two_vms(struct kvm dst_kvm, struct kvm src_kvm)
1563	{	1582	{
1564	struct kvm_sev_info *sev = &to_kvm_svm(kvm)->sev_info;	1583	struct kvm_sev_info *dst_sev = &to_kvm_svm(dst_kvm)->sev_info;
		1584	struct kvm_sev_info *src_sev = &to_kvm_svm(src_kvm)->sev_info;
1565		1585
1566	mutex_unlock(&kvm->lock);	1586	mutex_unlock(&dst_kvm->lock);
1567	atomic_set_release(&sev->migration_in_progress, 0);	1587	mutex_unlock(&src_kvm->lock);
		1588	atomic_set_release(&dst_sev->migration_in_progress, 0);
		1589	atomic_set_release(&src_sev->migration_in_progress, 0);
1568	}	1590	}
1569		1591
1570		1592
@@ -1607,14 +1629,15 @@ static void sev_migrate_from(struct kvm_sev_info *dst, · 36 unmodified lines
1607	dst->asid = src->asid;	1629	dst->asid = src->asid;
1608	dst->handle = src->handle;	1630	dst->handle = src->handle;
1609	dst->pages_locked = src->pages_locked;	1631	dst->pages_locked = src->pages_locked;
		1632	dst->enc_context_owner = src->enc_context_owner;
1610		1633
1611	src->asid = 0;	1634	src->asid = 0;
1612	src->active = false;	1635	src->active = false;
1613	src->handle = 0;	1636	src->handle = 0;
1614	src->pages_locked = 0;	1637	src->pages_locked = 0;
		1638	src->enc_context_owner = NULL;
1615		1639
1616	INIT_LIST_HEAD(&dst->regions_list);	1640	list_cut_before(&dst->regions_list, &src->regions_list, &src->regions_list);
1617	list_replace_init(&src->regions_list, &dst->regions_list);
1618	}	1641	}
1619		1642
1620	static int sev_es_migrate_from(struct kvm dst, struct kvm src)	1643	static int sev_es_migrate_from(struct kvm dst, struct kvm src)
@@ -1666,15 +1689,6 @@ int svm_vm_migrate_from(struct kvm *kvm, unsigned int source_fd) · 45 unmodified lines
1666	bool charged = false;	1689	bool charged = false;
1667	int ret;	1690	int ret;
1668		1691
1669	ret = sev_lock_for_migration(kvm);
1670	if (ret)
1671	return ret;
1672
1673	if (sev_guest(kvm)) {
1674	ret = -EINVAL;
1675	goto out_unlock;
1676	}
1677
1678	source_kvm_file = fget(source_fd);	1692	source_kvm_file = fget(source_fd);
1679	if (!file_is_kvm(source_kvm_file)) {	1693	if (!file_is_kvm(source_kvm_file)) {
1680	ret = -EBADF;	1694	ret = -EBADF;
@@ -1682,16 +1696,26 @@ int svm_vm_migrate_from(struct kvm *kvm, unsigned int source_fd) · 1 unmodified line
1682	}	1696	}
1683		1697
1684	source_kvm = source_kvm_file->private_data;	1698	source_kvm = source_kvm_file->private_data;
1685	ret = sev_lock_for_migration(source_kvm);	1699	ret = sev_lock_two_vms(kvm, source_kvm);
1686	if (ret)	1700	if (ret)
1687	goto out_fput;	1701	goto out_fput;
1688		1702
1689	if (!sev_guest(source_kvm)) {	1703	if (sev_guest(kvm) \|\| !sev_guest(source_kvm)) {
1690	ret = -EINVAL;	1704	ret = -EINVAL;
1691	goto out_source;	1705	goto out_unlock;
1692	}	1706	}
1693		1707
1694	src_sev = &to_kvm_svm(source_kvm)->sev_info;	1708	src_sev = &to_kvm_svm(source_kvm)->sev_info;
		1709
		1710	/*
		1711	* VMs mirroring src's encryption context rely on it to keep the
		1712	* ASID allocated, but below we are clearing src_sev->asid.
		1713	*/
		1714	if (src_sev->num_mirrored_vms) {
		1715	ret = -EBUSY;
		1716	goto out_unlock;
		1717	}
		1718
1695	dst_sev->misc_cg = get_current_misc_cg();	1719	dst_sev->misc_cg = get_current_misc_cg();
1696	cg_cleanup_sev = dst_sev;	1720	cg_cleanup_sev = dst_sev;
1697	if (dst_sev->misc_cg != src_sev->misc_cg) {	1721	if (dst_sev->misc_cg != src_sev->misc_cg) {
@@ -1728,13 +1752,11 @@ out_dst_cgroup: · 30 unmodified lines
1728	sev_misc_cg_uncharge(cg_cleanup_sev);	1752	sev_misc_cg_uncharge(cg_cleanup_sev);
1729	put_misc_cg(cg_cleanup_sev->misc_cg);	1753	put_misc_cg(cg_cleanup_sev->misc_cg);
1730	cg_cleanup_sev->misc_cg = NULL;	1754	cg_cleanup_sev->misc_cg = NULL;
1731	out_source:	1755	out_unlock:
1732	sev_unlock_after_migration(source_kvm);	1756	sev_unlock_two_vms(kvm, source_kvm);
1733	out_fput:	1757	out_fput:
1734	if (source_kvm_file)	1758	if (source_kvm_file)
1735	fput(source_kvm_file);	1759	fput(source_kvm_file);
1736	out_unlock:
1737	sev_unlock_after_migration(kvm);
1738	return ret;	1760	return ret;
1739	}	1761	}
1740		1762
@@ -1953,76 +1975,60 @@ int svm_vm_copy_asid_from(struct kvm *kvm, unsigned int source_fd) · 212 unmodified lines
1953	{	1975	{
1954	struct file *source_kvm_file;	1976	struct file *source_kvm_file;
1955	struct kvm *source_kvm;	1977	struct kvm *source_kvm;
1956	struct kvm_sev_info source_sev, *mirror_sev;	1978	struct kvm_sev_info source_sev, mirror_sev;
1957	int ret;	1979	int ret;
1958		1980
1959	source_kvm_file = fget(source_fd);	1981	source_kvm_file = fget(source_fd);
1960	if (!file_is_kvm(source_kvm_file)) {	1982	if (!file_is_kvm(source_kvm_file)) {
1961	ret = -EBADF;	1983	ret = -EBADF;
1962	goto e_source_put;	1984	goto e_source_fput;
1963	}	1985	}
1964		1986
1965	source_kvm = source_kvm_file->private_data;	1987	source_kvm = source_kvm_file->private_data;
1966	mutex_lock(&source_kvm->lock);	1988	ret = sev_lock_two_vms(kvm, source_kvm);
1967		1989	if (ret)
1968	if (!sev_guest(source_kvm)) {	1990	goto e_source_fput;
1969	ret = -EINVAL;
1970	goto e_source_unlock;
1971	}
1972		1991
1973	/* Mirrors of mirrors should work, but let's not get silly */	1992	/*
1974	if (is_mirroring_enc_context(source_kvm) \|\| source_kvm == kvm) {	1993	* Mirrors of mirrors should work, but let's not get silly. Also
		1994	* disallow out-of-band SEV/SEV-ES init if the target is already an
		1995	* SEV guest, or if vCPUs have been created. KVM relies on vCPUs being
		1996	* created after SEV/SEV-ES initialization, e.g. to init intercepts.
		1997	*/
		1998	if (sev_guest(kvm) \|\| !sev_guest(source_kvm) \|\|
		1999	is_mirroring_enc_context(source_kvm) \|\| kvm->created_vcpus) {
1975	ret = -EINVAL;	2000	ret = -EINVAL;
1976	goto e_source_unlock;	2001	goto e_unlock;
1977	}	2002	}
1978		2003
1979	memcpy(&source_sev, &to_kvm_svm(source_kvm)->sev_info,
1980	sizeof(source_sev));
1981
1982	/*	2004	/*
1983	* The mirror kvm holds an enc_context_owner ref so its asid can't	2005	* The mirror kvm holds an enc_context_owner ref so its asid can't
1984	* disappear until we're done with it	2006	* disappear until we're done with it
1985	*/	2007	*/
		2008	source_sev = &to_kvm_svm(source_kvm)->sev_info;
1986	kvm_get_kvm(source_kvm);	2009	kvm_get_kvm(source_kvm);
1987		2010	source_sev->num_mirrored_vms++;
1988	fput(source_kvm_file);
1989	mutex_unlock(&source_kvm->lock);
1990	mutex_lock(&kvm->lock);
1991
1992	/*
1993	* Disallow out-of-band SEV/SEV-ES init if the target is already an
1994	* SEV guest, or if vCPUs have been created. KVM relies on vCPUs being
1995	* created after SEV/SEV-ES initialization, e.g. to init intercepts.
1996	*/
1997	if (sev_guest(kvm) \|\| kvm->created_vcpus) {
1998	ret = -EINVAL;
1999	goto e_mirror_unlock;
2000	}
2001		2011
2002	/* Set enc_context_owner and copy its encryption context over */	2012	/* Set enc_context_owner and copy its encryption context over */
2003	mirror_sev = &to_kvm_svm(kvm)->sev_info;	2013	mirror_sev = &to_kvm_svm(kvm)->sev_info;
2004	mirror_sev->enc_context_owner = source_kvm;	2014	mirror_sev->enc_context_owner = source_kvm;
2005	mirror_sev->active = true;	2015	mirror_sev->active = true;
2006	mirror_sev->asid = source_sev.asid;	2016	mirror_sev->asid = source_sev->asid;
2007	mirror_sev->fd = source_sev.fd;	2017	mirror_sev->fd = source_sev->fd;
2008	mirror_sev->es_active = source_sev.es_active;	2018	mirror_sev->es_active = source_sev->es_active;
2009	mirror_sev->handle = source_sev.handle;	2019	mirror_sev->handle = source_sev->handle;
		2020	INIT_LIST_HEAD(&mirror_sev->regions_list);
		2021	ret = 0;
		2022
2010	/*	2023	/*
2011	* Do not copy ap_jump_table. Since the mirror does not share the same	2024	* Do not copy ap_jump_table. Since the mirror does not share the same
2012	* KVM contexts as the original, and they may have different	2025	* KVM contexts as the original, and they may have different
2013	* memory-views.	2026	* memory-views.
2014	*/	2027	*/
2015		2028
2016	mutex_unlock(&kvm->lock);	2029	e_unlock:
2017	return 0;	2030	sev_unlock_two_vms(kvm, source_kvm);
2018		2031	e_source_fput:
2019	e_mirror_unlock:
2020	mutex_unlock(&kvm->lock);
2021	kvm_put_kvm(source_kvm);
2022	return ret;
2023	e_source_unlock:
2024	mutex_unlock(&source_kvm->lock);
2025	e_source_put:
2026	if (source_kvm_file)	2032	if (source_kvm_file)
2027	fput(source_kvm_file);	2033	fput(source_kvm_file);
2028	return ret;	2034	return ret;
@@ -2034,17 +2040,24 @@ void sev_vm_destroy(struct kvm *kvm) · 5 unmodified lines
2034	struct list_head *head = &sev->regions_list;	2040	struct list_head *head = &sev->regions_list;
2035	struct list_head pos, q;	2041	struct list_head pos, q;
2036		2042
		2043	WARN_ON(sev->num_mirrored_vms);
		2044
2037	if (!sev_guest(kvm))	2045	if (!sev_guest(kvm))
2038	return;	2046	return;
2039		2047
2040	/* If this is a mirror_kvm release the enc_context_owner and skip sev cleanup */	2048	/* If this is a mirror_kvm release the enc_context_owner and skip sev cleanup */
2041	if (is_mirroring_enc_context(kvm)) {	2049	if (is_mirroring_enc_context(kvm)) {
2042	kvm_put_kvm(sev->enc_context_owner);	2050	struct kvm *owner_kvm = sev->enc_context_owner;
		2051	struct kvm_sev_info *owner_sev = &to_kvm_svm(owner_kvm)->sev_info;
		2052
		2053	mutex_lock(&owner_kvm->lock);
		2054	if (!WARN_ON(!owner_sev->num_mirrored_vms))
		2055	owner_sev->num_mirrored_vms--;
		2056	mutex_unlock(&owner_kvm->lock);
		2057	kvm_put_kvm(owner_kvm);
2043	return;	2058	return;
2044	}	2059	}
2045		2060
2046	mutex_lock(&kvm->lock);
2047
2048	/*	2061	/*
2049	* Ensure that all guest tagged cache entries are flushed before	2062	* Ensure that all guest tagged cache entries are flushed before
2050	* releasing the pages back to the system for use. CLFLUSH will	2063	* releasing the pages back to the system for use. CLFLUSH will
@@ -2064,8 +2077,6 @@ void sev_vm_destroy(struct kvm *kvm) · 13 unmodified lines
2064	}	2077	}
2065	}	2078	}
2066		2079
2067	mutex_unlock(&kvm->lock);
2068
2069	sev_unbind_asid(kvm, sev->handle);	2080	sev_unbind_asid(kvm, sev->handle);
2070	sev_asid_free(sev);	2081	sev_asid_free(sev);
2071	}	2082	}
@@ -2249,7 +2260,7 @@ void sev_free_vcpu(struct kvm_vcpu *vcpu) · 177 unmodified lines
2249	__free_page(virt_to_page(svm->sev_es.vmsa));	2260	__free_page(virt_to_page(svm->sev_es.vmsa));
2250		2261
2251	if (svm->sev_es.ghcb_sa_free)	2262	if (svm->sev_es.ghcb_sa_free)
2252	kfree(svm->sev_es.ghcb_sa);	2263	kvfree(svm->sev_es.ghcb_sa);
2253	}	2264	}
2254		2265
2255	static void dump_ghcb(struct vcpu_svm *svm)	2266	static void dump_ghcb(struct vcpu_svm *svm)
@@ -2341,24 +2352,29 @@ static void sev_es_sync_from_ghcb(struct vcpu_svm *svm) · 85 unmodified lines
2341	memset(ghcb->save.valid_bitmap, 0, sizeof(ghcb->save.valid_bitmap));	2352	memset(ghcb->save.valid_bitmap, 0, sizeof(ghcb->save.valid_bitmap));
2342	}	2353	}
2343		2354
2344	static int sev_es_validate_vmgexit(struct vcpu_svm *svm)	2355	static bool sev_es_validate_vmgexit(struct vcpu_svm *svm)
2345	{	2356	{
2346	struct kvm_vcpu *vcpu;	2357	struct kvm_vcpu *vcpu;
2347	struct ghcb *ghcb;	2358	struct ghcb *ghcb;
2348	u64 exit_code = 0;	2359	u64 exit_code;
		2360	u64 reason;
2349		2361
2350	ghcb = svm->sev_es.ghcb;	2362	ghcb = svm->sev_es.ghcb;
2351		2363
2352	/* Only GHCB Usage code 0 is supported */
2353	if (ghcb->ghcb_usage)
2354	goto vmgexit_err;
2355
2356	/*	2364	/*
2357	* Retrieve the exit code now even though is may not be marked valid	2365	* Retrieve the exit code now even though it may not be marked valid
2358	* as it could help with debugging.	2366	* as it could help with debugging.
2359	*/	2367	*/
2360	exit_code = ghcb_get_sw_exit_code(ghcb);	2368	exit_code = ghcb_get_sw_exit_code(ghcb);
2361		2369
		2370	/* Only GHCB Usage code 0 is supported */
		2371	if (ghcb->ghcb_usage) {
		2372	reason = GHCB_ERR_INVALID_USAGE;
		2373	goto vmgexit_err;
		2374	}
		2375
		2376	reason = GHCB_ERR_MISSING_INPUT;
		2377
2362	if (!ghcb_sw_exit_code_is_valid(ghcb) \|\|	2378	if (!ghcb_sw_exit_code_is_valid(ghcb) \|\|
2363	!ghcb_sw_exit_info_1_is_valid(ghcb) \|\|	2379	!ghcb_sw_exit_info_1_is_valid(ghcb) \|\|
2364	!ghcb_sw_exit_info_2_is_valid(ghcb))	2380	!ghcb_sw_exit_info_2_is_valid(ghcb))
@@ -2437,30 +2453,34 @@ static int sev_es_validate_vmgexit(struct vcpu_svm *svm) · 72 unmodified lines
2437	case SVM_VMGEXIT_UNSUPPORTED_EVENT:	2453	case SVM_VMGEXIT_UNSUPPORTED_EVENT:
2438	break;	2454	break;
2439	default:	2455	default:
		2456	reason = GHCB_ERR_INVALID_EVENT;
2440	goto vmgexit_err;	2457	goto vmgexit_err;
2441	}	2458	}
2442		2459
2443	return 0;	2460	return true;
2444		2461
2445	vmgexit_err:	2462	vmgexit_err:
2446	vcpu = &svm->vcpu;	2463	vcpu = &svm->vcpu;
2447		2464
2448	if (ghcb->ghcb_usage) {	2465	if (reason == GHCB_ERR_INVALID_USAGE) {
2449	vcpu_unimpl(vcpu, "vmgexit: ghcb usage %#x is not valid\n",	2466	vcpu_unimpl(vcpu, "vmgexit: ghcb usage %#x is not valid\n",
2450	ghcb->ghcb_usage);	2467	ghcb->ghcb_usage);
		2468	} else if (reason == GHCB_ERR_INVALID_EVENT) {
		2469	vcpu_unimpl(vcpu, "vmgexit: exit code %#llx is not valid\n",
		2470	exit_code);
2451	} else {	2471	} else {
2452	vcpu_unimpl(vcpu, "vmgexit: exit reason %#llx is not valid\n",	2472	vcpu_unimpl(vcpu, "vmgexit: exit code %#llx input is not valid\n",
2453	exit_code);	2473	exit_code);
2454	dump_ghcb(svm);	2474	dump_ghcb(svm);
2455	}	2475	}
2456		2476
2457	vcpu->run->exit_reason = KVM_EXIT_INTERNAL_ERROR;	2477	/* Clear the valid entries fields */
2458	vcpu->run->internal.suberror = KVM_INTERNAL_ERROR_UNEXPECTED_EXIT_REASON;	2478	memset(ghcb->save.valid_bitmap, 0, sizeof(ghcb->save.valid_bitmap));
2459	vcpu->run->internal.ndata = 2;	2479
2460	vcpu->run->internal.data[0] = exit_code;	2480	ghcb_set_sw_exit_info_1(ghcb, 2);
2461	vcpu->run->internal.data[1] = vcpu->arch.last_vmentry_cpu;	2481	ghcb_set_sw_exit_info_2(ghcb, reason);
2462		2482
2463	return -EINVAL;	2483	return false;
2464	}	2484	}
2465		2485
2466	void sev_es_unmap_ghcb(struct vcpu_svm *svm)	2486	void sev_es_unmap_ghcb(struct vcpu_svm *svm)
@@ -2482,7 +2502,7 @@ void sev_es_unmap_ghcb(struct vcpu_svm *svm) · 15 unmodified lines
2482	svm->sev_es.ghcb_sa_sync = false;	2502	svm->sev_es.ghcb_sa_sync = false;
2483	}	2503	}
2484		2504
2485	kfree(svm->sev_es.ghcb_sa);	2505	kvfree(svm->sev_es.ghcb_sa);
2486	svm->sev_es.ghcb_sa = NULL;	2506	svm->sev_es.ghcb_sa = NULL;
2487	svm->sev_es.ghcb_sa_free = false;	2507	svm->sev_es.ghcb_sa_free = false;
2488	}	2508	}
@@ -2530,14 +2550,14 @@ static bool setup_vmgexit_scratch(struct vcpu_svm *svm, bool sync, u64 len) · 41 unmodified lines
2530	scratch_gpa_beg = ghcb_get_sw_scratch(ghcb);	2550	scratch_gpa_beg = ghcb_get_sw_scratch(ghcb);
2531	if (!scratch_gpa_beg) {	2551	if (!scratch_gpa_beg) {
2532	pr_err("vmgexit: scratch gpa not provided\n");	2552	pr_err("vmgexit: scratch gpa not provided\n");
2533	return false;	2553	goto e_scratch;
2534	}	2554	}
2535		2555
2536	scratch_gpa_end = scratch_gpa_beg + len;	2556	scratch_gpa_end = scratch_gpa_beg + len;
2537	if (scratch_gpa_end < scratch_gpa_beg) {	2557	if (scratch_gpa_end < scratch_gpa_beg) {
2538	pr_err("vmgexit: scratch length (%#llx) not valid for scratch address (%#llx)\n",	2558	pr_err("vmgexit: scratch length (%#llx) not valid for scratch address (%#llx)\n",
2539	len, scratch_gpa_beg);	2559	len, scratch_gpa_beg);
2540	return false;	2560	goto e_scratch;
2541	}	2561	}
2542		2562
2543	if ((scratch_gpa_beg & PAGE_MASK) == control->ghcb_gpa) {	2563	if ((scratch_gpa_beg & PAGE_MASK) == control->ghcb_gpa) {
@@ -2555,7 +2575,7 @@ static bool setup_vmgexit_scratch(struct vcpu_svm *svm, bool sync, u64 len) · 11 unmodified lines
2555	scratch_gpa_end > ghcb_scratch_end) {	2575	scratch_gpa_end > ghcb_scratch_end) {
2556	pr_err("vmgexit: scratch area is outside of GHCB shared buffer area (%#llx - %#llx)\n",	2576	pr_err("vmgexit: scratch area is outside of GHCB shared buffer area (%#llx - %#llx)\n",
2557	scratch_gpa_beg, scratch_gpa_end);	2577	scratch_gpa_beg, scratch_gpa_end);
2558	return false;	2578	goto e_scratch;
2559	}	2579	}
2560		2580
2561	scratch_va = (void *)svm->sev_es.ghcb;	2581	scratch_va = (void *)svm->sev_es.ghcb;
@@ -2568,18 +2588,18 @@ static bool setup_vmgexit_scratch(struct vcpu_svm *svm, bool sync, u64 len) · 6 unmodified lines
2568	if (len > GHCB_SCRATCH_AREA_LIMIT) {	2588	if (len > GHCB_SCRATCH_AREA_LIMIT) {
2569	pr_err("vmgexit: scratch area exceeds KVM limits (%#llx requested, %#llx limit)\n",	2589	pr_err("vmgexit: scratch area exceeds KVM limits (%#llx requested, %#llx limit)\n",
2570	len, GHCB_SCRATCH_AREA_LIMIT);	2590	len, GHCB_SCRATCH_AREA_LIMIT);
2571	return false;	2591	goto e_scratch;
2572	}	2592	}
2573	scratch_va = kzalloc(len, GFP_KERNEL_ACCOUNT);	2593	scratch_va = kvzalloc(len, GFP_KERNEL_ACCOUNT);
2574	if (!scratch_va)	2594	if (!scratch_va)
2575	return false;	2595	goto e_scratch;
2576		2596
2577	if (kvm_read_guest(svm->vcpu.kvm, scratch_gpa_beg, scratch_va, len)) {	2597	if (kvm_read_guest(svm->vcpu.kvm, scratch_gpa_beg, scratch_va, len)) {
2578	/* Unable to copy scratch area from guest */	2598	/* Unable to copy scratch area from guest */
2579	pr_err("vmgexit: kvm_read_guest for scratch area failed\n");	2599	pr_err("vmgexit: kvm_read_guest for scratch area failed\n");
2580		2600
2581	kfree(scratch_va);	2601	kvfree(scratch_va);
2582	return false;	2602	goto e_scratch;
2583	}	2603	}
2584		2604
2585	/*	2605	/*
@@ -2596,6 +2616,12 @@ static bool setup_vmgexit_scratch(struct vcpu_svm *svm, bool sync, u64 len) · 10 unmodified lines
2596	svm->sev_es.ghcb_sa_len = len;	2616	svm->sev_es.ghcb_sa_len = len;
2597		2617
2598	return true;	2618	return true;
		2619
		2620	e_scratch:
		2621	ghcb_set_sw_exit_info_1(ghcb, 2);
		2622	ghcb_set_sw_exit_info_2(ghcb, GHCB_ERR_INVALID_SCRATCH_AREA);
		2623
		2624	return false;
2599	}	2625	}
2600		2626
2601	static void set_ghcb_msr_bits(struct vcpu_svm *svm, u64 value, u64 mask,	2627	static void set_ghcb_msr_bits(struct vcpu_svm *svm, u64 value, u64 mask,
@@ -2646,7 +2672,7 @@ static int sev_handle_vmgexit_msr_protocol(struct vcpu_svm *svm) · 44 unmodified lines
2646		2672
2647	ret = svm_invoke_exit_handler(vcpu, SVM_EXIT_CPUID);	2673	ret = svm_invoke_exit_handler(vcpu, SVM_EXIT_CPUID);
2648	if (!ret) {	2674	if (!ret) {
2649	ret = -EINVAL;	2675	/* Error, keep GHCB MSR value as-is */
2650	break;	2676	break;
2651	}	2677	}
2652		2678
@@ -2682,10 +2708,13 @@ static int sev_handle_vmgexit_msr_protocol(struct vcpu_svm *svm) · 29 unmodified lines
2682	GHCB_MSR_TERM_REASON_POS);	2708	GHCB_MSR_TERM_REASON_POS);
2683	pr_info("SEV-ES guest requested termination: %#llx:%#llx\n",	2709	pr_info("SEV-ES guest requested termination: %#llx:%#llx\n",
2684	reason_set, reason_code);	2710	reason_set, reason_code);
2685	fallthrough;	2711
		2712	ret = -EINVAL;
		2713	break;
2686	}	2714	}
2687	default:	2715	default:
2688	ret = -EINVAL;	2716	/* Error, keep GHCB MSR value as-is */
		2717	break;
2689	}	2718	}
2690		2719
2691	trace_kvm_vmgexit_msr_protocol_exit(svm->vcpu.vcpu_id,	2720	trace_kvm_vmgexit_msr_protocol_exit(svm->vcpu.vcpu_id,
@@ -2709,14 +2738,18 @@ int sev_handle_vmgexit(struct kvm_vcpu *vcpu) · 17 unmodified lines
2709		2738
2710	if (!ghcb_gpa) {	2739	if (!ghcb_gpa) {
2711	vcpu_unimpl(vcpu, "vmgexit: GHCB gpa is not set\n");	2740	vcpu_unimpl(vcpu, "vmgexit: GHCB gpa is not set\n");
2712	return -EINVAL;	2741
		2742	/* Without a GHCB, just return right back to the guest */
		2743	return 1;
2713	}	2744	}
2714		2745
2715	if (kvm_vcpu_map(vcpu, ghcb_gpa >> PAGE_SHIFT, &svm->sev_es.ghcb_map)) {	2746	if (kvm_vcpu_map(vcpu, ghcb_gpa >> PAGE_SHIFT, &svm->sev_es.ghcb_map)) {
2716	/* Unable to map GHCB from guest */	2747	/* Unable to map GHCB from guest */
2717	vcpu_unimpl(vcpu, "vmgexit: error mapping GHCB [%#llx] from guest\n",	2748	vcpu_unimpl(vcpu, "vmgexit: error mapping GHCB [%#llx] from guest\n",
2718	ghcb_gpa);	2749	ghcb_gpa);
2719	return -EINVAL;	2750
		2751	/* Without a GHCB, just return right back to the guest */
		2752	return 1;
2720	}	2753	}
2721		2754
2722	svm->sev_es.ghcb = svm->sev_es.ghcb_map.hva;	2755	svm->sev_es.ghcb = svm->sev_es.ghcb_map.hva;
@@ -2726,15 +2759,14 @@ int sev_handle_vmgexit(struct kvm_vcpu *vcpu) · 3 unmodified lines
2726		2759
2727	exit_code = ghcb_get_sw_exit_code(ghcb);	2760	exit_code = ghcb_get_sw_exit_code(ghcb);
2728		2761
2729	ret = sev_es_validate_vmgexit(svm);	2762	if (!sev_es_validate_vmgexit(svm))
2730	if (ret)	2763	return 1;
2731	return ret;
2732		2764
2733	sev_es_sync_from_ghcb(svm);	2765	sev_es_sync_from_ghcb(svm);
2734	ghcb_set_sw_exit_info_1(ghcb, 0);	2766	ghcb_set_sw_exit_info_1(ghcb, 0);
2735	ghcb_set_sw_exit_info_2(ghcb, 0);	2767	ghcb_set_sw_exit_info_2(ghcb, 0);
2736		2768
2737	ret = -EINVAL;	2769	ret = 1;
2738	switch (exit_code) {	2770	switch (exit_code) {
2739	case SVM_VMGEXIT_MMIO_READ:	2771	case SVM_VMGEXIT_MMIO_READ:
2740	if (!setup_vmgexit_scratch(svm, true, control->exit_info_2))	2772	if (!setup_vmgexit_scratch(svm, true, control->exit_info_2))
@@ -2775,20 +2807,17 @@ int sev_handle_vmgexit(struct kvm_vcpu *vcpu) · 34 unmodified lines
2775	default:	2807	default:
2776	pr_err("svm: vmgexit: unsupported AP jump table request - exit_info_1=%#llx\n",	2808	pr_err("svm: vmgexit: unsupported AP jump table request - exit_info_1=%#llx\n",
2777	control->exit_info_1);	2809	control->exit_info_1);
2778	ghcb_set_sw_exit_info_1(ghcb, 1);	2810	ghcb_set_sw_exit_info_1(ghcb, 2);
2779	ghcb_set_sw_exit_info_2(ghcb,	2811	ghcb_set_sw_exit_info_2(ghcb, GHCB_ERR_INVALID_INPUT);
2780	X86_TRAP_UD \|
2781	SVM_EVTINJ_TYPE_EXEPT \|
2782	SVM_EVTINJ_VALID);
2783	}	2812	}
2784		2813
2785	ret = 1;
2786	break;	2814	break;
2787	}	2815	}
2788	case SVM_VMGEXIT_UNSUPPORTED_EVENT:	2816	case SVM_VMGEXIT_UNSUPPORTED_EVENT:
2789	vcpu_unimpl(vcpu,	2817	vcpu_unimpl(vcpu,
2790	"vmgexit: unsupported event - exit_info_1=%#llx, exit_info_2=%#llx\n",	2818	"vmgexit: unsupported event - exit_info_1=%#llx, exit_info_2=%#llx\n",
2791	control->exit_info_1, control->exit_info_2);	2819	control->exit_info_1, control->exit_info_2);
		2820	ret = -EINVAL;
2792	break;	2821	break;
2793	default:	2822	default:
2794	ret = svm_invoke_exit_handler(vcpu, exit_code);	2823	ret = svm_invoke_exit_handler(vcpu, exit_code);
@@ -2810,7 +2839,7 @@ int sev_es_string_io(struct vcpu_svm *svm, int size, unsigned int port, int in) · 15 unmodified lines
2810	return -EINVAL;	2839	return -EINVAL;
2811		2840
2812	if (!setup_vmgexit_scratch(svm, in, bytes))	2841	if (!setup_vmgexit_scratch(svm, in, bytes))
2813	return -EINVAL;	2842	return 1;
2814		2843
2815	return kvm_sev_es_string_io(&svm->vcpu, size, port, svm->sev_es.ghcb_sa,	2844	return kvm_sev_es_string_io(&svm->vcpu, size, port, svm->sev_es.ghcb_sa,
2816	count, in);	2845	count, in);

arch/x86/kvm/svm/svm.c+0−1

@@ -4651,7 +4651,6 @@ static struct kvm_x86_ops svm_x86_ops __initdata = { · 4650 unmodified lines
4651	.load_eoi_exitmap = svm_load_eoi_exitmap,	4651	.load_eoi_exitmap = svm_load_eoi_exitmap,
4652	.hwapic_irr_update = svm_hwapic_irr_update,	4652	.hwapic_irr_update = svm_hwapic_irr_update,
4653	.hwapic_isr_update = svm_hwapic_isr_update,	4653	.hwapic_isr_update = svm_hwapic_isr_update,
4654	.sync_pir_to_irr = kvm_lapic_find_highest_irr,
4655	.apicv_post_state_restore = avic_post_state_restore,	4654	.apicv_post_state_restore = avic_post_state_restore,
4656		4655
4657	.set_tss_addr = svm_set_tss_addr,	4656	.set_tss_addr = svm_set_tss_addr,

arch/x86/kvm/svm/svm.h+1−0

@@ -79,6 +79,7 @@ struct kvm_sev_info { · 78 unmodified lines
79	struct list_head regions_list; /* List of registered regions */	79	struct list_head regions_list; /* List of registered regions */
80	u64 ap_jump_table; /* SEV-ES AP Jump Table address */	80	u64 ap_jump_table; /* SEV-ES AP Jump Table address */
81	struct kvm enc_context_owner; / Owner of copied encryption context */	81	struct kvm enc_context_owner; / Owner of copied encryption context */
		82	unsigned long num_mirrored_vms; /* Number of VMs sharing this ASID */
82	struct misc_cg misc_cg; / For misc cgroup accounting */	83	struct misc_cg misc_cg; / For misc cgroup accounting */
83	atomic_t migration_in_progress;	84	atomic_t migration_in_progress;
84	};	85	};

arch/x86/kvm/vmx/nested.c+25−28

 	WARN_ON(!enable_vpid);
 	/*
-	 * If VPID is enabled and used by vmc12, but L2 does not have a unique
+	 * VPID is enabled and in use by vmcs12.  If vpid12 is changing, then
-	 * TLB tag (ASID), i.e. EPT is disabled and KVM was unable to allocate
+	 * emulate a guest TLB flush as KVM does not track vpid12 history nor
-	 * a VPID for L2, flush the current context as the effective ASID is
+	 * is the VPID incorporated into the MMU context.  I.e. KVM must assume
-	 * common to both L1 and L2.
+	 * that the new vpid12 has never been used and thus represents a new
-	 *
+	 * guest ASID that cannot have entries in the TLB.
-	 * Defer the flush so that it runs after vmcs02.EPTP has been set by
-	 * KVM_REQ_LOAD_MMU_PGD (if nested EPT is enabled) and to avoid
-	 * redundant flushes further down the nested pipeline.
-	 *
-	 * If a TLB flush isn't required due to any of the above, and vpid12 is
-	 * changing then the new "virtual" VPID (vpid12) will reuse the same
-	 * "real" VPID (vpid02), and so needs to be flushed.  There's no direct
-	 * mapping between vpid02 and vpid12, vpid02 is per-vCPU and reused for
-	 * all nested vCPUs.  Remember, a flush on VM-Enter does not invalidate
-	 * guest-physical mappings, so there is no need to sync the nEPT MMU.
 	 */
-	if (!nested_has_guest_tlb_tag(vcpu)) {
+	if (is_vmenter && vmcs12->virtual_processor_id != vmx->nested.last_vpid) {
-		kvm_make_request(KVM_REQ_TLB_FLUSH_CURRENT, vcpu);
-	} else if (is_vmenter &&
-		   vmcs12->virtual_processor_id != vmx->nested.last_vpid) {
 		vmx->nested.last_vpid = vmcs12->virtual_processor_id;
-		vpid_sync_context(nested_get_vpid02(vcpu));
+		kvm_make_request(KVM_REQ_TLB_FLUSH_GUEST, vcpu);
+		return;
 	}
+	/*
+	 * If VPID is enabled, used by vmc12, and vpid12 is not changing but
+	 * does not have a unique TLB tag (ASID), i.e. EPT is disabled and
+	 * KVM was unable to allocate a VPID for L2, flush the current context
+	 * as the effective ASID is common to both L1 and L2.
+	 */
+	if (!nested_has_guest_tlb_tag(vcpu))
+		kvm_make_request(KVM_REQ_TLB_FLUSH_CURRENT, vcpu);
 }
 static bool is_bitwise_subset(u64 superset, u64 subset, u64 mask)
 	if ((vmcs12->vm_entry_controls & VM_ENTRY_LOAD_IA32_PERF_GLOBAL_CTRL) &&
 	    WARN_ON_ONCE(kvm_set_msr(vcpu, MSR_CORE_PERF_GLOBAL_CTRL,
-				     vmcs12->guest_ia32_perf_global_ctrl)))
+				     vmcs12->guest_ia32_perf_global_ctrl))) {
+		*entry_failure_code = ENTRY_FAIL_DEFAULT;
 		return -EINVAL;
+	}
 	kvm_rsp_write(vcpu, vmcs12->guest_rsp);
 	kvm_rip_write(vcpu, vmcs12->guest_rip);
 	};
 	u32 failed_index;
-	if (kvm_check_request(KVM_REQ_TLB_FLUSH_CURRENT, vcpu))
+	kvm_service_local_tlb_flush_requests(vcpu);
-		kvm_vcpu_flush_tlb_current(vcpu);
 	evaluate_pending_interrupts = exec_controls_get(vmx) &
 		(CPU_BASED_INTR_WINDOW_EXITING | CPU_BASED_NMI_WINDOW_EXITING);
 		(void)nested_get_evmcs_page(vcpu);
 	}
-	/* Service the TLB flush request for L2 before switching to L1. */
+	/* Service pending TLB flush requests for L2 before switching to L1. */
-	if (kvm_check_request(KVM_REQ_TLB_FLUSH_CURRENT, vcpu))
+	kvm_service_local_tlb_flush_requests(vcpu);
-		kvm_vcpu_flush_tlb_current(vcpu);
 	/*
 	 * VCPU_EXREG_PDPTR will be clobbered in arch/x86/kvm/vmx/vmx.h between
 	if (!vmx->nested.cached_vmcs12)
 		goto out_cached_vmcs12;
+	vmx->nested.shadow_vmcs12_cache.gpa = INVALID_GPA;
 	vmx->nested.cached_shadow_vmcs12 = kzalloc(VMCS12_SIZE, GFP_KERNEL_ACCOUNT);
 	if (!vmx->nested.cached_shadow_vmcs12)
 		goto out_cached_shadow_vmcs12;
 		struct gfn_to_hva_cache *ghc = &vmx->nested.vmcs12_cache;
 		struct vmcs_hdr hdr;
-		if (ghc->gpa != vmptr &&
+		if (kvm_gfn_to_hva_cache_init(vcpu->kvm, ghc, vmptr, VMCS12_SIZE)) {
-		    kvm_gfn_to_hva_cache_init(vcpu->kvm, ghc, vmptr, VMCS12_SIZE)) {
 			/*
 			 * Reads from an unbacked page return all 1s,
 			 * which means that the 32 bits located at the

arch/x86/kvm/vmx/posted_intr.c+11−9

 #include <asm/cpu.h>
 #include "lapic.h"
+#include "irq.h"
 #include "posted_intr.h"
 #include "trace.h"
 #include "vmx.h"
 		pi_set_on(pi_desc);
 }
+static bool vmx_can_use_vtd_pi(struct kvm *kvm)
+{
+	return irqchip_in_kernel(kvm) && enable_apicv &&
+		kvm_arch_has_assigned_device(kvm) &&
+		irq_remapping_cap(IRQ_POSTING_CAP);
+}
 void vmx_vcpu_pi_put(struct kvm_vcpu *vcpu)
 {
 	struct pi_desc *pi_desc = vcpu_to_pi_desc(vcpu);
-	if (!kvm_arch_has_assigned_device(vcpu->kvm) ||
+	if (!vmx_can_use_vtd_pi(vcpu->kvm))
-		!irq_remapping_cap(IRQ_POSTING_CAP)  ||
-		!kvm_vcpu_apicv_active(vcpu))
 		return;
 	/* Set SN when the vCPU is preempted */
 	struct pi_desc old, new;
 	struct pi_desc *pi_desc = vcpu_to_pi_desc(vcpu);
-	if (!kvm_arch_has_assigned_device(vcpu->kvm) ||
+	if (!vmx_can_use_vtd_pi(vcpu->kvm))
-		!irq_remapping_cap(IRQ_POSTING_CAP)  ||
-		!kvm_vcpu_apicv_active(vcpu))
 		return 0;
 	WARN_ON(irqs_disabled());
 	struct vcpu_data vcpu_info;
 	int idx, ret = 0;
-	if (!kvm_arch_has_assigned_device(kvm) ||
+	if (!vmx_can_use_vtd_pi(kvm))
-	    !irq_remapping_cap(IRQ_POSTING_CAP) ||
-	    !kvm_vcpu_apicv_active(kvm->vcpus[0]))
 		return 0;
 	idx = srcu_read_lock(&kvm->irq_srcu);

arch/x86/kvm/vmx/vmx.c+55−34

@@ -2646,15 +2646,6 @@ int alloc_loaded_vmcs(struct loaded_vmcs *loaded_vmcs) · 2645 unmodified lines
2646	if (!loaded_vmcs->msr_bitmap)	2646	if (!loaded_vmcs->msr_bitmap)
2647	goto out_vmcs;	2647	goto out_vmcs;
2648	memset(loaded_vmcs->msr_bitmap, 0xff, PAGE_SIZE);	2648	memset(loaded_vmcs->msr_bitmap, 0xff, PAGE_SIZE);
2649
2650	if (IS_ENABLED(CONFIG_HYPERV) &&
2651	static_branch_unlikely(&enable_evmcs) &&
2652	(ms_hyperv.nested_features & HV_X64_NESTED_MSR_BITMAP)) {
2653	struct hv_enlightened_vmcs *evmcs =
2654	(struct hv_enlightened_vmcs *)loaded_vmcs->vmcs;
2655
2656	evmcs->hv_enlightenments_control.msr_bitmap = 1;
2657	}
2658	}	2649	}
2659		2650
2660	memset(&loaded_vmcs->host_state, 0, sizeof(struct vmcs_host_state));	2651	memset(&loaded_vmcs->host_state, 0, sizeof(struct vmcs_host_state));
@@ -2918,6 +2909,13 @@ static void vmx_flush_tlb_all(struct kvm_vcpu *vcpu) · 257 unmodified lines
2918	}	2909	}
2919	}	2910	}
2920		2911
		2912	static inline int vmx_get_current_vpid(struct kvm_vcpu *vcpu)
		2913	{
		2914	if (is_guest_mode(vcpu))
		2915	return nested_get_vpid02(vcpu);
		2916	return to_vmx(vcpu)->vpid;
		2917	}
		2918
2921	static void vmx_flush_tlb_current(struct kvm_vcpu *vcpu)	2919	static void vmx_flush_tlb_current(struct kvm_vcpu *vcpu)
2922	{	2920	{
2923	struct kvm_mmu *mmu = vcpu->arch.mmu;	2921	struct kvm_mmu *mmu = vcpu->arch.mmu;
@@ -2930,31 +2928,29 @@ static void vmx_flush_tlb_current(struct kvm_vcpu *vcpu) · 6 unmodified lines
2930	if (enable_ept)	2928	if (enable_ept)
2931	ept_sync_context(construct_eptp(vcpu, root_hpa,	2929	ept_sync_context(construct_eptp(vcpu, root_hpa,
2932	mmu->shadow_root_level));	2930	mmu->shadow_root_level));
2933	else if (!is_guest_mode(vcpu))
2934	vpid_sync_context(to_vmx(vcpu)->vpid);
2935	else	2931	else
2936	vpid_sync_context(nested_get_vpid02(vcpu));	2932	vpid_sync_context(vmx_get_current_vpid(vcpu));
2937	}	2933	}
2938		2934
2939	static void vmx_flush_tlb_gva(struct kvm_vcpu *vcpu, gva_t addr)	2935	static void vmx_flush_tlb_gva(struct kvm_vcpu *vcpu, gva_t addr)
2940	{	2936	{
2941	/*	2937	/*
2942	* vpid_sync_vcpu_addr() is a nop if vmx->vpid==0, see the comment in	2938	* vpid_sync_vcpu_addr() is a nop if vpid==0, see the comment in
2943	* vmx_flush_tlb_guest() for an explanation of why this is ok.	2939	* vmx_flush_tlb_guest() for an explanation of why this is ok.
2944	*/	2940	*/
2945	vpid_sync_vcpu_addr(to_vmx(vcpu)->vpid, addr);	2941	vpid_sync_vcpu_addr(vmx_get_current_vpid(vcpu), addr);
2946	}	2942	}
2947		2943
2948	static void vmx_flush_tlb_guest(struct kvm_vcpu *vcpu)	2944	static void vmx_flush_tlb_guest(struct kvm_vcpu *vcpu)
2949	{	2945	{
2950	/*	2946	/*
2951	* vpid_sync_context() is a nop if vmx->vpid==0, e.g. if enable_vpid==0	2947	* vpid_sync_context() is a nop if vpid==0, e.g. if enable_vpid==0 or a
2952	* or a vpid couldn't be allocated for this vCPU. VM-Enter and VM-Exit	2948	* vpid couldn't be allocated for this vCPU. VM-Enter and VM-Exit are
2953	* are required to flush GVA->{G,H}PA mappings from the TLB if vpid is	2949	* required to flush GVA->{G,H}PA mappings from the TLB if vpid is
2954	* disabled (VM-Enter with vpid enabled and vpid==0 is disallowed),	2950	* disabled (VM-Enter with vpid enabled and vpid==0 is disallowed),
2955	* i.e. no explicit INVVPID is necessary.	2951	* i.e. no explicit INVVPID is necessary.
2956	*/	2952	*/
2957	vpid_sync_context(to_vmx(vcpu)->vpid);	2953	vpid_sync_context(vmx_get_current_vpid(vcpu));
2958	}	2954	}
2959		2955
2960	void vmx_ept_load_pdptrs(struct kvm_vcpu *vcpu)	2956	void vmx_ept_load_pdptrs(struct kvm_vcpu *vcpu)
@@ -6262,9 +6258,9 @@ static int vmx_sync_pir_to_irr(struct kvm_vcpu *vcpu) · 3301 unmodified lines
6262	{	6258	{
6263	struct vcpu_vmx *vmx = to_vmx(vcpu);	6259	struct vcpu_vmx *vmx = to_vmx(vcpu);
6264	int max_irr;	6260	int max_irr;
6265	bool max_irr_updated;	6261	bool got_posted_interrupt;
6266		6262
6267	if (KVM_BUG_ON(!vcpu->arch.apicv_active, vcpu->kvm))	6263	if (KVM_BUG_ON(!enable_apicv, vcpu->kvm))
6268	return -EIO;	6264	return -EIO;
6269		6265
6270	if (pi_test_on(&vmx->pi_desc)) {	6266	if (pi_test_on(&vmx->pi_desc)) {
@@ -6274,22 +6270,33 @@ static int vmx_sync_pir_to_irr(struct kvm_vcpu *vcpu) · 3 unmodified lines
6274	* But on x86 this is just a compiler barrier anyway.	6270	* But on x86 this is just a compiler barrier anyway.
6275	*/	6271	*/
6276	smp_mb__after_atomic();	6272	smp_mb__after_atomic();
6277	max_irr_updated =	6273	got_posted_interrupt =
6278	kvm_apic_update_irr(vcpu, vmx->pi_desc.pir, &max_irr);	6274	kvm_apic_update_irr(vcpu, vmx->pi_desc.pir, &max_irr);
6279
6280	/*
6281	* If we are running L2 and L1 has a new pending interrupt
6282	* which can be injected, this may cause a vmexit or it may
6283	* be injected into L2. Either way, this interrupt will be
6284	* processed via KVM_REQ_EVENT, not RVI, because we do not use
6285	* virtual interrupt delivery to inject L1 interrupts into L2.
6286	*/
6287	if (is_guest_mode(vcpu) && max_irr_updated)
6288	kvm_make_request(KVM_REQ_EVENT, vcpu);
6289	} else {	6275	} else {
6290	max_irr = kvm_lapic_find_highest_irr(vcpu);	6276	max_irr = kvm_lapic_find_highest_irr(vcpu);
		6277	got_posted_interrupt = false;
6291	}	6278	}
6292	vmx_hwapic_irr_update(vcpu, max_irr);	6279
		6280	/*
		6281	* Newly recognized interrupts are injected via either virtual interrupt
		6282	* delivery (RVI) or KVM_REQ_EVENT. Virtual interrupt delivery is
		6283	* disabled in two cases:
		6284	*
		6285	* 1) If L2 is running and the vCPU has a new pending interrupt. If L1
		6286	* wants to exit on interrupts, KVM_REQ_EVENT is needed to synthesize a
		6287	* VM-Exit to L1. If L1 doesn't want to exit, the interrupt is injected
		6288	* into L2, but KVM doesn't use virtual interrupt delivery to inject
		6289	* interrupts into L2, and so KVM_REQ_EVENT is again needed.
		6290	*
		6291	* 2) If APICv is disabled for this vCPU, assigned devices may still
		6292	* attempt to post interrupts. The posted interrupt vector will cause
		6293	* a VM-Exit and the subsequent entry will call sync_pir_to_irr.
		6294	*/
		6295	if (!is_guest_mode(vcpu) && kvm_vcpu_apicv_active(vcpu))
		6296	vmx_set_rvi(max_irr);
		6297	else if (got_posted_interrupt)
		6298	kvm_make_request(KVM_REQ_EVENT, vcpu);
		6299
6293	return max_irr;	6300	return max_irr;
6294	}	6301	}
6295		6302
@@ -6826,6 +6833,19 @@ static int vmx_create_vcpu(struct kvm_vcpu *vcpu) · 530 unmodified lines
6826	if (err < 0)	6833	if (err < 0)
6827	goto free_pml;	6834	goto free_pml;
6828		6835
		6836	/*
		6837	* Use Hyper-V 'Enlightened MSR Bitmap' feature when KVM runs as a
		6838	* nested (L1) hypervisor and Hyper-V in L0 supports it. Enable the
		6839	* feature only for vmcs01, KVM currently isn't equipped to realize any
		6840	* performance benefits from enabling it for vmcs02.
		6841	*/
		6842	if (IS_ENABLED(CONFIG_HYPERV) && static_branch_unlikely(&enable_evmcs) &&
		6843	(ms_hyperv.nested_features & HV_X64_NESTED_MSR_BITMAP)) {
		6844	struct hv_enlightened_vmcs evmcs = (void )vmx->vmcs01.vmcs;
		6845
		6846	evmcs->hv_enlightenments_control.msr_bitmap = 1;
		6847	}
		6848
6829	/* The MSR bitmap starts with all ones */	6849	/* The MSR bitmap starts with all ones */
6830	bitmap_fill(vmx->shadow_msr_intercept.read, MAX_POSSIBLE_PASSTHROUGH_MSRS);	6850	bitmap_fill(vmx->shadow_msr_intercept.read, MAX_POSSIBLE_PASSTHROUGH_MSRS);
6831	bitmap_fill(vmx->shadow_msr_intercept.write, MAX_POSSIBLE_PASSTHROUGH_MSRS);	6851	bitmap_fill(vmx->shadow_msr_intercept.write, MAX_POSSIBLE_PASSTHROUGH_MSRS);
@@ -7509,6 +7529,7 @@ static void hardware_unsetup(void) · 677 unmodified lines
7509	static bool vmx_check_apicv_inhibit_reasons(ulong bit)	7529	static bool vmx_check_apicv_inhibit_reasons(ulong bit)
7510	{	7530	{
7511	ulong supported = BIT(APICV_INHIBIT_REASON_DISABLE) \|	7531	ulong supported = BIT(APICV_INHIBIT_REASON_DISABLE) \|
		7532	BIT(APICV_INHIBIT_REASON_ABSENT) \|
7512	BIT(APICV_INHIBIT_REASON_HYPERV) \|	7533	BIT(APICV_INHIBIT_REASON_HYPERV) \|
7513	BIT(APICV_INHIBIT_REASON_BLOCKIRQ);	7534	BIT(APICV_INHIBIT_REASON_BLOCKIRQ);
7514		7535
@@ -7761,10 +7782,10 @@ static __init int hardware_setup(void) · 246 unmodified lines
7761	ple_window_shrink = 0;	7782	ple_window_shrink = 0;
7762	}	7783	}
7763		7784
7764	if (!cpu_has_vmx_apicv()) {	7785	if (!cpu_has_vmx_apicv())
7765	enable_apicv = 0;	7786	enable_apicv = 0;
		7787	if (!enable_apicv)
7766	vmx_x86_ops.sync_pir_to_irr = NULL;	7788	vmx_x86_ops.sync_pir_to_irr = NULL;
7767	}
7768		7789
7769	if (cpu_has_vmx_tsc_scaling()) {	7790	if (cpu_has_vmx_tsc_scaling()) {
7770	kvm_has_tsc_control = true;	7791	kvm_has_tsc_control = true;

arch/x86/kvm/x86.c+67−20

 	    !load_pdptrs(vcpu, vcpu->arch.walk_mmu, kvm_read_cr3(vcpu)))
 		return 1;
-	if (!(cr0 & X86_CR0_PG) && kvm_read_cr4_bits(vcpu, X86_CR4_PCIDE))
+	if (!(cr0 & X86_CR0_PG) &&
+	    (is_64_bit_mode(vcpu) || kvm_read_cr4_bits(vcpu, X86_CR4_PCIDE)))
 		return 1;
 	static_call(kvm_x86_set_cr0)(vcpu, cr0);
 	static_call(kvm_x86_tlb_flush_guest)(vcpu);
 }
+static inline void kvm_vcpu_flush_tlb_current(struct kvm_vcpu *vcpu)
+{
+	++vcpu->stat.tlb_flush;
+	static_call(kvm_x86_tlb_flush_current)(vcpu);
+}
+/*
+ * Service "local" TLB flush requests, which are specific to the current MMU
+ * context.  In addition to the generic event handling in vcpu_enter_guest(),
+ * TLB flushes that are targeted at an MMU context also need to be serviced
+ * prior before nested VM-Enter/VM-Exit.
+ */
+void kvm_service_local_tlb_flush_requests(struct kvm_vcpu *vcpu)
+{
+	if (kvm_check_request(KVM_REQ_TLB_FLUSH_CURRENT, vcpu))
+		kvm_vcpu_flush_tlb_current(vcpu);
+	if (kvm_check_request(KVM_REQ_TLB_FLUSH_GUEST, vcpu))
+		kvm_vcpu_flush_tlb_guest(vcpu);
+}
+EXPORT_SYMBOL_GPL(kvm_service_local_tlb_flush_requests);
 static void record_steal_time(struct kvm_vcpu *vcpu)
 {
 	struct gfn_to_hva_cache *ghc = &vcpu->arch.st.cache;
 	case KVM_CAP_SGX_ATTRIBUTE:
 #endif
 	case KVM_CAP_VM_COPY_ENC_CONTEXT_FROM:
+	case KVM_CAP_VM_MOVE_ENC_CONTEXT_FROM:
 	case KVM_CAP_SREGS2:
 	case KVM_CAP_EXIT_ON_EMULATION_FAILURE:
 	case KVM_CAP_VCPU_ATTRIBUTES:
 static int kvm_vcpu_ioctl_get_lapic(struct kvm_vcpu *vcpu,
 				    struct kvm_lapic_state *s)
 {
-	if (vcpu->arch.apicv_active)
+	static_call_cond(kvm_x86_sync_pir_to_irr)(vcpu);
-		static_call(kvm_x86_sync_pir_to_irr)(vcpu);
 	return kvm_apic_get_state(vcpu, s);
 }
 		struct kvm_cpuid __user *cpuid_arg = argp;
 		struct kvm_cpuid cpuid;
+		/*
+		 * KVM does not correctly handle changing guest CPUID after KVM_RUN, as
+		 * MAXPHYADDR, GBPAGES support, AMD reserved bit behavior, etc.. aren't
+		 * tracked in kvm_mmu_page_role.  As a result, KVM may miss guest page
+		 * faults due to reusing SPs/SPTEs.  In practice no sane VMM mucks with
+		 * the core vCPU model on the fly, so fail.
+		 */
+		r = -EINVAL;
+		if (vcpu->arch.last_vmentry_cpu != -1)
+			goto out;
 		r = -EFAULT;
 		if (copy_from_user(&cpuid, cpuid_arg, sizeof(cpuid)))
 			goto out;
 		struct kvm_cpuid2 __user *cpuid_arg = argp;
 		struct kvm_cpuid2 cpuid;
+		/*
+		 * KVM_SET_CPUID{,2} after KVM_RUN is forbidded, see the comment in
+		 * KVM_SET_CPUID case above.
+		 */
+		r = -EINVAL;
+		if (vcpu->arch.last_vmentry_cpu != -1)
+			goto out;
 		r = -EFAULT;
 		if (copy_from_user(&cpuid, cpuid_arg, sizeof(cpuid)))
 			goto out;
 		smp_wmb();
 		kvm->arch.irqchip_mode = KVM_IRQCHIP_SPLIT;
 		kvm->arch.nr_reserved_ioapic_pins = cap->args[0];
+		kvm_request_apicv_update(kvm, true, APICV_INHIBIT_REASON_ABSENT);
 		r = 0;
 split_irqchip_unlock:
 		mutex_unlock(&kvm->lock);
 		/* Write kvm->irq_routing before enabling irqchip_in_kernel. */
 		smp_wmb();
 		kvm->arch.irqchip_mode = KVM_IRQCHIP_KERNEL;
+		kvm_request_apicv_update(kvm, true, APICV_INHIBIT_REASON_ABSENT);
 	create_irqchip_unlock:
 		mutex_unlock(&kvm->lock);
 		break;
 			   unsigned short port, void *val, unsigned int count)
 {
 	if (vcpu->arch.pio.count) {
-		/* Complete previous iteration.  */
+		/*
+		 * Complete a previous iteration that required userspace I/O.
+		 * Note, @count isn't guaranteed to match pio.count as userspace
+		 * can modify ECX before rerunning the vCPU.  Ignore any such
+		 * shenanigans as KVM doesn't support modifying the rep count,
+		 * and the emulator ensures @count doesn't overflow the buffer.
+		 */
 	} else {
 		int r = __emulator_pio_in(vcpu, size, port, count);
 		if (!r)
 		/* Results already available, fall through.  */
 	}
-	WARN_ON(count != vcpu->arch.pio.count);
 	complete_emulator_pio_in(vcpu, val);
 	return 1;
 }
 {
 	init_rwsem(&kvm->arch.apicv_update_lock);
-	if (enable_apicv)
+	set_bit(APICV_INHIBIT_REASON_ABSENT,
-		clear_bit(APICV_INHIBIT_REASON_DISABLE,
+		&kvm->arch.apicv_inhibit_reasons);
-			  &kvm->arch.apicv_inhibit_reasons);
+	if (!enable_apicv)
-	else
 		set_bit(APICV_INHIBIT_REASON_DISABLE,
 			&kvm->arch.apicv_inhibit_reasons);
 }
 	if (irqchip_split(vcpu->kvm))
 		kvm_scan_ioapic_routes(vcpu, vcpu->arch.ioapic_handled_vectors);
 	else {
-		if (vcpu->arch.apicv_active)
+		static_call_cond(kvm_x86_sync_pir_to_irr)(vcpu);
-			static_call(kvm_x86_sync_pir_to_irr)(vcpu);
 		if (ioapic_in_kernel(vcpu->kvm))
 			kvm_ioapic_scan_entry(vcpu, vcpu->arch.ioapic_handled_vectors);
 	}
 			/* Flushing all ASIDs flushes the current ASID... */
 			kvm_clear_request(KVM_REQ_TLB_FLUSH_CURRENT, vcpu);
 		}
-		if (kvm_check_request(KVM_REQ_TLB_FLUSH_CURRENT, vcpu))
+		kvm_service_local_tlb_flush_requests(vcpu);
-			kvm_vcpu_flush_tlb_current(vcpu);
-		if (kvm_check_request(KVM_REQ_TLB_FLUSH_GUEST, vcpu))
-			kvm_vcpu_flush_tlb_guest(vcpu);
 		if (kvm_check_request(KVM_REQ_REPORT_TPR_ACCESS, vcpu)) {
 			vcpu->run->exit_reason = KVM_EXIT_TPR_ACCESS;
 	/*
 	 * This handles the case where a posted interrupt was
-	 * notified with kvm_vcpu_kick.
+	 * notified with kvm_vcpu_kick.  Assigned devices can
+	 * use the POSTED_INTR_VECTOR even if APICv is disabled,
+	 * so do it even if APICv is disabled on this vCPU.
 	 */
-	if (kvm_lapic_enabled(vcpu) && vcpu->arch.apicv_active)
+	if (kvm_lapic_enabled(vcpu))
-		static_call(kvm_x86_sync_pir_to_irr)(vcpu);
+		static_call_cond(kvm_x86_sync_pir_to_irr)(vcpu);
 	if (kvm_vcpu_exit_request(vcpu)) {
 		vcpu->mode = OUTSIDE_GUEST_MODE;
 		if (likely(exit_fastpath != EXIT_FASTPATH_REENTER_GUEST))
 			break;
-		if (vcpu->arch.apicv_active)
+		if (kvm_lapic_enabled(vcpu))
-			static_call(kvm_x86_sync_pir_to_irr)(vcpu);
+			static_call_cond(kvm_x86_sync_pir_to_irr)(vcpu);
 		if (unlikely(kvm_vcpu_exit_request(vcpu))) {
 			exit_fastpath = EXIT_FASTPATH_EXIT_HANDLED;

arch/x86/kvm/x86.h+1−6

 #define MSR_IA32_CR_PAT_DEFAULT  0x0007040600070406ULL
+void kvm_service_local_tlb_flush_requests(struct kvm_vcpu *vcpu);
 int kvm_check_nested_events(struct kvm_vcpu *vcpu);
 static inline void kvm_clear_exception_queue(struct kvm_vcpu *vcpu)
 	return vcpu->arch.walk_mmu == &vcpu->arch.nested_mmu;
 }
-static inline void kvm_vcpu_flush_tlb_current(struct kvm_vcpu *vcpu)
-{
-	++vcpu->stat.tlb_flush;
-	static_call(kvm_x86_tlb_flush_current)(vcpu);
-}
 static inline int is_pae(struct kvm_vcpu *vcpu)
 {
 	return kvm_read_cr4_bits(vcpu, X86_CR4_PAE);

arch/x86/platform/efi/quirks.c+2−1

@@ -277,7 +277,8 @@ void __init efi_arch_mem_reserve(phys_addr_t addr, u64 size) · 276 unmodified lines
277	return;	277	return;
278	}	278	}
279		279
280	new = early_memremap(data.phys_map, data.size);	280	new = early_memremap_prot(data.phys_map, data.size,
		281	pgprot_val(pgprot_encrypted(FIXMAP_PAGE_NORMAL)));
281	if (!new) {	282	if (!new) {
282	pr_err("Failed to map new boot services memmap\n");	283	pr_err("Failed to map new boot services memmap\n");
283	return;	284	return;

arch/x86/realmode/init.c+11−1

@@ -72,6 +72,7 @@ static void __init setup_real_mode(void) · 71 unmodified lines
72	#ifdef CONFIG_X86_64	72	#ifdef CONFIG_X86_64
73	u64 *trampoline_pgd;	73	u64 *trampoline_pgd;
74	u64 efer;	74	u64 efer;
		75	int i;
75	#endif	76	#endif
76		77
77	base = (unsigned char *)real_mode_header;	78	base = (unsigned char *)real_mode_header;
@@ -128,8 +129,17 @@ static void __init setup_real_mode(void) · 50 unmodified lines
128	trampoline_header->flags = 0;	129	trampoline_header->flags = 0;
129		130
130	trampoline_pgd = (u64 *) __va(real_mode_header->trampoline_pgd);	131	trampoline_pgd = (u64 *) __va(real_mode_header->trampoline_pgd);
		132
		133	/* Map the real mode stub as virtual == physical */
131	trampoline_pgd[0] = trampoline_pgd_entry.pgd;	134	trampoline_pgd[0] = trampoline_pgd_entry.pgd;
132	trampoline_pgd[511] = init_top_pgt[511].pgd;	135
		136	/*
		137	* Include the entirety of the kernel mapping into the trampoline
		138	* PGD. This way, all mappings present in the normal kernel page
		139	* tables are usable while running on trampoline_pgd.
		140	*/
		141	for (i = pgd_index(__PAGE_OFFSET); i < PTRS_PER_PGD; i++)
		142	trampoline_pgd[i] = init_top_pgt[i].pgd;
133	#endif	143	#endif
134		144
135	sme_sev_setup_real_mode(trampoline_header);	145	sme_sev_setup_real_mode(trampoline_header);

arch/x86/xen/xen-asm.S+20−0

@@ -20,6 +20,7 @@ · 19 unmodified lines
20		20
21	#include <linux/init.h>	21	#include <linux/init.h>
22	#include <linux/linkage.h>	22	#include <linux/linkage.h>
		23	#include <../entry/calling.h>
23		24
24	.pushsection .noinstr.text, "ax"	25	.pushsection .noinstr.text, "ax"
25	/*	26	/*
@@ -192,6 +193,25 @@ SYM_CODE_START(xen_iret) · 166 unmodified lines
192	jmp hypercall_iret	193	jmp hypercall_iret
193	SYM_CODE_END(xen_iret)	194	SYM_CODE_END(xen_iret)
194		195
		196	/*
		197	* XEN pv doesn't use trampoline stack, PER_CPU_VAR(cpu_tss_rw + TSS_sp0) is
		198	* also the kernel stack. Reusing swapgs_restore_regs_and_return_to_usermode()
		199	* in XEN pv would cause %rsp to move up to the top of the kernel stack and
		200	* leave the IRET frame below %rsp, which is dangerous to be corrupted if #NMI
		201	* interrupts. And swapgs_restore_regs_and_return_to_usermode() pushing the IRET
		202	* frame at the same address is useless.
		203	*/
		204	SYM_CODE_START(xenpv_restore_regs_and_return_to_usermode)
		205	UNWIND_HINT_REGS
		206	POP_REGS
		207
		208	/* stackleak_erase() can work safely on the kernel stack. */
		209	STACKLEAK_ERASE_NOCLOBBER
		210
		211	addq $8, %rsp /* skip regs->orig_ax */
		212	jmp xen_iret
		213	SYM_CODE_END(xenpv_restore_regs_and_return_to_usermode)
		214
195	/*	215	/*
196	* Xen handles syscall callbacks much like ordinary exceptions, which	216	* Xen handles syscall callbacks much like ordinary exceptions, which
197	* means we have:	217	* means we have:

block/fops.c+2−2

 #include <linux/falloc.h>
 #include <linux/suspend.h>
 #include <linux/fs.h>
+#include <linux/module.h>
 #include "blk.h"
 static inline struct inode *bdev_file_inode(struct file *file)
 	} else {
 		ret = bio_iov_iter_get_pages(bio, iter);
 		if (unlikely(ret)) {
-			bio->bi_status = BLK_STS_IOERR;
+			bio_put(bio);
-			bio_endio(bio);
 			return ret;
 		}
 	}

block/ioprio.c+3−0

 				pgrp = task_pgrp(current);
 			else
 				pgrp = find_vpid(who);
+			read_lock(&tasklist_lock);
 			do_each_pid_thread(pgrp, PIDTYPE_PGID, p) {
 				tmpio = get_task_ioprio(p);
 				if (tmpio < 0)
 				else
 					ret = ioprio_best(ret, tmpio);
 			} while_each_pid_thread(pgrp, PIDTYPE_PGID, p);
+			read_unlock(&tasklist_lock);
 			break;
 		case IOPRIO_WHO_USER:
 			uid = make_kuid(current_user_ns(), who);

drivers/android/binder.c+9−12

 	__release(&t->lock);
 	/*
-	 * If this thread used poll, make sure we remove the waitqueue
+	 * If this thread used poll, make sure we remove the waitqueue from any
-	 * from any epoll data structures holding it with POLLFREE.
+	 * poll data structures holding it.
-	 * waitqueue_active() is safe to use here because we're holding
-	 * the inner lock.
 	 */
-	if ((thread->looper & BINDER_LOOPER_STATE_POLL) &&
+	if (thread->looper & BINDER_LOOPER_STATE_POLL)
-	    waitqueue_active(&thread->wait)) {
+		wake_up_pollfree(&thread->wait);
-		wake_up_poll(&thread->wait, EPOLLHUP | POLLFREE);
-	}
 	binder_inner_proc_unlock(thread->proc);
 	/*
-	 * This is needed to avoid races between wake_up_poll() above and
+	 * This is needed to avoid races between wake_up_pollfree() above and
-	 * and ep_remove_waitqueue() called for other reasons (eg the epoll file
+	 * someone else removing the last entry from the queue for other reasons
-	 * descriptor being closed); ep_remove_waitqueue() holds an RCU read
+	 * (e.g. ep_remove_wait_queue() being called due to an epoll file
-	 * lock, so we can be sure it's done after calling synchronize_rcu().
+	 * descriptor being closed).  Such other users hold an RCU read lock, so
+	 * we can be sure they're done after we call synchronize_rcu().
 	 */
 	if (thread->looper & BINDER_LOOPER_STATE_POLL)
 		synchronize_rcu();

drivers/ata/ahci_ceva.c+2−1

 static unsigned int ceva_ahci_read_id(struct ata_device *dev,
 					struct ata_taskfile *tf, u16 *id)
 {
+	__le16 *__id = (__le16 *)id;
 	u32 err_mask;
 	err_mask = ata_do_dev_read_id(dev, tf, id);
 	 * Since CEVA controller does not support device sleep feature, we
 	 * need to clear DEVSLP (bit 8) in word78 of the IDENTIFY DEVICE data.
 	 */
-	id[ATA_ID_FEATURE_SUPP] &= cpu_to_le16(~(1 << 8));
+	__id[ATA_ID_FEATURE_SUPP] &= cpu_to_le16(~(1 << 8));
 	return 0;
 }

drivers/ata/libata-core.c+2−0

@@ -3920,6 +3920,8 @@ static const struct ata_blacklist_entry ata_device_blacklist [] = { · 3919 unmodified lines
3920	{ "VRFDFC22048UCHC-TE*", NULL, ATA_HORKAGE_NODMA },	3920	{ "VRFDFC22048UCHC-TE*", NULL, ATA_HORKAGE_NODMA },
3921	/* Odd clown on sil3726/4726 PMPs */	3921	/* Odd clown on sil3726/4726 PMPs */
3922	{ "Config Disk", NULL, ATA_HORKAGE_DISABLE },	3922	{ "Config Disk", NULL, ATA_HORKAGE_DISABLE },
		3923	/* Similar story with ASMedia 1092 */
		3924	{ "ASMT109x- Config", NULL, ATA_HORKAGE_DISABLE },
3923		3925
3924	/* Weird ATAPI devices */	3926	/* Weird ATAPI devices */
3925	{ "TORiSAN DVD-ROM DRD-N216", NULL, ATA_HORKAGE_MAX_SEC_128 },	3927	{ "TORiSAN DVD-ROM DRD-N216", NULL, ATA_HORKAGE_MAX_SEC_128 },

drivers/ata/libata-sata.c+1−1

@@ -827,7 +827,7 @@ static ssize_t ata_scsi_lpm_show(struct device *dev, · 826 unmodified lines
827	if (ap->target_lpm_policy >= ARRAY_SIZE(ata_lpm_policy_names))	827	if (ap->target_lpm_policy >= ARRAY_SIZE(ata_lpm_policy_names))
828	return -EINVAL;	828	return -EINVAL;
829		829
830	return snprintf(buf, PAGE_SIZE, "%s\n",	830	return sysfs_emit(buf, "%s\n",
831	ata_lpm_policy_names[ap->target_lpm_policy]);	831	ata_lpm_policy_names[ap->target_lpm_policy]);
832	}	832	}
833	DEVICE_ATTR(link_power_management_policy, S_IRUGO \| S_IWUSR,	833	DEVICE_ATTR(link_power_management_policy, S_IRUGO \| S_IWUSR,

drivers/ata/pata_falcon.c+8−8

@@ -55,14 +55,14 @@ static unsigned int pata_falcon_data_xfer(struct ata_queued_cmd *qc, · 54 unmodified lines
55	/* Transfer multiple of 2 bytes */	55	/* Transfer multiple of 2 bytes */
56	if (rw == READ) {	56	if (rw == READ) {
57	if (swap)	57	if (swap)
58	raw_insw_swapw((u16 )data_addr, (u16 )buf, words);	58	raw_insw_swapw(data_addr, (u16 *)buf, words);
59	else	59	else
60	raw_insw((u16 )data_addr, (u16 )buf, words);	60	raw_insw(data_addr, (u16 *)buf, words);
61	} else {	61	} else {
62	if (swap)	62	if (swap)
63	raw_outsw_swapw((u16 )data_addr, (u16 )buf, words);	63	raw_outsw_swapw(data_addr, (u16 *)buf, words);
64	else	64	else
65	raw_outsw((u16 )data_addr, (u16 )buf, words);	65	raw_outsw(data_addr, (u16 *)buf, words);
66	}	66	}
67		67
68	/* Transfer trailing byte, if any. */	68	/* Transfer trailing byte, if any. */
@@ -74,16 +74,16 @@ static unsigned int pata_falcon_data_xfer(struct ata_queued_cmd *qc, · 5 unmodified lines
74		74
75	if (rw == READ) {	75	if (rw == READ) {
76	if (swap)	76	if (swap)
77	raw_insw_swapw((u16 )data_addr, (u16 )pad, 1);	77	raw_insw_swapw(data_addr, (u16 *)pad, 1);
78	else	78	else
79	raw_insw((u16 )data_addr, (u16 )pad, 1);	79	raw_insw(data_addr, (u16 *)pad, 1);
80	*buf = pad[0];	80	*buf = pad[0];
81	} else {	81	} else {
82	pad[0] = *buf;	82	pad[0] = *buf;
83	if (swap)	83	if (swap)
84	raw_outsw_swapw((u16 )data_addr, (u16 )pad, 1);	84	raw_outsw_swapw(data_addr, (u16 *)pad, 1);
85	else	85	else
86	raw_outsw((u16 )data_addr, (u16 )pad, 1);	86	raw_outsw(data_addr, (u16 *)pad, 1);
87	}	87	}
88	words++;	88	words++;
89	}	89	}

drivers/ata/sata_fsl.c+13−7

 	return 0;
 }
+static void sata_fsl_host_stop(struct ata_host *host)
+{
+        struct sata_fsl_host_priv *host_priv = host->private_data;
+        iounmap(host_priv->hcr_base);
+        kfree(host_priv);
+}
 /*
  * scsi mid-layer and libata interface structures
  */
 	.port_start = sata_fsl_port_start,
 	.port_stop = sata_fsl_port_stop,
+	.host_stop      = sata_fsl_host_stop,
 	.pmp_attach = sata_fsl_pmp_attach,
 	.pmp_detach = sata_fsl_pmp_detach,
 };
 	host_priv->ssr_base = ssr_base;
 	host_priv->csr_base = csr_base;
-	irq = irq_of_parse_and_map(ofdev->dev.of_node, 0);
+	irq = platform_get_irq(ofdev, 0);
-	if (!irq) {
+	if (irq < 0) {
-		dev_err(&ofdev->dev, "invalid irq from platform\n");
+		retval = irq;
 		goto error_exit_with_cleanup;
 	}
 	host_priv->irq = irq;
 	ata_host_detach(host);
-	irq_dispose_mapping(host_priv->irq);
-	iounmap(host_priv->hcr_base);
-	kfree(host_priv);
 	return 0;
 }

drivers/block/loop.c+1−1

@@ -2103,7 +2103,7 @@ static int loop_control_remove(int idx) · 2102 unmodified lines
2103	int ret;	2103	int ret;
2104		2104
2105	if (idx < 0) {	2105	if (idx < 0) {
2106	pr_warn("deleting an unspecified loop device is not supported.\n");	2106	pr_warn_once("deleting an unspecified loop device is not supported.\n");
2107	return -EINVAL;	2107	return -EINVAL;
2108	}	2108	}
2109		2109

drivers/bus/mhi/core/pm.c+18−3

 }
 EXPORT_SYMBOL_GPL(mhi_pm_suspend);
-int mhi_pm_resume(struct mhi_controller *mhi_cntrl)
+static int __mhi_pm_resume(struct mhi_controller *mhi_cntrl, bool force)
 {
 	struct mhi_chan *itr, *tmp;
 	struct device *dev = &mhi_cntrl->mhi_dev->dev;
 	if (MHI_PM_IN_ERROR_STATE(mhi_cntrl->pm_state))
 		return -EIO;
-	if (mhi_get_mhi_state(mhi_cntrl) != MHI_STATE_M3)
+	if (mhi_get_mhi_state(mhi_cntrl) != MHI_STATE_M3) {
-		return -EINVAL;
+		dev_warn(dev, "Resuming from non M3 state (%s)\n",
+			 TO_MHI_STATE_STR(mhi_get_mhi_state(mhi_cntrl)));
+		if (!force)
+			return -EINVAL;
+	}
 	/* Notify clients about exiting LPM */
 	list_for_each_entry_safe(itr, tmp, &mhi_cntrl->lpm_chans, node) {
 	return 0;
 }
+int mhi_pm_resume(struct mhi_controller *mhi_cntrl)
+{
+	return __mhi_pm_resume(mhi_cntrl, false);
+}
 EXPORT_SYMBOL_GPL(mhi_pm_resume);
+int mhi_pm_resume_force(struct mhi_controller *mhi_cntrl)
+{
+	return __mhi_pm_resume(mhi_cntrl, true);
+}
+EXPORT_SYMBOL_GPL(mhi_pm_resume_force);
 int __mhi_device_get_sync(struct mhi_controller *mhi_cntrl)
 {
 	int ret;

drivers/bus/mhi/pci_generic.c+1−1

@@ -20,7 +20,7 @@ · 19 unmodified lines
20		20
21	#define MHI_PCI_DEFAULT_BAR_NUM 0	21	#define MHI_PCI_DEFAULT_BAR_NUM 0
22		22
23	#define MHI_POST_RESET_DELAY_MS 500	23	#define MHI_POST_RESET_DELAY_MS 2000
24		24
25	#define HEALTH_CHECK_PERIOD (HZ * 2)	25	#define HEALTH_CHECK_PERIOD (HZ * 2)
26		26

drivers/char/agp/parisc-agp.c+3−3

@@ -281,7 +281,7 @@ agp_ioc_init(void __iomem *ioc_regs) · 280 unmodified lines
281	return 0;	281	return 0;
282	}	282	}
283		283
284	static int	284	static int __init
285	lba_find_capability(int cap)	285	lba_find_capability(int cap)
286	{	286	{
287	struct _parisc_agp_info *info = &parisc_agp_info;	287	struct _parisc_agp_info *info = &parisc_agp_info;
@@ -366,7 +366,7 @@ fail: · 78 unmodified lines
366	return error;	366	return error;
367	}	367	}
368		368
369	static int	369	static int __init
370	find_quicksilver(struct device dev, void data)	370	find_quicksilver(struct device dev, void data)
371	{	371	{
372	struct parisc_device **lba = data;	372	struct parisc_device **lba = data;
@@ -378,7 +378,7 @@ find_quicksilver(struct device dev, void data) · 5 unmodified lines
378	return 0;	378	return 0;
379	}	379	}
380		380
381	static int	381	static int __init
382	parisc_agp_init(void)	382	parisc_agp_init(void)
383	{	383	{
384	extern struct sba_device *sba_list;	384	extern struct sba_device *sba_list;

drivers/char/ipmi/ipmi_msghandler.c+33−8

 	struct work_struct remove_work;
 };
+static struct workqueue_struct *remove_work_wq;
 static struct ipmi_user *acquire_ipmi_user(struct ipmi_user *user, int *index)
 	__acquires(user->release_barrier)
 {
 	struct ipmi_user *user = container_of(ref, struct ipmi_user, refcount);
 	/* SRCU cleanup must happen in task context. */
-	schedule_work(&user->remove_work);
+	queue_work(remove_work_wq, &user->remove_work);
 }
 static void _ipmi_destroy_user(struct ipmi_user *user)
 		/* We didn't find a user, deliver an error response. */
 		ipmi_inc_stat(intf, unhandled_commands);
-		msg->data[0] = ((netfn + 1) << 2) | (msg->rsp[4] & 0x3);
+		msg->data[0] = (netfn + 1) << 2;
-		msg->data[1] = msg->rsp[2];
+		msg->data[0] |= msg->rsp[2] & 0x3; /* rqLUN */
-		msg->data[2] = msg->rsp[4] & ~0x3;
+		msg->data[1] = msg->rsp[1]; /* Addr */
+		msg->data[2] = msg->rsp[2] & ~0x3; /* rqSeq */
+		msg->data[2] |= msg->rsp[0] & 0x3; /* rsLUN */
 		msg->data[3] = cmd;
 		msg->data[4] = IPMI_INVALID_CMD_COMPLETION_CODE;
 		msg->data_size = 5;
 		msg->rsp[2] = IPMI_ERR_UNSPECIFIED;
 		msg->rsp_size = 3;
 	} else if (msg->type == IPMI_SMI_MSG_TYPE_IPMB_DIRECT) {
-		/* commands must have at least 3 bytes, responses 4. */
+		/* commands must have at least 4 bytes, responses 5. */
-		if (is_cmd && (msg->rsp_size < 3)) {
+		if (is_cmd && (msg->rsp_size < 4)) {
 			ipmi_inc_stat(intf, invalid_commands);
 			goto out;
 		}
-		if (!is_cmd && (msg->rsp_size < 4))
+		if (!is_cmd && (msg->rsp_size < 5)) {
-			goto return_unspecified;
+			ipmi_inc_stat(intf, invalid_ipmb_responses);
+			/* Construct a valid error response. */
+			msg->rsp[0] = msg->data[0] & 0xfc; /* NetFN */
+			msg->rsp[0] |= (1 << 2); /* Make it a response */
+			msg->rsp[0] |= msg->data[2] & 3; /* rqLUN */
+			msg->rsp[1] = msg->data[1]; /* Addr */
+			msg->rsp[2] = msg->data[2] & 0xfc; /* rqSeq */
+			msg->rsp[2] |= msg->data[0] & 0x3; /* rsLUN */
+			msg->rsp[3] = msg->data[3]; /* Cmd */
+			msg->rsp[4] = IPMI_ERR_UNSPECIFIED;
+			msg->rsp_size = 5;
+		}
 	} else if ((msg->data_size >= 2)
 	    && (msg->data[0] == (IPMI_NETFN_APP_REQUEST << 2))
 	    && (msg->data[1] == IPMI_SEND_MSG_CMD)
 	if (rv) {
 		rv->done = free_smi_msg;
 		rv->user_data = NULL;
+		rv->type = IPMI_SMI_MSG_TYPE_NORMAL;
 		atomic_inc(&smi_msg_inuse_count);
 	}
 	return rv;
 	atomic_notifier_chain_register(&panic_notifier_list, &panic_block);
+	remove_work_wq = create_singlethread_workqueue("ipmi-msghandler-remove-wq");
+	if (!remove_work_wq) {
+		pr_err("unable to create ipmi-msghandler-remove-wq workqueue");
+		rv = -ENOMEM;
+		goto out;
+	}
 	initialized = true;
 out:
 	int count;
 	if (initialized) {
+		destroy_workqueue(remove_work_wq);
 		atomic_notifier_chain_unregister(&panic_notifier_list,
 						 &panic_block);

drivers/clk/imx/clk-imx8qxp-lpcg.c+1−1

@@ -370,7 +370,7 @@ static struct platform_driver imx8qxp_lpcg_clk_driver = { · 369 unmodified lines
370	.probe = imx8qxp_lpcg_clk_probe,	370	.probe = imx8qxp_lpcg_clk_probe,
371	};	371	};
372		372
373	builtin_platform_driver(imx8qxp_lpcg_clk_driver);	373	module_platform_driver(imx8qxp_lpcg_clk_driver);
374		374
375	MODULE_AUTHOR("Aisheng Dong <aisheng.dong@nxp.com>");	375	MODULE_AUTHOR("Aisheng Dong <aisheng.dong@nxp.com>");
376	MODULE_DESCRIPTION("NXP i.MX8QXP LPCG clock driver");	376	MODULE_DESCRIPTION("NXP i.MX8QXP LPCG clock driver");

drivers/clk/imx/clk-imx8qxp.c+1−1

@@ -308,7 +308,7 @@ static struct platform_driver imx8qxp_clk_driver = { · 307 unmodified lines
308	},	308	},
309	.probe = imx8qxp_clk_probe,	309	.probe = imx8qxp_clk_probe,
310	};	310	};
311	builtin_platform_driver(imx8qxp_clk_driver);	311	module_platform_driver(imx8qxp_clk_driver);
312		312
313	MODULE_AUTHOR("Aisheng Dong <aisheng.dong@nxp.com>");	313	MODULE_AUTHOR("Aisheng Dong <aisheng.dong@nxp.com>");
314	MODULE_DESCRIPTION("NXP i.MX8QXP clock driver");	314	MODULE_DESCRIPTION("NXP i.MX8QXP clock driver");

drivers/clk/qcom/clk-alpha-pll.c+9−0

@@ -1429,6 +1429,15 @@ EXPORT_SYMBOL_GPL(clk_alpha_pll_postdiv_fabia_ops); · 1428 unmodified lines
1429	void clk_trion_pll_configure(struct clk_alpha_pll pll, struct regmap regmap,	1429	void clk_trion_pll_configure(struct clk_alpha_pll pll, struct regmap regmap,
1430	const struct alpha_pll_config *config)	1430	const struct alpha_pll_config *config)
1431	{	1431	{
		1432	/*
		1433	* If the bootloader left the PLL enabled it's likely that there are
		1434	* RCGs that will lock up if we disable the PLL below.
		1435	*/
		1436	if (trion_pll_is_enabled(pll, regmap)) {
		1437	pr_debug("Trion PLL is already enabled, skipping configuration\n");
		1438	return;
		1439	}
		1440
1432	clk_alpha_pll_write_config(regmap, PLL_L_VAL(pll), config->l);	1441	clk_alpha_pll_write_config(regmap, PLL_L_VAL(pll), config->l);
1433	regmap_write(regmap, PLL_CAL_L_VAL(pll), TRION_PLL_CAL_VAL);	1442	regmap_write(regmap, PLL_CAL_L_VAL(pll), TRION_PLL_CAL_VAL);
1434	clk_alpha_pll_write_config(regmap, PLL_ALPHA_VAL(pll), config->alpha);	1443	clk_alpha_pll_write_config(regmap, PLL_ALPHA_VAL(pll), config->alpha);

drivers/clk/qcom/clk-regmap-mux.c+1−1

@@ -28,7 +28,7 @@ static u8 mux_get_parent(struct clk_hw *hw) · 27 unmodified lines
28	val &= mask;	28	val &= mask;
29		29
30	if (mux->parent_map)	30	if (mux->parent_map)
31	return qcom_find_src_index(hw, mux->parent_map, val);	31	return qcom_find_cfg_index(hw, mux->parent_map, val);
32		32
33	return val;	33	return val;
34	}	34	}

drivers/clk/qcom/common.c+12−0

@@ -69,6 +69,18 @@ int qcom_find_src_index(struct clk_hw hw, const struct parent_map map, u8 src) · 68 unmodified lines
69	}	69	}
70	EXPORT_SYMBOL_GPL(qcom_find_src_index);	70	EXPORT_SYMBOL_GPL(qcom_find_src_index);
71		71
		72	int qcom_find_cfg_index(struct clk_hw hw, const struct parent_map map, u8 cfg)
		73	{
		74	int i, num_parents = clk_hw_get_num_parents(hw);
		75
		76	for (i = 0; i < num_parents; i++)
		77	if (cfg == map[i].cfg)
		78	return i;
		79
		80	return -ENOENT;
		81	}
		82	EXPORT_SYMBOL_GPL(qcom_find_cfg_index);
		83
72	struct regmap *	84	struct regmap *
73	qcom_cc_map(struct platform_device pdev, const struct qcom_cc_desc desc)	85	qcom_cc_map(struct platform_device pdev, const struct qcom_cc_desc desc)
74	{	86	{

drivers/clk/qcom/common.h+2−0

@@ -49,6 +49,8 @@ extern void · 48 unmodified lines
49	qcom_pll_set_fsm_mode(struct regmap *m, u32 reg, u8 bias_count, u8 lock_count);	49	qcom_pll_set_fsm_mode(struct regmap *m, u32 reg, u8 bias_count, u8 lock_count);
50	extern int qcom_find_src_index(struct clk_hw hw, const struct parent_map map,	50	extern int qcom_find_src_index(struct clk_hw hw, const struct parent_map map,
51	u8 src);	51	u8 src);
		52	extern int qcom_find_cfg_index(struct clk_hw hw, const struct parent_map map,
		53	u8 cfg);
52		54
53	extern int qcom_cc_register_board_clk(struct device dev, const char path,	55	extern int qcom_cc_register_board_clk(struct device dev, const char path,
54	const char *name, unsigned long rate);	56	const char *name, unsigned long rate);

drivers/clk/qcom/gcc-sm6125.c+2−2

@@ -1121,7 +1121,7 @@ static struct clk_rcg2 gcc_sdcc1_apps_clk_src = { · 1120 unmodified lines
1121	.name = "gcc_sdcc1_apps_clk_src",	1121	.name = "gcc_sdcc1_apps_clk_src",
1122	.parent_data = gcc_parent_data_1,	1122	.parent_data = gcc_parent_data_1,
1123	.num_parents = ARRAY_SIZE(gcc_parent_data_1),	1123	.num_parents = ARRAY_SIZE(gcc_parent_data_1),
1124	.ops = &clk_rcg2_ops,	1124	.ops = &clk_rcg2_floor_ops,
1125	},	1125	},
1126	};	1126	};
1127		1127
@@ -1143,7 +1143,7 @@ static struct clk_rcg2 gcc_sdcc1_ice_core_clk_src = { · 15 unmodified lines
1143	.name = "gcc_sdcc1_ice_core_clk_src",	1143	.name = "gcc_sdcc1_ice_core_clk_src",
1144	.parent_data = gcc_parent_data_0,	1144	.parent_data = gcc_parent_data_0,
1145	.num_parents = ARRAY_SIZE(gcc_parent_data_0),	1145	.num_parents = ARRAY_SIZE(gcc_parent_data_0),
1146	.ops = &clk_rcg2_floor_ops,	1146	.ops = &clk_rcg2_ops,
1147	},	1147	},
1148	};	1148	};
1149		1149

drivers/clk/versatile/clk-icst.c+1−1

 	regclk = icst_clk_setup(NULL, &icst_desc, name, parent_name, map, ctype);
 	if (IS_ERR(regclk)) {
-		kfree(name);
 		pr_err("error setting up syscon ICST clock %s\n", name);
+		kfree(name);
 		return;
 	}
 	of_clk_add_provider(np, of_clk_src_simple_get, regclk);

drivers/clocksource/arm_arch_timer.c+7−2

 static atomic_t timer_unstable_counter_workaround_in_use = ATOMIC_INIT(0);
-static void erratum_set_next_event_generic(const int access, unsigned long evt,
+/*
-						struct clock_event_device *clk)
+ * Force the inlining of this function so that the register accesses
+ * can be themselves correctly inlined.
+ */
+static __always_inline
+void erratum_set_next_event_generic(const int access, unsigned long evt,
+				    struct clock_event_device *clk)
 {
 	unsigned long ctrl;
 	u64 cval;

drivers/clocksource/dw_apb_timer_of.c+1−1

@@ -47,7 +47,7 @@ static int __init timer_get_base_and_rate(struct device_node *np, · 46 unmodified lines
47	pr_warn("pclk for %pOFn is present, but could not be activated\n",	47	pr_warn("pclk for %pOFn is present, but could not be activated\n",
48	np);	48	np);
49		49
50	if (!of_property_read_u32(np, "clock-freq", rate) &&	50	if (!of_property_read_u32(np, "clock-freq", rate) \|\|
51	!of_property_read_u32(np, "clock-frequency", rate))	51	!of_property_read_u32(np, "clock-frequency", rate))
52	return 0;	52	return 0;
53		53

drivers/cpufreq/cpufreq.c+7−7

 	.release	= cpufreq_sysfs_release,
 };
-static void add_cpu_dev_symlink(struct cpufreq_policy *policy, unsigned int cpu)
+static void add_cpu_dev_symlink(struct cpufreq_policy *policy, unsigned int cpu,
+				struct device *dev)
 {
-	struct device *dev = get_cpu_device(cpu);
 	if (unlikely(!dev))
 		return;
 	if (policy->max_freq_req) {
 		/*
-		 * CPUFREQ_CREATE_POLICY notification is sent only after
+		 * Remove max_freq_req after sending CPUFREQ_REMOVE_POLICY
-		 * successfully adding max_freq_req request.
+		 * notification, since CPUFREQ_CREATE_POLICY notification was
+		 * sent after adding max_freq_req earlier.
 		 */
 		blocking_notifier_call_chain(&cpufreq_policy_notifier_list,
 					     CPUFREQ_REMOVE_POLICY, policy);
 	if (new_policy) {
 		for_each_cpu(j, policy->related_cpus) {
 			per_cpu(cpufreq_cpu_data, j) = policy;
-			add_cpu_dev_symlink(policy, j);
+			add_cpu_dev_symlink(policy, j, get_cpu_device(j));
 		}
 		policy->min_freq_req = kzalloc(2 * sizeof(*policy->min_freq_req),
 	/* Create sysfs link on CPU registration */
 	policy = per_cpu(cpufreq_cpu_data, cpu);
 	if (policy)
-		add_cpu_dev_symlink(policy, cpu);
+		add_cpu_dev_symlink(policy, cpu, dev);
 	return 0;
 }

drivers/dma-buf/heaps/system_heap.c+1−1

@@ -290,7 +290,7 @@ static void system_heap_dma_buf_release(struct dma_buf *dmabuf) · 289 unmodified lines
290	int i;	290	int i;
291		291
292	table = &buffer->sg_table;	292	table = &buffer->sg_table;
293	for_each_sg(table->sgl, sg, table->nents, i) {	293	for_each_sgtable_sg(table, sg, i) {
294	struct page *page = sg_page(sg);	294	struct page *page = sg_page(sg);
295		295
296	__free_pages(page, compound_order(page));	296	__free_pages(page, compound_order(page));

drivers/gpu/drm/amd/amdgpu/amdgpu_amdkfd_gpuvm.c+5−3

 	struct sg_table *sg = NULL;
 	uint64_t user_addr = 0;
 	struct amdgpu_bo *bo;
-	struct drm_gem_object *gobj;
+	struct drm_gem_object *gobj = NULL;
 	u32 domain, alloc_domain;
 	u64 alloc_flags;
 	int ret;
 	remove_kgd_mem_from_kfd_bo_list(*mem, avm->process_info);
 	drm_vma_node_revoke(&gobj->vma_node, drm_priv);
 err_node_allow:
-	drm_gem_object_put(gobj);
 	/* Don't unreserve system mem limit twice */
 	goto err_reserve_limit;
 err_bo_create:
 	unreserve_mem_limit(adev, size, alloc_domain, !!sg);
 err_reserve_limit:
 	mutex_destroy(&(*mem)->lock);
-	kfree(*mem);
+	if (gobj)
+		drm_gem_object_put(gobj);
+	else
+		kfree(*mem);
 err:
 	if (sg) {
 		sg_free_table(sg);

drivers/gpu/drm/amd/amdgpu/amdgpu_device.c+10−6

 	/* disable all interrupts */
 	amdgpu_irq_disable_all(adev);
 	if (adev->mode_info.mode_config_initialized){
-		if (!amdgpu_device_has_dc_support(adev))
+		if (!drm_drv_uses_atomic_modeset(adev_to_drm(adev)))
 			drm_helper_force_disable_all(adev_to_drm(adev));
 		else
 			drm_atomic_helper_shutdown(adev_to_drm(adev));
 {
 	int r;
+	amdgpu_amdkfd_pre_reset(adev);
 	if (from_hypervisor)
 		r = amdgpu_virt_request_full_gpu(adev, true);
 	else
 	amdgpu_irq_gpu_reset_resume_helper(adev);
 	r = amdgpu_ib_ring_tests(adev);
+	amdgpu_amdkfd_post_reset(adev);
 error:
 	if (!r && adev->virt.gim_feature & AMDGIM_FEATURE_GIM_FLR_VRAMLOST) {
 		cancel_delayed_work_sync(&tmp_adev->delayed_init_work);
-		amdgpu_amdkfd_pre_reset(tmp_adev);
+		if (!amdgpu_sriov_vf(tmp_adev))
+			amdgpu_amdkfd_pre_reset(tmp_adev);
 		/*
 		 * Mark these ASICs to be reseted as untracked first
 			drm_sched_start(&ring->sched, !tmp_adev->asic_reset_res);
 		}
-		if (!amdgpu_device_has_dc_support(tmp_adev) && !job_signaled) {
+		if (!drm_drv_uses_atomic_modeset(adev_to_drm(tmp_adev)) && !job_signaled) {
 			drm_helper_resume_force_mode(adev_to_drm(tmp_adev));
 		}
 skip_sched_resume:
 	list_for_each_entry(tmp_adev, device_list_handle, reset_list) {
-		/* unlock kfd */
+		/* unlock kfd: SRIOV would do it separately */
-		if (!need_emergency_restart)
+		if (!need_emergency_restart && !amdgpu_sriov_vf(tmp_adev))
-	                amdgpu_amdkfd_post_reset(tmp_adev);
+			amdgpu_amdkfd_post_reset(tmp_adev);
 		/* kfd_post_reset will do nothing if kfd device is not initialized,
 		 * need to bring up kfd here if it's not be initialized before

drivers/gpu/drm/amd/amdgpu/amdgpu_discovery.c+3−0

 	[HDP_HWIP]	= HDP_HWID,
 	[SDMA0_HWIP]	= SDMA0_HWID,
 	[SDMA1_HWIP]	= SDMA1_HWID,
+	[SDMA2_HWIP]    = SDMA2_HWID,
+	[SDMA3_HWIP]    = SDMA3_HWID,
 	[MMHUB_HWIP]	= MMHUB_HWID,
 	[ATHUB_HWIP]	= ATHUB_HWID,
 	[NBIO_HWIP]	= NBIF_HWID,
 		case IP_VERSION(3, 0, 64):
 		case IP_VERSION(3, 1, 1):
 		case IP_VERSION(3, 0, 2):
+		case IP_VERSION(3, 0, 192):
 			amdgpu_device_ip_block_add(adev, &vcn_v3_0_ip_block);
 			if (!amdgpu_sriov_vf(adev))
 				amdgpu_device_ip_block_add(adev, &jpeg_v3_0_ip_block);

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

@@ -135,6 +135,7 @@ int amdgpu_vcn_sw_init(struct amdgpu_device *adev) · 134 unmodified lines
135	break;	135	break;
136	case IP_VERSION(3, 0, 0):	136	case IP_VERSION(3, 0, 0):
137	case IP_VERSION(3, 0, 64):	137	case IP_VERSION(3, 0, 64):
		138	case IP_VERSION(3, 0, 192):
138	if (adev->ip_versions[GC_HWIP][0] == IP_VERSION(10, 3, 0))	139	if (adev->ip_versions[GC_HWIP][0] == IP_VERSION(10, 3, 0))
139	fw_name = FIRMWARE_SIENNA_CICHLID;	140	fw_name = FIRMWARE_SIENNA_CICHLID;
140	else	141	else

drivers/gpu/drm/amd/amdgpu/amdgpu_vkms.c+2−2

@@ -504,8 +504,8 @@ static int amdgpu_vkms_sw_fini(void *handle) · 503 unmodified lines
504	int i = 0;	504	int i = 0;
505		505
506	for (i = 0; i < adev->mode_info.num_crtc; i++)	506	for (i = 0; i < adev->mode_info.num_crtc; i++)
507	if (adev->mode_info.crtcs[i])	507	if (adev->amdgpu_vkms_output[i].vblank_hrtimer.function)
508	hrtimer_cancel(&adev->mode_info.crtcs[i]->vblank_timer);	508	hrtimer_cancel(&adev->amdgpu_vkms_output[i].vblank_hrtimer);
509		509
510	kfree(adev->mode_info.bios_hardcoded_edid);	510	kfree(adev->mode_info.bios_hardcoded_edid);
511	kfree(adev->amdgpu_vkms_output);	511	kfree(adev->amdgpu_vkms_output);

drivers/gpu/drm/amd/amdgpu/gfx_v9_0.c+4−3

@@ -4060,9 +4060,10 @@ static int gfx_v9_0_hw_fini(void *handle) · 4059 unmodified lines
4060		4060
4061	gfx_v9_0_cp_enable(adev, false);	4061	gfx_v9_0_cp_enable(adev, false);
4062		4062
4063	/* Skip suspend with A+A reset */	4063	/* Skip stopping RLC with A+A reset or when RLC controls GFX clock */
4064	if (adev->gmc.xgmi.connected_to_cpu && amdgpu_in_reset(adev)) {	4064	if ((adev->gmc.xgmi.connected_to_cpu && amdgpu_in_reset(adev)) \|\|
4065	dev_dbg(adev->dev, "Device in reset. Skipping RLC halt\n");	4065	(adev->ip_versions[GC_HWIP][0] >= IP_VERSION(9, 4, 2))) {
		4066	dev_dbg(adev->dev, "Skipping RLC halt\n");
4066	return 0;	4067	return 0;
4067	}	4068	}
4068		4069

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

@@ -183,6 +183,7 @@ static int nv_query_video_codecs(struct amdgpu_device *adev, bool encode, · 182 unmodified lines
183	switch (adev->ip_versions[UVD_HWIP][0]) {	183	switch (adev->ip_versions[UVD_HWIP][0]) {
184	case IP_VERSION(3, 0, 0):	184	case IP_VERSION(3, 0, 0):
185	case IP_VERSION(3, 0, 64):	185	case IP_VERSION(3, 0, 64):
		186	case IP_VERSION(3, 0, 192):
186	if (amdgpu_sriov_vf(adev)) {	187	if (amdgpu_sriov_vf(adev)) {
187	if (encode)	188	if (encode)
188	*codecs = &sriov_sc_video_codecs_encode;	189	*codecs = &sriov_sc_video_codecs_encode;

drivers/gpu/drm/amd/amdkfd/kfd_svm.c+4−9

 static void svm_range_restore_work(struct work_struct *work)
 {
 	struct delayed_work *dwork = to_delayed_work(work);
-	struct amdkfd_process_info *process_info;
 	struct svm_range_list *svms;
 	struct svm_range *prange;
 	struct kfd_process *p;
 	 * the lifetime of this thread, kfd_process and mm will be valid.
 	 */
 	p = container_of(svms, struct kfd_process, svms);
-	process_info = p->kgd_process_info;
 	mm = p->mm;
 	if (!mm)
 		return;
-	mutex_lock(&process_info->lock);
 	svm_range_list_lock_and_flush_work(svms, mm);
 	mutex_lock(&svms->lock);
 out_reschedule:
 	mutex_unlock(&svms->lock);
 	mmap_write_unlock(mm);
-	mutex_unlock(&process_info->lock);
 	/* If validation failed, reschedule another attempt */
 	if (evicted_ranges) {
 	if (atomic_read(&svms->drain_pagefaults)) {
 		pr_debug("draining retry fault, drop fault 0x%llx\n", addr);
+		r = 0;
 		goto out;
 	}
 	mm = get_task_mm(p->lead_thread);
 	if (!mm) {
 		pr_debug("svms 0x%p failed to get mm\n", svms);
+		r = 0;
 		goto out;
 	}
 	if (svm_range_skip_recover(prange)) {
 		amdgpu_gmc_filter_faults_remove(adev, addr, pasid);
+		r = 0;
 		goto out_unlock_range;
 	}
 	if (timestamp < AMDGPU_SVM_RANGE_RETRY_FAULT_PENDING) {
 		pr_debug("svms 0x%p [0x%lx %lx] already restored\n",
 			 svms, prange->start, prange->last);
+		r = 0;
 		goto out_unlock_range;
 	}
 svm_range_set_attr(struct kfd_process *p, uint64_t start, uint64_t size,
 		   uint32_t nattr, struct kfd_ioctl_svm_attribute *attrs)
 {
-	struct amdkfd_process_info *process_info = p->kgd_process_info;
 	struct mm_struct *mm = current->mm;
 	struct list_head update_list;
 	struct list_head insert_list;
 	svms = &p->svms;
-	mutex_lock(&process_info->lock);
 	svm_range_list_lock_and_flush_work(svms, mm);
 	r = svm_range_is_valid(p, start, size);
 	mutex_unlock(&svms->lock);
 	mmap_read_unlock(mm);
 out:
-	mutex_unlock(&process_info->lock);
 	pr_debug("pasid 0x%x svms 0x%p [0x%llx 0x%llx] done, r=%d\n", p->pasid,
 		 &p->svms, start, start + size - 1, r);

drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c+6−1

 		 */
 		link_enc_cfg_init(dm->dc, dc_state);
-		amdgpu_dm_outbox_init(adev);
+		if (dc_enable_dmub_notifications(adev->dm.dc))
+			amdgpu_dm_outbox_init(adev);
 		r = dm_dmub_hw_init(adev);
 		if (r)
 	/* TODO: Remove dc_state->dccg, use dc->dccg directly. */
 	dc_resource_state_construct(dm->dc, dm_state->context);
+	/* Re-enable outbox interrupts for DPIA. */
+	if (dc_enable_dmub_notifications(adev->dm.dc))
+		amdgpu_dm_outbox_init(adev);
 	/* Before powering on DC we need to re-initialize DMUB. */
 	r = dm_dmub_hw_init(adev);
 	if (r)

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

@@ -314,6 +314,14 @@ int amdgpu_dm_crtc_set_crc_source(struct drm_crtc crtc, const char src_name) · 313 unmodified lines
314	ret = -EINVAL;	314	ret = -EINVAL;
315	goto cleanup;	315	goto cleanup;
316	}	316	}
		317
		318	if ((aconn->base.connector_type != DRM_MODE_CONNECTOR_DisplayPort) &&
		319	(aconn->base.connector_type != DRM_MODE_CONNECTOR_eDP)) {
		320	DRM_DEBUG_DRIVER("No DP connector available for CRC source\n");
		321	ret = -EINVAL;
		322	goto cleanup;
		323	}
		324
317	}	325	}
318		326
319	#if defined(CONFIG_DRM_AMD_SECURE_DISPLAY)	327	#if defined(CONFIG_DRM_AMD_SECURE_DISPLAY)

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

@@ -36,6 +36,8 @@ · 35 unmodified lines
36	#include "dm_helpers.h"	36	#include "dm_helpers.h"
37		37
38	#include "dc_link_ddc.h"	38	#include "dc_link_ddc.h"
		39	#include "ddc_service_types.h"
		40	#include "dpcd_defs.h"
39		41
40	#include "i2caux_interface.h"	42	#include "i2caux_interface.h"
41	#include "dmub_cmd.h"	43	#include "dmub_cmd.h"
@@ -157,6 +159,16 @@ static const struct drm_connector_funcs dm_dp_mst_connector_funcs = { · 115 unmodified lines
157	};	159	};
158		160
159	#if defined(CONFIG_DRM_AMD_DC_DCN)	161	#if defined(CONFIG_DRM_AMD_DC_DCN)
		162	static bool needs_dsc_aux_workaround(struct dc_link *link)
		163	{
		164	if (link->dpcd_caps.branch_dev_id == DP_BRANCH_DEVICE_ID_90CC24 &&
		165	(link->dpcd_caps.dpcd_rev.raw == DPCD_REV_14 \|\| link->dpcd_caps.dpcd_rev.raw == DPCD_REV_12) &&
		166	link->dpcd_caps.sink_count.bits.SINK_COUNT >= 2)
		167	return true;
		168
		169	return false;
		170	}
		171
160	static bool validate_dsc_caps_on_connector(struct amdgpu_dm_connector *aconnector)	172	static bool validate_dsc_caps_on_connector(struct amdgpu_dm_connector *aconnector)
161	{	173	{
162	struct dc_sink *dc_sink = aconnector->dc_sink;	174	struct dc_sink *dc_sink = aconnector->dc_sink;
@@ -166,7 +178,7 @@ static bool validate_dsc_caps_on_connector(struct amdgpu_dm_connector *aconnecto · 3 unmodified lines
166	u8 *dsc_branch_dec_caps = NULL;	178	u8 *dsc_branch_dec_caps = NULL;
167		179
168	aconnector->dsc_aux = drm_dp_mst_dsc_aux_for_port(port);	180	aconnector->dsc_aux = drm_dp_mst_dsc_aux_for_port(port);
169	#if defined(CONFIG_HP_HOOK_WORKAROUND)	181
170	/*	182	/*
171	* drm_dp_mst_dsc_aux_for_port() will return NULL for certain configs	183	* drm_dp_mst_dsc_aux_for_port() will return NULL for certain configs
172	* because it only check the dsc/fec caps of the "port variable" and not the dock	184	* because it only check the dsc/fec caps of the "port variable" and not the dock
@@ -176,10 +188,10 @@ static bool validate_dsc_caps_on_connector(struct amdgpu_dm_connector *aconnecto · 3 unmodified lines
176	* Workaround: explicitly check the use case above and use the mst dock's aux as dsc_aux	188	* Workaround: explicitly check the use case above and use the mst dock's aux as dsc_aux
177	*	189	*
178	*/	190	*/
179		191	if (!aconnector->dsc_aux && !port->parent->port_parent &&
180	if (!aconnector->dsc_aux && !port->parent->port_parent)	192	needs_dsc_aux_workaround(aconnector->dc_link))
181	aconnector->dsc_aux = &aconnector->mst_port->dm_dp_aux.aux;	193	aconnector->dsc_aux = &aconnector->mst_port->dm_dp_aux.aux;
182	#endif	194
183	if (!aconnector->dsc_aux)	195	if (!aconnector->dsc_aux)
184	return false;	196	return false;
185		197

drivers/gpu/drm/amd/display/dc/core/dc_link.c+16−0

@@ -758,6 +758,18 @@ static bool detect_dp(struct dc_link *link, · 757 unmodified lines
758	dal_ddc_service_set_transaction_type(link->ddc,	758	dal_ddc_service_set_transaction_type(link->ddc,
759	sink_caps->transaction_type);	759	sink_caps->transaction_type);
760		760
		761	#if defined(CONFIG_DRM_AMD_DC_DCN)
		762	/* Apply work around for tunneled MST on certain USB4 docks. Always use DSC if dock
		763	* reports DSC support.
		764	*/
		765	if (link->ep_type == DISPLAY_ENDPOINT_USB4_DPIA &&
		766	link->type == dc_connection_mst_branch &&
		767	link->dpcd_caps.branch_dev_id == DP_BRANCH_DEVICE_ID_90CC24 &&
		768	link->dpcd_caps.dsc_caps.dsc_basic_caps.fields.dsc_support.DSC_SUPPORT &&
		769	!link->dc->debug.dpia_debug.bits.disable_mst_dsc_work_around)
		770	link->wa_flags.dpia_mst_dsc_always_on = true;
		771	#endif
		772
761	#if defined(CONFIG_DRM_AMD_DC_HDCP)	773	#if defined(CONFIG_DRM_AMD_DC_HDCP)
762	/* In case of fallback to SST when topology discovery below fails	774	/* In case of fallback to SST when topology discovery below fails
763	* HDCP caps will be querried again later by the upper layer (caller	775	* HDCP caps will be querried again later by the upper layer (caller
@@ -1203,6 +1215,10 @@ static bool dc_link_detect_helper(struct dc_link *link, · 439 unmodified lines
1203	LINK_INFO("link=%d, mst branch is now Disconnected\n",	1215	LINK_INFO("link=%d, mst branch is now Disconnected\n",
1204	link->link_index);	1216	link->link_index);
1205		1217
		1218	/* Disable work around which keeps DSC on for tunneled MST on certain USB4 docks. */
		1219	if (link->ep_type == DISPLAY_ENDPOINT_USB4_DPIA)
		1220	link->wa_flags.dpia_mst_dsc_always_on = false;
		1221
1206	dm_helpers_dp_mst_stop_top_mgr(link->ctx, link);	1222	dm_helpers_dp_mst_stop_top_mgr(link->ctx, link);
1207		1223
1208	link->mst_stream_alloc_table.stream_count = 0;	1224	link->mst_stream_alloc_table.stream_count = 0;

drivers/gpu/drm/amd/display/dc/core/dc_link_dp.c+1−1

@@ -2138,7 +2138,7 @@ static enum link_training_result dp_perform_8b_10b_link_training( · 2137 unmodified lines
2138	}	2138	}
2139		2139
2140	for (lane = 0; lane < (uint8_t)lt_settings->link_settings.lane_count; lane++)	2140	for (lane = 0; lane < (uint8_t)lt_settings->link_settings.lane_count; lane++)
2141	lt_settings->dpcd_lane_settings[lane].bits.VOLTAGE_SWING_SET = VOLTAGE_SWING_LEVEL0;	2141	lt_settings->dpcd_lane_settings[lane].raw = 0;
2142	}	2142	}
2143		2143
2144	if (status == LINK_TRAINING_SUCCESS) {	2144	if (status == LINK_TRAINING_SUCCESS) {

drivers/gpu/drm/amd/display/dc/core/dc_resource.c+14−10

 	if (old_stream->ignore_msa_timing_param != stream->ignore_msa_timing_param)
 		return false;
+	// Only Have Audio left to check whether it is same or not. This is a corner case for Tiled sinks
+	if (old_stream->audio_info.mode_count != stream->audio_info.mode_count)
+		return false;
 	return true;
 }
 	if (!new_ctx)
 		return DC_ERROR_UNEXPECTED;
-#if defined(CONFIG_DRM_AMD_DC_DCN)
-	/*
-	 * Update link encoder to stream assignment.
-	 * TODO: Split out reason allocation from validation.
-	 */
-	if (dc->res_pool->funcs->link_encs_assign && fast_validate == false)
-		dc->res_pool->funcs->link_encs_assign(
-			dc, new_ctx, new_ctx->streams, new_ctx->stream_count);
-#endif
 	if (dc->res_pool->funcs->validate_global) {
 		result = dc->res_pool->funcs->validate_global(dc, new_ctx);
 		if (!dc->res_pool->funcs->validate_bandwidth(dc, new_ctx, fast_validate))
 			result = DC_FAIL_BANDWIDTH_VALIDATE;
+#if defined(CONFIG_DRM_AMD_DC_DCN)
+	/*
+	 * Only update link encoder to stream assignment after bandwidth validation passed.
+	 * TODO: Split out assignment and validation.
+	 */
+	if (result == DC_OK && dc->res_pool->funcs->link_encs_assign && fast_validate == false)
+		dc->res_pool->funcs->link_encs_assign(
+			dc, new_ctx, new_ctx->streams, new_ctx->stream_count);
+#endif
 	return result;
 }

drivers/gpu/drm/amd/display/dc/dc.h+2−1

 		uint32_t disable_dpia:1;
 		uint32_t force_non_lttpr:1;
 		uint32_t extend_aux_rd_interval:1;
-		uint32_t reserved:29;
+		uint32_t disable_mst_dsc_work_around:1;
+		uint32_t reserved:28;
 	} bits;
 	uint32_t raw;
 };

drivers/gpu/drm/amd/display/dc/dc_link.h+4−0

 		bool dp_skip_DID2;
 		bool dp_skip_reset_segment;
 		bool dp_mot_reset_segment;
+		/* Some USB4 docks do not handle turning off MST DSC once it has been enabled. */
+		bool dpia_mst_dsc_always_on;
 	} wa_flags;
 	struct link_mst_stream_allocation_table mst_stream_alloc_table;
 	*edp_num = 0;
 	for (i = 0; i < dc->link_count; i++) {
 		// report any eDP links, even unconnected DDI's
+		if (!dc->links[i])
+			continue;
 		if (dc->links[i]->connector_signal == SIGNAL_TYPE_EDP) {
 			edp_links[*edp_num] = dc->links[i];
 			if (++(*edp_num) == MAX_NUM_EDP)

drivers/gpu/drm/amd/pm/swsmu/amdgpu_smu.c+1−1

@@ -1468,7 +1468,7 @@ static int smu_disable_dpms(struct smu_context *smu) · 1467 unmodified lines
1468	dev_err(adev->dev, "Failed to disable smu features.\n");	1468	dev_err(adev->dev, "Failed to disable smu features.\n");
1469	}	1469	}
1470		1470
1471	if (adev->ip_versions[GC_HWIP][0] >= IP_VERSION(10, 0, 0) &&	1471	if (adev->ip_versions[GC_HWIP][0] >= IP_VERSION(9, 4, 2) &&
1472	adev->gfx.rlc.funcs->stop)	1472	adev->gfx.rlc.funcs->stop)
1473	adev->gfx.rlc.funcs->stop(adev);	1473	adev->gfx.rlc.funcs->stop(adev);
1474		1474

drivers/gpu/drm/drm_gem_shmem_helper.c+1−0

@@ -9,6 +9,7 @@ · 8 unmodified lines
9	#include <linux/shmem_fs.h>	9	#include <linux/shmem_fs.h>
10	#include <linux/slab.h>	10	#include <linux/slab.h>
11	#include <linux/vmalloc.h>	11	#include <linux/vmalloc.h>
		12	#include <linux/module.h>
12		13
13	#ifdef CONFIG_X86	14	#ifdef CONFIG_X86
14	#include <asm/set_memory.h>	15	#include <asm/set_memory.h>

drivers/gpu/drm/drm_syncobj.c+10−1

@@ -404,8 +404,17 @@ int drm_syncobj_find_fence(struct drm_file *file_private, · 403 unmodified lines
404		404
405	if (*fence) {	405	if (*fence) {
406	ret = dma_fence_chain_find_seqno(fence, point);	406	ret = dma_fence_chain_find_seqno(fence, point);
407	if (!ret)	407	if (!ret) {
		408	/* If the requested seqno is already signaled
		409	* drm_syncobj_find_fence may return a NULL
		410	* fence. To make sure the recipient gets
		411	* signalled, use a new fence instead.
		412	*/
		413	if (!*fence)
		414	*fence = dma_fence_get_stub();
		415
408	goto out;	416	goto out;
		417	}
409	dma_fence_put(*fence);	418	dma_fence_put(*fence);
410	} else {	419	} else {
411	ret = -EINVAL;	420	ret = -EINVAL;

drivers/gpu/drm/i915/display/intel_display_types.h+3−0

@@ -1640,6 +1640,9 @@ struct intel_dp { · 1639 unmodified lines
1640	struct intel_dp_pcon_frl frl;	1640	struct intel_dp_pcon_frl frl;
1641		1641
1642	struct intel_psr psr;	1642	struct intel_psr psr;
		1643
		1644	/* When we last wrote the OUI for eDP */
		1645	unsigned long last_oui_write;
1643	};	1646	};
1644		1647
1645	enum lspcon_vendor {	1648	enum lspcon_vendor {

drivers/gpu/drm/i915/display/intel_dp.c+11−0

 #include <linux/i2c.h>
 #include <linux/notifier.h>
 #include <linux/slab.h>
+#include <linux/timekeeping.h>
 #include <linux/types.h>
 #include <asm/byteorder.h>
 	if (drm_dp_dpcd_write(&intel_dp->aux, DP_SOURCE_OUI, oui, sizeof(oui)) < 0)
 		drm_err(&i915->drm, "Failed to write source OUI\n");
+	intel_dp->last_oui_write = jiffies;
+}
+void intel_dp_wait_source_oui(struct intel_dp *intel_dp)
+{
+	struct drm_i915_private *i915 = dp_to_i915(intel_dp);
+	drm_dbg_kms(&i915->drm, "Performing OUI wait\n");
+	wait_remaining_ms_from_jiffies(intel_dp->last_oui_write, 30);
 }
 /* If the device supports it, try to set the power state appropriately */

drivers/gpu/drm/i915/display/intel_dp.h+2−0

@@ -119,4 +119,6 @@ void intel_dp_pcon_dsc_configure(struct intel_dp *intel_dp, · 118 unmodified lines
119	const struct intel_crtc_state *crtc_state);	119	const struct intel_crtc_state *crtc_state);
120	void intel_dp_phy_test(struct intel_encoder *encoder);	120	void intel_dp_phy_test(struct intel_encoder *encoder);
121		121
		122	void intel_dp_wait_source_oui(struct intel_dp *intel_dp);
		123
122	#endif /* __INTEL_DP_H__ */	124	#endif /* __INTEL_DP_H__ */

drivers/gpu/drm/i915/display/intel_dp_aux_backlight.c+26−6

 #include "intel_backlight.h"
 #include "intel_display_types.h"
+#include "intel_dp.h"
 #include "intel_dp_aux_backlight.h"
 /* TODO:
 	int ret;
 	u8 tcon_cap[4];
+	intel_dp_wait_source_oui(intel_dp);
 	ret = drm_dp_dpcd_read(aux, INTEL_EDP_HDR_TCON_CAP0, tcon_cap, sizeof(tcon_cap));
 	if (ret != sizeof(tcon_cap))
 		return false;
 	int ret;
 	u8 old_ctrl, ctrl;
+	intel_dp_wait_source_oui(intel_dp);
 	ret = drm_dp_dpcd_readb(&intel_dp->aux, INTEL_EDP_HDR_GETSET_CTRL_PARAMS, &old_ctrl);
 	if (ret != 1) {
 		drm_err(&i915->drm, "Failed to read current backlight control mode: %d\n", ret);
 	struct intel_panel *panel = &connector->panel;
 	struct intel_dp *intel_dp = enc_to_intel_dp(connector->encoder);
+	if (!panel->backlight.edp.vesa.info.aux_enable) {
+		u32 pwm_level = intel_backlight_invert_pwm_level(connector,
+								 panel->backlight.pwm_level_max);
+		panel->backlight.pwm_funcs->enable(crtc_state, conn_state, pwm_level);
+	}
 	drm_edp_backlight_enable(&intel_dp->aux, &panel->backlight.edp.vesa.info, level);
 }
 	struct intel_dp *intel_dp = enc_to_intel_dp(connector->encoder);
 	drm_edp_backlight_disable(&intel_dp->aux, &panel->backlight.edp.vesa.info);
+	if (!panel->backlight.edp.vesa.info.aux_enable)
+		panel->backlight.pwm_funcs->disable(old_conn_state,
+						    intel_backlight_invert_pwm_level(connector, 0));
 }
 static int intel_dp_aux_vesa_setup_backlight(struct intel_connector *connector, enum pipe pipe)
 	if (ret < 0)
 		return ret;
+	if (!panel->backlight.edp.vesa.info.aux_enable) {
+		ret = panel->backlight.pwm_funcs->setup(connector, pipe);
+		if (ret < 0) {
+			drm_err(&i915->drm,
+				"Failed to setup PWM backlight controls for eDP backlight: %d\n",
+				ret);
+			return ret;
+		}
+	}
 	panel->backlight.max = panel->backlight.edp.vesa.info.max;
 	panel->backlight.min = 0;
 	if (current_mode == DP_EDP_BACKLIGHT_CONTROL_MODE_DPCD) {
 	struct intel_dp *intel_dp = intel_attached_dp(connector);
 	struct drm_i915_private *i915 = dp_to_i915(intel_dp);
-	/* TODO: We currently only support AUX only backlight configurations, not backlights which
+	if (drm_edp_backlight_supported(intel_dp->edp_dpcd)) {
-	 * require a mix of PWM and AUX controls to work. In the mean time, these machines typically
-	 * work just fine using normal PWM controls anyway.
-	 */
-	if ((intel_dp->edp_dpcd[1] & DP_EDP_BACKLIGHT_AUX_ENABLE_CAP) &&
-	    drm_edp_backlight_supported(intel_dp->edp_dpcd)) {
 		drm_dbg_kms(&i915->drm, "AUX Backlight Control Supported!\n");
 		return true;
 	}

drivers/gpu/drm/i915/gem/i915_gem_execbuffer.c+1−0

@@ -3277,6 +3277,7 @@ i915_gem_do_execbuffer(struct drm_device *dev, · 3276 unmodified lines
3277	out_fence = eb_requests_create(&eb, in_fence, out_fence_fd);	3277	out_fence = eb_requests_create(&eb, in_fence, out_fence_fd);
3278	if (IS_ERR(out_fence)) {	3278	if (IS_ERR(out_fence)) {
3279	err = PTR_ERR(out_fence);	3279	err = PTR_ERR(out_fence);
		3280	out_fence = NULL;
3280	if (eb.requests[0])	3281	if (eb.requests[0])
3281	goto err_request;	3282	goto err_request;
3282	else	3283	else

drivers/gpu/drm/i915/gt/intel_gtt.c+1−0

@@ -6,6 +6,7 @@ · 5 unmodified lines
6	#include <linux/slab.h> /* fault-inject.h is not standalone! */	6	#include <linux/slab.h> /* fault-inject.h is not standalone! */
7		7
8	#include <linux/fault-inject.h>	8	#include <linux/fault-inject.h>
		9	#include <linux/sched/mm.h>
9		10
10	#include "gem/i915_gem_lmem.h"	11	#include "gem/i915_gem_lmem.h"
11	#include "i915_trace.h"	12	#include "i915_trace.h"

drivers/gpu/drm/i915/gt/intel_workarounds.c+9−16

 	       FF_MODE2_GS_TIMER_MASK,
 	       FF_MODE2_GS_TIMER_224,
 	       0, false);
-	/*
-	 * Wa_14012131227:dg1
-	 * Wa_1508744258:tgl,rkl,dg1,adl-s,adl-p
-	 */
-	wa_masked_en(wal, GEN7_COMMON_SLICE_CHICKEN1,
-		     GEN9_RHWO_OPTIMIZATION_DISABLE);
 }
 static void dg1_ctx_workarounds_init(struct intel_engine_cs *engine,
 		    GAMT_CHKN_BIT_REG,
 		    GAMT_CHKN_DISABLE_L3_COH_PIPE);
+	/* Wa_1407352427:icl,ehl */
+	wa_write_or(wal, UNSLICE_UNIT_LEVEL_CLKGATE2,
+		    PSDUNIT_CLKGATE_DIS);
+	/* Wa_1406680159:icl,ehl */
+	wa_write_or(wal,
+		    SUBSLICE_UNIT_LEVEL_CLKGATE,
+		    GWUNIT_CLKGATE_DIS);
 	/* Wa_1607087056:icl,ehl,jsl */
 	if (IS_ICELAKE(i915) ||
 	    IS_JSL_EHL_GT_STEP(i915, STEP_A0, STEP_B0))
 		wa_write_or(wal, UNSLICE_UNIT_LEVEL_CLKGATE,
 			    VSUNIT_CLKGATE_DIS | HSUNIT_CLKGATE_DIS);
-		/* Wa_1407352427:icl,ehl */
-		wa_write_or(wal, UNSLICE_UNIT_LEVEL_CLKGATE2,
-			    PSDUNIT_CLKGATE_DIS);
-		/* Wa_1406680159:icl,ehl */
-		wa_write_or(wal,
-			    SUBSLICE_UNIT_LEVEL_CLKGATE,
-			    GWUNIT_CLKGATE_DIS);
 		/*
 		 * Wa_1408767742:icl[a2..forever],ehl[all]
 		 * Wa_1605460711:icl[a0..c0]

drivers/gpu/drm/i915/i915_request.c+1−0

@@ -29,6 +29,7 @@ · 28 unmodified lines
29	#include <linux/sched.h>	29	#include <linux/sched.h>
30	#include <linux/sched/clock.h>	30	#include <linux/sched/clock.h>
31	#include <linux/sched/signal.h>	31	#include <linux/sched/signal.h>
		32	#include <linux/sched/mm.h>
32		33
33	#include "gem/i915_gem_context.h"	34	#include "gem/i915_gem_context.h"
34	#include "gt/intel_breadcrumbs.h"	35	#include "gt/intel_breadcrumbs.h"

drivers/gpu/drm/lima/lima_device.c+1−0

@@ -4,6 +4,7 @@ · 3 unmodified lines
4	#include <linux/regulator/consumer.h>	4	#include <linux/regulator/consumer.h>
5	#include <linux/reset.h>	5	#include <linux/reset.h>
6	#include <linux/clk.h>	6	#include <linux/clk.h>
		7	#include <linux/slab.h>
7	#include <linux/dma-mapping.h>	8	#include <linux/dma-mapping.h>
8	#include <linux/platform_device.h>	9	#include <linux/platform_device.h>
9		10

drivers/gpu/drm/msm/Kconfig+1−1

 	tristate "MSM DRM"
 	depends on DRM
 	depends on ARCH_QCOM || SOC_IMX5 || COMPILE_TEST
+	depends on COMMON_CLK
 	depends on IOMMU_SUPPORT
-	depends on (OF && COMMON_CLK) || COMPILE_TEST
 	depends on QCOM_OCMEM || QCOM_OCMEM=n
 	depends on QCOM_LLCC || QCOM_LLCC=n
 	depends on QCOM_COMMAND_DB || QCOM_COMMAND_DB=n

drivers/gpu/drm/msm/Makefile+3−3

 	hdmi/hdmi_i2c.o \
 	hdmi/hdmi_phy.o \
 	hdmi/hdmi_phy_8960.o \
+	hdmi/hdmi_phy_8996.o \
 	hdmi/hdmi_phy_8x60.o \
 	hdmi/hdmi_phy_8x74.o \
+	hdmi/hdmi_pll_8960.o \
 	edp/edp.o \
 	edp/edp_aux.o \
 	edp/edp_bridge.o \
 	disp/mdp4/mdp4_dtv_encoder.o \
 	disp/mdp4/mdp4_lcdc_encoder.o \
 	disp/mdp4/mdp4_lvds_connector.o \
+	disp/mdp4/mdp4_lvds_pll.o \
 	disp/mdp4/mdp4_irq.o \
 	disp/mdp4/mdp4_kms.o \
 	disp/mdp4/mdp4_plane.o \
 	dp/dp_audio.o
 msm-$(CONFIG_DRM_FBDEV_EMULATION) += msm_fbdev.o
-msm-$(CONFIG_COMMON_CLK) += disp/mdp4/mdp4_lvds_pll.o
-msm-$(CONFIG_COMMON_CLK) += hdmi/hdmi_pll_8960.o
-msm-$(CONFIG_COMMON_CLK) += hdmi/hdmi_phy_8996.o
 msm-$(CONFIG_DRM_MSM_HDMI_HDCP) += hdmi/hdmi_hdcp.o

drivers/gpu/drm/msm/adreno/a6xx_gpu.c+10−10

 {
 	struct adreno_gpu *adreno_gpu = &a6xx_gpu->base;
 	struct msm_gpu *gpu = &adreno_gpu->base;
-	u32 gpu_scid, cntl1_regval = 0;
+	u32 cntl1_regval = 0;
 	if (IS_ERR(a6xx_gpu->llc_mmio))
 		return;
 	if (!llcc_slice_activate(a6xx_gpu->llc_slice)) {
-		gpu_scid = llcc_get_slice_id(a6xx_gpu->llc_slice);
+		u32 gpu_scid = llcc_get_slice_id(a6xx_gpu->llc_slice);
 		gpu_scid &= 0x1f;
 		cntl1_regval = (gpu_scid << 0) | (gpu_scid << 5) | (gpu_scid << 10) |
 			       (gpu_scid << 15) | (gpu_scid << 20);
+		/* On A660, the SCID programming for UCHE traffic is done in
+		 * A6XX_GBIF_SCACHE_CNTL0[14:10]
+		 */
+		if (adreno_is_a660_family(adreno_gpu))
+			gpu_rmw(gpu, REG_A6XX_GBIF_SCACHE_CNTL0, (0x1f << 10) |
+				(1 << 8), (gpu_scid << 10) | (1 << 8));
 	}
 	/*
 	}
 	gpu_rmw(gpu, REG_A6XX_GBIF_SCACHE_CNTL1, GENMASK(24, 0), cntl1_regval);
-	/* On A660, the SCID programming for UCHE traffic is done in
-	 * A6XX_GBIF_SCACHE_CNTL0[14:10]
-	 */
-	if (adreno_is_a660_family(adreno_gpu))
-		gpu_rmw(gpu, REG_A6XX_GBIF_SCACHE_CNTL0, (0x1f << 10) |
-			(1 << 8), (gpu_scid << 10) | (1 << 8));
 }
 static void a6xx_llc_slices_destroy(struct a6xx_gpu *a6xx_gpu)
 	return (unsigned long)busy_time;
 }
-void a6xx_gpu_set_freq(struct msm_gpu *gpu, struct dev_pm_opp *opp)
+static void a6xx_gpu_set_freq(struct msm_gpu *gpu, struct dev_pm_opp *opp)
 {
 	struct adreno_gpu *adreno_gpu = to_adreno_gpu(gpu);
 	struct a6xx_gpu *a6xx_gpu = to_a6xx_gpu(adreno_gpu);

drivers/gpu/drm/msm/adreno/a6xx_gpu_state.c+2−2

@@ -777,12 +777,12 @@ static void a6xx_get_gmu_registers(struct msm_gpu *gpu, · 776 unmodified lines
777	struct a6xx_gpu *a6xx_gpu = to_a6xx_gpu(adreno_gpu);	777	struct a6xx_gpu *a6xx_gpu = to_a6xx_gpu(adreno_gpu);
778		778
779	a6xx_state->gmu_registers = state_kcalloc(a6xx_state,	779	a6xx_state->gmu_registers = state_kcalloc(a6xx_state,
780	2, sizeof(*a6xx_state->gmu_registers));	780	3, sizeof(*a6xx_state->gmu_registers));
781		781
782	if (!a6xx_state->gmu_registers)	782	if (!a6xx_state->gmu_registers)
783	return;	783	return;
784		784
785	a6xx_state->nr_gmu_registers = 2;	785	a6xx_state->nr_gmu_registers = 3;
786		786
787	/* Get the CX GMU registers from AHB */	787	/* Get the CX GMU registers from AHB */
788	_a6xx_get_gmu_registers(gpu, a6xx_state, &a6xx_gmu_reglist[0],	788	_a6xx_get_gmu_registers(gpu, a6xx_state, &a6xx_gmu_reglist[0],

drivers/gpu/drm/msm/dp/dp_aux.c+17−0

 	bool read;
 	bool no_send_addr;
 	bool no_send_stop;
+	bool initted;
 	u32 offset;
 	u32 segment;
 	}
 	mutex_lock(&aux->mutex);
+	if (!aux->initted) {
+		ret = -EIO;
+		goto exit;
+	}
 	dp_aux_update_offset_and_segment(aux, msg);
 	dp_aux_transfer_helper(aux, msg, true);
 	}
 	aux->cmd_busy = false;
+exit:
 	mutex_unlock(&aux->mutex);
 	return ret;
 	aux = container_of(dp_aux, struct dp_aux_private, dp_aux);
+	mutex_lock(&aux->mutex);
 	dp_catalog_aux_enable(aux->catalog, true);
 	aux->retry_cnt = 0;
+	aux->initted = true;
+	mutex_unlock(&aux->mutex);
 }
 void dp_aux_deinit(struct drm_dp_aux *dp_aux)
 	aux = container_of(dp_aux, struct dp_aux_private, dp_aux);
+	mutex_lock(&aux->mutex);
+	aux->initted = false;
 	dp_catalog_aux_enable(aux->catalog, false);
+	mutex_unlock(&aux->mutex);
 }
 int dp_aux_register(struct drm_dp_aux *dp_aux)

drivers/gpu/drm/msm/dsi/dsi_host.c+2−0

@@ -1658,6 +1658,8 @@ static int dsi_host_parse_lane_data(struct msm_dsi_host *msm_host, · 1657 unmodified lines
1658	if (!prop) {	1658	if (!prop) {
1659	DRM_DEV_DEBUG(dev,	1659	DRM_DEV_DEBUG(dev,
1660	"failed to find data lane mapping, using default\n");	1660	"failed to find data lane mapping, using default\n");
		1661	/* Set the number of date lanes to 4 by default. */
		1662	msm_host->num_data_lanes = 4;
1661	return 0;	1663	return 0;
1662	}	1664	}
1663		1665

drivers/gpu/drm/msm/msm_debugfs.c+1−0

@@ -77,6 +77,7 @@ static int msm_gpu_open(struct inode inode, struct file file) · 76 unmodified lines
77	goto free_priv;	77	goto free_priv;
78		78
79	pm_runtime_get_sync(&gpu->pdev->dev);	79	pm_runtime_get_sync(&gpu->pdev->dev);
		80	msm_gpu_hw_init(gpu);
80	show_priv->state = gpu->funcs->gpu_state_get(gpu);	81	show_priv->state = gpu->funcs->gpu_state_get(gpu);
81	pm_runtime_put_sync(&gpu->pdev->dev);	82	pm_runtime_put_sync(&gpu->pdev->dev);
82		83

drivers/gpu/drm/msm/msm_drv.c+32−17

 	return ret;
 }
-static int msm_ioctl_wait_fence(struct drm_device *dev, void *data,
+static int wait_fence(struct msm_gpu_submitqueue *queue, uint32_t fence_id,
-		struct drm_file *file)
+		      ktime_t timeout)
 {
-	struct msm_drm_private *priv = dev->dev_private;
-	struct drm_msm_wait_fence *args = data;
-	ktime_t timeout = to_ktime(args->timeout);
-	struct msm_gpu_submitqueue *queue;
-	struct msm_gpu *gpu = priv->gpu;
 	struct dma_fence *fence;
 	int ret;
-	if (args->pad) {
+	if (fence_id > queue->last_fence) {
-		DRM_ERROR("invalid pad: %08x\n", args->pad);
+		DRM_ERROR_RATELIMITED("waiting on invalid fence: %u (of %u)\n",
+				      fence_id, queue->last_fence);
 		return -EINVAL;
 	}
-	if (!gpu)
-		return 0;
-	queue = msm_submitqueue_get(file->driver_priv, args->queueid);
-	if (!queue)
-		return -ENOENT;
 	/*
 	 * Map submitqueue scoped "seqno" (which is actually an idr key)
 	 * back to underlying dma-fence
 	ret = mutex_lock_interruptible(&queue->lock);
 	if (ret)
 		return ret;
-	fence = idr_find(&queue->fence_idr, args->fence);
+	fence = idr_find(&queue->fence_idr, fence_id);
 	if (fence)
 		fence = dma_fence_get_rcu(fence);
 	mutex_unlock(&queue->lock);
 	}
 	dma_fence_put(fence);
+	return ret;
+}
+static int msm_ioctl_wait_fence(struct drm_device *dev, void *data,
+		struct drm_file *file)
+{
+	struct msm_drm_private *priv = dev->dev_private;
+	struct drm_msm_wait_fence *args = data;
+	struct msm_gpu_submitqueue *queue;
+	int ret;
+	if (args->pad) {
+		DRM_ERROR("invalid pad: %08x\n", args->pad);
+		return -EINVAL;
+	}
+	if (!priv->gpu)
+		return 0;
+	queue = msm_submitqueue_get(file->driver_priv, args->queueid);
+	if (!queue)
+		return -ENOENT;
+	ret = wait_fence(queue, args->fence, to_ktime(args->timeout));
 	msm_submitqueue_put(queue);
 	return ret;

drivers/gpu/drm/msm/msm_gem.c+2−3

 {
 	struct msm_gem_object *msm_obj = to_msm_bo(obj);
-	vma->vm_flags &= ~VM_PFNMAP;
+	vma->vm_flags |= VM_IO | VM_MIXEDMAP | VM_DONTEXPAND | VM_DONTDUMP;
-	vma->vm_flags |= VM_MIXEDMAP | VM_DONTEXPAND;
 	vma->vm_page_prot = msm_gem_pgprot(msm_obj, vm_get_page_prot(vma->vm_flags));
 	return 0;
 			break;
 		fallthrough;
 	default:
-		DRM_DEV_ERROR(dev->dev, "invalid cache flag: %x\n",
+		DRM_DEV_DEBUG(dev->dev, "invalid cache flag: %x\n",
 				(flags & MSM_BO_CACHE_MASK));
 		return -EINVAL;
 	}

drivers/gpu/drm/msm/msm_gem_shrinker.c+1−0

@@ -5,6 +5,7 @@ · 4 unmodified lines
5	*/	5	*/
6		6
7	#include <linux/vmalloc.h>	7	#include <linux/vmalloc.h>
		8	#include <linux/sched/mm.h>
8		9
9	#include "msm_drv.h"	10	#include "msm_drv.h"
10	#include "msm_gem.h"	11	#include "msm_gem.h"

drivers/gpu/drm/msm/msm_gem_submit.c+2−0

 		args->nr_cmds);
 	if (IS_ERR(submit)) {
 		ret = PTR_ERR(submit);
+		submit = NULL;
 		goto out_unlock;
 	}
 	drm_sched_entity_push_job(&submit->base);
 	args->fence = submit->fence_id;
+	queue->last_fence = submit->fence_id;
 	msm_reset_syncobjs(syncobjs_to_reset, args->nr_in_syncobjs);
 	msm_process_post_deps(post_deps, args->nr_out_syncobjs,

drivers/gpu/drm/msm/msm_gpu.h+3−0

  * @ring_nr:   the ringbuffer used by this submitqueue, which is determined
  *             by the submitqueue's priority
  * @faults:    the number of GPU hangs associated with this submitqueue
+ * @last_fence: the sequence number of the last allocated fence (for error
+ *             checking)
  * @ctx:       the per-drm_file context associated with the submitqueue (ie.
  *             which set of pgtables do submits jobs associated with the
  *             submitqueue use)
 	u32 flags;
 	u32 ring_nr;
 	int faults;
+	uint32_t last_fence;
 	struct msm_file_private *ctx;
 	struct list_head node;
 	struct idr fence_idr;

drivers/gpu/drm/msm/msm_gpu_devfreq.c+9−4

 	struct msm_gpu *gpu = dev_to_gpu(dev);
 	struct dev_pm_opp *opp;
+	/*
+	 * Note that devfreq_recommended_opp() can modify the freq
+	 * to something that actually is in the opp table:
+	 */
 	opp = devfreq_recommended_opp(dev, freq, flags);
 	/*
 	 */
 	if (gpu->devfreq.idle_freq) {
 		gpu->devfreq.idle_freq = *freq;
+		dev_pm_opp_put(opp);
 		return 0;
 	}
 	struct msm_gpu *gpu = container_of(df, struct msm_gpu, devfreq);
 	unsigned long idle_freq, target_freq = 0;
-	if (!df->devfreq)
-		return;
 	/*
 	 * Hold devfreq lock to synchronize with get_dev_status()/
 	 * target() callbacks
 {
 	struct msm_gpu_devfreq *df = &gpu->devfreq;
+	if (!df->devfreq)
+		return;
 	msm_hrtimer_queue_work(&df->idle_work, ms_to_ktime(1),
-			       HRTIMER_MODE_ABS);
+			       HRTIMER_MODE_REL);
 }

drivers/gpu/drm/ttm/ttm_bo.c+2−1

 	 * as an indication that we're about to swap out.
 	 */
 	memset(&place, 0, sizeof(place));
-	place.mem_type = TTM_PL_SYSTEM;
+	place.mem_type = bo->resource->mem_type;
 	if (!ttm_bo_evict_swapout_allowable(bo, ctx, &place, &locked, NULL))
 		return -EBUSY;
 		struct ttm_place hop;
 		memset(&hop, 0, sizeof(hop));
+		place.mem_type = TTM_PL_SYSTEM;
 		ret = ttm_resource_alloc(bo, &place, &evict_mem);
 		if (unlikely(ret))
 			goto out;

drivers/gpu/drm/ttm/ttm_tt.c+1−0

@@ -34,6 +34,7 @@ · 33 unmodified lines
34	#include <linux/sched.h>	34	#include <linux/sched.h>
35	#include <linux/shmem_fs.h>	35	#include <linux/shmem_fs.h>
36	#include <linux/file.h>	36	#include <linux/file.h>
		37	#include <linux/module.h>
37	#include <drm/drm_cache.h>	38	#include <drm/drm_cache.h>
38	#include <drm/ttm/ttm_bo_driver.h>	39	#include <drm/ttm/ttm_bo_driver.h>
39		40

drivers/gpu/drm/vc4/vc4_kms.c+18−22

 	struct drm_device *dev = state->dev;
 	struct vc4_dev *vc4 = to_vc4_dev(dev);
 	struct vc4_hvs *hvs = vc4->hvs;
-	struct drm_crtc_state *old_crtc_state;
 	struct drm_crtc_state *new_crtc_state;
 	struct drm_crtc *crtc;
 	struct vc4_hvs_state *old_hvs_state;
+	unsigned int channel;
 	int i;
 	for_each_new_crtc_in_state(state, crtc, new_crtc_state, i) {
 		vc4_hvs_mask_underrun(dev, vc4_crtc_state->assigned_channel);
 	}
-	if (vc4->hvs->hvs5)
-		clk_set_min_rate(hvs->core_clk, 500000000);
 	old_hvs_state = vc4_hvs_get_old_global_state(state);
-	if (!old_hvs_state)
+	if (IS_ERR(old_hvs_state))
 		return;
-	for_each_old_crtc_in_state(state, crtc, old_crtc_state, i) {
+	for (channel = 0; channel < HVS_NUM_CHANNELS; channel++) {
-		struct vc4_crtc_state *vc4_crtc_state =
+		struct drm_crtc_commit *commit;
-			to_vc4_crtc_state(old_crtc_state);
-		unsigned int channel = vc4_crtc_state->assigned_channel;
 		int ret;
-		if (channel == VC4_HVS_CHANNEL_DISABLED)
+		if (!old_hvs_state->fifo_state[channel].in_use)
 			continue;
-		if (!old_hvs_state->fifo_state[channel].in_use)
+		commit = old_hvs_state->fifo_state[channel].pending_commit;
+		if (!commit)
 			continue;
-		ret = drm_crtc_commit_wait(old_hvs_state->fifo_state[channel].pending_commit);
+		ret = drm_crtc_commit_wait(commit);
 		if (ret)
 			drm_err(dev, "Timed out waiting for commit\n");
+		drm_crtc_commit_put(commit);
+		old_hvs_state->fifo_state[channel].pending_commit = NULL;
 	}
+	if (vc4->hvs->hvs5)
+		clk_set_min_rate(hvs->core_clk, 500000000);
 	drm_atomic_helper_commit_modeset_disables(dev, state);
 	vc4_ctm_commit(vc4, state);
 	unsigned int i;
 	hvs_state = vc4_hvs_get_new_global_state(state);
-	if (!hvs_state)
+	if (WARN_ON(IS_ERR(hvs_state)))
-		return -EINVAL;
+		return PTR_ERR(hvs_state);
 	for_each_new_crtc_in_state(state, crtc, crtc_state, i) {
 		struct vc4_crtc_state *vc4_crtc_state =
 	for (i = 0; i < HVS_NUM_CHANNELS; i++) {
 		state->fifo_state[i].in_use = old_state->fifo_state[i].in_use;
-		if (!old_state->fifo_state[i].pending_commit)
-			continue;
-		state->fifo_state[i].pending_commit =
-			drm_crtc_commit_get(old_state->fifo_state[i].pending_commit);
 	}
 	return &state->base;
 	unsigned int i;
 	hvs_new_state = vc4_hvs_get_global_state(state);
-	if (!hvs_new_state)
+	if (IS_ERR(hvs_new_state))
-		return -EINVAL;
+		return PTR_ERR(hvs_new_state);
 	for (i = 0; i < ARRAY_SIZE(hvs_new_state->fifo_state); i++)
 		if (!hvs_new_state->fifo_state[i].in_use)

drivers/gpu/drm/virtio/virtgpu_drv.c+1−41

@@ -157,36 +157,6 @@ static void virtio_gpu_config_changed(struct virtio_device *vdev) · 156 unmodified lines
157	schedule_work(&vgdev->config_changed_work);	157	schedule_work(&vgdev->config_changed_work);
158	}	158	}
159		159
160	static __poll_t virtio_gpu_poll(struct file *filp,
161	struct poll_table_struct *wait)
162	{
163	struct drm_file *drm_file = filp->private_data;
164	struct virtio_gpu_fpriv *vfpriv = drm_file->driver_priv;
165	struct drm_device *dev = drm_file->minor->dev;
166	struct virtio_gpu_device *vgdev = dev->dev_private;
167	struct drm_pending_event *e = NULL;
168	__poll_t mask = 0;
169
170	if (!vgdev->has_virgl_3d \|\| !vfpriv \|\| !vfpriv->ring_idx_mask)
171	return drm_poll(filp, wait);
172
173	poll_wait(filp, &drm_file->event_wait, wait);
174
175	if (!list_empty(&drm_file->event_list)) {
176	spin_lock_irq(&dev->event_lock);
177	e = list_first_entry(&drm_file->event_list,
178	struct drm_pending_event, link);
179	drm_file->event_space += e->event->length;
180	list_del(&e->link);
181	spin_unlock_irq(&dev->event_lock);
182
183	kfree(e);
184	mask \|= EPOLLIN \| EPOLLRDNORM;
185	}
186
187	return mask;
188	}
189
190	static struct virtio_device_id id_table[] = {	160	static struct virtio_device_id id_table[] = {
191	{ VIRTIO_ID_GPU, VIRTIO_DEV_ANY_ID },	161	{ VIRTIO_ID_GPU, VIRTIO_DEV_ANY_ID },
192	{ 0 },	162	{ 0 },
@@ -226,17 +196,7 @@ MODULE_AUTHOR("Dave Airlie <airlied@redhat.com>"); · 33 unmodified lines
226	MODULE_AUTHOR("Gerd Hoffmann <kraxel@redhat.com>");	196	MODULE_AUTHOR("Gerd Hoffmann <kraxel@redhat.com>");
227	MODULE_AUTHOR("Alon Levy");	197	MODULE_AUTHOR("Alon Levy");
228		198
229	static const struct file_operations virtio_gpu_driver_fops = {	199	DEFINE_DRM_GEM_FOPS(virtio_gpu_driver_fops);
230	.owner = THIS_MODULE,
231	.open = drm_open,
232	.release = drm_release,
233	.unlocked_ioctl = drm_ioctl,
234	.compat_ioctl = drm_compat_ioctl,
235	.poll = virtio_gpu_poll,
236	.read = drm_read,
237	.llseek = noop_llseek,
238	.mmap = drm_gem_mmap
239	};
240		200
241	static const struct drm_driver driver = {	201	static const struct drm_driver driver = {
242	.driver_features = DRIVER_MODESET \| DRIVER_GEM \| DRIVER_RENDER \| DRIVER_ATOMIC,	202	.driver_features = DRIVER_MODESET \| DRIVER_GEM \| DRIVER_RENDER \| DRIVER_ATOMIC,

drivers/gpu/drm/virtio/virtgpu_drv.h+0−1

@@ -138,7 +138,6 @@ struct virtio_gpu_fence_driver { · 137 unmodified lines
138	spinlock_t lock;	138	spinlock_t lock;
139	};	139	};
140		140
141	#define VIRTGPU_EVENT_FENCE_SIGNALED_INTERNAL 0x10000000
142	struct virtio_gpu_fence_event {	141	struct virtio_gpu_fence_event {
143	struct drm_pending_event base;	142	struct drm_pending_event base;
144	struct drm_event event;	143	struct drm_event event;

drivers/gpu/drm/virtio/virtgpu_ioctl.c+1−1

@@ -54,7 +54,7 @@ static int virtio_gpu_fence_event_create(struct drm_device *dev, · 53 unmodified lines
54	if (!e)	54	if (!e)
55	return -ENOMEM;	55	return -ENOMEM;
56		56
57	e->event.type = VIRTGPU_EVENT_FENCE_SIGNALED_INTERNAL;	57	e->event.type = VIRTGPU_EVENT_FENCE_SIGNALED;
58	e->event.length = sizeof(e->event);	58	e->event.length = sizeof(e->event);
59		59
60	ret = drm_event_reserve_init(dev, file, &e->base, &e->event);	60	ret = drm_event_reserve_init(dev, file, &e->base, &e->event);

drivers/hid/Kconfig+5−5

@@ -207,14 +207,14 @@ config HID_CHERRY · 206 unmodified lines
207		207
208	config HID_CHICONY	208	config HID_CHICONY
209	tristate "Chicony devices"	209	tristate "Chicony devices"
210	depends on HID	210	depends on USB_HID
211	default !EXPERT	211	default !EXPERT
212	help	212	help
213	Support for Chicony Tactical pad and special keys on Chicony keyboards.	213	Support for Chicony Tactical pad and special keys on Chicony keyboards.
214		214
215	config HID_CORSAIR	215	config HID_CORSAIR
216	tristate "Corsair devices"	216	tristate "Corsair devices"
217	depends on HID && USB && LEDS_CLASS	217	depends on USB_HID && LEDS_CLASS
218	help	218	help
219	Support for Corsair devices that are not fully compliant with the	219	Support for Corsair devices that are not fully compliant with the
220	HID standard.	220	HID standard.
@@ -245,7 +245,7 @@ config HID_MACALLY · 24 unmodified lines
245		245
246	config HID_PRODIKEYS	246	config HID_PRODIKEYS
247	tristate "Prodikeys PC-MIDI Keyboard support"	247	tristate "Prodikeys PC-MIDI Keyboard support"
248	depends on HID && SND	248	depends on USB_HID && SND
249	select SND_RAWMIDI	249	select SND_RAWMIDI
250	help	250	help
251	Support for Prodikeys PC-MIDI Keyboard device support.	251	Support for Prodikeys PC-MIDI Keyboard device support.
@@ -560,7 +560,7 @@ config HID_LENOVO · 308 unmodified lines
560		560
561	config HID_LOGITECH	561	config HID_LOGITECH
562	tristate "Logitech devices"	562	tristate "Logitech devices"
563	depends on HID	563	depends on USB_HID
564	depends on LEDS_CLASS	564	depends on LEDS_CLASS
565	default !EXPERT	565	default !EXPERT
566	help	566	help
@@ -951,7 +951,7 @@ config HID_SAITEK · 384 unmodified lines
951		951
952	config HID_SAMSUNG	952	config HID_SAMSUNG
953	tristate "Samsung InfraRed remote control or keyboards"	953	tristate "Samsung InfraRed remote control or keyboards"
954	depends on HID	954	depends on USB_HID
955	help	955	help
956	Support for Samsung InfraRed remote control or keyboards.	956	Support for Samsung InfraRed remote control or keyboards.
957		957

drivers/hid/hid-asus.c+2−4

 	if (drvdata->quirks & QUIRK_IS_MULTITOUCH)
 		drvdata->tp = &asus_i2c_tp;
-	if ((drvdata->quirks & QUIRK_T100_KEYBOARD) &&
+	if ((drvdata->quirks & QUIRK_T100_KEYBOARD) && hid_is_usb(hdev)) {
-	    hid_is_using_ll_driver(hdev, &usb_hid_driver)) {
 		struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
 		if (intf->altsetting->desc.bInterfaceNumber == T100_TPAD_INTF) {
 		drvdata->tp = &asus_t100chi_tp;
 	}
-	if ((drvdata->quirks & QUIRK_MEDION_E1239T) &&
+	if ((drvdata->quirks & QUIRK_MEDION_E1239T) && hid_is_usb(hdev)) {
-	    hid_is_using_ll_driver(hdev, &usb_hid_driver)) {
 		struct usb_host_interface *alt =
 			to_usb_interface(hdev->dev.parent)->altsetting;

drivers/hid/hid-bigbenff.c+1−1

@@ -191,7 +191,7 @@ static void bigben_worker(struct work_struct *work) · 190 unmodified lines
191	struct bigben_device, worker);	191	struct bigben_device, worker);
192	struct hid_field *report_field = bigben->report->field[0];	192	struct hid_field *report_field = bigben->report->field[0];
193		193
194	if (bigben->removed)	194	if (bigben->removed \|\| !report_field)
195	return;	195	return;
196		196
197	if (bigben->work_led) {	197	if (bigben->work_led) {

drivers/hid/hid-chicony.c+3−0

@@ -114,6 +114,9 @@ static int ch_probe(struct hid_device hdev, const struct hid_device_id id) · 113 unmodified lines
114	{	114	{
115	int ret;	115	int ret;
116		116
		117	if (!hid_is_usb(hdev))
		118	return -EINVAL;
		119
117	hdev->quirks \|= HID_QUIRK_INPUT_PER_APP;	120	hdev->quirks \|= HID_QUIRK_INPUT_PER_APP;
118	ret = hid_parse(hdev);	121	ret = hid_parse(hdev);
119	if (ret) {	122	if (ret) {

drivers/hid/hid-corsair.c+6−1

 	int ret;
 	unsigned long quirks = id->driver_data;
 	struct corsair_drvdata *drvdata;
-	struct usb_interface *usbif = to_usb_interface(dev->dev.parent);
+	struct usb_interface *usbif;
+	if (!hid_is_usb(dev))
+		return -EINVAL;
+	usbif = to_usb_interface(dev->dev.parent);
 	drvdata = devm_kzalloc(&dev->dev, sizeof(struct corsair_drvdata),
 			       GFP_KERNEL);

drivers/hid/hid-elan.c+1−1

@@ -50,7 +50,7 @@ struct elan_drvdata { · 49 unmodified lines
50		50
51	static int is_not_elan_touchpad(struct hid_device *hdev)	51	static int is_not_elan_touchpad(struct hid_device *hdev)
52	{	52	{
53	if (hdev->bus == BUS_USB) {	53	if (hid_is_usb(hdev)) {
54	struct usb_interface *intf = to_usb_interface(hdev->dev.parent);	54	struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
55		55
56	return (intf->altsetting->desc.bInterfaceNumber !=	56	return (intf->altsetting->desc.bInterfaceNumber !=

drivers/hid/hid-elo.c+3−0

@@ -230,6 +230,9 @@ static int elo_probe(struct hid_device hdev, const struct hid_device_id id) · 229 unmodified lines
230	int ret;	230	int ret;
231	struct usb_device *udev;	231	struct usb_device *udev;
232		232
		233	if (!hid_is_usb(hdev))
		234	return -EINVAL;
		235
233	priv = kzalloc(sizeof(*priv), GFP_KERNEL);	236	priv = kzalloc(sizeof(*priv), GFP_KERNEL);
234	if (!priv)	237	if (!priv)
235	return -ENOMEM;	238	return -ENOMEM;

drivers/hid/hid-ft260.c+3−0

@@ -915,6 +915,9 @@ static int ft260_probe(struct hid_device hdev, const struct hid_device_id id) · 914 unmodified lines
915	struct ft260_get_chip_version_report version;	915	struct ft260_get_chip_version_report version;
916	int ret;	916	int ret;
917		917
		918	if (!hid_is_usb(hdev))
		919	return -EINVAL;
		920
918	dev = devm_kzalloc(&hdev->dev, sizeof(*dev), GFP_KERNEL);	921	dev = devm_kzalloc(&hdev->dev, sizeof(*dev), GFP_KERNEL);
919	if (!dev)	922	if (!dev)
920	return -ENOMEM;	923	return -ENOMEM;

drivers/hid/hid-google-hammer.c+2−0

 static const struct hid_device_id hammer_devices[] = {
 	{ HID_DEVICE(BUS_USB, HID_GROUP_GENERIC,
 		     USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_DON) },
+	{ HID_DEVICE(BUS_USB, HID_GROUP_GENERIC,
+		     USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_EEL) },
 	{ HID_DEVICE(BUS_USB, HID_GROUP_GENERIC,
 		     USB_VENDOR_ID_GOOGLE, USB_DEVICE_ID_GOOGLE_HAMMER) },
 	{ HID_DEVICE(BUS_USB, HID_GROUP_GENERIC,

drivers/hid/hid-holtek-kbd.c+7−2

 static int holtek_kbd_probe(struct hid_device *hdev,
 		const struct hid_device_id *id)
 {
-	struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
+	struct usb_interface *intf;
-	int ret = hid_parse(hdev);
+	int ret;
+	if (!hid_is_usb(hdev))
+		return -EINVAL;
+	ret = hid_parse(hdev);
 	if (!ret)
 		ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
+	intf = to_usb_interface(hdev->dev.parent);
 	if (!ret && intf->cur_altsetting->desc.bInterfaceNumber == 1) {
 		struct hid_input *hidinput;
 		list_for_each_entry(hidinput, &hdev->inputs, list) {

drivers/hid/hid-holtek-mouse.c+9−0

 	return rdesc;
 }
+static int holtek_mouse_probe(struct hid_device *hdev,
+			      const struct hid_device_id *id)
+{
+	if (!hid_is_usb(hdev))
+		return -EINVAL;
+	return 0;
+}
 static const struct hid_device_id holtek_mouse_devices[] = {
 	{ HID_USB_DEVICE(USB_VENDOR_ID_HOLTEK_ALT,
 			USB_DEVICE_ID_HOLTEK_ALT_MOUSE_A067) },
 	.name = "holtek_mouse",
 	.id_table = holtek_mouse_devices,
 	.report_fixup = holtek_mouse_report_fixup,
+	.probe = holtek_mouse_probe,
 };
 module_hid_driver(holtek_mouse_driver);

drivers/hid/hid-ids.h+3−0

 #define USB_DEVICE_ID_HP_X2_10_COVER	0x0755
 #define I2C_DEVICE_ID_HP_ENVY_X360_15	0x2d05
 #define I2C_DEVICE_ID_HP_SPECTRE_X360_15	0x2817
+#define USB_DEVICE_ID_ASUS_UX550VE_TOUCHSCREEN	0x2544
 #define USB_DEVICE_ID_ASUS_UX550_TOUCHSCREEN	0x2706
 #define I2C_DEVICE_ID_SURFACE_GO_TOUCHSCREEN	0x261A
 #define USB_DEVICE_ID_GOOGLE_MAGNEMITE	0x503d
 #define USB_DEVICE_ID_GOOGLE_MOONBALL	0x5044
 #define USB_DEVICE_ID_GOOGLE_DON	0x5050
+#define USB_DEVICE_ID_GOOGLE_EEL	0x5057
 #define USB_VENDOR_ID_GOTOP		0x08f2
 #define USB_DEVICE_ID_SUPER_Q2		0x007f
 #define USB_DEVICE_ID_MS_TOUCH_COVER_2   0x07a7
 #define USB_DEVICE_ID_MS_TYPE_COVER_2    0x07a9
 #define USB_DEVICE_ID_MS_POWER_COVER     0x07da
+#define USB_DEVICE_ID_MS_SURFACE3_COVER		0x07de
 #define USB_DEVICE_ID_MS_XBOX_ONE_S_CONTROLLER	0x02fd
 #define USB_DEVICE_ID_MS_PIXART_MOUSE    0x00cb
 #define USB_DEVICE_ID_8BITDO_SN30_PRO_PLUS      0x02e0

drivers/hid/hid-input.c+2−0

 	  HID_BATTERY_QUIRK_IGNORE },
 	{ HID_USB_DEVICE(USB_VENDOR_ID_ELAN, USB_DEVICE_ID_ASUS_UX550_TOUCHSCREEN),
 	  HID_BATTERY_QUIRK_IGNORE },
+	{ HID_USB_DEVICE(USB_VENDOR_ID_ELAN, USB_DEVICE_ID_ASUS_UX550VE_TOUCHSCREEN),
+	  HID_BATTERY_QUIRK_IGNORE },
 	{ HID_I2C_DEVICE(USB_VENDOR_ID_ELAN, I2C_DEVICE_ID_HP_ENVY_X360_15),
 	  HID_BATTERY_QUIRK_IGNORE },
 	{ HID_I2C_DEVICE(USB_VENDOR_ID_ELAN, I2C_DEVICE_ID_HP_SPECTRE_X360_15),

drivers/hid/hid-lg.c+8−2

 static int lg_probe(struct hid_device *hdev, const struct hid_device_id *id)
 {
-	struct usb_interface *iface = to_usb_interface(hdev->dev.parent);
+	struct usb_interface *iface;
-	__u8 iface_num = iface->cur_altsetting->desc.bInterfaceNumber;
+	__u8 iface_num;
 	unsigned int connect_mask = HID_CONNECT_DEFAULT;
 	struct lg_drv_data *drv_data;
 	int ret;
+	if (!hid_is_usb(hdev))
+		return -EINVAL;
+	iface = to_usb_interface(hdev->dev.parent);
+	iface_num = iface->cur_altsetting->desc.bInterfaceNumber;
 	/* G29 only work with the 1st interface */
 	if ((hdev->product == USB_DEVICE_ID_LOGITECH_G29_WHEEL) &&
 	    (iface_num != 0)) {

drivers/hid/hid-logitech-dj.c+1−1

@@ -1777,7 +1777,7 @@ static int logi_dj_probe(struct hid_device *hdev, · 1776 unmodified lines
1777	case recvr_type_bluetooth: no_dj_interfaces = 2; break;	1777	case recvr_type_bluetooth: no_dj_interfaces = 2; break;
1778	case recvr_type_dinovo: no_dj_interfaces = 2; break;	1778	case recvr_type_dinovo: no_dj_interfaces = 2; break;
1779	}	1779	}
1780	if (hid_is_using_ll_driver(hdev, &usb_hid_driver)) {	1780	if (hid_is_usb(hdev)) {
1781	intf = to_usb_interface(hdev->dev.parent);	1781	intf = to_usb_interface(hdev->dev.parent);
1782	if (intf && intf->altsetting->desc.bInterfaceNumber >=	1782	if (intf && intf->altsetting->desc.bInterfaceNumber >=
1783	no_dj_interfaces) {	1783	no_dj_interfaces) {

drivers/hid/hid-prodikeys.c+8−2

 static int pk_probe(struct hid_device *hdev, const struct hid_device_id *id)
 {
 	int ret;
-	struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
+	struct usb_interface *intf;
-	unsigned short ifnum = intf->cur_altsetting->desc.bInterfaceNumber;
+	unsigned short ifnum;
 	unsigned long quirks = id->driver_data;
 	struct pk_device *pk;
 	struct pcmidi_snd *pm = NULL;
+	if (!hid_is_usb(hdev))
+		return -EINVAL;
+	intf = to_usb_interface(hdev->dev.parent);
+	ifnum = intf->cur_altsetting->desc.bInterfaceNumber;
 	pk = kzalloc(sizeof(*pk), GFP_KERNEL);
 	if (pk == NULL) {
 		hid_err(hdev, "can't alloc descriptor\n");

drivers/hid/hid-quirks.c+1−0

@@ -124,6 +124,7 @@ static const struct hid_device_id hid_quirks[] = { · 123 unmodified lines
124	{ HID_USB_DEVICE(USB_VENDOR_ID_MCS, USB_DEVICE_ID_MCS_GAMEPADBLOCK), HID_QUIRK_MULTI_INPUT },	124	{ HID_USB_DEVICE(USB_VENDOR_ID_MCS, USB_DEVICE_ID_MCS_GAMEPADBLOCK), HID_QUIRK_MULTI_INPUT },
125	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_PIXART_MOUSE), HID_QUIRK_ALWAYS_POLL },	125	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_PIXART_MOUSE), HID_QUIRK_ALWAYS_POLL },
126	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_POWER_COVER), HID_QUIRK_NO_INIT_REPORTS },	126	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_POWER_COVER), HID_QUIRK_NO_INIT_REPORTS },
		127	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_SURFACE3_COVER), HID_QUIRK_NO_INIT_REPORTS },
127	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_SURFACE_PRO_2), HID_QUIRK_NO_INIT_REPORTS },	128	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_SURFACE_PRO_2), HID_QUIRK_NO_INIT_REPORTS },
128	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_TOUCH_COVER_2), HID_QUIRK_NO_INIT_REPORTS },	129	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_TOUCH_COVER_2), HID_QUIRK_NO_INIT_REPORTS },
129	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_TYPE_COVER_2), HID_QUIRK_NO_INIT_REPORTS },	130	{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_TYPE_COVER_2), HID_QUIRK_NO_INIT_REPORTS },

drivers/hid/hid-roccat-arvo.c+3−0

@@ -344,6 +344,9 @@ static int arvo_probe(struct hid_device *hdev, · 343 unmodified lines
344	{	344	{
345	int retval;	345	int retval;
346		346
		347	if (!hid_is_usb(hdev))
		348	return -EINVAL;
		349
347	retval = hid_parse(hdev);	350	retval = hid_parse(hdev);
348	if (retval) {	351	if (retval) {
349	hid_err(hdev, "parse failed\n");	352	hid_err(hdev, "parse failed\n");

drivers/hid/hid-roccat-isku.c+3−0

@@ -324,6 +324,9 @@ static int isku_probe(struct hid_device *hdev, · 323 unmodified lines
324	{	324	{
325	int retval;	325	int retval;
326		326
		327	if (!hid_is_usb(hdev))
		328	return -EINVAL;
		329
327	retval = hid_parse(hdev);	330	retval = hid_parse(hdev);
328	if (retval) {	331	if (retval) {
329	hid_err(hdev, "parse failed\n");	332	hid_err(hdev, "parse failed\n");

drivers/hid/hid-roccat-kone.c+3−0

@@ -749,6 +749,9 @@ static int kone_probe(struct hid_device hdev, const struct hid_device_id id) · 748 unmodified lines
749	{	749	{
750	int retval;	750	int retval;
751		751
		752	if (!hid_is_usb(hdev))
		753	return -EINVAL;
		754
752	retval = hid_parse(hdev);	755	retval = hid_parse(hdev);
753	if (retval) {	756	if (retval) {
754	hid_err(hdev, "parse failed\n");	757	hid_err(hdev, "parse failed\n");

drivers/hid/hid-roccat-koneplus.c+3−0

@@ -431,6 +431,9 @@ static int koneplus_probe(struct hid_device *hdev, · 430 unmodified lines
431	{	431	{
432	int retval;	432	int retval;
433		433
		434	if (!hid_is_usb(hdev))
		435	return -EINVAL;
		436
434	retval = hid_parse(hdev);	437	retval = hid_parse(hdev);
435	if (retval) {	438	if (retval) {
436	hid_err(hdev, "parse failed\n");	439	hid_err(hdev, "parse failed\n");

drivers/hid/hid-roccat-konepure.c+3−0

@@ -133,6 +133,9 @@ static int konepure_probe(struct hid_device *hdev, · 132 unmodified lines
133	{	133	{
134	int retval;	134	int retval;
135		135
		136	if (!hid_is_usb(hdev))
		137	return -EINVAL;
		138
136	retval = hid_parse(hdev);	139	retval = hid_parse(hdev);
137	if (retval) {	140	if (retval) {
138	hid_err(hdev, "parse failed\n");	141	hid_err(hdev, "parse failed\n");

drivers/hid/hid-roccat-kovaplus.c+3−0

@@ -501,6 +501,9 @@ static int kovaplus_probe(struct hid_device *hdev, · 500 unmodified lines
501	{	501	{
502	int retval;	502	int retval;
503		503
		504	if (!hid_is_usb(hdev))
		505	return -EINVAL;
		506
504	retval = hid_parse(hdev);	507	retval = hid_parse(hdev);
505	if (retval) {	508	if (retval) {
506	hid_err(hdev, "parse failed\n");	509	hid_err(hdev, "parse failed\n");

drivers/hid/hid-roccat-lua.c+3−0

@@ -160,6 +160,9 @@ static int lua_probe(struct hid_device *hdev, · 159 unmodified lines
160	{	160	{
161	int retval;	161	int retval;
162		162
		163	if (!hid_is_usb(hdev))
		164	return -EINVAL;
		165
163	retval = hid_parse(hdev);	166	retval = hid_parse(hdev);
164	if (retval) {	167	if (retval) {
165	hid_err(hdev, "parse failed\n");	168	hid_err(hdev, "parse failed\n");

drivers/hid/hid-roccat-pyra.c+3−0

@@ -449,6 +449,9 @@ static int pyra_probe(struct hid_device hdev, const struct hid_device_id id) · 448 unmodified lines
449	{	449	{
450	int retval;	450	int retval;
451		451
		452	if (!hid_is_usb(hdev))
		453	return -EINVAL;
		454
452	retval = hid_parse(hdev);	455	retval = hid_parse(hdev);
453	if (retval) {	456	if (retval) {
454	hid_err(hdev, "parse failed\n");	457	hid_err(hdev, "parse failed\n");

drivers/hid/hid-roccat-ryos.c+3−0

@@ -141,6 +141,9 @@ static int ryos_probe(struct hid_device *hdev, · 140 unmodified lines
141	{	141	{
142	int retval;	142	int retval;
143		143
		144	if (!hid_is_usb(hdev))
		145	return -EINVAL;
		146
144	retval = hid_parse(hdev);	147	retval = hid_parse(hdev);
145	if (retval) {	148	if (retval) {
146	hid_err(hdev, "parse failed\n");	149	hid_err(hdev, "parse failed\n");

drivers/hid/hid-roccat-savu.c+3−0

@@ -113,6 +113,9 @@ static int savu_probe(struct hid_device *hdev, · 112 unmodified lines
113	{	113	{
114	int retval;	114	int retval;
115		115
		116	if (!hid_is_usb(hdev))
		117	return -EINVAL;
		118
116	retval = hid_parse(hdev);	119	retval = hid_parse(hdev);
117	if (retval) {	120	if (retval) {
118	hid_err(hdev, "parse failed\n");	121	hid_err(hdev, "parse failed\n");

drivers/hid/hid-samsung.c+3−0

@@ -152,6 +152,9 @@ static int samsung_probe(struct hid_device *hdev, · 151 unmodified lines
152	int ret;	152	int ret;
153	unsigned int cmask = HID_CONNECT_DEFAULT;	153	unsigned int cmask = HID_CONNECT_DEFAULT;
154		154
		155	if (!hid_is_usb(hdev))
		156	return -EINVAL;
		157
155	ret = hid_parse(hdev);	158	ret = hid_parse(hdev);
156	if (ret) {	159	if (ret) {
157	hid_err(hdev, "parse failed\n");	160	hid_err(hdev, "parse failed\n");

drivers/hid/hid-sony.c+18−6

 	sc->quirks = quirks;
 	hid_set_drvdata(hdev, sc);
 	sc->hdev = hdev;
-	usbdev = to_usb_device(sc->hdev->dev.parent->parent);
 	ret = hid_parse(hdev);
 	if (ret) {
 	 */
 	if (!(hdev->claimed & HID_CLAIMED_INPUT)) {
 		hid_err(hdev, "failed to claim input\n");
-		hid_hw_stop(hdev);
+		ret = -ENODEV;
-		return -ENODEV;
+		goto err;
 	}
 	if (sc->quirks & (GHL_GUITAR_PS3WIIU | GHL_GUITAR_PS4)) {
+		if (!hid_is_usb(hdev)) {
+			ret = -EINVAL;
+			goto err;
+		}
+		usbdev = to_usb_device(sc->hdev->dev.parent->parent);
 		sc->ghl_urb = usb_alloc_urb(0, GFP_ATOMIC);
-		if (!sc->ghl_urb)
+		if (!sc->ghl_urb) {
-			return -ENOMEM;
+			ret = -ENOMEM;
+			goto err;
+		}
 		if (sc->quirks & GHL_GUITAR_PS3WIIU)
 			ret = ghl_init_urb(sc, usbdev, ghl_ps3wiiu_magic_data,
 							   ARRAY_SIZE(ghl_ps4_magic_data));
 		if (ret) {
 			hid_err(hdev, "error preparing URB\n");
-			return ret;
+			goto err;
 		}
 		timer_setup(&sc->ghl_poke_timer, ghl_magic_poke, 0);
 	}
 	return ret;
+err:
+	hid_hw_stop(hdev);
+	return ret;
 }
 static void sony_remove(struct hid_device *hdev)

drivers/hid/hid-thrustmaster.c+3−0

@@ -274,6 +274,9 @@ static int thrustmaster_probe(struct hid_device *hdev, const struct hid_device_i · 273 unmodified lines
274	int ret = 0;	274	int ret = 0;
275	struct tm_wheel *tm_wheel = NULL;	275	struct tm_wheel *tm_wheel = NULL;
276		276
		277	if (!hid_is_usb(hdev))
		278	return -EINVAL;
		279
277	ret = hid_parse(hdev);	280	ret = hid_parse(hdev);
278	if (ret) {	281	if (ret) {
279	hid_err(hdev, "parse failed with error %d\n", ret);	282	hid_err(hdev, "parse failed with error %d\n", ret);

drivers/hid/hid-u2fzero.c+1−1

@@ -311,7 +311,7 @@ static int u2fzero_probe(struct hid_device *hdev, · 310 unmodified lines
311	unsigned int minor;	311	unsigned int minor;
312	int ret;	312	int ret;
313		313
314	if (!hid_is_using_ll_driver(hdev, &usb_hid_driver))	314	if (!hid_is_usb(hdev))
315	return -EINVAL;	315	return -EINVAL;
316		316
317	dev = devm_kzalloc(&hdev->dev, sizeof(*dev), GFP_KERNEL);	317	dev = devm_kzalloc(&hdev->dev, sizeof(*dev), GFP_KERNEL);

drivers/hid/hid-uclogic-core.c+3−0

@@ -164,6 +164,9 @@ static int uclogic_probe(struct hid_device *hdev, · 163 unmodified lines
164	struct uclogic_drvdata *drvdata = NULL;	164	struct uclogic_drvdata *drvdata = NULL;
165	bool params_initialized = false;	165	bool params_initialized = false;
166		166
		167	if (!hid_is_usb(hdev))
		168	return -EINVAL;
		169
167	/*	170	/*
168	* libinput requires the pad interface to be on a different node	171	* libinput requires the pad interface to be on a different node
169	* than the pen, so use QUIRK_MULTI_INPUT for all tablets.	172	* than the pen, so use QUIRK_MULTI_INPUT for all tablets.

drivers/hid/hid-uclogic-params.c+1−2

@@ -843,8 +843,7 @@ int uclogic_params_init(struct uclogic_params *params, · 842 unmodified lines
843	struct uclogic_params p = {0, };	843	struct uclogic_params p = {0, };
844		844
845	/* Check arguments */	845	/* Check arguments */
846	if (params == NULL \|\| hdev == NULL \|\|	846	if (params == NULL \|\| hdev == NULL \|\| !hid_is_usb(hdev)) {
847	!hid_is_using_ll_driver(hdev, &usb_hid_driver)) {
848	rc = -EINVAL;	847	rc = -EINVAL;
849	goto cleanup;	848	goto cleanup;
850	}	849	}

drivers/hid/intel-ish-hid/ipc/pci-ish.c+4−2

 	if (ish_should_leave_d0i3(pdev) && !dev->suspend_flag
 			&& IPC_IS_ISH_ILUP(fwsts)) {
-		disable_irq_wake(pdev->irq);
+		if (device_may_wakeup(&pdev->dev))
+			disable_irq_wake(pdev->irq);
 		ish_set_host_ready(dev);
 			 */
 			pci_save_state(pdev);
-			enable_irq_wake(pdev->irq);
+			if (device_may_wakeup(&pdev->dev))
+				enable_irq_wake(pdev->irq);
 		}
 	} else {
 		/*

drivers/hid/wacom_sys.c+13−6

 	 * Skip the query for this type and modify defaults based on
 	 * interface number.
 	 */
-	if (features->type == WIRELESS) {
+	if (features->type == WIRELESS && intf) {
 		if (intf->cur_altsetting->desc.bInterfaceNumber == 0)
 			features->device_type = WACOM_DEVICETYPE_WL_MONITOR;
 		else
 	if ((features->type == HID_GENERIC) && !strcmp("Wacom HID", features->name)) {
 		char *product_name = wacom->hdev->name;
-		if (hid_is_using_ll_driver(wacom->hdev, &usb_hid_driver)) {
+		if (hid_is_usb(wacom->hdev)) {
 			struct usb_interface *intf = to_usb_interface(wacom->hdev->dev.parent);
 			struct usb_device *dev = interface_to_usbdev(intf);
 			product_name = dev->product;
 	wacom_destroy_battery(wacom);
+	if (!usbdev)
+		return;
 	/* Stylus interface */
 	hdev1 = usb_get_intfdata(usbdev->config->interface[1]);
 	wacom1 = hid_get_drvdata(hdev1);
 static int wacom_probe(struct hid_device *hdev,
 		const struct hid_device_id *id)
 {
-	struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
-	struct usb_device *dev = interface_to_usbdev(intf);
 	struct wacom *wacom;
 	struct wacom_wac *wacom_wac;
 	struct wacom_features *features;
 	wacom_wac->hid_data.inputmode = -1;
 	wacom_wac->mode_report = -1;
-	wacom->usbdev = dev;
+	if (hid_is_usb(hdev)) {
-	wacom->intf = intf;
+		struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
+		struct usb_device *dev = interface_to_usbdev(intf);
+		wacom->usbdev = dev;
+		wacom->intf = intf;
+	}
 	mutex_init(&wacom->lock);
 	INIT_DELAYED_WORK(&wacom->init_work, wacom_init_work);
 	INIT_WORK(&wacom->wireless_work, wacom_wireless_work);

drivers/hwmon/corsair-psu.c+1−1

@@ -729,7 +729,7 @@ static int corsairpsu_probe(struct hid_device *hdev, const struct hid_device_id · 728 unmodified lines
729	corsairpsu_check_cmd_support(priv);	729	corsairpsu_check_cmd_support(priv);
730		730
731	priv->hwmon_dev = hwmon_device_register_with_info(&hdev->dev, "corsairpsu", priv,	731	priv->hwmon_dev = hwmon_device_register_with_info(&hdev->dev, "corsairpsu", priv,
732	&corsairpsu_chip_info, 0);	732	&corsairpsu_chip_info, NULL);
733		733
734	if (IS_ERR(priv->hwmon_dev)) {	734	if (IS_ERR(priv->hwmon_dev)) {
735	ret = PTR_ERR(priv->hwmon_dev);	735	ret = PTR_ERR(priv->hwmon_dev);

drivers/hwmon/dell-smm-hwmon.c+3−4

@@ -627,10 +627,9 @@ static void __init i8k_init_procfs(struct device *dev) · 626 unmodified lines
627	{	627	{
628	struct dell_smm_data *data = dev_get_drvdata(dev);	628	struct dell_smm_data *data = dev_get_drvdata(dev);
629		629
630	/* Register the proc entry */	630	/* Only register exit function if creation was successful */
631	proc_create_data("i8k", 0, NULL, &i8k_proc_ops, data);	631	if (proc_create_data("i8k", 0, NULL, &i8k_proc_ops, data))
632		632	devm_add_action_or_reset(dev, i8k_exit_procfs, NULL);
633	devm_add_action_or_reset(dev, i8k_exit_procfs, NULL);
634	}	633	}
635		634
636	#else	635	#else

drivers/hwmon/nct6775.c+1−1

@@ -1527,7 +1527,7 @@ static u16 nct6775_wmi_read_value(struct nct6775_data *data, u16 reg) · 1526 unmodified lines
1527		1527
1528	nct6775_wmi_set_bank(data, reg);	1528	nct6775_wmi_set_bank(data, reg);
1529		1529
1530	err = nct6775_asuswmi_read(data->bank, reg, &tmp);	1530	err = nct6775_asuswmi_read(data->bank, reg & 0xff, &tmp);
1531	if (err)	1531	if (err)
1532	return 0;	1532	return 0;
1533		1533

drivers/hwmon/pwm-fan.c+0−2

@@ -336,8 +336,6 @@ static int pwm_fan_probe(struct platform_device *pdev) · 335 unmodified lines
336	return ret;	336	return ret;
337	}	337	}
338		338
339	ctx->pwm_value = MAX_PWM;
340
341	pwm_init_state(ctx->pwm, &ctx->pwm_state);	339	pwm_init_state(ctx->pwm, &ctx->pwm_state);
342		340
343	/*	341	/*

drivers/hwmon/sht4x.c+2−2

@@ -23,7 +23,7 @@ · 22 unmodified lines
23	/*	23	/*
24	* I2C command delays (in microseconds)	24	* I2C command delays (in microseconds)
25	*/	25	*/
26	#define SHT4X_MEAS_DELAY 1000	26	#define SHT4X_MEAS_DELAY_HPM 8200 /* see t_MEAS,h in datasheet */
27	#define SHT4X_DELAY_EXTRA 10000	27	#define SHT4X_DELAY_EXTRA 10000
28		28
29	/*	29	/*
@@ -90,7 +90,7 @@ static int sht4x_read_values(struct sht4x_data *data) · 60 unmodified lines
90	if (ret < 0)	90	if (ret < 0)
91	goto unlock;	91	goto unlock;
92		92
93	usleep_range(SHT4X_MEAS_DELAY, SHT4X_MEAS_DELAY + SHT4X_DELAY_EXTRA);	93	usleep_range(SHT4X_MEAS_DELAY_HPM, SHT4X_MEAS_DELAY_HPM + SHT4X_DELAY_EXTRA);
94		94
95	ret = i2c_master_recv(client, raw_data, SHT4X_RESPONSE_LENGTH);	95	ret = i2c_master_recv(client, raw_data, SHT4X_RESPONSE_LENGTH);
96	if (ret != SHT4X_RESPONSE_LENGTH) {	96	if (ret != SHT4X_RESPONSE_LENGTH) {

drivers/i2c/busses/i2c-cbus-gpio.c+3−2

@@ -195,8 +195,9 @@ static u32 cbus_i2c_func(struct i2c_adapter *adapter) · 194 unmodified lines
195	}	195	}
196		196
197	static const struct i2c_algorithm cbus_i2c_algo = {	197	static const struct i2c_algorithm cbus_i2c_algo = {
198	.smbus_xfer = cbus_i2c_smbus_xfer,	198	.smbus_xfer = cbus_i2c_smbus_xfer,
199	.functionality = cbus_i2c_func,	199	.smbus_xfer_atomic = cbus_i2c_smbus_xfer,
		200	.functionality = cbus_i2c_func,
200	};	201	};
201		202
202	static int cbus_i2c_remove(struct platform_device *pdev)	203	static int cbus_i2c_remove(struct platform_device *pdev)

drivers/i2c/busses/i2c-mpc.c+1−1

@@ -636,7 +636,7 @@ static irqreturn_t mpc_i2c_isr(int irq, void *dev_id) · 635 unmodified lines
636	status = readb(i2c->base + MPC_I2C_SR);	636	status = readb(i2c->base + MPC_I2C_SR);
637	if (status & CSR_MIF) {	637	if (status & CSR_MIF) {
638	/* Wait up to 100us for transfer to properly complete */	638	/* Wait up to 100us for transfer to properly complete */
639	readb_poll_timeout(i2c->base + MPC_I2C_SR, status, !(status & CSR_MCF), 0, 100);	639	readb_poll_timeout_atomic(i2c->base + MPC_I2C_SR, status, status & CSR_MCF, 0, 100);
640	writeb(0, i2c->base + MPC_I2C_SR);	640	writeb(0, i2c->base + MPC_I2C_SR);
641	mpc_i2c_do_intr(i2c, status);	641	mpc_i2c_do_intr(i2c, status);
642	return IRQ_HANDLED;	642	return IRQ_HANDLED;

drivers/i2c/busses/i2c-rk3x.c+2−2

@@ -423,8 +423,8 @@ static void rk3x_i2c_handle_read(struct rk3x_i2c *i2c, unsigned int ipd) · 422 unmodified lines
423	if (!(ipd & REG_INT_MBRF))	423	if (!(ipd & REG_INT_MBRF))
424	return;	424	return;
425		425
426	/* ack interrupt */	426	/* ack interrupt (read also produces a spurious START flag, clear it too) */
427	i2c_writel(i2c, REG_INT_MBRF, REG_IPD);	427	i2c_writel(i2c, REG_INT_MBRF \| REG_INT_START, REG_IPD);
428		428
429	/* Can only handle a maximum of 32 bytes at a time */	429	/* Can only handle a maximum of 32 bytes at a time */
430	if (len > 32)	430	if (len > 32)

drivers/i2c/busses/i2c-stm32f7.c+38−7

 {
 	struct stm32f7_i2c_dev *i2c_dev = data;
 	struct stm32f7_i2c_msg *f7_msg = &i2c_dev->f7_msg;
+	struct stm32_i2c_dma *dma = i2c_dev->dma;
 	void __iomem *base = i2c_dev->base;
 	u32 status, mask;
 	int ret = IRQ_HANDLED;
 		dev_dbg(i2c_dev->dev, "<%s>: Receive NACK (addr %x)\n",
 			__func__, f7_msg->addr);
 		writel_relaxed(STM32F7_I2C_ICR_NACKCF, base + STM32F7_I2C_ICR);
+		if (i2c_dev->use_dma) {
+			stm32f7_i2c_disable_dma_req(i2c_dev);
+			dmaengine_terminate_async(dma->chan_using);
+		}
 		f7_msg->result = -ENXIO;
 	}
 		/* Clear STOP flag */
 		writel_relaxed(STM32F7_I2C_ICR_STOPCF, base + STM32F7_I2C_ICR);
-		if (i2c_dev->use_dma) {
+		if (i2c_dev->use_dma && !f7_msg->result) {
 			ret = IRQ_WAKE_THREAD;
 		} else {
 			i2c_dev->master_mode = false;
 		if (f7_msg->stop) {
 			mask = STM32F7_I2C_CR2_STOP;
 			stm32f7_i2c_set_bits(base + STM32F7_I2C_CR2, mask);
-		} else if (i2c_dev->use_dma) {
+		} else if (i2c_dev->use_dma && !f7_msg->result) {
 			ret = IRQ_WAKE_THREAD;
 		} else if (f7_msg->smbus) {
 			stm32f7_i2c_smbus_rep_start(i2c_dev);
 	if (!ret) {
 		dev_dbg(i2c_dev->dev, "<%s>: Timed out\n", __func__);
 		stm32f7_i2c_disable_dma_req(i2c_dev);
-		dmaengine_terminate_all(dma->chan_using);
+		dmaengine_terminate_async(dma->chan_using);
 		f7_msg->result = -ETIMEDOUT;
 	}
 	/* Disable dma */
 	if (i2c_dev->use_dma) {
 		stm32f7_i2c_disable_dma_req(i2c_dev);
-		dmaengine_terminate_all(dma->chan_using);
+		dmaengine_terminate_async(dma->chan_using);
 	}
 	i2c_dev->master_mode = false;
 	time_left = wait_for_completion_timeout(&i2c_dev->complete,
 						i2c_dev->adap.timeout);
 	ret = f7_msg->result;
+	if (ret) {
+		if (i2c_dev->use_dma)
+			dmaengine_synchronize(dma->chan_using);
+		/*
+		 * It is possible that some unsent data have already been
+		 * written into TXDR. To avoid sending old data in a
+		 * further transfer, flush TXDR in case of any error
+		 */
+		writel_relaxed(STM32F7_I2C_ISR_TXE,
+			       i2c_dev->base + STM32F7_I2C_ISR);
+		goto pm_free;
+	}
 	if (!time_left) {
 		dev_dbg(i2c_dev->dev, "Access to slave 0x%x timed out\n",
 			i2c_dev->msg->addr);
 		if (i2c_dev->use_dma)
-			dmaengine_terminate_all(dma->chan_using);
+			dmaengine_terminate_sync(dma->chan_using);
+		stm32f7_i2c_wait_free_bus(i2c_dev);
 		ret = -ETIMEDOUT;
 	}
 	timeout = wait_for_completion_timeout(&i2c_dev->complete,
 					      i2c_dev->adap.timeout);
 	ret = f7_msg->result;
-	if (ret)
+	if (ret) {
+		if (i2c_dev->use_dma)
+			dmaengine_synchronize(dma->chan_using);
+		/*
+		 * It is possible that some unsent data have already been
+		 * written into TXDR. To avoid sending old data in a
+		 * further transfer, flush TXDR in case of any error
+		 */
+		writel_relaxed(STM32F7_I2C_ISR_TXE,
+			       i2c_dev->base + STM32F7_I2C_ISR);
 		goto pm_free;
+	}
 	if (!timeout) {
 		dev_dbg(dev, "Access to slave 0x%x timed out\n", f7_msg->addr);
 		if (i2c_dev->use_dma)
-			dmaengine_terminate_all(dma->chan_using);
+			dmaengine_terminate_sync(dma->chan_using);
+		stm32f7_i2c_wait_free_bus(i2c_dev);
 		ret = -ETIMEDOUT;
 		goto pm_free;
 	}

drivers/i2c/busses/i2c-virtio.c+12−20

@@ -22,24 +22,24 @@ · 21 unmodified lines
22	/**	22	/**
23	* struct virtio_i2c - virtio I2C data	23	* struct virtio_i2c - virtio I2C data
24	* @vdev: virtio device for this controller	24	* @vdev: virtio device for this controller
25	* @completion: completion of virtio I2C message
26	* @adap: I2C adapter for this controller	25	* @adap: I2C adapter for this controller
27	* @vq: the virtio virtqueue for communication	26	* @vq: the virtio virtqueue for communication
28	*/	27	*/
29	struct virtio_i2c {	28	struct virtio_i2c {
30	struct virtio_device *vdev;	29	struct virtio_device *vdev;
31	struct completion completion;
32	struct i2c_adapter adap;	30	struct i2c_adapter adap;
33	struct virtqueue *vq;	31	struct virtqueue *vq;
34	};	32	};
35		33
36	/**	34	/**
37	* struct virtio_i2c_req - the virtio I2C request structure	35	* struct virtio_i2c_req - the virtio I2C request structure
		36	* @completion: completion of virtio I2C message
38	* @out_hdr: the OUT header of the virtio I2C message	37	* @out_hdr: the OUT header of the virtio I2C message
39	* @buf: the buffer into which data is read, or from which it's written	38	* @buf: the buffer into which data is read, or from which it's written
40	* @in_hdr: the IN header of the virtio I2C message	39	* @in_hdr: the IN header of the virtio I2C message
41	*/	40	*/
42	struct virtio_i2c_req {	41	struct virtio_i2c_req {
		42	struct completion completion;
43	struct virtio_i2c_out_hdr out_hdr ____cacheline_aligned;	43	struct virtio_i2c_out_hdr out_hdr ____cacheline_aligned;
44	uint8_t *buf ____cacheline_aligned;	44	uint8_t *buf ____cacheline_aligned;
45	struct virtio_i2c_in_hdr in_hdr ____cacheline_aligned;	45	struct virtio_i2c_in_hdr in_hdr ____cacheline_aligned;
@@ -47,9 +47,11 @@ struct virtio_i2c_req { · 1 unmodified line
47		47
48	static void virtio_i2c_msg_done(struct virtqueue *vq)	48	static void virtio_i2c_msg_done(struct virtqueue *vq)
49	{	49	{
50	struct virtio_i2c *vi = vq->vdev->priv;	50	struct virtio_i2c_req *req;
		51	unsigned int len;
51		52
52	complete(&vi->completion);	53	while ((req = virtqueue_get_buf(vq, &len)))
		54	complete(&req->completion);
53	}	55	}
54		56
55	static int virtio_i2c_prepare_reqs(struct virtqueue *vq,	57	static int virtio_i2c_prepare_reqs(struct virtqueue *vq,
@@ -62,6 +64,8 @@ static int virtio_i2c_prepare_reqs(struct virtqueue *vq, · 6 unmodified lines
62	for (i = 0; i < num; i++) {	64	for (i = 0; i < num; i++) {
63	int outcnt = 0, incnt = 0;	65	int outcnt = 0, incnt = 0;
64		66
		67	init_completion(&reqs[i].completion);
		68
65	/*	69	/*
66	* Only 7-bit mode supported for this moment. For the address	70	* Only 7-bit mode supported for this moment. For the address
67	* format, Please check the Virtio I2C Specification.	71	* format, Please check the Virtio I2C Specification.
@@ -106,21 +110,15 @@ static int virtio_i2c_complete_reqs(struct virtqueue *vq, · 38 unmodified lines
106	struct virtio_i2c_req *reqs,	110	struct virtio_i2c_req *reqs,
107	struct i2c_msg *msgs, int num)	111	struct i2c_msg *msgs, int num)
108	{	112	{
109	struct virtio_i2c_req *req;
110	bool failed = false;	113	bool failed = false;
111	unsigned int len;
112	int i, j = 0;	114	int i, j = 0;
113		115
114	for (i = 0; i < num; i++) {	116	for (i = 0; i < num; i++) {
115	/* Detach the ith request from the vq */	117	struct virtio_i2c_req *req = &reqs[i];
116	req = virtqueue_get_buf(vq, &len);
117		118
118	/*	119	wait_for_completion(&req->completion);
119	* Condition req == &reqs[i] should always meet since we have	120
120	* total num requests in the vq. reqs[i] can never be NULL here.	121	if (!failed && req->in_hdr.status != VIRTIO_I2C_MSG_OK)
121	*/
122	if (!failed && (WARN_ON(req != &reqs[i]) \|\|
123	req->in_hdr.status != VIRTIO_I2C_MSG_OK))
124	failed = true;	122	failed = true;
125		123
126	i2c_put_dma_safe_msg_buf(reqs[i].buf, &msgs[i], !failed);	124	i2c_put_dma_safe_msg_buf(reqs[i].buf, &msgs[i], !failed);
@@ -156,12 +154,8 @@ static int virtio_i2c_xfer(struct i2c_adapter adap, struct i2c_msg msgs, · 29 unmodified lines
156	* remote here to clear the virtqueue, so we can try another set of	154	* remote here to clear the virtqueue, so we can try another set of
157	* messages later on.	155	* messages later on.
158	*/	156	*/
159
160	reinit_completion(&vi->completion);
161	virtqueue_kick(vq);	157	virtqueue_kick(vq);
162		158
163	wait_for_completion(&vi->completion);
164
165	count = virtio_i2c_complete_reqs(vq, reqs, msgs, count);	159	count = virtio_i2c_complete_reqs(vq, reqs, msgs, count);
166		160
167	err_free:	161	err_free:
@@ -210,8 +204,6 @@ static int virtio_i2c_probe(struct virtio_device *vdev) · 42 unmodified lines
210	vdev->priv = vi;	204	vdev->priv = vi;
211	vi->vdev = vdev;	205	vi->vdev = vdev;
212		206
213	init_completion(&vi->completion);
214
215	ret = virtio_i2c_setup_vqs(vi);	207	ret = virtio_i2c_setup_vqs(vi);
216	if (ret)	208	if (ret)
217	return ret;	209	return ret;

drivers/iio/accel/kxcjk-1013.c+2−3

 	return 0;
 err_buffer_cleanup:
-	if (data->dready_trig)
+	iio_triggered_buffer_cleanup(indio_dev);
-		iio_triggered_buffer_cleanup(indio_dev);
 err_trigger_unregister:
 	if (data->dready_trig)
 		iio_trigger_unregister(data->dready_trig);
 	pm_runtime_disable(&client->dev);
 	pm_runtime_set_suspended(&client->dev);
+	iio_triggered_buffer_cleanup(indio_dev);
 	if (data->dready_trig) {
-		iio_triggered_buffer_cleanup(indio_dev);
 		iio_trigger_unregister(data->dready_trig);
 		iio_trigger_unregister(data->motion_trig);
 	}

drivers/iio/accel/kxsd9.c+3−3

 			       hw_values.chan,
 			       sizeof(hw_values.chan));
 	if (ret) {
-		dev_err(st->dev,
+		dev_err(st->dev, "error reading data: %d\n", ret);
-			"error reading data\n");
+		goto out;
-		return ret;
 	}
 	iio_push_to_buffers_with_timestamp(indio_dev,
 					   &hw_values,
 					   iio_get_time_ns(indio_dev));
+out:
 	iio_trigger_notify_done(indio_dev->trig);
 	return IRQ_HANDLED;

drivers/iio/accel/mma8452.c+1−1

@@ -1470,7 +1470,7 @@ static int mma8452_trigger_setup(struct iio_dev *indio_dev) · 1469 unmodified lines
1470	if (ret)	1470	if (ret)
1471	return ret;	1471	return ret;
1472		1472
1473	indio_dev->trig = trig;	1473	indio_dev->trig = iio_trigger_get(trig);
1474		1474
1475	return 0;	1475	return 0;
1476	}	1476	}

drivers/iio/adc/Kconfig+1−1

@@ -532,7 +532,7 @@ config IMX7D_ADC · 531 unmodified lines
532		532
533	config IMX8QXP_ADC	533	config IMX8QXP_ADC
534	tristate "NXP IMX8QXP ADC driver"	534	tristate "NXP IMX8QXP ADC driver"
535	depends on ARCH_MXC_ARM64 \|\| COMPILE_TEST	535	depends on ARCH_MXC \|\| COMPILE_TEST
536	depends on HAS_IOMEM	536	depends on HAS_IOMEM
537	help	537	help
538	Say yes here to build support for IMX8QXP ADC.	538	Say yes here to build support for IMX8QXP ADC.

drivers/iio/adc/ad7768-1.c+1−1

@@ -480,8 +480,8 @@ static irqreturn_t ad7768_trigger_handler(int irq, void *p) · 479 unmodified lines
480	iio_push_to_buffers_with_timestamp(indio_dev, &st->data.scan,	480	iio_push_to_buffers_with_timestamp(indio_dev, &st->data.scan,
481	iio_get_time_ns(indio_dev));	481	iio_get_time_ns(indio_dev));
482		482
483	iio_trigger_notify_done(indio_dev->trig);
484	err_unlock:	483	err_unlock:
		484	iio_trigger_notify_done(indio_dev->trig);
485	mutex_unlock(&st->lock);	485	mutex_unlock(&st->lock);
486		486
487	return IRQ_HANDLED;	487	return IRQ_HANDLED;

drivers/iio/adc/at91-sama5d2_adc.c+2−1

@@ -1586,7 +1586,8 @@ static int at91_adc_read_info_raw(struct iio_dev *indio_dev, · 1585 unmodified lines
1586	*val = st->conversion_value;	1586	*val = st->conversion_value;
1587	ret = at91_adc_adjust_val_osr(st, val);	1587	ret = at91_adc_adjust_val_osr(st, val);
1588	if (chan->scan_type.sign == 's')	1588	if (chan->scan_type.sign == 's')
1589	val = sign_extend32(val, 11);	1589	val = sign_extend32(val,
		1590	chan->scan_type.realbits - 1);
1590	st->conversion_done = false;	1591	st->conversion_done = false;
1591	}	1592	}
1592		1593

drivers/iio/adc/axp20x_adc.c+3−15

 			  struct iio_chan_spec const *chan, int *val)
 {
 	struct axp20x_adc_iio *info = iio_priv(indio_dev);
-	int size;
-	/*
+	*val = axp20x_read_variable_width(info->regmap, chan->address, 12);
-	 * N.B.: Unlike the Chinese datasheets tell, the charging current is
-	 * stored on 12 bits, not 13 bits. Only discharging current is on 13
-	 * bits.
-	 */
-	if (chan->type == IIO_CURRENT && chan->channel == AXP22X_BATT_DISCHRG_I)
-		size = 13;
-	else
-		size = 12;
-	*val = axp20x_read_variable_width(info->regmap, chan->address, size);
 	if (*val < 0)
 		return *val;
 		return IIO_VAL_INT_PLUS_MICRO;
 	case IIO_CURRENT:
-		*val = 0;
+		*val = 1;
-		*val2 = 500000;
+		return IIO_VAL_INT;
-		return IIO_VAL_INT_PLUS_MICRO;
 	case IIO_TEMP:
 		*val = 100;

drivers/iio/adc/dln2-adc.c+12−9

 static int dln2_adc_read(struct dln2_adc *dln2, unsigned int channel)
 {
 	int ret, i;
-	struct iio_dev *indio_dev = platform_get_drvdata(dln2->pdev);
 	u16 conflict;
 	__le16 value;
 	int olen = sizeof(value);
 		.chan = channel,
 	};
-	ret = iio_device_claim_direct_mode(indio_dev);
-	if (ret < 0)
-		return ret;
 	ret = dln2_adc_set_chan_enabled(dln2, channel, true);
 	if (ret < 0)
-		goto release_direct;
+		return ret;
 	ret = dln2_adc_set_port_enabled(dln2, true, &conflict);
 	if (ret < 0) {
 	dln2_adc_set_port_enabled(dln2, false, NULL);
 disable_chan:
 	dln2_adc_set_chan_enabled(dln2, channel, false);
-release_direct:
-	iio_device_release_direct_mode(indio_dev);
 	return ret;
 }
 	switch (mask) {
 	case IIO_CHAN_INFO_RAW:
+		ret = iio_device_claim_direct_mode(indio_dev);
+		if (ret < 0)
+			return ret;
 		mutex_lock(&dln2->mutex);
 		ret = dln2_adc_read(dln2, chan->channel);
 		mutex_unlock(&dln2->mutex);
+		iio_device_release_direct_mode(indio_dev);
 		if (ret < 0)
 			return ret;
 		return -ENOMEM;
 	}
 	iio_trigger_set_drvdata(dln2->trig, dln2);
-	devm_iio_trigger_register(dev, dln2->trig);
+	ret = devm_iio_trigger_register(dev, dln2->trig);
+	if (ret) {
+		dev_err(dev, "failed to register trigger: %d\n", ret);
+		return ret;
+	}
 	iio_trigger_set_immutable(indio_dev, dln2->trig);
 	ret = devm_iio_triggered_buffer_setup(dev, indio_dev, NULL,

drivers/iio/adc/stm32-adc.c+2−1

 {
 	struct stm32_adc *adc = iio_priv(indio_dev);
+	stm32_adc_writel(adc, STM32H7_ADC_PCSEL, 0);
 	stm32h7_adc_disable(indio_dev);
 	stm32_adc_int_ch_disable(adc);
 	stm32h7_adc_enter_pwr_down(adc);
 			/* Get calibration data for vrefint channel */
 			ret = nvmem_cell_read_u16(&indio_dev->dev, "vrefint", &vrefint);
 			if (ret && ret != -ENOENT) {
-				return dev_err_probe(&indio_dev->dev, ret,
+				return dev_err_probe(indio_dev->dev.parent, ret,
 						     "nvmem access error\n");
 			}
 			if (ret == -ENOENT)

drivers/iio/gyro/adxrs290.c+3−2

  */
 #include <linux/bitfield.h>
+#include <linux/bitops.h>
 #include <linux/delay.h>
 #include <linux/device.h>
 #include <linux/kernel.h>
 		goto err_unlock;
 	}
-	*val = temp;
+	*val = sign_extend32(temp, 15);
 err_unlock:
 	mutex_unlock(&st->lock);
 	}
 	/* extract lower 12 bits temperature reading */
-	*val = temp & 0x0FFF;
+	*val = sign_extend32(temp, 11);
 err_unlock:
 	mutex_unlock(&st->lock);

drivers/iio/gyro/itg3200_buffer.c+1−1

@@ -61,9 +61,9 @@ static irqreturn_t itg3200_trigger_handler(int irq, void *p) · 60 unmodified lines
61		61
62	iio_push_to_buffers_with_timestamp(indio_dev, &scan, pf->timestamp);	62	iio_push_to_buffers_with_timestamp(indio_dev, &scan, pf->timestamp);
63		63
		64	error_ret:
64	iio_trigger_notify_done(indio_dev->trig);	65	iio_trigger_notify_done(indio_dev->trig);
65		66
66	error_ret:
67	return IRQ_HANDLED;	67	return IRQ_HANDLED;
68	}	68	}
69		69

drivers/iio/industrialio-trigger.c+0−1

@@ -556,7 +556,6 @@ struct iio_trigger viio_trigger_alloc(struct device parent, · 555 unmodified lines
556	irq_modify_status(trig->subirq_base + i,	556	irq_modify_status(trig->subirq_base + i,
557	IRQ_NOREQUEST \| IRQ_NOAUTOEN, IRQ_NOPROBE);	557	IRQ_NOREQUEST \| IRQ_NOAUTOEN, IRQ_NOPROBE);
558	}	558	}
559	get_device(&trig->dev);
560		559
561	return trig;	560	return trig;
562		561

drivers/iio/light/ltr501.c+1−1

@@ -1275,7 +1275,7 @@ static irqreturn_t ltr501_trigger_handler(int irq, void *p) · 1274 unmodified lines
1275	ret = regmap_bulk_read(data->regmap, LTR501_ALS_DATA1,	1275	ret = regmap_bulk_read(data->regmap, LTR501_ALS_DATA1,
1276	als_buf, sizeof(als_buf));	1276	als_buf, sizeof(als_buf));
1277	if (ret < 0)	1277	if (ret < 0)
1278	return ret;	1278	goto done;
1279	if (test_bit(0, indio_dev->active_scan_mask))	1279	if (test_bit(0, indio_dev->active_scan_mask))
1280	scan.channels[j++] = le16_to_cpu(als_buf[1]);	1280	scan.channels[j++] = le16_to_cpu(als_buf[1]);
1281	if (test_bit(1, indio_dev->active_scan_mask))	1281	if (test_bit(1, indio_dev->active_scan_mask))

drivers/iio/light/stk3310.c+3−3

 	mutex_lock(&data->lock);
 	ret = regmap_field_read(data->reg_flag_nf, &dir);
 	if (ret < 0) {
-		dev_err(&data->client->dev, "register read failed\n");
+		dev_err(&data->client->dev, "register read failed: %d\n", ret);
-		mutex_unlock(&data->lock);
+		goto out;
-		return ret;
 	}
 	event = IIO_UNMOD_EVENT_CODE(IIO_PROXIMITY, 1,
 				     IIO_EV_TYPE_THRESH,
 	ret = regmap_field_write(data->reg_flag_psint, 0);
 	if (ret < 0)
 		dev_err(&data->client->dev, "failed to reset interrupts\n");
+out:
 	mutex_unlock(&data->lock);
 	return IRQ_HANDLED;

drivers/iio/trigger/stm32-timer-trigger.c+1−1

@@ -912,6 +912,6 @@ static struct platform_driver stm32_timer_trigger_driver = { · 911 unmodified lines
912	};	912	};
913	module_platform_driver(stm32_timer_trigger_driver);	913	module_platform_driver(stm32_timer_trigger_driver);
914		914
915	MODULE_ALIAS("platform: stm32-timer-trigger");	915	MODULE_ALIAS("platform:stm32-timer-trigger");
916	MODULE_DESCRIPTION("STMicroelectronics STM32 Timer Trigger driver");	916	MODULE_DESCRIPTION("STMicroelectronics STM32 Timer Trigger driver");
917	MODULE_LICENSE("GPL v2");	917	MODULE_LICENSE("GPL v2");

drivers/infiniband/hw/hfi1/chip.c+2−0

  */
 static void __hfi1_rcd_eoi_intr(struct hfi1_ctxtdata *rcd)
 {
+	if (!rcd->rcvhdrq)
+		return;
 	clear_recv_intr(rcd);
 	if (check_packet_present(rcd))
 		force_recv_intr(rcd);

drivers/infiniband/hw/hfi1/driver.c+2−0

@@ -1012,6 +1012,8 @@ int handle_receive_interrupt(struct hfi1_ctxtdata *rcd, int thread) · 1011 unmodified lines
1012	struct hfi1_packet packet;	1012	struct hfi1_packet packet;
1013	int skip_pkt = 0;	1013	int skip_pkt = 0;
1014		1014
		1015	if (!rcd->rcvhdrq)
		1016	return RCV_PKT_OK;
1015	/* Control context will always use the slow path interrupt handler */	1017	/* Control context will always use the slow path interrupt handler */
1016	needset = (rcd->ctxt == HFI1_CTRL_CTXT) ? 0 : 1;	1018	needset = (rcd->ctxt == HFI1_CTRL_CTXT) ? 0 : 1;
1017		1019

drivers/infiniband/hw/hfi1/init.c+17−23

 	rcd->fast_handler = get_dma_rtail_setting(rcd) ?
 				handle_receive_interrupt_dma_rtail :
 				handle_receive_interrupt_nodma_rtail;
-	rcd->slow_handler = handle_receive_interrupt;
 	hfi1_set_seq_cnt(rcd, 1);
 		rcd->numa_id = numa;
 		rcd->rcv_array_groups = dd->rcv_entries.ngroups;
 		rcd->rhf_rcv_function_map = normal_rhf_rcv_functions;
+		rcd->slow_handler = handle_receive_interrupt;
+		rcd->do_interrupt = rcd->slow_handler;
 		rcd->msix_intr = CCE_NUM_MSIX_VECTORS;
 		mutex_init(&rcd->exp_mutex);
 	if (ret)
 		goto done;
-	/* allocate dummy tail memory for all receive contexts */
-	dd->rcvhdrtail_dummy_kvaddr = dma_alloc_coherent(&dd->pcidev->dev,
-							 sizeof(u64),
-							 &dd->rcvhdrtail_dummy_dma,
-							 GFP_KERNEL);
-	if (!dd->rcvhdrtail_dummy_kvaddr) {
-		dd_dev_err(dd, "cannot allocate dummy tail memory\n");
-		ret = -ENOMEM;
-		goto done;
-	}
 	/* dd->rcd can be NULL if early initialization failed */
 	for (i = 0; dd->rcd && i < dd->first_dyn_alloc_ctxt; ++i) {
 		/*
 		if (!rcd)
 			continue;
-		rcd->do_interrupt = &handle_receive_interrupt;
 		lastfail = hfi1_create_rcvhdrq(dd, rcd);
 		if (!lastfail)
 			lastfail = hfi1_setup_eagerbufs(rcd);
 	rcd->egrbufs.rcvtids = NULL;
 	for (e = 0; e < rcd->egrbufs.alloced; e++) {
-		if (rcd->egrbufs.buffers[e].dma)
+		if (rcd->egrbufs.buffers[e].addr)
 			dma_free_coherent(&dd->pcidev->dev,
 					  rcd->egrbufs.buffers[e].len,
 					  rcd->egrbufs.buffers[e].addr,
 	dd->tx_opstats    = NULL;
 	kfree(dd->comp_vect);
 	dd->comp_vect = NULL;
+	if (dd->rcvhdrtail_dummy_kvaddr)
+		dma_free_coherent(&dd->pcidev->dev, sizeof(u64),
+				  (void *)dd->rcvhdrtail_dummy_kvaddr,
+				  dd->rcvhdrtail_dummy_dma);
+	dd->rcvhdrtail_dummy_kvaddr = NULL;
 	sdma_clean(dd, dd->num_sdma);
 	rvt_dealloc_device(&dd->verbs_dev.rdi);
 }
 		goto bail;
 	}
+	/* allocate dummy tail memory for all receive contexts */
+	dd->rcvhdrtail_dummy_kvaddr =
+		dma_alloc_coherent(&dd->pcidev->dev, sizeof(u64),
+				   &dd->rcvhdrtail_dummy_dma, GFP_KERNEL);
+	if (!dd->rcvhdrtail_dummy_kvaddr) {
+		ret = -ENOMEM;
+		goto bail;
+	}
 	atomic_set(&dd->ipoib_rsm_usr_num, 0);
 	return dd;
 	free_credit_return(dd);
-	if (dd->rcvhdrtail_dummy_kvaddr) {
-		dma_free_coherent(&dd->pcidev->dev, sizeof(u64),
-				  (void *)dd->rcvhdrtail_dummy_kvaddr,
-				  dd->rcvhdrtail_dummy_dma);
-		dd->rcvhdrtail_dummy_kvaddr = NULL;
-	}
 	/*
 	 * Free any resources still in use (usually just kernel contexts)
 	 * at unload; we do for ctxtcnt, because that's what we allocate.

drivers/infiniband/hw/hfi1/sdma.c+1−1

@@ -838,8 +838,8 @@ struct sdma_engine sdma_select_user_engine(struct hfi1_devdata dd, · 837 unmodified lines
838	if (current->nr_cpus_allowed != 1)	838	if (current->nr_cpus_allowed != 1)
839	goto out;	839	goto out;
840		840
841	cpu_id = smp_processor_id();
842	rcu_read_lock();	841	rcu_read_lock();
		842	cpu_id = smp_processor_id();
843	rht_node = rhashtable_lookup(dd->sdma_rht, &cpu_id,	843	rht_node = rhashtable_lookup(dd->sdma_rht, &cpu_id,
844	sdma_rht_params);	844	sdma_rht_params);
845		845

drivers/infiniband/hw/hns/hns_roce_hw_v2.c+11−3

@@ -33,6 +33,7 @@ · 32 unmodified lines
33	#include <linux/acpi.h>	33	#include <linux/acpi.h>
34	#include <linux/etherdevice.h>	34	#include <linux/etherdevice.h>
35	#include <linux/interrupt.h>	35	#include <linux/interrupt.h>
		36	#include <linux/iopoll.h>
36	#include <linux/kernel.h>	37	#include <linux/kernel.h>
37	#include <linux/types.h>	38	#include <linux/types.h>
38	#include <net/addrconf.h>	39	#include <net/addrconf.h>
@@ -1050,9 +1051,14 @@ static u32 hns_roce_v2_cmd_hw_resetting(struct hns_roce_dev *hr_dev, · 1011 unmodified lines
1050	unsigned long instance_stage,	1051	unsigned long instance_stage,
1051	unsigned long reset_stage)	1052	unsigned long reset_stage)
1052	{	1053	{
		1054	#define HW_RESET_TIMEOUT_US 1000000
		1055	#define HW_RESET_SLEEP_US 1000
		1056
1053	struct hns_roce_v2_priv *priv = hr_dev->priv;	1057	struct hns_roce_v2_priv *priv = hr_dev->priv;
1054	struct hnae3_handle *handle = priv->handle;	1058	struct hnae3_handle *handle = priv->handle;
1055	const struct hnae3_ae_ops *ops = handle->ae_algo->ops;	1059	const struct hnae3_ae_ops *ops = handle->ae_algo->ops;
		1060	unsigned long val;
		1061	int ret;
1056		1062
1057	/* When hardware reset is detected, we should stop sending mailbox&cmq&	1063	/* When hardware reset is detected, we should stop sending mailbox&cmq&
1058	* doorbell to hardware. If now in .init_instance() function, we should	1064	* doorbell to hardware. If now in .init_instance() function, we should
@@ -1064,7 +1070,11 @@ static u32 hns_roce_v2_cmd_hw_resetting(struct hns_roce_dev *hr_dev, · 5 unmodified lines
1064	* again.	1070	* again.
1065	*/	1071	*/
1066	hr_dev->dis_db = true;	1072	hr_dev->dis_db = true;
1067	if (!ops->get_hw_reset_stat(handle))	1073
		1074	ret = read_poll_timeout(ops->ae_dev_reset_cnt, val,
		1075	val > hr_dev->reset_cnt, HW_RESET_SLEEP_US,
		1076	HW_RESET_TIMEOUT_US, false, handle);
		1077	if (!ret)
1068	hr_dev->is_reset = true;	1078	hr_dev->is_reset = true;
1069		1079
1070	if (!hr_dev->is_reset \|\| reset_stage == HNS_ROCE_STATE_RST_INIT \|\|	1080	if (!hr_dev->is_reset \|\| reset_stage == HNS_ROCE_STATE_RST_INIT \|\|
@@ -6387,10 +6397,8 @@ static int hns_roce_hw_v2_reset_notify_down(struct hnae3_handle *handle) · 5316 unmodified lines
6387	if (!hr_dev)	6397	if (!hr_dev)
6388	return 0;	6398	return 0;
6389		6399
6390	hr_dev->is_reset = true;
6391	hr_dev->active = false;	6400	hr_dev->active = false;
6392	hr_dev->dis_db = true;	6401	hr_dev->dis_db = true;
6393
6394	hr_dev->state = HNS_ROCE_DEVICE_STATE_RST_DOWN;	6402	hr_dev->state = HNS_ROCE_DEVICE_STATE_RST_DOWN;
6395		6403
6396	return 0;	6404	return 0;

drivers/infiniband/hw/irdma/hw.c+6−1

 {
 	struct irdma_cq *cq = iwcq->back_cq;
+	if (!cq->user_mode)
+		cq->armed = false;
 	if (cq->ibcq.comp_handler)
 		cq->ibcq.comp_handler(&cq->ibcq, cq->ibcq.cq_context);
 }
 		qp->flush_code = FLUSH_PROT_ERR;
 		break;
 	case IRDMA_AE_AMP_BAD_QP:
+	case IRDMA_AE_WQE_UNEXPECTED_OPCODE:
 		qp->flush_code = FLUSH_LOC_QP_OP_ERR;
 		break;
 	case IRDMA_AE_AMP_BAD_STAG_KEY:
 	case IRDMA_AE_PRIV_OPERATION_DENIED:
 	case IRDMA_AE_IB_INVALID_REQUEST:
 	case IRDMA_AE_IB_REMOTE_ACCESS_ERROR:
-	case IRDMA_AE_IB_REMOTE_OP_ERROR:
 		qp->flush_code = FLUSH_REM_ACCESS_ERR;
 		qp->event_type = IRDMA_QP_EVENT_ACCESS_ERR;
 		break;
 	case IRDMA_AE_AMP_MWBIND_INVALID_BOUNDS:
 		qp->flush_code = FLUSH_MW_BIND_ERR;
 		break;
+	case IRDMA_AE_IB_REMOTE_OP_ERROR:
+		qp->flush_code = FLUSH_REM_OP_ERR;
+		break;
 	default:
 		qp->flush_code = FLUSH_FATAL_ERR;
 		break;

drivers/infiniband/hw/irdma/main.h+1−0

@@ -542,6 +542,7 @@ int irdma_ah_cqp_op(struct irdma_pci_f rf, struct irdma_sc_ah sc_ah, u8 cmd, · 541 unmodified lines
542	void (callback_fcn)(struct irdma_cqp_request cqp_request),	542	void (callback_fcn)(struct irdma_cqp_request cqp_request),
543	void *cb_param);	543	void *cb_param);
544	void irdma_gsi_ud_qp_ah_cb(struct irdma_cqp_request *cqp_request);	544	void irdma_gsi_ud_qp_ah_cb(struct irdma_cqp_request *cqp_request);
		545	bool irdma_cq_empty(struct irdma_cq *iwcq);
545	int irdma_inetaddr_event(struct notifier_block *notifier, unsigned long event,	546	int irdma_inetaddr_event(struct notifier_block *notifier, unsigned long event,
546	void *ptr);	547	void *ptr);
547	int irdma_inet6addr_event(struct notifier_block *notifier, unsigned long event,	548	int irdma_inet6addr_event(struct notifier_block *notifier, unsigned long event,

drivers/infiniband/hw/irdma/pble.c+3−5

 		list_del(&chunk->list);
 		if (chunk->type == PBLE_SD_PAGED)
 			irdma_pble_free_paged_mem(chunk);
-		if (chunk->bitmapbuf)
+		bitmap_free(chunk->bitmapbuf);
-			kfree(chunk->bitmapmem.va);
 		kfree(chunk->chunkmem.va);
 	}
 }
 		  "PBLE: next_fpm_addr = %llx chunk_size[%llu] = 0x%llx\n",
 		  pble_rsrc->next_fpm_addr, chunk->size, chunk->size);
 	pble_rsrc->unallocated_pble -= (u32)(chunk->size >> 3);
-	list_add(&chunk->list, &pble_rsrc->pinfo.clist);
 	sd_reg_val = (sd_entry_type == IRDMA_SD_TYPE_PAGED) ?
 			     sd_entry->u.pd_table.pd_page_addr.pa :
 			     sd_entry->u.bp.addr.pa;
 			goto error;
 	}
+	list_add(&chunk->list, &pble_rsrc->pinfo.clist);
 	sd_entry->valid = true;
 	return 0;
 error:
-	if (chunk->bitmapbuf)
+	bitmap_free(chunk->bitmapbuf);
-		kfree(chunk->bitmapmem.va);
 	kfree(chunk->chunkmem.va);
 	return ret_code;

drivers/infiniband/hw/irdma/pble.h+0−1

@@ -78,7 +78,6 @@ struct irdma_chunk { · 77 unmodified lines
78	u32 pg_cnt;	78	u32 pg_cnt;
79	enum irdma_alloc_type type;	79	enum irdma_alloc_type type;
80	struct irdma_sc_dev *dev;	80	struct irdma_sc_dev *dev;
81	struct irdma_virt_mem bitmapmem;
82	struct irdma_virt_mem chunkmem;	81	struct irdma_virt_mem chunkmem;
83	};	82	};
84		83

drivers/infiniband/hw/irdma/utils.c+17−7

 	sizeofbitmap = (u64)pchunk->size >> pprm->pble_shift;
-	pchunk->bitmapmem.size = sizeofbitmap >> 3;
+	pchunk->bitmapbuf = bitmap_zalloc(sizeofbitmap, GFP_KERNEL);
-	pchunk->bitmapmem.va = kzalloc(pchunk->bitmapmem.size, GFP_KERNEL);
+	if (!pchunk->bitmapbuf)
-	if (!pchunk->bitmapmem.va)
 		return IRDMA_ERR_NO_MEMORY;
-	pchunk->bitmapbuf = pchunk->bitmapmem.va;
-	bitmap_zero(pchunk->bitmapbuf, sizeofbitmap);
 	pchunk->sizeofbitmap = sizeofbitmap;
 	/* each pble is 8 bytes hence shift by 3 */
 	pprm->total_pble_alloc += pchunk->size >> 3;
 	ibevent.element.qp = &iwqp->ibqp;
 	iwqp->ibqp.event_handler(&ibevent, iwqp->ibqp.qp_context);
 }
+bool irdma_cq_empty(struct irdma_cq *iwcq)
+{
+	struct irdma_cq_uk *ukcq;
+	u64 qword3;
+	__le64 *cqe;
+	u8 polarity;
+	ukcq  = &iwcq->sc_cq.cq_uk;
+	cqe = IRDMA_GET_CURRENT_CQ_ELEM(ukcq);
+	get_64bit_val(cqe, 24, &qword3);
+	polarity = (u8)FIELD_GET(IRDMA_CQ_VALID, qword3);
+	return polarity != ukcq->polarity;
+}

drivers/infiniband/hw/irdma/verbs.c+18−5

 	struct irdma_cq *iwcq;
 	struct irdma_cq_uk *ukcq;
 	unsigned long flags;
-	enum irdma_cmpl_notify cq_notify = IRDMA_CQ_COMPL_EVENT;
+	enum irdma_cmpl_notify cq_notify;
+	bool promo_event = false;
+	int ret = 0;
+	cq_notify = notify_flags == IB_CQ_SOLICITED ?
+		    IRDMA_CQ_COMPL_SOLICITED : IRDMA_CQ_COMPL_EVENT;
 	iwcq = to_iwcq(ibcq);
 	ukcq = &iwcq->sc_cq.cq_uk;
-	if (notify_flags == IB_CQ_SOLICITED)
-		cq_notify = IRDMA_CQ_COMPL_SOLICITED;
 	spin_lock_irqsave(&iwcq->lock, flags);
-	irdma_uk_cq_request_notification(ukcq, cq_notify);
+	/* Only promote to arm the CQ for any event if the last arm event was solicited. */
+	if (iwcq->last_notify == IRDMA_CQ_COMPL_SOLICITED && notify_flags != IB_CQ_SOLICITED)
+		promo_event = true;
+	if (!iwcq->armed || promo_event) {
+		iwcq->armed = true;
+		iwcq->last_notify = cq_notify;
+		irdma_uk_cq_request_notification(ukcq, cq_notify);
+	}
+	if ((notify_flags & IB_CQ_REPORT_MISSED_EVENTS) && !irdma_cq_empty(iwcq))
+		ret = 1;
 	spin_unlock_irqrestore(&iwcq->lock, flags);
-	return 0;
+	return ret;
 }
 static int irdma_roce_port_immutable(struct ib_device *ibdev, u32 port_num,

drivers/infiniband/hw/irdma/verbs.h+2−0

 	u16 cq_size;
 	u16 cq_num;
 	bool user_mode;
+	bool armed;
+	enum irdma_cmpl_notify last_notify;
 	u32 polled_cmpls;
 	u32 cq_mem_size;
 	struct irdma_dma_mem kmem;

drivers/infiniband/hw/mlx5/mlx5_ib.h+3−3

 	/* User MR data */
 	struct mlx5_cache_ent *cache_ent;
-	struct ib_umem *umem;
 	/* This is zero'd when the MR is allocated */
 	union {
 			struct list_head list;
 		};
-		/* Used only by kernel MRs (umem == NULL) */
+		/* Used only by kernel MRs */
 		struct {
 			void *descs;
 			void *descs_alloc;
 			int data_length;
 		};
-		/* Used only by User MRs (umem != NULL) */
+		/* Used only by User MRs */
 		struct {
+			struct ib_umem *umem;
 			unsigned int page_shift;
 			/* Current access_flags */
 			int access_flags;

drivers/infiniband/hw/mlx5/mr.c+12−14

@@ -1904,19 +1904,18 @@ err: · 1903 unmodified lines
1904	return ret;	1904	return ret;
1905	}	1905	}
1906		1906
1907	static void	1907	static void mlx5_free_priv_descs(struct mlx5_ib_mr *mr)
1908	mlx5_free_priv_descs(struct mlx5_ib_mr *mr)
1909	{	1908	{
1910	if (!mr->umem && mr->descs) {	1909	struct mlx5_ib_dev *dev = to_mdev(mr->ibmr.device);
1911	struct ib_device *device = mr->ibmr.device;	1910	int size = mr->max_descs * mr->desc_size;
1912	int size = mr->max_descs * mr->desc_size;
1913	struct mlx5_ib_dev *dev = to_mdev(device);
1914		1911
1915	dma_unmap_single(&dev->mdev->pdev->dev, mr->desc_map, size,	1912	if (!mr->descs)
1916	DMA_TO_DEVICE);	1913	return;
1917	kfree(mr->descs_alloc);	1914
1918	mr->descs = NULL;	1915	dma_unmap_single(&dev->mdev->pdev->dev, mr->desc_map, size,
1919	}	1916	DMA_TO_DEVICE);
		1917	kfree(mr->descs_alloc);
		1918	mr->descs = NULL;
1920	}	1919	}
1921		1920
1922	int mlx5_ib_dereg_mr(struct ib_mr ibmr, struct ib_udata udata)	1921	int mlx5_ib_dereg_mr(struct ib_mr ibmr, struct ib_udata udata)
@@ -1992,7 +1991,8 @@ int mlx5_ib_dereg_mr(struct ib_mr ibmr, struct ib_udata udata) · 69 unmodified lines
1992	if (mr->cache_ent) {	1991	if (mr->cache_ent) {
1993	mlx5_mr_cache_free(dev, mr);	1992	mlx5_mr_cache_free(dev, mr);
1994	} else {	1993	} else {
1995	mlx5_free_priv_descs(mr);	1994	if (!udata)
		1995	mlx5_free_priv_descs(mr);
1996	kfree(mr);	1996	kfree(mr);
1997	}	1997	}
1998	return 0;	1998	return 0;
@@ -2079,7 +2079,6 @@ static struct mlx5_ib_mr mlx5_ib_alloc_pi_mr(struct ib_pd pd, · 80 unmodified lines
2079	if (err)	2079	if (err)
2080	goto err_free_in;	2080	goto err_free_in;
2081		2081
2082	mr->umem = NULL;
2083	kfree(in);	2082	kfree(in);
2084		2083
2085	return mr;	2084	return mr;
@@ -2206,7 +2205,6 @@ static struct ib_mr __mlx5_ib_alloc_mr(struct ib_pd pd, · 120 unmodified lines
2206	}	2205	}
2207		2206
2208	mr->ibmr.device = pd->device;	2207	mr->ibmr.device = pd->device;
2209	mr->umem = NULL;
2210		2208
2211	switch (mr_type) {	2209	switch (mr_type) {
2212	case IB_MR_TYPE_MEM_REG:	2210	case IB_MR_TYPE_MEM_REG:

drivers/infiniband/sw/rxe/rxe_qp.c+1−0

@@ -359,6 +359,7 @@ int rxe_qp_from_init(struct rxe_dev rxe, struct rxe_qp qp, struct rxe_pd *pd, · 358 unmodified lines
359		359
360	err2:	360	err2:
361	rxe_queue_cleanup(qp->sq.queue);	361	rxe_queue_cleanup(qp->sq.queue);
		362	qp->sq.queue = NULL;
362	err1:	363	err1:
363	qp->pd = NULL;	364	qp->pd = NULL;
364	qp->rcq = NULL;	365	qp->rcq = NULL;

drivers/infiniband/ulp/rtrs/rtrs-clt-stats.c+6−3

 	int cpu;
 	cpu = raw_smp_processor_id();
-	s = this_cpu_ptr(stats->pcpu_stats);
+	s = get_cpu_ptr(stats->pcpu_stats);
 	if (con->cpu != cpu) {
 		s->cpu_migr.to++;
 		s = per_cpu_ptr(stats->pcpu_stats, con->cpu);
 		atomic_inc(&s->cpu_migr.from);
 	}
+	put_cpu_ptr(stats->pcpu_stats);
 }
 void rtrs_clt_inc_failover_cnt(struct rtrs_clt_stats *stats)
 {
 	struct rtrs_clt_stats_pcpu *s;
-	s = this_cpu_ptr(stats->pcpu_stats);
+	s = get_cpu_ptr(stats->pcpu_stats);
 	s->rdma.failover_cnt++;
+	put_cpu_ptr(stats->pcpu_stats);
 }
 int rtrs_clt_stats_migration_from_cnt_to_str(struct rtrs_clt_stats *stats, char *buf)
 {
 	struct rtrs_clt_stats_pcpu *s;
-	s = this_cpu_ptr(stats->pcpu_stats);
+	s = get_cpu_ptr(stats->pcpu_stats);
 	s->rdma.dir[d].cnt++;
 	s->rdma.dir[d].size_total += size;
+	put_cpu_ptr(stats->pcpu_stats);
 }
 void rtrs_clt_update_all_stats(struct rtrs_clt_io_req *req, int dir)

drivers/irqchip/irq-apple-aic.c+1−1

@@ -707,7 +707,7 @@ static const struct irq_domain_ops aic_ipi_domain_ops = { · 706 unmodified lines
707	.free = aic_ipi_free,	707	.free = aic_ipi_free,
708	};	708	};
709		709
710	static int aic_init_smp(struct aic_irq_chip irqc, struct device_node node)	710	static int __init aic_init_smp(struct aic_irq_chip irqc, struct device_node node)
711	{	711	{
712	struct irq_domain *ipi_domain;	712	struct irq_domain *ipi_domain;
713	int base_ipi;	713	int base_ipi;

drivers/irqchip/irq-armada-370-xp.c+6−10

 	int hwirq, i;
 	mutex_lock(&msi_used_lock);
+	hwirq = bitmap_find_free_region(msi_used, PCI_MSI_DOORBELL_NR,
+					order_base_2(nr_irqs));
+	mutex_unlock(&msi_used_lock);
-	hwirq = bitmap_find_next_zero_area(msi_used, PCI_MSI_DOORBELL_NR,
+	if (hwirq < 0)
-					   0, nr_irqs, 0);
-	if (hwirq >= PCI_MSI_DOORBELL_NR) {
-		mutex_unlock(&msi_used_lock);
 		return -ENOSPC;
-	}
-	bitmap_set(msi_used, hwirq, nr_irqs);
-	mutex_unlock(&msi_used_lock);
 	for (i = 0; i < nr_irqs; i++) {
 		irq_domain_set_info(domain, virq + i, hwirq + i,
 				    NULL, NULL);
 	}
-	return hwirq;
+	return 0;
 }
 static void armada_370_xp_msi_free(struct irq_domain *domain,
 	struct irq_data *d = irq_domain_get_irq_data(domain, virq);
 	mutex_lock(&msi_used_lock);
-	bitmap_clear(msi_used, d->hwirq, nr_irqs);
+	bitmap_release_region(msi_used, d->hwirq, order_base_2(nr_irqs));
 	mutex_unlock(&msi_used_lock);
 }

drivers/irqchip/irq-aspeed-scu-ic.c+2−2

@@ -76,8 +76,8 @@ static void aspeed_scu_ic_irq_handler(struct irq_desc *desc) · 75 unmodified lines
76	generic_handle_domain_irq(scu_ic->irq_domain,	76	generic_handle_domain_irq(scu_ic->irq_domain,
77	bit - scu_ic->irq_shift);	77	bit - scu_ic->irq_shift);
78		78
79	regmap_update_bits(scu_ic->scu, scu_ic->reg, mask,	79	regmap_write_bits(scu_ic->scu, scu_ic->reg, mask,
80	BIT(bit + ASPEED_SCU_IC_STATUS_SHIFT));	80	BIT(bit + ASPEED_SCU_IC_STATUS_SHIFT));
81	}	81	}
82		82
83	chained_irq_exit(chip, desc);	83	chained_irq_exit(chip, desc);

drivers/irqchip/irq-bcm7120-l2.c+1−0

@@ -238,6 +238,7 @@ static int __init bcm7120_l2_intc_probe(struct device_node *dn, · 237 unmodified lines
238	}	238	}
239		239
240	data->num_parent_irqs = platform_irq_count(pdev);	240	data->num_parent_irqs = platform_irq_count(pdev);
		241	put_device(&pdev->dev);
241	if (data->num_parent_irqs <= 0) {	242	if (data->num_parent_irqs <= 0) {
242	pr_err("invalid number of parent interrupts\n");	243	pr_err("invalid number of parent interrupts\n");
243	ret = -ENOMEM;	244	ret = -ENOMEM;

drivers/irqchip/irq-gic-v3-its.c+1−1

@@ -742,7 +742,7 @@ static struct its_collection its_build_invall_cmd(struct its_node its, · 741 unmodified lines
742		742
743	its_fixup_cmd(cmd);	743	its_fixup_cmd(cmd);
744		744
745	return NULL;	745	return desc->its_invall_cmd.col;
746	}	746	}
747		747
748	static struct its_vpe its_build_vinvall_cmd(struct its_node its,	748	static struct its_vpe its_build_vinvall_cmd(struct its_node its,

drivers/irqchip/irq-mips-gic.c+2−2

 #define pr_fmt(fmt) "irq-mips-gic: " fmt
+#include <linux/bitfield.h>
 #include <linux/bitmap.h>
 #include <linux/clocksource.h>
 #include <linux/cpuhotplug.h>
 	mips_gic_base = ioremap(gic_base, gic_len);
 	gicconfig = read_gic_config();
-	gic_shared_intrs = gicconfig & GIC_CONFIG_NUMINTERRUPTS;
+	gic_shared_intrs = FIELD_GET(GIC_CONFIG_NUMINTERRUPTS, gicconfig);
-	gic_shared_intrs >>= __ffs(GIC_CONFIG_NUMINTERRUPTS);
 	gic_shared_intrs = (gic_shared_intrs + 1) * 8;
 	if (cpu_has_veic) {

drivers/irqchip/irq-nvic.c+1−1

@@ -26,7 +26,7 @@ · 25 unmodified lines
26		26
27	#define NVIC_ISER 0x000	27	#define NVIC_ISER 0x000
28	#define NVIC_ICER 0x080	28	#define NVIC_ICER 0x080
29	#define NVIC_IPR 0x300	29	#define NVIC_IPR 0x400
30		30
31	#define NVIC_MAX_BANKS 16	31	#define NVIC_MAX_BANKS 16
32	/*	32	/*

drivers/md/md.c+3−1

 		if (!num_sectors || num_sectors > max_sectors)
 			num_sectors = max_sectors;
+		rdev->sb_start = sb_start;
 	}
 	sb = page_address(rdev->sb_page);
 	sb->data_size = cpu_to_le64(num_sectors);
 	spin_lock(&mddev->lock);
 	mddev->pers = NULL;
 	spin_unlock(&mddev->lock);
-	pers->free(mddev, mddev->private);
+	if (mddev->private)
+		pers->free(mddev, mddev->private);
 	mddev->private = NULL;
 	if (pers->sync_request && mddev->to_remove == NULL)
 		mddev->to_remove = &md_redundancy_group;

drivers/misc/cardreader/rtsx_pcr.c+0−4

 	mutex_lock(&pcr->pcr_mutex);
 	rtsx_pci_power_off(pcr, HOST_ENTER_S3);
-	free_irq(pcr->irq, (void *)pcr);
 	mutex_unlock(&pcr->pcr_mutex);
 	pcr->is_runtime_suspended = true;
 	mutex_lock(&pcr->pcr_mutex);
 	rtsx_pci_write_register(pcr, HOST_SLEEP_STATE, 0x03, 0x00);
-	rtsx_pci_acquire_irq(pcr);
-	synchronize_irq(pcr->irq);
 	if (pcr->ops->fetch_vendor_settings)
 		pcr->ops->fetch_vendor_settings(pcr);

drivers/misc/eeprom/at25.c+2−5

 		return -ENXIO;
 	}
-	at25 = devm_kzalloc(&spi->dev, sizeof(struct at25_data), GFP_KERNEL);
-	if (!at25)
-		return -ENOMEM;
 	mutex_init(&at25->lock);
 	at25->spi = spi;
 	spi_set_drvdata(spi, at25);
 		return PTR_ERR(at25->nvmem);
 	dev_info(&spi->dev, "%d %s %s %s%s, pagesize %u\n",
-		 (at25->chip.byte_len < 1024) ? at25->chip.byte_len : (at25->chip.byte_len / 1024),
+		 (at25->chip.byte_len < 1024) ?
+			at25->chip.byte_len : (at25->chip.byte_len / 1024),
 		 (at25->chip.byte_len < 1024) ? "Byte" : "KByte",
 		 at25->chip.name, is_fram ? "fram" : "eeprom",
 		 (at25->chip.flags & EE_READONLY) ? " (readonly)" : "",

drivers/misc/fastrpc.c+6−4

 static u64 fastrpc_get_payload_size(struct fastrpc_invoke_ctx *ctx, int metalen)
 {
 	u64 size = 0;
-	int i;
+	int oix;
 	size = ALIGN(metalen, FASTRPC_ALIGN);
-	for (i = 0; i < ctx->nscalars; i++) {
+	for (oix = 0; oix < ctx->nbufs; oix++) {
+		int i = ctx->olaps[oix].raix;
 		if (ctx->args[i].fd == 0 || ctx->args[i].fd == -1) {
-			if (ctx->olaps[i].offset == 0)
+			if (ctx->olaps[oix].offset == 0)
 				size = ALIGN(size, FASTRPC_ALIGN);
-			size += (ctx->olaps[i].mend - ctx->olaps[i].mstart);
+			size += (ctx->olaps[oix].mend - ctx->olaps[oix].mstart);
 		}
 	}

drivers/mmc/host/mtk-sd.c+3−1

 			sdr_set_field(host->base + PAD_DS_TUNE,
 				      PAD_DS_TUNE_DLY1, i);
 		ret = mmc_get_ext_csd(card, &ext_csd);
-		if (!ret)
+		if (!ret) {
 			result_dly1 |= (1 << i);
+			kfree(ext_csd);
+		}
 	}
 	host->hs400_tuning = false;

drivers/mmc/host/renesas_sdhi_core.c+1−1

@@ -673,7 +673,7 @@ static int renesas_sdhi_execute_tuning(struct mmc_host *mmc, u32 opcode) · 672 unmodified lines
673		673
674	/* Issue CMD19 twice for each tap */	674	/* Issue CMD19 twice for each tap */
675	for (i = 0; i < 2 * priv->tap_num; i++) {	675	for (i = 0; i < 2 * priv->tap_num; i++) {
676	int cmd_error;	676	int cmd_error = 0;
677		677
678	/* Set sampling clock position */	678	/* Set sampling clock position */
679	sd_scc_write32(host, priv, SH_MOBILE_SDHI_SCC_TAPSET, i % priv->tap_num);	679	sd_scc_write32(host, priv, SH_MOBILE_SDHI_SCC_TAPSET, i % priv->tap_num);

drivers/mtd/devices/mtd_dataflash.c+8−0

 	struct mtd_info		mtd;
 };
+static const struct spi_device_id dataflash_dev_ids[] = {
+	{ "at45" },
+	{ "dataflash" },
+	{ },
+};
+MODULE_DEVICE_TABLE(spi, dataflash_dev_ids);
 #ifdef CONFIG_OF
 static const struct of_device_id dataflash_dt_ids[] = {
 	{ .compatible = "atmel,at45", },
 		.name		= "mtd_dataflash",
 		.of_match_table = of_match_ptr(dataflash_dt_ids),
 	},
+	.id_table = dataflash_dev_ids,
 	.probe		= dataflash_probe,
 	.remove		= dataflash_remove,

drivers/mtd/nand/raw/Kconfig+1−1

@@ -26,7 +26,7 @@ config MTD_NAND_DENALI_PCI · 25 unmodified lines
26	config MTD_NAND_DENALI_DT	26	config MTD_NAND_DENALI_DT
27	tristate "Denali NAND controller as a DT device"	27	tristate "Denali NAND controller as a DT device"
28	select MTD_NAND_DENALI	28	select MTD_NAND_DENALI
29	depends on HAS_DMA && HAVE_CLK && OF	29	depends on HAS_DMA && HAVE_CLK && OF && HAS_IOMEM
30	help	30	help
31	Enable the driver for NAND flash on platforms using a Denali NAND	31	Enable the driver for NAND flash on platforms using a Denali NAND
32	controller as a DT device.	32	controller as a DT device.

drivers/mtd/nand/raw/fsmc_nand.c+28−8

 #include <linux/clk.h>
 #include <linux/completion.h>
+#include <linux/delay.h>
 #include <linux/dmaengine.h>
 #include <linux/dma-direction.h>
 #include <linux/dma-mapping.h>
 #define FSMC_BUSY_WAIT_TIMEOUT	(1 * HZ)
+/*
+ * According to SPEAr300 Reference Manual (RM0082)
+ *  TOUDEL = 7ns (Output delay from the flip-flops to the board)
+ *  TINDEL = 5ns (Input delay from the board to the flipflop)
+ */
+#define TOUTDEL	7000
+#define TINDEL	5000
 struct fsmc_nand_timings {
 	u8 tclr;
 	u8 tar;
 {
 	unsigned long hclk = clk_get_rate(host->clk);
 	unsigned long hclkn = NSEC_PER_SEC / hclk;
-	u32 thiz, thold, twait, tset;
+	u32 thiz, thold, twait, tset, twait_min;
 	if (sdrt->tRC_min < 30000)
 		return -EOPNOTSUPP;
 	else if (tims->thold > FSMC_THOLD_MASK)
 		tims->thold = FSMC_THOLD_MASK;
-	twait = max(sdrt->tRP_min, sdrt->tWP_min);
-	tims->twait = DIV_ROUND_UP(twait / 1000, hclkn) - 1;
-	if (tims->twait == 0)
-		tims->twait = 1;
-	else if (tims->twait > FSMC_TWAIT_MASK)
-		tims->twait = FSMC_TWAIT_MASK;
 	tset = max(sdrt->tCS_min - sdrt->tWP_min,
 		   sdrt->tCEA_max - sdrt->tREA_max);
 	tims->tset = DIV_ROUND_UP(tset / 1000, hclkn) - 1;
 	else if (tims->tset > FSMC_TSET_MASK)
 		tims->tset = FSMC_TSET_MASK;
+	/*
+	 * According to SPEAr300 Reference Manual (RM0082) which gives more
+	 * information related to FSMSC timings than the SPEAr600 one (RM0305),
+	 *   twait >= tCEA - (tset * TCLK) + TOUTDEL + TINDEL
+	 */
+	twait_min = sdrt->tCEA_max - ((tims->tset + 1) * hclkn * 1000)
+		    + TOUTDEL + TINDEL;
+	twait = max3(sdrt->tRP_min, sdrt->tWP_min, twait_min);
+	tims->twait = DIV_ROUND_UP(twait / 1000, hclkn) - 1;
+	if (tims->twait == 0)
+		tims->twait = 1;
+	else if (tims->twait > FSMC_TWAIT_MASK)
+		tims->twait = FSMC_TWAIT_MASK;
 	return 0;
 }
 						instr->ctx.waitrdy.timeout_ms);
 			break;
 		}
+		if (instr->delay_ns)
+			ndelay(instr->delay_ns);
 	}
 	return ret;

drivers/mtd/nand/raw/nand_base.c+3−3

@@ -926,7 +926,7 @@ int nand_choose_best_sdr_timings(struct nand_chip *chip, · 925 unmodified lines
926	struct nand_sdr_timings *spec_timings)	926	struct nand_sdr_timings *spec_timings)
927	{	927	{
928	const struct nand_controller_ops *ops = chip->controller->ops;	928	const struct nand_controller_ops *ops = chip->controller->ops;
929	int best_mode = 0, mode, ret;	929	int best_mode = 0, mode, ret = -EOPNOTSUPP;
930		930
931	iface->type = NAND_SDR_IFACE;	931	iface->type = NAND_SDR_IFACE;
932		932
@@ -977,7 +977,7 @@ int nand_choose_best_nvddr_timings(struct nand_chip *chip, · 44 unmodified lines
977	struct nand_nvddr_timings *spec_timings)	977	struct nand_nvddr_timings *spec_timings)
978	{	978	{
979	const struct nand_controller_ops *ops = chip->controller->ops;	979	const struct nand_controller_ops *ops = chip->controller->ops;
980	int best_mode = 0, mode, ret;	980	int best_mode = 0, mode, ret = -EOPNOTSUPP;
981		981
982	iface->type = NAND_NVDDR_IFACE;	982	iface->type = NAND_NVDDR_IFACE;
983		983
@@ -1837,7 +1837,7 @@ int nand_erase_op(struct nand_chip *chip, unsigned int eraseblock) · 853 unmodified lines
1837	NAND_OP_CMD(NAND_CMD_ERASE1, 0),	1837	NAND_OP_CMD(NAND_CMD_ERASE1, 0),
1838	NAND_OP_ADDR(2, addrs, 0),	1838	NAND_OP_ADDR(2, addrs, 0),
1839	NAND_OP_CMD(NAND_CMD_ERASE2,	1839	NAND_OP_CMD(NAND_CMD_ERASE2,
1840	NAND_COMMON_TIMING_MS(conf, tWB_max)),	1840	NAND_COMMON_TIMING_NS(conf, tWB_max)),
1841	NAND_OP_WAIT_RDY(NAND_COMMON_TIMING_MS(conf, tBERS_max),	1841	NAND_OP_WAIT_RDY(NAND_COMMON_TIMING_MS(conf, tBERS_max),
1842	0),	1842	0),
1843	};	1843	};

drivers/net/bonding/bond_alb.c+8−6

 	struct slave *slave;
 	if (!bond_has_slaves(bond)) {
-		bond_info->tx_rebalance_counter = 0;
+		atomic_set(&bond_info->tx_rebalance_counter, 0);
 		bond_info->lp_counter = 0;
 		goto re_arm;
 	}
 	rcu_read_lock();
-	bond_info->tx_rebalance_counter++;
+	atomic_inc(&bond_info->tx_rebalance_counter);
 	bond_info->lp_counter++;
 	/* send learning packets */
 	}
 	/* rebalance tx traffic */
-	if (bond_info->tx_rebalance_counter >= BOND_TLB_REBALANCE_TICKS) {
+	if (atomic_read(&bond_info->tx_rebalance_counter) >= BOND_TLB_REBALANCE_TICKS) {
 		bond_for_each_slave_rcu(bond, slave, iter) {
 			tlb_clear_slave(bond, slave, 1);
 			if (slave == rcu_access_pointer(bond->curr_active_slave)) {
 				bond_info->unbalanced_load = 0;
 			}
 		}
-		bond_info->tx_rebalance_counter = 0;
+		atomic_set(&bond_info->tx_rebalance_counter, 0);
 	}
 	if (bond_info->rlb_enabled) {
 	tlb_init_slave(slave);
 	/* order a rebalance ASAP */
-	bond->alb_info.tx_rebalance_counter = BOND_TLB_REBALANCE_TICKS;
+	atomic_set(&bond->alb_info.tx_rebalance_counter,
+		   BOND_TLB_REBALANCE_TICKS);
 	if (bond->alb_info.rlb_enabled)
 		bond->alb_info.rlb_rebalance = 1;
 			rlb_clear_slave(bond, slave);
 	} else if (link == BOND_LINK_UP) {
 		/* order a rebalance ASAP */
-		bond_info->tx_rebalance_counter = BOND_TLB_REBALANCE_TICKS;
+		atomic_set(&bond_info->tx_rebalance_counter,
+			   BOND_TLB_REBALANCE_TICKS);
 		if (bond->alb_info.rlb_enabled) {
 			bond->alb_info.rlb_rebalance = 1;
 			/* If the updelay module parameter is smaller than the

drivers/net/can/kvaser_pciefd.c+7−1

 #define KVASER_PCIEFD_SPACK_EWLR BIT(23)
 #define KVASER_PCIEFD_SPACK_EPLR BIT(24)
+/* Kvaser KCAN_EPACK second word */
+#define KVASER_PCIEFD_EPACK_DIR_TX BIT(0)
 struct kvaser_pciefd;
 struct kvaser_pciefd_can {
 	can->err_rep_cnt++;
 	can->can.can_stats.bus_error++;
-	stats->rx_errors++;
+	if (p->header[1] & KVASER_PCIEFD_EPACK_DIR_TX)
+		stats->tx_errors++;
+	else
+		stats->rx_errors++;
 	can->bec.txerr = bec.txerr;
 	can->bec.rxerr = bec.rxerr;

drivers/net/can/m_can/m_can.c+27−15

 /* Interrupts for version 3.0.x */
 #define IR_ERR_LEC_30X	(IR_STE	| IR_FOE | IR_ACKE | IR_BE | IR_CRCE)
-#define IR_ERR_BUS_30X	(IR_ERR_LEC_30X | IR_WDI | IR_ELO | IR_BEU | \
+#define IR_ERR_BUS_30X	(IR_ERR_LEC_30X | IR_WDI | IR_BEU | IR_BEC | \
-			 IR_BEC | IR_TOO | IR_MRAF | IR_TSW | IR_TEFL | \
+			 IR_TOO | IR_MRAF | IR_TSW | IR_TEFL | IR_RF1L | \
-			 IR_RF1L | IR_RF0L)
+			 IR_RF0L)
 #define IR_ERR_ALL_30X	(IR_ERR_STATE | IR_ERR_BUS_30X)
 /* Interrupts for version >= 3.1.x */
 #define IR_ERR_LEC_31X	(IR_PED | IR_PEA)
-#define IR_ERR_BUS_31X      (IR_ERR_LEC_31X | IR_WDI | IR_ELO | IR_BEU | \
+#define IR_ERR_BUS_31X      (IR_ERR_LEC_31X | IR_WDI | IR_BEU | IR_BEC | \
-			 IR_BEC | IR_TOO | IR_MRAF | IR_TSW | IR_TEFL | \
+			 IR_TOO | IR_MRAF | IR_TSW | IR_TEFL | IR_RF1L | \
-			 IR_RF1L | IR_RF0L)
+			 IR_RF0L)
 #define IR_ERR_ALL_31X	(IR_ERR_STATE | IR_ERR_BUS_31X)
 /* Interrupt Line Select (ILS) */
 		err = m_can_fifo_read(cdev, fgi, M_CAN_FIFO_DATA,
 				      cf->data, DIV_ROUND_UP(cf->len, 4));
 		if (err)
-			goto out_fail;
+			goto out_free_skb;
 	}
 	/* acknowledge rx fifo 0 */
 	return 0;
+out_free_skb:
+	kfree_skb(skb);
 out_fail:
 	netdev_err(dev, "FIFO read returned %d\n", err);
 	return err;
 {
 	if (irqstatus & IR_WDI)
 		netdev_err(dev, "Message RAM Watchdog event due to missing READY\n");
-	if (irqstatus & IR_ELO)
-		netdev_err(dev, "Error Logging Overflow\n");
 	if (irqstatus & IR_BEU)
 		netdev_err(dev, "Bit Error Uncorrected\n");
 	if (irqstatus & IR_BEC)
 	case 30:
 		/* CAN_CTRLMODE_FD_NON_ISO is fixed with M_CAN IP v3.0.x */
 		can_set_static_ctrlmode(dev, CAN_CTRLMODE_FD_NON_ISO);
-		cdev->can.bittiming_const = &m_can_bittiming_const_30X;
+		cdev->can.bittiming_const = cdev->bit_timing ?
-		cdev->can.data_bittiming_const = &m_can_data_bittiming_const_30X;
+			cdev->bit_timing : &m_can_bittiming_const_30X;
+		cdev->can.data_bittiming_const = cdev->data_timing ?
+			cdev->data_timing :
+			&m_can_data_bittiming_const_30X;
 		break;
 	case 31:
 		/* CAN_CTRLMODE_FD_NON_ISO is fixed with M_CAN IP v3.1.x */
 		can_set_static_ctrlmode(dev, CAN_CTRLMODE_FD_NON_ISO);
-		cdev->can.bittiming_const = &m_can_bittiming_const_31X;
+		cdev->can.bittiming_const = cdev->bit_timing ?
-		cdev->can.data_bittiming_const = &m_can_data_bittiming_const_31X;
+			cdev->bit_timing : &m_can_bittiming_const_31X;
+		cdev->can.data_bittiming_const = cdev->data_timing ?
+			cdev->data_timing :
+			&m_can_data_bittiming_const_31X;
 		break;
 	case 32:
 	case 33:
 		/* Support both MCAN version v3.2.x and v3.3.0 */
-		cdev->can.bittiming_const = &m_can_bittiming_const_31X;
+		cdev->can.bittiming_const = cdev->bit_timing ?
-		cdev->can.data_bittiming_const = &m_can_data_bittiming_const_31X;
+			cdev->bit_timing : &m_can_bittiming_const_31X;
+		cdev->can.data_bittiming_const = cdev->data_timing ?
+			cdev->data_timing :
+			&m_can_data_bittiming_const_31X;
 		cdev->can.ctrlmode_supported |=
 			(m_can_niso_supported(cdev) ?

drivers/net/can/m_can/m_can.h+3−0

@@ -85,6 +85,9 @@ struct m_can_classdev { · 84 unmodified lines
85	struct sk_buff *tx_skb;	85	struct sk_buff *tx_skb;
86	struct phy *transceiver;	86	struct phy *transceiver;
87		87
		88	const struct can_bittiming_const *bit_timing;
		89	const struct can_bittiming_const *data_timing;
		90
88	struct m_can_ops *ops;	91	struct m_can_ops *ops;
89		92
90	int version;	93	int version;

drivers/net/can/m_can/m_can_pci.c+56−6

 #define M_CAN_PCI_MMIO_BAR		0
-#define M_CAN_CLOCK_FREQ_EHL		100000000
 #define CTL_CSR_INT_CTL_OFFSET		0x508
+struct m_can_pci_config {
+	const struct can_bittiming_const *bit_timing;
+	const struct can_bittiming_const *data_timing;
+	unsigned int clock_freq;
+};
 struct m_can_pci_priv {
 	struct m_can_classdev cdev;
 static int iomap_read_fifo(struct m_can_classdev *cdev, int offset, void *val, size_t val_count)
 {
 	struct m_can_pci_priv *priv = cdev_to_priv(cdev);
+	void __iomem *src = priv->base + offset;
-	ioread32_rep(priv->base + offset, val, val_count);
+	while (val_count--) {
+		*(unsigned int *)val = ioread32(src);
+		val += 4;
+		src += 4;
+	}
 	return 0;
 }
 			    const void *val, size_t val_count)
 {
 	struct m_can_pci_priv *priv = cdev_to_priv(cdev);
+	void __iomem *dst = priv->base + offset;
-	iowrite32_rep(priv->base + offset, val, val_count);
+	while (val_count--) {
+		iowrite32(*(unsigned int *)val, dst);
+		val += 4;
+		dst += 4;
+	}
 	return 0;
 }
 	.read_fifo = iomap_read_fifo,
 };
+static const struct can_bittiming_const m_can_bittiming_const_ehl = {
+	.name = KBUILD_MODNAME,
+	.tseg1_min = 2,		/* Time segment 1 = prop_seg + phase_seg1 */
+	.tseg1_max = 64,
+	.tseg2_min = 1,		/* Time segment 2 = phase_seg2 */
+	.tseg2_max = 128,
+	.sjw_max = 128,
+	.brp_min = 1,
+	.brp_max = 512,
+	.brp_inc = 1,
+};
+static const struct can_bittiming_const m_can_data_bittiming_const_ehl = {
+	.name = KBUILD_MODNAME,
+	.tseg1_min = 2,		/* Time segment 1 = prop_seg + phase_seg1 */
+	.tseg1_max = 16,
+	.tseg2_min = 1,		/* Time segment 2 = phase_seg2 */
+	.tseg2_max = 8,
+	.sjw_max = 4,
+	.brp_min = 1,
+	.brp_max = 32,
+	.brp_inc = 1,
+};
+static const struct m_can_pci_config m_can_pci_ehl = {
+	.bit_timing = &m_can_bittiming_const_ehl,
+	.data_timing = &m_can_data_bittiming_const_ehl,
+	.clock_freq = 200000000,
+};
 static int m_can_pci_probe(struct pci_dev *pci, const struct pci_device_id *id)
 {
 	struct device *dev = &pci->dev;
+	const struct m_can_pci_config *cfg;
 	struct m_can_classdev *mcan_class;
 	struct m_can_pci_priv *priv;
 	void __iomem *base;
 	if (!mcan_class)
 		return -ENOMEM;
+	cfg = (const struct m_can_pci_config *)id->driver_data;
 	priv = cdev_to_priv(mcan_class);
 	priv->base = base;
 	mcan_class->dev = &pci->dev;
 	mcan_class->net->irq = pci_irq_vector(pci, 0);
 	mcan_class->pm_clock_support = 1;
-	mcan_class->can.clock.freq = id->driver_data;
+	mcan_class->bit_timing = cfg->bit_timing;
+	mcan_class->data_timing = cfg->data_timing;
+	mcan_class->can.clock.freq = cfg->clock_freq;
 	mcan_class->ops = &m_can_pci_ops;
 	pci_set_drvdata(pci, mcan_class);
 			 m_can_pci_suspend, m_can_pci_resume);
 static const struct pci_device_id m_can_pci_id_table[] = {
-	{ PCI_VDEVICE(INTEL, 0x4bc1), M_CAN_CLOCK_FREQ_EHL, },
+	{ PCI_VDEVICE(INTEL, 0x4bc1), (kernel_ulong_t)&m_can_pci_ehl, },
-	{ PCI_VDEVICE(INTEL, 0x4bc2), M_CAN_CLOCK_FREQ_EHL, },
+	{ PCI_VDEVICE(INTEL, 0x4bc2), (kernel_ulong_t)&m_can_pci_ehl, },
 	{  }	/* Terminating Entry */
 };
 MODULE_DEVICE_TABLE(pci, m_can_pci_id_table);

drivers/net/can/pch_can.c+1−1

 			cf->data[i + 1] = data_reg >> 8;
 		}
-		netif_receive_skb(skb);
 		rcv_pkts++;
 		stats->rx_packets++;
 		quota--;
 		stats->rx_bytes += cf->len;
+		netif_receive_skb(skb);
 		pch_fifo_thresh(priv, obj_num);
 		obj_num++;

drivers/net/can/sja1000/ems_pcmcia.c+6−1

 			free_sja1000dev(dev);
 	}
-	err = request_irq(dev->irq, &ems_pcmcia_interrupt, IRQF_SHARED,
+	if (!card->channels) {
+		err = -ENODEV;
+		goto failure_cleanup;
+	}
+	err = request_irq(pdev->irq, &ems_pcmcia_interrupt, IRQF_SHARED,
 			  DRV_NAME, card);
 	if (!err)
 		return 0;

drivers/net/can/usb/kvaser_usb/kvaser_usb_leaf.c+73−28

 #include "kvaser_usb.h"
-/* Forward declaration */
-static const struct kvaser_usb_dev_cfg kvaser_usb_leaf_dev_cfg;
-#define CAN_USB_CLOCK			8000000
 #define MAX_USBCAN_NET_DEVICES		2
 /* Command header size */
 #define CMD_LEAF_LOG_MESSAGE		106
+/* Leaf frequency options */
+#define KVASER_USB_LEAF_SWOPTION_FREQ_MASK 0x60
+#define KVASER_USB_LEAF_SWOPTION_FREQ_16_MHZ_CLK 0
+#define KVASER_USB_LEAF_SWOPTION_FREQ_32_MHZ_CLK BIT(5)
+#define KVASER_USB_LEAF_SWOPTION_FREQ_24_MHZ_CLK BIT(6)
 /* error factors */
 #define M16C_EF_ACKE			BIT(0)
 #define M16C_EF_CRCE			BIT(1)
 	};
 };
+static const struct can_bittiming_const kvaser_usb_leaf_bittiming_const = {
+	.name = "kvaser_usb",
+	.tseg1_min = KVASER_USB_TSEG1_MIN,
+	.tseg1_max = KVASER_USB_TSEG1_MAX,
+	.tseg2_min = KVASER_USB_TSEG2_MIN,
+	.tseg2_max = KVASER_USB_TSEG2_MAX,
+	.sjw_max = KVASER_USB_SJW_MAX,
+	.brp_min = KVASER_USB_BRP_MIN,
+	.brp_max = KVASER_USB_BRP_MAX,
+	.brp_inc = KVASER_USB_BRP_INC,
+};
+static const struct kvaser_usb_dev_cfg kvaser_usb_leaf_dev_cfg_8mhz = {
+	.clock = {
+		.freq = 8000000,
+	},
+	.timestamp_freq = 1,
+	.bittiming_const = &kvaser_usb_leaf_bittiming_const,
+};
+static const struct kvaser_usb_dev_cfg kvaser_usb_leaf_dev_cfg_16mhz = {
+	.clock = {
+		.freq = 16000000,
+	},
+	.timestamp_freq = 1,
+	.bittiming_const = &kvaser_usb_leaf_bittiming_const,
+};
+static const struct kvaser_usb_dev_cfg kvaser_usb_leaf_dev_cfg_24mhz = {
+	.clock = {
+		.freq = 24000000,
+	},
+	.timestamp_freq = 1,
+	.bittiming_const = &kvaser_usb_leaf_bittiming_const,
+};
+static const struct kvaser_usb_dev_cfg kvaser_usb_leaf_dev_cfg_32mhz = {
+	.clock = {
+		.freq = 32000000,
+	},
+	.timestamp_freq = 1,
+	.bittiming_const = &kvaser_usb_leaf_bittiming_const,
+};
 static void *
 kvaser_usb_leaf_frame_to_cmd(const struct kvaser_usb_net_priv *priv,
 			     const struct sk_buff *skb, int *frame_len,
 	return rc;
 }
+static void kvaser_usb_leaf_get_software_info_leaf(struct kvaser_usb *dev,
+						   const struct leaf_cmd_softinfo *softinfo)
+{
+	u32 sw_options = le32_to_cpu(softinfo->sw_options);
+	dev->fw_version = le32_to_cpu(softinfo->fw_version);
+	dev->max_tx_urbs = le16_to_cpu(softinfo->max_outstanding_tx);
+	switch (sw_options & KVASER_USB_LEAF_SWOPTION_FREQ_MASK) {
+	case KVASER_USB_LEAF_SWOPTION_FREQ_16_MHZ_CLK:
+		dev->cfg = &kvaser_usb_leaf_dev_cfg_16mhz;
+		break;
+	case KVASER_USB_LEAF_SWOPTION_FREQ_24_MHZ_CLK:
+		dev->cfg = &kvaser_usb_leaf_dev_cfg_24mhz;
+		break;
+	case KVASER_USB_LEAF_SWOPTION_FREQ_32_MHZ_CLK:
+		dev->cfg = &kvaser_usb_leaf_dev_cfg_32mhz;
+		break;
+	}
+}
 static int kvaser_usb_leaf_get_software_info_inner(struct kvaser_usb *dev)
 {
 	struct kvaser_cmd cmd;
 	switch (dev->card_data.leaf.family) {
 	case KVASER_LEAF:
-		dev->fw_version = le32_to_cpu(cmd.u.leaf.softinfo.fw_version);
+		kvaser_usb_leaf_get_software_info_leaf(dev, &cmd.u.leaf.softinfo);
-		dev->max_tx_urbs =
-			le16_to_cpu(cmd.u.leaf.softinfo.max_outstanding_tx);
 		break;
 	case KVASER_USBCAN:
 		dev->fw_version = le32_to_cpu(cmd.u.usbcan.softinfo.fw_version);
 		dev->max_tx_urbs =
 			le16_to_cpu(cmd.u.usbcan.softinfo.max_outstanding_tx);
+		dev->cfg = &kvaser_usb_leaf_dev_cfg_8mhz;
 		break;
 	}
 {
 	struct kvaser_usb_dev_card_data *card_data = &dev->card_data;
-	dev->cfg = &kvaser_usb_leaf_dev_cfg;
 	card_data->ctrlmode_supported |= CAN_CTRLMODE_3_SAMPLES;
 	return 0;
 }
-static const struct can_bittiming_const kvaser_usb_leaf_bittiming_const = {
-	.name = "kvaser_usb",
-	.tseg1_min = KVASER_USB_TSEG1_MIN,
-	.tseg1_max = KVASER_USB_TSEG1_MAX,
-	.tseg2_min = KVASER_USB_TSEG2_MIN,
-	.tseg2_max = KVASER_USB_TSEG2_MAX,
-	.sjw_max = KVASER_USB_SJW_MAX,
-	.brp_min = KVASER_USB_BRP_MIN,
-	.brp_max = KVASER_USB_BRP_MAX,
-	.brp_inc = KVASER_USB_BRP_INC,
-};
 static int kvaser_usb_leaf_set_bittiming(struct net_device *netdev)
 {
 	struct kvaser_usb_net_priv *priv = netdev_priv(netdev);
 	.dev_read_bulk_callback = kvaser_usb_leaf_read_bulk_callback,
 	.dev_frame_to_cmd = kvaser_usb_leaf_frame_to_cmd,
 };
-static const struct kvaser_usb_dev_cfg kvaser_usb_leaf_dev_cfg = {
-	.clock = {
-		.freq = CAN_USB_CLOCK,
-	},
-	.timestamp_freq = 1,
-	.bittiming_const = &kvaser_usb_leaf_bittiming_const,
-};

drivers/net/dsa/b53/b53_spi.c+14−0

@@ -349,6 +349,19 @@ static const struct of_device_id b53_spi_of_match[] = { · 348 unmodified lines
349	};	349	};
350	MODULE_DEVICE_TABLE(of, b53_spi_of_match);	350	MODULE_DEVICE_TABLE(of, b53_spi_of_match);
351		351
		352	static const struct spi_device_id b53_spi_ids[] = {
		353	{ .name = "bcm5325" },
		354	{ .name = "bcm5365" },
		355	{ .name = "bcm5395" },
		356	{ .name = "bcm5397" },
		357	{ .name = "bcm5398" },
		358	{ .name = "bcm53115" },
		359	{ .name = "bcm53125" },
		360	{ .name = "bcm53128" },
		361	{ /* sentinel */ }
		362	};
		363	MODULE_DEVICE_TABLE(spi, b53_spi_ids);
		364
352	static struct spi_driver b53_spi_driver = {	365	static struct spi_driver b53_spi_driver = {
353	.driver = {	366	.driver = {
354	.name = "b53-switch",	367	.name = "b53-switch",
@@ -357,6 +370,7 @@ static struct spi_driver b53_spi_driver = { · 2 unmodified lines
357	.probe = b53_spi_probe,	370	.probe = b53_spi_probe,
358	.remove = b53_spi_remove,	371	.remove = b53_spi_remove,
359	.shutdown = b53_spi_shutdown,	372	.shutdown = b53_spi_shutdown,
		373	.id_table = b53_spi_ids,
360	};	374	};
361		375
362	module_spi_driver(b53_spi_driver);	376	module_spi_driver(b53_spi_driver);

drivers/net/dsa/mv88e6xxx/chip.c+47−38

 	u16 reg;
 	int err;
+	/* The 88e6250 family does not have the PHY detect bit. Instead,
+	 * report whether the port is internal.
+	 */
+	if (chip->info->family == MV88E6XXX_FAMILY_6250)
+		return port < chip->info->num_internal_phys;
 	err = mv88e6xxx_port_read(chip, port, MV88E6XXX_PORT_STS, &reg);
 	if (err) {
 		dev_err(chip->dev,
 {
 	struct mv88e6xxx_chip *chip = ds->priv;
 	struct mv88e6xxx_port *p;
-	int err;
+	int err = 0;
 	p = &chip->ports[port];
-	/* FIXME: is this the correct test? If we're in fixed mode on an
-	 * internal port, why should we process this any different from
-	 * PHY mode? On the other hand, the port may be automedia between
-	 * an internal PHY and the serdes...
-	 */
-	if ((mode == MLO_AN_PHY) && mv88e6xxx_phy_is_internal(ds, port))
-		return;
 	mv88e6xxx_reg_lock(chip);
-	/* In inband mode, the link may come up at any time while the link
-	 * is not forced down. Force the link down while we reconfigure the
-	 * interface mode.
-	 */
-	if (mode == MLO_AN_INBAND && p->interface != state->interface &&
-	    chip->info->ops->port_set_link)
-		chip->info->ops->port_set_link(chip, port, LINK_FORCED_DOWN);
-	err = mv88e6xxx_port_config_interface(chip, port, state->interface);
-	if (err && err != -EOPNOTSUPP)
-		goto err_unlock;
-	err = mv88e6xxx_serdes_pcs_config(chip, port, mode, state->interface,
+	if (mode != MLO_AN_PHY || !mv88e6xxx_phy_is_internal(ds, port)) {
-					  state->advertising);
+		/* In inband mode, the link may come up at any time while the
-	/* FIXME: we should restart negotiation if something changed - which
+		 * link is not forced down. Force the link down while we
-	 * is something we get if we convert to using phylinks PCS operations.
+		 * reconfigure the interface mode.
-	 */
+		 */
-	if (err > 0)
+		if (mode == MLO_AN_INBAND &&
-		err = 0;
+		    p->interface != state->interface &&
+		    chip->info->ops->port_set_link)
+			chip->info->ops->port_set_link(chip, port,
+						       LINK_FORCED_DOWN);
+		err = mv88e6xxx_port_config_interface(chip, port,
+						      state->interface);
+		if (err && err != -EOPNOTSUPP)
+			goto err_unlock;
+		err = mv88e6xxx_serdes_pcs_config(chip, port, mode,
+						  state->interface,
+						  state->advertising);
+		/* FIXME: we should restart negotiation if something changed -
+		 * which is something we get if we convert to using phylinks
+		 * PCS operations.
+		 */
+		if (err > 0)
+			err = 0;
+	}
 	/* Undo the forced down state above after completing configuration
-	 * irrespective of its state on entry, which allows the link to come up.
+	 * irrespective of its state on entry, which allows the link to come
+	 * up in the in-band case where there is no separate SERDES. Also
+	 * ensure that the link can come up if the PPU is in use and we are
+	 * in PHY mode (we treat the PPU as an effective in-band mechanism.)
 	 */
-	if (mode == MLO_AN_INBAND && p->interface != state->interface &&
+	if (chip->info->ops->port_set_link &&
-	    chip->info->ops->port_set_link)
+	    ((mode == MLO_AN_INBAND && p->interface != state->interface) ||
+	     (mode == MLO_AN_PHY && mv88e6xxx_port_ppu_updates(chip, port))))
 		chip->info->ops->port_set_link(chip, port, LINK_UNFORCED);
 	p->interface = state->interface;
 	ops = chip->info->ops;
 	mv88e6xxx_reg_lock(chip);
-	/* Internal PHYs propagate their configuration directly to the MAC.
+	/* Force the link down if we know the port may not be automatically
-	 * External PHYs depend on whether the PPU is enabled for this port.
+	 * updated by the switch or if we are using fixed-link mode.
 	 */
-	if (((!mv88e6xxx_phy_is_internal(ds, port) &&
+	if ((!mv88e6xxx_port_ppu_updates(chip, port) ||
-	      !mv88e6xxx_port_ppu_updates(chip, port)) ||
 	     mode == MLO_AN_FIXED) && ops->port_sync_link)
 		err = ops->port_sync_link(chip, port, mode, false);
 	mv88e6xxx_reg_unlock(chip);
 	ops = chip->info->ops;
 	mv88e6xxx_reg_lock(chip);
-	/* Internal PHYs propagate their configuration directly to the MAC.
+	/* Configure and force the link up if we know that the port may not
-	 * External PHYs depend on whether the PPU is enabled for this port.
+	 * automatically updated by the switch or if we are using fixed-link
+	 * mode.
 	 */
-	if ((!mv88e6xxx_phy_is_internal(ds, port) &&
+	if (!mv88e6xxx_port_ppu_updates(chip, port) ||
-	     !mv88e6xxx_port_ppu_updates(chip, port)) ||
 	    mode == MLO_AN_FIXED) {
 		/* FIXME: for an automedia port, should we force the link
 		 * down here - what if the link comes up due to "other" media

drivers/net/dsa/mv88e6xxx/serdes.c+227−33

@@ -50,11 +50,22 @@ static int mv88e6390_serdes_write(struct mv88e6xxx_chip *chip, · 49 unmodified lines
50	}	50	}
51		51
52	static int mv88e6xxx_serdes_pcs_get_state(struct mv88e6xxx_chip *chip,	52	static int mv88e6xxx_serdes_pcs_get_state(struct mv88e6xxx_chip *chip,
53	u16 status, u16 lpa,	53	u16 ctrl, u16 status, u16 lpa,
54	struct phylink_link_state *state)	54	struct phylink_link_state *state)
55	{	55	{
		56	state->link = !!(status & MV88E6390_SGMII_PHY_STATUS_LINK);
		57
56	if (status & MV88E6390_SGMII_PHY_STATUS_SPD_DPL_VALID) {	58	if (status & MV88E6390_SGMII_PHY_STATUS_SPD_DPL_VALID) {
57	state->link = !!(status & MV88E6390_SGMII_PHY_STATUS_LINK);	59	/* The Spped and Duplex Resolved register is 1 if AN is enabled
		60	* and complete, or if AN is disabled. So with disabled AN we
		61	* still get here on link up. But we want to set an_complete
		62	* only if AN was enabled, thus we look at BMCR_ANENABLE.
		63	* (According to 802.3-2008 section 22.2.4.2.10, we should be
		64	* able to get this same value from BMSR_ANEGCAPABLE, but tests
		65	* show that these Marvell PHYs don't conform to this part of
		66	* the specificaion - BMSR_ANEGCAPABLE is simply always 1.)
		67	*/
		68	state->an_complete = !!(ctrl & BMCR_ANENABLE);
58	state->duplex = status &	69	state->duplex = status &
59	MV88E6390_SGMII_PHY_STATUS_DUPLEX_FULL ?	70	MV88E6390_SGMII_PHY_STATUS_DUPLEX_FULL ?
60	DUPLEX_FULL : DUPLEX_HALF;	71	DUPLEX_FULL : DUPLEX_HALF;
@@ -81,6 +92,18 @@ static int mv88e6xxx_serdes_pcs_get_state(struct mv88e6xxx_chip *chip, · 20 unmodified lines
81	dev_err(chip->dev, "invalid PHY speed\n");	92	dev_err(chip->dev, "invalid PHY speed\n");
82	return -EINVAL;	93	return -EINVAL;
83	}	94	}
		95	} else if (state->link &&
		96	state->interface != PHY_INTERFACE_MODE_SGMII) {
		97	/* If Speed and Duplex Resolved register is 0 and link is up, it
		98	* means that AN was enabled, but link partner had it disabled
		99	* and the PHY invoked the Auto-Negotiation Bypass feature and
		100	* linked anyway.
		101	*/
		102	state->duplex = DUPLEX_FULL;
		103	if (state->interface == PHY_INTERFACE_MODE_2500BASEX)
		104	state->speed = SPEED_2500;
		105	else
		106	state->speed = SPEED_1000;
84	} else {	107	} else {
85	state->link = false;	108	state->link = false;
86	}	109	}
@@ -168,9 +191,15 @@ int mv88e6352_serdes_pcs_config(struct mv88e6xxx_chip *chip, int port, · 81 unmodified lines
168	int mv88e6352_serdes_pcs_get_state(struct mv88e6xxx_chip *chip, int port,	191	int mv88e6352_serdes_pcs_get_state(struct mv88e6xxx_chip *chip, int port,
169	int lane, struct phylink_link_state *state)	192	int lane, struct phylink_link_state *state)
170	{	193	{
171	u16 lpa, status;	194	u16 lpa, status, ctrl;
172	int err;	195	int err;
173		196
		197	err = mv88e6352_serdes_read(chip, MII_BMCR, &ctrl);
		198	if (err) {
		199	dev_err(chip->dev, "can't read Serdes PHY control: %d\n", err);
		200	return err;
		201	}
		202
174	err = mv88e6352_serdes_read(chip, 0x11, &status);	203	err = mv88e6352_serdes_read(chip, 0x11, &status);
175	if (err) {	204	if (err) {
176	dev_err(chip->dev, "can't read Serdes PHY status: %d\n", err);	205	dev_err(chip->dev, "can't read Serdes PHY status: %d\n", err);
@@ -183,7 +212,7 @@ int mv88e6352_serdes_pcs_get_state(struct mv88e6xxx_chip *chip, int port, · 6 unmodified lines
183	return err;	212	return err;
184	}	213	}
185		214
186	return mv88e6xxx_serdes_pcs_get_state(chip, status, lpa, state);	215	return mv88e6xxx_serdes_pcs_get_state(chip, ctrl, status, lpa, state);
187	}	216	}
188		217
189	int mv88e6352_serdes_pcs_an_restart(struct mv88e6xxx_chip *chip, int port,	218	int mv88e6352_serdes_pcs_an_restart(struct mv88e6xxx_chip *chip, int port,
@@ -801,7 +830,7 @@ int mv88e6390_serdes_power(struct mv88e6xxx_chip *chip, int port, int lane, · 611 unmodified lines
801	bool up)	830	bool up)
802	{	831	{
803	u8 cmode = chip->ports[port].cmode;	832	u8 cmode = chip->ports[port].cmode;
804	int err = 0;	833	int err;
805		834
806	switch (cmode) {	835	switch (cmode) {
807	case MV88E6XXX_PORT_STS_CMODE_SGMII:	836	case MV88E6XXX_PORT_STS_CMODE_SGMII:
@@ -813,6 +842,9 @@ int mv88e6390_serdes_power(struct mv88e6xxx_chip *chip, int port, int lane, · 5 unmodified lines
813	case MV88E6XXX_PORT_STS_CMODE_RXAUI:	842	case MV88E6XXX_PORT_STS_CMODE_RXAUI:
814	err = mv88e6390_serdes_power_10g(chip, lane, up);	843	err = mv88e6390_serdes_power_10g(chip, lane, up);
815	break;	844	break;
		845	default:
		846	err = -EINVAL;
		847	break;
816	}	848	}
817		849
818	if (!err && up)	850	if (!err && up)
@@ -883,9 +915,16 @@ int mv88e6390_serdes_pcs_config(struct mv88e6xxx_chip *chip, int port, · 64 unmodified lines
883	static int mv88e6390_serdes_pcs_get_state_sgmii(struct mv88e6xxx_chip *chip,	915	static int mv88e6390_serdes_pcs_get_state_sgmii(struct mv88e6xxx_chip *chip,
884	int port, int lane, struct phylink_link_state *state)	916	int port, int lane, struct phylink_link_state *state)
885	{	917	{
886	u16 lpa, status;	918	u16 lpa, status, ctrl;
887	int err;	919	int err;
888		920
		921	err = mv88e6390_serdes_read(chip, lane, MDIO_MMD_PHYXS,
		922	MV88E6390_SGMII_BMCR, &ctrl);
		923	if (err) {
		924	dev_err(chip->dev, "can't read Serdes PHY control: %d\n", err);
		925	return err;
		926	}
		927
889	err = mv88e6390_serdes_read(chip, lane, MDIO_MMD_PHYXS,	928	err = mv88e6390_serdes_read(chip, lane, MDIO_MMD_PHYXS,
890	MV88E6390_SGMII_PHY_STATUS, &status);	929	MV88E6390_SGMII_PHY_STATUS, &status);
891	if (err) {	930	if (err) {
@@ -900,7 +939,7 @@ static int mv88e6390_serdes_pcs_get_state_sgmii(struct mv88e6xxx_chip *chip, · 8 unmodified lines
900	return err;	939	return err;
901	}	940	}
902		941
903	return mv88e6xxx_serdes_pcs_get_state(chip, status, lpa, state);	942	return mv88e6xxx_serdes_pcs_get_state(chip, ctrl, status, lpa, state);
904	}	943	}
905		944
906	static int mv88e6390_serdes_pcs_get_state_10g(struct mv88e6xxx_chip *chip,	945	static int mv88e6390_serdes_pcs_get_state_10g(struct mv88e6xxx_chip *chip,
@@ -1271,9 +1310,31 @@ void mv88e6390_serdes_get_regs(struct mv88e6xxx_chip chip, int port, void _p) · 364 unmodified lines
1271	}	1310	}
1272	}	1311	}
1273		1312
1274	static int mv88e6393x_serdes_port_errata(struct mv88e6xxx_chip *chip, int lane)	1313	static int mv88e6393x_serdes_power_lane(struct mv88e6xxx_chip *chip, int lane,
		1314	bool on)
1275	{	1315	{
1276	u16 reg, pcs;	1316	u16 reg;
		1317	int err;
		1318
		1319	err = mv88e6390_serdes_read(chip, lane, MDIO_MMD_PHYXS,
		1320	MV88E6393X_SERDES_CTRL1, &reg);
		1321	if (err)
		1322	return err;
		1323
		1324	if (on)
		1325	reg &= ~(MV88E6393X_SERDES_CTRL1_TX_PDOWN \|
		1326	MV88E6393X_SERDES_CTRL1_RX_PDOWN);
		1327	else
		1328	reg \|= MV88E6393X_SERDES_CTRL1_TX_PDOWN \|
		1329	MV88E6393X_SERDES_CTRL1_RX_PDOWN;
		1330
		1331	return mv88e6390_serdes_write(chip, lane, MDIO_MMD_PHYXS,
		1332	MV88E6393X_SERDES_CTRL1, reg);
		1333	}
		1334
		1335	static int mv88e6393x_serdes_erratum_4_6(struct mv88e6xxx_chip *chip, int lane)
		1336	{
		1337	u16 reg;
1277	int err;	1338	int err;
1278		1339
1279	/* mv88e6393x family errata 4.6:	1340	/* mv88e6393x family errata 4.6:
@@ -1284,26 +1345,45 @@ static int mv88e6393x_serdes_port_errata(struct mv88e6xxx_chip *chip, int lane) · 4 unmodified lines
1284	* It seems that after this workaround the SERDES is automatically	1345	* It seems that after this workaround the SERDES is automatically
1285	* powered up (the bit is cleared), so power it down.	1346	* powered up (the bit is cleared), so power it down.
1286	*/	1347	*/
1287	if (lane == MV88E6393X_PORT0_LANE \|\| lane == MV88E6393X_PORT9_LANE \|\|	1348	err = mv88e6390_serdes_read(chip, lane, MDIO_MMD_PHYXS,
1288	lane == MV88E6393X_PORT10_LANE) {	1349	MV88E6393X_SERDES_POC, &reg);
1289	err = mv88e6390_serdes_read(chip, lane,	1350	if (err)
1290	MDIO_MMD_PHYXS,	1351	return err;
1291	MV88E6393X_SERDES_POC, &reg);
1292	if (err)
1293	return err;
1294		1352
1295	reg &= ~MV88E6393X_SERDES_POC_PDOWN;	1353	reg &= ~MV88E6393X_SERDES_POC_PDOWN;
1296	reg \|= MV88E6393X_SERDES_POC_RESET;	1354	reg \|= MV88E6393X_SERDES_POC_RESET;
1297		1355
1298	err = mv88e6390_serdes_write(chip, lane, MDIO_MMD_PHYXS,	1356	err = mv88e6390_serdes_write(chip, lane, MDIO_MMD_PHYXS,
1299	MV88E6393X_SERDES_POC, reg);	1357	MV88E6393X_SERDES_POC, reg);
1300	if (err)	1358	if (err)
1301	return err;	1359	return err;
1302		1360
1303	err = mv88e6390_serdes_power_sgmii(chip, lane, false);	1361	err = mv88e6390_serdes_power_sgmii(chip, lane, false);
1304	if (err)	1362	if (err)
1305	return err;	1363	return err;
1306	}	1364
		1365	return mv88e6393x_serdes_power_lane(chip, lane, false);
		1366	}
		1367
		1368	int mv88e6393x_serdes_setup_errata(struct mv88e6xxx_chip *chip)
		1369	{
		1370	int err;
		1371
		1372	err = mv88e6393x_serdes_erratum_4_6(chip, MV88E6393X_PORT0_LANE);
		1373	if (err)
		1374	return err;
		1375
		1376	err = mv88e6393x_serdes_erratum_4_6(chip, MV88E6393X_PORT9_LANE);
		1377	if (err)
		1378	return err;
		1379
		1380	return mv88e6393x_serdes_erratum_4_6(chip, MV88E6393X_PORT10_LANE);
		1381	}
		1382
		1383	static int mv88e6393x_serdes_erratum_4_8(struct mv88e6xxx_chip *chip, int lane)
		1384	{
		1385	u16 reg, pcs;
		1386	int err;
1307		1387
1308	/* mv88e6393x family errata 4.8:	1388	/* mv88e6393x family errata 4.8:
1309	* When a SERDES port is operating in 1000BASE-X or SGMII mode link may	1389	* When a SERDES port is operating in 1000BASE-X or SGMII mode link may
@@ -1334,38 +1414,152 @@ static int mv88e6393x_serdes_port_errata(struct mv88e6xxx_chip *chip, int lane) · 24 unmodified lines
1334	MV88E6393X_ERRATA_4_8_REG, reg);	1414	MV88E6393X_ERRATA_4_8_REG, reg);
1335	}	1415	}
1336		1416
1337	int mv88e6393x_serdes_setup_errata(struct mv88e6xxx_chip *chip)	1417	static int mv88e6393x_serdes_erratum_5_2(struct mv88e6xxx_chip *chip, int lane,
		1418	u8 cmode)
		1419	{
		1420	static const struct {
		1421	u16 dev, reg, val, mask;
		1422	} fixes[] = {
		1423	{ MDIO_MMD_VEND1, 0x8093, 0xcb5a, 0xffff },
		1424	{ MDIO_MMD_VEND1, 0x8171, 0x7088, 0xffff },
		1425	{ MDIO_MMD_VEND1, 0x80c9, 0x311a, 0xffff },
		1426	{ MDIO_MMD_VEND1, 0x80a2, 0x8000, 0xff7f },
		1427	{ MDIO_MMD_VEND1, 0x80a9, 0x0000, 0xfff0 },
		1428	{ MDIO_MMD_VEND1, 0x80a3, 0x0000, 0xf8ff },
		1429	{ MDIO_MMD_PHYXS, MV88E6393X_SERDES_POC,
		1430	MV88E6393X_SERDES_POC_RESET, MV88E6393X_SERDES_POC_RESET },
		1431	};
		1432	int err, i;
		1433	u16 reg;
		1434
		1435	/* mv88e6393x family errata 5.2:
		1436	* For optimal signal integrity the following sequence should be applied
		1437	* to SERDES operating in 10G mode. These registers only apply to 10G
		1438	* operation and have no effect on other speeds.
		1439	*/
		1440	if (cmode != MV88E6393X_PORT_STS_CMODE_10GBASER)
		1441	return 0;
		1442
		1443	for (i = 0; i < ARRAY_SIZE(fixes); ++i) {
		1444	err = mv88e6390_serdes_read(chip, lane, fixes[i].dev,
		1445	fixes[i].reg, &reg);
		1446	if (err)
		1447	return err;
		1448
		1449	reg &= ~fixes[i].mask;
		1450	reg \|= fixes[i].val;
		1451
		1452	err = mv88e6390_serdes_write(chip, lane, fixes[i].dev,
		1453	fixes[i].reg, reg);
		1454	if (err)
		1455	return err;
		1456	}
		1457
		1458	return 0;
		1459	}
		1460
		1461	static int mv88e6393x_serdes_fix_2500basex_an(struct mv88e6xxx_chip *chip,
		1462	int lane, u8 cmode, bool on)
1338	{	1463	{
		1464	u16 reg;
1339	int err;	1465	int err;
1340		1466
1341	err = mv88e6393x_serdes_port_errata(chip, MV88E6393X_PORT0_LANE);	1467	if (cmode != MV88E6XXX_PORT_STS_CMODE_2500BASEX)
		1468	return 0;
		1469
		1470	/* Inband AN is broken on Amethyst in 2500base-x mode when set by
		1471	* standard mechanism (via cmode).
		1472	* We can get around this by configuring the PCS mode to 1000base-x
		1473	* and then writing value 0x58 to register 1e.8000. (This must be done
		1474	* while SerDes receiver and transmitter are disabled, which is, when
		1475	* this function is called.)
		1476	* It seem that when we do this configuration to 2500base-x mode (by
		1477	* changing PCS mode to 1000base-x and frequency to 3.125 GHz from
		1478	* 1.25 GHz) and then configure to sgmii or 1000base-x, the device
		1479	* thinks that it already has SerDes at 1.25 GHz and does not change
		1480	* the 1e.8000 register, leaving SerDes at 3.125 GHz.
		1481	* To avoid this, change PCS mode back to 2500base-x when disabling
		1482	* SerDes from 2500base-x mode.
		1483	*/
		1484	err = mv88e6390_serdes_read(chip, lane, MDIO_MMD_PHYXS,
		1485	MV88E6393X_SERDES_POC, &reg);
		1486	if (err)
		1487	return err;
		1488
		1489	reg &= ~(MV88E6393X_SERDES_POC_PCS_MASK \| MV88E6393X_SERDES_POC_AN);
		1490	if (on)
		1491	reg \|= MV88E6393X_SERDES_POC_PCS_1000BASEX \|
		1492	MV88E6393X_SERDES_POC_AN;
		1493	else
		1494	reg \|= MV88E6393X_SERDES_POC_PCS_2500BASEX;
		1495	reg \|= MV88E6393X_SERDES_POC_RESET;
		1496
		1497	err = mv88e6390_serdes_write(chip, lane, MDIO_MMD_PHYXS,
		1498	MV88E6393X_SERDES_POC, reg);
1342	if (err)	1499	if (err)
1343	return err;	1500	return err;
1344		1501
1345	err = mv88e6393x_serdes_port_errata(chip, MV88E6393X_PORT9_LANE);	1502	err = mv88e6390_serdes_write(chip, lane, MDIO_MMD_VEND1, 0x8000, 0x58);
1346	if (err)	1503	if (err)
1347	return err;	1504	return err;
1348		1505
1349	return mv88e6393x_serdes_port_errata(chip, MV88E6393X_PORT10_LANE);	1506	return 0;
1350	}	1507	}
1351		1508
1352	int mv88e6393x_serdes_power(struct mv88e6xxx_chip *chip, int port, int lane,	1509	int mv88e6393x_serdes_power(struct mv88e6xxx_chip *chip, int port, int lane,
1353	bool on)	1510	bool on)
1354	{	1511	{
1355	u8 cmode = chip->ports[port].cmode;	1512	u8 cmode = chip->ports[port].cmode;
		1513	int err;
1356		1514
1357	if (port != 0 && port != 9 && port != 10)	1515	if (port != 0 && port != 9 && port != 10)
1358	return -EOPNOTSUPP;	1516	return -EOPNOTSUPP;
1359		1517
		1518	if (on) {
		1519	err = mv88e6393x_serdes_erratum_4_8(chip, lane);
		1520	if (err)
		1521	return err;
		1522
		1523	err = mv88e6393x_serdes_erratum_5_2(chip, lane, cmode);
		1524	if (err)
		1525	return err;
		1526
		1527	err = mv88e6393x_serdes_fix_2500basex_an(chip, lane, cmode,
		1528	true);
		1529	if (err)
		1530	return err;
		1531
		1532	err = mv88e6393x_serdes_power_lane(chip, lane, true);
		1533	if (err)
		1534	return err;
		1535	}
		1536
1360	switch (cmode) {	1537	switch (cmode) {
1361	case MV88E6XXX_PORT_STS_CMODE_SGMII:	1538	case MV88E6XXX_PORT_STS_CMODE_SGMII:
1362	case MV88E6XXX_PORT_STS_CMODE_1000BASEX:	1539	case MV88E6XXX_PORT_STS_CMODE_1000BASEX:
1363	case MV88E6XXX_PORT_STS_CMODE_2500BASEX:	1540	case MV88E6XXX_PORT_STS_CMODE_2500BASEX:
1364	return mv88e6390_serdes_power_sgmii(chip, lane, on);	1541	err = mv88e6390_serdes_power_sgmii(chip, lane, on);
		1542	break;
1365	case MV88E6393X_PORT_STS_CMODE_5GBASER:	1543	case MV88E6393X_PORT_STS_CMODE_5GBASER:
1366	case MV88E6393X_PORT_STS_CMODE_10GBASER:	1544	case MV88E6393X_PORT_STS_CMODE_10GBASER:
1367	return mv88e6390_serdes_power_10g(chip, lane, on);	1545	err = mv88e6390_serdes_power_10g(chip, lane, on);
		1546	break;
		1547	default:
		1548	err = -EINVAL;
		1549	break;
1368	}	1550	}
1369		1551
1370	return 0;	1552	if (err)
		1553	return err;
		1554
		1555	if (!on) {
		1556	err = mv88e6393x_serdes_power_lane(chip, lane, false);
		1557	if (err)
		1558	return err;
		1559
		1560	err = mv88e6393x_serdes_fix_2500basex_an(chip, lane, cmode,
		1561	false);
		1562	}
		1563
		1564	return err;
1371	}	1565	}

drivers/net/dsa/mv88e6xxx/serdes.h+4−0

 #define MV88E6393X_SERDES_POC_PCS_MASK		0x0007
 #define MV88E6393X_SERDES_POC_RESET		BIT(15)
 #define MV88E6393X_SERDES_POC_PDOWN		BIT(5)
+#define MV88E6393X_SERDES_POC_AN		BIT(3)
+#define MV88E6393X_SERDES_CTRL1			0xf003
+#define MV88E6393X_SERDES_CTRL1_TX_PDOWN	BIT(9)
+#define MV88E6393X_SERDES_CTRL1_RX_PDOWN	BIT(8)
 #define MV88E6393X_ERRATA_4_8_REG		0xF074
 #define MV88E6393X_ERRATA_4_8_BIT		BIT(14)

drivers/net/dsa/ocelot/felix.c+4−1

 		}
 	}
-	if (cpu < 0)
+	if (cpu < 0) {
+		kfree(tagging_rule);
+		kfree(redirect_rule);
 		return -EINVAL;
+	}
 	tagging_rule->key_type = OCELOT_VCAP_KEY_ETYPE;
 	*(__be16 *)tagging_rule->key.etype.etype.value = htons(ETH_P_1588);

drivers/net/dsa/rtl8365mb.c+8−1

 #define RTL8365MB_LEARN_LIMIT_MAX_8365MB_VC	2112
 /* Family-specific data and limits */
+#define RTL8365MB_PHYADDRMAX	7
 #define RTL8365MB_NUM_PHYREGS	32
 #define RTL8365MB_PHYREGMAX	(RTL8365MB_NUM_PHYREGS - 1)
 #define RTL8365MB_MAX_NUM_PORTS	(RTL8365MB_CPU_PORT_NUM_8365MB_VC + 1)
 #define RTL8365MB_INDIRECT_ACCESS_STATUS_REG			0x1F01
 #define RTL8365MB_INDIRECT_ACCESS_ADDRESS_REG			0x1F02
 #define   RTL8365MB_INDIRECT_ACCESS_ADDRESS_OCPADR_5_1_MASK	GENMASK(4, 0)
-#define   RTL8365MB_INDIRECT_ACCESS_ADDRESS_PHYNUM_MASK		GENMASK(6, 5)
+#define   RTL8365MB_INDIRECT_ACCESS_ADDRESS_PHYNUM_MASK		GENMASK(7, 5)
 #define   RTL8365MB_INDIRECT_ACCESS_ADDRESS_OCPADR_9_6_MASK	GENMASK(11, 8)
 #define   RTL8365MB_PHY_BASE					0x2000
 #define RTL8365MB_INDIRECT_ACCESS_WRITE_DATA_REG		0x1F03
 	u16 val;
 	int ret;
+	if (phy > RTL8365MB_PHYADDRMAX)
+		return -EINVAL;
 	if (regnum > RTL8365MB_PHYREGMAX)
 		return -EINVAL;
 	u32 ocp_addr;
 	int ret;
+	if (phy > RTL8365MB_PHYADDRMAX)
+		return -EINVAL;
 	if (regnum > RTL8365MB_PHYREGMAX)
 		return -EINVAL;

drivers/net/ethernet/altera/altera_tse_main.c+6−3

 		priv->rxdescmem_busaddr = dma_res->start;
 	} else {
+		ret = -ENODEV;
 		goto err_free_netdev;
 	}
-	if (!dma_set_mask(priv->device, DMA_BIT_MASK(priv->dmaops->dmamask)))
+	if (!dma_set_mask(priv->device, DMA_BIT_MASK(priv->dmaops->dmamask))) {
 		dma_set_coherent_mask(priv->device,
 				      DMA_BIT_MASK(priv->dmaops->dmamask));
-	else if (!dma_set_mask(priv->device, DMA_BIT_MASK(32)))
+	} else if (!dma_set_mask(priv->device, DMA_BIT_MASK(32))) {
 		dma_set_coherent_mask(priv->device, DMA_BIT_MASK(32));
-	else
+	} else {
+		ret = -EIO;
 		goto err_free_netdev;
+	}
 	/* MAC address space */
 	ret = request_and_map(pdev, "control_port", &control_port,

drivers/net/ethernet/aquantia/atlantic/aq_common.h+14−13

@@ -40,10 +40,12 @@ · 39 unmodified lines
40		40
41	#define AQ_DEVICE_ID_AQC113DEV 0x00C0	41	#define AQ_DEVICE_ID_AQC113DEV 0x00C0
42	#define AQ_DEVICE_ID_AQC113CS 0x94C0	42	#define AQ_DEVICE_ID_AQC113CS 0x94C0
		43	#define AQ_DEVICE_ID_AQC113CA 0x34C0
43	#define AQ_DEVICE_ID_AQC114CS 0x93C0	44	#define AQ_DEVICE_ID_AQC114CS 0x93C0
44	#define AQ_DEVICE_ID_AQC113 0x04C0	45	#define AQ_DEVICE_ID_AQC113 0x04C0
45	#define AQ_DEVICE_ID_AQC113C 0x14C0	46	#define AQ_DEVICE_ID_AQC113C 0x14C0
46	#define AQ_DEVICE_ID_AQC115C 0x12C0	47	#define AQ_DEVICE_ID_AQC115C 0x12C0
		48	#define AQ_DEVICE_ID_AQC116C 0x11C0
47		49
48	#define HW_ATL_NIC_NAME "Marvell (aQuantia) AQtion 10Gbit Network Adapter"	50	#define HW_ATL_NIC_NAME "Marvell (aQuantia) AQtion 10Gbit Network Adapter"
49		51
@@ -53,20 +55,19 @@ · 3 unmodified lines
53		55
54	#define AQ_NIC_RATE_10G BIT(0)	56	#define AQ_NIC_RATE_10G BIT(0)
55	#define AQ_NIC_RATE_5G BIT(1)	57	#define AQ_NIC_RATE_5G BIT(1)
56	#define AQ_NIC_RATE_5GSR BIT(2)	58	#define AQ_NIC_RATE_2G5 BIT(2)
57	#define AQ_NIC_RATE_2G5 BIT(3)	59	#define AQ_NIC_RATE_1G BIT(3)
58	#define AQ_NIC_RATE_1G BIT(4)	60	#define AQ_NIC_RATE_100M BIT(4)
59	#define AQ_NIC_RATE_100M BIT(5)	61	#define AQ_NIC_RATE_10M BIT(5)
60	#define AQ_NIC_RATE_10M BIT(6)	62	#define AQ_NIC_RATE_1G_HALF BIT(6)
61	#define AQ_NIC_RATE_1G_HALF BIT(7)	63	#define AQ_NIC_RATE_100M_HALF BIT(7)
62	#define AQ_NIC_RATE_100M_HALF BIT(8)	64	#define AQ_NIC_RATE_10M_HALF BIT(8)
63	#define AQ_NIC_RATE_10M_HALF BIT(9)
64		65
65	#define AQ_NIC_RATE_EEE_10G BIT(10)	66	#define AQ_NIC_RATE_EEE_10G BIT(9)
66	#define AQ_NIC_RATE_EEE_5G BIT(11)	67	#define AQ_NIC_RATE_EEE_5G BIT(10)
67	#define AQ_NIC_RATE_EEE_2G5 BIT(12)	68	#define AQ_NIC_RATE_EEE_2G5 BIT(11)
68	#define AQ_NIC_RATE_EEE_1G BIT(13)	69	#define AQ_NIC_RATE_EEE_1G BIT(12)
69	#define AQ_NIC_RATE_EEE_100M BIT(14)	70	#define AQ_NIC_RATE_EEE_100M BIT(13)
70	#define AQ_NIC_RATE_EEE_MSK (AQ_NIC_RATE_EEE_10G \|\	71	#define AQ_NIC_RATE_EEE_MSK (AQ_NIC_RATE_EEE_10G \|\
71	AQ_NIC_RATE_EEE_5G \|\	72	AQ_NIC_RATE_EEE_5G \|\
72	AQ_NIC_RATE_EEE_2G5 \|\	73	AQ_NIC_RATE_EEE_2G5 \|\

drivers/net/ethernet/aquantia/atlantic/aq_hw.h+2−0

@@ -80,6 +80,8 @@ struct aq_hw_link_status_s { · 79 unmodified lines
80	};	80	};
81		81
82	struct aq_stats_s {	82	struct aq_stats_s {
		83	u64 brc;
		84	u64 btc;
83	u64 uprc;	85	u64 uprc;
84	u64 mprc;	86	u64 mprc;
85	u64 bprc;	87	u64 bprc;

drivers/net/ethernet/aquantia/atlantic/aq_nic.c+22−12

 	aq_macsec_init(self);
 #endif
-	mutex_lock(&self->fwreq_mutex);
+	if (platform_get_ethdev_address(&self->pdev->dev, self->ndev) != 0) {
-	err = self->aq_fw_ops->get_mac_permanent(self->aq_hw, addr);
+		// If DT has none or an invalid one, ask device for MAC address
-	mutex_unlock(&self->fwreq_mutex);
+		mutex_lock(&self->fwreq_mutex);
-	if (err)
+		err = self->aq_fw_ops->get_mac_permanent(self->aq_hw, addr);
-		goto err_exit;
+		mutex_unlock(&self->fwreq_mutex);
-	eth_hw_addr_set(self->ndev, addr);
+		if (err)
+			goto err_exit;
-	if (!is_valid_ether_addr(self->ndev->dev_addr) ||
+		if (is_valid_ether_addr(addr) &&
-	    !aq_nic_is_valid_ether_addr(self->ndev->dev_addr)) {
+		    aq_nic_is_valid_ether_addr(addr)) {
-		netdev_warn(self->ndev, "MAC is invalid, will use random.");
+			eth_hw_addr_set(self->ndev, addr);
-		eth_hw_addr_random(self->ndev);
+		} else {
+			netdev_warn(self->ndev, "MAC is invalid, will use random.");
+			eth_hw_addr_random(self->ndev);
+		}
 	}
 #if defined(AQ_CFG_MAC_ADDR_PERMANENT)
 	data[++i] = stats->mbtc;
 	data[++i] = stats->bbrc;
 	data[++i] = stats->bbtc;
-	data[++i] = stats->ubrc + stats->mbrc + stats->bbrc;
+	if (stats->brc)
-	data[++i] = stats->ubtc + stats->mbtc + stats->bbtc;
+		data[++i] = stats->brc;
+	else
+		data[++i] = stats->ubrc + stats->mbrc + stats->bbrc;
+	if (stats->btc)
+		data[++i] = stats->btc;
+	else
+		data[++i] = stats->ubtc + stats->mbtc + stats->bbtc;
 	data[++i] = stats->dma_pkt_rc;
 	data[++i] = stats->dma_pkt_tc;
 	data[++i] = stats->dma_oct_rc;

drivers/net/ethernet/aquantia/atlantic/aq_pci_func.c+6−1

 	{ PCI_VDEVICE(AQUANTIA, AQ_DEVICE_ID_AQC113), },
 	{ PCI_VDEVICE(AQUANTIA, AQ_DEVICE_ID_AQC113C), },
 	{ PCI_VDEVICE(AQUANTIA, AQ_DEVICE_ID_AQC115C), },
+	{ PCI_VDEVICE(AQUANTIA, AQ_DEVICE_ID_AQC113CA), },
+	{ PCI_VDEVICE(AQUANTIA, AQ_DEVICE_ID_AQC116C), },
 	{}
 };
 	{ AQ_DEVICE_ID_AQC113CS,	AQ_HWREV_ANY,	&hw_atl2_ops, &hw_atl2_caps_aqc113, },
 	{ AQ_DEVICE_ID_AQC114CS,	AQ_HWREV_ANY,	&hw_atl2_ops, &hw_atl2_caps_aqc113, },
 	{ AQ_DEVICE_ID_AQC113C,		AQ_HWREV_ANY,	&hw_atl2_ops, &hw_atl2_caps_aqc113, },
-	{ AQ_DEVICE_ID_AQC115C,		AQ_HWREV_ANY,	&hw_atl2_ops, &hw_atl2_caps_aqc113, },
+	{ AQ_DEVICE_ID_AQC115C,		AQ_HWREV_ANY,	&hw_atl2_ops, &hw_atl2_caps_aqc115c, },
+	{ AQ_DEVICE_ID_AQC113CA,	AQ_HWREV_ANY,	&hw_atl2_ops, &hw_atl2_caps_aqc113, },
+	{ AQ_DEVICE_ID_AQC116C,		AQ_HWREV_ANY,	&hw_atl2_ops, &hw_atl2_caps_aqc116c, },
 };
 MODULE_DEVICE_TABLE(pci, aq_pci_tbl);

drivers/net/ethernet/aquantia/atlantic/aq_vec.c+0−3

@@ -362,9 +362,6 @@ unsigned int aq_vec_get_sw_stats(struct aq_vec_s *self, const unsigned int tc, u · 361 unmodified lines
362	{	362	{
363	unsigned int count;	363	unsigned int count;
364		364
365	WARN_ONCE(!aq_vec_is_valid_tc(self, tc),
366	"Invalid tc %u (#rx=%u, #tx=%u)\n",
367	tc, self->rx_rings, self->tx_rings);
368	if (!aq_vec_is_valid_tc(self, tc))	365	if (!aq_vec_is_valid_tc(self, tc))
369	return 0;	366	return 0;
370		367

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_utils.c+13−2

 int hw_atl_utils_update_stats(struct aq_hw_s *self)
 {
 	struct aq_stats_s *cs = &self->curr_stats;
+	struct aq_stats_s curr_stats = *cs;
 	struct hw_atl_utils_mbox mbox;
+	bool corrupted_stats = false;
 	hw_atl_utils_mpi_read_stats(self, &mbox);
-#define AQ_SDELTA(_N_) (self->curr_stats._N_ += \
+#define AQ_SDELTA(_N_)  \
-			mbox.stats._N_ - self->last_stats._N_)
+do { \
+	if (!corrupted_stats && \
+	    ((s64)(mbox.stats._N_ - self->last_stats._N_)) >= 0) \
+		curr_stats._N_ += mbox.stats._N_ - self->last_stats._N_; \
+	else \
+		corrupted_stats = true; \
+} while (0)
 	if (self->aq_link_status.mbps) {
 		AQ_SDELTA(uprc);
 		AQ_SDELTA(bbrc);
 		AQ_SDELTA(bbtc);
 		AQ_SDELTA(dpc);
+		if (!corrupted_stats)
+			*cs = curr_stats;
 	}
 #undef AQ_SDELTA

drivers/net/ethernet/aquantia/atlantic/hw_atl/hw_atl_utils_fw2x.c+0−3

@@ -132,9 +132,6 @@ static enum hw_atl_fw2x_rate link_speed_mask_2fw2x_ratemask(u32 speed) · 131 unmodified lines
132	if (speed & AQ_NIC_RATE_5G)	132	if (speed & AQ_NIC_RATE_5G)
133	rate \|= FW2X_RATE_5G;	133	rate \|= FW2X_RATE_5G;
134		134
135	if (speed & AQ_NIC_RATE_5GSR)
136	rate \|= FW2X_RATE_5G;
137
138	if (speed & AQ_NIC_RATE_2G5)	135	if (speed & AQ_NIC_RATE_2G5)
139	rate \|= FW2X_RATE_2G5;	136	rate \|= FW2X_RATE_2G5;
140		137

drivers/net/ethernet/aquantia/atlantic/hw_atl2/hw_atl2.c+18−4

@@ -65,11 +65,25 @@ const struct aq_hw_caps_s hw_atl2_caps_aqc113 = { · 64 unmodified lines
65	AQ_NIC_RATE_5G \|	65	AQ_NIC_RATE_5G \|
66	AQ_NIC_RATE_2G5 \|	66	AQ_NIC_RATE_2G5 \|
67	AQ_NIC_RATE_1G \|	67	AQ_NIC_RATE_1G \|
68	AQ_NIC_RATE_1G_HALF \|
69	AQ_NIC_RATE_100M \|	68	AQ_NIC_RATE_100M \|
70	AQ_NIC_RATE_100M_HALF \|	69	AQ_NIC_RATE_10M,
71	AQ_NIC_RATE_10M \|	70	};
72	AQ_NIC_RATE_10M_HALF,	71
		72	const struct aq_hw_caps_s hw_atl2_caps_aqc115c = {
		73	DEFAULT_BOARD_BASIC_CAPABILITIES,
		74	.media_type = AQ_HW_MEDIA_TYPE_TP,
		75	.link_speed_msk = AQ_NIC_RATE_2G5 \|
		76	AQ_NIC_RATE_1G \|
		77	AQ_NIC_RATE_100M \|
		78	AQ_NIC_RATE_10M,
		79	};
		80
		81	const struct aq_hw_caps_s hw_atl2_caps_aqc116c = {
		82	DEFAULT_BOARD_BASIC_CAPABILITIES,
		83	.media_type = AQ_HW_MEDIA_TYPE_TP,
		84	.link_speed_msk = AQ_NIC_RATE_1G \|
		85	AQ_NIC_RATE_100M \|
		86	AQ_NIC_RATE_10M,
73	};	87	};
74		88
75	static u32 hw_atl2_sem_act_rslvr_get(struct aq_hw_s *self)	89	static u32 hw_atl2_sem_act_rslvr_get(struct aq_hw_s *self)

drivers/net/ethernet/aquantia/atlantic/hw_atl2/hw_atl2.h+2−0

@@ -9,6 +9,8 @@ · 8 unmodified lines
9	#include "aq_common.h"	9	#include "aq_common.h"
10		10
11	extern const struct aq_hw_caps_s hw_atl2_caps_aqc113;	11	extern const struct aq_hw_caps_s hw_atl2_caps_aqc113;
		12	extern const struct aq_hw_caps_s hw_atl2_caps_aqc115c;
		13	extern const struct aq_hw_caps_s hw_atl2_caps_aqc116c;
12	extern const struct aq_hw_ops hw_atl2_ops;	14	extern const struct aq_hw_ops hw_atl2_ops;
13		15
14	#endif /* HW_ATL2_H */	16	#endif /* HW_ATL2_H */

drivers/net/ethernet/aquantia/atlantic/hw_atl2/hw_atl2_utils.h+34−4

 		u8 minor;
 		u16 build;
 	} phy;
-	u32 rsvd;
+	u32 drv_iface_ver:4;
+	u32 rsvd:28;
 };
 struct link_status_s {
 	u16 rsvd2;
 };
-struct statistics_s {
+struct statistics_a0_s {
 	struct {
 		u32 link_up;
 		u32 link_down;
 	u32 reserve_fw_gap;
 };
+struct __packed statistics_b0_s {
+	u64 rx_good_octets;
+	u64 rx_pause_frames;
+	u64 rx_good_frames;
+	u64 rx_errors;
+	u64 rx_unicast_frames;
+	u64 rx_multicast_frames;
+	u64 rx_broadcast_frames;
+	u64 tx_good_octets;
+	u64 tx_pause_frames;
+	u64 tx_good_frames;
+	u64 tx_errors;
+	u64 tx_unicast_frames;
+	u64 tx_multicast_frames;
+	u64 tx_broadcast_frames;
+	u32 main_loop_cycles;
+};
+struct __packed statistics_s {
+	union __packed {
+		struct statistics_a0_s a0;
+		struct statistics_b0_s b0;
+	};
+};
 struct filter_caps_s {
 	u8 l2_filters_base_index:6;
 	u8 flexible_filter_mask:2;
 	u32 rsvd5;
 };
-struct fw_interface_out {
+struct __packed fw_interface_out {
 	struct transaction_counter_s transaction_id;
 	struct version_s version;
 	struct link_status_s link_status;
 	struct core_dump_s core_dump;
 	u32 rsvd11;
 	struct statistics_s stats;
-	u32 rsvd12;
 	struct filter_caps_s filter_caps;
 	struct device_caps_s device_caps;
 	u32 rsvd13;
 #define  AQ_HOST_MODE_LOW_POWER    3U
 #define  AQ_HOST_MODE_SHUTDOWN     4U
+#define  AQ_A2_FW_INTERFACE_A0     0
+#define  AQ_A2_FW_INTERFACE_B0     1
 int hw_atl2_utils_initfw(struct aq_hw_s *self, const struct aq_fw_ops **fw_ops);
 int hw_atl2_utils_soft_reset(struct aq_hw_s *self);

drivers/net/ethernet/aquantia/atlantic/hw_atl2/hw_atl2_utils_fw.c+87−23

@@ -84,7 +84,7 @@ static int hw_atl2_shared_buffer_read_block(struct aq_hw_s *self, · 83 unmodified lines
84	if (cnt > AQ_A2_FW_READ_TRY_MAX)	84	if (cnt > AQ_A2_FW_READ_TRY_MAX)
85	return -ETIME;	85	return -ETIME;
86	if (tid1.transaction_cnt_a != tid1.transaction_cnt_b)	86	if (tid1.transaction_cnt_a != tid1.transaction_cnt_b)
87	udelay(1);	87	mdelay(1);
88	} while (tid1.transaction_cnt_a != tid1.transaction_cnt_b);	88	} while (tid1.transaction_cnt_a != tid1.transaction_cnt_b);
89		89
90	hw_atl2_mif_shared_buf_read(self, offset, (u32 *)data, dwords);	90	hw_atl2_mif_shared_buf_read(self, offset, (u32 *)data, dwords);
@@ -154,7 +154,7 @@ static void a2_link_speed_mask2fw(u32 speed, · 63 unmodified lines
154	{	154	{
155	link_options->rate_10G = !!(speed & AQ_NIC_RATE_10G);	155	link_options->rate_10G = !!(speed & AQ_NIC_RATE_10G);
156	link_options->rate_5G = !!(speed & AQ_NIC_RATE_5G);	156	link_options->rate_5G = !!(speed & AQ_NIC_RATE_5G);
157	link_options->rate_N5G = !!(speed & AQ_NIC_RATE_5GSR);	157	link_options->rate_N5G = link_options->rate_5G;
158	link_options->rate_2P5G = !!(speed & AQ_NIC_RATE_2G5);	158	link_options->rate_2P5G = !!(speed & AQ_NIC_RATE_2G5);
159	link_options->rate_N2P5G = link_options->rate_2P5G;	159	link_options->rate_N2P5G = link_options->rate_2P5G;
160	link_options->rate_1G = !!(speed & AQ_NIC_RATE_1G);	160	link_options->rate_1G = !!(speed & AQ_NIC_RATE_1G);
@@ -192,8 +192,6 @@ static u32 a2_fw_lkp_to_mask(struct lkp_link_caps_s *lkp_link_caps) · 31 unmodified lines
192	rate \|= AQ_NIC_RATE_10G;	192	rate \|= AQ_NIC_RATE_10G;
193	if (lkp_link_caps->rate_5G)	193	if (lkp_link_caps->rate_5G)
194	rate \|= AQ_NIC_RATE_5G;	194	rate \|= AQ_NIC_RATE_5G;
195	if (lkp_link_caps->rate_N5G)
196	rate \|= AQ_NIC_RATE_5GSR;
197	if (lkp_link_caps->rate_2P5G)	195	if (lkp_link_caps->rate_2P5G)
198	rate \|= AQ_NIC_RATE_2G5;	196	rate \|= AQ_NIC_RATE_2G5;
199	if (lkp_link_caps->rate_1G)	197	if (lkp_link_caps->rate_1G)
@@ -335,15 +333,22 @@ static int aq_a2_fw_get_mac_permanent(struct aq_hw_s self, u8 mac) · 135 unmodified lines
335	return 0;	333	return 0;
336	}	334	}
337		335
338	static int aq_a2_fw_update_stats(struct aq_hw_s *self)	336	static void aq_a2_fill_a0_stats(struct aq_hw_s *self,
		337	struct statistics_s *stats)
339	{	338	{
340	struct hw_atl2_priv priv = (struct hw_atl2_priv )self->priv;	339	struct hw_atl2_priv priv = (struct hw_atl2_priv )self->priv;
341	struct statistics_s stats;	340	struct aq_stats_s *cs = &self->curr_stats;
342		341	struct aq_stats_s curr_stats = *cs;
343	hw_atl2_shared_buffer_read_safe(self, stats, &stats);	342	bool corrupted_stats = false;
344		343
345	#define AQ_SDELTA(_N_, _F_) (self->curr_stats._N_ += \	344	#define AQ_SDELTA(_N, _F) \
346	stats.msm._F_ - priv->last_stats.msm._F_)	345	do { \
		346	if (!corrupted_stats && \
		347	((s64)(stats->a0.msm._F - priv->last_stats.a0.msm._F)) >= 0) \
		348	curr_stats._N += stats->a0.msm._F - priv->last_stats.a0.msm._F;\
		349	else \
		350	corrupted_stats = true; \
		351	} while (0)
347		352
348	if (self->aq_link_status.mbps) {	353	if (self->aq_link_status.mbps) {
349	AQ_SDELTA(uprc, rx_unicast_frames);	354	AQ_SDELTA(uprc, rx_unicast_frames);
@@ -362,17 +367,76 @@ static int aq_a2_fw_update_stats(struct aq_hw_s *self) · 12 unmodified lines
362	AQ_SDELTA(mbtc, tx_multicast_octets);	367	AQ_SDELTA(mbtc, tx_multicast_octets);
363	AQ_SDELTA(bbrc, rx_broadcast_octets);	368	AQ_SDELTA(bbrc, rx_broadcast_octets);
364	AQ_SDELTA(bbtc, tx_broadcast_octets);	369	AQ_SDELTA(bbtc, tx_broadcast_octets);
		370
		371	if (!corrupted_stats)
		372	*cs = curr_stats;
365	}	373	}
366	#undef AQ_SDELTA	374	#undef AQ_SDELTA
367	self->curr_stats.dma_pkt_rc =	375
368	hw_atl_stats_rx_dma_good_pkt_counter_get(self);	376	}
369	self->curr_stats.dma_pkt_tc =	377
370	hw_atl_stats_tx_dma_good_pkt_counter_get(self);	378	static void aq_a2_fill_b0_stats(struct aq_hw_s *self,
371	self->curr_stats.dma_oct_rc =	379	struct statistics_s *stats)
372	hw_atl_stats_rx_dma_good_octet_counter_get(self);	380	{
373	self->curr_stats.dma_oct_tc =	381	struct hw_atl2_priv priv = (struct hw_atl2_priv )self->priv;
374	hw_atl_stats_tx_dma_good_octet_counter_get(self);	382	struct aq_stats_s *cs = &self->curr_stats;
375	self->curr_stats.dpc = hw_atl_rpb_rx_dma_drop_pkt_cnt_get(self);	383	struct aq_stats_s curr_stats = *cs;
		384	bool corrupted_stats = false;
		385
		386	#define AQ_SDELTA(_N, _F) \
		387	do { \
		388	if (!corrupted_stats && \
		389	((s64)(stats->b0._F - priv->last_stats.b0._F)) >= 0) \
		390	curr_stats._N += stats->b0._F - priv->last_stats.b0._F; \
		391	else \
		392	corrupted_stats = true; \
		393	} while (0)
		394
		395	if (self->aq_link_status.mbps) {
		396	AQ_SDELTA(uprc, rx_unicast_frames);
		397	AQ_SDELTA(mprc, rx_multicast_frames);
		398	AQ_SDELTA(bprc, rx_broadcast_frames);
		399	AQ_SDELTA(erpr, rx_errors);
		400	AQ_SDELTA(brc, rx_good_octets);
		401
		402	AQ_SDELTA(uptc, tx_unicast_frames);
		403	AQ_SDELTA(mptc, tx_multicast_frames);
		404	AQ_SDELTA(bptc, tx_broadcast_frames);
		405	AQ_SDELTA(erpt, tx_errors);
		406	AQ_SDELTA(btc, tx_good_octets);
		407
		408	if (!corrupted_stats)
		409	*cs = curr_stats;
		410	}
		411	#undef AQ_SDELTA
		412	}
		413
		414	static int aq_a2_fw_update_stats(struct aq_hw_s *self)
		415	{
		416	struct hw_atl2_priv priv = (struct hw_atl2_priv )self->priv;
		417	struct aq_stats_s *cs = &self->curr_stats;
		418	struct statistics_s stats;
		419	struct version_s version;
		420	int err;
		421
		422	err = hw_atl2_shared_buffer_read_safe(self, version, &version);
		423	if (err)
		424	return err;
		425
		426	err = hw_atl2_shared_buffer_read_safe(self, stats, &stats);
		427	if (err)
		428	return err;
		429
		430	if (version.drv_iface_ver == AQ_A2_FW_INTERFACE_A0)
		431	aq_a2_fill_a0_stats(self, &stats);
		432	else
		433	aq_a2_fill_b0_stats(self, &stats);
		434
		435	cs->dma_pkt_rc = hw_atl_stats_rx_dma_good_pkt_counter_get(self);
		436	cs->dma_pkt_tc = hw_atl_stats_tx_dma_good_pkt_counter_get(self);
		437	cs->dma_oct_rc = hw_atl_stats_rx_dma_good_octet_counter_get(self);
		438	cs->dma_oct_tc = hw_atl_stats_tx_dma_good_octet_counter_get(self);
		439	cs->dpc = hw_atl_rpb_rx_dma_drop_pkt_cnt_get(self);
376		440
377	memcpy(&priv->last_stats, &stats, sizeof(stats));	441	memcpy(&priv->last_stats, &stats, sizeof(stats));
378		442
@@ -499,9 +563,9 @@ u32 hw_atl2_utils_get_fw_version(struct aq_hw_s *self) · 120 unmodified lines
499	hw_atl2_shared_buffer_read_safe(self, version, &version);	563	hw_atl2_shared_buffer_read_safe(self, version, &version);
500		564
501	/* A2 FW version is stored in reverse order */	565	/* A2 FW version is stored in reverse order */
502	return version.mac.major << 24 \|	566	return version.bundle.major << 24 \|
503	version.mac.minor << 16 \|	567	version.bundle.minor << 16 \|
504	version.mac.build;	568	version.bundle.build;
505	}	569	}
506		570
507	int hw_atl2_utils_get_action_resolve_table_caps(struct aq_hw_s *self,	571	int hw_atl2_utils_get_action_resolve_table_caps(struct aq_hw_s *self,

drivers/net/ethernet/broadcom/bcm4908_enet.c+3−1

@@ -708,7 +708,9 @@ static int bcm4908_enet_probe(struct platform_device *pdev) · 707 unmodified lines
708		708
709	enet->irq_tx = platform_get_irq_byname(pdev, "tx");	709	enet->irq_tx = platform_get_irq_byname(pdev, "tx");
710		710
711	dma_set_coherent_mask(dev, DMA_BIT_MASK(32));	711	err = dma_set_coherent_mask(dev, DMA_BIT_MASK(32));
		712	if (err)
		713	return err;
712		714
713	err = bcm4908_enet_dma_alloc(enet);	715	err = bcm4908_enet_dma_alloc(enet);
714	if (err)	716	if (err)

drivers/net/ethernet/freescale/dpaa2/dpaa2-eth.c+2−0

@@ -4550,6 +4550,8 @@ static int dpaa2_eth_remove(struct fsl_mc_device *ls_dev) · 4549 unmodified lines
4550		4550
4551	fsl_mc_portal_free(priv->mc_io);	4551	fsl_mc_portal_free(priv->mc_io);
4552		4552
		4553	destroy_workqueue(priv->dpaa2_ptp_wq);
		4554
4553	dev_dbg(net_dev->dev.parent, "Removed interface %s\n", net_dev->name);	4555	dev_dbg(net_dev->dev.parent, "Removed interface %s\n", net_dev->name);
4554		4556
4555	free_netdev(net_dev);	4557	free_netdev(net_dev);

drivers/net/ethernet/freescale/fec.h+3−0

 #define FEC_ENET_WAKEUP	((uint)0x00020000)	/* Wakeup request */
 #define FEC_ENET_TXF	(FEC_ENET_TXF_0 | FEC_ENET_TXF_1 | FEC_ENET_TXF_2)
 #define FEC_ENET_RXF	(FEC_ENET_RXF_0 | FEC_ENET_RXF_1 | FEC_ENET_RXF_2)
+#define FEC_ENET_RXF_GET(X)	(((X) == 0) ? FEC_ENET_RXF_0 :	\
+				(((X) == 1) ? FEC_ENET_RXF_1 :	\
+				FEC_ENET_RXF_2))
 #define FEC_ENET_TS_AVAIL       ((uint)0x00010000)
 #define FEC_ENET_TS_TIMER       ((uint)0x00008000)

drivers/net/ethernet/freescale/fec_main.c+1−1

@@ -1480,7 +1480,7 @@ fec_enet_rx_queue(struct net_device *ndev, int budget, u16 queue_id) · 1479 unmodified lines
1480	break;	1480	break;
1481	pkt_received++;	1481	pkt_received++;
1482		1482
1483	writel(FEC_ENET_RXF, fep->hwp + FEC_IEVENT);	1483	writel(FEC_ENET_RXF_GET(queue_id), fep->hwp + FEC_IEVENT);
1484		1484
1485	/* Check for errors. */	1485	/* Check for errors. */
1486	status ^= BD_ENET_RX_LAST;	1486	status ^= BD_ENET_RX_LAST;

drivers/net/ethernet/google/gve/gve_utils.c+3−0

 		set_protocol = ctx->curr_frag_cnt == ctx->expected_frag_cnt - 1;
 	} else {
 		skb = napi_alloc_skb(napi, len);
+		if (unlikely(!skb))
+			return NULL;
 		set_protocol = true;
 	}
 	__skb_put(skb, len);

drivers/net/ethernet/huawei/hinic/hinic_sriov.c+1−0

@@ -8,6 +8,7 @@ · 7 unmodified lines
8	#include <linux/interrupt.h>	8	#include <linux/interrupt.h>
9	#include <linux/etherdevice.h>	9	#include <linux/etherdevice.h>
10	#include <linux/netdevice.h>	10	#include <linux/netdevice.h>
		11	#include <linux/module.h>
11		12
12	#include "hinic_hw_dev.h"	13	#include "hinic_hw_dev.h"
13	#include "hinic_dev.h"	14	#include "hinic_dev.h"

drivers/net/ethernet/ibm/ibmvnic.c+6−22

 	old_buff_size = adapter->prev_rx_buf_sz;
 	new_buff_size = adapter->cur_rx_buf_sz;
-	/* Require buff size to be exactly same for now */
+	if (old_buff_size != new_buff_size ||
-	if (old_buff_size != new_buff_size)
+	    old_num_pools != new_num_pools ||
-		return false;
+	    old_pool_size != new_pool_size)
-	if (old_num_pools == new_num_pools && old_pool_size == new_pool_size)
-		return true;
-	if (old_num_pools < adapter->min_rx_queues ||
-	    old_num_pools > adapter->max_rx_queues ||
-	    old_pool_size < adapter->min_rx_add_entries_per_subcrq ||
-	    old_pool_size > adapter->max_rx_add_entries_per_subcrq)
 		return false;
 	return true;
 	old_mtu = adapter->prev_mtu;
 	new_mtu = adapter->req_mtu;
-	/* Require MTU to be exactly same to reuse pools for now */
+	if (old_mtu != new_mtu ||
-	if (old_mtu != new_mtu)
+	    old_num_pools != new_num_pools ||
-		return false;
+	    old_pool_size != new_pool_size)
-	if (old_num_pools == new_num_pools && old_pool_size == new_pool_size)
-		return true;
-	if (old_num_pools < adapter->min_tx_queues ||
-	    old_num_pools > adapter->max_tx_queues ||
-	    old_pool_size < adapter->min_tx_entries_per_subcrq ||
-	    old_pool_size > adapter->max_tx_entries_per_subcrq)
 		return false;
 	return true;

drivers/net/ethernet/intel/i40e/i40e_debugfs.c+8−0

@@ -553,6 +553,14 @@ static void i40e_dbg_dump_desc(int cnt, int vsi_seid, int ring_id, int desc_n, · 552 unmodified lines
553	dev_info(&pf->pdev->dev, "vsi %d not found\n", vsi_seid);	553	dev_info(&pf->pdev->dev, "vsi %d not found\n", vsi_seid);
554	return;	554	return;
555	}	555	}
		556	if (vsi->type != I40E_VSI_MAIN &&
		557	vsi->type != I40E_VSI_FDIR &&
		558	vsi->type != I40E_VSI_VMDQ2) {
		559	dev_info(&pf->pdev->dev,
		560	"vsi %d type %d descriptor rings not available\n",
		561	vsi_seid, vsi->type);
		562	return;
		563	}
556	if (type == RING_TYPE_XDP && !i40e_enabled_xdp_vsi(vsi)) {	564	if (type == RING_TYPE_XDP && !i40e_enabled_xdp_vsi(vsi)) {
557	dev_info(&pf->pdev->dev, "XDP not enabled on VSI %d\n", vsi_seid);	565	dev_info(&pf->pdev->dev, "XDP not enabled on VSI %d\n", vsi_seid);
558	return;	566	return;

drivers/net/ethernet/intel/i40e/i40e_virtchnl_pf.c+48−27

 	return i40e_vc_send_msg_to_vf(vf, opcode, retval, NULL, 0);
 }
+/**
+ * i40e_sync_vf_state
+ * @vf: pointer to the VF info
+ * @state: VF state
+ *
+ * Called from a VF message to synchronize the service with a potential
+ * VF reset state
+ **/
+static bool i40e_sync_vf_state(struct i40e_vf *vf, enum i40e_vf_states state)
+{
+	int i;
+	/* When handling some messages, it needs VF state to be set.
+	 * It is possible that this flag is cleared during VF reset,
+	 * so there is a need to wait until the end of the reset to
+	 * handle the request message correctly.
+	 */
+	for (i = 0; i < I40E_VF_STATE_WAIT_COUNT; i++) {
+		if (test_bit(state, &vf->vf_states))
+			return true;
+		usleep_range(10000, 20000);
+	}
+	return test_bit(state, &vf->vf_states);
+}
 /**
  * i40e_vc_get_version_msg
  * @vf: pointer to the VF info
 	size_t len = 0;
 	int ret;
-	if (!test_bit(I40E_VF_STATE_INIT, &vf->vf_states)) {
+	if (!i40e_sync_vf_state(vf, I40E_VF_STATE_INIT)) {
 		aq_ret = I40E_ERR_PARAM;
 		goto err;
 	}
 	bool allmulti = false;
 	bool alluni = false;
-	if (!test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states)) {
+	if (!i40e_sync_vf_state(vf, I40E_VF_STATE_ACTIVE)) {
 		aq_ret = I40E_ERR_PARAM;
 		goto err_out;
 	}
 	struct i40e_vsi *vsi;
 	u16 num_qps_all = 0;
-	if (!test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states)) {
+	if (!i40e_sync_vf_state(vf, I40E_VF_STATE_ACTIVE)) {
 		aq_ret = I40E_ERR_PARAM;
 		goto error_param;
 	}
 	i40e_status aq_ret = 0;
 	int i;
-	if (!test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states)) {
+	if (!i40e_sync_vf_state(vf, I40E_VF_STATE_ACTIVE)) {
 		aq_ret = I40E_ERR_PARAM;
 		goto error_param;
 	}
 	struct i40e_pf *pf = vf->pf;
 	i40e_status aq_ret = 0;
-	if (!test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states)) {
+	if (!i40e_sync_vf_state(vf, I40E_VF_STATE_ACTIVE)) {
 		aq_ret = I40E_ERR_PARAM;
 		goto error_param;
 	}
 	u8 cur_pairs = vf->num_queue_pairs;
 	struct i40e_pf *pf = vf->pf;
-	if (!test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states))
+	if (!i40e_sync_vf_state(vf, I40E_VF_STATE_ACTIVE))
 		return -EINVAL;
 	if (req_pairs > I40E_MAX_VF_QUEUES) {
 	memset(&stats, 0, sizeof(struct i40e_eth_stats));
-	if (!test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states)) {
+	if (!i40e_sync_vf_state(vf, I40E_VF_STATE_ACTIVE)) {
 		aq_ret = I40E_ERR_PARAM;
 		goto error_param;
 	}
 	i40e_status ret = 0;
 	int i;
-	if (!test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states) ||
+	if (!i40e_sync_vf_state(vf, I40E_VF_STATE_ACTIVE) ||
 	    !i40e_vc_isvalid_vsi_id(vf, al->vsi_id)) {
 		ret = I40E_ERR_PARAM;
 		goto error_param;
 	i40e_status ret = 0;
 	int i;
-	if (!test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states) ||
+	if (!i40e_sync_vf_state(vf, I40E_VF_STATE_ACTIVE) ||
 	    !i40e_vc_isvalid_vsi_id(vf, al->vsi_id)) {
 		ret = I40E_ERR_PARAM;
 		goto error_param;
 	i40e_status aq_ret = 0;
 	int i;
-	if (!test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states) ||
+	if (!i40e_sync_vf_state(vf, I40E_VF_STATE_ACTIVE) ||
 	    !i40e_vc_isvalid_vsi_id(vf, vfl->vsi_id)) {
 		aq_ret = I40E_ERR_PARAM;
 		goto error_param;
 	struct i40e_vsi *vsi = NULL;
 	i40e_status aq_ret = 0;
-	if (!test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states) ||
+	if (!i40e_sync_vf_state(vf, I40E_VF_STATE_ACTIVE) ||
 	    !i40e_vc_isvalid_vsi_id(vf, vrk->vsi_id) ||
-	    (vrk->key_len != I40E_HKEY_ARRAY_SIZE)) {
+	    vrk->key_len != I40E_HKEY_ARRAY_SIZE) {
 		aq_ret = I40E_ERR_PARAM;
 		goto err;
 	}
 	i40e_status aq_ret = 0;
 	u16 i;
-	if (!test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states) ||
+	if (!i40e_sync_vf_state(vf, I40E_VF_STATE_ACTIVE) ||
 	    !i40e_vc_isvalid_vsi_id(vf, vrl->vsi_id) ||
-	    (vrl->lut_entries != I40E_VF_HLUT_ARRAY_SIZE)) {
+	    vrl->lut_entries != I40E_VF_HLUT_ARRAY_SIZE) {
 		aq_ret = I40E_ERR_PARAM;
 		goto err;
 	}
 	i40e_status aq_ret = 0;
 	int len = 0;
-	if (!test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states)) {
+	if (!i40e_sync_vf_state(vf, I40E_VF_STATE_ACTIVE)) {
 		aq_ret = I40E_ERR_PARAM;
 		goto err;
 	}
 	struct i40e_hw *hw = &pf->hw;
 	i40e_status aq_ret = 0;
-	if (!test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states)) {
+	if (!i40e_sync_vf_state(vf, I40E_VF_STATE_ACTIVE)) {
 		aq_ret = I40E_ERR_PARAM;
 		goto err;
 	}
 	i40e_status aq_ret = 0;
 	struct i40e_vsi *vsi;
-	if (!test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states)) {
+	if (!i40e_sync_vf_state(vf, I40E_VF_STATE_ACTIVE)) {
 		aq_ret = I40E_ERR_PARAM;
 		goto err;
 	}
 	i40e_status aq_ret = 0;
 	struct i40e_vsi *vsi;
-	if (!test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states)) {
+	if (!i40e_sync_vf_state(vf, I40E_VF_STATE_ACTIVE)) {
 		aq_ret = I40E_ERR_PARAM;
 		goto err;
 	}
 	i40e_status aq_ret = 0;
 	int i, ret;
-	if (!test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states)) {
+	if (!i40e_sync_vf_state(vf, I40E_VF_STATE_ACTIVE)) {
 		aq_ret = I40E_ERR_PARAM;
 		goto err;
 	}
 	i40e_status aq_ret = 0;
 	int i, ret;
-	if (!test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states)) {
+	if (!i40e_sync_vf_state(vf, I40E_VF_STATE_ACTIVE)) {
 		aq_ret = I40E_ERR_PARAM;
 		goto err_out;
 	}
 	i40e_status aq_ret = 0;
 	u64 speed = 0;
-	if (!test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states)) {
+	if (!i40e_sync_vf_state(vf, I40E_VF_STATE_ACTIVE)) {
 		aq_ret = I40E_ERR_PARAM;
 		goto err;
 	}
 	/* set this flag only after making sure all inputs are sane */
 	vf->adq_enabled = true;
-	/* num_req_queues is set when user changes number of queues via ethtool
-	 * and this causes issue for default VSI(which depends on this variable)
-	 * when ADq is enabled, hence reset it.
-	 */
-	vf->num_req_queues = 0;
 	/* reset the VF in order to allocate resources */
 	i40e_vc_reset_vf(vf, true);
 	struct i40e_pf *pf = vf->pf;
 	i40e_status aq_ret = 0;
-	if (!test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states)) {
+	if (!i40e_sync_vf_state(vf, I40E_VF_STATE_ACTIVE)) {
 		aq_ret = I40E_ERR_PARAM;
 		goto err;
 	}

drivers/net/ethernet/intel/i40e/i40e_virtchnl_pf.h+2−0

@@ -18,6 +18,8 @@ · 17 unmodified lines
18		18
19	#define I40E_MAX_VF_PROMISC_FLAGS 3	19	#define I40E_MAX_VF_PROMISC_FLAGS 3
20		20
		21	#define I40E_VF_STATE_WAIT_COUNT 20
		22
21	/* Various queue ctrls */	23	/* Various queue ctrls */
22	enum i40e_queue_ctrl {	24	enum i40e_queue_ctrl {
23	I40E_QUEUE_CTRL_UNKNOWN = 0,	25	I40E_QUEUE_CTRL_UNKNOWN = 0,

drivers/net/ethernet/intel/iavf/iavf_ethtool.c+32−11

 	if ((ring->rx_mini_pending) || (ring->rx_jumbo_pending))
 		return -EINVAL;
-	new_tx_count = clamp_t(u32, ring->tx_pending,
+	if (ring->tx_pending > IAVF_MAX_TXD ||
-			       IAVF_MIN_TXD,
+	    ring->tx_pending < IAVF_MIN_TXD ||
-			       IAVF_MAX_TXD);
+	    ring->rx_pending > IAVF_MAX_RXD ||
-	new_tx_count = ALIGN(new_tx_count, IAVF_REQ_DESCRIPTOR_MULTIPLE);
+	    ring->rx_pending < IAVF_MIN_RXD) {
+		netdev_err(netdev, "Descriptors requested (Tx: %d / Rx: %d) out of range [%d-%d] (increment %d)\n",
+			   ring->tx_pending, ring->rx_pending, IAVF_MIN_TXD,
+			   IAVF_MAX_RXD, IAVF_REQ_DESCRIPTOR_MULTIPLE);
+		return -EINVAL;
+	}
-	new_rx_count = clamp_t(u32, ring->rx_pending,
+	new_tx_count = ALIGN(ring->tx_pending, IAVF_REQ_DESCRIPTOR_MULTIPLE);
-			       IAVF_MIN_RXD,
+	if (new_tx_count != ring->tx_pending)
-			       IAVF_MAX_RXD);
+		netdev_info(netdev, "Requested Tx descriptor count rounded up to %d\n",
-	new_rx_count = ALIGN(new_rx_count, IAVF_REQ_DESCRIPTOR_MULTIPLE);
+			    new_tx_count);
+	new_rx_count = ALIGN(ring->rx_pending, IAVF_REQ_DESCRIPTOR_MULTIPLE);
+	if (new_rx_count != ring->rx_pending)
+		netdev_info(netdev, "Requested Rx descriptor count rounded up to %d\n",
+			    new_rx_count);
 	/* if nothing to do return success */
 	if ((new_tx_count == adapter->tx_desc_count) &&
-	    (new_rx_count == adapter->rx_desc_count))
+	    (new_rx_count == adapter->rx_desc_count)) {
+		netdev_dbg(netdev, "Nothing to change, descriptor count is same as requested\n");
 		return 0;
+	}
-	adapter->tx_desc_count = new_tx_count;
+	if (new_tx_count != adapter->tx_desc_count) {
-	adapter->rx_desc_count = new_rx_count;
+		netdev_dbg(netdev, "Changing Tx descriptor count from %d to %d\n",
+			   adapter->tx_desc_count, new_tx_count);
+		adapter->tx_desc_count = new_tx_count;
+	}
+	if (new_rx_count != adapter->rx_desc_count) {
+		netdev_dbg(netdev, "Changing Rx descriptor count from %d to %d\n",
+			   adapter->rx_desc_count, new_rx_count);
+		adapter->rx_desc_count = new_rx_count;
+	}
 	if (netif_running(netdev)) {
 		adapter->flags |= IAVF_FLAG_RESET_NEEDED;

drivers/net/ethernet/intel/iavf/iavf_main.c+1−0

@@ -2248,6 +2248,7 @@ static void iavf_reset_task(struct work_struct *work) · 2247 unmodified lines
2248	}	2248	}
2249		2249
2250	pci_set_master(adapter->pdev);	2250	pci_set_master(adapter->pdev);
		2251	pci_restore_msi_state(adapter->pdev);
2251		2252
2252	if (i == IAVF_RESET_WAIT_COMPLETE_COUNT) {	2253	if (i == IAVF_RESET_WAIT_COMPLETE_COUNT) {
2253	dev_err(&adapter->pdev->dev, "Reset never finished (%x)\n",	2254	dev_err(&adapter->pdev->dev, "Reset never finished (%x)\n",

drivers/net/ethernet/intel/ice/ice_dcb_nl.c+12−6

@@ -97,6 +97,9 @@ static int ice_dcbnl_setets(struct net_device netdev, struct ieee_ets ets) · 96 unmodified lines
97		97
98	new_cfg->etscfg.maxtcs = pf->hw.func_caps.common_cap.maxtc;	98	new_cfg->etscfg.maxtcs = pf->hw.func_caps.common_cap.maxtc;
99		99
		100	if (!bwcfg)
		101	new_cfg->etscfg.tcbwtable[0] = 100;
		102
100	if (!bwrec)	103	if (!bwrec)
101	new_cfg->etsrec.tcbwtable[0] = 100;	104	new_cfg->etsrec.tcbwtable[0] = 100;
102		105
@@ -167,15 +170,18 @@ static u8 ice_dcbnl_setdcbx(struct net_device *netdev, u8 mode) · 64 unmodified lines
167	if (mode == pf->dcbx_cap)	170	if (mode == pf->dcbx_cap)
168	return ICE_DCB_NO_HW_CHG;	171	return ICE_DCB_NO_HW_CHG;
169		172
170	pf->dcbx_cap = mode;
171	qos_cfg = &pf->hw.port_info->qos_cfg;	173	qos_cfg = &pf->hw.port_info->qos_cfg;
172	if (mode & DCB_CAP_DCBX_VER_CEE) {	174
173	if (qos_cfg->local_dcbx_cfg.pfc_mode == ICE_QOS_MODE_DSCP)	175	/* DSCP configuration is not DCBx negotiated */
174	return ICE_DCB_NO_HW_CHG;	176	if (qos_cfg->local_dcbx_cfg.pfc_mode == ICE_QOS_MODE_DSCP)
		177	return ICE_DCB_NO_HW_CHG;
		178
		179	pf->dcbx_cap = mode;
		180
		181	if (mode & DCB_CAP_DCBX_VER_CEE)
175	qos_cfg->local_dcbx_cfg.dcbx_mode = ICE_DCBX_MODE_CEE;	182	qos_cfg->local_dcbx_cfg.dcbx_mode = ICE_DCBX_MODE_CEE;
176	} else {	183	else
177	qos_cfg->local_dcbx_cfg.dcbx_mode = ICE_DCBX_MODE_IEEE;	184	qos_cfg->local_dcbx_cfg.dcbx_mode = ICE_DCBX_MODE_IEEE;
178	}
179		185
180	dev_info(ice_pf_to_dev(pf), "DCBx mode = 0x%x\n", mode);	186	dev_info(ice_pf_to_dev(pf), "DCBx mode = 0x%x\n", mode);
181	return ICE_DCB_HW_CHG_RST;	187	return ICE_DCB_HW_CHG_RST;

drivers/net/ethernet/intel/ice/ice_ethtool_fdir.c+2−2

@@ -1268,7 +1268,7 @@ ice_fdir_write_all_fltr(struct ice_pf pf, struct ice_fdir_fltr input, · 1267 unmodified lines
1268	bool is_tun = tun == ICE_FD_HW_SEG_TUN;	1268	bool is_tun = tun == ICE_FD_HW_SEG_TUN;
1269	int err;	1269	int err;
1270		1270
1271	if (is_tun && !ice_get_open_tunnel_port(&pf->hw, &port_num))	1271	if (is_tun && !ice_get_open_tunnel_port(&pf->hw, &port_num, TNL_ALL))
1272	continue;	1272	continue;
1273	err = ice_fdir_write_fltr(pf, input, add, is_tun);	1273	err = ice_fdir_write_fltr(pf, input, add, is_tun);
1274	if (err)	1274	if (err)
@@ -1652,7 +1652,7 @@ int ice_add_fdir_ethtool(struct ice_vsi vsi, struct ethtool_rxnfc cmd) · 377 unmodified lines
1652	}	1652	}
1653		1653
1654	/* return error if not an update and no available filters */	1654	/* return error if not an update and no available filters */
1655	fltrs_needed = ice_get_open_tunnel_port(hw, &tunnel_port) ? 2 : 1;	1655	fltrs_needed = ice_get_open_tunnel_port(hw, &tunnel_port, TNL_ALL) ? 2 : 1;
1656	if (!ice_fdir_find_fltr_by_idx(hw, fsp->location) &&	1656	if (!ice_fdir_find_fltr_by_idx(hw, fsp->location) &&
1657	ice_fdir_num_avail_fltr(hw, pf->vsi[vsi->idx]) < fltrs_needed) {	1657	ice_fdir_num_avail_fltr(hw, pf->vsi[vsi->idx]) < fltrs_needed) {
1658	dev_err(dev, "Failed to add filter. The maximum number of flow director filters has been reached.\n");	1658	dev_err(dev, "Failed to add filter. The maximum number of flow director filters has been reached.\n");

drivers/net/ethernet/intel/ice/ice_fdir.c+1−1

@@ -924,7 +924,7 @@ ice_fdir_get_gen_prgm_pkt(struct ice_hw hw, struct ice_fdir_fltr input, · 923 unmodified lines
924	memcpy(pkt, ice_fdir_pkt[idx].pkt, ice_fdir_pkt[idx].pkt_len);	924	memcpy(pkt, ice_fdir_pkt[idx].pkt, ice_fdir_pkt[idx].pkt_len);
925	loc = pkt;	925	loc = pkt;
926	} else {	926	} else {
927	if (!ice_get_open_tunnel_port(hw, &tnl_port))	927	if (!ice_get_open_tunnel_port(hw, &tnl_port, TNL_ALL))
928	return ICE_ERR_DOES_NOT_EXIST;	928	return ICE_ERR_DOES_NOT_EXIST;
929	if (!ice_fdir_pkt[idx].tun_pkt)	929	if (!ice_fdir_pkt[idx].tun_pkt)
930	return ICE_ERR_PARAM;	930	return ICE_ERR_PARAM;

drivers/net/ethernet/intel/ice/ice_flex_pipe.c+5−2

  * ice_get_open_tunnel_port - retrieve an open tunnel port
  * @hw: pointer to the HW structure
  * @port: returns open port
+ * @type: type of tunnel, can be TNL_LAST if it doesn't matter
  */
 bool
-ice_get_open_tunnel_port(struct ice_hw *hw, u16 *port)
+ice_get_open_tunnel_port(struct ice_hw *hw, u16 *port,
+			 enum ice_tunnel_type type)
 {
 	bool res = false;
 	u16 i;
 	mutex_lock(&hw->tnl_lock);
 	for (i = 0; i < hw->tnl.count && i < ICE_TUNNEL_MAX_ENTRIES; i++)
-		if (hw->tnl.tbl[i].valid && hw->tnl.tbl[i].port) {
+		if (hw->tnl.tbl[i].valid && hw->tnl.tbl[i].port &&
+		    (type == TNL_LAST || type == hw->tnl.tbl[i].type)) {
 			*port = hw->tnl.tbl[i].port;
 			res = true;
 			break;

drivers/net/ethernet/intel/ice/ice_flex_pipe.h+2−1

 ice_get_sw_fv_list(struct ice_hw *hw, u8 *prot_ids, u16 ids_cnt,
 		   unsigned long *bm, struct list_head *fv_list);
 bool
-ice_get_open_tunnel_port(struct ice_hw *hw, u16 *port);
+ice_get_open_tunnel_port(struct ice_hw *hw, u16 *port,
+			 enum ice_tunnel_type type);
 int ice_udp_tunnel_set_port(struct net_device *netdev, unsigned int table,
 			    unsigned int idx, struct udp_tunnel_info *ti);
 int ice_udp_tunnel_unset_port(struct net_device *netdev, unsigned int table,

drivers/net/ethernet/intel/ice/ice_main.c+21−11

 		netif_carrier_on(vsi->netdev);
 	}
+	/* clear this now, and the first stats read will be used as baseline */
+	vsi->stat_offsets_loaded = false;
 	ice_service_task_schedule(pf);
 	return 0;
 /**
  * ice_update_vsi_tx_ring_stats - Update VSI Tx ring stats counters
  * @vsi: the VSI to be updated
+ * @vsi_stats: the stats struct to be updated
  * @rings: rings to work on
  * @count: number of rings
  */
 static void
-ice_update_vsi_tx_ring_stats(struct ice_vsi *vsi, struct ice_tx_ring **rings,
+ice_update_vsi_tx_ring_stats(struct ice_vsi *vsi,
-			     u16 count)
+			     struct rtnl_link_stats64 *vsi_stats,
+			     struct ice_tx_ring **rings, u16 count)
 {
-	struct rtnl_link_stats64 *vsi_stats = &vsi->net_stats;
 	u16 i;
 	for (i = 0; i < count; i++) {
  */
 static void ice_update_vsi_ring_stats(struct ice_vsi *vsi)
 {
-	struct rtnl_link_stats64 *vsi_stats = &vsi->net_stats;
+	struct rtnl_link_stats64 *vsi_stats;
 	u64 pkts, bytes;
 	int i;
-	/* reset netdev stats */
+	vsi_stats = kzalloc(sizeof(*vsi_stats), GFP_ATOMIC);
-	vsi_stats->tx_packets = 0;
+	if (!vsi_stats)
-	vsi_stats->tx_bytes = 0;
+		return;
-	vsi_stats->rx_packets = 0;
-	vsi_stats->rx_bytes = 0;
 	/* reset non-netdev (extended) stats */
 	vsi->tx_restart = 0;
 	rcu_read_lock();
 	/* update Tx rings counters */
-	ice_update_vsi_tx_ring_stats(vsi, vsi->tx_rings, vsi->num_txq);
+	ice_update_vsi_tx_ring_stats(vsi, vsi_stats, vsi->tx_rings,
+				     vsi->num_txq);
 	/* update Rx rings counters */
 	ice_for_each_rxq(vsi, i) {
 	/* update XDP Tx rings counters */
 	if (ice_is_xdp_ena_vsi(vsi))
-		ice_update_vsi_tx_ring_stats(vsi, vsi->xdp_rings,
+		ice_update_vsi_tx_ring_stats(vsi, vsi_stats, vsi->xdp_rings,
 					     vsi->num_xdp_txq);
 	rcu_read_unlock();
+	vsi->net_stats.tx_packets = vsi_stats->tx_packets;
+	vsi->net_stats.tx_bytes = vsi_stats->tx_bytes;
+	vsi->net_stats.rx_packets = vsi_stats->rx_packets;
+	vsi->net_stats.rx_bytes = vsi_stats->rx_bytes;
+	kfree(vsi_stats);
 }
 /**

drivers/net/ethernet/intel/ice/ice_switch.c+13−6

  * ice_find_recp - find a recipe
  * @hw: pointer to the hardware structure
  * @lkup_exts: extension sequence to match
+ * @tun_type: type of recipe tunnel
  *
  * Returns index of matching recipe, or ICE_MAX_NUM_RECIPES if not found.
  */
-static u16 ice_find_recp(struct ice_hw *hw, struct ice_prot_lkup_ext *lkup_exts)
+static u16
+ice_find_recp(struct ice_hw *hw, struct ice_prot_lkup_ext *lkup_exts,
+	      enum ice_sw_tunnel_type tun_type)
 {
 	bool refresh_required = true;
 	struct ice_sw_recipe *recp;
 			}
 			/* If for "i"th recipe the found was never set to false
 			 * then it means we found our match
+			 * Also tun type of recipe needs to be checked
 			 */
-			if (found)
+			if (found && recp[i].tun_type == tun_type)
 				return i; /* Return the recipe ID */
 		}
 	}
 	}
 	/* Look for a recipe which matches our requested fv / mask list */
-	*rid = ice_find_recp(hw, lkup_exts);
+	*rid = ice_find_recp(hw, lkup_exts, rinfo->tun_type);
 	if (*rid < ICE_MAX_NUM_RECIPES)
 		/* Success if found a recipe that match the existing criteria */
 		goto err_unroll;
+	rm->tun_type = rinfo->tun_type;
 	/* Recipe we need does not exist, add a recipe */
 	status = ice_add_sw_recipe(hw, rm, profiles);
 	if (status)
 	switch (tun_type) {
 	case ICE_SW_TUN_VXLAN:
+		if (!ice_get_open_tunnel_port(hw, &open_port, TNL_VXLAN))
+			return ICE_ERR_CFG;
+		break;
 	case ICE_SW_TUN_GENEVE:
-		if (!ice_get_open_tunnel_port(hw, &open_port))
+		if (!ice_get_open_tunnel_port(hw, &open_port, TNL_GENEVE))
 			return ICE_ERR_CFG;
 		break;
 	default:
 		/* Nothing needs to be done for this tunnel type */
 		return 0;
 	if (status)
 		return status;
-	rid = ice_find_recp(hw, &lkup_exts);
+	rid = ice_find_recp(hw, &lkup_exts, rinfo->tun_type);
 	/* If did not find a recipe that match the existing criteria */
 	if (rid == ICE_MAX_NUM_RECIPES)
 		return ICE_ERR_PARAM;

drivers/net/ethernet/intel/ice/ice_tc_lib.c+12−18

 	return inner ? ICE_IPV6_IL : ICE_IPV6_OFOS;
 }
-static enum ice_protocol_type
+static enum ice_protocol_type ice_proto_type_from_l4_port(u16 ip_proto)
-ice_proto_type_from_l4_port(bool inner, u16 ip_proto)
 {
-	if (inner) {
+	switch (ip_proto) {
-		switch (ip_proto) {
+	case IPPROTO_TCP:
-		case IPPROTO_UDP:
+		return ICE_TCP_IL;
-			return ICE_UDP_ILOS;
+	case IPPROTO_UDP:
-		}
+		return ICE_UDP_ILOS;
-	} else {
-		switch (ip_proto) {
-		case IPPROTO_TCP:
-			return ICE_TCP_IL;
-		case IPPROTO_UDP:
-			return ICE_UDP_OF;
-		}
 	}
 	return 0;
 		i++;
 	}
-	if (flags & ICE_TC_FLWR_FIELD_ENC_DEST_L4_PORT) {
+	if ((flags & ICE_TC_FLWR_FIELD_ENC_DEST_L4_PORT) &&
-		list[i].type = ice_proto_type_from_l4_port(false, hdr->l3_key.ip_proto);
+	    hdr->l3_key.ip_proto == IPPROTO_UDP) {
+		list[i].type = ICE_UDP_OF;
 		list[i].h_u.l4_hdr.dst_port = hdr->l4_key.dst_port;
 		list[i].m_u.l4_hdr.dst_port = hdr->l4_mask.dst_port;
 		i++;
 		     ICE_TC_FLWR_FIELD_SRC_L4_PORT)) {
 		struct ice_tc_l4_hdr *l4_key, *l4_mask;
-		list[i].type = ice_proto_type_from_l4_port(inner, headers->l3_key.ip_proto);
+		list[i].type = ice_proto_type_from_l4_port(headers->l3_key.ip_proto);
 		l4_key = &headers->l4_key;
 		l4_mask = &headers->l4_mask;
 		headers->l3_mask.ttl = match.mask->ttl;
 	}
-	if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_ENC_PORTS)) {
+	if (flow_rule_match_key(rule, FLOW_DISSECTOR_KEY_ENC_PORTS) &&
+	    fltr->tunnel_type != TNL_VXLAN && fltr->tunnel_type != TNL_GENEVE) {
 		struct flow_match_ports match;
 		flow_rule_match_enc_ports(rule, &match);

drivers/net/ethernet/intel/ice/ice_virtchnl_pf.c+6−0

 		ice_vc_set_default_allowlist(vf);
 		ice_vf_fdir_exit(vf);
+		ice_vf_fdir_init(vf);
 		/* clean VF control VSI when resetting VFs since it should be
 		 * setup only when VF creates its first FDIR rule.
 		 */
 	}
 	ice_vf_fdir_exit(vf);
+	ice_vf_fdir_init(vf);
 	/* clean VF control VSI when resetting VF since it should be setup
 	 * only when VF creates its first FDIR rule.
 	 */
 	if (ret)
 		goto err_unroll_sriov;
+	/* rearm global interrupts */
+	if (test_and_clear_bit(ICE_OICR_INTR_DIS, pf->state))
+		ice_irq_dynamic_ena(hw, NULL, NULL);
 	return 0;
 err_unroll_sriov:

drivers/net/ethernet/intel/ice/ice_xsk.c+1−0

@@ -383,6 +383,7 @@ bool ice_alloc_rx_bufs_zc(struct ice_rx_ring *rx_ring, u16 count) · 382 unmodified lines
383	while (i--) {	383	while (i--) {
384	dma = xsk_buff_xdp_get_dma(*xdp);	384	dma = xsk_buff_xdp_get_dma(*xdp);
385	rx_desc->read.pkt_addr = cpu_to_le64(dma);	385	rx_desc->read.pkt_addr = cpu_to_le64(dma);
		386	rx_desc->wb.status_error0 = 0;
386		387
387	rx_desc++;	388	rx_desc++;
388	xdp++;	389	xdp++;

drivers/net/ethernet/marvell/mvpp2/mvpp2_main.c+3−3

@@ -2960,11 +2960,11 @@ static int mvpp2_rxq_init(struct mvpp2_port *port, · 2959 unmodified lines
2960	mvpp2_rxq_status_update(port, rxq->id, 0, rxq->size);	2960	mvpp2_rxq_status_update(port, rxq->id, 0, rxq->size);
2961		2961
2962	if (priv->percpu_pools) {	2962	if (priv->percpu_pools) {
2963	err = xdp_rxq_info_reg(&rxq->xdp_rxq_short, port->dev, rxq->id, 0);	2963	err = xdp_rxq_info_reg(&rxq->xdp_rxq_short, port->dev, rxq->logic_rxq, 0);
2964	if (err < 0)	2964	if (err < 0)
2965	goto err_free_dma;	2965	goto err_free_dma;
2966		2966
2967	err = xdp_rxq_info_reg(&rxq->xdp_rxq_long, port->dev, rxq->id, 0);	2967	err = xdp_rxq_info_reg(&rxq->xdp_rxq_long, port->dev, rxq->logic_rxq, 0);
2968	if (err < 0)	2968	if (err < 0)
2969	goto err_unregister_rxq_short;	2969	goto err_unregister_rxq_short;
2970		2970
@@ -7458,7 +7458,7 @@ static int mvpp2_probe(struct platform_device *pdev) · 4487 unmodified lines
7458		7458
7459	shared = num_present_cpus() - priv->nthreads;	7459	shared = num_present_cpus() - priv->nthreads;
7460	if (shared > 0)	7460	if (shared > 0)
7461	bitmap_fill(&priv->lock_map,	7461	bitmap_set(&priv->lock_map, 0,
7462	min_t(int, shared, MVPP2_MAX_THREADS));	7462	min_t(int, shared, MVPP2_MAX_THREADS));
7463		7463
7464	for (i = 0; i < MVPP2_MAX_THREADS; i++) {	7464	for (i = 0; i < MVPP2_MAX_THREADS; i++) {

drivers/net/ethernet/marvell/octeontx2/af/rvu.c+1−1

@@ -2341,7 +2341,7 @@ static int rvu_mbox_init(struct rvu rvu, struct mbox_wq_info mw, · 2340 unmodified lines
2341	goto free_regions;	2341	goto free_regions;
2342	break;	2342	break;
2343	default:	2343	default:
2344	return err;	2344	goto free_regions;
2345	}	2345	}
2346		2346
2347	mw->mbox_wq = alloc_workqueue(name,	2347	mw->mbox_wq = alloc_workqueue(name,

drivers/net/ethernet/marvell/octeontx2/nic/otx2_ptp.c+2−0

@@ -5,6 +5,8 @@ · 4 unmodified lines
5	*	5	*
6	*/	6	*/
7		7
		8	#include <linux/module.h>
		9
8	#include "otx2_common.h"	10	#include "otx2_common.h"
9	#include "otx2_ptp.h"	11	#include "otx2_ptp.h"
10		12

drivers/net/ethernet/mellanox/mlx4/en_ethtool.c+3−3

drivers/net/ethernet/mellanox/mlx4/en_netdev.c+7−2

 				bool carry_xdp_prog)
 {
 	struct bpf_prog *xdp_prog;
-	int i, t;
+	int i, t, ret;
-	mlx4_en_copy_priv(tmp, priv, prof);
+	ret = mlx4_en_copy_priv(tmp, priv, prof);
+	if (ret) {
+		en_warn(priv, "%s: mlx4_en_copy_priv() failed, return\n",
+			__func__);
+		return ret;
+	}
 	if (mlx4_en_alloc_resources(tmp)) {
 		en_warn(priv,

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

 	case MLX5_CMD_OP_DEALLOC_SF:
 	case MLX5_CMD_OP_DESTROY_UCTX:
 	case MLX5_CMD_OP_DESTROY_UMEM:
+	case MLX5_CMD_OP_MODIFY_RQT:
 		return MLX5_CMD_STAT_OK;
 	case MLX5_CMD_OP_QUERY_HCA_CAP:
 	case MLX5_CMD_OP_MODIFY_TIS:
 	case MLX5_CMD_OP_QUERY_TIS:
 	case MLX5_CMD_OP_CREATE_RQT:
-	case MLX5_CMD_OP_MODIFY_RQT:
 	case MLX5_CMD_OP_QUERY_RQT:
 	case MLX5_CMD_OP_CREATE_FLOW_TABLE:

drivers/net/ethernet/mellanox/mlx5/core/en/rx_res.c+40−1

 	unsigned int max_nch;
 	u32 drop_rqn;
+	struct mlx5e_packet_merge_param pkt_merge_param;
+	struct rw_semaphore pkt_merge_param_sem;
 	struct mlx5e_rss *rss[MLX5E_MAX_NUM_RSS];
 	bool rss_active;
 	u32 rss_rqns[MLX5E_INDIR_RQT_SIZE];
 	if (err)
 		goto out;
+	/* Separated from the channels RQs, does not share pkt_merge state with them */
 	mlx5e_tir_builder_build_rqt(builder, res->mdev->mlx5e_res.hw_objs.td.tdn,
 				    mlx5e_rqt_get_rqtn(&res->ptp.rqt),
 				    inner_ft_support);
 	res->max_nch = max_nch;
 	res->drop_rqn = drop_rqn;
+	res->pkt_merge_param = *init_pkt_merge_param;
+	init_rwsem(&res->pkt_merge_param_sem);
 	err = mlx5e_rx_res_rss_init_def(res, init_pkt_merge_param, init_nch);
 	if (err)
 		goto err_out;
 	return mlx5e_tir_get_tirn(&res->ptp.tir);
 }
-u32 mlx5e_rx_res_get_rqtn_direct(struct mlx5e_rx_res *res, unsigned int ix)
+static u32 mlx5e_rx_res_get_rqtn_direct(struct mlx5e_rx_res *res, unsigned int ix)
 {
 	return mlx5e_rqt_get_rqtn(&res->channels[ix].direct_rqt);
 }
 	if (!builder)
 		return -ENOMEM;
+	down_write(&res->pkt_merge_param_sem);
+	res->pkt_merge_param = *pkt_merge_param;
 	mlx5e_tir_builder_build_packet_merge(builder, pkt_merge_param);
 	final_err = 0;
 		}
 	}
+	up_write(&res->pkt_merge_param_sem);
 	mlx5e_tir_builder_free(builder);
 	return final_err;
 }
 {
 	return mlx5e_rss_get_hash(res->rss[0]);
 }
+int mlx5e_rx_res_tls_tir_create(struct mlx5e_rx_res *res, unsigned int rxq,
+				struct mlx5e_tir *tir)
+{
+	bool inner_ft_support = res->features & MLX5E_RX_RES_FEATURE_INNER_FT;
+	struct mlx5e_tir_builder *builder;
+	u32 rqtn;
+	int err;
+	builder = mlx5e_tir_builder_alloc(false);
+	if (!builder)
+		return -ENOMEM;
+	rqtn = mlx5e_rx_res_get_rqtn_direct(res, rxq);
+	mlx5e_tir_builder_build_rqt(builder, res->mdev->mlx5e_res.hw_objs.td.tdn, rqtn,
+				    inner_ft_support);
+	mlx5e_tir_builder_build_direct(builder);
+	mlx5e_tir_builder_build_tls(builder);
+	down_read(&res->pkt_merge_param_sem);
+	mlx5e_tir_builder_build_packet_merge(builder, &res->pkt_merge_param);
+	err = mlx5e_tir_init(tir, builder, res->mdev, false);
+	up_read(&res->pkt_merge_param_sem);
+	mlx5e_tir_builder_free(builder);
+	return err;
+}

drivers/net/ethernet/mellanox/mlx5/core/en/rx_res.h+3−3

 u32 mlx5e_rx_res_get_tirn_rss_inner(struct mlx5e_rx_res *res, enum mlx5_traffic_types tt);
 u32 mlx5e_rx_res_get_tirn_ptp(struct mlx5e_rx_res *res);
-/* RQTN getters for modules that create their own TIRs */
-u32 mlx5e_rx_res_get_rqtn_direct(struct mlx5e_rx_res *res, unsigned int ix);
 /* Activate/deactivate API */
 void mlx5e_rx_res_channels_activate(struct mlx5e_rx_res *res, struct mlx5e_channels *chs);
 void mlx5e_rx_res_channels_deactivate(struct mlx5e_rx_res *res);
 /* Workaround for hairpin */
 struct mlx5e_rss_params_hash mlx5e_rx_res_get_current_hash(struct mlx5e_rx_res *res);
+/* Accel TIRs */
+int mlx5e_rx_res_tls_tir_create(struct mlx5e_rx_res *res, unsigned int rxq,
+				struct mlx5e_tir *tir);
 #endif /* __MLX5_EN_RX_RES_H__ */

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

@@ -191,7 +191,7 @@ static void mlx5e_ipsec_set_swp(struct sk_buff *skb, · 190 unmodified lines
191	eseg->swp_inner_l3_offset = skb_inner_network_offset(skb) / 2;	191	eseg->swp_inner_l3_offset = skb_inner_network_offset(skb) / 2;
192	eseg->swp_inner_l4_offset =	192	eseg->swp_inner_l4_offset =
193	(skb->csum_start + skb->head - skb->data) / 2;	193	(skb->csum_start + skb->head - skb->data) / 2;
194	if (skb->protocol == htons(ETH_P_IPV6))	194	if (inner_ip_hdr(skb)->version == 6)
195	eseg->swp_flags \|= MLX5_ETH_WQE_SWP_INNER_L3_IPV6;	195	eseg->swp_flags \|= MLX5_ETH_WQE_SWP_INNER_L3_IPV6;
196	break;	196	break;
197	default:	197	default:

drivers/net/ethernet/mellanox/mlx5/core/en_accel/ktls_rx.c+1−23

@@ -100,25 +100,6 @@ mlx5e_ktls_rx_resync_create_resp_list(void) · 99 unmodified lines
100	return resp_list;	100	return resp_list;
101	}	101	}
102		102
103	static int mlx5e_ktls_create_tir(struct mlx5_core_dev mdev, struct mlx5e_tir tir, u32 rqtn)
104	{
105	struct mlx5e_tir_builder *builder;
106	int err;
107
108	builder = mlx5e_tir_builder_alloc(false);
109	if (!builder)
110	return -ENOMEM;
111
112	mlx5e_tir_builder_build_rqt(builder, mdev->mlx5e_res.hw_objs.td.tdn, rqtn, false);
113	mlx5e_tir_builder_build_direct(builder);
114	mlx5e_tir_builder_build_tls(builder);
115	err = mlx5e_tir_init(tir, builder, mdev, false);
116
117	mlx5e_tir_builder_free(builder);
118
119	return err;
120	}
121
122	static void accel_rule_handle_work(struct work_struct *work)	103	static void accel_rule_handle_work(struct work_struct *work)
123	{	104	{
124	struct mlx5e_ktls_offload_context_rx *priv_rx;	105	struct mlx5e_ktls_offload_context_rx *priv_rx;
@@ -609,7 +590,6 @@ int mlx5e_ktls_add_rx(struct net_device netdev, struct sock sk, · 484 unmodified lines
609	struct mlx5_core_dev *mdev;	590	struct mlx5_core_dev *mdev;
610	struct mlx5e_priv *priv;	591	struct mlx5e_priv *priv;
611	int rxq, err;	592	int rxq, err;
612	u32 rqtn;
613		593
614	tls_ctx = tls_get_ctx(sk);	594	tls_ctx = tls_get_ctx(sk);
615	priv = netdev_priv(netdev);	595	priv = netdev_priv(netdev);
@@ -635,9 +615,7 @@ int mlx5e_ktls_add_rx(struct net_device netdev, struct sock sk, · 19 unmodified lines
635	priv_rx->sw_stats = &priv->tls->sw_stats;	615	priv_rx->sw_stats = &priv->tls->sw_stats;
636	mlx5e_set_ktls_rx_priv_ctx(tls_ctx, priv_rx);	616	mlx5e_set_ktls_rx_priv_ctx(tls_ctx, priv_rx);
637		617
638	rqtn = mlx5e_rx_res_get_rqtn_direct(priv->rx_res, rxq);	618	err = mlx5e_rx_res_tls_tir_create(priv->rx_res, rxq, &priv_rx->tir);
639
640	err = mlx5e_ktls_create_tir(mdev, &priv_rx->tir, rqtn);
641	if (err)	619	if (err)
642	goto err_create_tir;	620	goto err_create_tir;
643		621

drivers/net/ethernet/mellanox/mlx5/core/en_rep.c+4−0

 	&MLX5E_STATS_GRP(pme),
 	&MLX5E_STATS_GRP(channels),
 	&MLX5E_STATS_GRP(per_port_buff_congest),
+#ifdef CONFIG_MLX5_EN_IPSEC
+	&MLX5E_STATS_GRP(ipsec_sw),
+	&MLX5E_STATS_GRP(ipsec_hw),
+#endif
 };
 static unsigned int mlx5e_ul_rep_stats_grps_num(struct mlx5e_priv *priv)

drivers/net/ethernet/mellanox/mlx5/core/en_rx.c+3−5

 				     u16 klm_entries, u16 index)
 {
 	struct mlx5e_shampo_hd *shampo = rq->mpwqe.shampo;
-	u16 entries, pi, i, header_offset, err, wqe_bbs, new_entries;
+	u16 entries, pi, header_offset, err, wqe_bbs, new_entries;
 	u32 lkey = rq->mdev->mlx5e_res.hw_objs.mkey;
 	struct page *page = shampo->last_page;
 	u64 addr = shampo->last_addr;
 	struct mlx5e_dma_info *dma_info;
 	struct mlx5e_umr_wqe *umr_wqe;
-	int headroom;
+	int headroom, i;
 	headroom = rq->buff.headroom;
 	new_entries = klm_entries - (shampo->pi & (MLX5_UMR_KLM_ALIGNMENT - 1));
 err_unmap:
 	while (--i >= 0) {
-		if (--index < 0)
+		dma_info = &shampo->info[--index];
-			index = shampo->hd_per_wq - 1;
-		dma_info = &shampo->info[index];
 		if (!(i & (MLX5E_SHAMPO_WQ_HEADER_PER_PAGE - 1))) {
 			dma_info->addr = ALIGN_DOWN(dma_info->addr, PAGE_SIZE);
 			mlx5e_page_release(rq, dma_info, true);

drivers/net/ethernet/mellanox/mlx5/core/esw/qos.c+2−2

@@ -130,7 +130,7 @@ static u32 esw_qos_calculate_min_rate_divider(struct mlx5_eswitch *esw, · 129 unmodified lines
130	/* If vports min rate divider is 0 but their group has bw_share configured, then	130	/* If vports min rate divider is 0 but their group has bw_share configured, then
131	* need to set bw_share for vports to minimal value.	131	* need to set bw_share for vports to minimal value.
132	*/	132	*/
133	if (!group_level && !max_guarantee && group->bw_share)	133	if (!group_level && !max_guarantee && group && group->bw_share)
134	return 1;	134	return 1;
135	return 0;	135	return 0;
136	}	136	}
@@ -423,7 +423,7 @@ static int esw_qos_vport_update_group(struct mlx5_eswitch *esw, · 286 unmodified lines
423	return err;	423	return err;
424		424
425	/* Recalculate bw share weights of old and new groups */	425	/* Recalculate bw share weights of old and new groups */
426	if (vport->qos.bw_share) {	426	if (vport->qos.bw_share \|\| new_group->bw_share) {
427	esw_qos_normalize_vports_min_rate(esw, curr_group, extack);	427	esw_qos_normalize_vports_min_rate(esw, curr_group, extack);
428	esw_qos_normalize_vports_min_rate(esw, new_group, extack);	428	esw_qos_normalize_vports_min_rate(esw, new_group, extack);
429	}	429	}

drivers/net/ethernet/mellanox/mlx5/core/eswitch_offloads.c+16−4

 esw_is_indir_table(struct mlx5_eswitch *esw, struct mlx5_flow_attr *attr)
 {
 	struct mlx5_esw_flow_attr *esw_attr = attr->esw_attr;
+	bool result = false;
 	int i;
-	for (i = esw_attr->split_count; i < esw_attr->out_count; i++)
+	/* Indirect table is supported only for flows with in_port uplink
+	 * and the destination is vport on the same eswitch as the uplink,
+	 * return false in case at least one of destinations doesn't meet
+	 * this criteria.
+	 */
+	for (i = esw_attr->split_count; i < esw_attr->out_count; i++) {
 		if (esw_attr->dests[i].rep &&
 		    mlx5_esw_indir_table_needed(esw, attr, esw_attr->dests[i].rep->vport,
-						esw_attr->dests[i].mdev))
+						esw_attr->dests[i].mdev)) {
-			return true;
+			result = true;
-	return false;
+		} else {
+			result = false;
+			break;
+		}
+	}
+	return result;
 }
 static int
 	struct mlx5_eswitch *esw = master->priv.eswitch;
 	struct mlx5_flow_table_attr ft_attr = {
 		.max_fte = 1, .prio = 0, .level = 0,
+		.flags = MLX5_FLOW_TABLE_OTHER_VPORT,
 	};
 	struct mlx5_flow_namespace *egress_ns;
 	struct mlx5_flow_table *acl;

drivers/net/ethernet/mellanox/mlx5/core/health.c+3−2

 	health->timer.expires = jiffies + msecs_to_jiffies(poll_interval_ms);
 	add_timer(&health->timer);
+	if (mlx5_core_is_pf(dev) && MLX5_CAP_MCAM_REG(dev, mrtc))
+		queue_delayed_work(health->wq, &health->update_fw_log_ts_work, 0);
 }
 void mlx5_stop_health_poll(struct mlx5_core_dev *dev, bool disable_health)
 	INIT_WORK(&health->fatal_report_work, mlx5_fw_fatal_reporter_err_work);
 	INIT_WORK(&health->report_work, mlx5_fw_reporter_err_work);
 	INIT_DELAYED_WORK(&health->update_fw_log_ts_work, mlx5_health_log_ts_update);
-	if (mlx5_core_is_pf(dev))
-		queue_delayed_work(health->wq, &health->update_fw_log_ts_work, 0);
 	return 0;

drivers/net/ethernet/mellanox/mlx5/core/lag/port_sel.c+1−0

@@ -608,4 +608,5 @@ void mlx5_lag_port_sel_destroy(struct mlx5_lag *ldev) · 607 unmodified lines
608	if (port_sel->tunnel)	608	if (port_sel->tunnel)
609	mlx5_destroy_ttc_table(port_sel->inner.ttc);	609	mlx5_destroy_ttc_table(port_sel->inner.ttc);
610	mlx5_lag_destroy_definers(ldev);	610	mlx5_lag_destroy_definers(ldev);
		611	memset(port_sel, 0, sizeof(*port_sel));
611	}	612	}

drivers/net/ethernet/mellanox/mlx5/core/lib/tout.c+2−3

 	dev->timeouts->to[type] = val;
 }
-static void tout_set_def_val(struct mlx5_core_dev *dev)
+void mlx5_tout_set_def_val(struct mlx5_core_dev *dev)
 {
 	int i;
-	for (i = MLX5_TO_FW_PRE_INIT_TIMEOUT_MS; i < MAX_TIMEOUT_TYPES; i++)
+	for (i = 0; i < MAX_TIMEOUT_TYPES; i++)
 		tout_set(dev, tout_def_sw_val[i], i);
 }
 	if (!dev->timeouts)
 		return -ENOMEM;
-	tout_set_def_val(dev);
 	return 0;
 }

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

@@ -34,6 +34,7 @@ int mlx5_tout_init(struct mlx5_core_dev *dev); · 33 unmodified lines
34	void mlx5_tout_cleanup(struct mlx5_core_dev *dev);	34	void mlx5_tout_cleanup(struct mlx5_core_dev *dev);
35	void mlx5_tout_query_iseg(struct mlx5_core_dev *dev);	35	void mlx5_tout_query_iseg(struct mlx5_core_dev *dev);
36	int mlx5_tout_query_dtor(struct mlx5_core_dev *dev);	36	int mlx5_tout_query_dtor(struct mlx5_core_dev *dev);
		37	void mlx5_tout_set_def_val(struct mlx5_core_dev *dev);
37	u64 _mlx5_tout_ms(struct mlx5_core_dev *dev, enum mlx5_timeouts_types type);	38	u64 _mlx5_tout_ms(struct mlx5_core_dev *dev, enum mlx5_timeouts_types type);
38		39
39	#define mlx5_tout_ms(dev, type) _mlx5_tout_ms(dev, MLX5_TO_##type##_MS)	40	#define mlx5_tout_ms(dev, type) _mlx5_tout_ms(dev, MLX5_TO_##type##_MS)

drivers/net/ethernet/mellanox/mlx5/core/main.c+15−15

 	if (mlx5_core_is_pf(dev))
 		pcie_print_link_status(dev->pdev);
-	err = mlx5_tout_init(dev);
+	mlx5_tout_set_def_val(dev);
-	if (err) {
-		mlx5_core_err(dev, "Failed initializing timeouts, aborting\n");
-		return err;
-	}
 	/* wait for firmware to accept initialization segments configurations
 	 */
 	if (err) {
 		mlx5_core_err(dev, "Firmware over %llu MS in pre-initializing state, aborting\n",
 			      mlx5_tout_ms(dev, FW_PRE_INIT_TIMEOUT));
-		goto err_tout_cleanup;
+		return err;
 	}
 	err = mlx5_cmd_init(dev);
 	if (err) {
 		mlx5_core_err(dev, "Failed initializing command interface, aborting\n");
-		goto err_tout_cleanup;
+		return err;
 	}
 	mlx5_tout_query_iseg(dev);
 	mlx5_set_driver_version(dev);
-	mlx5_start_health_poll(dev);
 	err = mlx5_query_hca_caps(dev);
 	if (err) {
 		mlx5_core_err(dev, "query hca failed\n");
-		goto stop_health;
+		goto reclaim_boot_pages;
 	}
+	mlx5_start_health_poll(dev);
 	return 0;
-stop_health:
-	mlx5_stop_health_poll(dev, boot);
 reclaim_boot_pages:
 	mlx5_reclaim_startup_pages(dev);
 err_disable_hca:
 err_cmd_cleanup:
 	mlx5_cmd_set_state(dev, MLX5_CMDIF_STATE_DOWN);
 	mlx5_cmd_cleanup(dev);
-err_tout_cleanup:
-	mlx5_tout_cleanup(dev);
 	return err;
 }
 	mlx5_core_disable_hca(dev, 0);
 	mlx5_cmd_set_state(dev, MLX5_CMDIF_STATE_DOWN);
 	mlx5_cmd_cleanup(dev);
-	mlx5_tout_cleanup(dev);
 	return 0;
 }
 					    mlx5_debugfs_root);
 	INIT_LIST_HEAD(&priv->traps);
+	err = mlx5_tout_init(dev);
+	if (err) {
+		mlx5_core_err(dev, "Failed initializing timeouts, aborting\n");
+		goto err_timeout_init;
+	}
 	err = mlx5_health_init(dev);
 	if (err)
 		goto err_health_init;
 err_pagealloc_init:
 	mlx5_health_cleanup(dev);
 err_health_init:
+	mlx5_tout_cleanup(dev);
+err_timeout_init:
 	debugfs_remove(dev->priv.dbg_root);
 	mutex_destroy(&priv->pgdir_mutex);
 	mutex_destroy(&priv->alloc_mutex);
 	mlx5_adev_cleanup(dev);
 	mlx5_pagealloc_cleanup(dev);
 	mlx5_health_cleanup(dev);
+	mlx5_tout_cleanup(dev);
 	debugfs_remove_recursive(dev->priv.dbg_root);
 	mutex_destroy(&priv->pgdir_mutex);
 	mutex_destroy(&priv->alloc_mutex);

drivers/net/ethernet/microsoft/mana/hw_channel.c+5−5

 	if (err)
 		goto out;
-	err = mana_hwc_alloc_dma_buf(hwc, q_depth, max_msg_size,
-				     &hwc_wq->msg_buf);
-	if (err)
-		goto out;
 	hwc_wq->hwc = hwc;
 	hwc_wq->gdma_wq = queue;
 	hwc_wq->queue_depth = q_depth;
 	hwc_wq->hwc_cq = hwc_cq;
+	err = mana_hwc_alloc_dma_buf(hwc, q_depth, max_msg_size,
+				     &hwc_wq->msg_buf);
+	if (err)
+		goto out;
 	*hwc_wq_ptr = hwc_wq;
 	return 0;
 out:

drivers/net/ethernet/mscc/ocelot.c+3−1

 	}
 	err = ocelot_setup_ptp_traps(ocelot, port, l2, l4);
-	if (err)
+	if (err) {
+		mutex_unlock(&ocelot->ptp_lock);
 		return err;
+	}
 	if (l2 && l4)
 		cfg.rx_filter = HWTSTAMP_FILTER_PTP_V2_EVENT;

drivers/net/ethernet/natsemi/xtsonic.c+1−1

@@ -120,7 +120,7 @@ static const struct net_device_ops xtsonic_netdev_ops = { · 119 unmodified lines
120	.ndo_set_mac_address = eth_mac_addr,	120	.ndo_set_mac_address = eth_mac_addr,
121	};	121	};
122		122
123	static int __init sonic_probe1(struct net_device *dev)	123	static int sonic_probe1(struct net_device *dev)
124	{	124	{
125	unsigned int silicon_revision;	125	unsigned int silicon_revision;
126	struct sonic_local *lp = netdev_priv(dev);	126	struct sonic_local *lp = netdev_priv(dev);

drivers/net/ethernet/netronome/nfp/nfpcore/nfp_cppcore.c+3−1

 		return -ENOMEM;
 	cache = kzalloc(sizeof(*cache), GFP_KERNEL);
-	if (!cache)
+	if (!cache) {
+		nfp_cpp_area_free(area);
 		return -ENOMEM;
+	}
 	cache->id = 0;
 	cache->addr = 0;

drivers/net/ethernet/qlogic/qede/qede_fp.c+7−0

@@ -1643,6 +1643,13 @@ netdev_tx_t qede_start_xmit(struct sk_buff skb, struct net_device ndev) · 1642 unmodified lines
1643	data_split = true;	1643	data_split = true;
1644	}	1644	}
1645	} else {	1645	} else {
		1646	if (unlikely(skb->len > ETH_TX_MAX_NON_LSO_PKT_LEN)) {
		1647	DP_ERR(edev, "Unexpected non LSO skb length = 0x%x\n", skb->len);
		1648	qede_free_failed_tx_pkt(txq, first_bd, 0, false);
		1649	qede_update_tx_producer(txq);
		1650	return NETDEV_TX_OK;
		1651	}
		1652
1646	val \|= ((skb->len & ETH_TX_DATA_1ST_BD_PKT_LEN_MASK) <<	1653	val \|= ((skb->len & ETH_TX_DATA_1ST_BD_PKT_LEN_MASK) <<
1647	ETH_TX_DATA_1ST_BD_PKT_LEN_SHIFT);	1654	ETH_TX_DATA_1ST_BD_PKT_LEN_SHIFT);
1648	}	1655	}

drivers/net/ethernet/qlogic/qla3xxx.c+9−10

 	spin_lock_irqsave(&qdev->hw_lock, hw_flags);
-	err = ql_wait_for_drvr_lock(qdev);
+	if (!ql_wait_for_drvr_lock(qdev)) {
-	if (err) {
-		err = ql_adapter_initialize(qdev);
-		if (err) {
-			netdev_err(ndev, "Unable to initialize adapter\n");
-			goto err_init;
-		}
-		netdev_err(ndev, "Releasing driver lock\n");
-		ql_sem_unlock(qdev, QL_DRVR_SEM_MASK);
-	} else {
 		netdev_err(ndev, "Could not acquire driver lock\n");
+		err = -ENODEV;
 		goto err_lock;
 	}
+	err = ql_adapter_initialize(qdev);
+	if (err) {
+		netdev_err(ndev, "Unable to initialize adapter\n");
+		goto err_init;
+	}
+	ql_sem_unlock(qdev, QL_DRVR_SEM_MASK);
 	spin_unlock_irqrestore(&qdev->hw_lock, hw_flags);
 	set_bit(QL_ADAPTER_UP, &qdev->flags);

drivers/net/ethernet/qlogic/qlcnic/qlcnic_83xx_hw.c+8−2

 	sds_mbx_size = sizeof(struct qlcnic_sds_mbx);
 	context_id = recv_ctx->context_id;
 	num_sds = adapter->drv_sds_rings - QLCNIC_MAX_SDS_RINGS;
-	ahw->hw_ops->alloc_mbx_args(&cmd, adapter,
+	err = ahw->hw_ops->alloc_mbx_args(&cmd, adapter,
-				    QLCNIC_CMD_ADD_RCV_RINGS);
+					QLCNIC_CMD_ADD_RCV_RINGS);
+	if (err) {
+		dev_err(&adapter->pdev->dev,
+			"Failed to alloc mbx args %d\n", err);
+		return err;
+	}
 	cmd.req.arg[1] = 0 | (num_sds << 8) | (context_id << 16);
 	/* set up status rings, mbx 2-81 */

drivers/net/ethernet/stmicro/stmmac/stmmac_main.c+6−5

 			       netdev_features_t features)
 {
 	struct stmmac_priv *priv = netdev_priv(netdev);
-	bool sph_en;
-	u32 chan;
 	/* Keep the COE Type in case of csum is supporting */
 	if (features & NETIF_F_RXCSUM)
 	 */
 	stmmac_rx_ipc(priv, priv->hw);
-	sph_en = (priv->hw->rx_csum > 0) && priv->sph;
+	if (priv->sph_cap) {
+		bool sph_en = (priv->hw->rx_csum > 0) && priv->sph;
+		u32 chan;
-	for (chan = 0; chan < priv->plat->rx_queues_to_use; chan++)
+		for (chan = 0; chan < priv->plat->rx_queues_to_use; chan++)
-		stmmac_enable_sph(priv, priv->ioaddr, sph_en, chan);
+			stmmac_enable_sph(priv, priv->ioaddr, sph_en, chan);
+	}
 	return 0;
 }

drivers/net/phy/phylink.c+1−0

@@ -1388,6 +1388,7 @@ EXPORT_SYMBOL_GPL(phylink_stop); · 1387 unmodified lines
1388	* @mac_wol: true if the MAC needs to receive packets for Wake-on-Lan	1388	* @mac_wol: true if the MAC needs to receive packets for Wake-on-Lan
1389	*	1389	*
1390	* Handle a network device suspend event. There are several cases:	1390	* Handle a network device suspend event. There are several cases:
		1391	*
1391	* - If Wake-on-Lan is not active, we can bring down the link between	1392	* - If Wake-on-Lan is not active, we can bring down the link between
1392	* the MAC and PHY by calling phylink_stop().	1393	* the MAC and PHY by calling phylink_stop().
1393	* - If Wake-on-Lan is active, and being handled only by the PHY, we	1394	* - If Wake-on-Lan is active, and being handled only by the PHY, we

drivers/net/usb/cdc_ncm.c+2−0

@@ -181,6 +181,8 @@ static u32 cdc_ncm_check_tx_max(struct usbnet *dev, u32 new_tx) · 180 unmodified lines
181	min = ctx->max_datagram_size + ctx->max_ndp_size + sizeof(struct usb_cdc_ncm_nth32);	181	min = ctx->max_datagram_size + ctx->max_ndp_size + sizeof(struct usb_cdc_ncm_nth32);
182		182
183	max = min_t(u32, CDC_NCM_NTB_MAX_SIZE_TX, le32_to_cpu(ctx->ncm_parm.dwNtbOutMaxSize));	183	max = min_t(u32, CDC_NCM_NTB_MAX_SIZE_TX, le32_to_cpu(ctx->ncm_parm.dwNtbOutMaxSize));
		184	if (max == 0)
		185	max = CDC_NCM_NTB_MAX_SIZE_TX; /* dwNtbOutMaxSize not set */
184		186
185	/* some devices set dwNtbOutMaxSize too low for the above default */	187	/* some devices set dwNtbOutMaxSize too low for the above default */
186	min = min(min, max);	188	min = min(min, max);

drivers/net/usb/lan78xx.c+1−1

@@ -2228,7 +2228,7 @@ static int lan78xx_phy_init(struct lan78xx_net *dev) · 2227 unmodified lines
2228	if (dev->domain_data.phyirq > 0)	2228	if (dev->domain_data.phyirq > 0)
2229	phydev->irq = dev->domain_data.phyirq;	2229	phydev->irq = dev->domain_data.phyirq;
2230	else	2230	else
2231	phydev->irq = 0;	2231	phydev->irq = PHY_POLL;
2232	netdev_dbg(dev->net, "phydev->irq = %d\n", phydev->irq);	2232	netdev_dbg(dev->net, "phydev->irq = %d\n", phydev->irq);
2233		2233
2234	/* set to AUTOMDIX */	2234	/* set to AUTOMDIX */

drivers/net/vmxnet3/vmxnet3_drv.c+7−6

 #ifdef CONFIG_PCI_MSI
 	if (adapter->intr.type == VMXNET3_IT_MSIX) {
-		int i, nvec;
+		int i, nvec, nvec_allocated;
 		nvec  = adapter->share_intr == VMXNET3_INTR_TXSHARE ?
 			1 : adapter->num_tx_queues;
 		for (i = 0; i < nvec; i++)
 			adapter->intr.msix_entries[i].entry = i;
-		nvec = vmxnet3_acquire_msix_vectors(adapter, nvec);
+		nvec_allocated = vmxnet3_acquire_msix_vectors(adapter, nvec);
-		if (nvec < 0)
+		if (nvec_allocated < 0)
 			goto msix_err;
 		/* If we cannot allocate one MSIx vector per queue
 		 * then limit the number of rx queues to 1
 		 */
-		if (nvec == VMXNET3_LINUX_MIN_MSIX_VECT) {
+		if (nvec_allocated == VMXNET3_LINUX_MIN_MSIX_VECT &&
+		    nvec != VMXNET3_LINUX_MIN_MSIX_VECT) {
 			if (adapter->share_intr != VMXNET3_INTR_BUDDYSHARE
 			    || adapter->num_rx_queues != 1) {
 				adapter->share_intr = VMXNET3_INTR_TXSHARE;
 			}
 		}
-		adapter->intr.num_intrs = nvec;
+		adapter->intr.num_intrs = nvec_allocated;
 		return;
 msix_err:
 		/* If we cannot allocate MSIx vectors use only one rx queue */
 		dev_info(&adapter->pdev->dev,
 			 "Failed to enable MSI-X, error %d. "
-			 "Limiting #rx queues to 1, try MSI.\n", nvec);
+			 "Limiting #rx queues to 1, try MSI.\n", nvec_allocated);
 		adapter->intr.type = VMXNET3_IT_MSI;
 	}

drivers/net/vrf.c+6−4

 	/* strip the ethernet header added for pass through VRF device */
 	__skb_pull(skb, skb_network_offset(skb));
+	memset(IP6CB(skb), 0, sizeof(*IP6CB(skb)));
 	ret = vrf_ip6_local_out(net, skb->sk, skb);
 	if (unlikely(net_xmit_eval(ret)))
 		dev->stats.tx_errors++;
 					       RT_SCOPE_LINK);
 	}
+	memset(IPCB(skb), 0, sizeof(*IPCB(skb)));
 	ret = vrf_ip_local_out(dev_net(skb_dst(skb)->dev), skb->sk, skb);
 	if (unlikely(net_xmit_eval(ret)))
 		vrf_dev->stats.tx_errors++;
 	skb->dev = vrf_dev;
-	vrf_nf_set_untracked(skb);
 	err = nf_hook(NFPROTO_IPV6, NF_INET_LOCAL_OUT, net, sk,
 		      skb, NULL, vrf_dev, vrf_ip6_out_direct_finish);
 	if (rt6_need_strict(&ipv6_hdr(skb)->daddr))
 		return skb;
+	vrf_nf_set_untracked(skb);
 	if (qdisc_tx_is_default(vrf_dev) ||
 	    IP6CB(skb)->flags & IP6SKB_XFRM_TRANSFORMED)
 		return vrf_ip6_out_direct(vrf_dev, sk, skb);
 	skb->dev = vrf_dev;
-	vrf_nf_set_untracked(skb);
 	err = nf_hook(NFPROTO_IPV4, NF_INET_LOCAL_OUT, net, sk,
 		      skb, NULL, vrf_dev, vrf_ip_out_direct_finish);
 	    ipv4_is_lbcast(ip_hdr(skb)->daddr))
 		return skb;
+	vrf_nf_set_untracked(skb);
 	if (qdisc_tx_is_default(vrf_dev) ||
 	    IPCB(skb)->flags & IPSKB_XFRM_TRANSFORMED)
 		return vrf_ip_out_direct(vrf_dev, sk, skb);

drivers/net/wireguard/allowedips.c+1−1

@@ -163,7 +163,7 @@ static bool node_placement(struct allowedips_node __rcu trie, const u8 key, · 162 unmodified lines
163	return exact;	163	return exact;
164	}	164	}
165		165
166	static inline void connect_node(struct allowedips_node *parent, u8 bit, struct allowedips_node node)	166	static inline void connect_node(struct allowedips_node __rcu *parent, u8 bit, struct allowedips_node node)
167	{	167	{
168	node->parent_bit_packed = (unsigned long)parent \| bit;	168	node->parent_bit_packed = (unsigned long)parent \| bit;
169	rcu_assign_pointer(*parent, node);	169	rcu_assign_pointer(*parent, node);

drivers/net/wireguard/device.c+21−18

 {
 	struct wg_device *wg = netdev_priv(dev);
 	struct wg_peer *peer;
+	struct sk_buff *skb;
 	mutex_lock(&wg->device_update_lock);
 	list_for_each_entry(peer, &wg->peer_list, peer_list) {
 		wg_noise_reset_last_sent_handshake(&peer->last_sent_handshake);
 	}
 	mutex_unlock(&wg->device_update_lock);
-	skb_queue_purge(&wg->incoming_handshakes);
+	while ((skb = ptr_ring_consume(&wg->handshake_queue.ring)) != NULL)
+		kfree_skb(skb);
+	atomic_set(&wg->handshake_queue_len, 0);
 	wg_socket_reinit(wg, NULL, NULL);
 	return 0;
 }
 	destroy_workqueue(wg->handshake_receive_wq);
 	destroy_workqueue(wg->handshake_send_wq);
 	destroy_workqueue(wg->packet_crypt_wq);
-	wg_packet_queue_free(&wg->decrypt_queue);
+	wg_packet_queue_free(&wg->handshake_queue, true);
-	wg_packet_queue_free(&wg->encrypt_queue);
+	wg_packet_queue_free(&wg->decrypt_queue, false);
+	wg_packet_queue_free(&wg->encrypt_queue, false);
 	rcu_barrier(); /* Wait for all the peers to be actually freed. */
 	wg_ratelimiter_uninit();
 	memzero_explicit(&wg->static_identity, sizeof(wg->static_identity));
-	skb_queue_purge(&wg->incoming_handshakes);
 	free_percpu(dev->tstats);
-	free_percpu(wg->incoming_handshakes_worker);
 	kvfree(wg->index_hashtable);
 	kvfree(wg->peer_hashtable);
 	mutex_unlock(&wg->device_update_lock);
 	init_rwsem(&wg->static_identity.lock);
 	mutex_init(&wg->socket_update_lock);
 	mutex_init(&wg->device_update_lock);
-	skb_queue_head_init(&wg->incoming_handshakes);
 	wg_allowedips_init(&wg->peer_allowedips);
 	wg_cookie_checker_init(&wg->cookie_checker, wg);
 	INIT_LIST_HEAD(&wg->peer_list);
 	if (!dev->tstats)
 		goto err_free_index_hashtable;
-	wg->incoming_handshakes_worker =
-		wg_packet_percpu_multicore_worker_alloc(
-				wg_packet_handshake_receive_worker, wg);
-	if (!wg->incoming_handshakes_worker)
-		goto err_free_tstats;
 	wg->handshake_receive_wq = alloc_workqueue("wg-kex-%s",
 			WQ_CPU_INTENSIVE | WQ_FREEZABLE, 0, dev->name);
 	if (!wg->handshake_receive_wq)
-		goto err_free_incoming_handshakes;
+		goto err_free_tstats;
 	wg->handshake_send_wq = alloc_workqueue("wg-kex-%s",
 			WQ_UNBOUND | WQ_FREEZABLE, 0, dev->name);
 	if (ret < 0)
 		goto err_free_encrypt_queue;
-	ret = wg_ratelimiter_init();
+	ret = wg_packet_queue_init(&wg->handshake_queue, wg_packet_handshake_receive_worker,
+				   MAX_QUEUED_INCOMING_HANDSHAKES);
 	if (ret < 0)
 		goto err_free_decrypt_queue;
+	ret = wg_ratelimiter_init();
+	if (ret < 0)
+		goto err_free_handshake_queue;
 	ret = register_netdevice(dev);
 	if (ret < 0)
 		goto err_uninit_ratelimiter;
 err_uninit_ratelimiter:
 	wg_ratelimiter_uninit();
+err_free_handshake_queue:
+	wg_packet_queue_free(&wg->handshake_queue, false);
 err_free_decrypt_queue:
-	wg_packet_queue_free(&wg->decrypt_queue);
+	wg_packet_queue_free(&wg->decrypt_queue, false);
 err_free_encrypt_queue:
-	wg_packet_queue_free(&wg->encrypt_queue);
+	wg_packet_queue_free(&wg->encrypt_queue, false);
 err_destroy_packet_crypt:
 	destroy_workqueue(wg->packet_crypt_wq);
 err_destroy_handshake_send:
 	destroy_workqueue(wg->handshake_send_wq);
 err_destroy_handshake_receive:
 	destroy_workqueue(wg->handshake_receive_wq);
-err_free_incoming_handshakes:
-	free_percpu(wg->incoming_handshakes_worker);
 err_free_tstats:
 	free_percpu(dev->tstats);
 err_free_index_hashtable:
 static void wg_netns_pre_exit(struct net *net)
 {
 	struct wg_device *wg;
+	struct wg_peer *peer;
 	rtnl_lock();
 	list_for_each_entry(wg, &device_list, device_list) {
 			mutex_lock(&wg->device_update_lock);
 			rcu_assign_pointer(wg->creating_net, NULL);
 			wg_socket_reinit(wg, NULL, NULL);
+			list_for_each_entry(peer, &wg->peer_list, peer_list)
+				wg_socket_clear_peer_endpoint_src(peer);
 			mutex_unlock(&wg->device_update_lock);
 		}
 	}

drivers/net/wireguard/device.h+3−6

 struct wg_device {
 	struct net_device *dev;
-	struct crypt_queue encrypt_queue, decrypt_queue;
+	struct crypt_queue encrypt_queue, decrypt_queue, handshake_queue;
 	struct sock __rcu *sock4, *sock6;
 	struct net __rcu *creating_net;
 	struct noise_static_identity static_identity;
-	struct workqueue_struct *handshake_receive_wq, *handshake_send_wq;
+	struct workqueue_struct *packet_crypt_wq,*handshake_receive_wq, *handshake_send_wq;
-	struct workqueue_struct *packet_crypt_wq;
-	struct sk_buff_head incoming_handshakes;
-	int incoming_handshake_cpu;
-	struct multicore_worker __percpu *incoming_handshakes_worker;
 	struct cookie_checker cookie_checker;
 	struct pubkey_hashtable *peer_hashtable;
 	struct index_hashtable *index_hashtable;
 	struct allowedips peer_allowedips;
 	struct mutex device_update_lock, socket_update_lock;
 	struct list_head device_list, peer_list;
+	atomic_t handshake_queue_len;
 	unsigned int num_peers, device_update_gen;
 	u32 fwmark;
 	u16 incoming_port;

drivers/net/wireguard/main.c+4−4

@@ -17,7 +17,7 @@ · 16 unmodified lines
17	#include <linux/genetlink.h>	17	#include <linux/genetlink.h>
18	#include <net/rtnetlink.h>	18	#include <net/rtnetlink.h>
19		19
20	static int __init mod_init(void)	20	static int __init wg_mod_init(void)
21	{	21	{
22	int ret;	22	int ret;
23		23
@@ -60,7 +60,7 @@ err_allowedips: · 36 unmodified lines
60	return ret;	60	return ret;
61	}	61	}
62		62
63	static void __exit mod_exit(void)	63	static void __exit wg_mod_exit(void)
64	{	64	{
65	wg_genetlink_uninit();	65	wg_genetlink_uninit();
66	wg_device_uninit();	66	wg_device_uninit();
@@ -68,8 +68,8 @@ static void __exit mod_exit(void) · 1 unmodified line
68	wg_allowedips_slab_uninit();	68	wg_allowedips_slab_uninit();
69	}	69	}
70		70
71	module_init(mod_init);	71	module_init(wg_mod_init);
72	module_exit(mod_exit);	72	module_exit(wg_mod_exit);
73	MODULE_LICENSE("GPL v2");	73	MODULE_LICENSE("GPL v2");
74	MODULE_DESCRIPTION("WireGuard secure network tunnel");	74	MODULE_DESCRIPTION("WireGuard secure network tunnel");
75	MODULE_AUTHOR("Jason A. Donenfeld <Jason@zx2c4.com>");	75	MODULE_AUTHOR("Jason A. Donenfeld <Jason@zx2c4.com>");

drivers/net/wireguard/queueing.c+3−3

@@ -38,11 +38,11 @@ int wg_packet_queue_init(struct crypt_queue *queue, work_func_t function, · 37 unmodified lines
38	return 0;	38	return 0;
39	}	39	}
40		40
41	void wg_packet_queue_free(struct crypt_queue *queue)	41	void wg_packet_queue_free(struct crypt_queue *queue, bool purge)
42	{	42	{
43	free_percpu(queue->worker);	43	free_percpu(queue->worker);
44	WARN_ON(!__ptr_ring_empty(&queue->ring));	44	WARN_ON(!purge && !__ptr_ring_empty(&queue->ring));
45	ptr_ring_cleanup(&queue->ring, NULL);	45	ptr_ring_cleanup(&queue->ring, purge ? (void()(void))kfree_skb : NULL);
46	}	46	}
47		47
48	#define NEXT(skb) ((skb)->prev)	48	#define NEXT(skb) ((skb)->prev)

drivers/net/wireguard/queueing.h+1−1

@@ -23,7 +23,7 @@ struct sk_buff; · 22 unmodified lines
23	/* queueing.c APIs: */	23	/* queueing.c APIs: */
24	int wg_packet_queue_init(struct crypt_queue *queue, work_func_t function,	24	int wg_packet_queue_init(struct crypt_queue *queue, work_func_t function,
25	unsigned int len);	25	unsigned int len);
26	void wg_packet_queue_free(struct crypt_queue *queue);	26	void wg_packet_queue_free(struct crypt_queue *queue, bool purge);
27	struct multicore_worker __percpu *	27	struct multicore_worker __percpu *
28	wg_packet_percpu_multicore_worker_alloc(work_func_t function, void *ptr);	28	wg_packet_percpu_multicore_worker_alloc(work_func_t function, void *ptr);
29		29

drivers/net/wireguard/ratelimiter.c+2−2

@@ -176,12 +176,12 @@ int wg_ratelimiter_init(void) · 175 unmodified lines
176	(1U << 14) / sizeof(struct hlist_head)));	176	(1U << 14) / sizeof(struct hlist_head)));
177	max_entries = table_size * 8;	177	max_entries = table_size * 8;
178		178
179	table_v4 = kvzalloc(table_size * sizeof(*table_v4), GFP_KERNEL);	179	table_v4 = kvcalloc(table_size, sizeof(*table_v4), GFP_KERNEL);
180	if (unlikely(!table_v4))	180	if (unlikely(!table_v4))
181	goto err_kmemcache;	181	goto err_kmemcache;
182		182
183	#if IS_ENABLED(CONFIG_IPV6)	183	#if IS_ENABLED(CONFIG_IPV6)
184	table_v6 = kvzalloc(table_size * sizeof(*table_v6), GFP_KERNEL);	184	table_v6 = kvcalloc(table_size, sizeof(*table_v6), GFP_KERNEL);
185	if (unlikely(!table_v6)) {	185	if (unlikely(!table_v6)) {
186	kvfree(table_v4);	186	kvfree(table_v4);
187	goto err_kmemcache;	187	goto err_kmemcache;

drivers/net/wireguard/receive.c+23−16

 		return;
 	}
-	under_load = skb_queue_len(&wg->incoming_handshakes) >=
+	under_load = atomic_read(&wg->handshake_queue_len) >=
-		     MAX_QUEUED_INCOMING_HANDSHAKES / 8;
+			MAX_QUEUED_INCOMING_HANDSHAKES / 8;
 	if (under_load) {
 		last_under_load = ktime_get_coarse_boottime_ns();
 	} else if (last_under_load) {
 void wg_packet_handshake_receive_worker(struct work_struct *work)
 {
-	struct wg_device *wg = container_of(work, struct multicore_worker,
+	struct crypt_queue *queue = container_of(work, struct multicore_worker, work)->ptr;
-					    work)->ptr;
+	struct wg_device *wg = container_of(queue, struct wg_device, handshake_queue);
 	struct sk_buff *skb;
-	while ((skb = skb_dequeue(&wg->incoming_handshakes)) != NULL) {
+	while ((skb = ptr_ring_consume_bh(&queue->ring)) != NULL) {
 		wg_receive_handshake_packet(wg, skb);
 		dev_kfree_skb(skb);
+		atomic_dec(&wg->handshake_queue_len);
 		cond_resched();
 	}
 }
 	case cpu_to_le32(MESSAGE_HANDSHAKE_INITIATION):
 	case cpu_to_le32(MESSAGE_HANDSHAKE_RESPONSE):
 	case cpu_to_le32(MESSAGE_HANDSHAKE_COOKIE): {
-		int cpu;
+		int cpu, ret = -EBUSY;
-		if (skb_queue_len(&wg->incoming_handshakes) >
+		if (unlikely(!rng_is_initialized()))
-			    MAX_QUEUED_INCOMING_HANDSHAKES ||
+			goto drop;
-		    unlikely(!rng_is_initialized())) {
+		if (atomic_read(&wg->handshake_queue_len) > MAX_QUEUED_INCOMING_HANDSHAKES / 2) {
+			if (spin_trylock_bh(&wg->handshake_queue.ring.producer_lock)) {
+				ret = __ptr_ring_produce(&wg->handshake_queue.ring, skb);
+				spin_unlock_bh(&wg->handshake_queue.ring.producer_lock);
+			}
+		} else
+			ret = ptr_ring_produce_bh(&wg->handshake_queue.ring, skb);
+		if (ret) {
+	drop:
 			net_dbg_skb_ratelimited("%s: Dropping handshake packet from %pISpfsc\n",
 						wg->dev->name, skb);
 			goto err;
 		}
-		skb_queue_tail(&wg->incoming_handshakes, skb);
+		atomic_inc(&wg->handshake_queue_len);
-		/* Queues up a call to packet_process_queued_handshake_
+		cpu = wg_cpumask_next_online(&wg->handshake_queue.last_cpu);
-		 * packets(skb):
+		/* Queues up a call to packet_process_queued_handshake_packets(skb): */
-		 */
-		cpu = wg_cpumask_next_online(&wg->incoming_handshake_cpu);
 		queue_work_on(cpu, wg->handshake_receive_wq,
-			&per_cpu_ptr(wg->incoming_handshakes_worker, cpu)->work);
+			      &per_cpu_ptr(wg->handshake_queue.worker, cpu)->work);
 		break;
 	}
 	case cpu_to_le32(MESSAGE_DATA):

drivers/net/wireguard/socket.c+1−1

@@ -308,7 +308,7 @@ void wg_socket_clear_peer_endpoint_src(struct wg_peer *peer) · 307 unmodified lines
308	{	308	{
309	write_lock_bh(&peer->endpoint_lock);	309	write_lock_bh(&peer->endpoint_lock);
310	memset(&peer->endpoint.src6, 0, sizeof(peer->endpoint.src6));	310	memset(&peer->endpoint.src6, 0, sizeof(peer->endpoint.src6));
311	dst_cache_reset(&peer->endpoint_cache);	311	dst_cache_reset_now(&peer->endpoint_cache);
312	write_unlock_bh(&peer->endpoint_lock);	312	write_unlock_bh(&peer->endpoint_lock);
313	}	313	}
314		314

drivers/net/wireless/ath/ath11k/mhi.c+5−1

 		ret = mhi_pm_suspend(ab_pci->mhi_ctrl);
 		break;
 	case ATH11K_MHI_RESUME:
-		ret = mhi_pm_resume(ab_pci->mhi_ctrl);
+		/* Do force MHI resume as some devices like QCA6390, WCN6855
+		 * are not in M3 state but they are functional. So just ignore
+		 * the MHI state while resuming.
+		 */
+		ret = mhi_pm_resume_force(ab_pci->mhi_ctrl);
 		break;
 	case ATH11K_MHI_TRIGGER_RDDM:
 		ret = mhi_force_rddm_mode(ab_pci->mhi_ctrl);

drivers/net/wireless/intel/iwlwifi/fw/uefi.c+6−0

 		if (len < tlv_len) {
 			IWL_ERR(trans, "invalid TLV len: %zd/%u\n",
 				len, tlv_len);
+			kfree(reduce_power_data);
 			reduce_power_data = ERR_PTR(-EINVAL);
 			goto out;
 		}
 				IWL_DEBUG_FW(trans,
 					     "Couldn't allocate (more) reduce_power_data\n");
+				kfree(reduce_power_data);
 				reduce_power_data = ERR_PTR(-ENOMEM);
 				goto out;
 			}
 done:
 	if (!size) {
 		IWL_DEBUG_FW(trans, "Empty REDUCE_POWER, skipping.\n");
+		/* Better safe than sorry, but 'reduce_power_data' should
+		 * always be NULL if !size.
+		 */
+		kfree(reduce_power_data);
 		reduce_power_data = ERR_PTR(-ENOENT);
 		goto out;
 	}

drivers/net/wireless/intel/iwlwifi/iwl-drv.c+15−7

 	const struct iwl_op_mode_ops *ops = op->ops;
 	struct dentry *dbgfs_dir = NULL;
 	struct iwl_op_mode *op_mode = NULL;
+	int retry, max_retry = !!iwlwifi_mod_params.fw_restart * IWL_MAX_INIT_RETRY;
+	for (retry = 0; retry <= max_retry; retry++) {
 #ifdef CONFIG_IWLWIFI_DEBUGFS
-	drv->dbgfs_op_mode = debugfs_create_dir(op->name,
+		drv->dbgfs_op_mode = debugfs_create_dir(op->name,
-						drv->dbgfs_drv);
+							drv->dbgfs_drv);
-	dbgfs_dir = drv->dbgfs_op_mode;
+		dbgfs_dir = drv->dbgfs_op_mode;
 #endif
-	op_mode = ops->start(drv->trans, drv->trans->cfg, &drv->fw, dbgfs_dir);
+		op_mode = ops->start(drv->trans, drv->trans->cfg,
+				     &drv->fw, dbgfs_dir);
+		if (op_mode)
+			return op_mode;
+		IWL_ERR(drv, "retry init count %d\n", retry);
 #ifdef CONFIG_IWLWIFI_DEBUGFS
-	if (!op_mode) {
 		debugfs_remove_recursive(drv->dbgfs_op_mode);
 		drv->dbgfs_op_mode = NULL;
-	}
 #endif
+	}
-	return op_mode;
+	return NULL;
 }
 static void _iwl_op_mode_stop(struct iwl_drv *drv)

drivers/net/wireless/intel/iwlwifi/iwl-drv.h+3−0

@@ -89,4 +89,7 @@ void iwl_drv_stop(struct iwl_drv *drv); · 88 unmodified lines
89	#define IWL_EXPORT_SYMBOL(sym)	89	#define IWL_EXPORT_SYMBOL(sym)
90	#endif	90	#endif
91		91
		92	/* max retry for init flow */
		93	#define IWL_MAX_INIT_RETRY 2
		94
92	#endif /* __iwl_drv_h__ */	95	#endif /* __iwl_drv_h__ */

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

@@ -16,6 +16,7 @@ · 15 unmodified lines
16	#include <net/ieee80211_radiotap.h>	16	#include <net/ieee80211_radiotap.h>
17	#include <net/tcp.h>	17	#include <net/tcp.h>
18		18
		19	#include "iwl-drv.h"
19	#include "iwl-op-mode.h"	20	#include "iwl-op-mode.h"
20	#include "iwl-io.h"	21	#include "iwl-io.h"
21	#include "mvm.h"	22	#include "mvm.h"
@@ -1117,9 +1118,30 @@ static int iwl_mvm_mac_start(struct ieee80211_hw *hw) · 1095 unmodified lines
1117	{	1118	{
1118	struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);	1119	struct iwl_mvm *mvm = IWL_MAC80211_GET_MVM(hw);
1119	int ret;	1120	int ret;
		1121	int retry, max_retry = 0;
1120		1122
1121	mutex_lock(&mvm->mutex);	1123	mutex_lock(&mvm->mutex);
1122	ret = __iwl_mvm_mac_start(mvm);	1124
		1125	/* we are starting the mac not in error flow, and restart is enabled */
		1126	if (!test_bit(IWL_MVM_STATUS_HW_RESTART_REQUESTED, &mvm->status) &&
		1127	iwlwifi_mod_params.fw_restart) {
		1128	max_retry = IWL_MAX_INIT_RETRY;
		1129	/*
		1130	* This will prevent mac80211 recovery flows to trigger during
		1131	* init failures
		1132	*/
		1133	set_bit(IWL_MVM_STATUS_STARTING, &mvm->status);
		1134	}
		1135
		1136	for (retry = 0; retry <= max_retry; retry++) {
		1137	ret = __iwl_mvm_mac_start(mvm);
		1138	if (!ret)
		1139	break;
		1140
		1141	IWL_ERR(mvm, "mac start retry %d\n", retry);
		1142	}
		1143	clear_bit(IWL_MVM_STATUS_STARTING, &mvm->status);
		1144
1123	mutex_unlock(&mvm->mutex);	1145	mutex_unlock(&mvm->mutex);
1124		1146
1125	return ret;	1147	return ret;

drivers/net/wireless/intel/iwlwifi/mvm/mvm.h+3−0

  * @IWL_MVM_STATUS_FIRMWARE_RUNNING: firmware is running
  * @IWL_MVM_STATUS_NEED_FLUSH_P2P: need to flush P2P bcast STA
  * @IWL_MVM_STATUS_IN_D3: in D3 (or at least about to go into it)
+ * @IWL_MVM_STATUS_STARTING: starting mac,
+ *	used to disable restart flow while in STARTING state
  */
 enum iwl_mvm_status {
 	IWL_MVM_STATUS_HW_RFKILL,
 	IWL_MVM_STATUS_FIRMWARE_RUNNING,
 	IWL_MVM_STATUS_NEED_FLUSH_P2P,
 	IWL_MVM_STATUS_IN_D3,
+	IWL_MVM_STATUS_STARTING,
 };
 /* Keep track of completed init configuration */

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

 	int ret;
 	rtnl_lock();
+	wiphy_lock(mvm->hw->wiphy);
 	mutex_lock(&mvm->mutex);
 	ret = iwl_run_init_mvm_ucode(mvm);
 		iwl_mvm_stop_device(mvm);
 	mutex_unlock(&mvm->mutex);
+	wiphy_unlock(mvm->hw->wiphy);
 	rtnl_unlock();
 	if (ret < 0)
 	 */
 	if (!mvm->fw_restart && fw_error) {
 		iwl_fw_error_collect(&mvm->fwrt, false);
+	} else if (test_bit(IWL_MVM_STATUS_STARTING,
+			    &mvm->status)) {
+		IWL_ERR(mvm, "Starting mac, retry will be triggered anyway\n");
 	} else if (test_bit(IWL_MVM_STATUS_IN_HW_RESTART, &mvm->status)) {
 		struct iwl_mvm_reprobe *reprobe;

drivers/net/wireless/intel/iwlwifi/pcie/drv.c+8−2

 		      u16 mac_type, u8 mac_step,
 		      u16 rf_type, u8 cdb, u8 rf_id, u8 no_160, u8 cores)
 {
+	int num_devices = ARRAY_SIZE(iwl_dev_info_table);
 	int i;
-	for (i = ARRAY_SIZE(iwl_dev_info_table) - 1; i >= 0; i--) {
+	if (!num_devices)
+		return NULL;
+	for (i = num_devices - 1; i >= 0; i--) {
 		const struct iwl_dev_info *dev_info = &iwl_dev_info_table[i];
 		if (dev_info->device != (u16)IWL_CFG_ANY &&
 	 */
 	if (iwl_trans->trans_cfg->rf_id &&
 	    iwl_trans->trans_cfg->device_family >= IWL_DEVICE_FAMILY_9000 &&
-	    !CSR_HW_RFID_TYPE(iwl_trans->hw_rf_id) && get_crf_id(iwl_trans))
+	    !CSR_HW_RFID_TYPE(iwl_trans->hw_rf_id) && get_crf_id(iwl_trans)) {
+		ret = -EINVAL;
 		goto out_free_trans;
+	}
 	dev_info = iwl_pci_find_dev_info(pdev->device, pdev->subsystem_device,
 					 CSR_HW_REV_TYPE(iwl_trans->hw_rev),

drivers/net/wireless/mediatek/mt76/mt7615/pci_mac.c+1−2

 	if (!wcid)
 		wcid = &dev->mt76.global_wcid;
-	pid = mt76_tx_status_skb_add(mdev, wcid, tx_info->skb);
 	if ((info->flags & IEEE80211_TX_CTL_RATE_CTRL_PROBE) && msta) {
 		struct mt7615_phy *phy = &dev->phy;
 	if (id < 0)
 		return id;
+	pid = mt76_tx_status_skb_add(mdev, wcid, tx_info->skb);
 	mt7615_mac_write_txwi(dev, txwi_ptr, tx_info->skb, wcid, sta,
 			      pid, key, false);

drivers/net/wireless/mediatek/mt76/mt7615/usb_sdio.c+15−13

 static void
 mt7663_usb_sdio_write_txwi(struct mt7615_dev *dev, struct mt76_wcid *wcid,
 			   enum mt76_txq_id qid, struct ieee80211_sta *sta,
+			   struct ieee80211_key_conf *key, int pid,
 			   struct sk_buff *skb)
 {
-	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
+	__le32 *txwi = (__le32 *)(skb->data - MT_USB_TXD_SIZE);
-	struct ieee80211_key_conf *key = info->control.hw_key;
-	__le32 *txwi;
-	int pid;
-	if (!wcid)
-		wcid = &dev->mt76.global_wcid;
-	pid = mt76_tx_status_skb_add(&dev->mt76, wcid, skb);
-	txwi = (__le32 *)(skb->data - MT_USB_TXD_SIZE);
 	memset(txwi, 0, MT_USB_TXD_SIZE);
 	mt7615_mac_write_txwi(dev, txwi, skb, wcid, sta, pid, key, false);
 	skb_push(skb, MT_USB_TXD_SIZE);
 	struct mt7615_dev *dev = container_of(mdev, struct mt7615_dev, mt76);
 	struct sk_buff *skb = tx_info->skb;
 	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
+	struct ieee80211_key_conf *key = info->control.hw_key;
 	struct mt7615_sta *msta;
-	int pad;
+	int pad, err, pktid;
 	msta = wcid ? container_of(wcid, struct mt7615_sta, wcid) : NULL;
+	if (!wcid)
+		wcid = &dev->mt76.global_wcid;
 	if ((info->flags & IEEE80211_TX_CTL_RATE_CTRL_PROBE) &&
 	    msta && !msta->rate_probe) {
 		/* request to configure sampling rate */
 		spin_unlock_bh(&dev->mt76.lock);
 	}
-	mt7663_usb_sdio_write_txwi(dev, wcid, qid, sta, skb);
+	pktid = mt76_tx_status_skb_add(&dev->mt76, wcid, skb);
+	mt7663_usb_sdio_write_txwi(dev, wcid, qid, sta, key, pktid, skb);
 	if (mt76_is_usb(mdev)) {
 		u32 len = skb->len;
 		pad = round_up(skb->len, 4) - skb->len;
 	}
-	return mt76_skb_adjust_pad(skb, pad);
+	err = mt76_skb_adjust_pad(skb, pad);
+	if (err)
+		/* Release pktid in case of error. */
+		idr_remove(&wcid->pktid, pktid);
+	return err;
 }
 EXPORT_SYMBOL_GPL(mt7663_usb_sdio_tx_prepare_skb);

drivers/net/wireless/mediatek/mt76/mt76x02_usb_core.c+7−1

 	bool ampdu = IEEE80211_SKB_CB(tx_info->skb)->flags & IEEE80211_TX_CTL_AMPDU;
 	enum mt76_qsel qsel;
 	u32 flags;
+	int err;
 	mt76_insert_hdr_pad(tx_info->skb);
 		ewma_pktlen_add(&msta->pktlen, tx_info->skb->len);
 	}
-	return mt76x02u_skb_dma_info(tx_info->skb, WLAN_PORT, flags);
+	err = mt76x02u_skb_dma_info(tx_info->skb, WLAN_PORT, flags);
+	if (err && wcid)
+		/* Release pktid in case of error. */
+		idr_remove(&wcid->pktid, pid);
+	return err;
 }
 EXPORT_SYMBOL_GPL(mt76x02u_tx_prepare_skb);

drivers/net/wireless/mediatek/mt76/mt7915/mac.c+7−8

 		}
 	}
-	pid = mt76_tx_status_skb_add(mdev, wcid, tx_info->skb);
+	t = (struct mt76_txwi_cache *)(txwi + mdev->drv->txwi_size);
+	t->skb = tx_info->skb;
+	id = mt76_token_consume(mdev, &t);
+	if (id < 0)
+		return id;
+	pid = mt76_tx_status_skb_add(mdev, wcid, tx_info->skb);
 	mt7915_mac_write_txwi(dev, txwi_ptr, tx_info->skb, wcid, pid, key,
 			      false);
 		txp->bss_idx = mvif->idx;
 	}
-	t = (struct mt76_txwi_cache *)(txwi + mdev->drv->txwi_size);
-	t->skb = tx_info->skb;
-	id = mt76_token_consume(mdev, &t);
-	if (id < 0)
-		return id;
 	txp->token = cpu_to_le16(id);
 	if (test_bit(MT_WCID_FLAG_4ADDR, &wcid->flags))
 		txp->rept_wds_wcid = cpu_to_le16(wcid->idx);

drivers/net/wireless/mediatek/mt76/mt7915/mcu.c+2−2

@@ -176,7 +176,7 @@ mt7915_get_phy_mode(struct ieee80211_vif vif, struct ieee80211_sta sta) · 175 unmodified lines
176	if (ht_cap->ht_supported)	176	if (ht_cap->ht_supported)
177	mode \|= PHY_MODE_GN;	177	mode \|= PHY_MODE_GN;
178		178
179	if (he_cap->has_he)	179	if (he_cap && he_cap->has_he)
180	mode \|= PHY_MODE_AX_24G;	180	mode \|= PHY_MODE_AX_24G;
181	} else if (band == NL80211_BAND_5GHZ) {	181	} else if (band == NL80211_BAND_5GHZ) {
182	mode \|= PHY_MODE_A;	182	mode \|= PHY_MODE_A;
@@ -187,7 +187,7 @@ mt7915_get_phy_mode(struct ieee80211_vif vif, struct ieee80211_sta sta) · 4 unmodified lines
187	if (vht_cap->vht_supported)	187	if (vht_cap->vht_supported)
188	mode \|= PHY_MODE_AC;	188	mode \|= PHY_MODE_AC;
189		189
190	if (he_cap->has_he)	190	if (he_cap && he_cap->has_he)
191	mode \|= PHY_MODE_AX_5G;	191	mode \|= PHY_MODE_AX_5G;
192	}	192	}
193		193

drivers/net/wireless/mediatek/mt76/mt7921/sdio_mac.c+12−9

 static void
 mt7921s_write_txwi(struct mt7921_dev *dev, struct mt76_wcid *wcid,
 		   enum mt76_txq_id qid, struct ieee80211_sta *sta,
+		   struct ieee80211_key_conf *key, int pid,
 		   struct sk_buff *skb)
 {
-	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(skb);
+	__le32 *txwi = (__le32 *)(skb->data - MT_SDIO_TXD_SIZE);
-	struct ieee80211_key_conf *key = info->control.hw_key;
-	__le32 *txwi;
-	int pid;
-	pid = mt76_tx_status_skb_add(&dev->mt76, wcid, skb);
-	txwi = (__le32 *)(skb->data - MT_SDIO_TXD_SIZE);
 	memset(txwi, 0, MT_SDIO_TXD_SIZE);
 	mt7921_mac_write_txwi(dev, txwi, skb, wcid, key, pid, false);
 	skb_push(skb, MT_SDIO_TXD_SIZE);
 {
 	struct mt7921_dev *dev = container_of(mdev, struct mt7921_dev, mt76);
 	struct ieee80211_tx_info *info = IEEE80211_SKB_CB(tx_info->skb);
+	struct ieee80211_key_conf *key = info->control.hw_key;
 	struct sk_buff *skb = tx_info->skb;
-	int pad;
+	int err, pad, pktid;
 	if (unlikely(tx_info->skb->len <= ETH_HLEN))
 		return -EINVAL;
 		}
 	}
-	mt7921s_write_txwi(dev, wcid, qid, sta, skb);
+	pktid = mt76_tx_status_skb_add(&dev->mt76, wcid, skb);
+	mt7921s_write_txwi(dev, wcid, qid, sta, key, pktid, skb);
 	mt7921_skb_add_sdio_hdr(skb, MT7921_SDIO_DATA);
 	pad = round_up(skb->len, 4) - skb->len;
-	return mt76_skb_adjust_pad(skb, pad);
+	err = mt76_skb_adjust_pad(skb, pad);
+	if (err)
+		/* Release pktid in case of error. */
+		idr_remove(&wcid->pktid, pktid);
+	return err;
 }
 void mt7921s_tx_complete_skb(struct mt76_dev *mdev, struct mt76_queue_entry *e)

drivers/net/wireless/mediatek/mt76/tx.c+1−1

@@ -173,7 +173,7 @@ mt76_tx_status_skb_get(struct mt76_dev dev, struct mt76_wcid wcid, int pktid, · 172 unmodified lines
173	if (!(cb->flags & MT_TX_CB_DMA_DONE))	173	if (!(cb->flags & MT_TX_CB_DMA_DONE))
174	continue;	174	continue;
175		175
176	if (!time_is_after_jiffies(cb->jiffies +	176	if (time_is_after_jiffies(cb->jiffies +
177	MT_TX_STATUS_SKB_TIMEOUT))	177	MT_TX_STATUS_SKB_TIMEOUT))
178	continue;	178	continue;
179	}	179	}

drivers/net/wireless/ralink/rt2x00/rt2x00usb.c+3−0

@@ -25,6 +25,9 @@ static bool rt2x00usb_check_usb_error(struct rt2x00_dev *rt2x00dev, int status) · 24 unmodified lines
25	if (status == -ENODEV \|\| status == -ENOENT)	25	if (status == -ENODEV \|\| status == -ENOENT)
26	return true;	26	return true;
27		27
		28	if (!test_bit(DEVICE_STATE_STARTED, &rt2x00dev->flags))
		29	return false;
		30
28	if (status == -EPROTO \|\| status == -ETIMEDOUT)	31	if (status == -EPROTO \|\| status == -ETIMEDOUT)
29	rt2x00dev->num_proto_errs++;	32	rt2x00dev->num_proto_errs++;
30	else	33	else

drivers/net/wireless/realtek/rtw89/fw.c+1−1

 	info->section_num = GET_FW_HDR_SEC_NUM(fw);
 	info->hdr_len = RTW89_FW_HDR_SIZE +
 			info->section_num * RTW89_FW_SECTION_HDR_SIZE;
-	SET_FW_HDR_PART_SIZE(fw, FWDL_SECTION_PER_PKT_LEN);
 	bin = fw + info->hdr_len;
 	}
 	skb_put_data(skb, fw, len);
+	SET_FW_HDR_PART_SIZE(skb->data, FWDL_SECTION_PER_PKT_LEN);
 	rtw89_h2c_pkt_set_hdr_fwdl(rtwdev, skb, FWCMD_TYPE_H2C,
 				   H2C_CAT_MAC, H2C_CL_MAC_FWDL,
 				   H2C_FUNC_MAC_FWHDR_DL, len);

drivers/net/wireless/realtek/rtw89/fw.h+4−2

 	le32_get_bits(*((__le32 *)(fwhdr) + 6), GENMASK(15, 8))
 #define GET_FW_HDR_CMD_VERSERION(fwhdr)	\
 	le32_get_bits(*((__le32 *)(fwhdr) + 7), GENMASK(31, 24))
-#define SET_FW_HDR_PART_SIZE(fwhdr, val)	\
+static inline void SET_FW_HDR_PART_SIZE(void *fwhdr, u32 val)
-	le32p_replace_bits((__le32 *)(fwhdr) + 7, val, GENMASK(15, 0))
+{
+	le32p_replace_bits((__le32 *)fwhdr + 7, val, GENMASK(15, 0));
+}
 #define SET_CTRL_INFO_MACID(table, val) \
 	le32p_replace_bits((__le32 *)(table) + 0, val, GENMASK(6, 0))

drivers/net/wwan/iosm/iosm_ipc_imem.c+17−9

@@ -181,9 +181,9 @@ void ipc_imem_hrtimer_stop(struct hrtimer *hr_timer) · 180 unmodified lines
181	bool ipc_imem_ul_write_td(struct iosm_imem *ipc_imem)	181	bool ipc_imem_ul_write_td(struct iosm_imem *ipc_imem)
182	{	182	{
183	struct ipc_mem_channel *channel;	183	struct ipc_mem_channel *channel;
		184	bool hpda_ctrl_pending = false;
184	struct sk_buff_head *ul_list;	185	struct sk_buff_head *ul_list;
185	bool hpda_pending = false;	186	bool hpda_pending = false;
186	bool forced_hpdu = false;
187	struct ipc_pipe *pipe;	187	struct ipc_pipe *pipe;
188	int i;	188	int i;
189		189
@@ -200,15 +200,19 @@ bool ipc_imem_ul_write_td(struct iosm_imem *ipc_imem) · 10 unmodified lines
200	ul_list = &channel->ul_list;	200	ul_list = &channel->ul_list;
201		201
202	/* Fill the transfer descriptor with the uplink buffer info. */	202	/* Fill the transfer descriptor with the uplink buffer info. */
203	hpda_pending \|= ipc_protocol_ul_td_send(ipc_imem->ipc_protocol,	203	if (!ipc_imem_check_wwan_ips(channel)) {
		204	hpda_ctrl_pending \|=
		205	ipc_protocol_ul_td_send(ipc_imem->ipc_protocol,
204	pipe, ul_list);	206	pipe, ul_list);
205		207	} else {
206	/* forced HP update needed for non data channels */	208	hpda_pending \|=
207	if (hpda_pending && !ipc_imem_check_wwan_ips(channel))	209	ipc_protocol_ul_td_send(ipc_imem->ipc_protocol,
208	forced_hpdu = true;	210	pipe, ul_list);
		211	}
209	}	212	}
210		213
211	if (forced_hpdu) {	214	/* forced HP update needed for non data channels */
		215	if (hpda_ctrl_pending) {
212	hpda_pending = false;	216	hpda_pending = false;
213	ipc_protocol_doorbell_trigger(ipc_imem->ipc_protocol,	217	ipc_protocol_doorbell_trigger(ipc_imem->ipc_protocol,
214	IPC_HP_UL_WRITE_TD);	218	IPC_HP_UL_WRITE_TD);
@@ -527,6 +531,9 @@ static void ipc_imem_run_state_worker(struct work_struct *instance) · 312 unmodified lines
527	return;	531	return;
528	}	532	}
529		533
		534	if (test_and_clear_bit(IOSM_DEVLINK_INIT, &ipc_imem->flag))
		535	ipc_devlink_deinit(ipc_imem->ipc_devlink);
		536
530	if (!ipc_imem_setup_cp_mux_cap_init(ipc_imem, &mux_cfg))	537	if (!ipc_imem_setup_cp_mux_cap_init(ipc_imem, &mux_cfg))
531	ipc_imem->mux = ipc_mux_init(&mux_cfg, ipc_imem);	538	ipc_imem->mux = ipc_mux_init(&mux_cfg, ipc_imem);
532		539
@@ -1167,7 +1174,7 @@ void ipc_imem_cleanup(struct iosm_imem *ipc_imem) · 634 unmodified lines
1167	ipc_port_deinit(ipc_imem->ipc_port);	1174	ipc_port_deinit(ipc_imem->ipc_port);
1168	}	1175	}
1169		1176
1170	if (ipc_imem->ipc_devlink)	1177	if (test_and_clear_bit(IOSM_DEVLINK_INIT, &ipc_imem->flag))
1171	ipc_devlink_deinit(ipc_imem->ipc_devlink);	1178	ipc_devlink_deinit(ipc_imem->ipc_devlink);
1172		1179
1173	ipc_imem_device_ipc_uninit(ipc_imem);	1180	ipc_imem_device_ipc_uninit(ipc_imem);
@@ -1263,7 +1270,6 @@ struct iosm_imem ipc_imem_init(struct iosm_pcie pcie, unsigned int device_id, · 89 unmodified lines
1263		1270
1264	ipc_imem->pci_device_id = device_id;	1271	ipc_imem->pci_device_id = device_id;
1265		1272
1266	ipc_imem->ev_cdev_write_pending = false;
1267	ipc_imem->cp_version = 0;	1273	ipc_imem->cp_version = 0;
1268	ipc_imem->device_sleep = IPC_HOST_SLEEP_ENTER_SLEEP;	1274	ipc_imem->device_sleep = IPC_HOST_SLEEP_ENTER_SLEEP;
1269		1275
@@ -1331,6 +1337,8 @@ struct iosm_imem ipc_imem_init(struct iosm_pcie pcie, unsigned int device_id, · 61 unmodified lines
1331		1337
1332	if (ipc_flash_link_establish(ipc_imem))	1338	if (ipc_flash_link_establish(ipc_imem))
1333	goto devlink_channel_fail;	1339	goto devlink_channel_fail;
		1340
		1341	set_bit(IOSM_DEVLINK_INIT, &ipc_imem->flag);
1334	}	1342	}
1335	return ipc_imem;	1343	return ipc_imem;
1336	devlink_channel_fail:	1344	devlink_channel_fail:

drivers/net/wwan/iosm/iosm_ipc_imem.h+1−3

 #define IOSM_CHIP_INFO_SIZE_MAX 100
 #define FULLY_FUNCTIONAL 0
+#define IOSM_DEVLINK_INIT 1
 /* List of the supported UL/DL pipes. */
 enum ipc_mem_pipes {
  *				process the irq actions.
  * @flag:			Flag to monitor the state of driver
  * @td_update_timer_suspended:	if true then td update timer suspend
- * @ev_cdev_write_pending:	0 means inform the IPC tasklet to pass
- *				the accumulated uplink buffers to CP.
  * @ev_mux_net_transmit_pending:0 means inform the IPC tasklet to pass
  * @reset_det_n:		Reset detect flag
  * @pcie_wake_n:		Pcie wake flag
 	u8 ev_irq_pending[IPC_IRQ_VECTORS];
 	unsigned long flag;
 	u8 td_update_timer_suspended:1,
-	   ev_cdev_write_pending:1,
 	   ev_mux_net_transmit_pending:1,
 	   reset_det_n:1,
 	   pcie_wake_n:1;

drivers/net/wwan/iosm/iosm_ipc_imem_ops.c+1−6

 static int ipc_imem_tq_cdev_write(struct iosm_imem *ipc_imem, int arg,
 				  void *msg, size_t size)
 {
-	ipc_imem->ev_cdev_write_pending = false;
 	ipc_imem_ul_send(ipc_imem);
 	return 0;
 /* Through tasklet to do sio write. */
 static int ipc_imem_call_cdev_write(struct iosm_imem *ipc_imem)
 {
-	if (ipc_imem->ev_cdev_write_pending)
-		return -1;
-	ipc_imem->ev_cdev_write_pending = true;
 	return ipc_task_queue_send_task(ipc_imem, ipc_imem_tq_cdev_write, 0,
 					NULL, 0, false);
 }
 	/* Release the pipe resources */
 	ipc_imem_pipe_cleanup(ipc_imem, &channel->ul_pipe);
 	ipc_imem_pipe_cleanup(ipc_imem, &channel->dl_pipe);
+	ipc_imem->nr_of_channels--;
 }
 void ipc_imem_sys_devlink_notify_rx(struct iosm_devlink *ipc_devlink,

drivers/nvme/host/core.c+18−5

@@ -666,6 +666,7 @@ blk_status_t nvme_fail_nonready_command(struct nvme_ctrl *ctrl, · 665 unmodified lines
666	struct request *rq)	666	struct request *rq)
667	{	667	{
668	if (ctrl->state != NVME_CTRL_DELETING_NOIO &&	668	if (ctrl->state != NVME_CTRL_DELETING_NOIO &&
		669	ctrl->state != NVME_CTRL_DELETING &&
669	ctrl->state != NVME_CTRL_DEAD &&	670	ctrl->state != NVME_CTRL_DEAD &&
670	!test_bit(NVME_CTRL_FAILFAST_EXPIRED, &ctrl->flags) &&	671	!test_bit(NVME_CTRL_FAILFAST_EXPIRED, &ctrl->flags) &&
671	!blk_noretry_request(rq) && !(rq->cmd_flags & REQ_NVME_MPATH))	672	!blk_noretry_request(rq) && !(rq->cmd_flags & REQ_NVME_MPATH))
@@ -1749,9 +1750,20 @@ static int nvme_configure_metadata(struct nvme_ns ns, struct nvme_id_ns id) · 1077 unmodified lines
1749	*/	1750	*/
1750	if (WARN_ON_ONCE(!(id->flbas & NVME_NS_FLBAS_META_EXT)))	1751	if (WARN_ON_ONCE(!(id->flbas & NVME_NS_FLBAS_META_EXT)))
1751	return -EINVAL;	1752	return -EINVAL;
1752	if (ctrl->max_integrity_segments)	1753
1753	ns->features \|=	1754	ns->features \|= NVME_NS_EXT_LBAS;
1754	(NVME_NS_METADATA_SUPPORTED \| NVME_NS_EXT_LBAS);	1755
		1756	/*
		1757	* The current fabrics transport drivers support namespace
		1758	* metadata formats only if nvme_ns_has_pi() returns true.
		1759	* Suppress support for all other formats so the namespace will
		1760	* have a 0 capacity and not be usable through the block stack.
		1761	*
		1762	* Note, this check will need to be modified if any drivers
		1763	* gain the ability to use other metadata formats.
		1764	*/
		1765	if (ctrl->max_integrity_segments && nvme_ns_has_pi(ns))
		1766	ns->features \|= NVME_NS_METADATA_SUPPORTED;
1755	} else {	1767	} else {
1756	/*	1768	/*
1757	* For PCIe controllers, we can't easily remap the separate	1769	* For PCIe controllers, we can't easily remap the separate
@@ -2696,8 +2708,9 @@ static bool nvme_validate_cntlid(struct nvme_subsystem *subsys, · 938 unmodified lines
2696		2708
2697	if (tmp->cntlid == ctrl->cntlid) {	2709	if (tmp->cntlid == ctrl->cntlid) {
2698	dev_err(ctrl->device,	2710	dev_err(ctrl->device,
2699	"Duplicate cntlid %u with %s, rejecting\n",	2711	"Duplicate cntlid %u with %s, subsys %s, rejecting\n",
2700	ctrl->cntlid, dev_name(tmp->device));	2712	ctrl->cntlid, dev_name(tmp->device),
		2713	subsys->subnqn);
2701	return false;	2714	return false;
2702	}	2715	}
2703		2716

drivers/nvme/host/multipath.c+2−1

 	}
 	if (ana_log_size > ctrl->ana_log_size) {
 		nvme_mpath_stop(ctrl);
-		kfree(ctrl->ana_log_buf);
+		nvme_mpath_uninit(ctrl);
 		ctrl->ana_log_buf = kmalloc(ana_log_size, GFP_KERNEL);
 		if (!ctrl->ana_log_buf)
 			return -ENOMEM;
 {
 	kfree(ctrl->ana_log_buf);
 	ctrl->ana_log_buf = NULL;
+	ctrl->ana_log_size = 0;
 }

drivers/nvme/host/nvme.h+1−1

@@ -709,7 +709,7 @@ static inline bool nvme_check_ready(struct nvme_ctrl ctrl, struct request rq, · 708 unmodified lines
709	return true;	709	return true;
710	if (ctrl->ops->flags & NVME_F_FABRICS &&	710	if (ctrl->ops->flags & NVME_F_FABRICS &&
711	ctrl->state == NVME_CTRL_DELETING)	711	ctrl->state == NVME_CTRL_DELETING)
712	return true;	712	return queue_live;
713	return __nvme_check_ready(ctrl, rq, queue_live);	713	return __nvme_check_ready(ctrl, rq, queue_live);
714	}	714	}
715	int nvme_submit_sync_cmd(struct request_queue q, struct nvme_command cmd,	715	int nvme_submit_sync_cmd(struct request_queue q, struct nvme_command cmd,

drivers/nvme/host/zns.c+4−1

 	zone.len = ns->zsze;
 	zone.capacity = nvme_lba_to_sect(ns, le64_to_cpu(entry->zcap));
 	zone.start = nvme_lba_to_sect(ns, le64_to_cpu(entry->zslba));
-	zone.wp = nvme_lba_to_sect(ns, le64_to_cpu(entry->wp));
+	if (zone.cond == BLK_ZONE_COND_FULL)
+		zone.wp = zone.start + zone.len;
+	else
+		zone.wp = nvme_lba_to_sect(ns, le64_to_cpu(entry->wp));
 	return cb(&zone, idx, data);
 }

drivers/nvme/target/tcp.c+8−1

 	size_t data_len = le32_to_cpu(req->cmd->common.dptr.sgl.length);
 	int ret;
-	if (!nvme_is_write(cmd->req.cmd) ||
+	/*
+	 * This command has not been processed yet, hence we are trying to
+	 * figure out if there is still pending data left to receive. If
+	 * we don't, we can simply prepare for the next pdu and bail out,
+	 * otherwise we will need to prepare a buffer and receive the
+	 * stale data before continuing forward.
+	 */
+	if (!nvme_is_write(cmd->req.cmd) || !data_len ||
 	    data_len > cmd->req.port->inline_data_size) {
 		nvmet_prepare_receive_pdu(queue);
 		return;

drivers/of/irq.c+25−2

@@ -76,6 +76,26 @@ struct device_node of_irq_find_parent(struct device_node child) · 75 unmodified lines
76	}	76	}
77	EXPORT_SYMBOL_GPL(of_irq_find_parent);	77	EXPORT_SYMBOL_GPL(of_irq_find_parent);
78		78
		79	/*
		80	* These interrupt controllers abuse interrupt-map for unspeakable
		81	* reasons and rely on the core code to ignore it (the drivers do
		82	* their own parsing of the property).
		83	*
		84	* If you think of adding to the list for something new, think
		85	* again. There is a high chance that you will be sent back to the
		86	* drawing board.
		87	*/
		88	static const char * const of_irq_imap_abusers[] = {
		89	"CBEA,platform-spider-pic",
		90	"sti,platform-spider-pic",
		91	"realtek,rtl-intc",
		92	"fsl,ls1021a-extirq",
		93	"fsl,ls1043a-extirq",
		94	"fsl,ls1088a-extirq",
		95	"renesas,rza1-irqc",
		96	NULL,
		97	};
		98
79	/**	99	/**
80	* of_irq_parse_raw - Low level interrupt tree parsing	100	* of_irq_parse_raw - Low level interrupt tree parsing
81	* @addr: address specifier (start of "reg" property of the device) in be32 format	101	* @addr: address specifier (start of "reg" property of the device) in be32 format
@@ -159,12 +179,15 @@ int of_irq_parse_raw(const __be32 addr, struct of_phandle_args out_irq) · 77 unmodified lines
159	/*	179	/*
160	* Now check if cursor is an interrupt-controller and	180	* Now check if cursor is an interrupt-controller and
161	* if it is then we are done, unless there is an	181	* if it is then we are done, unless there is an
162	* interrupt-map which takes precedence.	182	* interrupt-map which takes precedence except on one
		183	* of these broken platforms that want to parse
		184	* interrupt-map themselves for $reason.
163	*/	185	*/
164	bool intc = of_property_read_bool(ipar, "interrupt-controller");	186	bool intc = of_property_read_bool(ipar, "interrupt-controller");
165		187
166	imap = of_get_property(ipar, "interrupt-map", &imaplen);	188	imap = of_get_property(ipar, "interrupt-map", &imaplen);
167	if (imap == NULL && intc) {	189	if (intc &&
		190	(!imap \|\| of_device_compatible_match(ipar, of_irq_imap_abusers))) {
168	pr_debug(" -> got it !\n");	191	pr_debug(" -> got it !\n");
169	return 0;	192	return 0;
170	}	193	}

drivers/pci/controller/dwc/pci-exynos.c+1−0

@@ -19,6 +19,7 @@ · 18 unmodified lines
19	#include <linux/platform_device.h>	19	#include <linux/platform_device.h>
20	#include <linux/phy/phy.h>	20	#include <linux/phy/phy.h>
21	#include <linux/regulator/consumer.h>	21	#include <linux/regulator/consumer.h>
		22	#include <linux/module.h>
22		23
23	#include "pcie-designware.h"	24	#include "pcie-designware.h"
24		25

drivers/pci/controller/dwc/pcie-qcom-ep.c+1−0

@@ -18,6 +18,7 @@ · 17 unmodified lines
18	#include <linux/pm_domain.h>	18	#include <linux/pm_domain.h>
19	#include <linux/regmap.h>	19	#include <linux/regmap.h>
20	#include <linux/reset.h>	20	#include <linux/reset.h>
		21	#include <linux/module.h>
21		22
22	#include "pcie-designware.h"	23	#include "pcie-designware.h"
23		24

drivers/pci/controller/pci-aardvark.c+0−9

 #define PCIE_CORE_DEV_ID_REG					0x0
 #define PCIE_CORE_CMD_STATUS_REG				0x4
 #define PCIE_CORE_DEV_REV_REG					0x8
-#define PCIE_CORE_EXP_ROM_BAR_REG				0x30
 #define PCIE_CORE_PCIEXP_CAP					0xc0
 #define PCIE_CORE_ERR_CAPCTL_REG				0x118
 #define     PCIE_CORE_ERR_CAPCTL_ECRC_CHK_TX			BIT(5)
 		*value = advk_readl(pcie, PCIE_CORE_CMD_STATUS_REG);
 		return PCI_BRIDGE_EMUL_HANDLED;
-	case PCI_ROM_ADDRESS1:
-		*value = advk_readl(pcie, PCIE_CORE_EXP_ROM_BAR_REG);
-		return PCI_BRIDGE_EMUL_HANDLED;
 	case PCI_INTERRUPT_LINE: {
 		/*
 		 * From the whole 32bit register we support reading from HW only
 		advk_writel(pcie, new, PCIE_CORE_CMD_STATUS_REG);
 		break;
-	case PCI_ROM_ADDRESS1:
-		advk_writel(pcie, new, PCIE_CORE_EXP_ROM_BAR_REG);
-		break;
 	case PCI_INTERRUPT_LINE:
 		if (mask & (PCI_BRIDGE_CTL_BUS_RESET << 16)) {
 			u32 val = advk_readl(pcie, PCIE_CORE_CTRL1_REG);

drivers/pci/controller/pcie-apple.c+12−2

 	int ret, i;
 	reset = gpiod_get_from_of_node(np, "reset-gpios", 0,
-				       GPIOD_OUT_LOW, "#PERST");
+				       GPIOD_OUT_LOW, "PERST#");
 	if (IS_ERR(reset))
 		return PTR_ERR(reset);
 	rmw_set(PORT_APPCLK_EN, port->base + PORT_APPCLK);
+	/* Assert PERST# before setting up the clock */
+	gpiod_set_value(reset, 1);
 	ret = apple_pcie_setup_refclk(pcie, port);
 	if (ret < 0)
 		return ret;
+	/* The minimal Tperst-clk value is 100us (PCIe CEM r5.0, 2.9.2) */
+	usleep_range(100, 200);
+	/* Deassert PERST# */
 	rmw_set(PORT_PERST_OFF, port->base + PORT_PERST);
-	gpiod_set_value(reset, 1);
+	gpiod_set_value(reset, 0);
+	/* Wait for 100ms after PERST# deassertion (PCIe r5.0, 6.6.1) */
+	msleep(100);
 	ret = readl_relaxed_poll_timeout(port->base + PORT_STATUS, stat,
 					 stat & PORT_STATUS_READY, 100, 250000);

drivers/phy/hisilicon/phy-hi3670-pcie.c+2−2

@@ -757,8 +757,8 @@ static int hi3670_pcie_phy_get_resources(struct hi3670_pcie_phy *phy, · 756 unmodified lines
757	return PTR_ERR(phy->sysctrl);	757	return PTR_ERR(phy->sysctrl);
758		758
759	phy->pmctrl = syscon_regmap_lookup_by_compatible("hisilicon,hi3670-pmctrl");	759	phy->pmctrl = syscon_regmap_lookup_by_compatible("hisilicon,hi3670-pmctrl");
760	if (IS_ERR(phy->sysctrl))	760	if (IS_ERR(phy->pmctrl))
761	return PTR_ERR(phy->sysctrl);	761	return PTR_ERR(phy->pmctrl);
762		762
763	/* clocks */	763	/* clocks */
764	phy->phy_ref_clk = devm_clk_get(dev, "phy_ref");	764	phy->phy_ref_clk = devm_clk_get(dev, "phy_ref");

drivers/phy/marvell/phy-mvebu-cp110-utmi.c+2−2

@@ -82,9 +82,9 @@ · 81 unmodified lines
82	* struct mvebu_cp110_utmi - PHY driver data	82	* struct mvebu_cp110_utmi - PHY driver data
83	*	83	*
84	* @regs: PHY registers	84	* @regs: PHY registers
85	* @syscom: Regmap with system controller registers	85	* @syscon: Regmap with system controller registers
86	* @dev: device driver handle	86	* @dev: device driver handle
87	* @caps: PHY capabilities	87	* @ops: phy ops
88	*/	88	*/
89	struct mvebu_cp110_utmi {	89	struct mvebu_cp110_utmi {
90	void __iomem *regs;	90	void __iomem *regs;

drivers/phy/qualcomm/phy-qcom-ipq806x-usb.c+14−12

 };
 /**
- * Write register and read back masked value to confirm it is written
+ * usb_phy_write_readback() - Write register and read back masked value to
+ * confirm it is written
  *
- * @base - QCOM DWC3 PHY base virtual address.
+ * @phy_dwc3: QCOM DWC3 phy context
- * @offset - register offset.
+ * @offset: register offset.
- * @mask - register bitmask specifying what should be updated
+ * @mask: register bitmask specifying what should be updated
- * @val - value to write.
+ * @val: value to write.
  */
 static inline void usb_phy_write_readback(struct usb_phy *phy_dwc3,
 					  u32 offset,
 }
 /**
- * Write SSPHY register
+ * usb_ss_write_phycreg() - Write SSPHY register
  *
- * @base - QCOM DWC3 PHY base virtual address.
+ * @phy_dwc3: QCOM DWC3 phy context
- * @addr - SSPHY address to write.
+ * @addr: SSPHY address to write.
- * @val - value to write.
+ * @val: value to write.
  */
 static int usb_ss_write_phycreg(struct usb_phy *phy_dwc3,
 				u32 addr, u32 val)
 }
 /**
- * Read SSPHY register.
+ * usb_ss_read_phycreg() - Read SSPHY register.
  *
- * @base - QCOM DWC3 PHY base virtual address.
+ * @phy_dwc3: QCOM DWC3 phy context
- * @addr - SSPHY address to read.
+ * @addr: SSPHY address to read.
+ * @val: pointer in which read is store.
  */
 static int usb_ss_read_phycreg(struct usb_phy *phy_dwc3,
 			       u32 addr, u32 *val)

drivers/phy/qualcomm/phy-qcom-qmp.c+3−0

  * @qmp: QMP phy to which this lane belongs
  * @lane_rst: lane's reset controller
  * @mode: current PHY mode
+ * @dp_aux_cfg: Display port aux config
+ * @dp_opts: Display port optional config
+ * @dp_clks: Display port clocks
  */
 struct qmp_phy {
 	struct phy *phy;

drivers/phy/qualcomm/phy-qcom-usb-hsic.c+1−1

@@ -1,5 +1,5 @@
1	// SPDX-License-Identifier: GPL-2.0-only	1	// SPDX-License-Identifier: GPL-2.0-only
2	/**	2	/*
3	* Copyright (C) 2016 Linaro Ltd	3	* Copyright (C) 2016 Linaro Ltd
4	*/	4	*/
5	#include <linux/module.h>	5	#include <linux/module.h>

drivers/phy/st/phy-stm32-usbphyc.c+1−1

@@ -478,7 +478,7 @@ static void stm32_usbphyc_phy_tuning(struct stm32_usbphyc *usbphyc, · 477 unmodified lines
478	if (!of_property_read_bool(np, "st,no-lsfs-fb-cap"))	478	if (!of_property_read_bool(np, "st,no-lsfs-fb-cap"))
479	usbphyc_phy->tune \|= LFSCAPEN;	479	usbphyc_phy->tune \|= LFSCAPEN;
480		480
481	if (of_property_read_bool(np, "st,slow-hs-slew-rate"))	481	if (of_property_read_bool(np, "st,decrease-hs-slew-rate"))
482	usbphyc_phy->tune \|= HSDRVSLEW;	482	usbphyc_phy->tune \|= HSDRVSLEW;
483		483
484	ret = of_property_read_u32(np, "st,tune-hs-dc-level", &val);	484	ret = of_property_read_u32(np, "st,tune-hs-dc-level", &val);

drivers/phy/ti/phy-am654-serdes.c+1−1

@@ -1,5 +1,5 @@
1	// SPDX-License-Identifier: GPL-2.0	1	// SPDX-License-Identifier: GPL-2.0
2	/**	2	/*
3	* PCIe SERDES driver for AM654x SoC	3	* PCIe SERDES driver for AM654x SoC
4	*	4	*
5	* Copyright (C) 2018 - 2019 Texas Instruments Incorporated - http://www.ti.com/	5	* Copyright (C) 2018 - 2019 Texas Instruments Incorporated - http://www.ti.com/

drivers/phy/ti/phy-j721e-wiz.c+1−1

@@ -1,5 +1,5 @@
1	// SPDX-License-Identifier: GPL-2.0	1	// SPDX-License-Identifier: GPL-2.0
2	/**	2	/*
3	* Wrapper driver for SERDES used in J721E	3	* Wrapper driver for SERDES used in J721E
4	*	4	*
5	* Copyright (C) 2019 Texas Instruments Incorporated - http://www.ti.com/	5	* Copyright (C) 2019 Texas Instruments Incorporated - http://www.ti.com/

drivers/phy/ti/phy-omap-usb2.c+3−3

@@ -89,9 +89,9 @@ static inline void omap_usb_writel(void __iomem *addr, unsigned int offset, · 88 unmodified lines
89	}	89	}
90		90
91	/**	91	/**
92	* omap_usb2_set_comparator - links the comparator present in the system with	92	* omap_usb2_set_comparator() - links the comparator present in the system with this phy
93	* this phy	93	*
94	* @comparator - the companion phy(comparator) for this phy	94	* @comparator: the companion phy(comparator) for this phy
95	*	95	*
96	* The phy companion driver should call this API passing the phy_companion	96	* The phy companion driver should call this API passing the phy_companion
97	* filled with set_vbus and start_srp to be used by usb phy.	97	* filled with set_vbus and start_srp to be used by usb phy.

drivers/phy/ti/phy-tusb1210.c+1−1

@@ -1,5 +1,5 @@
1	// SPDX-License-Identifier: GPL-2.0-only	1	// SPDX-License-Identifier: GPL-2.0-only
2	/**	2	/*
3	* tusb1210.c - TUSB1210 USB ULPI PHY driver	3	* tusb1210.c - TUSB1210 USB ULPI PHY driver
4	*	4	*
5	* Copyright (C) 2015 Intel Corporation	5	* Copyright (C) 2015 Intel Corporation

drivers/platform/x86/amd-pmc.c+1−1

@@ -76,7 +76,7 @@ · 75 unmodified lines
76	#define AMD_CPU_ID_CZN AMD_CPU_ID_RN	76	#define AMD_CPU_ID_CZN AMD_CPU_ID_RN
77	#define AMD_CPU_ID_YC 0x14B5	77	#define AMD_CPU_ID_YC 0x14B5
78		78
79	#define PMC_MSG_DELAY_MIN_US 100	79	#define PMC_MSG_DELAY_MIN_US 50
80	#define RESPONSE_REGISTER_LOOP_MAX 20000	80	#define RESPONSE_REGISTER_LOOP_MAX 20000
81		81
82	#define SOC_SUBSYSTEM_IP_MAX 12	82	#define SOC_SUBSYSTEM_IP_MAX 12

drivers/platform/x86/intel/hid.c+7−0

@@ -99,6 +99,13 @@ static const struct dmi_system_id button_array_table[] = { · 98 unmodified lines
99	DMI_MATCH(DMI_PRODUCT_FAMILY, "ThinkPad X1 Tablet Gen 2"),	99	DMI_MATCH(DMI_PRODUCT_FAMILY, "ThinkPad X1 Tablet Gen 2"),
100	},	100	},
101	},	101	},
		102	{
		103	.ident = "Microsoft Surface Go 3",
		104	.matches = {
		105	DMI_MATCH(DMI_SYS_VENDOR, "Microsoft Corporation"),
		106	DMI_MATCH(DMI_PRODUCT_NAME, "Surface Go 3"),
		107	},
		108	},
102	{ }	109	{ }
103	};	110	};
104		111

drivers/platform/x86/lg-laptop.c+12−0

@@ -657,6 +657,18 @@ static int acpi_add(struct acpi_device *device) · 656 unmodified lines
657	if (product && strlen(product) > 4)	657	if (product && strlen(product) > 4)
658	switch (product[4]) {	658	switch (product[4]) {
659	case '5':	659	case '5':
		660	if (strlen(product) > 5)
		661	switch (product[5]) {
		662	case 'N':
		663	year = 2021;
		664	break;
		665	case '0':
		666	year = 2016;
		667	break;
		668	default:
		669	year = 2022;
		670	}
		671	break;
660	case '6':	672	case '6':
661	year = 2016;	673	year = 2016;
662	break;	674	break;

drivers/platform/x86/thinkpad_acpi.c+4−2

 	&dev_attr_hotkey_all_mask.attr,
 	&dev_attr_hotkey_adaptive_all_mask.attr,
 	&dev_attr_hotkey_recommended_mask.attr,
+	&dev_attr_hotkey_tablet_mode.attr,
+	&dev_attr_hotkey_radio_sw.attr,
 #ifdef CONFIG_THINKPAD_ACPI_HOTKEY_POLL
 	&dev_attr_hotkey_source_mask.attr,
 	&dev_attr_hotkey_poll_freq.attr,
 	"tpacpi::standby",
 	"tpacpi::dock_status1",
 	"tpacpi::dock_status2",
-	"tpacpi::unknown_led2",
+	"tpacpi::lid_logo_dot",
 	"tpacpi::unknown_led3",
 	"tpacpi::thinkvantage",
 };
-#define TPACPI_SAFE_LEDS	0x1081U
+#define TPACPI_SAFE_LEDS	0x1481U
 static inline bool tpacpi_is_led_restricted(const unsigned int led)
 {

drivers/platform/x86/touchscreen_dmi.c+18−0

@@ -905,6 +905,16 @@ static const struct ts_dmi_data trekstor_primetab_t13b_data = { · 904 unmodified lines
905	.properties = trekstor_primetab_t13b_props,	905	.properties = trekstor_primetab_t13b_props,
906	};	906	};
907		907
		908	static const struct property_entry trekstor_surftab_duo_w1_props[] = {
		909	PROPERTY_ENTRY_BOOL("touchscreen-inverted-x"),
		910	{ }
		911	};
		912
		913	static const struct ts_dmi_data trekstor_surftab_duo_w1_data = {
		914	.acpi_name = "GDIX1001:00",
		915	.properties = trekstor_surftab_duo_w1_props,
		916	};
		917
908	static const struct property_entry trekstor_surftab_twin_10_1_props[] = {	918	static const struct property_entry trekstor_surftab_twin_10_1_props[] = {
909	PROPERTY_ENTRY_U32("touchscreen-min-x", 20),	919	PROPERTY_ENTRY_U32("touchscreen-min-x", 20),
910	PROPERTY_ENTRY_U32("touchscreen-min-y", 0),	920	PROPERTY_ENTRY_U32("touchscreen-min-y", 0),
@@ -1502,6 +1512,14 @@ const struct dmi_system_id touchscreen_dmi_table[] = { · 591 unmodified lines
1502	DMI_MATCH(DMI_PRODUCT_NAME, "Primetab T13B"),	1512	DMI_MATCH(DMI_PRODUCT_NAME, "Primetab T13B"),
1503	},	1513	},
1504	},	1514	},
		1515	{
		1516	/* TrekStor SurfTab duo W1 10.1 ST10432-10b */
		1517	.driver_data = (void *)&trekstor_surftab_duo_w1_data,
		1518	.matches = {
		1519	DMI_MATCH(DMI_SYS_VENDOR, "TrekStor"),
		1520	DMI_MATCH(DMI_PRODUCT_NAME, "SurfTab duo W1 10.1 (VT4)"),
		1521	},
		1522	},
1505	{	1523	{
1506	/* TrekStor SurfTab twin 10.1 ST10432-8 */	1524	/* TrekStor SurfTab twin 10.1 ST10432-8 */
1507	.driver_data = (void *)&trekstor_surftab_twin_10_1_data,	1525	.driver_data = (void *)&trekstor_surftab_twin_10_1_data,

drivers/powercap/dtpm.c+0−5

 static int __init init_dtpm(void)
 {
-	struct dtpm_descr *dtpm_descr;
 	pct = powercap_register_control_type(NULL, "dtpm", NULL);
 	if (IS_ERR(pct)) {
 		pr_err("Failed to register control type\n");
 		return PTR_ERR(pct);
 	}
-	for_each_dtpm_table(dtpm_descr)
-		dtpm_descr->init();
 	return 0;
 }
 late_initcall(init_dtpm);

drivers/scsi/lpfc/lpfc_els.c+2−7

 		/* NPort Recovery mode or node is just allocated */
 		if (!lpfc_nlp_not_used(ndlp)) {
 			/* A LOGO is completing and the node is in NPR state.
-			 * If this a fabric node that cleared its transport
+			 * Just unregister the RPI because the node is still
-			 * registration, release the rpi.
+			 * required.
 			 */
-			spin_lock_irq(&ndlp->lock);
-			ndlp->nlp_flag &= ~NLP_NPR_2B_DISC;
-			if (phba->sli_rev == LPFC_SLI_REV4)
-				ndlp->nlp_flag |= NLP_RELEASE_RPI;
-			spin_unlock_irq(&ndlp->lock);
 			lpfc_unreg_rpi(vport, ndlp);
 		} else {
 			/* Indicate the node has already released, should

drivers/scsi/pm8001/pm8001_init.c+2−4

 	if (rc) {
 		pm8001_dbg(pm8001_ha, FAIL,
 			   "pm8001_setup_irq failed [ret: %d]\n", rc);
-		goto err_out_shost;
+		goto err_out;
 	}
 	/* Request Interrupt */
 	rc = pm8001_request_irq(pm8001_ha);
 	if (rc)
-		goto err_out_shost;
+		goto err_out;
 	count = pm8001_ha->max_q_num;
 	/* Queues are chosen based on the number of cores/msix availability */
 	pm8001_tag_init(pm8001_ha);
 	return 0;
-err_out_shost:
-	scsi_remove_host(pm8001_ha->shost);
 err_out_nodev:
 	for (i = 0; i < pm8001_ha->max_memcnt; i++) {
 		if (pm8001_ha->memoryMap.region[i].virt_ptr != NULL) {

drivers/scsi/qedi/qedi_fw.c+15−22

 {
 	struct qedi_work_map *work, *work_tmp;
 	u32 proto_itt = cqe->itid;
-	itt_t protoitt = 0;
 	int found = 0;
 	struct qedi_cmd *qedi_cmd = NULL;
 	u32 iscsi_cid;
 	return;
 check_cleanup_reqs:
-	if (qedi_conn->cmd_cleanup_req > 0) {
+	if (atomic_inc_return(&qedi_conn->cmd_cleanup_cmpl) ==
-		QEDI_INFO(&qedi->dbg_ctx, QEDI_LOG_TID,
+	    qedi_conn->cmd_cleanup_req) {
+		QEDI_INFO(&qedi->dbg_ctx, QEDI_LOG_SCSI_TM,
 			  "Freeing tid=0x%x for cid=0x%x\n",
 			  cqe->itid, qedi_conn->iscsi_conn_id);
-		qedi_conn->cmd_cleanup_cmpl++;
 		wake_up(&qedi_conn->wait_queue);
-	} else {
-		QEDI_ERR(&qedi->dbg_ctx,
-			 "Delayed or untracked cleanup response, itt=0x%x, tid=0x%x, cid=0x%x\n",
-			 protoitt, cqe->itid, qedi_conn->iscsi_conn_id);
 	}
 }
 	}
 	qedi_conn->cmd_cleanup_req = 0;
-	qedi_conn->cmd_cleanup_cmpl = 0;
+	atomic_set(&qedi_conn->cmd_cleanup_cmpl, 0);
 	QEDI_INFO(&qedi->dbg_ctx, QEDI_LOG_SCSI_TM,
 		  "active_cmd_count=%d, cid=0x%x, in_recovery=%d, lun_reset=%d\n",
 		  qedi_conn->iscsi_conn_id);
 	rval  = wait_event_interruptible_timeout(qedi_conn->wait_queue,
-						 ((qedi_conn->cmd_cleanup_req ==
+				(qedi_conn->cmd_cleanup_req ==
-						 qedi_conn->cmd_cleanup_cmpl) ||
+				 atomic_read(&qedi_conn->cmd_cleanup_cmpl)) ||
-						 test_bit(QEDI_IN_RECOVERY,
+				test_bit(QEDI_IN_RECOVERY, &qedi->flags),
-							  &qedi->flags)),
+				5 * HZ);
-						 5 * HZ);
 	if (rval) {
 		QEDI_INFO(&qedi->dbg_ctx, QEDI_LOG_SCSI_TM,
 			  "i/o cmd_cleanup_req=%d, equal to cmd_cleanup_cmpl=%d, cid=0x%x\n",
 			  qedi_conn->cmd_cleanup_req,
-			  qedi_conn->cmd_cleanup_cmpl,
+			  atomic_read(&qedi_conn->cmd_cleanup_cmpl),
 			  qedi_conn->iscsi_conn_id);
 		return 0;
 	QEDI_INFO(&qedi->dbg_ctx, QEDI_LOG_SCSI_TM,
 		  "i/o cmd_cleanup_req=%d, not equal to cmd_cleanup_cmpl=%d, cid=0x%x\n",
 		  qedi_conn->cmd_cleanup_req,
-		  qedi_conn->cmd_cleanup_cmpl,
+		  atomic_read(&qedi_conn->cmd_cleanup_cmpl),
 		  qedi_conn->iscsi_conn_id);
 	iscsi_host_for_each_session(qedi->shost,
 	/* Enable IOs for all other sessions except current.*/
 	if (!wait_event_interruptible_timeout(qedi_conn->wait_queue,
-					      (qedi_conn->cmd_cleanup_req ==
+				(qedi_conn->cmd_cleanup_req ==
-					       qedi_conn->cmd_cleanup_cmpl) ||
+				 atomic_read(&qedi_conn->cmd_cleanup_cmpl)) ||
-					       test_bit(QEDI_IN_RECOVERY,
+				test_bit(QEDI_IN_RECOVERY, &qedi->flags),
-							&qedi->flags),
+				5 * HZ)) {
-					      5 * HZ)) {
 		iscsi_host_for_each_session(qedi->shost,
 					    qedi_mark_device_available);
 		return -1;
 	qedi_ep = qedi_conn->ep;
 	qedi_conn->cmd_cleanup_req = 0;
-	qedi_conn->cmd_cleanup_cmpl = 0;
+	atomic_set(&qedi_conn->cmd_cleanup_cmpl, 0);
 	if (!qedi_ep) {
 		QEDI_WARN(&qedi->dbg_ctx,

drivers/scsi/qedi/qedi_iscsi.c+1−1

@@ -412,7 +412,7 @@ static int qedi_conn_bind(struct iscsi_cls_session *cls_session, · 411 unmodified lines
412	qedi_conn->iscsi_conn_id = qedi_ep->iscsi_cid;	412	qedi_conn->iscsi_conn_id = qedi_ep->iscsi_cid;
413	qedi_conn->fw_cid = qedi_ep->fw_cid;	413	qedi_conn->fw_cid = qedi_ep->fw_cid;
414	qedi_conn->cmd_cleanup_req = 0;	414	qedi_conn->cmd_cleanup_req = 0;
415	qedi_conn->cmd_cleanup_cmpl = 0;	415	atomic_set(&qedi_conn->cmd_cleanup_cmpl, 0);
416		416
417	if (qedi_bind_conn_to_iscsi_cid(qedi, qedi_conn)) {	417	if (qedi_bind_conn_to_iscsi_cid(qedi, qedi_conn)) {
418	rc = -EINVAL;	418	rc = -EINVAL;

drivers/scsi/qedi/qedi_iscsi.h+1−1

@@ -155,7 +155,7 @@ struct qedi_conn { · 154 unmodified lines
155	spinlock_t list_lock; /* internal conn lock */	155	spinlock_t list_lock; /* internal conn lock */
156	u32 active_cmd_count;	156	u32 active_cmd_count;
157	u32 cmd_cleanup_req;	157	u32 cmd_cleanup_req;
158	u32 cmd_cleanup_cmpl;	158	atomic_t cmd_cleanup_cmpl;
159		159
160	u32 iscsi_conn_id;	160	u32 iscsi_conn_id;
161	int itt;	161	int itt;

drivers/scsi/qla2xxx/qla_dbg.c+3−0

@@ -2491,6 +2491,9 @@ ql_dbg(uint level, scsi_qla_host_t vha, uint id, const char fmt, ...) · 2490 unmodified lines
2491	struct va_format vaf;	2491	struct va_format vaf;
2492	char pbuf[64];	2492	char pbuf[64];
2493		2493
		2494	if (!ql_mask_match(level) && !trace_ql_dbg_log_enabled())
		2495	return;
		2496
2494	va_start(va, fmt);	2497	va_start(va, fmt);
2495		2498
2496	vaf.fmt = fmt;	2499	vaf.fmt = fmt;

drivers/scsi/scsi_debug.c+1−1

@@ -4342,7 +4342,7 @@ static int resp_report_zones(struct scsi_cmnd *scp, · 4341 unmodified lines
4342	rep_max_zones = min((alloc_len - 64) >> ilog2(RZONES_DESC_HD),	4342	rep_max_zones = min((alloc_len - 64) >> ilog2(RZONES_DESC_HD),
4343	max_zones);	4343	max_zones);
4344		4344
4345	arr = kcalloc(RZONES_DESC_HD, alloc_len, GFP_ATOMIC);	4345	arr = kzalloc(alloc_len, GFP_ATOMIC);
4346	if (!arr) {	4346	if (!arr) {
4347	mk_sense_buffer(scp, ILLEGAL_REQUEST, INSUFF_RES_ASC,	4347	mk_sense_buffer(scp, ILLEGAL_REQUEST, INSUFF_RES_ASC,
4348	INSUFF_RES_ASCQ);	4348	INSUFF_RES_ASCQ);

drivers/scsi/ufs/ufshcd-pci.c+18−0

 	return err;
 }
+static int ufs_intel_adl_init(struct ufs_hba *hba)
+{
+	hba->nop_out_timeout = 200;
+	hba->quirks |= UFSHCD_QUIRK_BROKEN_AUTO_HIBERN8;
+	return ufs_intel_common_init(hba);
+}
 static struct ufs_hba_variant_ops ufs_intel_cnl_hba_vops = {
 	.name                   = "intel-pci",
 	.init			= ufs_intel_common_init,
 	.device_reset		= ufs_intel_device_reset,
 };
+static struct ufs_hba_variant_ops ufs_intel_adl_hba_vops = {
+	.name			= "intel-pci",
+	.init			= ufs_intel_adl_init,
+	.exit			= ufs_intel_common_exit,
+	.link_startup_notify	= ufs_intel_link_startup_notify,
+	.resume			= ufs_intel_resume,
+	.device_reset		= ufs_intel_device_reset,
+};
 #ifdef CONFIG_PM_SLEEP
 static int ufshcd_pci_restore(struct device *dev)
 {
 	{ PCI_VDEVICE(INTEL, 0x4B41), (kernel_ulong_t)&ufs_intel_ehl_hba_vops },
 	{ PCI_VDEVICE(INTEL, 0x4B43), (kernel_ulong_t)&ufs_intel_ehl_hba_vops },
 	{ PCI_VDEVICE(INTEL, 0x98FA), (kernel_ulong_t)&ufs_intel_lkf_hba_vops },
+	{ PCI_VDEVICE(INTEL, 0x51FF), (kernel_ulong_t)&ufs_intel_adl_hba_vops },
+	{ PCI_VDEVICE(INTEL, 0x54FF), (kernel_ulong_t)&ufs_intel_adl_hba_vops },
 	{ }	/* terminate list */
 };

drivers/thermal/intel/int340x_thermal/processor_thermal_rfim.c+1−1

@@ -29,7 +29,7 @@ static const char * const fivr_strings[] = { · 28 unmodified lines
29	};	29	};
30		30
31	static const struct mmio_reg tgl_fivr_mmio_regs[] = {	31	static const struct mmio_reg tgl_fivr_mmio_regs[] = {
32	{ 0, 0x5A18, 3, 0x7, 12}, /* vco_ref_code_lo */	32	{ 0, 0x5A18, 3, 0x7, 11}, /* vco_ref_code_lo */
33	{ 0, 0x5A18, 8, 0xFF, 16}, /* vco_ref_code_hi */	33	{ 0, 0x5A18, 8, 0xFF, 16}, /* vco_ref_code_hi */
34	{ 0, 0x5A08, 8, 0xFF, 0}, /* spread_spectrum_pct */	34	{ 0, 0x5A08, 8, 0xFF, 0}, /* spread_spectrum_pct */
35	{ 0, 0x5A08, 1, 0x1, 8}, /* spread_spectrum_clk_enable */	35	{ 0, 0x5A08, 1, 0x1, 8}, /* spread_spectrum_clk_enable */

drivers/tty/serial/8250/8250_bcm7271.c+13−0

 	u32		rx_err;
 	u32		rx_timeout;
 	u32		rx_abort;
+	u32		saved_mctrl;
 };
 static struct dentry *brcmuart_debugfs_root;
 static int __maybe_unused brcmuart_suspend(struct device *dev)
 {
 	struct brcmuart_priv *priv = dev_get_drvdata(dev);
+	struct uart_8250_port *up = serial8250_get_port(priv->line);
+	struct uart_port *port = &up->port;
 	serial8250_suspend_port(priv->line);
 	clk_disable_unprepare(priv->baud_mux_clk);
+	/*
+	 * This will prevent resume from enabling RTS before the
+	 *  baud rate has been resored.
+	 */
+	priv->saved_mctrl = port->mctrl;
+	port->mctrl = 0;
 	return 0;
 }
 static int __maybe_unused brcmuart_resume(struct device *dev)
 {
 	struct brcmuart_priv *priv = dev_get_drvdata(dev);
+	struct uart_8250_port *up = serial8250_get_port(priv->line);
+	struct uart_port *port = &up->port;
 	int ret;
 	ret = clk_prepare_enable(priv->baud_mux_clk);
 		start_rx_dma(serial8250_get_port(priv->line));
 	}
 	serial8250_resume_port(priv->line);
+	port->mctrl = priv->saved_mctrl;
 	return 0;
 }

drivers/tty/serial/8250/8250_pci.c+25−14

@@ -1324,29 +1324,33 @@ pericom_do_set_divisor(struct uart_port *port, unsigned int baud, · 1323 unmodified lines
1324	{	1324	{
1325	int scr;	1325	int scr;
1326	int lcr;	1326	int lcr;
1327	int actual_baud;
1328	int tolerance;
1329		1327
1330	for (scr = 5 ; scr <= 15 ; scr++) {	1328	for (scr = 16; scr > 4; scr--) {
1331	actual_baud = 921600 * 16 / scr;	1329	unsigned int maxrate = port->uartclk / scr;
1332	tolerance = actual_baud / 50;	1330	unsigned int divisor = max(maxrate / baud, 1U);
		1331	int delta = maxrate / divisor - baud;
1333		1332
1334	if ((baud < actual_baud + tolerance) &&	1333	if (baud > maxrate + baud / 50)
1335	(baud > actual_baud - tolerance)) {	1334	continue;
1336		1335
		1336	if (delta > baud / 50)
		1337	divisor++;
		1338
		1339	if (divisor > 0xffff)
		1340	continue;
		1341
		1342	/* Update delta due to possible divisor change */
		1343	delta = maxrate / divisor - baud;
		1344	if (abs(delta) < baud / 50) {
1337	lcr = serial_port_in(port, UART_LCR);	1345	lcr = serial_port_in(port, UART_LCR);
1338	serial_port_out(port, UART_LCR, lcr \| 0x80);	1346	serial_port_out(port, UART_LCR, lcr \| 0x80);
1339		1347	serial_port_out(port, UART_DLL, divisor & 0xff);
1340	serial_port_out(port, UART_DLL, 1);	1348	serial_port_out(port, UART_DLM, divisor >> 8 & 0xff);
1341	serial_port_out(port, UART_DLM, 0);
1342	serial_port_out(port, 2, 16 - scr);	1349	serial_port_out(port, 2, 16 - scr);
1343	serial_port_out(port, UART_LCR, lcr);	1350	serial_port_out(port, UART_LCR, lcr);
1344	return;	1351	return;
1345	} else if (baud > actual_baud) {
1346	break;
1347	}	1352	}
1348	}	1353	}
1349	serial8250_do_set_divisor(port, baud, quot, quot_frac);
1350	}	1354	}
1351	static int pci_pericom_setup(struct serial_private *priv,	1355	static int pci_pericom_setup(struct serial_private *priv,
1352	const struct pciserial_board *board,	1356	const struct pciserial_board *board,
@@ -2291,12 +2295,19 @@ static struct pci_serial_quirk pci_serial_quirks[] = { · 938 unmodified lines
2291	.setup = pci_pericom_setup_four_at_eight,	2295	.setup = pci_pericom_setup_four_at_eight,
2292	},	2296	},
2293	{	2297	{
2294	.vendor = PCI_DEVICE_ID_ACCESIO_PCIE_ICM_4S,	2298	.vendor = PCI_VENDOR_ID_ACCESIO,
2295	.device = PCI_DEVICE_ID_ACCESIO_PCIE_ICM232_4,	2299	.device = PCI_DEVICE_ID_ACCESIO_PCIE_ICM232_4,
2296	.subvendor = PCI_ANY_ID,	2300	.subvendor = PCI_ANY_ID,
2297	.subdevice = PCI_ANY_ID,	2301	.subdevice = PCI_ANY_ID,
2298	.setup = pci_pericom_setup_four_at_eight,	2302	.setup = pci_pericom_setup_four_at_eight,
2299	},	2303	},
		2304	{
		2305	.vendor = PCI_VENDOR_ID_ACCESIO,
		2306	.device = PCI_DEVICE_ID_ACCESIO_PCIE_ICM_4S,
		2307	.subvendor = PCI_ANY_ID,
		2308	.subdevice = PCI_ANY_ID,
		2309	.setup = pci_pericom_setup_four_at_eight,
		2310	},
2300	{	2311	{
2301	.vendor = PCI_VENDOR_ID_ACCESIO,	2312	.vendor = PCI_VENDOR_ID_ACCESIO,
2302	.device = PCI_DEVICE_ID_ACCESIO_MPCIE_ICM232_4,	2313	.device = PCI_DEVICE_ID_ACCESIO_MPCIE_ICM232_4,

drivers/tty/serial/8250/8250_port.c+0−7

@@ -2024,13 +2024,6 @@ void serial8250_do_set_mctrl(struct uart_port *port, unsigned int mctrl) · 2023 unmodified lines
2024	struct uart_8250_port *up = up_to_u8250p(port);	2024	struct uart_8250_port *up = up_to_u8250p(port);
2025	unsigned char mcr;	2025	unsigned char mcr;
2026		2026
2027	if (port->rs485.flags & SER_RS485_ENABLED) {
2028	if (serial8250_in_MCR(up) & UART_MCR_RTS)
2029	mctrl \|= TIOCM_RTS;
2030	else
2031	mctrl &= ~TIOCM_RTS;
2032	}
2033
2034	mcr = serial8250_TIOCM_to_MCR(mctrl);	2027	mcr = serial8250_TIOCM_to_MCR(mctrl);
2035		2028
2036	mcr = (mcr & up->mcr_mask) \| up->mcr_force \| up->mcr;	2029	mcr = (mcr & up->mcr_mask) \| up->mcr_force \| up->mcr;

drivers/tty/serial/Kconfig+1−1

@@ -1533,7 +1533,7 @@ config SERIAL_LITEUART · 1532 unmodified lines
1533	tristate "LiteUART serial port support"	1533	tristate "LiteUART serial port support"
1534	depends on HAS_IOMEM	1534	depends on HAS_IOMEM
1535	depends on OF \|\| COMPILE_TEST	1535	depends on OF \|\| COMPILE_TEST
1536	depends on LITEX	1536	depends on LITEX \|\| COMPILE_TEST
1537	select SERIAL_CORE	1537	select SERIAL_CORE
1538	help	1538	help
1539	This driver is for the FPGA-based LiteUART serial controller from LiteX	1539	This driver is for the FPGA-based LiteUART serial controller from LiteX

drivers/tty/serial/amba-pl011.c+1−0

@@ -2947,6 +2947,7 @@ MODULE_DEVICE_TABLE(of, sbsa_uart_of_match); · 2946 unmodified lines
2947		2947
2948	static const struct acpi_device_id __maybe_unused sbsa_uart_acpi_match[] = {	2948	static const struct acpi_device_id __maybe_unused sbsa_uart_acpi_match[] = {
2949	{ "ARMH0011", 0 },	2949	{ "ARMH0011", 0 },
		2950	{ "ARMHB000", 0 },
2950	{},	2951	{},
2951	};	2952	};
2952	MODULE_DEVICE_TABLE(acpi, sbsa_uart_acpi_match);	2953	MODULE_DEVICE_TABLE(acpi, sbsa_uart_acpi_match);

drivers/tty/serial/fsl_lpuart.c+1−0

@@ -2625,6 +2625,7 @@ OF_EARLYCON_DECLARE(lpuart, "fsl,vf610-lpuart", lpuart_early_console_setup); · 2624 unmodified lines
2625	OF_EARLYCON_DECLARE(lpuart32, "fsl,ls1021a-lpuart", lpuart32_early_console_setup);	2625	OF_EARLYCON_DECLARE(lpuart32, "fsl,ls1021a-lpuart", lpuart32_early_console_setup);
2626	OF_EARLYCON_DECLARE(lpuart32, "fsl,ls1028a-lpuart", ls1028a_early_console_setup);	2626	OF_EARLYCON_DECLARE(lpuart32, "fsl,ls1028a-lpuart", ls1028a_early_console_setup);
2627	OF_EARLYCON_DECLARE(lpuart32, "fsl,imx7ulp-lpuart", lpuart32_imx_early_console_setup);	2627	OF_EARLYCON_DECLARE(lpuart32, "fsl,imx7ulp-lpuart", lpuart32_imx_early_console_setup);
		2628	OF_EARLYCON_DECLARE(lpuart32, "fsl,imx8qxp-lpuart", lpuart32_imx_early_console_setup);
2628	EARLYCON_DECLARE(lpuart, lpuart_early_console_setup);	2629	EARLYCON_DECLARE(lpuart, lpuart_early_console_setup);
2629	EARLYCON_DECLARE(lpuart32, lpuart32_early_console_setup);	2630	EARLYCON_DECLARE(lpuart32, lpuart32_early_console_setup);
2630		2631

drivers/tty/serial/liteuart.c+17−3

 	/* get membase */
 	port->membase = devm_platform_get_and_ioremap_resource(pdev, 0, NULL);
-	if (IS_ERR(port->membase))
+	if (IS_ERR(port->membase)) {
-		return PTR_ERR(port->membase);
+		ret = PTR_ERR(port->membase);
+		goto err_erase_id;
+	}
 	/* values not from device tree */
 	port->dev = &pdev->dev;
 	port->line = dev_id;
 	spin_lock_init(&port->lock);
-	return uart_add_one_port(&liteuart_driver, &uart->port);
+	platform_set_drvdata(pdev, port);
+	ret = uart_add_one_port(&liteuart_driver, &uart->port);
+	if (ret)
+		goto err_erase_id;
+	return 0;
+err_erase_id:
+	xa_erase(&liteuart_array, uart->id);
+	return ret;
 }
 static int liteuart_remove(struct platform_device *pdev)
 	struct uart_port *port = platform_get_drvdata(pdev);
 	struct liteuart_port *uart = to_liteuart_port(port);
+	uart_remove_one_port(&liteuart_driver, port);
 	xa_erase(&liteuart_array, uart->id);
 	return 0;

drivers/tty/serial/msm_serial.c+3−0

@@ -598,6 +598,9 @@ static void msm_start_rx_dma(struct msm_port *msm_port) · 597 unmodified lines
598	u32 val;	598	u32 val;
599	int ret;	599	int ret;
600		600
		601	if (IS_ENABLED(CONFIG_CONSOLE_POLL))
		602	return;
		603
601	if (!dma->chan)	604	if (!dma->chan)
602	return;	605	return;
603		606

drivers/tty/serial/serial-tegra.c+2−2

@@ -1506,7 +1506,7 @@ static struct tegra_uart_chip_data tegra20_uart_chip_data = { · 1505 unmodified lines
1506	.fifo_mode_enable_status = false,	1506	.fifo_mode_enable_status = false,
1507	.uart_max_port = 5,	1507	.uart_max_port = 5,
1508	.max_dma_burst_bytes = 4,	1508	.max_dma_burst_bytes = 4,
1509	.error_tolerance_low_range = 0,	1509	.error_tolerance_low_range = -4,
1510	.error_tolerance_high_range = 4,	1510	.error_tolerance_high_range = 4,
1511	};	1511	};
1512		1512
@@ -1517,7 +1517,7 @@ static struct tegra_uart_chip_data tegra30_uart_chip_data = { · 4 unmodified lines
1517	.fifo_mode_enable_status = false,	1517	.fifo_mode_enable_status = false,
1518	.uart_max_port = 5,	1518	.uart_max_port = 5,
1519	.max_dma_burst_bytes = 4,	1519	.max_dma_burst_bytes = 4,
1520	.error_tolerance_low_range = 0,	1520	.error_tolerance_low_range = -4,
1521	.error_tolerance_high_range = 4,	1521	.error_tolerance_high_range = 4,
1522	};	1522	};
1523		1523

drivers/tty/serial/serial_core.c+17−1

 		goto out;
 	if (!tty_io_error(tty)) {
+		if (uport->rs485.flags & SER_RS485_ENABLED) {
+			set &= ~TIOCM_RTS;
+			clear &= ~TIOCM_RTS;
+		}
 		uart_update_mctrl(uport, set, clear);
 		ret = 0;
 	}
 {
 	struct uart_state *state = container_of(port, struct uart_state, port);
 	struct uart_port *uport = uart_port_check(state);
+	char *buf;
 	/*
 	 * At this point, we stop accepting input.  To do this, we
 	 */
 	tty_port_set_suspended(port, 0);
-	uart_change_pm(state, UART_PM_STATE_OFF);
+	/*
+	 * Free the transmit buffer.
+	 */
+	spin_lock_irq(&uport->lock);
+	buf = state->xmit.buf;
+	state->xmit.buf = NULL;
+	spin_unlock_irq(&uport->lock);
+	if (buf)
+		free_page((unsigned long)buf);
+	uart_change_pm(state, UART_PM_STATE_OFF);
 }
 static void uart_wait_until_sent(struct tty_struct *tty, int timeout)

drivers/usb/cdns3/cdns3-gadget.c+4−16

 	cdns3_ep_inc_trb(&priv_ep->dequeue, &priv_ep->ccs, priv_ep->num_trbs);
 }
-static void cdns3_move_deq_to_next_trb(struct cdns3_request *priv_req)
-{
-	struct cdns3_endpoint *priv_ep = priv_req->priv_ep;
-	int current_trb = priv_req->start_trb;
-	while (current_trb != priv_req->end_trb) {
-		cdns3_ep_inc_deq(priv_ep);
-		current_trb = priv_ep->dequeue;
-	}
-	cdns3_ep_inc_deq(priv_ep);
-}
 /**
  * cdns3_allow_enable_l1 - enable/disable permits to transition to L1.
  * @priv_dev: Extended gadget object
 		trb = priv_ep->trb_pool + priv_ep->dequeue;
-		/* Request was dequeued and TRB was changed to TRB_LINK. */
+		/* The TRB was changed as link TRB, and the request was handled at ep_dequeue */
-		if (TRB_FIELD_TO_TYPE(le32_to_cpu(trb->control)) == TRB_LINK) {
+		while (TRB_FIELD_TO_TYPE(le32_to_cpu(trb->control)) == TRB_LINK) {
 			trace_cdns3_complete_trb(priv_ep, trb);
-			cdns3_move_deq_to_next_trb(priv_req);
+			cdns3_ep_inc_deq(priv_ep);
+			trb = priv_ep->trb_pool + priv_ep->dequeue;
 		}
 		if (!request->stream_id) {

drivers/usb/cdns3/cdnsp-mem.c+3−0

@@ -987,6 +987,9 @@ int cdnsp_endpoint_init(struct cdnsp_device *pdev, · 986 unmodified lines
987		987
988	/* Set up the endpoint ring. */	988	/* Set up the endpoint ring. */
989	pep->ring = cdnsp_ring_alloc(pdev, 2, ring_type, max_packet, mem_flags);	989	pep->ring = cdnsp_ring_alloc(pdev, 2, ring_type, max_packet, mem_flags);
		990	if (!pep->ring)
		991	return -ENOMEM;
		992
990	pep->skip = false;	993	pep->skip = false;
991		994
992	/* Fill the endpoint context */	995	/* Fill the endpoint context */

drivers/usb/cdns3/host.c+1−0

@@ -10,6 +10,7 @@ · 9 unmodified lines
10	*/	10	*/
11		11
12	#include <linux/platform_device.h>	12	#include <linux/platform_device.h>
		13	#include <linux/slab.h>
13	#include "core.h"	14	#include "core.h"
14	#include "drd.h"	15	#include "drd.h"
15	#include "host-export.h"	16	#include "host-export.h"

drivers/usb/core/config.c+3−3

@@ -406,7 +406,7 @@ static int usb_parse_endpoint(struct device *ddev, int cfgno, · 405 unmodified lines
406	* the USB-2 spec requires such endpoints to have wMaxPacketSize = 0	406	* the USB-2 spec requires such endpoints to have wMaxPacketSize = 0
407	* (see the end of section 5.6.3), so don't warn about them.	407	* (see the end of section 5.6.3), so don't warn about them.
408	*/	408	*/
409	maxp = usb_endpoint_maxp(&endpoint->desc);	409	maxp = le16_to_cpu(endpoint->desc.wMaxPacketSize);
410	if (maxp == 0 && !(usb_endpoint_xfer_isoc(d) && asnum == 0)) {	410	if (maxp == 0 && !(usb_endpoint_xfer_isoc(d) && asnum == 0)) {
411	dev_warn(ddev, "config %d interface %d altsetting %d endpoint 0x%X has invalid wMaxPacketSize 0\n",	411	dev_warn(ddev, "config %d interface %d altsetting %d endpoint 0x%X has invalid wMaxPacketSize 0\n",
412	cfgno, inum, asnum, d->bEndpointAddress);	412	cfgno, inum, asnum, d->bEndpointAddress);
@@ -422,9 +422,9 @@ static int usb_parse_endpoint(struct device *ddev, int cfgno, · 9 unmodified lines
422	maxpacket_maxes = full_speed_maxpacket_maxes;	422	maxpacket_maxes = full_speed_maxpacket_maxes;
423	break;	423	break;
424	case USB_SPEED_HIGH:	424	case USB_SPEED_HIGH:
425	/* Bits 12..11 are allowed only for HS periodic endpoints */	425	/* Multiple-transactions bits are allowed only for HS periodic endpoints */
426	if (usb_endpoint_xfer_int(d) \|\| usb_endpoint_xfer_isoc(d)) {	426	if (usb_endpoint_xfer_int(d) \|\| usb_endpoint_xfer_isoc(d)) {
427	i = maxp & (BIT(12) \| BIT(11));	427	i = maxp & USB_EP_MAXP_MULT_MASK;
428	maxp &= ~i;	428	maxp &= ~i;
429	}	429	}
430	fallthrough;	430	fallthrough;

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

@@ -434,6 +434,9 @@ static const struct usb_device_id usb_quirk_list[] = { · 433 unmodified lines
434	{ USB_DEVICE(0x1532, 0x0116), .driver_info =	434	{ USB_DEVICE(0x1532, 0x0116), .driver_info =
435	USB_QUIRK_LINEAR_UFRAME_INTR_BINTERVAL },	435	USB_QUIRK_LINEAR_UFRAME_INTR_BINTERVAL },
436		436
		437	/* Lenovo Powered USB-C Travel Hub (4X90S92381, RTL8153 GigE) */
		438	{ USB_DEVICE(0x17ef, 0x721e), .driver_info = USB_QUIRK_NO_LPM },
		439
437	/* Lenovo ThinkCenter A630Z TI024Gen3 usb-audio */	440	/* Lenovo ThinkCenter A630Z TI024Gen3 usb-audio */
438	{ USB_DEVICE(0x17ef, 0xa012), .driver_info =	441	{ USB_DEVICE(0x17ef, 0xa012), .driver_info =
439	USB_QUIRK_DISCONNECT_SUSPEND },	442	USB_QUIRK_DISCONNECT_SUSPEND },

drivers/usb/dwc3/dwc3-qcom.c+0−15

@@ -649,7 +649,6 @@ static int dwc3_qcom_of_register_core(struct platform_device *pdev) · 648 unmodified lines
649	struct dwc3_qcom *qcom = platform_get_drvdata(pdev);	649	struct dwc3_qcom *qcom = platform_get_drvdata(pdev);
650	struct device_node np = pdev->dev.of_node, dwc3_np;	650	struct device_node np = pdev->dev.of_node, dwc3_np;
651	struct device *dev = &pdev->dev;	651	struct device *dev = &pdev->dev;
652	struct property *prop;
653	int ret;	652	int ret;
654		653
655	dwc3_np = of_get_compatible_child(np, "snps,dwc3");	654	dwc3_np = of_get_compatible_child(np, "snps,dwc3");
@@ -658,20 +657,6 @@ static int dwc3_qcom_of_register_core(struct platform_device *pdev) · 2 unmodified lines
658	return -ENODEV;	657	return -ENODEV;
659	}	658	}
660		659
661	prop = devm_kzalloc(dev, sizeof(*prop), GFP_KERNEL);
662	if (!prop) {
663	ret = -ENOMEM;
664	dev_err(dev, "unable to allocate memory for property\n");
665	goto node_put;
666	}
667
668	prop->name = "tx-fifo-resize";
669	ret = of_add_property(dwc3_np, prop);
670	if (ret) {
671	dev_err(dev, "unable to add property\n");
672	goto node_put;
673	}
674
675	ret = of_platform_populate(np, NULL, NULL, dev);	660	ret = of_platform_populate(np, NULL, NULL, dev);
676	if (ret) {	661	if (ret) {
677	dev_err(dev, "failed to register dwc3 core - %d\n", ret);	662	dev_err(dev, "failed to register dwc3 core - %d\n", ret);

drivers/usb/gadget/composite.c+13−1

 	struct usb_function		*f = NULL;
 	u8				endp;
+	if (w_length > USB_COMP_EP0_BUFSIZ) {
+		if (ctrl->bRequestType == USB_DIR_OUT) {
+			goto done;
+		} else {
+			/* Cast away the const, we are going to overwrite on purpose. */
+			__le16 *temp = (__le16 *)&ctrl->wLength;
+			*temp = cpu_to_le16(USB_COMP_EP0_BUFSIZ);
+			w_length = USB_COMP_EP0_BUFSIZ;
+		}
+	}
 	/* partial re-init of the response message; the function or the
 	 * gadget might need to intercept e.g. a control-OUT completion
 	 * when we delegate to it.
 	if (!cdev->req)
 		return -ENOMEM;
-	cdev->req->buf = kmalloc(USB_COMP_EP0_BUFSIZ, GFP_KERNEL);
+	cdev->req->buf = kzalloc(USB_COMP_EP0_BUFSIZ, GFP_KERNEL);
 	if (!cdev->req->buf)
 		goto fail;

drivers/usb/gadget/legacy/dbgp.c+14−1

 		goto fail_1;
 	}
-	req->buf = kmalloc(DBGP_REQ_LEN, GFP_KERNEL);
+	req->buf = kzalloc(DBGP_REQ_LEN, GFP_KERNEL);
 	if (!req->buf) {
 		err = -ENOMEM;
 		stp = 2;
 	void *data = NULL;
 	u16 len = 0;
+	if (length > DBGP_REQ_LEN) {
+		if (ctrl->bRequestType == USB_DIR_OUT) {
+			return err;
+		} else {
+			/* Cast away the const, we are going to overwrite on purpose. */
+			__le16 *temp = (__le16 *)&ctrl->wLength;
+			*temp = cpu_to_le16(DBGP_REQ_LEN);
+			length = DBGP_REQ_LEN;
+		}
+	}
 	if (request == USB_REQ_GET_DESCRIPTOR) {
 		switch (value>>8) {
 		case USB_DT_DEVICE:

drivers/usb/gadget/legacy/inode.c+15−1

 /* enough for the whole queue: most events invalidate others */
 #define	N_EVENT			5
+#define RBUF_SIZE		256
 struct dev_data {
 	spinlock_t			lock;
 	refcount_t			count;
 	struct dentry			*dentry;
 	/* except this scratch i/o buffer for ep0 */
-	u8				rbuf [256];
+	u8				rbuf[RBUF_SIZE];
 };
 static inline void get_dev (struct dev_data *data)
 	u16				w_value = le16_to_cpu(ctrl->wValue);
 	u16				w_length = le16_to_cpu(ctrl->wLength);
+	if (w_length > RBUF_SIZE) {
+		if (ctrl->bRequestType == USB_DIR_OUT) {
+			return value;
+		} else {
+			/* Cast away the const, we are going to overwrite on purpose. */
+			__le16 *temp = (__le16 *)&ctrl->wLength;
+			*temp = cpu_to_le16(RBUF_SIZE);
+			w_length = RBUF_SIZE;
+		}
+	}
 	spin_lock (&dev->lock);
 	dev->setup_abort = 0;
 	if (dev->state == STATE_DEV_UNCONNECTED) {

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

@@ -717,6 +717,7 @@ static int xhci_enter_test_mode(struct xhci_hcd *xhci, · 716 unmodified lines
717	continue;	717	continue;
718		718
719	retval = xhci_disable_slot(xhci, i);	719	retval = xhci_disable_slot(xhci, i);
		720	xhci_free_virt_device(xhci, i);
720	if (retval)	721	if (retval)
721	xhci_err(xhci, "Failed to disable slot %d, %d. Enter test mode anyway\n",	722	xhci_err(xhci, "Failed to disable slot %d, %d. Enter test mode anyway\n",
722	i, retval);	723	i, retval);

drivers/usb/host/xhci-ring.c+14−8

 /* Must be called with xhci->lock held, releases and aquires lock back */
 static int xhci_abort_cmd_ring(struct xhci_hcd *xhci, unsigned long flags)
 {
-	u32 temp_32;
+	struct xhci_segment *new_seg	= xhci->cmd_ring->deq_seg;
+	union xhci_trb *new_deq		= xhci->cmd_ring->dequeue;
+	u64 crcr;
 	int ret;
 	xhci_dbg(xhci, "Abort command ring\n");
 	/*
 	 * The control bits like command stop, abort are located in lower
-	 * dword of the command ring control register. Limit the write
+	 * dword of the command ring control register.
-	 * to the lower dword to avoid corrupting the command ring pointer
+	 * Some controllers require all 64 bits to be written to abort the ring.
-	 * in case if the command ring is stopped by the time upper dword
+	 * Make sure the upper dword is valid, pointing to the next command,
-	 * is written.
+	 * avoiding corrupting the command ring pointer in case the command ring
+	 * is stopped by the time the upper dword is written.
 	 */
-	temp_32 = readl(&xhci->op_regs->cmd_ring);
+	next_trb(xhci, NULL, &new_seg, &new_deq);
-	writel(temp_32 | CMD_RING_ABORT, &xhci->op_regs->cmd_ring);
+	if (trb_is_link(new_deq))
+		next_trb(xhci, NULL, &new_seg, &new_deq);
+	crcr = xhci_trb_virt_to_dma(new_seg, new_deq);
+	xhci_write_64(xhci, crcr | CMD_RING_ABORT, &xhci->op_regs->cmd_ring);
 	/* Section 4.6.1.2 of xHCI 1.0 spec says software should also time the
 	 * completion of the Command Abort operation. If CRR is not negated in 5
 	if (xhci->quirks & XHCI_EP_LIMIT_QUIRK)
 		/* Delete default control endpoint resources */
 		xhci_free_device_endpoint_resources(xhci, virt_dev, true);
-	xhci_free_virt_device(xhci, slot_id);
 }
 static void xhci_handle_cmd_config_ep(struct xhci_hcd *xhci, int slot_id,

drivers/usb/host/xhci.c+15−11

 	struct xhci_slot_ctx *slot_ctx;
 	int i, ret;
-#ifndef CONFIG_USB_DEFAULT_PERSIST
 	/*
 	 * We called pm_runtime_get_noresume when the device was attached.
 	 * Decrement the counter here to allow controller to runtime suspend
 	 */
 	if (xhci->quirks & XHCI_RESET_ON_RESUME)
 		pm_runtime_put_noidle(hcd->self.controller);
-#endif
 	ret = xhci_check_args(hcd, udev, NULL, 0, true, __func__);
 	/* If the host is halted due to driver unload, we still need to free the
 		del_timer_sync(&virt_dev->eps[i].stop_cmd_timer);
 	}
 	virt_dev->udev = NULL;
-	ret = xhci_disable_slot(xhci, udev->slot_id);
+	xhci_disable_slot(xhci, udev->slot_id);
-	if (ret)
+	xhci_free_virt_device(xhci, udev->slot_id);
-		xhci_free_virt_device(xhci, udev->slot_id);
 }
 int xhci_disable_slot(struct xhci_hcd *xhci, u32 slot_id)
 	u32 state;
 	int ret = 0;
-	command = xhci_alloc_command(xhci, false, GFP_KERNEL);
+	command = xhci_alloc_command(xhci, true, GFP_KERNEL);
 	if (!command)
 		return -ENOMEM;
 	}
 	xhci_ring_cmd_db(xhci);
 	spin_unlock_irqrestore(&xhci->lock, flags);
+	wait_for_completion(command->completion);
+	if (command->status != COMP_SUCCESS)
+		xhci_warn(xhci, "Unsuccessful disable slot %u command, status %d\n",
+			  slot_id, command->status);
+	xhci_free_command(xhci, command);
 	return ret;
 }
 	xhci_debugfs_create_slot(xhci, slot_id);
-#ifndef CONFIG_USB_DEFAULT_PERSIST
 	/*
 	 * If resetting upon resume, we can't put the controller into runtime
 	 * suspend if there is a device attached.
 	 */
 	if (xhci->quirks & XHCI_RESET_ON_RESUME)
 		pm_runtime_get_noresume(hcd->self.controller);
-#endif
 	/* Is this a LS or FS device under a HS hub? */
 	/* Hub or peripherial? */
 	return 1;
 disable_slot:
-	ret = xhci_disable_slot(xhci, udev->slot_id);
+	xhci_disable_slot(xhci, udev->slot_id);
-	if (ret)
+	xhci_free_virt_device(xhci, udev->slot_id);
-		xhci_free_virt_device(xhci, udev->slot_id);
 	return 0;
 }
 		mutex_unlock(&xhci->mutex);
 		ret = xhci_disable_slot(xhci, udev->slot_id);
+		xhci_free_virt_device(xhci, udev->slot_id);
 		if (!ret)
 			xhci_alloc_dev(hcd, udev);
 		kfree(command->completion);

drivers/usb/typec/tcpm/tcpm.c+0−4

 				       tcpm_try_src(port) ? SRC_TRY
 							  : SNK_ATTACHED,
 				       0);
-		else
-			/* Wait for VBUS, but not forever */
-			tcpm_set_state(port, PORT_RESET, PD_T_PS_SOURCE_ON);
 		break;
 	case SRC_TRY:
 		port->try_src_count++;
 		tcpm_set_cc(port, tcpm_rp_cc(port));

drivers/vfio/pci/vfio_pci_igd.c+3−2

 			version = cpu_to_le16(0x0201);
 		if (igd_opregion_shift_copy(buf, &off,
-					    &version + (pos - OPREGION_VERSION),
+					    (u8 *)&version +
+					    (pos - OPREGION_VERSION),
 					    &pos, &remaining, bytes))
 			return -EFAULT;
 	}
 					  OPREGION_SIZE : 0);
 		if (igd_opregion_shift_copy(buf, &off,
-					    &rvda + (pos - OPREGION_RVDA),
+					    (u8 *)&rvda + (pos - OPREGION_RVDA),
 					    &pos, &remaining, bytes))
 			return -EFAULT;
 	}

drivers/vfio/vfio.c+14−14

@@ -232,7 +232,7 @@ static inline bool vfio_iommu_driver_allowed(struct vfio_container *container, · 231 unmodified lines
232	}	232	}
233	#endif /* CONFIG_VFIO_NOIOMMU */	233	#endif /* CONFIG_VFIO_NOIOMMU */
234		234
235	/**	235	/*
236	* IOMMU driver registration	236	* IOMMU driver registration
237	*/	237	*/
238	int vfio_register_iommu_driver(const struct vfio_iommu_driver_ops *ops)	238	int vfio_register_iommu_driver(const struct vfio_iommu_driver_ops *ops)
@@ -285,7 +285,7 @@ static int vfio_iommu_group_notifier(struct notifier_block *nb, · 46 unmodified lines
285	unsigned long action, void *data);	285	unsigned long action, void *data);
286	static void vfio_group_get(struct vfio_group *group);	286	static void vfio_group_get(struct vfio_group *group);
287		287
288	/**	288	/*
289	* Container objects - containers are created when /dev/vfio/vfio is	289	* Container objects - containers are created when /dev/vfio/vfio is
290	* opened, but their lifecycle extends until the last user is done, so	290	* opened, but their lifecycle extends until the last user is done, so
291	* it's freed via kref. Must support container/group/device being	291	* it's freed via kref. Must support container/group/device being
@@ -309,7 +309,7 @@ static void vfio_container_put(struct vfio_container *container) · 17 unmodified lines
309	kref_put(&container->kref, vfio_container_release);	309	kref_put(&container->kref, vfio_container_release);
310	}	310	}
311		311
312	/**	312	/*
313	* Group objects - create, release, get, put, search	313	* Group objects - create, release, get, put, search
314	*/	314	*/
315	static struct vfio_group *	315	static struct vfio_group *
@@ -488,7 +488,7 @@ static struct vfio_group vfio_group_get_from_dev(struct device dev) · 172 unmodified lines
488	return group;	488	return group;
489	}	489	}
490		490
491	/**	491	/*
492	* Device objects - create, release, get, put, search	492	* Device objects - create, release, get, put, search
493	*/	493	*/
494	/* Device reference always implies a group reference */	494	/* Device reference always implies a group reference */
@@ -595,7 +595,7 @@ static int vfio_dev_viable(struct device dev, void data) · 100 unmodified lines
595	return ret;	595	return ret;
596	}	596	}
597		597
598	/**	598	/*
599	* Async device support	599	* Async device support
600	*/	600	*/
601	static int vfio_group_nb_add_dev(struct vfio_group group, struct device dev)	601	static int vfio_group_nb_add_dev(struct vfio_group group, struct device dev)
@@ -689,7 +689,7 @@ static int vfio_iommu_group_notifier(struct notifier_block *nb, · 87 unmodified lines
689	return NOTIFY_OK;	689	return NOTIFY_OK;
690	}	690	}
691		691
692	/**	692	/*
693	* VFIO driver API	693	* VFIO driver API
694	*/	694	*/
695	void vfio_init_group_dev(struct vfio_device device, struct device dev,	695	void vfio_init_group_dev(struct vfio_device device, struct device dev,
@@ -831,7 +831,7 @@ int vfio_register_emulated_iommu_dev(struct vfio_device *device) · 135 unmodified lines
831	}	831	}
832	EXPORT_SYMBOL_GPL(vfio_register_emulated_iommu_dev);	832	EXPORT_SYMBOL_GPL(vfio_register_emulated_iommu_dev);
833		833
834	/**	834	/*
835	* Get a reference to the vfio_device for a device. Even if the	835	* Get a reference to the vfio_device for a device. Even if the
836	* caller thinks they own the device, they could be racing with a	836	* caller thinks they own the device, they could be racing with a
837	* release call path, so we can't trust drvdata for the shortcut.	837	* release call path, so we can't trust drvdata for the shortcut.
@@ -965,7 +965,7 @@ void vfio_unregister_group_dev(struct vfio_device *device) · 127 unmodified lines
965	}	965	}
966	EXPORT_SYMBOL_GPL(vfio_unregister_group_dev);	966	EXPORT_SYMBOL_GPL(vfio_unregister_group_dev);
967		967
968	/**	968	/*
969	* VFIO base fd, /dev/vfio/vfio	969	* VFIO base fd, /dev/vfio/vfio
970	*/	970	*/
971	static long vfio_ioctl_check_extension(struct vfio_container *container,	971	static long vfio_ioctl_check_extension(struct vfio_container *container,
@@ -1183,7 +1183,7 @@ static const struct file_operations vfio_fops = { · 211 unmodified lines
1183	.compat_ioctl = compat_ptr_ioctl,	1183	.compat_ioctl = compat_ptr_ioctl,
1184	};	1184	};
1185		1185
1186	/**	1186	/*
1187	* VFIO Group fd, /dev/vfio/$GROUP	1187	* VFIO Group fd, /dev/vfio/$GROUP
1188	*/	1188	*/
1189	static void __vfio_group_unset_container(struct vfio_group *group)	1189	static void __vfio_group_unset_container(struct vfio_group *group)
@@ -1536,7 +1536,7 @@ static const struct file_operations vfio_group_fops = { · 346 unmodified lines
1536	.release = vfio_group_fops_release,	1536	.release = vfio_group_fops_release,
1537	};	1537	};
1538		1538
1539	/**	1539	/*
1540	* VFIO Device fd	1540	* VFIO Device fd
1541	*/	1541	*/
1542	static int vfio_device_fops_release(struct inode inode, struct file filep)	1542	static int vfio_device_fops_release(struct inode inode, struct file filep)
@@ -1611,7 +1611,7 @@ static const struct file_operations vfio_device_fops = { · 68 unmodified lines
1611	.mmap = vfio_device_fops_mmap,	1611	.mmap = vfio_device_fops_mmap,
1612	};	1612	};
1613		1613
1614	/**	1614	/*
1615	* External user API, exported by symbols to be linked dynamically.	1615	* External user API, exported by symbols to be linked dynamically.
1616	*	1616	*
1617	* The protocol includes:	1617	* The protocol includes:
@@ -1659,7 +1659,7 @@ struct vfio_group vfio_group_get_external_user(struct file filep) · 41 unmodified lines
1659	}	1659	}
1660	EXPORT_SYMBOL_GPL(vfio_group_get_external_user);	1660	EXPORT_SYMBOL_GPL(vfio_group_get_external_user);
1661		1661
1662	/**	1662	/*
1663	* External user API, exported by symbols to be linked dynamically.	1663	* External user API, exported by symbols to be linked dynamically.
1664	* The external user passes in a device pointer	1664	* The external user passes in a device pointer
1665	* to verify that:	1665	* to verify that:
@@ -1725,7 +1725,7 @@ long vfio_external_check_extension(struct vfio_group *group, unsigned long arg) · 59 unmodified lines
1725	}	1725	}
1726	EXPORT_SYMBOL_GPL(vfio_external_check_extension);	1726	EXPORT_SYMBOL_GPL(vfio_external_check_extension);
1727		1727
1728	/**	1728	/*
1729	* Sub-module support	1729	* Sub-module support
1730	*/	1730	*/
1731	/*	1731	/*
@@ -2272,7 +2272,7 @@ struct iommu_domain vfio_group_iommu_domain(struct vfio_group group) · 540 unmodified lines
2272	}	2272	}
2273	EXPORT_SYMBOL_GPL(vfio_group_iommu_domain);	2273	EXPORT_SYMBOL_GPL(vfio_group_iommu_domain);
2274		2274
2275	/**	2275	/*
2276	* Module/class support	2276	* Module/class support
2277	*/	2277	*/
2278	static char vfio_devnode(struct device dev, umode_t *mode)	2278	static char vfio_devnode(struct device dev, umode_t *mode)

drivers/video/console/vgacon.c+9−5

 	struct uni_pagedir *p;
 	/*
-	 * We cannot be loaded as a module, therefore init is always 1,
+	 * We cannot be loaded as a module, therefore init will be 1
-	 * but vgacon_init can be called more than once, and init will
+	 * if we are the default console, however if we are a fallback
-	 * not be 1.
+	 * console, for example if fbcon has failed registration, then
+	 * init will be 0, so we need to make sure our boot parameters
+	 * have been copied to the console structure for vgacon_resize
+	 * ultimately called by vc_resize.  Any subsequent calls to
+	 * vgacon_init init will have init set to 0 too.
 	 */
 	c->vc_can_do_color = vga_can_do_color;
+	c->vc_scan_lines = vga_scan_lines;
+	c->vc_font.height = c->vc_cell_height = vga_video_font_height;
 	/* set dimensions manually if init != 0 since vc_resize() will fail */
 	if (init) {
 	} else
 		vc_resize(c, vga_video_num_columns, vga_video_num_lines);
-	c->vc_scan_lines = vga_scan_lines;
-	c->vc_font.height = c->vc_cell_height = vga_video_font_height;
 	c->vc_complement_mask = 0x7700;
 	if (vga_512_chars)
 		c->vc_hi_font_mask = 0x0800;

fs/aio.c+152−34

@@ -181,8 +181,9 @@ struct poll_iocb { · 180 unmodified lines
181	struct file *file;	181	struct file *file;
182	struct wait_queue_head *head;	182	struct wait_queue_head *head;
183	__poll_t events;	183	__poll_t events;
184	bool done;
185	bool cancelled;	184	bool cancelled;
		185	bool work_scheduled;
		186	bool work_need_resched;
186	struct wait_queue_entry wait;	187	struct wait_queue_entry wait;
187	struct work_struct work;	188	struct work_struct work;
188	};	189	};
@@ -1619,6 +1620,51 @@ static void aio_poll_put_work(struct work_struct *work) · 1430 unmodified lines
1619	iocb_put(iocb);	1620	iocb_put(iocb);
1620	}	1621	}
1621		1622
		1623	/*
		1624	* Safely lock the waitqueue which the request is on, synchronizing with the
		1625	* case where the ->poll() provider decides to free its waitqueue early.
		1626	*
		1627	* Returns true on success, meaning that req->head->lock was locked, req->wait
		1628	* is on req->head, and an RCU read lock was taken. Returns false if the
		1629	* request was already removed from its waitqueue (which might no longer exist).
		1630	*/
		1631	static bool poll_iocb_lock_wq(struct poll_iocb *req)
		1632	{
		1633	wait_queue_head_t *head;
		1634
		1635	/*
		1636	* While we hold the waitqueue lock and the waitqueue is nonempty,
		1637	* wake_up_pollfree() will wait for us. However, taking the waitqueue
		1638	* lock in the first place can race with the waitqueue being freed.
		1639	*
		1640	* We solve this as eventpoll does: by taking advantage of the fact that
		1641	* all users of wake_up_pollfree() will RCU-delay the actual free. If
		1642	* we enter rcu_read_lock() and see that the pointer to the queue is
		1643	* non-NULL, we can then lock it without the memory being freed out from
		1644	* under us, then check whether the request is still on the queue.
		1645	*
		1646	* Keep holding rcu_read_lock() as long as we hold the queue lock, in
		1647	* case the caller deletes the entry from the queue, leaving it empty.
		1648	* In that case, only RCU prevents the queue memory from being freed.
		1649	*/
		1650	rcu_read_lock();
		1651	head = smp_load_acquire(&req->head);
		1652	if (head) {
		1653	spin_lock(&head->lock);
		1654	if (!list_empty(&req->wait.entry))
		1655	return true;
		1656	spin_unlock(&head->lock);
		1657	}
		1658	rcu_read_unlock();
		1659	return false;
		1660	}
		1661
		1662	static void poll_iocb_unlock_wq(struct poll_iocb *req)
		1663	{
		1664	spin_unlock(&req->head->lock);
		1665	rcu_read_unlock();
		1666	}
		1667
1622	static void aio_poll_complete_work(struct work_struct *work)	1668	static void aio_poll_complete_work(struct work_struct *work)
1623	{	1669	{
1624	struct poll_iocb *req = container_of(work, struct poll_iocb, work);	1670	struct poll_iocb *req = container_of(work, struct poll_iocb, work);
@@ -1638,14 +1684,27 @@ static void aio_poll_complete_work(struct work_struct *work) · 13 unmodified lines
1638	* avoid further branches in the fast path.	1684	* avoid further branches in the fast path.
1639	*/	1685	*/
1640	spin_lock_irq(&ctx->ctx_lock);	1686	spin_lock_irq(&ctx->ctx_lock);
1641	if (!mask && !READ_ONCE(req->cancelled)) {	1687	if (poll_iocb_lock_wq(req)) {
1642	add_wait_queue(req->head, &req->wait);	1688	if (!mask && !READ_ONCE(req->cancelled)) {
1643	spin_unlock_irq(&ctx->ctx_lock);	1689	/*
1644	return;	1690	* The request isn't actually ready to be completed yet.
1645	}	1691	* Reschedule completion if another wakeup came in.
		1692	*/
		1693	if (req->work_need_resched) {
		1694	schedule_work(&req->work);
		1695	req->work_need_resched = false;
		1696	} else {
		1697	req->work_scheduled = false;
		1698	}
		1699	poll_iocb_unlock_wq(req);
		1700	spin_unlock_irq(&ctx->ctx_lock);
		1701	return;
		1702	}
		1703	list_del_init(&req->wait.entry);
		1704	poll_iocb_unlock_wq(req);
		1705	} /* else, POLLFREE has freed the waitqueue, so we must complete */
1646	list_del_init(&iocb->ki_list);	1706	list_del_init(&iocb->ki_list);
1647	iocb->ki_res.res = mangle_poll(mask);	1707	iocb->ki_res.res = mangle_poll(mask);
1648	req->done = true;
1649	spin_unlock_irq(&ctx->ctx_lock);	1708	spin_unlock_irq(&ctx->ctx_lock);
1650		1709
1651	iocb_put(iocb);	1710	iocb_put(iocb);
@@ -1657,13 +1716,14 @@ static int aio_poll_cancel(struct kiocb *iocb) · 5 unmodified lines
1657	struct aio_kiocb *aiocb = container_of(iocb, struct aio_kiocb, rw);	1716	struct aio_kiocb *aiocb = container_of(iocb, struct aio_kiocb, rw);
1658	struct poll_iocb *req = &aiocb->poll;	1717	struct poll_iocb *req = &aiocb->poll;
1659		1718
1660	spin_lock(&req->head->lock);	1719	if (poll_iocb_lock_wq(req)) {
1661	WRITE_ONCE(req->cancelled, true);	1720	WRITE_ONCE(req->cancelled, true);
1662	if (!list_empty(&req->wait.entry)) {	1721	if (!req->work_scheduled) {
1663	list_del_init(&req->wait.entry);	1722	schedule_work(&aiocb->poll.work);
1664	schedule_work(&aiocb->poll.work);	1723	req->work_scheduled = true;
1665	}	1724	}
1666	spin_unlock(&req->head->lock);	1725	poll_iocb_unlock_wq(req);
		1726	} /* else, the request was force-cancelled by POLLFREE already */
1667		1727
1668	return 0;	1728	return 0;
1669	}	1729	}
@@ -1680,21 +1740,27 @@ static int aio_poll_wake(struct wait_queue_entry *wait, unsigned mode, int sync, · 10 unmodified lines
1680	if (mask && !(mask & req->events))	1740	if (mask && !(mask & req->events))
1681	return 0;	1741	return 0;
1682		1742
1683	list_del_init(&req->wait.entry);	1743	/*
1684		1744	* Complete the request inline if possible. This requires that three
1685	if (mask && spin_trylock_irqsave(&iocb->ki_ctx->ctx_lock, flags)) {	1745	* conditions be met:
		1746	* 1. An event mask must have been passed. If a plain wakeup was done
		1747	* instead, then mask == 0 and we have to call vfs_poll() to get
		1748	* the events, so inline completion isn't possible.
		1749	* 2. The completion work must not have already been scheduled.
		1750	* 3. ctx_lock must not be busy. We have to use trylock because we
		1751	* already hold the waitqueue lock, so this inverts the normal
		1752	* locking order. Use irqsave/irqrestore because not all
		1753	* filesystems (e.g. fuse) call this function with IRQs disabled,
		1754	* yet IRQs have to be disabled before ctx_lock is obtained.
		1755	*/
		1756	if (mask && !req->work_scheduled &&
		1757	spin_trylock_irqsave(&iocb->ki_ctx->ctx_lock, flags)) {
1686	struct kioctx *ctx = iocb->ki_ctx;	1758	struct kioctx *ctx = iocb->ki_ctx;
1687		1759
1688	/*	1760	list_del_init(&req->wait.entry);
1689	* Try to complete the iocb inline if we can. Use
1690	* irqsave/irqrestore because not all filesystems (e.g. fuse)
1691	* call this function with IRQs disabled and because IRQs
1692	* have to be disabled before ctx_lock is obtained.
1693	*/
1694	list_del(&iocb->ki_list);	1761	list_del(&iocb->ki_list);
1695	iocb->ki_res.res = mangle_poll(mask);	1762	iocb->ki_res.res = mangle_poll(mask);
1696	req->done = true;	1763	if (iocb->ki_eventfd && !eventfd_signal_allowed()) {
1697	if (iocb->ki_eventfd && eventfd_signal_allowed()) {
1698	iocb = NULL;	1764	iocb = NULL;
1699	INIT_WORK(&req->work, aio_poll_put_work);	1765	INIT_WORK(&req->work, aio_poll_put_work);
1700	schedule_work(&req->work);	1766	schedule_work(&req->work);
@@ -1703,7 +1769,43 @@ static int aio_poll_wake(struct wait_queue_entry *wait, unsigned mode, int sync, · 2 unmodified lines
1703	if (iocb)	1769	if (iocb)
1704	iocb_put(iocb);	1770	iocb_put(iocb);
1705	} else {	1771	} else {
1706	schedule_work(&req->work);	1772	/*
		1773	* Schedule the completion work if needed. If it was already
		1774	* scheduled, record that another wakeup came in.
		1775	*
		1776	* Don't remove the request from the waitqueue here, as it might
		1777	* not actually be complete yet (we won't know until vfs_poll()
		1778	* is called), and we must not miss any wakeups. POLLFREE is an
		1779	* exception to this; see below.
		1780	*/
		1781	if (req->work_scheduled) {
		1782	req->work_need_resched = true;
		1783	} else {
		1784	schedule_work(&req->work);
		1785	req->work_scheduled = true;
		1786	}
		1787
		1788	/*
		1789	* If the waitqueue is being freed early but we can't complete
		1790	* the request inline, we have to tear down the request as best
		1791	* we can. That means immediately removing the request from its
		1792	* waitqueue and preventing all further accesses to the
		1793	* waitqueue via the request. We also need to schedule the
		1794	* completion work (done above). Also mark the request as
		1795	* cancelled, to potentially skip an unneeded call to ->poll().
		1796	*/
		1797	if (mask & POLLFREE) {
		1798	WRITE_ONCE(req->cancelled, true);
		1799	list_del_init(&req->wait.entry);
		1800
		1801	/*
		1802	* Careful: this must be the last step, since as soon
		1803	* as req->head is NULL'ed out, the request can be
		1804	* completed and freed, since aio_poll_complete_work()
		1805	* will no longer need to take the waitqueue lock.
		1806	*/
		1807	smp_store_release(&req->head, NULL);
		1808	}
1707	}	1809	}
1708	return 1;	1810	return 1;
1709	}	1811	}
@@ -1711,6 +1813,7 @@ static int aio_poll_wake(struct wait_queue_entry *wait, unsigned mode, int sync, · 1 unmodified line
1711	struct aio_poll_table {	1813	struct aio_poll_table {
1712	struct poll_table_struct pt;	1814	struct poll_table_struct pt;
1713	struct aio_kiocb *iocb;	1815	struct aio_kiocb *iocb;
		1816	bool queued;
1714	int error;	1817	int error;
1715	};	1818	};
1716		1819
@@ -1721,11 +1824,12 @@ aio_poll_queue_proc(struct file file, struct wait_queue_head head, · 4 unmodified lines
1721	struct aio_poll_table *pt = container_of(p, struct aio_poll_table, pt);	1824	struct aio_poll_table *pt = container_of(p, struct aio_poll_table, pt);
1722		1825
1723	/* multiple wait queues per file are not supported */	1826	/* multiple wait queues per file are not supported */
1724	if (unlikely(pt->iocb->poll.head)) {	1827	if (unlikely(pt->queued)) {
1725	pt->error = -EINVAL;	1828	pt->error = -EINVAL;
1726	return;	1829	return;
1727	}	1830	}
1728		1831
		1832	pt->queued = true;
1729	pt->error = 0;	1833	pt->error = 0;
1730	pt->iocb->poll.head = head;	1834	pt->iocb->poll.head = head;
1731	add_wait_queue(head, &pt->iocb->poll.wait);	1835	add_wait_queue(head, &pt->iocb->poll.wait);
@@ -1750,12 +1854,14 @@ static int aio_poll(struct aio_kiocb aiocb, const struct iocb iocb) · 18 unmodified lines
1750	req->events = demangle_poll(iocb->aio_buf) \| EPOLLERR \| EPOLLHUP;	1854	req->events = demangle_poll(iocb->aio_buf) \| EPOLLERR \| EPOLLHUP;
1751		1855
1752	req->head = NULL;	1856	req->head = NULL;
1753	req->done = false;
1754	req->cancelled = false;	1857	req->cancelled = false;
		1858	req->work_scheduled = false;
		1859	req->work_need_resched = false;
1755		1860
1756	apt.pt._qproc = aio_poll_queue_proc;	1861	apt.pt._qproc = aio_poll_queue_proc;
1757	apt.pt._key = req->events;	1862	apt.pt._key = req->events;
1758	apt.iocb = aiocb;	1863	apt.iocb = aiocb;
		1864	apt.queued = false;
1759	apt.error = -EINVAL; /* same as no support for IOCB_CMD_POLL */	1865	apt.error = -EINVAL; /* same as no support for IOCB_CMD_POLL */
1760		1866
1761	/* initialized the list so that we can do list_empty checks */	1867	/* initialized the list so that we can do list_empty checks */
@@ -1764,23 +1870,35 @@ static int aio_poll(struct aio_kiocb aiocb, const struct iocb iocb) · 2 unmodified lines
1764		1870
1765	mask = vfs_poll(req->file, &apt.pt) & req->events;	1871	mask = vfs_poll(req->file, &apt.pt) & req->events;
1766	spin_lock_irq(&ctx->ctx_lock);	1872	spin_lock_irq(&ctx->ctx_lock);
1767	if (likely(req->head)) {	1873	if (likely(apt.queued)) {
1768	spin_lock(&req->head->lock);	1874	bool on_queue = poll_iocb_lock_wq(req);
1769	if (unlikely(list_empty(&req->wait.entry))) {	1875
1770	if (apt.error)	1876	if (!on_queue \|\| req->work_scheduled) {
		1877	/*
		1878	* aio_poll_wake() already either scheduled the async
		1879	* completion work, or completed the request inline.
		1880	*/
		1881	if (apt.error) /* unsupported case: multiple queues */
1771	cancel = true;	1882	cancel = true;
1772	apt.error = 0;	1883	apt.error = 0;
1773	mask = 0;	1884	mask = 0;
1774	}	1885	}
1775	if (mask \|\| apt.error) {	1886	if (mask \|\| apt.error) {
		1887	/* Steal to complete synchronously. */
1776	list_del_init(&req->wait.entry);	1888	list_del_init(&req->wait.entry);
1777	} else if (cancel) {	1889	} else if (cancel) {
		1890	/* Cancel if possible (may be too late though). */
1778	WRITE_ONCE(req->cancelled, true);	1891	WRITE_ONCE(req->cancelled, true);
1779	} else if (!req->done) { /* actually waiting for an event */	1892	} else if (on_queue) {
		1893	/*
		1894	* Actually waiting for an event, so add the request to
		1895	* active_reqs so that it can be cancelled if needed.
		1896	*/
1780	list_add_tail(&aiocb->ki_list, &ctx->active_reqs);	1897	list_add_tail(&aiocb->ki_list, &ctx->active_reqs);
1781	aiocb->ki_cancel = aio_poll_cancel;	1898	aiocb->ki_cancel = aio_poll_cancel;
1782	}	1899	}
1783	spin_unlock(&req->head->lock);	1900	if (on_queue)
		1901	poll_iocb_unlock_wq(req);
1784	}	1902	}
1785	if (mask) { /* no async, we'd stolen it */	1903	if (mask) { /* no async, we'd stolen it */
1786	aiocb->ki_res.res = mangle_poll(mask);	1904	aiocb->ki_res.res = mangle_poll(mask);

fs/btrfs/delalloc-space.c+9−3

 	/* Use new btrfs_qgroup_reserve_data to reserve precious data space. */
 	ret = btrfs_qgroup_reserve_data(inode, reserved, start, len);
-	if (ret < 0)
+	if (ret < 0) {
 		btrfs_free_reserved_data_space_noquota(fs_info, len);
-	else
+		extent_changeset_free(*reserved);
+		*reserved = NULL;
+	} else {
 		ret = 0;
+	}
 	return ret;
 }
 	if (ret < 0)
 		return ret;
 	ret = btrfs_delalloc_reserve_metadata(inode, len);
-	if (ret < 0)
+	if (ret < 0) {
 		btrfs_free_reserved_data_space(inode, *reserved, start, len);
+		extent_changeset_free(*reserved);
+		*reserved = NULL;
+	}
 	return ret;
 }

fs/btrfs/extent-tree.c+3−0

@@ -6051,6 +6051,9 @@ int btrfs_trim_fs(struct btrfs_fs_info fs_info, struct fstrim_range range) · 6050 unmodified lines
6051	int dev_ret = 0;	6051	int dev_ret = 0;
6052	int ret = 0;	6052	int ret = 0;
6053		6053
		6054	if (range->start == U64_MAX)
		6055	return -EINVAL;
		6056
6054	/*	6057	/*
6055	* Check range overflow if range->len is set.	6058	* Check range overflow if range->len is set.
6056	* The default range->len is U64_MAX.	6059	* The default range->len is U64_MAX.

fs/btrfs/extent_io.c+14−0

@@ -4313,6 +4313,20 @@ static void set_btree_ioerr(struct page page, struct extent_buffer eb) · 4312 unmodified lines
4313	if (test_and_set_bit(EXTENT_BUFFER_WRITE_ERR, &eb->bflags))	4313	if (test_and_set_bit(EXTENT_BUFFER_WRITE_ERR, &eb->bflags))
4314	return;	4314	return;
4315		4315
		4316	/*
		4317	* A read may stumble upon this buffer later, make sure that it gets an
		4318	* error and knows there was an error.
		4319	*/
		4320	clear_bit(EXTENT_BUFFER_UPTODATE, &eb->bflags);
		4321
		4322	/*
		4323	* We need to set the mapping with the io error as well because a write
		4324	* error will flip the file system readonly, and then syncfs() will
		4325	* return a 0 because we are readonly if we don't modify the err seq for
		4326	* the superblock.
		4327	*/
		4328	mapping_set_error(page->mapping, -EIO);
		4329
4316	/*	4330	/*
4317	* If we error out, we should add back the dirty_metadata_bytes	4331	* If we error out, we should add back the dirty_metadata_bytes
4318	* to make it consistent.	4332	* to make it consistent.

fs/btrfs/ioctl.c+2−4

 		return -EPERM;
 	vol_args = memdup_user(arg, sizeof(*vol_args));
-	if (IS_ERR(vol_args)) {
+	if (IS_ERR(vol_args))
-		ret = PTR_ERR(vol_args);
+		return PTR_ERR(vol_args);
-		goto out;
-	}
 	if (vol_args->flags & ~BTRFS_DEVICE_REMOVE_ARGS_MASK) {
 		ret = -EOPNOTSUPP;

fs/btrfs/root-tree.c+2−1

 	key.offset = ref_id;
 again:
 	ret = btrfs_search_slot(trans, tree_root, &key, path, -1, 1);
-	BUG_ON(ret < 0);
+	if (ret < 0)
+		goto out;
 	if (ret == 0) {
 		leaf = path->nodes[0];
 		ref = btrfs_item_ptr(leaf, path->slots[0],

fs/btrfs/tree-log.c+3−2

 						     path->nodes[*level]->len);
 					if (ret)
 						return ret;
+					btrfs_redirty_list_add(trans->transaction,
+							       next);
 				} else {
 					if (test_and_clear_bit(EXTENT_BUFFER_DIRTY, &next->bflags))
 						clear_extent_buffer_dirty(next);
 						next->start, next->len);
 				if (ret)
 					goto out;
+				btrfs_redirty_list_add(trans->transaction, next);
 			} else {
 				if (test_and_clear_bit(EXTENT_BUFFER_DIRTY, &next->bflags))
 					clear_extent_buffer_dirty(next);
 			  EXTENT_DIRTY | EXTENT_NEW | EXTENT_NEED_WAIT);
 	extent_io_tree_release(&log->log_csum_range);
-	if (trans && log->node)
-		btrfs_redirty_list_add(trans->transaction, log->node);
 	btrfs_put_root(log);
 }

fs/btrfs/zoned.c+2−0

 	block_group->alloc_offset = block_group->zone_capacity;
 	block_group->free_space_ctl->free_space = 0;
 	btrfs_clear_treelog_bg(block_group);
+	btrfs_clear_data_reloc_bg(block_group);
 	spin_unlock(&block_group->lock);
 	ret = blkdev_zone_mgmt(device->bdev, REQ_OP_ZONE_FINISH,
 	ASSERT(block_group->alloc_offset == block_group->zone_capacity);
 	ASSERT(block_group->free_space_ctl->free_space == 0);
 	btrfs_clear_treelog_bg(block_group);
+	btrfs_clear_data_reloc_bg(block_group);
 	spin_unlock(&block_group->lock);
 	map = block_group->physical_map;

fs/cifs/connect.c+5−6

 	/* fscache server cookies are based on primary channel only */
 	if (!CIFS_SERVER_IS_CHAN(tcp_ses))
 		cifs_fscache_get_client_cookie(tcp_ses);
+#ifdef CONFIG_CIFS_FSCACHE
+	else
+		tcp_ses->fscache = tcp_ses->primary_server->fscache;
+#endif /* CONFIG_CIFS_FSCACHE */
 	/* queue echo request delayed work */
 	queue_delayed_work(cifsiod_wq, &tcp_ses->echo, tcp_ses->echo_interval);
 				cifs_dbg(VFS, "read only mount of RW share\n");
 			/* no need to log a RW mount of a typical RW share */
 		}
-		/*
-		 * The cookie is initialized from volume info returned above.
-		 * Inside cifs_fscache_get_super_cookie it checks
-		 * that we do not get super cookie twice.
-		 */
-		cifs_fscache_get_super_cookie(tcon);
 	}
 	/*
 	 */
 	mount_put_conns(mnt_ctx);
 	mount_get_dfs_conns(mnt_ctx);
+	set_root_ses(mnt_ctx);
 	full_path = build_unc_path_to_root(ctx, cifs_sb, true);
 	if (IS_ERR(full_path))

fs/cifs/fscache.c+10−36

@@ -16,14 +16,7 @@ · 15 unmodified lines
16	* Key layout of CIFS server cache index object	16	* Key layout of CIFS server cache index object
17	*/	17	*/
18	struct cifs_server_key {	18	struct cifs_server_key {
19	struct {	19	__u64 conn_id;
20	uint16_t family; /* address family */
21	__be16 port; /* IP port */
22	} hdr;
23	union {
24	struct in_addr ipv4_addr;
25	struct in6_addr ipv6_addr;
26	};
27	} __packed;	20	} __packed;
28		21
29	/*	22	/*
@@ -31,42 +24,23 @@ struct cifs_server_key { · 1 unmodified line
31	*/	24	*/
32	void cifs_fscache_get_client_cookie(struct TCP_Server_Info *server)	25	void cifs_fscache_get_client_cookie(struct TCP_Server_Info *server)
33	{	26	{
34	const struct sockaddr sa = (struct sockaddr ) &server->dstaddr;
35	const struct sockaddr_in addr = (struct sockaddr_in ) sa;
36	const struct sockaddr_in6 addr6 = (struct sockaddr_in6 ) sa;
37	struct cifs_server_key key;	27	struct cifs_server_key key;
38	uint16_t key_len = sizeof(key.hdr);
39
40	memset(&key, 0, sizeof(key));
41		28
42	/*	29	/*
43	* Should not be a problem as sin_family/sin6_family overlays	30	* Check if cookie was already initialized so don't reinitialize it.
44	* sa_family field	31	* In the future, as we integrate with newer fscache features,
		32	* we may want to instead add a check if cookie has changed
45	*/	33	*/
46	key.hdr.family = sa->sa_family;	34	if (server->fscache)
47	switch (sa->sa_family) {
48	case AF_INET:
49	key.hdr.port = addr->sin_port;
50	key.ipv4_addr = addr->sin_addr;
51	key_len += sizeof(key.ipv4_addr);
52	break;
53
54	case AF_INET6:
55	key.hdr.port = addr6->sin6_port;
56	key.ipv6_addr = addr6->sin6_addr;
57	key_len += sizeof(key.ipv6_addr);
58	break;
59
60	default:
61	cifs_dbg(VFS, "Unknown network family '%d'\n", sa->sa_family);
62	server->fscache = NULL;
63	return;	35	return;
64	}	36
		37	memset(&key, 0, sizeof(key));
		38	key.conn_id = server->conn_id;
65		39
66	server->fscache =	40	server->fscache =
67	fscache_acquire_cookie(cifs_fscache_netfs.primary_index,	41	fscache_acquire_cookie(cifs_fscache_netfs.primary_index,
68	&cifs_fscache_server_index_def,	42	&cifs_fscache_server_index_def,
69	&key, key_len,	43	&key, sizeof(key),
70	NULL, 0,	44	NULL, 0,
71	server, 0, true);	45	server, 0, true);
72	cifs_dbg(FYI, "%s: (0x%p/0x%p)\n",	46	cifs_dbg(FYI, "%s: (0x%p/0x%p)\n",
@@ -92,7 +66,7 @@ void cifs_fscache_get_super_cookie(struct cifs_tcon *tcon) · 19 unmodified lines
92	* In the future, as we integrate with newer fscache features,	66	* In the future, as we integrate with newer fscache features,
93	* we may want to instead add a check if cookie has changed	67	* we may want to instead add a check if cookie has changed
94	*/	68	*/
95	if (tcon->fscache == NULL)	69	if (tcon->fscache)
96	return;	70	return;
97		71
98	sharename = extract_sharename(tcon->treeName);	72	sharename = extract_sharename(tcon->treeName);

fs/cifs/inode.c+7−0

@@ -1376,6 +1376,13 @@ iget_no_retry: · 1375 unmodified lines
1376	inode = ERR_PTR(rc);	1376	inode = ERR_PTR(rc);
1377	}	1377	}
1378		1378
		1379	/*
		1380	* The cookie is initialized from volume info returned above.
		1381	* Inside cifs_fscache_get_super_cookie it checks
		1382	* that we do not get super cookie twice.
		1383	*/
		1384	cifs_fscache_get_super_cookie(tcon);
		1385
1379	out:	1386	out:
1380	kfree(path);	1387	kfree(path);
1381	free_xid(xid);	1388	free_xid(xid);

fs/cifs/sess.c+36−18

@@ -590,8 +590,8 @@ int decode_ntlmssp_challenge(char *bcc_ptr, int blob_len, · 589 unmodified lines
590	{	590	{
591	unsigned int tioffset; /* challenge message target info area */	591	unsigned int tioffset; /* challenge message target info area */
592	unsigned int tilen; /* challenge message target info area length */	592	unsigned int tilen; /* challenge message target info area length */
593
594	CHALLENGE_MESSAGE pblob = (CHALLENGE_MESSAGE )bcc_ptr;	593	CHALLENGE_MESSAGE pblob = (CHALLENGE_MESSAGE )bcc_ptr;
		594	__u32 server_flags;
595		595
596	if (blob_len < sizeof(CHALLENGE_MESSAGE)) {	596	if (blob_len < sizeof(CHALLENGE_MESSAGE)) {
597	cifs_dbg(VFS, "challenge blob len %d too small\n", blob_len);	597	cifs_dbg(VFS, "challenge blob len %d too small\n", blob_len);
@@ -609,12 +609,37 @@ int decode_ntlmssp_challenge(char *bcc_ptr, int blob_len, · 11 unmodified lines
609	return -EINVAL;	609	return -EINVAL;
610	}	610	}
611		611
		612	server_flags = le32_to_cpu(pblob->NegotiateFlags);
		613	cifs_dbg(FYI, "%s: negotiate=0x%08x challenge=0x%08x\n", __func__,
		614	ses->ntlmssp->client_flags, server_flags);
		615
		616	if ((ses->ntlmssp->client_flags & (NTLMSSP_NEGOTIATE_SEAL \| NTLMSSP_NEGOTIATE_SIGN)) &&
		617	(!(server_flags & NTLMSSP_NEGOTIATE_56) && !(server_flags & NTLMSSP_NEGOTIATE_128))) {
		618	cifs_dbg(VFS, "%s: requested signing/encryption but server did not return either 56-bit or 128-bit session key size\n",
		619	__func__);
		620	return -EINVAL;
		621	}
		622	if (!(server_flags & NTLMSSP_NEGOTIATE_NTLM) && !(server_flags & NTLMSSP_NEGOTIATE_EXTENDED_SEC)) {
		623	cifs_dbg(VFS, "%s: server does not seem to support either NTLMv1 or NTLMv2\n", __func__);
		624	return -EINVAL;
		625	}
		626	if (ses->server->sign && !(server_flags & NTLMSSP_NEGOTIATE_SIGN)) {
		627	cifs_dbg(VFS, "%s: forced packet signing but server does not seem to support it\n",
		628	__func__);
		629	return -EOPNOTSUPP;
		630	}
		631	if ((ses->ntlmssp->client_flags & NTLMSSP_NEGOTIATE_KEY_XCH) &&
		632	!(server_flags & NTLMSSP_NEGOTIATE_KEY_XCH))
		633	pr_warn_once("%s: authentication has been weakened as server does not support key exchange\n",
		634	__func__);
		635
		636	ses->ntlmssp->server_flags = server_flags;
		637
612	memcpy(ses->ntlmssp->cryptkey, pblob->Challenge, CIFS_CRYPTO_KEY_SIZE);	638	memcpy(ses->ntlmssp->cryptkey, pblob->Challenge, CIFS_CRYPTO_KEY_SIZE);
613	/* BB we could decode pblob->NegotiateFlags; some may be useful */
614	/* In particular we can examine sign flags */	639	/* In particular we can examine sign flags */
615	/* BB spec says that if AvId field of MsvAvTimestamp is populated then	640	/* BB spec says that if AvId field of MsvAvTimestamp is populated then
616	we must set the MIC field of the AUTHENTICATE_MESSAGE */	641	we must set the MIC field of the AUTHENTICATE_MESSAGE */
617	ses->ntlmssp->server_flags = le32_to_cpu(pblob->NegotiateFlags);	642
618	tioffset = le32_to_cpu(pblob->TargetInfoArray.BufferOffset);	643	tioffset = le32_to_cpu(pblob->TargetInfoArray.BufferOffset);
619	tilen = le16_to_cpu(pblob->TargetInfoArray.Length);	644	tilen = le16_to_cpu(pblob->TargetInfoArray.Length);
620	if (tioffset > blob_len \|\| tioffset + tilen > blob_len) {	645	if (tioffset > blob_len \|\| tioffset + tilen > blob_len) {
@@ -721,13 +746,13 @@ int build_ntlmssp_negotiate_blob(unsigned char **pbuffer, · 100 unmodified lines
721	flags = NTLMSSP_NEGOTIATE_56 \| NTLMSSP_REQUEST_TARGET \|	746	flags = NTLMSSP_NEGOTIATE_56 \| NTLMSSP_REQUEST_TARGET \|
722	NTLMSSP_NEGOTIATE_128 \| NTLMSSP_NEGOTIATE_UNICODE \|	747	NTLMSSP_NEGOTIATE_128 \| NTLMSSP_NEGOTIATE_UNICODE \|
723	NTLMSSP_NEGOTIATE_NTLM \| NTLMSSP_NEGOTIATE_EXTENDED_SEC \|	748	NTLMSSP_NEGOTIATE_NTLM \| NTLMSSP_NEGOTIATE_EXTENDED_SEC \|
724	NTLMSSP_NEGOTIATE_SEAL;	749	NTLMSSP_NEGOTIATE_ALWAYS_SIGN \| NTLMSSP_NEGOTIATE_SEAL \|
725	if (server->sign)	750	NTLMSSP_NEGOTIATE_SIGN;
726	flags \|= NTLMSSP_NEGOTIATE_SIGN;
727	if (!server->session_estab \|\| ses->ntlmssp->sesskey_per_smbsess)	751	if (!server->session_estab \|\| ses->ntlmssp->sesskey_per_smbsess)
728	flags \|= NTLMSSP_NEGOTIATE_KEY_XCH;	752	flags \|= NTLMSSP_NEGOTIATE_KEY_XCH;
729		753
730	tmp = *pbuffer + sizeof(NEGOTIATE_MESSAGE);	754	tmp = *pbuffer + sizeof(NEGOTIATE_MESSAGE);
		755	ses->ntlmssp->client_flags = flags;
731	sec_blob->NegotiateFlags = cpu_to_le32(flags);	756	sec_blob->NegotiateFlags = cpu_to_le32(flags);
732		757
733	/* these fields should be null in negotiate phase MS-NLMP 3.1.5.1.1 */	758	/* these fields should be null in negotiate phase MS-NLMP 3.1.5.1.1 */
@@ -779,15 +804,8 @@ int build_ntlmssp_auth_blob(unsigned char **pbuffer, · 45 unmodified lines
779	memcpy(sec_blob->Signature, NTLMSSP_SIGNATURE, 8);	804	memcpy(sec_blob->Signature, NTLMSSP_SIGNATURE, 8);
780	sec_blob->MessageType = NtLmAuthenticate;	805	sec_blob->MessageType = NtLmAuthenticate;
781		806
782	flags = NTLMSSP_NEGOTIATE_56 \|	807	flags = ses->ntlmssp->server_flags \| NTLMSSP_REQUEST_TARGET \|
783	NTLMSSP_REQUEST_TARGET \| NTLMSSP_NEGOTIATE_TARGET_INFO \|	808	NTLMSSP_NEGOTIATE_TARGET_INFO \| NTLMSSP_NEGOTIATE_WORKSTATION_SUPPLIED;
784	NTLMSSP_NEGOTIATE_128 \| NTLMSSP_NEGOTIATE_UNICODE \|
785	NTLMSSP_NEGOTIATE_NTLM \| NTLMSSP_NEGOTIATE_EXTENDED_SEC \|
786	NTLMSSP_NEGOTIATE_SEAL \| NTLMSSP_NEGOTIATE_WORKSTATION_SUPPLIED;
787	if (ses->server->sign)
788	flags \|= NTLMSSP_NEGOTIATE_SIGN;
789	if (!ses->server->session_estab \|\| ses->ntlmssp->sesskey_per_smbsess)
790	flags \|= NTLMSSP_NEGOTIATE_KEY_XCH;
791		809
792	tmp = *pbuffer + sizeof(AUTHENTICATE_MESSAGE);	810	tmp = *pbuffer + sizeof(AUTHENTICATE_MESSAGE);
793	sec_blob->NegotiateFlags = cpu_to_le32(flags);	811	sec_blob->NegotiateFlags = cpu_to_le32(flags);
@@ -834,9 +852,9 @@ int build_ntlmssp_auth_blob(unsigned char **pbuffer, · 40 unmodified lines
834	*pbuffer, &tmp,	852	*pbuffer, &tmp,
835	nls_cp);	853	nls_cp);
836		854
837	if (((ses->ntlmssp->server_flags & NTLMSSP_NEGOTIATE_KEY_XCH) \|\|	855	if ((ses->ntlmssp->server_flags & NTLMSSP_NEGOTIATE_KEY_XCH) &&
838	(ses->ntlmssp->server_flags & NTLMSSP_NEGOTIATE_EXTENDED_SEC))	856	(!ses->server->session_estab \|\| ses->ntlmssp->sesskey_per_smbsess) &&
839	&& !calc_seckey(ses)) {	857	!calc_seckey(ses)) {
840	memcpy(tmp, ses->ntlmssp->ciphertext, CIFS_CPHTXT_SIZE);	858	memcpy(tmp, ses->ntlmssp->ciphertext, CIFS_CPHTXT_SIZE);
841	sec_blob->SessionKey.BufferOffset = cpu_to_le32(tmp - *pbuffer);	859	sec_blob->SessionKey.BufferOffset = cpu_to_le32(tmp - *pbuffer);
842	sec_blob->SessionKey.Length = cpu_to_le16(CIFS_CPHTXT_SIZE);	860	sec_blob->SessionKey.Length = cpu_to_le16(CIFS_CPHTXT_SIZE);

fs/file.c+4−0

 			file = NULL;
 		else if (!get_file_rcu_many(file, refs))
 			goto loop;
+		else if (files_lookup_fd_raw(files, fd) != file) {
+			fput_many(file, refs);
+			goto loop;
+		}
 	}
 	rcu_read_unlock();

fs/gfs2/glock.c+7−3

 void gfs2_glock_cb(struct gfs2_glock *gl, unsigned int state)
 {
-	struct gfs2_holder mock_gh = { .gh_gl = gl, .gh_state = state, };
 	unsigned long delay = 0;
 	unsigned long holdtime;
 	unsigned long now = jiffies;
 	 * keep the glock until the last strong holder is done with it.
 	 */
 	if (!find_first_strong_holder(gl)) {
-		if (state == LM_ST_UNLOCKED)
+		struct gfs2_holder mock_gh = {
-			mock_gh.gh_state = LM_ST_EXCLUSIVE;
+			.gh_gl = gl,
+			.gh_state = (state == LM_ST_UNLOCKED) ?
+				    LM_ST_EXCLUSIVE : state,
+			.gh_iflags = BIT(HIF_HOLDER)
+		};
 		demote_incompat_holders(gl, &mock_gh);
 	}
 	handle_callback(gl, state, delay, true);

fs/gfs2/inode.c+45−64

@@ -40,37 +40,6 @@ static const struct inode_operations gfs2_file_iops; · 39 unmodified lines
40	static const struct inode_operations gfs2_dir_iops;	40	static const struct inode_operations gfs2_dir_iops;
41	static const struct inode_operations gfs2_symlink_iops;	41	static const struct inode_operations gfs2_symlink_iops;
42		42
43	static int iget_test(struct inode inode, void opaque)
44	{
45	u64 no_addr = (u64 )opaque;
46
47	return GFS2_I(inode)->i_no_addr == no_addr;
48	}
49
50	static int iget_set(struct inode inode, void opaque)
51	{
52	u64 no_addr = (u64 )opaque;
53
54	GFS2_I(inode)->i_no_addr = no_addr;
55	inode->i_ino = no_addr;
56	return 0;
57	}
58
59	static struct inode gfs2_iget(struct super_block sb, u64 no_addr)
60	{
61	struct inode *inode;
62
63	repeat:
64	inode = iget5_locked(sb, no_addr, iget_test, iget_set, &no_addr);
65	if (!inode)
66	return inode;
67	if (is_bad_inode(inode)) {
68	iput(inode);
69	goto repeat;
70	}
71	return inode;
72	}
73
74	/**	43	/**
75	* gfs2_set_iop - Sets inode operations	44	* gfs2_set_iop - Sets inode operations
76	* @inode: The inode with correct i_mode filled in	45	* @inode: The inode with correct i_mode filled in
@@ -104,6 +73,22 @@ static void gfs2_set_iop(struct inode *inode) · 27 unmodified lines
104	}	73	}
105	}	74	}
106		75
		76	static int iget_test(struct inode inode, void opaque)
		77	{
		78	u64 no_addr = (u64 )opaque;
		79
		80	return GFS2_I(inode)->i_no_addr == no_addr;
		81	}
		82
		83	static int iget_set(struct inode inode, void opaque)
		84	{
		85	u64 no_addr = (u64 )opaque;
		86
		87	GFS2_I(inode)->i_no_addr = no_addr;
		88	inode->i_ino = no_addr;
		89	return 0;
		90	}
		91
107	/**	92	/**
108	* gfs2_inode_lookup - Lookup an inode	93	* gfs2_inode_lookup - Lookup an inode
109	* @sb: The super block	94	* @sb: The super block
@@ -132,12 +117,11 @@ struct inode gfs2_inode_lookup(struct super_block sb, unsigned int type, · 22 unmodified lines
132	{	117	{
133	struct inode *inode;	118	struct inode *inode;
134	struct gfs2_inode *ip;	119	struct gfs2_inode *ip;
135	struct gfs2_glock *io_gl = NULL;
136	struct gfs2_holder i_gh;	120	struct gfs2_holder i_gh;
137	int error;	121	int error;
138		122
139	gfs2_holder_mark_uninitialized(&i_gh);	123	gfs2_holder_mark_uninitialized(&i_gh);
140	inode = gfs2_iget(sb, no_addr);	124	inode = iget5_locked(sb, no_addr, iget_test, iget_set, &no_addr);
141	if (!inode)	125	if (!inode)
142	return ERR_PTR(-ENOMEM);	126	return ERR_PTR(-ENOMEM);
143		127
@@ -145,22 +129,16 @@ struct inode gfs2_inode_lookup(struct super_block sb, unsigned int type, · 1 unmodified line
145		129
146	if (inode->i_state & I_NEW) {	130	if (inode->i_state & I_NEW) {
147	struct gfs2_sbd *sdp = GFS2_SB(inode);	131	struct gfs2_sbd *sdp = GFS2_SB(inode);
		132	struct gfs2_glock *io_gl;
148		133
149	error = gfs2_glock_get(sdp, no_addr, &gfs2_inode_glops, CREATE, &ip->i_gl);	134	error = gfs2_glock_get(sdp, no_addr, &gfs2_inode_glops, CREATE, &ip->i_gl);
150	if (unlikely(error))	135	if (unlikely(error))
151	goto fail;	136	goto fail;
152	flush_delayed_work(&ip->i_gl->gl_work);
153
154	error = gfs2_glock_get(sdp, no_addr, &gfs2_iopen_glops, CREATE, &io_gl);
155	if (unlikely(error))
156	goto fail;
157	if (blktype != GFS2_BLKST_UNLINKED)
158	gfs2_cancel_delete_work(io_gl);
159		137
160	if (type == DT_UNKNOWN \|\| blktype != GFS2_BLKST_FREE) {	138	if (type == DT_UNKNOWN \|\| blktype != GFS2_BLKST_FREE) {
161	/*	139	/*
162	* The GL_SKIP flag indicates to skip reading the inode	140	* The GL_SKIP flag indicates to skip reading the inode
163	* block. We read the inode with gfs2_inode_refresh	141	* block. We read the inode when instantiating it
164	* after possibly checking the block type.	142	* after possibly checking the block type.
165	*/	143	*/
166	error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE,	144	error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE,
@@ -181,24 +159,31 @@ struct inode gfs2_inode_lookup(struct super_block sb, unsigned int type, · 14 unmodified lines
181	}	159	}
182	}	160	}
183		161
184	glock_set_object(ip->i_gl, ip);
185	set_bit(GLF_INSTANTIATE_NEEDED, &ip->i_gl->gl_flags);	162	set_bit(GLF_INSTANTIATE_NEEDED, &ip->i_gl->gl_flags);
186	error = gfs2_glock_nq_init(io_gl, LM_ST_SHARED, GL_EXACT, &ip->i_iopen_gh);	163
		164	error = gfs2_glock_get(sdp, no_addr, &gfs2_iopen_glops, CREATE, &io_gl);
187	if (unlikely(error))	165	if (unlikely(error))
188	goto fail;	166	goto fail;
189	glock_set_object(ip->i_iopen_gh.gh_gl, ip);	167	if (blktype != GFS2_BLKST_UNLINKED)
		168	gfs2_cancel_delete_work(io_gl);
		169	error = gfs2_glock_nq_init(io_gl, LM_ST_SHARED, GL_EXACT, &ip->i_iopen_gh);
190	gfs2_glock_put(io_gl);	170	gfs2_glock_put(io_gl);
191	io_gl = NULL;	171	if (unlikely(error))
		172	goto fail;
192		173
193	/* Lowest possible timestamp; will be overwritten in gfs2_dinode_in. */	174	/* Lowest possible timestamp; will be overwritten in gfs2_dinode_in. */
194	inode->i_atime.tv_sec = 1LL << (8 * sizeof(inode->i_atime.tv_sec) - 1);	175	inode->i_atime.tv_sec = 1LL << (8 * sizeof(inode->i_atime.tv_sec) - 1);
195	inode->i_atime.tv_nsec = 0;	176	inode->i_atime.tv_nsec = 0;
196		177
		178	glock_set_object(ip->i_gl, ip);
		179
197	if (type == DT_UNKNOWN) {	180	if (type == DT_UNKNOWN) {
198	/* Inode glock must be locked already */	181	/* Inode glock must be locked already */
199	error = gfs2_instantiate(&i_gh);	182	error = gfs2_instantiate(&i_gh);
200	if (error)	183	if (error) {
		184	glock_clear_object(ip->i_gl, ip);
201	goto fail;	185	goto fail;
		186	}
202	} else {	187	} else {
203	ip->i_no_formal_ino = no_formal_ino;	188	ip->i_no_formal_ino = no_formal_ino;
204	inode->i_mode = DT2IF(type);	189	inode->i_mode = DT2IF(type);
@@ -206,31 +191,23 @@ struct inode gfs2_inode_lookup(struct super_block sb, unsigned int type, · 1 unmodified line
206		191
207	if (gfs2_holder_initialized(&i_gh))	192	if (gfs2_holder_initialized(&i_gh))
208	gfs2_glock_dq_uninit(&i_gh);	193	gfs2_glock_dq_uninit(&i_gh);
		194	glock_set_object(ip->i_iopen_gh.gh_gl, ip);
209		195
210	gfs2_set_iop(inode);	196	gfs2_set_iop(inode);
		197	unlock_new_inode(inode);
211	}	198	}
212		199
213	if (no_formal_ino && ip->i_no_formal_ino &&	200	if (no_formal_ino && ip->i_no_formal_ino &&
214	no_formal_ino != ip->i_no_formal_ino) {	201	no_formal_ino != ip->i_no_formal_ino) {
215	error = -ESTALE;
216	if (inode->i_state & I_NEW)
217	goto fail;
218	iput(inode);	202	iput(inode);
219	return ERR_PTR(error);	203	return ERR_PTR(-ESTALE);
220	}	204	}
221		205
222	if (inode->i_state & I_NEW)
223	unlock_new_inode(inode);
224
225	return inode;	206	return inode;
226		207
227	fail:	208	fail:
228	if (gfs2_holder_initialized(&ip->i_iopen_gh)) {	209	if (gfs2_holder_initialized(&ip->i_iopen_gh))
229	glock_clear_object(ip->i_iopen_gh.gh_gl, ip);
230	gfs2_glock_dq_uninit(&ip->i_iopen_gh);	210	gfs2_glock_dq_uninit(&ip->i_iopen_gh);
231	}
232	if (io_gl)
233	gfs2_glock_put(io_gl);
234	if (gfs2_holder_initialized(&i_gh))	211	if (gfs2_holder_initialized(&i_gh))
235	gfs2_glock_dq_uninit(&i_gh);	212	gfs2_glock_dq_uninit(&i_gh);
236	iget_failed(inode);	213	iget_failed(inode);
@@ -730,18 +707,19 @@ static int gfs2_create_inode(struct inode dir, struct dentry dentry, · 493 unmodified lines
730	error = gfs2_glock_get(sdp, ip->i_no_addr, &gfs2_inode_glops, CREATE, &ip->i_gl);	707	error = gfs2_glock_get(sdp, ip->i_no_addr, &gfs2_inode_glops, CREATE, &ip->i_gl);
731	if (error)	708	if (error)
732	goto fail_free_inode;	709	goto fail_free_inode;
733	flush_delayed_work(&ip->i_gl->gl_work);
734		710
735	error = gfs2_glock_get(sdp, ip->i_no_addr, &gfs2_iopen_glops, CREATE, &io_gl);	711	error = gfs2_glock_get(sdp, ip->i_no_addr, &gfs2_iopen_glops, CREATE, &io_gl);
736	if (error)	712	if (error)
737	goto fail_free_inode;	713	goto fail_free_inode;
738	gfs2_cancel_delete_work(io_gl);	714	gfs2_cancel_delete_work(io_gl);
739		715
		716	error = insert_inode_locked4(inode, ip->i_no_addr, iget_test, &ip->i_no_addr);
		717	BUG_ON(error);
		718
740	error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, GL_SKIP, ghs + 1);	719	error = gfs2_glock_nq_init(ip->i_gl, LM_ST_EXCLUSIVE, GL_SKIP, ghs + 1);
741	if (error)	720	if (error)
742	goto fail_gunlock2;	721	goto fail_gunlock2;
743		722
744	glock_set_object(ip->i_gl, ip);
745	error = gfs2_trans_begin(sdp, blocks, 0);	723	error = gfs2_trans_begin(sdp, blocks, 0);
746	if (error)	724	if (error)
747	goto fail_gunlock2;	725	goto fail_gunlock2;
@@ -757,9 +735,9 @@ static int gfs2_create_inode(struct inode dir, struct dentry dentry, · 9 unmodified lines
757	if (error)	735	if (error)
758	goto fail_gunlock2;	736	goto fail_gunlock2;
759		737
		738	glock_set_object(ip->i_gl, ip);
760	glock_set_object(io_gl, ip);	739	glock_set_object(io_gl, ip);
761	gfs2_set_iop(inode);	740	gfs2_set_iop(inode);
762	insert_inode_hash(inode);
763		741
764	free_vfs_inode = 0; /* After this point, the inode is no longer	742	free_vfs_inode = 0; /* After this point, the inode is no longer
765	considered free. Any failures need to undo	743	considered free. Any failures need to undo
@@ -801,17 +779,17 @@ static int gfs2_create_inode(struct inode dir, struct dentry dentry, · 35 unmodified lines
801	gfs2_glock_dq_uninit(ghs + 1);	779	gfs2_glock_dq_uninit(ghs + 1);
802	gfs2_glock_put(io_gl);	780	gfs2_glock_put(io_gl);
803	gfs2_qa_put(dip);	781	gfs2_qa_put(dip);
		782	unlock_new_inode(inode);
804	return error;	783	return error;
805		784
806	fail_gunlock3:	785	fail_gunlock3:
		786	glock_clear_object(ip->i_gl, ip);
807	glock_clear_object(io_gl, ip);	787	glock_clear_object(io_gl, ip);
808	gfs2_glock_dq_uninit(&ip->i_iopen_gh);	788	gfs2_glock_dq_uninit(&ip->i_iopen_gh);
809	fail_gunlock2:	789	fail_gunlock2:
810	glock_clear_object(io_gl, ip);
811	gfs2_glock_put(io_gl);	790	gfs2_glock_put(io_gl);
812	fail_free_inode:	791	fail_free_inode:
813	if (ip->i_gl) {	792	if (ip->i_gl) {
814	glock_clear_object(ip->i_gl, ip);
815	if (free_vfs_inode) /* else evict will do the put for us */	793	if (free_vfs_inode) /* else evict will do the put for us */
816	gfs2_glock_put(ip->i_gl);	794	gfs2_glock_put(ip->i_gl);
817	}	795	}
@@ -829,7 +807,10 @@ fail_gunlock: · 11 unmodified lines
829	mark_inode_dirty(inode);	807	mark_inode_dirty(inode);
830	set_bit(free_vfs_inode ? GIF_FREE_VFS_INODE : GIF_ALLOC_FAILED,	808	set_bit(free_vfs_inode ? GIF_FREE_VFS_INODE : GIF_ALLOC_FAILED,
831	&GFS2_I(inode)->i_flags);	809	&GFS2_I(inode)->i_flags);
832	iput(inode);	810	if (inode->i_state & I_NEW)
		811	iget_failed(inode);
		812	else
		813	iput(inode);
833	}	814	}
834	if (gfs2_holder_initialized(ghs + 1))	815	if (gfs2_holder_initialized(ghs + 1))
835	gfs2_glock_dq_uninit(ghs + 1);	816	gfs2_glock_dq_uninit(ghs + 1);

fs/io-wq.c+30−6

 					struct io_wqe_acct *acct,
 					struct io_cb_cancel_data *match);
 static void create_worker_cb(struct callback_head *cb);
+static void io_wq_cancel_tw_create(struct io_wq *wq);
 static bool io_worker_get(struct io_worker *worker)
 {
 	    test_and_set_bit_lock(0, &worker->create_state))
 		goto fail_release;
+	atomic_inc(&wq->worker_refs);
 	init_task_work(&worker->create_work, func);
 	worker->create_index = acct->index;
 	if (!task_work_add(wq->task, &worker->create_work, TWA_SIGNAL)) {
-		clear_bit_unlock(0, &worker->create_state);
+		/*
+		 * EXIT may have been set after checking it above, check after
+		 * adding the task_work and remove any creation item if it is
+		 * now set. wq exit does that too, but we can have added this
+		 * work item after we canceled in io_wq_exit_workers().
+		 */
+		if (test_bit(IO_WQ_BIT_EXIT, &wq->state))
+			io_wq_cancel_tw_create(wq);
+		io_worker_ref_put(wq);
 		return true;
 	}
+	io_worker_ref_put(wq);
 	clear_bit_unlock(0, &worker->create_state);
 fail_release:
 	io_worker_release(worker);
 static inline bool io_should_retry_thread(long err)
 {
+	/*
+	 * Prevent perpetual task_work retry, if the task (or its group) is
+	 * exiting.
+	 */
+	if (fatal_signal_pending(current))
+		return false;
 	switch (err) {
 	case -EAGAIN:
 	case -ERESTARTSYS:
 	set_bit(IO_WQ_BIT_EXIT, &wq->state);
 }
-static void io_wq_exit_workers(struct io_wq *wq)
+static void io_wq_cancel_tw_create(struct io_wq *wq)
 {
 	struct callback_head *cb;
-	int node;
-	if (!wq->task)
-		return;
 	while ((cb = task_work_cancel_match(wq->task, io_task_work_match, wq)) != NULL) {
 		struct io_worker *worker;
 		worker = container_of(cb, struct io_worker, create_work);
 		io_worker_cancel_cb(worker);
 	}
+}
+static void io_wq_exit_workers(struct io_wq *wq)
+{
+	int node;
+	if (!wq->task)
+		return;
+	io_wq_cancel_tw_create(wq);
 	rcu_read_lock();
 	for_each_node(node) {

fs/io_uring.c+4−2

 /*
  * Find any io_uring ctx that this task has registered or done IO on, and cancel
- * requests. @sqd should be not-null IIF it's an SQPOLL thread cancellation.
+ * requests. @sqd should be not-null IFF it's an SQPOLL thread cancellation.
  */
 static __cold void io_uring_cancel_generic(bool cancel_all,
 					   struct io_sq_data *sqd)
 							     cancel_all);
 		}
-		prepare_to_wait(&tctx->wait, &wait, TASK_UNINTERRUPTIBLE);
+		prepare_to_wait(&tctx->wait, &wait, TASK_INTERRUPTIBLE);
+		io_run_task_work();
 		io_uring_drop_tctx_refs(current);
 		/*
 		 * If we've seen completions, retry without waiting. This
 		 * avoids a race where a completion comes in before we did

fs/netfs/read_helper.c+10−15

 	netfs_rreq_do_write_to_cache(rreq);
 }
-static void netfs_rreq_write_to_cache(struct netfs_read_request *rreq,
+static void netfs_rreq_write_to_cache(struct netfs_read_request *rreq)
-				      bool was_async)
 {
-	if (was_async) {
+	rreq->work.func = netfs_rreq_write_to_cache_work;
-		rreq->work.func = netfs_rreq_write_to_cache_work;
+	if (!queue_work(system_unbound_wq, &rreq->work))
-		if (!queue_work(system_unbound_wq, &rreq->work))
+		BUG();
-			BUG();
-	} else {
-		netfs_rreq_do_write_to_cache(rreq);
-	}
 }
 /*
 	wake_up_bit(&rreq->flags, NETFS_RREQ_IN_PROGRESS);
 	if (test_bit(NETFS_RREQ_WRITE_TO_CACHE, &rreq->flags))
-		return netfs_rreq_write_to_cache(rreq, was_async);
+		return netfs_rreq_write_to_cache(rreq);
 	netfs_rreq_completed(rreq, was_async);
 }
 	rreq = netfs_alloc_read_request(ops, netfs_priv, file);
 	if (!rreq) {
 		if (netfs_priv)
-			ops->cleanup(netfs_priv, folio_file_mapping(folio));
+			ops->cleanup(folio_file_mapping(folio), netfs_priv);
 		folio_unlock(folio);
 		return -ENOMEM;
 	}
 }
 EXPORT_SYMBOL(netfs_readpage);
-/**
+/*
- * netfs_skip_folio_read - prep a folio for writing without reading first
+ * Prepare a folio for writing without reading first
  * @folio: The folio being prepared
  * @pos: starting position for the write
  * @len: length of write
 		goto error;
 have_folio_no_wait:
 	if (netfs_priv)
-		ops->cleanup(netfs_priv, mapping);
+		ops->cleanup(mapping, netfs_priv);
 	*_folio = folio;
 	_leave(" = 0");
 	return 0;
 	folio_unlock(folio);
 	folio_put(folio);
 	if (netfs_priv)
-		ops->cleanup(netfs_priv, mapping);
+		ops->cleanup(mapping, netfs_priv);
 	_leave(" = %d", ret);
 	return ret;
 }

fs/nfsd/nfs4recover.c+1−0

@@ -2156,6 +2156,7 @@ static struct notifier_block nfsd4_cld_block = { · 2155 unmodified lines
2156	int	2156	int
2157	register_cld_notifier(void)	2157	register_cld_notifier(void)
2158	{	2158	{
		2159	WARN_ON(!nfsd_net_id);
2159	return rpc_pipefs_notifier_register(&nfsd4_cld_block);	2160	return rpc_pipefs_notifier_register(&nfsd4_cld_block);
2160	}	2161	}
2161		2162

fs/nfsd/nfs4state.c+7−2

 	return 0;
 }
+static bool delegation_hashed(struct nfs4_delegation *dp)
+{
+	return !(list_empty(&dp->dl_perfile));
+}
 static bool
 unhash_delegation_locked(struct nfs4_delegation *dp)
 {
 	lockdep_assert_held(&state_lock);
-	if (list_empty(&dp->dl_perfile))
+	if (!delegation_hashed(dp))
 		return false;
 	dp->dl_stid.sc_type = NFS4_CLOSED_DELEG_STID;
 	 * queued for a lease break. Don't queue it again.
 	 */
 	spin_lock(&state_lock);
-	if (dp->dl_time == 0) {
+	if (delegation_hashed(dp) && dp->dl_time == 0) {
 		dp->dl_time = ktime_get_boottime_seconds();
 		list_add_tail(&dp->dl_recall_lru, &nn->del_recall_lru);
 	}

fs/nfsd/nfsctl.c+7−7

 	int retval;
 	printk(KERN_INFO "Installing knfsd (copyright (C) 1996 okir@monad.swb.de).\n");
-	retval = register_cld_notifier();
-	if (retval)
-		return retval;
 	retval = nfsd4_init_slabs();
 	if (retval)
-		goto out_unregister_notifier;
+		return retval;
 	retval = nfsd4_init_pnfs();
 	if (retval)
 		goto out_free_slabs;
 		goto out_free_exports;
 	retval = register_pernet_subsys(&nfsd_net_ops);
 	if (retval < 0)
+		goto out_free_filesystem;
+	retval = register_cld_notifier();
+	if (retval)
 		goto out_free_all;
 	return 0;
 out_free_all:
+	unregister_pernet_subsys(&nfsd_net_ops);
+out_free_filesystem:
 	unregister_filesystem(&nfsd_fs_type);
 out_free_exports:
 	remove_proc_entry("fs/nfs/exports", NULL);
 	nfsd4_exit_pnfs();
 out_free_slabs:
 	nfsd4_free_slabs();
-out_unregister_notifier:
-	unregister_cld_notifier();
 	return retval;
 }
 static void __exit exit_nfsd(void)
 {
+	unregister_cld_notifier();
 	unregister_pernet_subsys(&nfsd_net_ops);
 	nfsd_drc_slab_free();
 	remove_proc_entry("fs/nfs/exports", NULL);
 	nfsd4_free_slabs();
 	nfsd4_exit_pnfs();
 	unregister_filesystem(&nfsd_fs_type);
-	unregister_cld_notifier();
 }
 MODULE_AUTHOR("Olaf Kirch <okir@monad.swb.de>");

fs/signalfd.c+1−11

@@ -35,17 +35,7 @@ · 34 unmodified lines
35		35
36	void signalfd_cleanup(struct sighand_struct *sighand)	36	void signalfd_cleanup(struct sighand_struct *sighand)
37	{	37	{
38	wait_queue_head_t *wqh = &sighand->signalfd_wqh;	38	wake_up_pollfree(&sighand->signalfd_wqh);
39	/*
40	* The lockless check can race with remove_wait_queue() in progress,
41	* but in this case its caller should run under rcu_read_lock() and
42	* sighand_cachep is SLAB_TYPESAFE_BY_RCU, we can safely return.
43	*/
44	if (likely(!waitqueue_active(wqh)))
45	return;
46
47	/* wait_queue_entry_t->func(POLLFREE) should do remove_wait_queue() */
48	wake_up_poll(wqh, EPOLLHUP \| POLLFREE);
49	}	39	}
50		40
51	struct signalfd_ctx {	41	struct signalfd_ctx {

fs/smbfs_common/cifs_arc4.c+0−13

@@ -72,16 +72,3 @@ void cifs_arc4_crypt(struct arc4_ctx ctx, u8 out, const u8 *in, unsigned int l · 71 unmodified lines
72	ctx->y = y;	72	ctx->y = y;
73	}	73	}
74	EXPORT_SYMBOL_GPL(cifs_arc4_crypt);	74	EXPORT_SYMBOL_GPL(cifs_arc4_crypt);
75
76	static int __init
77	init_smbfs_common(void)
78	{
79	return 0;
80	}
81	static void __init
82	exit_smbfs_common(void)
83	{
84	}
85
86	module_init(init_smbfs_common)
87	module_exit(exit_smbfs_common)

fs/tracefs/inode.c+76−0

@@ -161,6 +161,77 @@ struct tracefs_fs_info { · 160 unmodified lines
161	struct tracefs_mount_opts mount_opts;	161	struct tracefs_mount_opts mount_opts;
162	};	162	};
163		163
		164	static void change_gid(struct dentry *dentry, kgid_t gid)
		165	{
		166	if (!dentry->d_inode)
		167	return;
		168	dentry->d_inode->i_gid = gid;
		169	}
		170
		171	/*
		172	* Taken from d_walk, but without he need for handling renames.
		173	* Nothing can be renamed while walking the list, as tracefs
		174	* does not support renames. This is only called when mounting
		175	* or remounting the file system, to set all the files to
		176	* the given gid.
		177	*/
		178	static void set_gid(struct dentry *parent, kgid_t gid)
		179	{
		180	struct dentry *this_parent;
		181	struct list_head *next;
		182
		183	this_parent = parent;
		184	spin_lock(&this_parent->d_lock);
		185
		186	change_gid(this_parent, gid);
		187	repeat:
		188	next = this_parent->d_subdirs.next;
		189	resume:
		190	while (next != &this_parent->d_subdirs) {
		191	struct list_head *tmp = next;
		192	struct dentry *dentry = list_entry(tmp, struct dentry, d_child);
		193	next = tmp->next;
		194
		195	spin_lock_nested(&dentry->d_lock, DENTRY_D_LOCK_NESTED);
		196
		197	change_gid(dentry, gid);
		198
		199	if (!list_empty(&dentry->d_subdirs)) {
		200	spin_unlock(&this_parent->d_lock);
		201	spin_release(&dentry->d_lock.dep_map, _RET_IP_);
		202	this_parent = dentry;
		203	spin_acquire(&this_parent->d_lock.dep_map, 0, 1, _RET_IP_);
		204	goto repeat;
		205	}
		206	spin_unlock(&dentry->d_lock);
		207	}
		208	/*
		209	* All done at this level ... ascend and resume the search.
		210	*/
		211	rcu_read_lock();
		212	ascend:
		213	if (this_parent != parent) {
		214	struct dentry *child = this_parent;
		215	this_parent = child->d_parent;
		216
		217	spin_unlock(&child->d_lock);
		218	spin_lock(&this_parent->d_lock);
		219
		220	/* go into the first sibling still alive */
		221	do {
		222	next = child->d_child.next;
		223	if (next == &this_parent->d_subdirs)
		224	goto ascend;
		225	child = list_entry(next, struct dentry, d_child);
		226	} while (unlikely(child->d_flags & DCACHE_DENTRY_KILLED));
		227	rcu_read_unlock();
		228	goto resume;
		229	}
		230	rcu_read_unlock();
		231	spin_unlock(&this_parent->d_lock);
		232	return;
		233	}
		234
164	static int tracefs_parse_options(char data, struct tracefs_mount_opts opts)	235	static int tracefs_parse_options(char data, struct tracefs_mount_opts opts)
165	{	236	{
166	substring_t args[MAX_OPT_ARGS];	237	substring_t args[MAX_OPT_ARGS];
@@ -193,6 +264,7 @@ static int tracefs_parse_options(char data, struct tracefs_mount_opts opts) · 26 unmodified lines
193	if (!gid_valid(gid))	264	if (!gid_valid(gid))
194	return -EINVAL;	265	return -EINVAL;
195	opts->gid = gid;	266	opts->gid = gid;
		267	set_gid(tracefs_mount->mnt_root, gid);
196	break;	268	break;
197	case Opt_mode:	269	case Opt_mode:
198	if (match_octal(&args[0], &option))	270	if (match_octal(&args[0], &option))
@@ -414,6 +486,8 @@ struct dentry tracefs_create_file(const char name, umode_t mode, · 215 unmodified lines
414	inode->i_mode = mode;	486	inode->i_mode = mode;
415	inode->i_fop = fops ? fops : &tracefs_file_operations;	487	inode->i_fop = fops ? fops : &tracefs_file_operations;
416	inode->i_private = data;	488	inode->i_private = data;
		489	inode->i_uid = d_inode(dentry->d_parent)->i_uid;
		490	inode->i_gid = d_inode(dentry->d_parent)->i_gid;
417	d_instantiate(dentry, inode);	491	d_instantiate(dentry, inode);
418	fsnotify_create(dentry->d_parent->d_inode, dentry);	492	fsnotify_create(dentry->d_parent->d_inode, dentry);
419	return end_creating(dentry);	493	return end_creating(dentry);
@@ -436,6 +510,8 @@ static struct dentry __create_dir(const char name, struct dentry *parent, · 16 unmodified lines
436	inode->i_mode = S_IFDIR \| S_IRWXU \| S_IRUSR\| S_IRGRP \| S_IXUSR \| S_IXGRP;	510	inode->i_mode = S_IFDIR \| S_IRWXU \| S_IRUSR\| S_IRGRP \| S_IXUSR \| S_IXGRP;
437	inode->i_op = ops;	511	inode->i_op = ops;
438	inode->i_fop = &simple_dir_operations;	512	inode->i_fop = &simple_dir_operations;
		513	inode->i_uid = d_inode(dentry->d_parent)->i_uid;
		514	inode->i_gid = d_inode(dentry->d_parent)->i_gid;
439		515
440	/* directory inodes start off with i_nlink == 2 (for "." entry) */	516	/* directory inodes start off with i_nlink == 2 (for "." entry) */
441	inc_nlink(inode);	517	inc_nlink(inode);

fs/xfs/xfs_inode.c+0−1

@@ -3122,7 +3122,6 @@ xfs_rename( · 3121 unmodified lines
3122	* appropriately.	3122	* appropriately.
3123	*/	3123	*/
3124	if (flags & RENAME_WHITEOUT) {	3124	if (flags & RENAME_WHITEOUT) {
3125	ASSERT(!(flags & (RENAME_NOREPLACE \| RENAME_EXCHANGE)));
3126	error = xfs_rename_alloc_whiteout(mnt_userns, target_dp, &wip);	3125	error = xfs_rename_alloc_whiteout(mnt_userns, target_dp, &wip);
3127	if (error)	3126	if (error)
3128	return error;	3127	return error;

fs/xfs/xfs_super.c+11−3

 xfs_remount_ro(
 	struct xfs_mount	*mp)
 {
-	int error;
+	struct xfs_icwalk	icw = {
+		.icw_flags	= XFS_ICWALK_FLAG_SYNC,
+	};
+	int			error;
 	/*
 	 * Cancel background eofb scanning so it cannot race with the final
 	 */
 	xfs_blockgc_stop(mp);
-	/* Get rid of any leftover CoW reservations... */
+	/*
-	error = xfs_blockgc_free_space(mp, NULL);
+	 * Clear out all remaining COW staging extents and speculative post-EOF
+	 * preallocations so that we don't leave inodes requiring inactivation
+	 * cleanups during reclaim on a read-only mount.  We must process every
+	 * cached inode, so this requires a synchronous cache scan.
+	 */
+	error = xfs_blockgc_free_space(mp, &icw);
 	if (error) {
 		xfs_force_shutdown(mp, SHUTDOWN_CORRUPT_INCORE);
 		return error;

include/linux/bpf.h+3−14

 struct bpf_trampoline *bpf_trampoline_get(u64 key,
 					  struct bpf_attach_target_info *tgt_info);
 void bpf_trampoline_put(struct bpf_trampoline *tr);
+int arch_prepare_bpf_dispatcher(void *image, s64 *funcs, int num_funcs);
 #define BPF_DISPATCHER_INIT(_name) {				\
 	.mutex = __MUTEX_INITIALIZER(_name.mutex),		\
 	.func = &_name##_func,					\
  * kprobes, tracepoints) to prevent deadlocks on map operations as any of
  * these events can happen inside a region which holds a map bucket lock
  * and can deadlock on it.
- *
- * Use the preemption safe inc/dec variants on RT because migrate disable
- * is preemptible on RT and preemption in the middle of the RMW operation
- * might lead to inconsistent state. Use the raw variants for non RT
- * kernels as migrate_disable() maps to preempt_disable() so the slightly
- * more expensive save operation can be avoided.
  */
 static inline void bpf_disable_instrumentation(void)
 {
 	migrate_disable();
-	if (IS_ENABLED(CONFIG_PREEMPT_RT))
+	this_cpu_inc(bpf_prog_active);
-		this_cpu_inc(bpf_prog_active);
-	else
-		__this_cpu_inc(bpf_prog_active);
 }
 static inline void bpf_enable_instrumentation(void)
 {
-	if (IS_ENABLED(CONFIG_PREEMPT_RT))
+	this_cpu_dec(bpf_prog_active);
-		this_cpu_dec(bpf_prog_active);
-	else
-		__this_cpu_dec(bpf_prog_active);
 	migrate_enable();
 }

include/linux/btf.h+10−4

 	struct module *owner;
 };
-struct kfunc_btf_id_list;
+struct kfunc_btf_id_list {
+	struct list_head list;
+	struct mutex mutex;
+};
 #ifdef CONFIG_DEBUG_INFO_BTF_MODULES
 void register_kfunc_btf_id_set(struct kfunc_btf_id_list *l,
 				 struct kfunc_btf_id_set *s);
 bool bpf_check_mod_kfunc_call(struct kfunc_btf_id_list *klist, u32 kfunc_id,
 			      struct module *owner);
+extern struct kfunc_btf_id_list bpf_tcp_ca_kfunc_list;
+extern struct kfunc_btf_id_list prog_test_kfunc_list;
 #else
 static inline void register_kfunc_btf_id_set(struct kfunc_btf_id_list *l,
 					     struct kfunc_btf_id_set *s)
 {
 	return false;
 }
+static struct kfunc_btf_id_list bpf_tcp_ca_kfunc_list __maybe_unused;
+static struct kfunc_btf_id_list prog_test_kfunc_list __maybe_unused;
 #endif
 #define DEFINE_KFUNC_BTF_ID_SET(set, name)                                     \
 	struct kfunc_btf_id_set name = { LIST_HEAD_INIT(name.list), (set),     \
 					 THIS_MODULE }
-extern struct kfunc_btf_id_list bpf_tcp_ca_kfunc_list;
-extern struct kfunc_btf_id_list prog_test_kfunc_list;
 #endif

include/linux/cacheinfo.h+0−1

@@ -3,7 +3,6 @@ · 2 unmodified lines
3	#define _LINUX_CACHEINFO_H	3	#define _LINUX_CACHEINFO_H
4		4
5	#include <linux/bitops.h>	5	#include <linux/bitops.h>
6	#include <linux/cpu.h>
7	#include <linux/cpumask.h>	6	#include <linux/cpumask.h>
8	#include <linux/smp.h>	7	#include <linux/smp.h>
9		8

include/linux/delay.h+13−1

  */
 #include <linux/math.h>
+#include <linux/sched.h>
 extern unsigned long loops_per_jiffy;
 void __attribute__((weak)) calibration_delay_done(void);
 void msleep(unsigned int msecs);
 unsigned long msleep_interruptible(unsigned int msecs);
-void usleep_range(unsigned long min, unsigned long max);
+void usleep_range_state(unsigned long min, unsigned long max,
+			unsigned int state);
+static inline void usleep_range(unsigned long min, unsigned long max)
+{
+	usleep_range_state(min, max, TASK_UNINTERRUPTIBLE);
+}
+static inline void usleep_idle_range(unsigned long min, unsigned long max)
+{
+	usleep_range_state(min, max, TASK_IDLE);
+}
 static inline void ssleep(unsigned int seconds)
 {

include/linux/device/driver.h+1−0

@@ -18,6 +18,7 @@ · 17 unmodified lines
18	#include <linux/klist.h>	18	#include <linux/klist.h>
19	#include <linux/pm.h>	19	#include <linux/pm.h>
20	#include <linux/device/bus.h>	20	#include <linux/device/bus.h>
		21	#include <linux/module.h>
21		22
22	/**	23	/**
23	* enum probe_type - device driver probe type to try	24	* enum probe_type - device driver probe type to try

include/linux/filter.h+1−4

 #define __LINUX_FILTER_H__
 #include <linux/atomic.h>
+#include <linux/bpf.h>
 #include <linux/refcount.h>
 #include <linux/compat.h>
 #include <linux/skbuff.h>
 #include <asm/byteorder.h>
 #include <uapi/linux/filter.h>
-#include <uapi/linux/bpf.h>
 struct sk_buff;
 struct sock;
  * This uses migrate_disable/enable() explicitly to document that the
  * invocation of a BPF program does not require reentrancy protection
  * against a BPF program which is invoked from a preempting task.
- *
- * For non RT enabled kernels migrate_disable/enable() maps to
- * preempt_disable/enable(), i.e. it disables also preemption.
  */
 static inline u32 bpf_prog_run_pin_on_cpu(const struct bpf_prog *prog,
 					  const void *ctx)

include/linux/hid.h+5−0

 	return hdev->ll_driver == driver;
 }
+static inline bool hid_is_usb(struct hid_device *hdev)
+{
+	return hid_is_using_ll_driver(hdev, &usb_hid_driver);
+}
 #define	PM_HINT_FULLON	1<<5
 #define PM_HINT_NORMAL	1<<1

include/linux/kprobes.h+2−0

@@ -153,6 +153,8 @@ struct kretprobe { · 152 unmodified lines
153	struct kretprobe_holder *rph;	153	struct kretprobe_holder *rph;
154	};	154	};
155		155
		156	#define KRETPROBE_MAX_DATA_SIZE 4096
		157
156	struct kretprobe_instance {	158	struct kretprobe_instance {
157	union {	159	union {
158	struct freelist_node freelist;	160	struct freelist_node freelist;

include/linux/mhi.h+13−0

@@ -663,6 +663,19 @@ int mhi_pm_suspend(struct mhi_controller *mhi_cntrl); · 662 unmodified lines
663	*/	663	*/
664	int mhi_pm_resume(struct mhi_controller *mhi_cntrl);	664	int mhi_pm_resume(struct mhi_controller *mhi_cntrl);
665		665
		666	/**
		667	* mhi_pm_resume_force - Force resume MHI from suspended state
		668	* @mhi_cntrl: MHI controller
		669	*
		670	* Resume the device irrespective of its MHI state. As per the MHI spec, devices
		671	* has to be in M3 state during resume. But some devices seem to be in a
		672	* different MHI state other than M3 but they continue working fine if allowed.
		673	* This API is intented to be used for such devices.
		674	*
		675	* Return: 0 if the resume succeeds, a negative error code otherwise
		676	*/
		677	int mhi_pm_resume_force(struct mhi_controller *mhi_cntrl);
		678
666	/**	679	/**
667	* mhi_download_rddm_image - Download ramdump image from device for	680	* mhi_download_rddm_image - Download ramdump image from device for
668	* debugging purpose.	681	* debugging purpose.

include/linux/mlx5/mlx5_ifc.h+4−1

@@ -9698,7 +9698,10 @@ struct mlx5_ifc_mcam_access_reg_bits { · 9697 unmodified lines
9698	u8 regs_84_to_68[0x11];	9698	u8 regs_84_to_68[0x11];
9699	u8 tracer_registers[0x4];	9699	u8 tracer_registers[0x4];
9700		9700
9701	u8 regs_63_to_32[0x20];	9701	u8 regs_63_to_46[0x12];
		9702	u8 mrtc[0x1];
		9703	u8 regs_44_to_32[0xd];
		9704
9702	u8 regs_31_to_0[0x20];	9705	u8 regs_31_to_0[0x20];
9703	};	9706	};
9704		9707

include/linux/netdevice.h+13−6

@@ -4404,7 +4404,8 @@ static inline u32 netif_msg_init(int debug_value, int default_msg_enable_bits) · 4403 unmodified lines
4404	static inline void __netif_tx_lock(struct netdev_queue *txq, int cpu)	4404	static inline void __netif_tx_lock(struct netdev_queue *txq, int cpu)
4405	{	4405	{
4406	spin_lock(&txq->_xmit_lock);	4406	spin_lock(&txq->_xmit_lock);
4407	txq->xmit_lock_owner = cpu;	4407	/* Pairs with READ_ONCE() in __dev_queue_xmit() */
		4408	WRITE_ONCE(txq->xmit_lock_owner, cpu);
4408	}	4409	}
4409		4410
4410	static inline bool __netif_tx_acquire(struct netdev_queue *txq)	4411	static inline bool __netif_tx_acquire(struct netdev_queue *txq)
@@ -4421,26 +4422,32 @@ static inline void __netif_tx_release(struct netdev_queue *txq) · 10 unmodified lines
4421	static inline void __netif_tx_lock_bh(struct netdev_queue *txq)	4422	static inline void __netif_tx_lock_bh(struct netdev_queue *txq)
4422	{	4423	{
4423	spin_lock_bh(&txq->_xmit_lock);	4424	spin_lock_bh(&txq->_xmit_lock);
4424	txq->xmit_lock_owner = smp_processor_id();	4425	/* Pairs with READ_ONCE() in __dev_queue_xmit() */
		4426	WRITE_ONCE(txq->xmit_lock_owner, smp_processor_id());
4425	}	4427	}
4426		4428
4427	static inline bool __netif_tx_trylock(struct netdev_queue *txq)	4429	static inline bool __netif_tx_trylock(struct netdev_queue *txq)
4428	{	4430	{
4429	bool ok = spin_trylock(&txq->_xmit_lock);	4431	bool ok = spin_trylock(&txq->_xmit_lock);
4430	if (likely(ok))	4432
4431	txq->xmit_lock_owner = smp_processor_id();	4433	if (likely(ok)) {
		4434	/* Pairs with READ_ONCE() in __dev_queue_xmit() */
		4435	WRITE_ONCE(txq->xmit_lock_owner, smp_processor_id());
		4436	}
4432	return ok;	4437	return ok;
4433	}	4438	}
4434		4439
4435	static inline void __netif_tx_unlock(struct netdev_queue *txq)	4440	static inline void __netif_tx_unlock(struct netdev_queue *txq)
4436	{	4441	{
4437	txq->xmit_lock_owner = -1;	4442	/* Pairs with READ_ONCE() in __dev_queue_xmit() */
		4443	WRITE_ONCE(txq->xmit_lock_owner, -1);
4438	spin_unlock(&txq->_xmit_lock);	4444	spin_unlock(&txq->_xmit_lock);
4439	}	4445	}
4440		4446
4441	static inline void __netif_tx_unlock_bh(struct netdev_queue *txq)	4447	static inline void __netif_tx_unlock_bh(struct netdev_queue *txq)
4442	{	4448	{
4443	txq->xmit_lock_owner = -1;	4449	/* Pairs with READ_ONCE() in __dev_queue_xmit() */
		4450	WRITE_ONCE(txq->xmit_lock_owner, -1);
4444	spin_unlock_bh(&txq->_xmit_lock);	4451	spin_unlock_bh(&txq->_xmit_lock);
4445	}	4452	}
4446		4453

include/linux/percpu-refcount.h+1−1

 #define _LINUX_PERCPU_REFCOUNT_H
 #include <linux/atomic.h>
-#include <linux/kernel.h>
 #include <linux/percpu.h>
 #include <linux/rcupdate.h>
+#include <linux/types.h>
 #include <linux/gfp.h>
 struct percpu_ref;

include/linux/phy.h+6−5

@@ -538,11 +538,12 @@ struct macsec_ops; · 537 unmodified lines
538	* @mac_managed_pm: Set true if MAC driver takes of suspending/resuming PHY	538	* @mac_managed_pm: Set true if MAC driver takes of suspending/resuming PHY
539	* @state: State of the PHY for management purposes	539	* @state: State of the PHY for management purposes
540	* @dev_flags: Device-specific flags used by the PHY driver.	540	* @dev_flags: Device-specific flags used by the PHY driver.
541	* Bits [15:0] are free to use by the PHY driver to communicate	541	*
542	* driver specific behavior.	542	* - Bits [15:0] are free to use by the PHY driver to communicate
543	* Bits [23:16] are currently reserved for future use.	543	* driver specific behavior.
544	* Bits [31:24] are reserved for defining generic	544	* - Bits [23:16] are currently reserved for future use.
545	* PHY driver behavior.	545	* - Bits [31:24] are reserved for defining generic
		546	* PHY driver behavior.
546	* @irq: IRQ number of the PHY's interrupt (-1 if none)	547	* @irq: IRQ number of the PHY's interrupt (-1 if none)
547	* @phy_timer: The timer for handling the state machine	548	* @phy_timer: The timer for handling the state machine
548	* @phylink: Pointer to phylink instance for this PHY	549	* @phylink: Pointer to phylink instance for this PHY

include/linux/pm_runtime.h+1−1

@@ -129,7 +129,7 @@ static inline bool pm_runtime_suspended(struct device *dev) · 128 unmodified lines
129	* pm_runtime_active - Check whether or not a device is runtime-active.	129	* pm_runtime_active - Check whether or not a device is runtime-active.
130	* @dev: Target device.	130	* @dev: Target device.
131	*	131	*
132	* Return %true if runtime PM is enabled for @dev and its runtime PM status is	132	* Return %true if runtime PM is disabled for @dev or its runtime PM status is
133	* %RPM_ACTIVE, or %false otherwise.	133	* %RPM_ACTIVE, or %false otherwise.
134	*	134	*
135	* Note that the return value of this function can only be trusted if it is	135	* Note that the return value of this function can only be trusted if it is

include/linux/regulator/driver.h+8−6

  *		best to shut-down regulator(s) or reboot the SOC if error
  *		handling is repeatedly failing. If fatal_cnt is given the IRQ
  *		handling is aborted if it fails for fatal_cnt times and die()
- *		callback (if populated) or BUG() is called to try to prevent
+ *		callback (if populated) is called. If die() is not populated
+ *		poweroff for the system is attempted in order to prevent any
  *		further damage.
  * @reread_ms:	The time which is waited before attempting to re-read status
  *		at the worker if IC reading fails. Immediate re-read is done
  * @data:	Driver private data pointer which will be passed as such to
  *		the renable, map_event and die callbacks in regulator_irq_data.
  * @die:	Protection callback. If IC status reading or recovery actions
- *		fail fatal_cnt times this callback or BUG() is called. This
+ *		fail fatal_cnt times this callback is called or system is
- *		callback should implement a final protection attempt like
+ *		powered off. This callback should implement a final protection
- *		disabling the regulator. If protection succeeded this may
+ *		attempt like disabling the regulator. If protection succeeded
- *		return 0. If anything else is returned the core assumes final
+ *		die() may return 0. If anything else is returned the core
- *		protection failed and calls BUG() as a last resort.
+ *		assumes final protection failed and attempts to perform a
+ *		poweroff as a last resort.
  * @map_event:	Driver callback to map IRQ status into regulator devices with
  *		events / errors. NOTE: callback MUST initialize both the
  *		errors and notifs for all rdevs which it signals having

include/linux/sched/cputime.h+3−2

 #endif /* CONFIG_VIRT_CPU_ACCOUNTING_NATIVE */
 #ifdef CONFIG_VIRT_CPU_ACCOUNTING_GEN
-extern void task_cputime(struct task_struct *t,
+extern bool task_cputime(struct task_struct *t,
 			 u64 *utime, u64 *stime);
 extern u64 task_gtime(struct task_struct *t);
 #else
-static inline void task_cputime(struct task_struct *t,
+static inline bool task_cputime(struct task_struct *t,
 				u64 *utime, u64 *stime)
 {
 	*utime = t->utime;
 	*stime = t->stime;
+	return false;
 }
 static inline u64 task_gtime(struct task_struct *t)

include/linux/siphash.h+4−10

 }
 u64 __siphash_aligned(const void *data, size_t len, const siphash_key_t *key);
-#ifndef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
 u64 __siphash_unaligned(const void *data, size_t len, const siphash_key_t *key);
-#endif
 u64 siphash_1u64(const u64 a, const siphash_key_t *key);
 u64 siphash_2u64(const u64 a, const u64 b, const siphash_key_t *key);
 static inline u64 siphash(const void *data, size_t len,
 			  const siphash_key_t *key)
 {
-#ifndef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
+	if (IS_ENABLED(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS) ||
-	if (!IS_ALIGNED((unsigned long)data, SIPHASH_ALIGNMENT))
+	    !IS_ALIGNED((unsigned long)data, SIPHASH_ALIGNMENT))
 		return __siphash_unaligned(data, len, key);
-#endif
 	return ___siphash_aligned(data, len, key);
 }
 u32 __hsiphash_aligned(const void *data, size_t len,
 		       const hsiphash_key_t *key);
-#ifndef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
 u32 __hsiphash_unaligned(const void *data, size_t len,
 			 const hsiphash_key_t *key);
-#endif
 u32 hsiphash_1u32(const u32 a, const hsiphash_key_t *key);
 u32 hsiphash_2u32(const u32 a, const u32 b, const hsiphash_key_t *key);
 static inline u32 hsiphash(const void *data, size_t len,
 			   const hsiphash_key_t *key)
 {
-#ifndef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
+	if (IS_ENABLED(CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS) ||
-	if (!IS_ALIGNED((unsigned long)data, HSIPHASH_ALIGNMENT))
+	    !IS_ALIGNED((unsigned long)data, HSIPHASH_ALIGNMENT))
 		return __hsiphash_unaligned(data, len, key);
-#endif
 	return ___hsiphash_aligned(data, len, key);
 }

include/linux/wait.h+26−0

@@ -217,6 +217,7 @@ void __wake_up_sync_key(struct wait_queue_head *wq_head, unsigned int mode, void · 216 unmodified lines
217	void __wake_up_locked_sync_key(struct wait_queue_head wq_head, unsigned int mode, void key);	217	void __wake_up_locked_sync_key(struct wait_queue_head wq_head, unsigned int mode, void key);
218	void __wake_up_locked(struct wait_queue_head *wq_head, unsigned int mode, int nr);	218	void __wake_up_locked(struct wait_queue_head *wq_head, unsigned int mode, int nr);
219	void __wake_up_sync(struct wait_queue_head *wq_head, unsigned int mode);	219	void __wake_up_sync(struct wait_queue_head *wq_head, unsigned int mode);
		220	void __wake_up_pollfree(struct wait_queue_head *wq_head);
220		221
221	#define wake_up(x) __wake_up(x, TASK_NORMAL, 1, NULL)	222	#define wake_up(x) __wake_up(x, TASK_NORMAL, 1, NULL)
222	#define wake_up_nr(x, nr) __wake_up(x, TASK_NORMAL, nr, NULL)	223	#define wake_up_nr(x, nr) __wake_up(x, TASK_NORMAL, nr, NULL)
@@ -245,6 +246,31 @@ void __wake_up_sync(struct wait_queue_head *wq_head, unsigned int mode); · 22 unmodified lines
245	#define wake_up_interruptible_sync_poll_locked(x, m) \	246	#define wake_up_interruptible_sync_poll_locked(x, m) \
246	__wake_up_locked_sync_key((x), TASK_INTERRUPTIBLE, poll_to_key(m))	247	__wake_up_locked_sync_key((x), TASK_INTERRUPTIBLE, poll_to_key(m))
247		248
		249	/**
		250	* wake_up_pollfree - signal that a polled waitqueue is going away
		251	* @wq_head: the wait queue head
		252	*
		253	* In the very rare cases where a ->poll() implementation uses a waitqueue whose
		254	* lifetime is tied to a task rather than to the 'struct file' being polled,
		255	* this function must be called before the waitqueue is freed so that
		256	* non-blocking polls (e.g. epoll) are notified that the queue is going away.
		257	*
		258	* The caller must also RCU-delay the freeing of the wait_queue_head, e.g. via
		259	* an explicit synchronize_rcu() or call_rcu(), or via SLAB_TYPESAFE_BY_RCU.
		260	*/
		261	static inline void wake_up_pollfree(struct wait_queue_head *wq_head)
		262	{
		263	/*
		264	* For performance reasons, we don't always take the queue lock here.
		265	* Therefore, we might race with someone removing the last entry from
		266	* the queue, and proceed while they still hold the queue lock.
		267	* However, rcu_read_lock() is required to be held in such cases, so we
		268	* can safely proceed with an RCU-delayed free.
		269	*/
		270	if (waitqueue_active(wq_head))
		271	__wake_up_pollfree(wq_head);
		272	}
		273
248	#define ___wait_cond_timeout(condition) \	274	#define ___wait_cond_timeout(condition) \
249	({ \	275	({ \
250	bool __cond = (condition); \	276	bool __cond = (condition); \

include/net/bond_alb.h+1−1

@@ -126,7 +126,7 @@ struct tlb_slave_info { · 125 unmodified lines
126	struct alb_bond_info {	126	struct alb_bond_info {
127	struct tlb_client_info tx_hashtbl; / Dynamically allocated */	127	struct tlb_client_info tx_hashtbl; / Dynamically allocated */
128	u32 unbalanced_load;	128	u32 unbalanced_load;
129	int tx_rebalance_counter;	129	atomic_t tx_rebalance_counter;
130	int lp_counter;	130	int lp_counter;
131	/* -------- rlb parameters -------- */	131	/* -------- rlb parameters -------- */
132	int rlb_enabled;	132	int rlb_enabled;

include/net/busy_poll.h+13−0

@@ -132,6 +132,19 @@ static inline void sk_mark_napi_id(struct sock sk, const struct sk_buff skb) · 131 unmodified lines
132	#ifdef CONFIG_NET_RX_BUSY_POLL	132	#ifdef CONFIG_NET_RX_BUSY_POLL
133	if (unlikely(READ_ONCE(sk->sk_napi_id) != skb->napi_id))	133	if (unlikely(READ_ONCE(sk->sk_napi_id) != skb->napi_id))
134	WRITE_ONCE(sk->sk_napi_id, skb->napi_id);	134	WRITE_ONCE(sk->sk_napi_id, skb->napi_id);
		135	#endif
		136	sk_rx_queue_update(sk, skb);
		137	}
		138
		139	/* Variant of sk_mark_napi_id() for passive flow setup,
		140	* as sk->sk_napi_id and sk->sk_rx_queue_mapping content
		141	* needs to be set.
		142	*/
		143	static inline void sk_mark_napi_id_set(struct sock *sk,
		144	const struct sk_buff *skb)
		145	{
		146	#ifdef CONFIG_NET_RX_BUSY_POLL
		147	WRITE_ONCE(sk->sk_napi_id, skb->napi_id);
135	#endif	148	#endif
136	sk_rx_queue_set(sk, skb);	149	sk_rx_queue_set(sk, skb);
137	}	150	}

include/net/dst_cache.h+11−0

@@ -79,6 +79,17 @@ static inline void dst_cache_reset(struct dst_cache *dst_cache) · 78 unmodified lines
79	dst_cache->reset_ts = jiffies;	79	dst_cache->reset_ts = jiffies;
80	}	80	}
81		81
		82	/**
		83	* dst_cache_reset_now - invalidate the cache contents immediately
		84	* @dst_cache: the cache
		85	*
		86	* The caller must be sure there are no concurrent users, as this frees
		87	* all dst_cache users immediately, rather than waiting for the next
		88	* per-cpu usage like dst_cache_reset does. Most callers should use the
		89	* higher speed lazily-freed dst_cache_reset function instead.
		90	*/
		91	void dst_cache_reset_now(struct dst_cache *dst_cache);
		92
82	/**	93	/**
83	* dst_cache_init - initialize the cache, allocating the required storage	94	* dst_cache_init - initialize the cache, allocating the required storage
84	* @dst_cache: the cache	95	* @dst_cache: the cache

include/net/fib_rules.h+3−1

 	int			(*action)(struct fib_rule *,
 					  struct flowi *, int,
 					  struct fib_lookup_arg *);
-	bool			(*suppress)(struct fib_rule *,
+	bool			(*suppress)(struct fib_rule *, int,
 					    struct fib_lookup_arg *);
 	int			(*match)(struct fib_rule *,
 					 struct flowi *, int);
 			    struct fib_lookup_arg *arg));
 INDIRECT_CALLABLE_DECLARE(bool fib6_rule_suppress(struct fib_rule *rule,
+						int flags,
 						struct fib_lookup_arg *arg));
 INDIRECT_CALLABLE_DECLARE(bool fib4_rule_suppress(struct fib_rule *rule,
+						int flags,
 						struct fib_lookup_arg *arg));
 #endif

include/net/ip_fib.h+1−1

@@ -438,7 +438,7 @@ int fib_validate_source(struct sk_buff *skb, __be32 src, __be32 dst, · 437 unmodified lines
438	#ifdef CONFIG_IP_ROUTE_CLASSID	438	#ifdef CONFIG_IP_ROUTE_CLASSID
439	static inline int fib_num_tclassid_users(struct net *net)	439	static inline int fib_num_tclassid_users(struct net *net)
440	{	440	{
441	return net->ipv4.fib_num_tclassid_users;	441	return atomic_read(&net->ipv4.fib_num_tclassid_users);
442	}	442	}
443	#else	443	#else
444	static inline int fib_num_tclassid_users(struct net *net)	444	static inline int fib_num_tclassid_users(struct net *net)

include/net/netfilter/nf_conntrack.h+3−3

@@ -276,14 +276,14 @@ static inline bool nf_is_loopback_packet(const struct sk_buff *skb) · 275 unmodified lines
276	/* jiffies until ct expires, 0 if already expired */	276	/* jiffies until ct expires, 0 if already expired */
277	static inline unsigned long nf_ct_expires(const struct nf_conn *ct)	277	static inline unsigned long nf_ct_expires(const struct nf_conn *ct)
278	{	278	{
279	s32 timeout = ct->timeout - nfct_time_stamp;	279	s32 timeout = READ_ONCE(ct->timeout) - nfct_time_stamp;
280		280
281	return timeout > 0 ? timeout : 0;	281	return timeout > 0 ? timeout : 0;
282	}	282	}
283		283
284	static inline bool nf_ct_is_expired(const struct nf_conn *ct)	284	static inline bool nf_ct_is_expired(const struct nf_conn *ct)
285	{	285	{
286	return (__s32)(ct->timeout - nfct_time_stamp) <= 0;	286	return (__s32)(READ_ONCE(ct->timeout) - nfct_time_stamp) <= 0;
287	}	287	}
288		288
289	/* use after obtaining a reference count */	289	/* use after obtaining a reference count */
@@ -302,7 +302,7 @@ static inline bool nf_ct_should_gc(const struct nf_conn *ct) · 12 unmodified lines
302	static inline void nf_ct_offload_timeout(struct nf_conn *ct)	302	static inline void nf_ct_offload_timeout(struct nf_conn *ct)
303	{	303	{
304	if (nf_ct_expires(ct) < NF_CT_DAY / 2)	304	if (nf_ct_expires(ct) < NF_CT_DAY / 2)
305	ct->timeout = nfct_time_stamp + NF_CT_DAY;	305	WRITE_ONCE(ct->timeout, nfct_time_stamp + NF_CT_DAY);
306	}	306	}
307		307
308	struct kernel_param;	308	struct kernel_param;

include/net/netns/ipv4.h+1−1

@@ -65,7 +65,7 @@ struct netns_ipv4 { · 64 unmodified lines
65	bool fib_has_custom_local_routes;	65	bool fib_has_custom_local_routes;
66	bool fib_offload_disabled;	66	bool fib_offload_disabled;
67	#ifdef CONFIG_IP_ROUTE_CLASSID	67	#ifdef CONFIG_IP_ROUTE_CLASSID
68	int fib_num_tclassid_users;	68	atomic_t fib_num_tclassid_users;
69	#endif	69	#endif
70	struct hlist_head *fib_table_hash;	70	struct hlist_head *fib_table_hash;
71	struct sock *fibnl;	71	struct sock *fibnl;

include/net/sock.h+23−7

 	return -1;
 }
-static inline void sk_rx_queue_set(struct sock *sk, const struct sk_buff *skb)
+static inline void __sk_rx_queue_set(struct sock *sk,
+				     const struct sk_buff *skb,
+				     bool force_set)
 {
 #ifdef CONFIG_SOCK_RX_QUEUE_MAPPING
 	if (skb_rx_queue_recorded(skb)) {
 		u16 rx_queue = skb_get_rx_queue(skb);
-		if (unlikely(READ_ONCE(sk->sk_rx_queue_mapping) != rx_queue))
+		if (force_set ||
+		    unlikely(READ_ONCE(sk->sk_rx_queue_mapping) != rx_queue))
 			WRITE_ONCE(sk->sk_rx_queue_mapping, rx_queue);
 	}
 #endif
 }
+static inline void sk_rx_queue_set(struct sock *sk, const struct sk_buff *skb)
+{
+	__sk_rx_queue_set(sk, skb, true);
+}
+static inline void sk_rx_queue_update(struct sock *sk, const struct sk_buff *skb)
+{
+	__sk_rx_queue_set(sk, skb, false);
+}
 static inline void sk_rx_queue_clear(struct sock *sk)
 {
 #ifdef CONFIG_SOCK_RX_QUEUE_MAPPING
  * @sk: socket
  *
  * Use the per task page_frag instead of the per socket one for
- * optimization when we know that we're in the normal context and owns
+ * optimization when we know that we're in process context and own
  * everything that's associated with %current.
  *
- * gfpflags_allow_blocking() isn't enough here as direct reclaim may nest
+ * Both direct reclaim and page faults can nest inside other
- * inside other socket operations and end up recursing into sk_page_frag()
+ * socket operations and end up recursing into sk_page_frag()
- * while it's already in use.
+ * while it's already in use: explicitly avoid task page_frag
+ * usage if the caller is potentially doing any of them.
+ * This assumes that page fault handlers use the GFP_NOFS flags.
  *
  * Return: a per task page_frag if context allows that,
  * otherwise a per socket one.
  */
 static inline struct page_frag *sk_page_frag(struct sock *sk)
 {
-	if (gfpflags_normal_context(sk->sk_allocation))
+	if ((sk->sk_allocation & (__GFP_DIRECT_RECLAIM | __GFP_MEMALLOC | __GFP_FS)) ==
+	    (__GFP_DIRECT_RECLAIM | __GFP_FS))
 		return &current->task_frag;
 	return &sk->sk_frag;

include/sound/soc-acpi.h+1−1

@@ -147,7 +147,7 @@ struct snd_soc_acpi_link_adr { · 146 unmodified lines
147	*/	147	*/
148	/* Descriptor for SST ASoC machine driver */	148	/* Descriptor for SST ASoC machine driver */
149	struct snd_soc_acpi_mach {	149	struct snd_soc_acpi_mach {
150	const u8 id[ACPI_ID_LEN];	150	u8 id[ACPI_ID_LEN];
151	const struct snd_soc_acpi_codecs *comp_ids;	151	const struct snd_soc_acpi_codecs *comp_ids;
152	const u32 link_mask;	152	const u32 link_mask;
153	const struct snd_soc_acpi_link_adr *links;	153	const struct snd_soc_acpi_link_adr *links;

include/uapi/asm-generic/poll.h+1−1

@@ -29,7 +29,7 @@ · 28 unmodified lines
29	#define POLLRDHUP 0x2000	29	#define POLLRDHUP 0x2000
30	#endif	30	#endif
31		31
32	#define POLLFREE (__force __poll_t)0x4000 /* currently only for epoll */	32	#define POLLFREE (__force __poll_t)0x4000
33		33
34	#define POLL_BUSY_LOOP (__force __poll_t)0x8000	34	#define POLL_BUSY_LOOP (__force __poll_t)0x8000
35		35

include/uapi/drm/virtgpu_drm.h+7−0

@@ -196,6 +196,13 @@ struct drm_virtgpu_context_init { · 195 unmodified lines
196	__u64 ctx_set_params;	196	__u64 ctx_set_params;
197	};	197	};
198		198
		199	/*
		200	* Event code that's given when VIRTGPU_CONTEXT_PARAM_POLL_RINGS_MASK is in
		201	* effect. The event size is sizeof(drm_event), since there is no additional
		202	* payload.
		203	*/
		204	#define VIRTGPU_EVENT_FENCE_SIGNALED 0x90000000
		205
199	#define DRM_IOCTL_VIRTGPU_MAP \	206	#define DRM_IOCTL_VIRTGPU_MAP \
200	DRM_IOWR(DRM_COMMAND_BASE + DRM_VIRTGPU_MAP, struct drm_virtgpu_map)	207	DRM_IOWR(DRM_COMMAND_BASE + DRM_VIRTGPU_MAP, struct drm_virtgpu_map)
201		208

include/uapi/linux/if_ether.h+1−1

@@ -117,7 +117,7 @@ · 116 unmodified lines
117	#define ETH_P_IFE 0xED3E /* ForCES inter-FE LFB type */	117	#define ETH_P_IFE 0xED3E /* ForCES inter-FE LFB type */
118	#define ETH_P_AF_IUCV 0xFBFB /* IBM af_iucv [ NOT AN OFFICIALLY REGISTERED ID ] */	118	#define ETH_P_AF_IUCV 0xFBFB /* IBM af_iucv [ NOT AN OFFICIALLY REGISTERED ID ] */
119		119
120	#define ETH_P_802_3_MIN 0x0600 /* If the value in the ethernet type is less than this value	120	#define ETH_P_802_3_MIN 0x0600 /* If the value in the ethernet type is more than this value
121	* then the frame is Ethernet II. Else it is 802.3 */	121	* then the frame is Ethernet II. Else it is 802.3 */
122		122
123	/*	123	/*

include/uapi/linux/resource.h+10−3

 #define _STK_LIM	(8*1024*1024)
 /*
- * GPG2 wants 64kB of mlocked memory, to make sure pass phrases
+ * Limit the amount of locked memory by some sane default:
- * and other sensitive information are never written to disk.
+ * root can always increase this limit if needed.
+ *
+ * The main use-cases are (1) preventing sensitive memory
+ * from being swapped; (2) real-time operations; (3) via
+ * IOURING_REGISTER_BUFFERS.
+ *
+ * The first two don't need much. The latter will take as
+ * much as it can get. 8MB is a reasonably sane default.
  */
-#define MLOCK_LIMIT	((PAGE_SIZE > 64*1024) ? PAGE_SIZE : 64*1024)
+#define MLOCK_LIMIT	(8*1024*1024)
 /*
  * Due to binary compatibility, the actual resource numbers

kernel/bpf/btf.c+2−9

 /* BTF ID set registration API for modules */
-struct kfunc_btf_id_list {
-	struct list_head list;
-	struct mutex mutex;
-};
 #ifdef CONFIG_DEBUG_INFO_BTF_MODULES
 void register_kfunc_btf_id_set(struct kfunc_btf_id_list *l,
 {
 	struct kfunc_btf_id_set *s;
-	if (!owner)
-		return false;
 	mutex_lock(&klist->mutex);
 	list_for_each_entry(s, &klist->list, list) {
 		if (s->owner == owner && btf_id_set_contains(s->set, kfunc_id)) {
 	return false;
 }
-#endif
 #define DEFINE_KFUNC_BTF_ID_LIST(name)                                         \
 	struct kfunc_btf_id_list name = { LIST_HEAD_INIT(name.list),           \
 					  __MUTEX_INITIALIZER(name.mutex) };   \
 DEFINE_KFUNC_BTF_ID_LIST(bpf_tcp_ca_kfunc_list);
 DEFINE_KFUNC_BTF_ID_LIST(prog_test_kfunc_list);
+#endif

kernel/bpf/verifier.c+1−1

@@ -8422,7 +8422,7 @@ static void find_good_pkt_pointers(struct bpf_verifier_state *vstate, · 8421 unmodified lines
8422		8422
8423	new_range = dst_reg->off;	8423	new_range = dst_reg->off;
8424	if (range_right_open)	8424	if (range_right_open)
8425	new_range--;	8425	new_range++;
8426		8426
8427	/* Examples for register markings:	8427	/* Examples for register markings:
8428	*	8428	*

kernel/kprobes.c+3−0

@@ -2086,6 +2086,9 @@ int register_kretprobe(struct kretprobe *rp) · 2085 unmodified lines
2086	}	2086	}
2087	}	2087	}
2088		2088
		2089	if (rp->data_size > KRETPROBE_MAX_DATA_SIZE)
		2090	return -E2BIG;
		2091
2089	rp->kp.pre_handler = pre_handler_kretprobe;	2092	rp->kp.pre_handler = pre_handler_kretprobe;
2090	rp->kp.post_handler = NULL;	2093	rp->kp.post_handler = NULL;
2091		2094

kernel/sched/core.c+3−3

@@ -1918,7 +1918,7 @@ static void __init init_uclamp_rq(struct rq *rq) · 1917 unmodified lines
1918	};	1918	};
1919	}	1919	}
1920		1920
1921	rq->uclamp_flags = 0;	1921	rq->uclamp_flags = UCLAMP_FLAG_IDLE;
1922	}	1922	}
1923		1923
1924	static void __init init_uclamp(void)	1924	static void __init init_uclamp(void)
@@ -6617,11 +6617,11 @@ static int __init setup_preempt_mode(char *str) · 4692 unmodified lines
6617	int mode = sched_dynamic_mode(str);	6617	int mode = sched_dynamic_mode(str);
6618	if (mode < 0) {	6618	if (mode < 0) {
6619	pr_warn("Dynamic Preempt: unsupported mode: %s\n", str);	6619	pr_warn("Dynamic Preempt: unsupported mode: %s\n", str);
6620	return 1;	6620	return 0;
6621	}	6621	}
6622		6622
6623	sched_dynamic_update(mode);	6623	sched_dynamic_update(mode);
6624	return 0;	6624	return 1;
6625	}	6625	}
6626	__setup("preempt=", setup_preempt_mode);	6626	__setup("preempt=", setup_preempt_mode);
6627		6627

kernel/sched/cputime.c+9−3

 		.sum_exec_runtime = p->se.sum_exec_runtime,
 	};
-	task_cputime(p, &cputime.utime, &cputime.stime);
+	if (task_cputime(p, &cputime.utime, &cputime.stime))
+		cputime.sum_exec_runtime = task_sched_runtime(p);
 	cputime_adjust(&cputime, &p->prev_cputime, ut, st);
 }
 EXPORT_SYMBOL_GPL(task_cputime_adjusted);
  * add up the pending nohz execution time since the last
  * cputime snapshot.
  */
-void task_cputime(struct task_struct *t, u64 *utime, u64 *stime)
+bool task_cputime(struct task_struct *t, u64 *utime, u64 *stime)
 {
 	struct vtime *vtime = &t->vtime;
 	unsigned int seq;
 	u64 delta;
+	int ret;
 	if (!vtime_accounting_enabled()) {
 		*utime = t->utime;
 		*stime = t->stime;
-		return;
+		return false;
 	}
 	do {
+		ret = false;
 		seq = read_seqcount_begin(&vtime->seqcount);
 		*utime = t->utime;
 		if (vtime->state < VTIME_SYS)
 			continue;
+		ret = true;
 		delta = vtime_delta(vtime);
 		/*
 		else
 			*utime += vtime->utime + delta;
 	} while (read_seqcount_retry(&vtime->seqcount, seq));
+	return ret;
 }
 static int vtime_state_fetch(struct vtime *vtime, int cpu)

kernel/sched/wait.c+7−0

@@ -238,6 +238,13 @@ void __wake_up_sync(struct wait_queue_head *wq_head, unsigned int mode) · 237 unmodified lines
238	}	238	}
239	EXPORT_SYMBOL_GPL(__wake_up_sync); /* For internal use only */	239	EXPORT_SYMBOL_GPL(__wake_up_sync); /* For internal use only */
240		240
		241	void __wake_up_pollfree(struct wait_queue_head *wq_head)
		242	{
		243	__wake_up(wq_head, TASK_NORMAL, 0, poll_to_key(EPOLLHUP \| POLLFREE));
		244	/* POLLFREE must have cleared the queue. */
		245	WARN_ON_ONCE(waitqueue_active(wq_head));
		246	}
		247
241	/*	248	/*
242	* Note: we use "set_current_state()" _after_ the wait-queue add,	249	* Note: we use "set_current_state()" _after_ the wait-queue add,
243	* because we need a memory barrier there on SMP, so that any	250	* because we need a memory barrier there on SMP, so that any

kernel/softirq.c+2−1

@@ -595,7 +595,8 @@ void irq_enter_rcu(void) · 594 unmodified lines
595	{	595	{
596	__irq_enter_raw();	596	__irq_enter_raw();
597		597
598	if (is_idle_task(current) && (irq_count() == HARDIRQ_OFFSET))	598	if (tick_nohz_full_cpu(smp_processor_id()) \|\|
		599	(is_idle_task(current) && (irq_count() == HARDIRQ_OFFSET)))
599	tick_irq_enter();	600	tick_irq_enter();
600		601
601	account_hardirq_enter(current);	602	account_hardirq_enter(current);

kernel/time/tick-sched.c+7−0

@@ -1375,6 +1375,13 @@ static inline void tick_nohz_irq_enter(void) · 1374 unmodified lines
1375	now = ktime_get();	1375	now = ktime_get();
1376	if (ts->idle_active)	1376	if (ts->idle_active)
1377	tick_nohz_stop_idle(ts, now);	1377	tick_nohz_stop_idle(ts, now);
		1378	/*
		1379	* If all CPUs are idle. We may need to update a stale jiffies value.
		1380	* Note nohz_full is a special case: a timekeeper is guaranteed to stay
		1381	* alive but it might be busy looping with interrupts disabled in some
		1382	* rare case (typically stop machine). So we must make sure we have a
		1383	* last resort.
		1384	*/
1378	if (ts->tick_stopped)	1385	if (ts->tick_stopped)
1379	tick_nohz_update_jiffies(now);	1386	tick_nohz_update_jiffies(now);
1380	}	1387	}

kernel/time/timer.c+9−7

 EXPORT_SYMBOL(msleep_interruptible);
 /**
- * usleep_range - Sleep for an approximate time
+ * usleep_range_state - Sleep for an approximate time in a given state
- * @min: Minimum time in usecs to sleep
+ * @min:	Minimum time in usecs to sleep
- * @max: Maximum time in usecs to sleep
+ * @max:	Maximum time in usecs to sleep
+ * @state:	State of the current task that will be while sleeping
  *
  * In non-atomic context where the exact wakeup time is flexible, use
- * usleep_range() instead of udelay().  The sleep improves responsiveness
+ * usleep_range_state() instead of udelay().  The sleep improves responsiveness
  * by avoiding the CPU-hogging busy-wait of udelay(), and the range reduces
  * power usage by allowing hrtimers to take advantage of an already-
  * scheduled interrupt instead of scheduling a new one just for this sleep.
  */
-void __sched usleep_range(unsigned long min, unsigned long max)
+void __sched usleep_range_state(unsigned long min, unsigned long max,
+				unsigned int state)
 {
 	ktime_t exp = ktime_add_us(ktime_get(), min);
 	u64 delta = (u64)(max - min) * NSEC_PER_USEC;
 	for (;;) {
-		__set_current_state(TASK_UNINTERRUPTIBLE);
+		__set_current_state(state);
 		/* Do not return before the requested sleep time has elapsed */
 		if (!schedule_hrtimeout_range(&exp, delta, HRTIMER_MODE_ABS))
 			break;
 	}
 }
-EXPORT_SYMBOL(usleep_range);
+EXPORT_SYMBOL(usleep_range_state);

kernel/trace/ftrace.c+7−1

 {
 	struct ftrace_direct_func *direct;
 	struct ftrace_func_entry *entry;
+	struct ftrace_hash *hash;
 	int ret = -ENODEV;
 	mutex_lock(&direct_mutex);
 	if (!entry)
 		goto out_unlock;
-	if (direct_functions->count == 1)
+	hash = direct_ops.func_hash->filter_hash;
+	if (hash->count == 1)
 		unregister_ftrace_function(&direct_ops);
 	ret = ftrace_set_filter_ip(&direct_ops, ip, 1, 0);
 	err = unregister_ftrace_function(ops);
 	remove_direct_functions_hash(hash, addr);
 	mutex_unlock(&direct_mutex);
+	/* cleanup for possible another register call */
+	ops->func = NULL;
+	ops->trampoline = 0;
 	return err;
 }
 EXPORT_SYMBOL_GPL(unregister_ftrace_direct_multi);

kernel/trace/trace_events_hist.c+1−1

@@ -3757,7 +3757,7 @@ static int check_synth_field(struct synth_event *event, · 3756 unmodified lines
3757		3757
3758	if (strcmp(field->type, hist_field->type) != 0) {	3758	if (strcmp(field->type, hist_field->type) != 0) {
3759	if (field->size != hist_field->size \|\|	3759	if (field->size != hist_field->size \|\|
3760	field->is_signed != hist_field->is_signed)	3760	(!field->is_string && field->is_signed != hist_field->is_signed))
3761	return -EINVAL;	3761	return -EINVAL;
3762	}	3762	}
3763		3763

kernel/trace/trace_events_synth.c+6−5

 						  argv + consumed, &consumed,
 						  &field_version);
 			if (IS_ERR(field)) {
-				argv_free(argv);
 				ret = PTR_ERR(field);
-				goto err;
+				goto err_free_arg;
 			}
 			/*
 			if (cmd_version > 1 && n_fields_this_loop >= 1) {
 				synth_err(SYNTH_ERR_INVALID_CMD, errpos(field_str));
 				ret = -EINVAL;
-				goto err;
+				goto err_free_arg;
 			}
 			fields[n_fields++] = field;
 			if (n_fields == SYNTH_FIELDS_MAX) {
 				synth_err(SYNTH_ERR_TOO_MANY_FIELDS, 0);
 				ret = -EINVAL;
-				goto err;
+				goto err_free_arg;
 			}
 			n_fields_this_loop++;
 		}
+		argv_free(argv);
 		if (consumed < argc) {
 			synth_err(SYNTH_ERR_INVALID_CMD, 0);
 			goto err;
 		}
-		argv_free(argv);
 	}
 	if (n_fields == 0) {
 	kfree(saved_fields);
 	return ret;
+ err_free_arg:
+	argv_free(argv);
  err:
 	for (i = 0; i < n_fields; i++)
 		free_synth_field(fields[i]);

kernel/trace/tracing_map.c+3−0

 #include <linux/jhash.h>
 #include <linux/slab.h>
 #include <linux/sort.h>
+#include <linux/kmemleak.h>
 #include "tracing_map.h"
 #include "trace.h"
 	for (i = 0; i < a->n_pages; i++) {
 		if (!a->pages[i])
 			break;
+		kmemleak_free(a->pages[i]);
 		free_page((unsigned long)a->pages[i]);
 	}
 		a->pages[i] = (void *)get_zeroed_page(GFP_KERNEL);
 		if (!a->pages[i])
 			goto free;
+		kmemleak_alloc(a->pages[i], PAGE_SIZE, 1, GFP_KERNEL);
 	}
  out:
 	return a;

lib/Kconfig.debug+1−0

@@ -316,6 +316,7 @@ config DEBUG_INFO_BTF · 315 unmodified lines
316	bool "Generate BTF typeinfo"	316	bool "Generate BTF typeinfo"
317	depends on !DEBUG_INFO_SPLIT && !DEBUG_INFO_REDUCED	317	depends on !DEBUG_INFO_SPLIT && !DEBUG_INFO_REDUCED
318	depends on !GCC_PLUGIN_RANDSTRUCT \|\| COMPILE_TEST	318	depends on !GCC_PLUGIN_RANDSTRUCT \|\| COMPILE_TEST
		319	depends on BPF_SYSCALL
319	help	320	help
320	Generate deduplicated BTF type information from DWARF debug info.	321	Generate deduplicated BTF type information from DWARF debug info.
321	Turning this on expects presence of pahole tool, which will convert	322	Turning this on expects presence of pahole tool, which will convert

lib/siphash.c+6−6

 	SIPROUND; \
 	return (v0 ^ v1) ^ (v2 ^ v3);
+#ifndef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
 u64 __siphash_aligned(const void *data, size_t len, const siphash_key_t *key)
 {
 	const u8 *end = data + len - (len % sizeof(u64));
 	POSTAMBLE
 }
 EXPORT_SYMBOL(__siphash_aligned);
+#endif
-#ifndef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
 u64 __siphash_unaligned(const void *data, size_t len, const siphash_key_t *key)
 {
 	const u8 *end = data + len - (len % sizeof(u64));
 	POSTAMBLE
 }
 EXPORT_SYMBOL(__siphash_unaligned);
-#endif
 /**
  * siphash_1u64 - compute 64-bit siphash PRF value of a u64
 	HSIPROUND; \
 	return (v0 ^ v1) ^ (v2 ^ v3);
+#ifndef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
 u32 __hsiphash_aligned(const void *data, size_t len, const hsiphash_key_t *key)
 {
 	const u8 *end = data + len - (len % sizeof(u64));
 	HPOSTAMBLE
 }
 EXPORT_SYMBOL(__hsiphash_aligned);
+#endif
-#ifndef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
 u32 __hsiphash_unaligned(const void *data, size_t len,
 			 const hsiphash_key_t *key)
 {
 	HPOSTAMBLE
 }
 EXPORT_SYMBOL(__hsiphash_unaligned);
-#endif
 /**
  * hsiphash_1u32 - compute 64-bit hsiphash PRF value of a u32
 	HSIPROUND; \
 	return v1 ^ v3;
+#ifndef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
 u32 __hsiphash_aligned(const void *data, size_t len, const hsiphash_key_t *key)
 {
 	const u8 *end = data + len - (len % sizeof(u32));
 	HPOSTAMBLE
 }
 EXPORT_SYMBOL(__hsiphash_aligned);
+#endif
-#ifndef CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS
 u32 __hsiphash_unaligned(const void *data, size_t len,
 			 const hsiphash_key_t *key)
 {
 	HPOSTAMBLE
 }
 EXPORT_SYMBOL(__hsiphash_unaligned);
-#endif
 /**
  * hsiphash_1u32 - compute 32-bit hsiphash PRF value of a u32

mm/Kconfig+1−1

@@ -428,7 +428,7 @@ config THP_SWAP · 427 unmodified lines
428	# UP and nommu archs use km based percpu allocator	428	# UP and nommu archs use km based percpu allocator
429	#	429	#
430	config NEED_PER_CPU_KM	430	config NEED_PER_CPU_KM
431	depends on !SMP	431	depends on !SMP \|\| !MMU
432	bool	432	bool
433	default y	433	default y
434		434

mm/backing-dev.c+7−0

@@ -945,6 +945,13 @@ void bdi_unregister(struct backing_dev_info *bdi) · 944 unmodified lines
945	wb_shutdown(&bdi->wb);	945	wb_shutdown(&bdi->wb);
946	cgwb_bdi_unregister(bdi);	946	cgwb_bdi_unregister(bdi);
947		947
		948	/*
		949	* If this BDI's min ratio has been set, use bdi_set_min_ratio() to
		950	* update the global bdi_min_ratio.
		951	*/
		952	if (bdi->min_ratio)
		953	bdi_set_min_ratio(bdi, 0);
		954
948	if (bdi->dev) {	955	if (bdi->dev) {
949	bdi_debug_unregister(bdi);	956	bdi_debug_unregister(bdi);
950	device_unregister(bdi->dev);	957	device_unregister(bdi->dev);

mm/damon/core.c+7−13

 	for (i = 0; i < nr_ids; i++) {
 		t = damon_new_target(ids[i]);
 		if (!t) {
-			pr_err("Failed to alloc damon_target\n");
 			/* The caller should do cleanup of the ids itself */
 			damon_for_each_target_safe(t, next, ctx)
 				damon_destroy_target(t);
 		    unsigned long aggr_int, unsigned long primitive_upd_int,
 		    unsigned long min_nr_reg, unsigned long max_nr_reg)
 {
-	if (min_nr_reg < 3) {
+	if (min_nr_reg < 3)
-		pr_err("min_nr_regions (%lu) must be at least 3\n",
-				min_nr_reg);
 		return -EINVAL;
-	}
+	if (min_nr_reg > max_nr_reg)
-	if (min_nr_reg > max_nr_reg) {
-		pr_err("invalid nr_regions.  min (%lu) > max (%lu)\n",
-				min_nr_reg, max_nr_reg);
 		return -EINVAL;
-	}
 	ctx->sample_interval = sample_int;
 	ctx->aggr_interval = aggr_int;
 static void kdamond_usleep(unsigned long usecs)
 {
-	if (usecs > 100 * 1000)
+	/* See Documentation/timers/timers-howto.rst for the thresholds */
-		schedule_timeout_interruptible(usecs_to_jiffies(usecs));
+	if (usecs > 20 * USEC_PER_MSEC)
+		schedule_timeout_idle(usecs_to_jiffies(usecs));
 	else
-		usleep_range(usecs, usecs + 1);
+		usleep_idle_range(usecs, usecs + 1);
 }
 /* Returns negative error code if it's not activated but should return */
 				ctx->callback.after_sampling(ctx))
 			done = true;
-		usleep_range(ctx->sample_interval, ctx->sample_interval + 1);
+		kdamond_usleep(ctx->sample_interval);
 		if (ctx->primitive.check_accesses)
 			max_nr_accesses = ctx->primitive.check_accesses(ctx);

mm/damon/dbgfs.c+1−3

 				&wmarks.low, &parsed);
 		if (ret != 18)
 			break;
-		if (!damos_action_valid(action)) {
+		if (!damos_action_valid(action))
-			pr_err("wrong action %d\n", action);
 			goto fail;
-		}
 		pos += parsed;
 		scheme = damon_new_scheme(min_sz, max_sz, min_nr_a, max_nr_a,

mm/damon/vaddr-test.h+37−42

 				struct damon_addr_range *three_regions,
 				unsigned long *expected, int nr_expected)
 {
-	struct damon_ctx *ctx = damon_new_ctx();
 	struct damon_target *t;
 	struct damon_region *r;
 	int i;
 		r = damon_new_region(regions[i * 2], regions[i * 2 + 1]);
 		damon_add_region(r, t);
 	}
-	damon_add_target(ctx, t);
 	damon_va_apply_three_regions(t, three_regions);
 		KUNIT_EXPECT_EQ(test, r->ar.start, expected[i * 2]);
 		KUNIT_EXPECT_EQ(test, r->ar.end, expected[i * 2 + 1]);
 	}
-	damon_destroy_ctx(ctx);
 }
 /*
 			new_three_regions, expected, ARRAY_SIZE(expected));
 }
-static void damon_test_split_evenly(struct kunit *test)
+static void damon_test_split_evenly_fail(struct kunit *test,
+		unsigned long start, unsigned long end, unsigned int nr_pieces)
 {
-	struct damon_ctx *c = damon_new_ctx();
+	struct damon_target *t = damon_new_target(42);
-	struct damon_target *t;
+	struct damon_region *r = damon_new_region(start, end);
-	struct damon_region *r;
-	unsigned long i;
-	KUNIT_EXPECT_EQ(test, damon_va_evenly_split_region(NULL, NULL, 5),
-			-EINVAL);
-	t = damon_new_target(42);
-	r = damon_new_region(0, 100);
-	KUNIT_EXPECT_EQ(test, damon_va_evenly_split_region(t, r, 0), -EINVAL);
 	damon_add_region(r, t);
-	KUNIT_EXPECT_EQ(test, damon_va_evenly_split_region(t, r, 10), 0);
+	KUNIT_EXPECT_EQ(test,
-	KUNIT_EXPECT_EQ(test, damon_nr_regions(t), 10u);
+			damon_va_evenly_split_region(t, r, nr_pieces), -EINVAL);
+	KUNIT_EXPECT_EQ(test, damon_nr_regions(t), 1u);
-	i = 0;
 	damon_for_each_region(r, t) {
-		KUNIT_EXPECT_EQ(test, r->ar.start, i++ * 10);
+		KUNIT_EXPECT_EQ(test, r->ar.start, start);
-		KUNIT_EXPECT_EQ(test, r->ar.end, i * 10);
+		KUNIT_EXPECT_EQ(test, r->ar.end, end);
 	}
 	damon_free_target(t);
+}
+static void damon_test_split_evenly_succ(struct kunit *test,
+	unsigned long start, unsigned long end, unsigned int nr_pieces)
+{
+	struct damon_target *t = damon_new_target(42);
+	struct damon_region *r = damon_new_region(start, end);
+	unsigned long expected_width = (end - start) / nr_pieces;
+	unsigned long i = 0;
-	t = damon_new_target(42);
-	r = damon_new_region(5, 59);
 	damon_add_region(r, t);
-	KUNIT_EXPECT_EQ(test, damon_va_evenly_split_region(t, r, 5), 0);
+	KUNIT_EXPECT_EQ(test,
-	KUNIT_EXPECT_EQ(test, damon_nr_regions(t), 5u);
+			damon_va_evenly_split_region(t, r, nr_pieces), 0);
+	KUNIT_EXPECT_EQ(test, damon_nr_regions(t), nr_pieces);
-	i = 0;
 	damon_for_each_region(r, t) {
-		if (i == 4)
+		if (i == nr_pieces - 1)
 			break;
-		KUNIT_EXPECT_EQ(test, r->ar.start, 5 + 10 * i++);
+		KUNIT_EXPECT_EQ(test,
-		KUNIT_EXPECT_EQ(test, r->ar.end, 5 + 10 * i);
+				r->ar.start, start + i++ * expected_width);
+		KUNIT_EXPECT_EQ(test, r->ar.end, start + i * expected_width);
 	}
-	KUNIT_EXPECT_EQ(test, r->ar.start, 5 + 10 * i);
+	KUNIT_EXPECT_EQ(test, r->ar.start, start + i * expected_width);
-	KUNIT_EXPECT_EQ(test, r->ar.end, 59ul);
+	KUNIT_EXPECT_EQ(test, r->ar.end, end);
 	damon_free_target(t);
+}
-	t = damon_new_target(42);
+static void damon_test_split_evenly(struct kunit *test)
-	r = damon_new_region(5, 6);
+{
-	damon_add_region(r, t);
+	KUNIT_EXPECT_EQ(test, damon_va_evenly_split_region(NULL, NULL, 5),
-	KUNIT_EXPECT_EQ(test, damon_va_evenly_split_region(t, r, 2), -EINVAL);
+			-EINVAL);
-	KUNIT_EXPECT_EQ(test, damon_nr_regions(t), 1u);
-	damon_for_each_region(r, t) {
+	damon_test_split_evenly_fail(test, 0, 100, 0);
-		KUNIT_EXPECT_EQ(test, r->ar.start, 5ul);
+	damon_test_split_evenly_succ(test, 0, 100, 10);
-		KUNIT_EXPECT_EQ(test, r->ar.end, 6ul);
+	damon_test_split_evenly_succ(test, 5, 59, 5);
-	}
+	damon_test_split_evenly_fail(test, 5, 6, 2);
-	damon_free_target(t);
-	damon_destroy_ctx(c);
 }
 static struct kunit_case damon_test_cases[] = {

mm/damon/vaddr.c+1−1

 #include <linux/mmu_notifier.h>
 #include <linux/page_idle.h>
 #include <linux/pagewalk.h>
+#include <linux/sched/mm.h>
 #include "prmtv-common.h"
 	case DAMOS_STAT:
 		return 0;
 	default:
-		pr_warn("Wrong action %d\n", scheme->action);
 		return -EINVAL;
 	}

mm/filemap.c+0−2

 			goto skip;
 		if (!PageUptodate(page) || PageReadahead(page))
 			goto skip;
-		if (PageHWPoison(page))
-			goto skip;
 		if (!trylock_page(page))
 			goto skip;
 		if (page->mapping != mapping)

mm/hugetlb.c+1−1

@@ -2973,7 +2973,7 @@ int __alloc_bootmem_huge_page(struct hstate *h, int nid) · 2972 unmodified lines
2973	struct huge_bootmem_page m = NULL; / initialize for clang */	2973	struct huge_bootmem_page m = NULL; / initialize for clang */
2974	int nr_nodes, node;	2974	int nr_nodes, node;
2975		2975
2976	if (nid >= nr_online_nodes)	2976	if (nid != NUMA_NO_NODE && nid >= nr_online_nodes)
2977	return 0;	2977	return 0;
2978	/* do node specific alloc */	2978	/* do node specific alloc */
2979	if (nid != NUMA_NO_NODE) {	2979	if (nid != NUMA_NO_NODE) {

mm/memcontrol.c+53−53

 	rcu_read_unlock();
 }
-/*
- * mod_objcg_mlstate() may be called with irq enabled, so
- * mod_memcg_lruvec_state() should be used.
- */
-static inline void mod_objcg_mlstate(struct obj_cgroup *objcg,
-				     struct pglist_data *pgdat,
-				     enum node_stat_item idx, int nr)
-{
-	struct mem_cgroup *memcg;
-	struct lruvec *lruvec;
-	rcu_read_lock();
-	memcg = obj_cgroup_memcg(objcg);
-	lruvec = mem_cgroup_lruvec(memcg, pgdat);
-	mod_memcg_lruvec_state(lruvec, idx, nr);
-	rcu_read_unlock();
-}
 /**
  * __count_memcg_events - account VM events in a cgroup
  * @memcg: the memory cgroup
 }
 #endif
-/*
- * Most kmem_cache_alloc() calls are from user context. The irq disable/enable
- * sequence used in this case to access content from object stock is slow.
- * To optimize for user context access, there are now two object stocks for
- * task context and interrupt context access respectively.
- *
- * The task context object stock can be accessed by disabling preemption only
- * which is cheap in non-preempt kernel. The interrupt context object stock
- * can only be accessed after disabling interrupt. User context code can
- * access interrupt object stock, but not vice versa.
- */
-static inline struct obj_stock *get_obj_stock(unsigned long *pflags)
-{
-	struct memcg_stock_pcp *stock;
-	if (likely(in_task())) {
-		*pflags = 0UL;
-		preempt_disable();
-		stock = this_cpu_ptr(&memcg_stock);
-		return &stock->task_obj;
-	}
-	local_irq_save(*pflags);
-	stock = this_cpu_ptr(&memcg_stock);
-	return &stock->irq_obj;
-}
-static inline void put_obj_stock(unsigned long flags)
-{
-	if (likely(in_task()))
-		preempt_enable();
-	else
-		local_irq_restore(flags);
-}
 /**
  * consume_stock: Try to consume stocked charge on this cpu.
  * @memcg: memcg to consume from.
  */
 #define OBJCGS_CLEAR_MASK	(__GFP_DMA | __GFP_RECLAIMABLE | __GFP_ACCOUNT)
+/*
+ * Most kmem_cache_alloc() calls are from user context. The irq disable/enable
+ * sequence used in this case to access content from object stock is slow.
+ * To optimize for user context access, there are now two object stocks for
+ * task context and interrupt context access respectively.
+ *
+ * The task context object stock can be accessed by disabling preemption only
+ * which is cheap in non-preempt kernel. The interrupt context object stock
+ * can only be accessed after disabling interrupt. User context code can
+ * access interrupt object stock, but not vice versa.
+ */
+static inline struct obj_stock *get_obj_stock(unsigned long *pflags)
+{
+	struct memcg_stock_pcp *stock;
+	if (likely(in_task())) {
+		*pflags = 0UL;
+		preempt_disable();
+		stock = this_cpu_ptr(&memcg_stock);
+		return &stock->task_obj;
+	}
+	local_irq_save(*pflags);
+	stock = this_cpu_ptr(&memcg_stock);
+	return &stock->irq_obj;
+}
+static inline void put_obj_stock(unsigned long flags)
+{
+	if (likely(in_task()))
+		preempt_enable();
+	else
+		local_irq_restore(flags);
+}
+/*
+ * mod_objcg_mlstate() may be called with irq enabled, so
+ * mod_memcg_lruvec_state() should be used.
+ */
+static inline void mod_objcg_mlstate(struct obj_cgroup *objcg,
+				     struct pglist_data *pgdat,
+				     enum node_stat_item idx, int nr)
+{
+	struct mem_cgroup *memcg;
+	struct lruvec *lruvec;
+	rcu_read_lock();
+	memcg = obj_cgroup_memcg(objcg);
+	lruvec = mem_cgroup_lruvec(memcg, pgdat);
+	mod_memcg_lruvec_state(lruvec, idx, nr);
+	rcu_read_unlock();
+}
 int memcg_alloc_page_obj_cgroups(struct page *page, struct kmem_cache *s,
 				 gfp_t gfp, bool new_page)
 {

mm/memory_hotplug.c+1−0

@@ -35,6 +35,7 @@ · 34 unmodified lines
35	#include <linux/memblock.h>	35	#include <linux/memblock.h>
36	#include <linux/compaction.h>	36	#include <linux/compaction.h>
37	#include <linux/rmap.h>	37	#include <linux/rmap.h>
		38	#include <linux/module.h>
38		39
39	#include <asm/tlbflush.h>	40	#include <asm/tlbflush.h>
40		41

mm/slub.c+9−6

 	unsigned long max;
 	unsigned long count;
 	struct location *loc;
+	loff_t idx;
 };
 static struct dentry *slab_debugfs_root;
 #if defined(CONFIG_SLUB_DEBUG) && defined(CONFIG_DEBUG_FS)
 static int slab_debugfs_show(struct seq_file *seq, void *v)
 {
-	struct location *l;
-	unsigned int idx = *(unsigned int *)v;
 	struct loc_track *t = seq->private;
+	struct location *l;
+	unsigned long idx;
+	idx = (unsigned long) t->idx;
 	if (idx < t->count) {
 		l = &t->loc[idx];
 {
 	struct loc_track *t = seq->private;
-	v = ppos;
+	t->idx = ++(*ppos);
-	++*ppos;
 	if (*ppos <= t->count)
-		return v;
+		return ppos;
 	return NULL;
 }
 static void *slab_debugfs_start(struct seq_file *seq, loff_t *ppos)
 {
+	struct loc_track *t = seq->private;
+	t->idx = *ppos;
 	return ppos;
 }

mm/swap_slots.c+1−0

@@ -30,6 +30,7 @@ · 29 unmodified lines
30	#include <linux/swap_slots.h>	30	#include <linux/swap_slots.h>
31	#include <linux/cpu.h>	31	#include <linux/cpu.h>
32	#include <linux/cpumask.h>	32	#include <linux/cpumask.h>
		33	#include <linux/slab.h>
33	#include <linux/vmalloc.h>	34	#include <linux/vmalloc.h>
34	#include <linux/mutex.h>	35	#include <linux/mutex.h>
35	#include <linux/mm.h>	36	#include <linux/mm.h>

net/core/dev.c+4−1

 	if (dev->flags & IFF_UP) {
 		int cpu = smp_processor_id(); /* ok because BHs are off */
-		if (txq->xmit_lock_owner != cpu) {
+		/* Other cpus might concurrently change txq->xmit_lock_owner
+		 * to -1 or to their cpu id, but not to our id.
+		 */
+		if (READ_ONCE(txq->xmit_lock_owner) != cpu) {
 			if (dev_xmit_recursion())
 				goto recursion_alert;

net/core/devlink.c+8−8

 		return err;
 	}
-	if (info->attrs[DEVLINK_ATTR_NETNS_PID] ||
-	    info->attrs[DEVLINK_ATTR_NETNS_FD] ||
-	    info->attrs[DEVLINK_ATTR_NETNS_ID]) {
-		dest_net = devlink_netns_get(skb, info);
-		if (IS_ERR(dest_net))
-			return PTR_ERR(dest_net);
-	}
 	if (info->attrs[DEVLINK_ATTR_RELOAD_ACTION])
 		action = nla_get_u8(info->attrs[DEVLINK_ATTR_RELOAD_ACTION]);
 	else
 			return -EINVAL;
 		}
 	}
+	if (info->attrs[DEVLINK_ATTR_NETNS_PID] ||
+	    info->attrs[DEVLINK_ATTR_NETNS_FD] ||
+	    info->attrs[DEVLINK_ATTR_NETNS_ID]) {
+		dest_net = devlink_netns_get(skb, info);
+		if (IS_ERR(dest_net))
+			return PTR_ERR(dest_net);
+	}
 	err = devlink_reload(devlink, dest_net, action, limit, &actions_performed, info->extack);
 	if (dest_net)

net/core/dst_cache.c+19−0

@@ -162,3 +162,22 @@ void dst_cache_destroy(struct dst_cache *dst_cache) · 161 unmodified lines
162	free_percpu(dst_cache->cache);	162	free_percpu(dst_cache->cache);
163	}	163	}
164	EXPORT_SYMBOL_GPL(dst_cache_destroy);	164	EXPORT_SYMBOL_GPL(dst_cache_destroy);
		165
		166	void dst_cache_reset_now(struct dst_cache *dst_cache)
		167	{
		168	int i;
		169
		170	if (!dst_cache->cache)
		171	return;
		172
		173	dst_cache->reset_ts = jiffies;
		174	for_each_possible_cpu(i) {
		175	struct dst_cache_pcpu *idst = per_cpu_ptr(dst_cache->cache, i);
		176	struct dst_entry *dst = idst->dst;
		177
		178	idst->cookie = 0;
		179	idst->dst = NULL;
		180	dst_release(dst);
		181	}
		182	}
		183	EXPORT_SYMBOL_GPL(dst_cache_reset_now);

net/core/fib_rules.c+1−1

@@ -323,7 +323,7 @@ jumped: · 322 unmodified lines
323	if (!err && ops->suppress && INDIRECT_CALL_MT(ops->suppress,	323	if (!err && ops->suppress && INDIRECT_CALL_MT(ops->suppress,
324	fib6_rule_suppress,	324	fib6_rule_suppress,
325	fib4_rule_suppress,	325	fib4_rule_suppress,
326	rule, arg))	326	rule, flags, arg))
327	continue;	327	continue;
328		328
329	if (err != -EAGAIN) {	329	if (err != -EAGAIN) {

net/core/neighbour.c+1−2

 	ASSERT_RTNL();
-	n = kmalloc(sizeof(*n) + key_len, GFP_KERNEL);
+	n = kzalloc(sizeof(*n) + key_len, GFP_KERNEL);
 	if (!n)
 		goto out;
-	n->protocol = 0;
 	write_pnet(&n->net, net);
 	memcpy(n->key, pkey, key_len);
 	n->dev = dev;

net/core/skmsg.c+5−0

 void sk_psock_stop_strp(struct sock *sk, struct sk_psock *psock)
 {
+	psock_set_prog(&psock->progs.stream_parser, NULL);
 	if (!psock->saved_data_ready)
 		return;
 void sk_psock_stop_verdict(struct sock *sk, struct sk_psock *psock)
 {
+	psock_set_prog(&psock->progs.stream_verdict, NULL);
+	psock_set_prog(&psock->progs.skb_verdict, NULL);
 	if (!psock->saved_data_ready)
 		return;

net/core/sock_map.c+10−5

 		write_lock_bh(&sk->sk_callback_lock);
 		if (strp_stop)
 			sk_psock_stop_strp(sk, psock);
-		else
+		if (verdict_stop)
 			sk_psock_stop_verdict(sk, psock);
+		if (psock->psock_update_sk_prot)
+			psock->psock_update_sk_prot(sk, psock, false);
 		write_unlock_bh(&sk->sk_callback_lock);
 	}
 }
 	if (msg_parser)
 		psock_set_prog(&psock->progs.msg_parser, msg_parser);
+	if (stream_parser)
+		psock_set_prog(&psock->progs.stream_parser, stream_parser);
+	if (stream_verdict)
+		psock_set_prog(&psock->progs.stream_verdict, stream_verdict);
+	if (skb_verdict)
+		psock_set_prog(&psock->progs.skb_verdict, skb_verdict);
 	ret = sock_map_init_proto(sk, psock);
 	if (ret < 0)
 		ret = sk_psock_init_strp(sk, psock);
 		if (ret)
 			goto out_unlock_drop;
-		psock_set_prog(&psock->progs.stream_verdict, stream_verdict);
-		psock_set_prog(&psock->progs.stream_parser, stream_parser);
 		sk_psock_start_strp(sk, psock);
 	} else if (!stream_parser && stream_verdict && !psock->saved_data_ready) {
-		psock_set_prog(&psock->progs.stream_verdict, stream_verdict);
 		sk_psock_start_verdict(sk,psock);
 	} else if (!stream_verdict && skb_verdict && !psock->saved_data_ready) {
-		psock_set_prog(&psock->progs.skb_verdict, skb_verdict);
 		sk_psock_start_verdict(sk, psock);
 	}
 	write_unlock_bh(&sk->sk_callback_lock);

net/ethtool/netlink.c+2−1

@@ -40,7 +40,8 @@ int ethnl_ops_begin(struct net_device *dev) · 39 unmodified lines
40	if (dev->dev.parent)	40	if (dev->dev.parent)
41	pm_runtime_get_sync(dev->dev.parent);	41	pm_runtime_get_sync(dev->dev.parent);
42		42
43	if (!netif_device_present(dev)) {	43	if (!netif_device_present(dev) \|\|
		44	dev->reg_state == NETREG_UNREGISTERING) {
44	ret = -ENODEV;	45	ret = -ENODEV;
45	goto err;	46	goto err;
46	}	47	}

net/ipv4/fib_frontend.c+1−1

@@ -1582,7 +1582,7 @@ static int __net_init fib_net_init(struct net *net) · 1581 unmodified lines
1582	int error;	1582	int error;
1583		1583
1584	#ifdef CONFIG_IP_ROUTE_CLASSID	1584	#ifdef CONFIG_IP_ROUTE_CLASSID
1585	net->ipv4.fib_num_tclassid_users = 0;	1585	atomic_set(&net->ipv4.fib_num_tclassid_users, 0);
1586	#endif	1586	#endif
1587	error = ip_fib_net_init(net);	1587	error = ip_fib_net_init(net);
1588	if (error < 0)	1588	if (error < 0)

net/ipv4/fib_rules.c+3−2

 }
 INDIRECT_CALLABLE_SCOPE bool fib4_rule_suppress(struct fib_rule *rule,
+						int flags,
 						struct fib_lookup_arg *arg)
 {
 	struct fib_result *result = (struct fib_result *) arg->result;
 	if (tb[FRA_FLOW]) {
 		rule4->tclassid = nla_get_u32(tb[FRA_FLOW]);
 		if (rule4->tclassid)
-			net->ipv4.fib_num_tclassid_users++;
+			atomic_inc(&net->ipv4.fib_num_tclassid_users);
 	}
 #endif
 #ifdef CONFIG_IP_ROUTE_CLASSID
 	if (((struct fib4_rule *)rule)->tclassid)
-		net->ipv4.fib_num_tclassid_users--;
+		atomic_dec(&net->ipv4.fib_num_tclassid_users);
 #endif
 	net->ipv4.fib_has_custom_rules = true;

net/ipv4/fib_semantics.c+2−2

@@ -220,7 +220,7 @@ void fib_nh_release(struct net net, struct fib_nh fib_nh) · 219 unmodified lines
220	{	220	{
221	#ifdef CONFIG_IP_ROUTE_CLASSID	221	#ifdef CONFIG_IP_ROUTE_CLASSID
222	if (fib_nh->nh_tclassid)	222	if (fib_nh->nh_tclassid)
223	net->ipv4.fib_num_tclassid_users--;	223	atomic_dec(&net->ipv4.fib_num_tclassid_users);
224	#endif	224	#endif
225	fib_nh_common_release(&fib_nh->nh_common);	225	fib_nh_common_release(&fib_nh->nh_common);
226	}	226	}
@@ -632,7 +632,7 @@ int fib_nh_init(struct net net, struct fib_nh nh, · 405 unmodified lines
632	#ifdef CONFIG_IP_ROUTE_CLASSID	632	#ifdef CONFIG_IP_ROUTE_CLASSID
633	nh->nh_tclassid = cfg->fc_flow;	633	nh->nh_tclassid = cfg->fc_flow;
634	if (nh->nh_tclassid)	634	if (nh->nh_tclassid)
635	net->ipv4.fib_num_tclassid_users++;	635	atomic_inc(&net->ipv4.fib_num_tclassid_users);
636	#endif	636	#endif
637	#ifdef CONFIG_IP_ROUTE_MULTIPATH	637	#ifdef CONFIG_IP_ROUTE_MULTIPATH
638	nh->fib_nh_weight = nh_weight;	638	nh->fib_nh_weight = nh_weight;

net/ipv4/inet_connection_sock.c+1−1

@@ -721,7 +721,7 @@ static struct request_sock inet_reqsk_clone(struct request_sock req, · 720 unmodified lines
721		721
722	sk_node_init(&nreq_sk->sk_node);	722	sk_node_init(&nreq_sk->sk_node);
723	nreq_sk->sk_tx_queue_mapping = req_sk->sk_tx_queue_mapping;	723	nreq_sk->sk_tx_queue_mapping = req_sk->sk_tx_queue_mapping;
724	#ifdef CONFIG_XPS	724	#ifdef CONFIG_SOCK_RX_QUEUE_MAPPING
725	nreq_sk->sk_rx_queue_mapping = req_sk->sk_rx_queue_mapping;	725	nreq_sk->sk_rx_queue_mapping = req_sk->sk_rx_queue_mapping;
726	#endif	726	#endif
727	nreq_sk->sk_incoming_cpu = req_sk->sk_incoming_cpu;	727	nreq_sk->sk_incoming_cpu = req_sk->sk_incoming_cpu;

net/ipv4/tcp_minisocks.c+2−2

@@ -829,8 +829,8 @@ int tcp_child_process(struct sock parent, struct sock child, · 828 unmodified lines
829	int ret = 0;	829	int ret = 0;
830	int state = child->sk_state;	830	int state = child->sk_state;
831		831
832	/* record NAPI ID of child */	832	/* record sk_napi_id and sk_rx_queue_mapping of child. */
833	sk_mark_napi_id(child, skb);	833	sk_mark_napi_id_set(child, skb);
834		834
835	tcp_segs_in(tcp_sk(child), skb);	835	tcp_segs_in(tcp_sk(child), skb);
836	if (!sock_owned_by_user(child)) {	836	if (!sock_owned_by_user(child)) {

net/ipv4/udp.c+1−1

@@ -916,7 +916,7 @@ static int udp_send_skb(struct sk_buff skb, struct flowi4 fl4, · 915 unmodified lines
916	kfree_skb(skb);	916	kfree_skb(skb);
917	return -EINVAL;	917	return -EINVAL;
918	}	918	}
919	if (skb->len > cork->gso_size * UDP_MAX_SEGMENTS) {	919	if (datalen > cork->gso_size * UDP_MAX_SEGMENTS) {
920	kfree_skb(skb);	920	kfree_skb(skb);
921	return -EINVAL;	921	return -EINVAL;
922	}	922	}

net/ipv6/fib6_rules.c+2−2

 }
 INDIRECT_CALLABLE_SCOPE bool fib6_rule_suppress(struct fib_rule *rule,
+						int flags,
 						struct fib_lookup_arg *arg)
 {
 	struct fib6_result *res = arg->result;
 	return false;
 suppress_route:
-	if (!(arg->flags & FIB_LOOKUP_NOREF))
+	ip6_rt_put_flags(rt, flags);
-		ip6_rt_put(rt);
 	return true;
 }

net/ipv6/ip6_offload.c+3−3

@@ -248,9 +248,9 @@ INDIRECT_CALLABLE_SCOPE struct sk_buff ipv6_gro_receive(struct list_head head, · 247 unmodified lines
248	* memcmp() alone below is sufficient, right?	248	* memcmp() alone below is sufficient, right?
249	*/	249	*/
250	if ((first_word & htonl(0xF00FFFFF)) \|\|	250	if ((first_word & htonl(0xF00FFFFF)) \|\|
251	!ipv6_addr_equal(&iph->saddr, &iph2->saddr) \|\|	251	!ipv6_addr_equal(&iph->saddr, &iph2->saddr) \|\|
252	!ipv6_addr_equal(&iph->daddr, &iph2->daddr) \|\|	252	!ipv6_addr_equal(&iph->daddr, &iph2->daddr) \|\|
253	(u16 )&iph->nexthdr != (u16 )&iph2->nexthdr) {	253	(u16 )&iph->nexthdr != (u16 )&iph2->nexthdr) {
254	not_same_flow:	254	not_same_flow:
255	NAPI_GRO_CB(p)->same_flow = 0;	255	NAPI_GRO_CB(p)->same_flow = 0;
256	continue;	256	continue;

net/ipv6/seg6_iptunnel.c+8−0

@@ -161,6 +161,14 @@ int seg6_do_srh_encap(struct sk_buff skb, struct ipv6_sr_hdr osrh, int proto) · 160 unmodified lines
161	hdr->hop_limit = ip6_dst_hoplimit(skb_dst(skb));	161	hdr->hop_limit = ip6_dst_hoplimit(skb_dst(skb));
162		162
163	memset(IP6CB(skb), 0, sizeof(*IP6CB(skb)));	163	memset(IP6CB(skb), 0, sizeof(*IP6CB(skb)));
		164
		165	/* the control block has been erased, so we have to set the
		166	* iif once again.
		167	* We read the receiving interface index directly from the
		168	* skb->skb_iif as it is done in the IPv4 receiving path (i.e.:
		169	* ip_rcv_core(...)).
		170	*/
		171	IP6CB(skb)->iif = skb->skb_iif;
164	}	172	}
165		173
166	hdr->nexthdr = NEXTHDR_ROUTING;	174	hdr->nexthdr = NEXTHDR_ROUTING;

net/mctp/route.c+5−4

 }
 static int mctp_route_remove(struct mctp_dev *mdev, mctp_eid_t daddr_start,
-			     unsigned int daddr_extent)
+			     unsigned int daddr_extent, unsigned char type)
 {
 	struct net *net = dev_net(mdev->dev);
 	struct mctp_route *rt, *tmp;
 	list_for_each_entry_safe(rt, tmp, &net->mctp.routes, list) {
 		if (rt->dev == mdev &&
-		    rt->min == daddr_start && rt->max == daddr_end) {
+		    rt->min == daddr_start && rt->max == daddr_end &&
+		    rt->type == type) {
 			list_del_rcu(&rt->list);
 			/* TODO: immediate RTM_DELROUTE */
 			mctp_route_release(rt);
 int mctp_route_remove_local(struct mctp_dev *mdev, mctp_eid_t addr)
 {
-	return mctp_route_remove(mdev, addr, 0);
+	return mctp_route_remove(mdev, addr, 0, RTN_LOCAL);
 }
 /* removes all entries for a given device */
 	if (rtm->rtm_type != RTN_UNICAST)
 		return -EINVAL;
-	rc = mctp_route_remove(mdev, daddr_start, rtm->rtm_dst_len);
+	rc = mctp_route_remove(mdev, daddr_start, rtm->rtm_dst_len, RTN_UNICAST);
 	return rc;
 }

net/mctp/test/utils.c+1−1

@@ -12,7 +12,7 @@ · 11 unmodified lines
12	static netdev_tx_t mctp_test_dev_tx(struct sk_buff *skb,	12	static netdev_tx_t mctp_test_dev_tx(struct sk_buff *skb,
13	struct net_device *ndev)	13	struct net_device *ndev)
14	{	14	{
15	kfree(skb);	15	kfree_skb(skb);
16	return NETDEV_TX_OK;	16	return NETDEV_TX_OK;
17	}	17	}
18		18

net/mpls/af_mpls.c+62−35

 		goto err;
 	/* Find the output device */
-	out_dev = rcu_dereference(nh->nh_dev);
+	out_dev = nh->nh_dev;
 	if (!mpls_output_possible(out_dev))
 		goto tx_err;
 	    (dev->addr_len != nh->nh_via_alen))
 		goto errout;
-	RCU_INIT_POINTER(nh->nh_dev, dev);
+	nh->nh_dev = dev;
 	if (!(dev->flags & IFF_UP)) {
 		nh->nh_flags |= RTNH_F_DEAD;
 	kfree(mdev);
 }
-static void mpls_ifdown(struct net_device *dev, int event)
+static int mpls_ifdown(struct net_device *dev, int event)
 {
 	struct mpls_route __rcu **platform_label;
 	struct net *net = dev_net(dev);
-	u8 alive, deleted;
 	unsigned index;
 	platform_label = rtnl_dereference(net->mpls.platform_label);
 	for (index = 0; index < net->mpls.platform_labels; index++) {
 		struct mpls_route *rt = rtnl_dereference(platform_label[index]);
+		bool nh_del = false;
+		u8 alive = 0;
 		if (!rt)
 			continue;
-		alive = 0;
+		if (event == NETDEV_UNREGISTER) {
-		deleted = 0;
+			u8 deleted = 0;
+			for_nexthops(rt) {
+				if (!nh->nh_dev || nh->nh_dev == dev)
+					deleted++;
+				if (nh->nh_dev == dev)
+					nh_del = true;
+			} endfor_nexthops(rt);
+			/* if there are no more nexthops, delete the route */
+			if (deleted == rt->rt_nhn) {
+				mpls_route_update(net, index, NULL, NULL);
+				continue;
+			}
+			if (nh_del) {
+				size_t size = sizeof(*rt) + rt->rt_nhn *
+					rt->rt_nh_size;
+				struct mpls_route *orig = rt;
+				rt = kmalloc(size, GFP_KERNEL);
+				if (!rt)
+					return -ENOMEM;
+				memcpy(rt, orig, size);
+			}
+		}
 		change_nexthops(rt) {
 			unsigned int nh_flags = nh->nh_flags;
-			if (rtnl_dereference(nh->nh_dev) != dev)
+			if (nh->nh_dev != dev)
 				goto next;
 			switch (event) {
 				break;
 			}
 			if (event == NETDEV_UNREGISTER)
-				RCU_INIT_POINTER(nh->nh_dev, NULL);
+				nh->nh_dev = NULL;
 			if (nh->nh_flags != nh_flags)
 				WRITE_ONCE(nh->nh_flags, nh_flags);
 next:
 			if (!(nh_flags & (RTNH_F_DEAD | RTNH_F_LINKDOWN)))
 				alive++;
-			if (!rtnl_dereference(nh->nh_dev))
-				deleted++;
 		} endfor_nexthops(rt);
 		WRITE_ONCE(rt->rt_nhn_alive, alive);
-		/* if there are no more nexthops, delete the route */
+		if (nh_del)
-		if (event == NETDEV_UNREGISTER && deleted == rt->rt_nhn)
+			mpls_route_update(net, index, rt, NULL);
-			mpls_route_update(net, index, NULL, NULL);
 	}
+	return 0;
 }
 static void mpls_ifup(struct net_device *dev, unsigned int flags)
 		alive = 0;
 		change_nexthops(rt) {
 			unsigned int nh_flags = nh->nh_flags;
-			struct net_device *nh_dev =
-				rtnl_dereference(nh->nh_dev);
 			if (!(nh_flags & flags)) {
 				alive++;
 				continue;
 			}
-			if (nh_dev != dev)
+			if (nh->nh_dev != dev)
 				continue;
 			alive++;
 			nh_flags &= ~flags;
 		return NOTIFY_OK;
 	switch (event) {
+		int err;
 	case NETDEV_DOWN:
-		mpls_ifdown(dev, event);
+		err = mpls_ifdown(dev, event);
+		if (err)
+			return notifier_from_errno(err);
 		break;
 	case NETDEV_UP:
 		flags = dev_get_flags(dev);
 		break;
 	case NETDEV_CHANGE:
 		flags = dev_get_flags(dev);
-		if (flags & (IFF_RUNNING | IFF_LOWER_UP))
+		if (flags & (IFF_RUNNING | IFF_LOWER_UP)) {
 			mpls_ifup(dev, RTNH_F_DEAD | RTNH_F_LINKDOWN);
-		else
+		} else {
-			mpls_ifdown(dev, event);
+			err = mpls_ifdown(dev, event);
+			if (err)
+				return notifier_from_errno(err);
+		}
 		break;
 	case NETDEV_UNREGISTER:
-		mpls_ifdown(dev, event);
+		err = mpls_ifdown(dev, event);
+		if (err)
+			return notifier_from_errno(err);
 		mdev = mpls_dev_get(dev);
 		if (mdev) {
 			mpls_dev_sysctl_unregister(dev, mdev);
 	case NETDEV_CHANGENAME:
 		mdev = mpls_dev_get(dev);
 		if (mdev) {
-			int err;
 			mpls_dev_sysctl_unregister(dev, mdev);
 			err = mpls_dev_sysctl_register(dev, mdev);
 			if (err)
 		    nla_put_via(skb, nh->nh_via_table, mpls_nh_via(rt, nh),
 				nh->nh_via_alen))
 			goto nla_put_failure;
-		dev = rtnl_dereference(nh->nh_dev);
+		dev = nh->nh_dev;
 		if (dev && nla_put_u32(skb, RTA_OIF, dev->ifindex))
 			goto nla_put_failure;
 		if (nh->nh_flags & RTNH_F_LINKDOWN)
 			goto nla_put_failure;
 		for_nexthops(rt) {
-			dev = rtnl_dereference(nh->nh_dev);
+			dev = nh->nh_dev;
 			if (!dev)
 				continue;
 static bool mpls_rt_uses_dev(struct mpls_route *rt,
 			     const struct net_device *dev)
 {
-	struct net_device *nh_dev;
 	if (rt->rt_nhn == 1) {
 		struct mpls_nh *nh = rt->rt_nh;
-		nh_dev = rtnl_dereference(nh->nh_dev);
+		if (nh->nh_dev == dev)
-		if (dev == nh_dev)
 			return true;
 	} else {
 		for_nexthops(rt) {
-			nh_dev = rtnl_dereference(nh->nh_dev);
+			if (nh->nh_dev == dev)
-			if (nh_dev == dev)
 				return true;
 		} endfor_nexthops(rt);
 	}
 		size_t nhsize = 0;
 		for_nexthops(rt) {
-			if (!rtnl_dereference(nh->nh_dev))
+			if (!nh->nh_dev)
 				continue;
 			nhsize += nla_total_size(sizeof(struct rtnexthop));
 			/* RTA_VIA */
 	    nla_put_via(skb, nh->nh_via_table, mpls_nh_via(rt, nh),
 			nh->nh_via_alen))
 		goto nla_put_failure;
-	dev = rtnl_dereference(nh->nh_dev);
+	dev = nh->nh_dev;
 	if (dev && nla_put_u32(skb, RTA_OIF, dev->ifindex))
 		goto nla_put_failure;
 		rt0 = mpls_rt_alloc(1, lo->addr_len, 0);
 		if (IS_ERR(rt0))
 			goto nort0;
-		RCU_INIT_POINTER(rt0->rt_nh->nh_dev, lo);
+		rt0->rt_nh->nh_dev = lo;
 		rt0->rt_protocol = RTPROT_KERNEL;
 		rt0->rt_payload_type = MPT_IPV4;
 		rt0->rt_ttl_propagate = MPLS_TTL_PROP_DEFAULT;
 		rt2 = mpls_rt_alloc(1, lo->addr_len, 0);
 		if (IS_ERR(rt2))
 			goto nort2;
-		RCU_INIT_POINTER(rt2->rt_nh->nh_dev, lo);
+		rt2->rt_nh->nh_dev = lo;
 		rt2->rt_protocol = RTPROT_KERNEL;
 		rt2->rt_payload_type = MPT_IPV6;
 		rt2->rt_ttl_propagate = MPLS_TTL_PROP_DEFAULT;

net/mpls/internal.h+1−1

@@ -87,7 +87,7 @@ enum mpls_payload_type { · 86 unmodified lines
87	};	87	};
88		88
89	struct mpls_nh { /* next hop label forwarding entry */	89	struct mpls_nh { /* next hop label forwarding entry */
90	struct net_device __rcu *nh_dev;	90	struct net_device *nh_dev;
91		91
92	/* nh_flags is accessed under RCU in the packet path; it is	92	/* nh_flags is accessed under RCU in the packet path; it is
93	* modified handling netdev events with rtnl lock held	93	* modified handling netdev events with rtnl lock held

net/netfilter/nf_conntrack_core.c+3−3

@@ -684,7 +684,7 @@ bool nf_ct_delete(struct nf_conn *ct, u32 portid, int report) · 683 unmodified lines
684		684
685	tstamp = nf_conn_tstamp_find(ct);	685	tstamp = nf_conn_tstamp_find(ct);
686	if (tstamp) {	686	if (tstamp) {
687	s32 timeout = ct->timeout - nfct_time_stamp;	687	s32 timeout = READ_ONCE(ct->timeout) - nfct_time_stamp;
688		688
689	tstamp->stop = ktime_get_real_ns();	689	tstamp->stop = ktime_get_real_ns();
690	if (timeout < 0)	690	if (timeout < 0)
@@ -1036,7 +1036,7 @@ static int nf_ct_resolve_clash_harder(struct sk_buff *skb, u32 repl_idx) · 345 unmodified lines
1036	}	1036	}
1037		1037
1038	/* We want the clashing entry to go away real soon: 1 second timeout. */	1038	/* We want the clashing entry to go away real soon: 1 second timeout. */
1039	loser_ct->timeout = nfct_time_stamp + HZ;	1039	WRITE_ONCE(loser_ct->timeout, nfct_time_stamp + HZ);
1040		1040
1041	/* IPS_NAT_CLASH removes the entry automatically on the first	1041	/* IPS_NAT_CLASH removes the entry automatically on the first
1042	* reply. Also prevents UDP tracker from moving the entry to	1042	* reply. Also prevents UDP tracker from moving the entry to
@@ -1560,7 +1560,7 @@ __nf_conntrack_alloc(struct net *net, · 517 unmodified lines
1560	/* save hash for reusing when confirming */	1560	/* save hash for reusing when confirming */
1561	(unsigned long )(&ct->tuplehash[IP_CT_DIR_REPLY].hnnode.pprev) = hash;	1561	(unsigned long )(&ct->tuplehash[IP_CT_DIR_REPLY].hnnode.pprev) = hash;
1562	ct->status = 0;	1562	ct->status = 0;
1563	ct->timeout = 0;	1563	WRITE_ONCE(ct->timeout, 0);
1564	write_pnet(&ct->ct_net, net);	1564	write_pnet(&ct->ct_net, net);
1565	memset(&ct->__nfct_init_offset, 0,	1565	memset(&ct->__nfct_init_offset, 0,
1566	offsetof(struct nf_conn, proto) -	1566	offsetof(struct nf_conn, proto) -

net/netfilter/nf_conntrack_netlink.c+1−1

@@ -1998,7 +1998,7 @@ static int ctnetlink_change_timeout(struct nf_conn *ct, · 1997 unmodified lines
1998		1998
1999	if (timeout > INT_MAX)	1999	if (timeout > INT_MAX)
2000	timeout = INT_MAX;	2000	timeout = INT_MAX;
2001	ct->timeout = nfct_time_stamp + (u32)timeout;	2001	WRITE_ONCE(ct->timeout, nfct_time_stamp + (u32)timeout);
2002		2002
2003	if (test_bit(IPS_DYING_BIT, &ct->status))	2003	if (test_bit(IPS_DYING_BIT, &ct->status))
2004	return -ETIME;	2004	return -ETIME;

net/netfilter/nf_flow_table_core.c+2−2

@@ -201,8 +201,8 @@ static void flow_offload_fixup_ct_timeout(struct nf_conn *ct) · 200 unmodified lines
201	if (timeout < 0)	201	if (timeout < 0)
202	timeout = 0;	202	timeout = 0;
203		203
204	if (nf_flow_timeout_delta(ct->timeout) > (__s32)timeout)	204	if (nf_flow_timeout_delta(READ_ONCE(ct->timeout)) > (__s32)timeout)
205	ct->timeout = nfct_time_stamp + timeout;	205	WRITE_ONCE(ct->timeout, nfct_time_stamp + timeout);
206	}	206	}
207		207
208	static void flow_offload_fixup_ct_state(struct nf_conn *ct)	208	static void flow_offload_fixup_ct_state(struct nf_conn *ct)

net/netfilter/nfnetlink_queue.c+1−1

@@ -387,7 +387,7 @@ nfqnl_build_packet_message(struct net net, struct nfqnl_instance queue, · 386 unmodified lines
387	struct net_device *indev;	387	struct net_device *indev;
388	struct net_device *outdev;	388	struct net_device *outdev;
389	struct nf_conn *ct = NULL;	389	struct nf_conn *ct = NULL;
390	enum ip_conntrack_info ctinfo;	390	enum ip_conntrack_info ctinfo = 0;
391	struct nfnl_ct_hook *nfnl_ct;	391	struct nfnl_ct_hook *nfnl_ct;
392	bool csum_verify;	392	bool csum_verify;
393	char *secdata = NULL;	393	char *secdata = NULL;

net/netfilter/nft_exthdr.c+7−4

 	tcph = nft_tcp_header_pointer(pkt, sizeof(buff), buff, &tcphdr_len);
 	if (!tcph)
-		return;
+		goto err;
 	opt = (u8 *)tcph;
 	for (i = sizeof(*tcph); i < tcphdr_len - 1; i += optl) {
 			continue;
 		if (i + optl > tcphdr_len || priv->len + priv->offset > optl)
-			return;
+			goto err;
 		if (skb_ensure_writable(pkt->skb,
 					nft_thoff(pkt) + i + priv->len))
-			return;
+			goto err;
 		tcph = nft_tcp_header_pointer(pkt, sizeof(buff), buff,
 					      &tcphdr_len);
 		if (!tcph)
-			return;
+			goto err;
 		offset = i + priv->offset;
 		return;
 	}
+	return;
+err:
+	regs->verdict.code = NFT_BREAK;
 }
 static void nft_exthdr_sctp_eval(const struct nft_expr *expr,

net/netfilter/nft_set_pipapo_avx2.c+1−1

@@ -886,7 +886,7 @@ static int nft_pipapo_avx2_lookup_8b_6(unsigned long map, unsigned long fill, · 885 unmodified lines
886	NFT_PIPAPO_AVX2_BUCKET_LOAD8(4, lt, 4, pkt[4], bsize);	886	NFT_PIPAPO_AVX2_BUCKET_LOAD8(4, lt, 4, pkt[4], bsize);
887		887
888	NFT_PIPAPO_AVX2_AND(5, 0, 1);	888	NFT_PIPAPO_AVX2_AND(5, 0, 1);
889	NFT_PIPAPO_AVX2_BUCKET_LOAD8(6, lt, 6, pkt[5], bsize);	889	NFT_PIPAPO_AVX2_BUCKET_LOAD8(6, lt, 5, pkt[5], bsize);
890	NFT_PIPAPO_AVX2_AND(7, 2, 3);	890	NFT_PIPAPO_AVX2_AND(7, 2, 3);
891		891
892	/* Stall */	892	/* Stall */

net/netlink/af_netlink.c+5−0

 	if (msg->msg_flags & MSG_OOB)
 		return -EOPNOTSUPP;
+	if (len == 0) {
+		pr_warn_once("Zero length message leads to an empty skb\n");
+		return -ENODATA;
+	}
 	err = scm_send(sock, msg, &scm, true);
 	if (err < 0)
 		return err;

net/nfc/netlink.c+8−4

 {
 	struct class_dev_iter *iter = (struct class_dev_iter *) cb->args[0];
-	nfc_device_iter_exit(iter);
+	if (iter) {
-	kfree(iter);
+		nfc_device_iter_exit(iter);
+		kfree(iter);
+	}
 	return 0;
 }
 {
 	struct class_dev_iter *iter = (struct class_dev_iter *) cb->args[0];
-	nfc_device_iter_exit(iter);
+	if (iter) {
-	kfree(iter);
+		nfc_device_iter_exit(iter);
+		kfree(iter);
+	}
 	return 0;
 }

net/rds/tcp.c+1−1

@@ -500,7 +500,7 @@ void rds_tcp_tune(struct socket *sock) · 499 unmodified lines
500	sk->sk_userlocks \|= SOCK_SNDBUF_LOCK;	500	sk->sk_userlocks \|= SOCK_SNDBUF_LOCK;
501	}	501	}
502	if (rtn->rcvbuf_size > 0) {	502	if (rtn->rcvbuf_size > 0) {
503	sk->sk_sndbuf = rtn->rcvbuf_size;	503	sk->sk_rcvbuf = rtn->rcvbuf_size;
504	sk->sk_userlocks \|= SOCK_RCVBUF_LOCK;	504	sk->sk_userlocks \|= SOCK_RCVBUF_LOCK;
505	}	505	}
506	release_sock(sk);	506	release_sock(sk);

net/rxrpc/conn_client.c+9−5

 	return bundle;
 }
+static void rxrpc_free_bundle(struct rxrpc_bundle *bundle)
+{
+	rxrpc_put_peer(bundle->params.peer);
+	kfree(bundle);
+}
 void rxrpc_put_bundle(struct rxrpc_bundle *bundle)
 {
 	unsigned int d = bundle->debug_id;
 	unsigned int u = atomic_dec_return(&bundle->usage);
 	_debug("PUT B=%x %u", d, u);
-	if (u == 0) {
+	if (u == 0)
-		rxrpc_put_peer(bundle->params.peer);
+		rxrpc_free_bundle(bundle);
-		kfree(bundle);
-	}
 }
 /*
 	return candidate;
 found_bundle_free:
-	kfree(candidate);
+	rxrpc_free_bundle(candidate);
 found_bundle:
 	rxrpc_get_bundle(bundle);
 	spin_unlock(&local->client_bundles_lock);

net/rxrpc/peer_object.c+9−5

 	return peer;
 }
+static void rxrpc_free_peer(struct rxrpc_peer *peer)
+{
+	rxrpc_put_local(peer->local);
+	kfree_rcu(peer, rcu);
+}
 /*
  * Set up a new incoming peer.  There shouldn't be any other matching peers
  * since we've already done a search in the list from the non-reentrant context
 		spin_unlock_bh(&rxnet->peer_hash_lock);
 		if (peer)
-			kfree(candidate);
+			rxrpc_free_peer(candidate);
 		else
 			peer = candidate;
 	}
 	list_del_init(&peer->keepalive_link);
 	spin_unlock_bh(&rxnet->peer_hash_lock);
-	rxrpc_put_local(peer->local);
+	rxrpc_free_peer(peer);
-	kfree_rcu(peer, rcu);
 }
 /*
 	if (n == 0) {
 		hash_del_rcu(&peer->hash_link);
 		list_del_init(&peer->keepalive_link);
-		rxrpc_put_local(peer->local);
+		rxrpc_free_peer(peer);
-		kfree_rcu(peer, rcu);
 	}
 }

net/sched/sch_fq_pie.c+1−0

@@ -531,6 +531,7 @@ static void fq_pie_destroy(struct Qdisc *sch) · 530 unmodified lines
531	struct fq_pie_sched_data *q = qdisc_priv(sch);	531	struct fq_pie_sched_data *q = qdisc_priv(sch);
532		532
533	tcf_block_put(q->block);	533	tcf_block_put(q->block);
		534	q->p_params.tupdate = 0;
534	del_timer_sync(&q->adapt_timer);	535	del_timer_sync(&q->adapt_timer);
535	kvfree(q->flows);	536	kvfree(q->flows);
536	}	537	}

net/smc/smc_close.c+6−2

 	int old_state;
 	long timeout;
 	int rc = 0;
+	int rc1 = 0;
 	timeout = current->flags & PF_EXITING ?
 		  0 : sock_flag(sk, SOCK_LINGER) ?
 			/* actively shutdown clcsock before peer close it,
 			 * prevent peer from entering TIME_WAIT state.
 			 */
-			if (smc->clcsock && smc->clcsock->sk)
+			if (smc->clcsock && smc->clcsock->sk) {
-				rc = kernel_sock_shutdown(smc->clcsock, SHUT_RDWR);
+				rc1 = kernel_sock_shutdown(smc->clcsock,
+							   SHUT_RDWR);
+				rc = rc ? rc : rc1;
+			}
 		} else {
 			/* peer event has changed the state */
 			goto again;

net/smc/smc_core.c+3−4

 void smc_lgr_cleanup_early(struct smc_connection *conn)
 {
 	struct smc_link_group *lgr = conn->lgr;
-	struct list_head *lgr_list;
 	spinlock_t *lgr_lock;
 	if (!lgr)
 		return;
 	smc_conn_free(conn);
-	lgr_list = smc_lgr_list_head(lgr, &lgr_lock);
+	smc_lgr_list_head(lgr, &lgr_lock);
 	spin_lock_bh(lgr_lock);
 	/* do not use this link group for new connections */
-	if (!list_empty(lgr_list))
+	if (!list_empty(&lgr->list))
-		list_del_init(lgr_list);
+		list_del_init(&lgr->list);
 	spin_unlock_bh(lgr_lock);
 	__smc_lgr_terminate(lgr, true);
 }

net/tls/tls_sw.c+2−2

@@ -521,7 +521,7 @@ static int tls_do_encryption(struct sock *sk, · 520 unmodified lines
521	memcpy(&rec->iv_data[iv_offset], tls_ctx->tx.iv,	521	memcpy(&rec->iv_data[iv_offset], tls_ctx->tx.iv,
522	prot->iv_size + prot->salt_size);	522	prot->iv_size + prot->salt_size);
523		523
524	xor_iv_with_seq(prot, rec->iv_data, tls_ctx->tx.rec_seq);	524	xor_iv_with_seq(prot, rec->iv_data + iv_offset, tls_ctx->tx.rec_seq);
525		525
526	sge->offset += prot->prepend_size;	526	sge->offset += prot->prepend_size;
527	sge->length -= prot->prepend_size;	527	sge->length -= prot->prepend_size;
@@ -1499,7 +1499,7 @@ static int decrypt_internal(struct sock sk, struct sk_buff skb, · 971 unmodified lines
1499	else	1499	else
1500	memcpy(iv + iv_offset, tls_ctx->rx.iv, prot->salt_size);	1500	memcpy(iv + iv_offset, tls_ctx->rx.iv, prot->salt_size);
1501		1501
1502	xor_iv_with_seq(prot, iv, tls_ctx->rx.rec_seq);	1502	xor_iv_with_seq(prot, iv + iv_offset, tls_ctx->rx.rec_seq);
1503		1503
1504	/* Prepare AAD */	1504	/* Prepare AAD */
1505	tls_make_aad(aad, rxm->full_len - prot->overhead_size +	1505	tls_make_aad(aad, rxm->full_len - prot->overhead_size +

samples/ftrace/Makefile+1−0

@@ -4,6 +4,7 @@ obj-$(CONFIG_SAMPLE_FTRACE_DIRECT) += ftrace-direct.o · 3 unmodified lines
4	obj-$(CONFIG_SAMPLE_FTRACE_DIRECT) += ftrace-direct-too.o	4	obj-$(CONFIG_SAMPLE_FTRACE_DIRECT) += ftrace-direct-too.o
5	obj-$(CONFIG_SAMPLE_FTRACE_DIRECT) += ftrace-direct-modify.o	5	obj-$(CONFIG_SAMPLE_FTRACE_DIRECT) += ftrace-direct-modify.o
6	obj-$(CONFIG_SAMPLE_FTRACE_DIRECT_MULTI) += ftrace-direct-multi.o	6	obj-$(CONFIG_SAMPLE_FTRACE_DIRECT_MULTI) += ftrace-direct-multi.o
		7	obj-$(CONFIG_SAMPLE_FTRACE_DIRECT_MULTI) += ftrace-direct-multi-modify.o
7		8
8	CFLAGS_sample-trace-array.o := -I$(src)	9	CFLAGS_sample-trace-array.o := -I$(src)
9	obj-$(CONFIG_SAMPLE_TRACE_ARRAY) += sample-trace-array.o	10	obj-$(CONFIG_SAMPLE_TRACE_ARRAY) += sample-trace-array.o

samples/ftrace/ftrace-direct-multi-modify.c+152−0

@@ -0,0 +1,152 @@
	1	// SPDX-License-Identifier: GPL-2.0-only
	2	#include <linux/module.h>
	3	#include <linux/kthread.h>
	4	#include <linux/ftrace.h>
	5	#include <asm/asm-offsets.h>
	6
	7	void my_direct_func1(unsigned long ip)
	8	{
	9	trace_printk("my direct func1 ip %lx\n", ip);
	10	}
	11
	12	void my_direct_func2(unsigned long ip)
	13	{
	14	trace_printk("my direct func2 ip %lx\n", ip);
	15	}
	16
	17	extern void my_tramp1(void *);
	18	extern void my_tramp2(void *);
	19
	20	#ifdef CONFIG_X86_64
	21
	22	asm (
	23	" .pushsection .text, \"ax\", @progbits\n"
	24	" .type my_tramp1, @function\n"
	25	" .globl my_tramp1\n"
	26	" my_tramp1:"
	27	" pushq %rbp\n"
	28	" movq %rsp, %rbp\n"
	29	" pushq %rdi\n"
	30	" movq 8(%rbp), %rdi\n"
	31	" call my_direct_func1\n"
	32	" popq %rdi\n"
	33	" leave\n"
	34	" ret\n"
	35	" .size my_tramp1, .-my_tramp1\n"
	36	" .type my_tramp2, @function\n"
	37	"\n"
	38	" .globl my_tramp2\n"
	39	" my_tramp2:"
	40	" pushq %rbp\n"
	41	" movq %rsp, %rbp\n"
	42	" pushq %rdi\n"
	43	" movq 8(%rbp), %rdi\n"
	44	" call my_direct_func2\n"
	45	" popq %rdi\n"
	46	" leave\n"
	47	" ret\n"
	48	" .size my_tramp2, .-my_tramp2\n"
	49	" .popsection\n"
	50	);
	51
	52	#endif /* CONFIG_X86_64 */
	53
	54	#ifdef CONFIG_S390
	55
	56	asm (
	57	" .pushsection .text, \"ax\", @progbits\n"
	58	" .type my_tramp1, @function\n"
	59	" .globl my_tramp1\n"
	60	" my_tramp1:"
	61	" lgr %r1,%r15\n"
	62	" stmg %r0,%r5,"__stringify(__SF_GPRS)"(%r15)\n"
	63	" stg %r14,"__stringify(__SF_GPRS+8*8)"(%r15)\n"
	64	" aghi %r15,"__stringify(-STACK_FRAME_OVERHEAD)"\n"
	65	" stg %r1,"__stringify(__SF_BACKCHAIN)"(%r15)\n"
	66	" lgr %r2,%r0\n"
	67	" brasl %r14,my_direct_func1\n"
	68	" aghi %r15,"__stringify(STACK_FRAME_OVERHEAD)"\n"
	69	" lmg %r0,%r5,"__stringify(__SF_GPRS)"(%r15)\n"
	70	" lg %r14,"__stringify(__SF_GPRS+8*8)"(%r15)\n"
	71	" lgr %r1,%r0\n"
	72	" br %r1\n"
	73	" .size my_tramp1, .-my_tramp1\n"
	74	"\n"
	75	" .type my_tramp2, @function\n"
	76	" .globl my_tramp2\n"
	77	" my_tramp2:"
	78	" lgr %r1,%r15\n"
	79	" stmg %r0,%r5,"__stringify(__SF_GPRS)"(%r15)\n"
	80	" stg %r14,"__stringify(__SF_GPRS+8*8)"(%r15)\n"
	81	" aghi %r15,"__stringify(-STACK_FRAME_OVERHEAD)"\n"
	82	" stg %r1,"__stringify(__SF_BACKCHAIN)"(%r15)\n"
	83	" lgr %r2,%r0\n"
	84	" brasl %r14,my_direct_func2\n"
	85	" aghi %r15,"__stringify(STACK_FRAME_OVERHEAD)"\n"
	86	" lmg %r0,%r5,"__stringify(__SF_GPRS)"(%r15)\n"
	87	" lg %r14,"__stringify(__SF_GPRS+8*8)"(%r15)\n"
	88	" lgr %r1,%r0\n"
	89	" br %r1\n"
	90	" .size my_tramp2, .-my_tramp2\n"
	91	" .popsection\n"
	92	);
	93
	94	#endif /* CONFIG_S390 */
	95
	96	static unsigned long my_tramp = (unsigned long)my_tramp1;
	97	static unsigned long tramps[2] = {
	98	(unsigned long)my_tramp1,
	99	(unsigned long)my_tramp2,
	100	};
	101
	102	static struct ftrace_ops direct;
	103
	104	static int simple_thread(void *arg)
	105	{
	106	static int t;
	107	int ret = 0;
	108
	109	while (!kthread_should_stop()) {
	110	set_current_state(TASK_INTERRUPTIBLE);
	111	schedule_timeout(2 * HZ);
	112
	113	if (ret)
	114	continue;
	115	t ^= 1;
	116	ret = modify_ftrace_direct_multi(&direct, tramps[t]);
	117	if (!ret)
	118	my_tramp = tramps[t];
	119	WARN_ON_ONCE(ret);
	120	}
	121
	122	return 0;
	123	}
	124
	125	static struct task_struct *simple_tsk;
	126
	127	static int __init ftrace_direct_multi_init(void)
	128	{
	129	int ret;
	130
	131	ftrace_set_filter_ip(&direct, (unsigned long) wake_up_process, 0, 0);
	132	ftrace_set_filter_ip(&direct, (unsigned long) schedule, 0, 0);
	133
	134	ret = register_ftrace_direct_multi(&direct, my_tramp);
	135
	136	if (!ret)
	137	simple_tsk = kthread_run(simple_thread, NULL, "event-sample-fn");
	138	return ret;
	139	}
	140
	141	static void __exit ftrace_direct_multi_exit(void)
	142	{
	143	kthread_stop(simple_tsk);
	144	unregister_ftrace_direct_multi(&direct, my_tramp);
	145	}
	146
	147	module_init(ftrace_direct_multi_init);
	148	module_exit(ftrace_direct_multi_exit);
	149
	150	MODULE_AUTHOR("Jiri Olsa");
	151	MODULE_DESCRIPTION("Example use case of using modify_ftrace_direct_multi()");
	152	MODULE_LICENSE("GPL");

sound/core/control_compat.c+3−0

 				  struct snd_ctl_elem_value *data,
 				  int type, int count)
 {
+	struct snd_ctl_elem_value32 __user *data32 = userdata;
 	int i, size;
 	if (type == SNDRV_CTL_ELEM_TYPE_BOOLEAN ||
 		if (copy_to_user(valuep, data->value.bytes.data, size))
 			return -EFAULT;
 	}
+	if (copy_to_user(&data32->id, &data->id, sizeof(data32->id)))
+		return -EFAULT;
 	return 0;
 }

sound/core/oss/pcm_oss.c+25−12

@@ -147,7 +147,7 @@ snd_pcm_hw_param_value_min(const struct snd_pcm_hw_params *params, · 146 unmodified lines
147	*	147	*
148	* Return the maximum value for field PAR.	148	* Return the maximum value for field PAR.
149	*/	149	*/
150	static unsigned int	150	static int
151	snd_pcm_hw_param_value_max(const struct snd_pcm_hw_params *params,	151	snd_pcm_hw_param_value_max(const struct snd_pcm_hw_params *params,
152	snd_pcm_hw_param_t var, int *dir)	152	snd_pcm_hw_param_t var, int *dir)
153	{	153	{
@@ -682,18 +682,24 @@ static int snd_pcm_oss_period_size(struct snd_pcm_substream *substream, · 528 unmodified lines
682	struct snd_pcm_hw_params *oss_params,	682	struct snd_pcm_hw_params *oss_params,
683	struct snd_pcm_hw_params *slave_params)	683	struct snd_pcm_hw_params *slave_params)
684	{	684	{
685	size_t s;	685	ssize_t s;
686	size_t oss_buffer_size, oss_period_size, oss_periods;	686	ssize_t oss_buffer_size;
687	size_t min_period_size, max_period_size;	687	ssize_t oss_period_size, oss_periods;
		688	ssize_t min_period_size, max_period_size;
688	struct snd_pcm_runtime *runtime = substream->runtime;	689	struct snd_pcm_runtime *runtime = substream->runtime;
689	size_t oss_frame_size;	690	size_t oss_frame_size;
690		691
691	oss_frame_size = snd_pcm_format_physical_width(params_format(oss_params)) *	692	oss_frame_size = snd_pcm_format_physical_width(params_format(oss_params)) *
692	params_channels(oss_params) / 8;	693	params_channels(oss_params) / 8;
693		694
		695	oss_buffer_size = snd_pcm_hw_param_value_max(slave_params,
		696	SNDRV_PCM_HW_PARAM_BUFFER_SIZE,
		697	NULL);
		698	if (oss_buffer_size <= 0)
		699	return -EINVAL;
694	oss_buffer_size = snd_pcm_plug_client_size(substream,	700	oss_buffer_size = snd_pcm_plug_client_size(substream,
695	snd_pcm_hw_param_value_max(slave_params, SNDRV_PCM_HW_PARAM_BUFFER_SIZE, NULL)) * oss_frame_size;	701	oss_buffer_size * oss_frame_size);
696	if (!oss_buffer_size)	702	if (oss_buffer_size <= 0)
697	return -EINVAL;	703	return -EINVAL;
698	oss_buffer_size = rounddown_pow_of_two(oss_buffer_size);	704	oss_buffer_size = rounddown_pow_of_two(oss_buffer_size);
699	if (atomic_read(&substream->mmap_count)) {	705	if (atomic_read(&substream->mmap_count)) {
@@ -730,7 +736,7 @@ static int snd_pcm_oss_period_size(struct snd_pcm_substream *substream, · 30 unmodified lines
730		736
731	min_period_size = snd_pcm_plug_client_size(substream,	737	min_period_size = snd_pcm_plug_client_size(substream,
732	snd_pcm_hw_param_value_min(slave_params, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, NULL));	738	snd_pcm_hw_param_value_min(slave_params, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, NULL));
733	if (min_period_size) {	739	if (min_period_size > 0) {
734	min_period_size *= oss_frame_size;	740	min_period_size *= oss_frame_size;
735	min_period_size = roundup_pow_of_two(min_period_size);	741	min_period_size = roundup_pow_of_two(min_period_size);
736	if (oss_period_size < min_period_size)	742	if (oss_period_size < min_period_size)
@@ -739,7 +745,7 @@ static int snd_pcm_oss_period_size(struct snd_pcm_substream *substream, · 2 unmodified lines
739		745
740	max_period_size = snd_pcm_plug_client_size(substream,	746	max_period_size = snd_pcm_plug_client_size(substream,
741	snd_pcm_hw_param_value_max(slave_params, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, NULL));	747	snd_pcm_hw_param_value_max(slave_params, SNDRV_PCM_HW_PARAM_PERIOD_SIZE, NULL));
742	if (max_period_size) {	748	if (max_period_size > 0) {
743	max_period_size *= oss_frame_size;	749	max_period_size *= oss_frame_size;
744	max_period_size = rounddown_pow_of_two(max_period_size);	750	max_period_size = rounddown_pow_of_two(max_period_size);
745	if (oss_period_size > max_period_size)	751	if (oss_period_size > max_period_size)
@@ -752,7 +758,7 @@ static int snd_pcm_oss_period_size(struct snd_pcm_substream *substream, · 6 unmodified lines
752	oss_periods = substream->oss.setup.periods;	758	oss_periods = substream->oss.setup.periods;
753		759
754	s = snd_pcm_hw_param_value_max(slave_params, SNDRV_PCM_HW_PARAM_PERIODS, NULL);	760	s = snd_pcm_hw_param_value_max(slave_params, SNDRV_PCM_HW_PARAM_PERIODS, NULL);
755	if (runtime->oss.maxfrags && s > runtime->oss.maxfrags)	761	if (s > 0 && runtime->oss.maxfrags && s > runtime->oss.maxfrags)
756	s = runtime->oss.maxfrags;	762	s = runtime->oss.maxfrags;
757	if (oss_periods > s)	763	if (oss_periods > s)
758	oss_periods = s;	764	oss_periods = s;
@@ -878,8 +884,15 @@ static int snd_pcm_oss_change_params_locked(struct snd_pcm_substream *substream) · 119 unmodified lines
878	err = -EINVAL;	884	err = -EINVAL;
879	goto failure;	885	goto failure;
880	}	886	}
881	choose_rate(substream, sparams, runtime->oss.rate);	887
882	snd_pcm_hw_param_near(substream, sparams, SNDRV_PCM_HW_PARAM_CHANNELS, runtime->oss.channels, NULL);	888	err = choose_rate(substream, sparams, runtime->oss.rate);
		889	if (err < 0)
		890	goto failure;
		891	err = snd_pcm_hw_param_near(substream, sparams,
		892	SNDRV_PCM_HW_PARAM_CHANNELS,
		893	runtime->oss.channels, NULL);
		894	if (err < 0)
		895	goto failure;
883		896
884	format = snd_pcm_oss_format_from(runtime->oss.format);	897	format = snd_pcm_oss_format_from(runtime->oss.format);
885		898
@@ -1956,7 +1969,7 @@ static int snd_pcm_oss_set_fragment1(struct snd_pcm_substream *substream, unsign · 1070 unmodified lines
1956	if (runtime->oss.subdivision \|\| runtime->oss.fragshift)	1969	if (runtime->oss.subdivision \|\| runtime->oss.fragshift)
1957	return -EINVAL;	1970	return -EINVAL;
1958	fragshift = val & 0xffff;	1971	fragshift = val & 0xffff;
1959	if (fragshift >= 31)	1972	if (fragshift >= 25) /* should be large enough */
1960	return -EINVAL;	1973	return -EINVAL;
1961	runtime->oss.fragshift = fragshift;	1974	runtime->oss.fragshift = fragshift;
1962	runtime->oss.maxfrags = (val >> 16) & 0xffff;	1975	runtime->oss.maxfrags = (val >> 16) & 0xffff;

sound/hda/intel-dsp-config.c+10−0

 		.flags = FLAG_SOF | FLAG_SOF_ONLY_IF_DMIC_OR_SOUNDWIRE,
 		.device = 0x02c8,
 	},
+	{
+		.flags = FLAG_SOF,
+		.device = 0x02c8,
+		.codec_hid = "ESSX8336",
+	},
 /* Cometlake-H */
 	{
 		.flags = FLAG_SOF,
 		.flags = FLAG_SOF | FLAG_SOF_ONLY_IF_DMIC_OR_SOUNDWIRE,
 		.device = 0x06c8,
 	},
+		{
+		.flags = FLAG_SOF,
+		.device = 0x06c8,
+		.codec_hid = "ESSX8336",
+	},
 #endif
 /* Icelake */

sound/pci/hda/hda_intel.c+11−1

 					((pci)->device == 0x0c0c) || \
 					((pci)->device == 0x0d0c) || \
 					((pci)->device == 0x160c) || \
-					((pci)->device == 0x490d))
+					((pci)->device == 0x490d) || \
+					((pci)->device == 0x4f90) || \
+					((pci)->device == 0x4f91) || \
+					((pci)->device == 0x4f92))
 #define IS_BXT(pci) ((pci)->vendor == 0x8086 && (pci)->device == 0x5a98)
 	/* DG1 */
 	{ PCI_DEVICE(0x8086, 0x490d),
 	  .driver_data = AZX_DRIVER_SKL | AZX_DCAPS_INTEL_SKYLAKE},
+	/* DG2 */
+	{ PCI_DEVICE(0x8086, 0x4f90),
+	  .driver_data = AZX_DRIVER_SKL | AZX_DCAPS_INTEL_SKYLAKE},
+	{ PCI_DEVICE(0x8086, 0x4f91),
+	  .driver_data = AZX_DRIVER_SKL | AZX_DCAPS_INTEL_SKYLAKE},
+	{ PCI_DEVICE(0x8086, 0x4f92),
+	  .driver_data = AZX_DRIVER_SKL | AZX_DCAPS_INTEL_SKYLAKE},
 	/* Alderlake-S */
 	{ PCI_DEVICE(0x8086, 0x7ad0),
 	  .driver_data = AZX_DRIVER_SKL | AZX_DCAPS_INTEL_SKYLAKE},

sound/pci/hda/hda_local.h+9−0

@@ -438,6 +438,15 @@ int snd_hda_codec_set_pin_target(struct hda_codec *codec, hda_nid_t nid, · 437 unmodified lines
438	#define for_each_hda_codec_node(nid, codec) \	438	#define for_each_hda_codec_node(nid, codec) \
439	for ((nid) = (codec)->core.start_nid; (nid) < (codec)->core.end_nid; (nid)++)	439	for ((nid) = (codec)->core.start_nid; (nid) < (codec)->core.end_nid; (nid)++)
440		440
		441	/* Set the codec power_state flag to indicate to allow unsol event handling;
		442	* see hda_codec_unsol_event() in hda_bind.c. Calling this might confuse the
		443	* state tracking, so use with care.
		444	*/
		445	static inline void snd_hda_codec_allow_unsol_events(struct hda_codec *codec)
		446	{
		447	codec->core.dev.power.power_state = PMSG_ON;
		448	}
		449
441	/*	450	/*
442	* get widget capabilities	451	* get widget capabilities
443	*/	452	*/

sound/pci/hda/patch_cs8409.c+5−0

 	if (cs42l42->full_scale_vol)
 		cs8409_i2c_write(cs42l42, 0x2001, 0x01);
+	/* we have to explicitly allow unsol event handling even during the
+	 * resume phase so that the jack event is processed properly
+	 */
+	snd_hda_codec_allow_unsol_events(cs42l42->codec);
 	cs42l42_enable_jack_detect(cs42l42);
 }

sound/pci/hda/patch_hdmi.c+2−1

 HDA_CODEC_ENTRY(0x80862812, "Tigerlake HDMI",	patch_i915_tgl_hdmi),
 HDA_CODEC_ENTRY(0x80862814, "DG1 HDMI",	patch_i915_tgl_hdmi),
 HDA_CODEC_ENTRY(0x80862815, "Alderlake HDMI",	patch_i915_tgl_hdmi),
-HDA_CODEC_ENTRY(0x8086281c, "Alderlake-P HDMI", patch_i915_tgl_hdmi),
 HDA_CODEC_ENTRY(0x80862816, "Rocketlake HDMI",	patch_i915_tgl_hdmi),
+HDA_CODEC_ENTRY(0x80862819, "DG2 HDMI",	patch_i915_tgl_hdmi),
 HDA_CODEC_ENTRY(0x8086281a, "Jasperlake HDMI",	patch_i915_icl_hdmi),
 HDA_CODEC_ENTRY(0x8086281b, "Elkhartlake HDMI",	patch_i915_icl_hdmi),
+HDA_CODEC_ENTRY(0x8086281c, "Alderlake-P HDMI", patch_i915_tgl_hdmi),
 HDA_CODEC_ENTRY(0x80862880, "CedarTrail HDMI",	patch_generic_hdmi),
 HDA_CODEC_ENTRY(0x80862882, "Valleyview2 HDMI",	patch_i915_byt_hdmi),
 HDA_CODEC_ENTRY(0x80862883, "Braswell HDMI",	patch_i915_byt_hdmi),

sound/pci/hda/patch_realtek.c+62−18

 /* for alc285_fixup_ideapad_s740_coef() */
 #include "ideapad_s740_helper.c"
-static void alc256_fixup_tongfang_reset_persistent_settings(struct hda_codec *codec,
+static const struct coef_fw alc256_fixup_set_coef_defaults_coefs[] = {
-							    const struct hda_fixup *fix,
+	WRITE_COEF(0x10, 0x0020), WRITE_COEF(0x24, 0x0000),
-							    int action)
+	WRITE_COEF(0x26, 0x0000), WRITE_COEF(0x29, 0x3000),
+	WRITE_COEF(0x37, 0xfe05), WRITE_COEF(0x45, 0x5089),
+	{}
+};
+static void alc256_fixup_set_coef_defaults(struct hda_codec *codec,
+					   const struct hda_fixup *fix,
+					   int action)
 {
 	/*
-	* A certain other OS sets these coeffs to different values. On at least one TongFang
+	 * A certain other OS sets these coeffs to different values. On at least
-	* barebone these settings might survive even a cold reboot. So to restore a clean slate the
+	 * one TongFang barebone these settings might survive even a cold
-	* values are explicitly reset to default here. Without this, the external microphone is
+	 * reboot. So to restore a clean slate the values are explicitly reset
-	* always in a plugged-in state, while the internal microphone is always in an unplugged
+	 * to default here. Without this, the external microphone is always in a
-	* state, breaking the ability to use the internal microphone.
+	 * plugged-in state, while the internal microphone is always in an
-	*/
+	 * unplugged state, breaking the ability to use the internal microphone.
-	alc_write_coef_idx(codec, 0x24, 0x0000);
+	 */
-	alc_write_coef_idx(codec, 0x26, 0x0000);
+	alc_process_coef_fw(codec, alc256_fixup_set_coef_defaults_coefs);
-	alc_write_coef_idx(codec, 0x29, 0x3000);
-	alc_write_coef_idx(codec, 0x37, 0xfe05);
-	alc_write_coef_idx(codec, 0x45, 0x5089);
 }
 static const struct coef_fw alc233_fixup_no_audio_jack_coefs[] = {
 	ALC287_FIXUP_LEGION_15IMHG05_AUTOMUTE,
 	ALC287_FIXUP_YOGA7_14ITL_SPEAKERS,
 	ALC287_FIXUP_13S_GEN2_SPEAKERS,
-	ALC256_FIXUP_TONGFANG_RESET_PERSISTENT_SETTINGS,
+	ALC256_FIXUP_SET_COEF_DEFAULTS,
 	ALC256_FIXUP_SYSTEM76_MIC_NO_PRESENCE,
 	ALC233_FIXUP_NO_AUDIO_JACK,
 };
 		.chained = true,
 		.chain_id = ALC269_FIXUP_HEADSET_MODE,
 	},
-	[ALC256_FIXUP_TONGFANG_RESET_PERSISTENT_SETTINGS] = {
+	[ALC256_FIXUP_SET_COEF_DEFAULTS] = {
 		.type = HDA_FIXUP_FUNC,
-		.v.func = alc256_fixup_tongfang_reset_persistent_settings,
+		.v.func = alc256_fixup_set_coef_defaults,
 	},
 	[ALC245_FIXUP_HP_GPIO_LED] = {
 		.type = HDA_FIXUP_FUNC,
 	SND_PCI_QUIRK(0x1b7d, 0xa831, "Ordissimo EVE2 ", ALC269VB_FIXUP_ORDISSIMO_EVE2), /* Also known as Malata PC-B1303 */
 	SND_PCI_QUIRK(0x1c06, 0x2013, "Lemote A1802", ALC269_FIXUP_LEMOTE_A1802),
 	SND_PCI_QUIRK(0x1c06, 0x2015, "Lemote A190X", ALC269_FIXUP_LEMOTE_A190X),
-	SND_PCI_QUIRK(0x1d05, 0x1132, "TongFang PHxTxX1", ALC256_FIXUP_TONGFANG_RESET_PERSISTENT_SETTINGS),
+	SND_PCI_QUIRK(0x1d05, 0x1132, "TongFang PHxTxX1", ALC256_FIXUP_SET_COEF_DEFAULTS),
 	SND_PCI_QUIRK(0x1d72, 0x1602, "RedmiBook", ALC255_FIXUP_XIAOMI_HEADSET_MIC),
 	SND_PCI_QUIRK(0x1d72, 0x1701, "XiaomiNotebook Pro", ALC298_FIXUP_DELL1_MIC_NO_PRESENCE),
 	SND_PCI_QUIRK(0x1d72, 0x1901, "RedmiBook 14", ALC256_FIXUP_ASUS_HEADSET_MIC),
 	}
 }
+static void alc897_hp_automute_hook(struct hda_codec *codec,
+					 struct hda_jack_callback *jack)
+{
+	struct alc_spec *spec = codec->spec;
+	int vref;
+	snd_hda_gen_hp_automute(codec, jack);
+	vref = spec->gen.hp_jack_present ? (PIN_HP | AC_PINCTL_VREF_100) : PIN_HP;
+	snd_hda_codec_write(codec, 0x1b, 0, AC_VERB_SET_PIN_WIDGET_CONTROL,
+			    vref);
+}
+static void alc897_fixup_lenovo_headset_mic(struct hda_codec *codec,
+				     const struct hda_fixup *fix, int action)
+{
+	struct alc_spec *spec = codec->spec;
+	if (action == HDA_FIXUP_ACT_PRE_PROBE) {
+		spec->gen.hp_automute_hook = alc897_hp_automute_hook;
+	}
+}
 static const struct coef_fw alc668_coefs[] = {
 	WRITE_COEF(0x01, 0xbebe), WRITE_COEF(0x02, 0xaaaa), WRITE_COEF(0x03,    0x0),
 	WRITE_COEF(0x04, 0x0180), WRITE_COEF(0x06,    0x0), WRITE_COEF(0x07, 0x0f80),
 	ALC668_FIXUP_ASUS_NO_HEADSET_MIC,
 	ALC668_FIXUP_HEADSET_MIC,
 	ALC668_FIXUP_MIC_DET_COEF,
+	ALC897_FIXUP_LENOVO_HEADSET_MIC,
+	ALC897_FIXUP_HEADSET_MIC_PIN,
 };
 static const struct hda_fixup alc662_fixups[] = {
 			{}
 		},
 	},
+	[ALC897_FIXUP_LENOVO_HEADSET_MIC] = {
+		.type = HDA_FIXUP_FUNC,
+		.v.func = alc897_fixup_lenovo_headset_mic,
+	},
+	[ALC897_FIXUP_HEADSET_MIC_PIN] = {
+		.type = HDA_FIXUP_PINS,
+		.v.pins = (const struct hda_pintbl[]) {
+			{ 0x1a, 0x03a11050 },
+			{ }
+		},
+		.chained = true,
+		.chain_id = ALC897_FIXUP_LENOVO_HEADSET_MIC
+	},
 };
 static const struct snd_pci_quirk alc662_fixup_tbl[] = {
 	SND_PCI_QUIRK(0x144d, 0xc051, "Samsung R720", ALC662_FIXUP_IDEAPAD),
 	SND_PCI_QUIRK(0x14cd, 0x5003, "USI", ALC662_FIXUP_USI_HEADSET_MODE),
 	SND_PCI_QUIRK(0x17aa, 0x1036, "Lenovo P520", ALC662_FIXUP_LENOVO_MULTI_CODECS),
+	SND_PCI_QUIRK(0x17aa, 0x32ca, "Lenovo ThinkCentre M80", ALC897_FIXUP_HEADSET_MIC_PIN),
+	SND_PCI_QUIRK(0x17aa, 0x32cb, "Lenovo ThinkCentre M70", ALC897_FIXUP_HEADSET_MIC_PIN),
+	SND_PCI_QUIRK(0x17aa, 0x32cf, "Lenovo ThinkCentre M950", ALC897_FIXUP_HEADSET_MIC_PIN),
+	SND_PCI_QUIRK(0x17aa, 0x32f7, "Lenovo ThinkCentre M90", ALC897_FIXUP_HEADSET_MIC_PIN),
 	SND_PCI_QUIRK(0x17aa, 0x38af, "Lenovo Ideapad Y550P", ALC662_FIXUP_IDEAPAD),
 	SND_PCI_QUIRK(0x17aa, 0x3a0d, "Lenovo Ideapad Y550", ALC662_FIXUP_IDEAPAD),
 	SND_PCI_QUIRK(0x1849, 0x5892, "ASRock B150M", ALC892_FIXUP_ASROCK_MOBO),

sound/soc/amd/yc/pci-acp6x.c+2−1

 {
 	struct acp6x_dev_data *adata;
 	struct platform_device_info pdevinfo[ACP6x_DEVS];
-	int ret, index;
+	int index = 0;
 	int val = 0x00;
 	u32 addr;
 	unsigned int irqflags;
+	int ret;
 	irqflags = IRQF_SHARED;
 	/* Yellow Carp device check */

sound/soc/codecs/cs35l41-spi.c+3−29

@@ -42,34 +42,6 @@ static const struct spi_device_id cs35l41_id_spi[] = { · 41 unmodified lines
42		42
43	MODULE_DEVICE_TABLE(spi, cs35l41_id_spi);	43	MODULE_DEVICE_TABLE(spi, cs35l41_id_spi);
44		44
45	static void cs35l41_spi_otp_setup(struct cs35l41_private *cs35l41,
46	bool is_pre_setup, unsigned int *freq)
47	{
48	struct spi_device *spi;
49	u32 orig_spi_freq;
50
51	spi = to_spi_device(cs35l41->dev);
52
53	if (!spi) {
54	dev_err(cs35l41->dev, "%s: No SPI device\n", __func__);
55	return;
56	}
57
58	if (is_pre_setup) {
59	orig_spi_freq = spi->max_speed_hz;
60	if (orig_spi_freq > CS35L41_SPI_MAX_FREQ_OTP) {
61	spi->max_speed_hz = CS35L41_SPI_MAX_FREQ_OTP;
62	spi_setup(spi);
63	}
64	*freq = orig_spi_freq;
65	} else {
66	if (spi->max_speed_hz != *freq) {
67	spi->max_speed_hz = *freq;
68	spi_setup(spi);
69	}
70	}
71	}
72
73	static int cs35l41_spi_probe(struct spi_device *spi)	45	static int cs35l41_spi_probe(struct spi_device *spi)
74	{	46	{
75	const struct regmap_config *regmap_config = &cs35l41_regmap_spi;	47	const struct regmap_config *regmap_config = &cs35l41_regmap_spi;
@@ -81,6 +53,9 @@ static int cs35l41_spi_probe(struct spi_device *spi) · 5 unmodified lines
81	if (!cs35l41)	53	if (!cs35l41)
82	return -ENOMEM;	54	return -ENOMEM;
83		55
		56	spi->max_speed_hz = CS35L41_SPI_MAX_FREQ;
		57	spi_setup(spi);
		58
84	spi_set_drvdata(spi, cs35l41);	59	spi_set_drvdata(spi, cs35l41);
85	cs35l41->regmap = devm_regmap_init_spi(spi, regmap_config);	60	cs35l41->regmap = devm_regmap_init_spi(spi, regmap_config);
86	if (IS_ERR(cs35l41->regmap)) {	61	if (IS_ERR(cs35l41->regmap)) {
@@ -91,7 +66,6 @@ static int cs35l41_spi_probe(struct spi_device *spi) · 4 unmodified lines
91		66
92	cs35l41->dev = &spi->dev;	67	cs35l41->dev = &spi->dev;
93	cs35l41->irq = spi->irq;	68	cs35l41->irq = spi->irq;
94	cs35l41->otp_setup = cs35l41_spi_otp_setup;
95		69
96	return cs35l41_probe(cs35l41, pdata);	70	return cs35l41_probe(cs35l41, pdata);
97	}	71	}

sound/soc/codecs/cs35l41.c+0−7

 	const struct cs35l41_otp_packed_element_t *otp_map;
 	struct cs35l41_private *cs35l41 = data;
 	int bit_offset, word_offset, ret, i;
-	unsigned int orig_spi_freq;
 	unsigned int bit_sum = 8;
 	u32 otp_val, otp_id_reg;
 	u32 *otp_mem;
 		goto err_otp_unpack;
 	}
-	if (cs35l41->otp_setup)
-		cs35l41->otp_setup(cs35l41, true, &orig_spi_freq);
 	ret = regmap_bulk_read(cs35l41->regmap, CS35L41_OTP_MEM0, otp_mem,
 			       CS35L41_OTP_SIZE_WORDS);
 	if (ret < 0) {
 		goto err_otp_unpack;
 	}
-	if (cs35l41->otp_setup)
-		cs35l41->otp_setup(cs35l41, false, &orig_spi_freq);
 	otp_map = otp_map_match->map;
 	bit_offset = otp_map_match->bit_offset;

sound/soc/codecs/cs35l41.h+1−3

 #define CS35L41_FS2_WINDOW_MASK		0x00FFF800
 #define CS35L41_FS2_WINDOW_SHIFT	12
-#define CS35L41_SPI_MAX_FREQ_OTP	4000000
+#define CS35L41_SPI_MAX_FREQ		4000000
 #define CS35L41_RX_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_LE)
 #define CS35L41_TX_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_LE)
 	int irq;
 	/* GPIO for /RST */
 	struct gpio_desc *reset_gpio;
-	void (*otp_setup)(struct cs35l41_private *cs35l41, bool is_pre_setup,
-			  unsigned int *freq);
 };
 int cs35l41_probe(struct cs35l41_private *cs35l41,

sound/soc/codecs/rk817_codec.c+1−0

@@ -539,3 +539,4 @@ module_platform_driver(rk817_codec_driver); · 538 unmodified lines
539	MODULE_DESCRIPTION("ASoC RK817 codec driver");	539	MODULE_DESCRIPTION("ASoC RK817 codec driver");
540	MODULE_AUTHOR("binyuan <kevan.lan@rock-chips.com>");	540	MODULE_AUTHOR("binyuan <kevan.lan@rock-chips.com>");
541	MODULE_LICENSE("GPL v2");	541	MODULE_LICENSE("GPL v2");
		542	MODULE_ALIAS("platform:rk817-codec");

sound/soc/codecs/rt5682.c+6−4

 	for (i = 0; i < RT5682_DAI_NUM_CLKS; ++i) {
 		struct clk_init_data init = { };
+		struct clk_parent_data parent_data;
+		const struct clk_hw *parent;
 		dai_clk_hw = &rt5682->dai_clks_hw[i];
 		case RT5682_DAI_WCLK_IDX:
 			/* Make MCLK the parent of WCLK */
 			if (rt5682->mclk) {
-				init.parent_data = &(struct clk_parent_data){
+				parent_data = (struct clk_parent_data){
 					.fw_name = "mclk",
 				};
+				init.parent_data = &parent_data;
 				init.num_parents = 1;
 			}
 			break;
 		case RT5682_DAI_BCLK_IDX:
 			/* Make WCLK the parent of BCLK */
-			init.parent_hws = &(const struct clk_hw *){
+			parent = &rt5682->dai_clks_hw[RT5682_DAI_WCLK_IDX];
-				&rt5682->dai_clks_hw[RT5682_DAI_WCLK_IDX]
+			init.parent_hws = &parent;
-			};
 			init.num_parents = 1;
 			break;
 		default:

sound/soc/codecs/rt5682s.c+6−4

 	for (i = 0; i < RT5682S_DAI_NUM_CLKS; ++i) {
 		struct clk_init_data init = { };
+		struct clk_parent_data parent_data;
+		const struct clk_hw *parent;
 		dai_clk_hw = &rt5682s->dai_clks_hw[i];
 		case RT5682S_DAI_WCLK_IDX:
 			/* Make MCLK the parent of WCLK */
 			if (rt5682s->mclk) {
-				init.parent_data = &(struct clk_parent_data){
+				parent_data = (struct clk_parent_data){
 					.fw_name = "mclk",
 				};
+				init.parent_data = &parent_data;
 				init.num_parents = 1;
 			}
 			break;
 		case RT5682S_DAI_BCLK_IDX:
 			/* Make WCLK the parent of BCLK */
-			init.parent_hws = &(const struct clk_hw *){
+			parent = &rt5682s->dai_clks_hw[RT5682S_DAI_WCLK_IDX];
-				&rt5682s->dai_clks_hw[RT5682S_DAI_WCLK_IDX]
+			init.parent_hws = &parent;
-			};
 			init.num_parents = 1;
 			break;
 		default:

sound/soc/codecs/wcd934x.c+93−33

@@ -3256,6 +3256,9 @@ static int wcd934x_compander_set(struct snd_kcontrol *kc, · 3255 unmodified lines
3256	int value = ucontrol->value.integer.value[0];	3256	int value = ucontrol->value.integer.value[0];
3257	int sel;	3257	int sel;
3258		3258
		3259	if (wcd->comp_enabled[comp] == value)
		3260	return 0;
		3261
3259	wcd->comp_enabled[comp] = value;	3262	wcd->comp_enabled[comp] = value;
3260	sel = value ? WCD934X_HPH_GAIN_SRC_SEL_COMPANDER :	3263	sel = value ? WCD934X_HPH_GAIN_SRC_SEL_COMPANDER :
3261	WCD934X_HPH_GAIN_SRC_SEL_REGISTER;	3264	WCD934X_HPH_GAIN_SRC_SEL_REGISTER;
@@ -3279,10 +3282,10 @@ static int wcd934x_compander_set(struct snd_kcontrol *kc, · 17 unmodified lines
3279	case COMPANDER_8:	3282	case COMPANDER_8:
3280	break;	3283	break;
3281	default:	3284	default:
3282	break;	3285	return 0;
3283	}	3286	}
3284		3287
3285	return 0;	3288	return 1;
3286	}	3289	}
3287		3290
3288	static int wcd934x_rx_hph_mode_get(struct snd_kcontrol *kc,	3291	static int wcd934x_rx_hph_mode_get(struct snd_kcontrol *kc,
@@ -3326,6 +3329,31 @@ static int slim_rx_mux_get(struct snd_kcontrol *kc, · 37 unmodified lines
3326	return 0;	3329	return 0;
3327	}	3330	}
3328		3331
		3332	static int slim_rx_mux_to_dai_id(int mux)
		3333	{
		3334	int aif_id;
		3335
		3336	switch (mux) {
		3337	case 1:
		3338	aif_id = AIF1_PB;
		3339	break;
		3340	case 2:
		3341	aif_id = AIF2_PB;
		3342	break;
		3343	case 3:
		3344	aif_id = AIF3_PB;
		3345	break;
		3346	case 4:
		3347	aif_id = AIF4_PB;
		3348	break;
		3349	default:
		3350	aif_id = -1;
		3351	break;
		3352	}
		3353
		3354	return aif_id;
		3355	}
		3356
3329	static int slim_rx_mux_put(struct snd_kcontrol *kc,	3357	static int slim_rx_mux_put(struct snd_kcontrol *kc,
3330	struct snd_ctl_elem_value *ucontrol)	3358	struct snd_ctl_elem_value *ucontrol)
3331	{	3359	{
@@ -3333,43 +3361,59 @@ static int slim_rx_mux_put(struct snd_kcontrol *kc, · 1 unmodified line
3333	struct wcd934x_codec *wcd = dev_get_drvdata(w->dapm->dev);	3361	struct wcd934x_codec *wcd = dev_get_drvdata(w->dapm->dev);
3334	struct soc_enum e = (struct soc_enum )kc->private_value;	3362	struct soc_enum e = (struct soc_enum )kc->private_value;
3335	struct snd_soc_dapm_update *update = NULL;	3363	struct snd_soc_dapm_update *update = NULL;
		3364	struct wcd934x_slim_ch ch, c;
3336	u32 port_id = w->shift;	3365	u32 port_id = w->shift;
		3366	bool found = false;
		3367	int mux_idx;
		3368	int prev_mux_idx = wcd->rx_port_value[port_id];
		3369	int aif_id;
3337		3370
3338	if (wcd->rx_port_value[port_id] == ucontrol->value.enumerated.item[0])	3371	mux_idx = ucontrol->value.enumerated.item[0];
3339	return 0;
3340		3372
3341	wcd->rx_port_value[port_id] = ucontrol->value.enumerated.item[0];	3373	if (mux_idx == prev_mux_idx)
		3374	return 0;
3342		3375
3343	switch (wcd->rx_port_value[port_id]) {	3376	switch(mux_idx) {
3344	case 0:	3377	case 0:
3345	list_del_init(&wcd->rx_chs[port_id].list);	3378	aif_id = slim_rx_mux_to_dai_id(prev_mux_idx);
3346	break;	3379	if (aif_id < 0)
3347	case 1:	3380	return 0;
3348	list_add_tail(&wcd->rx_chs[port_id].list,	3381
3349	&wcd->dai[AIF1_PB].slim_ch_list);	3382	list_for_each_entry_safe(ch, c, &wcd->dai[aif_id].slim_ch_list, list) {
3350	break;	3383	if (ch->port == port_id + WCD934X_RX_START) {
3351	case 2:	3384	found = true;
3352	list_add_tail(&wcd->rx_chs[port_id].list,	3385	list_del_init(&ch->list);
3353	&wcd->dai[AIF2_PB].slim_ch_list);	3386	break;
3354	break;	3387	}
3355	case 3:	3388	}
3356	list_add_tail(&wcd->rx_chs[port_id].list,	3389	if (!found)
3357	&wcd->dai[AIF3_PB].slim_ch_list);	3390	return 0;
		3391
3358	break;	3392	break;
3359	case 4:	3393	case 1 ... 4:
3360	list_add_tail(&wcd->rx_chs[port_id].list,	3394	aif_id = slim_rx_mux_to_dai_id(mux_idx);
3361	&wcd->dai[AIF4_PB].slim_ch_list);	3395	if (aif_id < 0)
		3396	return 0;
		3397
		3398	if (list_empty(&wcd->rx_chs[port_id].list)) {
		3399	list_add_tail(&wcd->rx_chs[port_id].list,
		3400	&wcd->dai[aif_id].slim_ch_list);
		3401	} else {
		3402	dev_err(wcd->dev ,"SLIM_RX%d PORT is busy\n", port_id);
		3403	return 0;
		3404	}
3362	break;	3405	break;
		3406
3363	default:	3407	default:
3364	dev_err(wcd->dev, "Unknown AIF %d\n",	3408	dev_err(wcd->dev, "Unknown AIF %d\n", mux_idx);
3365	wcd->rx_port_value[port_id]);
3366	goto err;	3409	goto err;
3367	}	3410	}
3368		3411
		3412	wcd->rx_port_value[port_id] = mux_idx;
3369	snd_soc_dapm_mux_update_power(w->dapm, kc, wcd->rx_port_value[port_id],	3413	snd_soc_dapm_mux_update_power(w->dapm, kc, wcd->rx_port_value[port_id],
3370	e, update);	3414	e, update);
3371		3415
3372	return 0;	3416	return 1;
3373	err:	3417	err:
3374	return -EINVAL;	3418	return -EINVAL;
3375	}	3419	}
@@ -3815,6 +3859,7 @@ static int slim_tx_mixer_put(struct snd_kcontrol *kc, · 439 unmodified lines
3815	struct soc_mixer_control *mixer =	3859	struct soc_mixer_control *mixer =
3816	(struct soc_mixer_control *)kc->private_value;	3860	(struct soc_mixer_control *)kc->private_value;
3817	int enable = ucontrol->value.integer.value[0];	3861	int enable = ucontrol->value.integer.value[0];
		3862	struct wcd934x_slim_ch ch, c;
3818	int dai_id = widget->shift;	3863	int dai_id = widget->shift;
3819	int port_id = mixer->shift;	3864	int port_id = mixer->shift;
3820		3865
@@ -3822,17 +3867,32 @@ static int slim_tx_mixer_put(struct snd_kcontrol *kc, · 1 unmodified line
3822	if (enable == wcd->tx_port_value[port_id])	3867	if (enable == wcd->tx_port_value[port_id])
3823	return 0;	3868	return 0;
3824		3869
3825	wcd->tx_port_value[port_id] = enable;	3870	if (enable) {
3826		3871	if (list_empty(&wcd->tx_chs[port_id].list)) {
3827	if (enable)	3872	list_add_tail(&wcd->tx_chs[port_id].list,
3828	list_add_tail(&wcd->tx_chs[port_id].list,	3873	&wcd->dai[dai_id].slim_ch_list);
3829	&wcd->dai[dai_id].slim_ch_list);	3874	} else {
3830	else	3875	dev_err(wcd->dev ,"SLIM_TX%d PORT is busy\n", port_id);
3831	list_del_init(&wcd->tx_chs[port_id].list);	3876	return 0;
		3877	}
		3878	} else {
		3879	bool found = false;
		3880
		3881	list_for_each_entry_safe(ch, c, &wcd->dai[dai_id].slim_ch_list, list) {
		3882	if (ch->port == port_id) {
		3883	found = true;
		3884	list_del_init(&wcd->tx_chs[port_id].list);
		3885	break;
		3886	}
		3887	}
		3888	if (!found)
		3889	return 0;
		3890	}
3832		3891
		3892	wcd->tx_port_value[port_id] = enable;
3833	snd_soc_dapm_mixer_update_power(widget->dapm, kc, enable, update);	3893	snd_soc_dapm_mixer_update_power(widget->dapm, kc, enable, update);
3834		3894
3835	return 0;	3895	return 1;
3836	}	3896	}
3837		3897
3838	static const struct snd_kcontrol_new aif1_slim_cap_mixer[] = {	3898	static const struct snd_kcontrol_new aif1_slim_cap_mixer[] = {

sound/soc/codecs/wsa881x.c+12−4

@@ -772,7 +772,8 @@ static int wsa881x_put_pa_gain(struct snd_kcontrol *kc, · 771 unmodified lines
772		772
773	usleep_range(1000, 1010);	773	usleep_range(1000, 1010);
774	}	774	}
775	return 0;	775
		776	return 1;
776	}	777	}
777		778
778	static int wsa881x_get_port(struct snd_kcontrol *kcontrol,	779	static int wsa881x_get_port(struct snd_kcontrol *kcontrol,
@@ -816,15 +817,22 @@ static int wsa881x_set_port(struct snd_kcontrol *kcontrol, · 37 unmodified lines
816	(struct soc_mixer_control *)kcontrol->private_value;	817	(struct soc_mixer_control *)kcontrol->private_value;
817	int portidx = mixer->reg;	818	int portidx = mixer->reg;
818		819
819	if (ucontrol->value.integer.value[0])	820	if (ucontrol->value.integer.value[0]) {
		821	if (data->port_enable[portidx])
		822	return 0;
		823
820	data->port_enable[portidx] = true;	824	data->port_enable[portidx] = true;
821	else	825	} else {
		826	if (!data->port_enable[portidx])
		827	return 0;
		828
822	data->port_enable[portidx] = false;	829	data->port_enable[portidx] = false;
		830	}
823		831
824	if (portidx == WSA881X_PORT_BOOST) /* Boost Switch */	832	if (portidx == WSA881X_PORT_BOOST) /* Boost Switch */
825	wsa881x_boost_ctrl(comp, data->port_enable[portidx]);	833	wsa881x_boost_ctrl(comp, data->port_enable[portidx]);
826		834
827	return 0;	835	return 1;
828	}	836	}
829		837
830	static const char * const smart_boost_lvl_text[] = {	838	static const char * const smart_boost_lvl_text[] = {

sound/soc/intel/common/soc-acpi-intel-cml-match.c+6−0

 		.sof_fw_filename = "sof-cml.ri",
 		.sof_tplg_filename = "sof-cml-da7219-max98390.tplg",
 	},
+	{
+		.id = "ESSX8336",
+		.drv_name = "sof-essx8336",
+		.sof_fw_filename = "sof-cml.ri",
+		.sof_tplg_filename = "sof-cml-es8336.tplg",
+	},
 	{},
 };
 EXPORT_SYMBOL_GPL(snd_soc_acpi_intel_cml_machines);

sound/soc/qcom/qdsp6/q6routing.c+5−3

 	struct session_data *session = &data->sessions[session_id];
 	if (ucontrol->value.integer.value[0]) {
+		if (session->port_id == be_id)
+			return 0;
 		session->port_id = be_id;
 		snd_soc_dapm_mixer_update_power(dapm, kcontrol, 1, update);
 	} else {
-		if (session->port_id == be_id) {
+		if (session->port_id == -1 || session->port_id != be_id)
-			session->port_id = -1;
 			return 0;
-		}
+		session->port_id = -1;
 		snd_soc_dapm_mixer_update_power(dapm, kcontrol, 0, update);
 	}

sound/soc/rockchip/rockchip_i2s_tdm.c+31−21

@@ -95,6 +95,7 @@ struct rk_i2s_tdm_dev { · 94 unmodified lines
95	spinlock_t lock; /* xfer lock */	95	spinlock_t lock; /* xfer lock */
96	bool has_playback;	96	bool has_playback;
97	bool has_capture;	97	bool has_capture;
		98	struct snd_soc_dai_driver *dai;
98	};	99	};
99		100
100	static int to_ch_num(unsigned int val)	101	static int to_ch_num(unsigned int val)
@@ -1310,19 +1311,14 @@ static const struct of_device_id rockchip_i2s_tdm_match[] = { · 1209 unmodified lines
1310	{},	1311	{},
1311	};	1312	};
1312		1313
1313	static struct snd_soc_dai_driver i2s_tdm_dai = {	1314	static const struct snd_soc_dai_driver i2s_tdm_dai = {
1314	.probe = rockchip_i2s_tdm_dai_probe,	1315	.probe = rockchip_i2s_tdm_dai_probe,
1315	.playback = {
1316	.stream_name = "Playback",
1317	},
1318	.capture = {
1319	.stream_name = "Capture",
1320	},
1321	.ops = &rockchip_i2s_tdm_dai_ops,	1316	.ops = &rockchip_i2s_tdm_dai_ops,
1322	};	1317	};
1323		1318
1324	static void rockchip_i2s_tdm_init_dai(struct rk_i2s_tdm_dev *i2s_tdm)	1319	static int rockchip_i2s_tdm_init_dai(struct rk_i2s_tdm_dev *i2s_tdm)
1325	{	1320	{
		1321	struct snd_soc_dai_driver *dai;
1326	struct property *dma_names;	1322	struct property *dma_names;
1327	const char *dma_name;	1323	const char *dma_name;
1328	u64 formats = (SNDRV_PCM_FMTBIT_S8 \| SNDRV_PCM_FMTBIT_S16_LE \|	1324	u64 formats = (SNDRV_PCM_FMTBIT_S8 \| SNDRV_PCM_FMTBIT_S16_LE \|
@@ -1337,19 +1333,33 @@ static void rockchip_i2s_tdm_init_dai(struct rk_i2s_tdm_dev *i2s_tdm) · 8 unmodified lines
1337	i2s_tdm->has_capture = true;	1333	i2s_tdm->has_capture = true;
1338	}	1334	}
1339		1335
		1336	dai = devm_kmemdup(i2s_tdm->dev, &i2s_tdm_dai,
		1337	sizeof(*dai), GFP_KERNEL);
		1338	if (!dai)
		1339	return -ENOMEM;
		1340
1340	if (i2s_tdm->has_playback) {	1341	if (i2s_tdm->has_playback) {
1341	i2s_tdm_dai.playback.channels_min = 2;	1342	dai->playback.stream_name = "Playback";
1342	i2s_tdm_dai.playback.channels_max = 8;	1343	dai->playback.channels_min = 2;
1343	i2s_tdm_dai.playback.rates = SNDRV_PCM_RATE_8000_192000;	1344	dai->playback.channels_max = 8;
1344	i2s_tdm_dai.playback.formats = formats;	1345	dai->playback.rates = SNDRV_PCM_RATE_8000_192000;
		1346	dai->playback.formats = formats;
1345	}	1347	}
1346		1348
1347	if (i2s_tdm->has_capture) {	1349	if (i2s_tdm->has_capture) {
1348	i2s_tdm_dai.capture.channels_min = 2;	1350	dai->capture.stream_name = "Capture";
1349	i2s_tdm_dai.capture.channels_max = 8;	1351	dai->capture.channels_min = 2;
1350	i2s_tdm_dai.capture.rates = SNDRV_PCM_RATE_8000_192000;	1352	dai->capture.channels_max = 8;
1351	i2s_tdm_dai.capture.formats = formats;	1353	dai->capture.rates = SNDRV_PCM_RATE_8000_192000;
		1354	dai->capture.formats = formats;
1352	}	1355	}
		1356
		1357	if (i2s_tdm->clk_trcm != TRCM_TXRX)
		1358	dai->symmetric_rate = 1;
		1359
		1360	i2s_tdm->dai = dai;
		1361
		1362	return 0;
1353	}	1363	}
1354		1364
1355	static int rockchip_i2s_tdm_path_check(struct rk_i2s_tdm_dev *i2s_tdm,	1365	static int rockchip_i2s_tdm_path_check(struct rk_i2s_tdm_dev *i2s_tdm,
@@ -1541,8 +1551,6 @@ static int rockchip_i2s_tdm_probe(struct platform_device *pdev) · 185 unmodified lines
1541	spin_lock_init(&i2s_tdm->lock);	1551	spin_lock_init(&i2s_tdm->lock);
1542	i2s_tdm->soc_data = (struct rk_i2s_soc_data *)of_id->data;	1552	i2s_tdm->soc_data = (struct rk_i2s_soc_data *)of_id->data;
1543		1553
1544	rockchip_i2s_tdm_init_dai(i2s_tdm);
1545
1546	i2s_tdm->frame_width = 64;	1554	i2s_tdm->frame_width = 64;
1547		1555
1548	i2s_tdm->clk_trcm = TRCM_TXRX;	1556	i2s_tdm->clk_trcm = TRCM_TXRX;
@@ -1555,8 +1563,10 @@ static int rockchip_i2s_tdm_probe(struct platform_device *pdev) · 6 unmodified lines
1555	}	1563	}
1556	i2s_tdm->clk_trcm = TRCM_RX;	1564	i2s_tdm->clk_trcm = TRCM_RX;
1557	}	1565	}
1558	if (i2s_tdm->clk_trcm != TRCM_TXRX)	1566
1559	i2s_tdm_dai.symmetric_rate = 1;	1567	ret = rockchip_i2s_tdm_init_dai(i2s_tdm);
		1568	if (ret)
		1569	return ret;
1560		1570
1561	i2s_tdm->grf = syscon_regmap_lookup_by_phandle(node, "rockchip,grf");	1571	i2s_tdm->grf = syscon_regmap_lookup_by_phandle(node, "rockchip,grf");
1562	if (IS_ERR(i2s_tdm->grf))	1572	if (IS_ERR(i2s_tdm->grf))
@@ -1678,7 +1688,7 @@ static int rockchip_i2s_tdm_probe(struct platform_device *pdev) · 115 unmodified lines
1678		1688
1679	ret = devm_snd_soc_register_component(&pdev->dev,	1689	ret = devm_snd_soc_register_component(&pdev->dev,
1680	&rockchip_i2s_tdm_component,	1690	&rockchip_i2s_tdm_component,
1681	&i2s_tdm_dai, 1);	1691	i2s_tdm->dai, 1);
1682		1692
1683	if (ret) {	1693	if (ret) {
1684	dev_err(&pdev->dev, "Could not register DAI\n");	1694	dev_err(&pdev->dev, "Could not register DAI\n");

sound/soc/soc-acpi.c+3−1

 	if (comp_ids) {
 		for (i = 0; i < comp_ids->num_codecs; i++) {
-			if (acpi_dev_present(comp_ids->codecs[i], NULL, -1))
+			if (acpi_dev_present(comp_ids->codecs[i], NULL, -1)) {
+				strscpy(machine->id, comp_ids->codecs[i], ACPI_ID_LEN);
 				return true;
+			}
 		}
 	}

sound/soc/sof/intel/hda-codec.c+9−5

 #if IS_ENABLED(CONFIG_SND_SOC_SOF_HDA_AUDIO_CODEC)
 #define IDISP_VID_INTEL	0x80860000
+#define CODEC_PROBE_RETRIES 3
 /* load the legacy HDA codec driver */
 static int request_codec_module(struct hda_codec *codec)
 	u32 hda_cmd = (address << 28) | (AC_NODE_ROOT << 20) |
 		(AC_VERB_PARAMETERS << 8) | AC_PAR_VENDOR_ID;
 	u32 resp = -1;
-	int ret;
+	int ret, retry = 0;
+	do {
+		mutex_lock(&hbus->core.cmd_mutex);
+		snd_hdac_bus_send_cmd(&hbus->core, hda_cmd);
+		snd_hdac_bus_get_response(&hbus->core, address, &resp);
+		mutex_unlock(&hbus->core.cmd_mutex);
+	} while (resp == -1 && retry++ < CODEC_PROBE_RETRIES);
-	mutex_lock(&hbus->core.cmd_mutex);
-	snd_hdac_bus_send_cmd(&hbus->core, hda_cmd);
-	snd_hdac_bus_get_response(&hbus->core, address, &resp);
-	mutex_unlock(&hbus->core.cmd_mutex);
 	if (resp == -1)
 		return -EIO;
 	dev_dbg(sdev->dev, "HDA codec #%d probed OK: response: %x\n",

sound/soc/sof/intel/hda.c+7−0

@@ -58,6 +58,13 @@ int hda_ctrl_dai_widget_setup(struct snd_soc_dapm_widget *w) · 57 unmodified lines
58	return -EINVAL;	58	return -EINVAL;
59	}	59	}
60		60
		61	/* DAI already configured, reset it before reconfiguring it */
		62	if (sof_dai->configured) {
		63	ret = hda_ctrl_dai_widget_free(w);
		64	if (ret < 0)
		65	return ret;
		66	}
		67
61	config = &sof_dai->dai_config[sof_dai->current_config];	68	config = &sof_dai->dai_config[sof_dai->current_config];
62		69
63	/*	70	/*

sound/soc/tegra/tegra186_dspk.c+147−34

@@ -26,51 +26,162 @@ static const struct reg_default tegra186_dspk_reg_defaults[] = { · 25 unmodified lines
26	{ TEGRA186_DSPK_CODEC_CTRL, 0x03000000 },	26	{ TEGRA186_DSPK_CODEC_CTRL, 0x03000000 },
27	};	27	};
28		28
29	static int tegra186_dspk_get_control(struct snd_kcontrol *kcontrol,	29	static int tegra186_dspk_get_fifo_th(struct snd_kcontrol *kcontrol,
30	struct snd_ctl_elem_value *ucontrol)	30	struct snd_ctl_elem_value *ucontrol)
31	{	31	{
32	struct snd_soc_component *codec = snd_soc_kcontrol_component(kcontrol);	32	struct snd_soc_component *codec = snd_soc_kcontrol_component(kcontrol);
33	struct tegra186_dspk *dspk = snd_soc_component_get_drvdata(codec);	33	struct tegra186_dspk *dspk = snd_soc_component_get_drvdata(codec);
34		34
35	if (strstr(kcontrol->id.name, "FIFO Threshold"))	35	ucontrol->value.integer.value[0] = dspk->rx_fifo_th;
36	ucontrol->value.integer.value[0] = dspk->rx_fifo_th;
37	else if (strstr(kcontrol->id.name, "OSR Value"))
38	ucontrol->value.integer.value[0] = dspk->osr_val;
39	else if (strstr(kcontrol->id.name, "LR Polarity Select"))
40	ucontrol->value.integer.value[0] = dspk->lrsel;
41	else if (strstr(kcontrol->id.name, "Channel Select"))
42	ucontrol->value.integer.value[0] = dspk->ch_sel;
43	else if (strstr(kcontrol->id.name, "Mono To Stereo"))
44	ucontrol->value.integer.value[0] = dspk->mono_to_stereo;
45	else if (strstr(kcontrol->id.name, "Stereo To Mono"))
46	ucontrol->value.integer.value[0] = dspk->stereo_to_mono;
47		36
48	return 0;	37	return 0;
49	}	38	}
50		39
51	static int tegra186_dspk_put_control(struct snd_kcontrol *kcontrol,	40	static int tegra186_dspk_put_fifo_th(struct snd_kcontrol *kcontrol,
52	struct snd_ctl_elem_value *ucontrol)	41	struct snd_ctl_elem_value *ucontrol)
53	{	42	{
54	struct snd_soc_component *codec = snd_soc_kcontrol_component(kcontrol);	43	struct snd_soc_component *codec = snd_soc_kcontrol_component(kcontrol);
55	struct tegra186_dspk *dspk = snd_soc_component_get_drvdata(codec);	44	struct tegra186_dspk *dspk = snd_soc_component_get_drvdata(codec);
56	int val = ucontrol->value.integer.value[0];	45	int value = ucontrol->value.integer.value[0];
57		46
58	if (strstr(kcontrol->id.name, "FIFO Threshold"))	47	if (value == dspk->rx_fifo_th)
59	dspk->rx_fifo_th = val;	48	return 0;
60	else if (strstr(kcontrol->id.name, "OSR Value"))	49
61	dspk->osr_val = val;	50	dspk->rx_fifo_th = value;
62	else if (strstr(kcontrol->id.name, "LR Polarity Select"))	51
63	dspk->lrsel = val;	52	return 1;
64	else if (strstr(kcontrol->id.name, "Channel Select"))	53	}
65	dspk->ch_sel = val;	54
66	else if (strstr(kcontrol->id.name, "Mono To Stereo"))	55	static int tegra186_dspk_get_osr_val(struct snd_kcontrol *kcontrol,
67	dspk->mono_to_stereo = val;	56	struct snd_ctl_elem_value *ucontrol)
68	else if (strstr(kcontrol->id.name, "Stereo To Mono"))	57	{
69	dspk->stereo_to_mono = val;	58	struct snd_soc_component *codec = snd_soc_kcontrol_component(kcontrol);
		59	struct tegra186_dspk *dspk = snd_soc_component_get_drvdata(codec);
		60
		61	ucontrol->value.enumerated.item[0] = dspk->osr_val;
70		62
71	return 0;	63	return 0;
72	}	64	}
73		65
		66	static int tegra186_dspk_put_osr_val(struct snd_kcontrol *kcontrol,
		67	struct snd_ctl_elem_value *ucontrol)
		68	{
		69	struct snd_soc_component *codec = snd_soc_kcontrol_component(kcontrol);
		70	struct tegra186_dspk *dspk = snd_soc_component_get_drvdata(codec);
		71	unsigned int value = ucontrol->value.enumerated.item[0];
		72
		73	if (value == dspk->osr_val)
		74	return 0;
		75
		76	dspk->osr_val = value;
		77
		78	return 1;
		79	}
		80
		81	static int tegra186_dspk_get_pol_sel(struct snd_kcontrol *kcontrol,
		82	struct snd_ctl_elem_value *ucontrol)
		83	{
		84	struct snd_soc_component *codec = snd_soc_kcontrol_component(kcontrol);
		85	struct tegra186_dspk *dspk = snd_soc_component_get_drvdata(codec);
		86
		87	ucontrol->value.enumerated.item[0] = dspk->lrsel;
		88
		89	return 0;
		90	}
		91
		92	static int tegra186_dspk_put_pol_sel(struct snd_kcontrol *kcontrol,
		93	struct snd_ctl_elem_value *ucontrol)
		94	{
		95	struct snd_soc_component *codec = snd_soc_kcontrol_component(kcontrol);
		96	struct tegra186_dspk *dspk = snd_soc_component_get_drvdata(codec);
		97	unsigned int value = ucontrol->value.enumerated.item[0];
		98
		99	if (value == dspk->lrsel)
		100	return 0;
		101
		102	dspk->lrsel = value;
		103
		104	return 1;
		105	}
		106
		107	static int tegra186_dspk_get_ch_sel(struct snd_kcontrol *kcontrol,
		108	struct snd_ctl_elem_value *ucontrol)
		109	{
		110	struct snd_soc_component *codec = snd_soc_kcontrol_component(kcontrol);
		111	struct tegra186_dspk *dspk = snd_soc_component_get_drvdata(codec);
		112
		113	ucontrol->value.enumerated.item[0] = dspk->ch_sel;
		114
		115	return 0;
		116	}
		117
		118	static int tegra186_dspk_put_ch_sel(struct snd_kcontrol *kcontrol,
		119	struct snd_ctl_elem_value *ucontrol)
		120	{
		121	struct snd_soc_component *codec = snd_soc_kcontrol_component(kcontrol);
		122	struct tegra186_dspk *dspk = snd_soc_component_get_drvdata(codec);
		123	unsigned int value = ucontrol->value.enumerated.item[0];
		124
		125	if (value == dspk->ch_sel)
		126	return 0;
		127
		128	dspk->ch_sel = value;
		129
		130	return 1;
		131	}
		132
		133	static int tegra186_dspk_get_mono_to_stereo(struct snd_kcontrol *kcontrol,
		134	struct snd_ctl_elem_value *ucontrol)
		135	{
		136	struct snd_soc_component *codec = snd_soc_kcontrol_component(kcontrol);
		137	struct tegra186_dspk *dspk = snd_soc_component_get_drvdata(codec);
		138
		139	ucontrol->value.enumerated.item[0] = dspk->mono_to_stereo;
		140
		141	return 0;
		142	}
		143
		144	static int tegra186_dspk_put_mono_to_stereo(struct snd_kcontrol *kcontrol,
		145	struct snd_ctl_elem_value *ucontrol)
		146	{
		147	struct snd_soc_component *codec = snd_soc_kcontrol_component(kcontrol);
		148	struct tegra186_dspk *dspk = snd_soc_component_get_drvdata(codec);
		149	unsigned int value = ucontrol->value.enumerated.item[0];
		150
		151	if (value == dspk->mono_to_stereo)
		152	return 0;
		153
		154	dspk->mono_to_stereo = value;
		155
		156	return 1;
		157	}
		158
		159	static int tegra186_dspk_get_stereo_to_mono(struct snd_kcontrol *kcontrol,
		160	struct snd_ctl_elem_value *ucontrol)
		161	{
		162	struct snd_soc_component *codec = snd_soc_kcontrol_component(kcontrol);
		163	struct tegra186_dspk *dspk = snd_soc_component_get_drvdata(codec);
		164
		165	ucontrol->value.enumerated.item[0] = dspk->stereo_to_mono;
		166
		167	return 0;
		168	}
		169
		170	static int tegra186_dspk_put_stereo_to_mono(struct snd_kcontrol *kcontrol,
		171	struct snd_ctl_elem_value *ucontrol)
		172	{
		173	struct snd_soc_component *codec = snd_soc_kcontrol_component(kcontrol);
		174	struct tegra186_dspk *dspk = snd_soc_component_get_drvdata(codec);
		175	unsigned int value = ucontrol->value.enumerated.item[0];
		176
		177	if (value == dspk->stereo_to_mono)
		178	return 0;
		179
		180	dspk->stereo_to_mono = value;
		181
		182	return 1;
		183	}
		184
74	static int __maybe_unused tegra186_dspk_runtime_suspend(struct device *dev)	185	static int __maybe_unused tegra186_dspk_runtime_suspend(struct device *dev)
75	{	186	{
76	struct tegra186_dspk *dspk = dev_get_drvdata(dev);	187	struct tegra186_dspk *dspk = dev_get_drvdata(dev);
@@ -279,17 +390,19 @@ static const struct soc_enum tegra186_dspk_lrsel_enum = · 202 unmodified lines
279	static const struct snd_kcontrol_new tegrat186_dspk_controls[] = {	390	static const struct snd_kcontrol_new tegrat186_dspk_controls[] = {
280	SOC_SINGLE_EXT("FIFO Threshold", SND_SOC_NOPM, 0,	391	SOC_SINGLE_EXT("FIFO Threshold", SND_SOC_NOPM, 0,
281	TEGRA186_DSPK_RX_FIFO_DEPTH - 1, 0,	392	TEGRA186_DSPK_RX_FIFO_DEPTH - 1, 0,
282	tegra186_dspk_get_control, tegra186_dspk_put_control),	393	tegra186_dspk_get_fifo_th, tegra186_dspk_put_fifo_th),
283	SOC_ENUM_EXT("OSR Value", tegra186_dspk_osr_enum,	394	SOC_ENUM_EXT("OSR Value", tegra186_dspk_osr_enum,
284	tegra186_dspk_get_control, tegra186_dspk_put_control),	395	tegra186_dspk_get_osr_val, tegra186_dspk_put_osr_val),
285	SOC_ENUM_EXT("LR Polarity Select", tegra186_dspk_lrsel_enum,	396	SOC_ENUM_EXT("LR Polarity Select", tegra186_dspk_lrsel_enum,
286	tegra186_dspk_get_control, tegra186_dspk_put_control),	397	tegra186_dspk_get_pol_sel, tegra186_dspk_put_pol_sel),
287	SOC_ENUM_EXT("Channel Select", tegra186_dspk_ch_sel_enum,	398	SOC_ENUM_EXT("Channel Select", tegra186_dspk_ch_sel_enum,
288	tegra186_dspk_get_control, tegra186_dspk_put_control),	399	tegra186_dspk_get_ch_sel, tegra186_dspk_put_ch_sel),
289	SOC_ENUM_EXT("Mono To Stereo", tegra186_dspk_mono_conv_enum,	400	SOC_ENUM_EXT("Mono To Stereo", tegra186_dspk_mono_conv_enum,
290	tegra186_dspk_get_control, tegra186_dspk_put_control),	401	tegra186_dspk_get_mono_to_stereo,
		402	tegra186_dspk_put_mono_to_stereo),
291	SOC_ENUM_EXT("Stereo To Mono", tegra186_dspk_stereo_conv_enum,	403	SOC_ENUM_EXT("Stereo To Mono", tegra186_dspk_stereo_conv_enum,
292	tegra186_dspk_get_control, tegra186_dspk_put_control),	404	tegra186_dspk_get_stereo_to_mono,
		405	tegra186_dspk_put_stereo_to_mono),
293	};	406	};
294		407
295	static const struct snd_soc_component_driver tegra186_dspk_cmpnt = {	408	static const struct snd_soc_component_driver tegra186_dspk_cmpnt = {

sound/soc/tegra/tegra210_admaif.c+110−30

@@ -424,46 +424,122 @@ static const struct snd_soc_dai_ops tegra_admaif_dai_ops = { · 423 unmodified lines
424	.trigger = tegra_admaif_trigger,	424	.trigger = tegra_admaif_trigger,
425	};	425	};
426		426
427	static int tegra_admaif_get_control(struct snd_kcontrol *kcontrol,	427	static int tegra210_admaif_pget_mono_to_stereo(struct snd_kcontrol *kcontrol,
428	struct snd_ctl_elem_value *ucontrol)	428	struct snd_ctl_elem_value *ucontrol)
429	{	429	{
430	struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);	430	struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
		431	struct tegra_admaif *admaif = snd_soc_component_get_drvdata(cmpnt);
		432	struct soc_enum ec = (struct soc_enum )kcontrol->private_value;
		433
		434	ucontrol->value.enumerated.item[0] =
		435	admaif->mono_to_stereo[ADMAIF_TX_PATH][ec->reg];
		436
		437	return 0;
		438	}
		439
		440	static int tegra210_admaif_pput_mono_to_stereo(struct snd_kcontrol *kcontrol,
		441	struct snd_ctl_elem_value *ucontrol)
		442	{
		443	struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
		444	struct tegra_admaif *admaif = snd_soc_component_get_drvdata(cmpnt);
		445	struct soc_enum ec = (struct soc_enum )kcontrol->private_value;
		446	unsigned int value = ucontrol->value.enumerated.item[0];
		447
		448	if (value == admaif->mono_to_stereo[ADMAIF_TX_PATH][ec->reg])
		449	return 0;
		450
		451	admaif->mono_to_stereo[ADMAIF_TX_PATH][ec->reg] = value;
		452
		453	return 1;
		454	}
		455
		456	static int tegra210_admaif_cget_mono_to_stereo(struct snd_kcontrol *kcontrol,
		457	struct snd_ctl_elem_value *ucontrol)
		458	{
		459	struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
		460	struct tegra_admaif *admaif = snd_soc_component_get_drvdata(cmpnt);
		461	struct soc_enum ec = (struct soc_enum )kcontrol->private_value;
		462
		463	ucontrol->value.enumerated.item[0] =
		464	admaif->mono_to_stereo[ADMAIF_RX_PATH][ec->reg];
		465
		466	return 0;
		467	}
		468
		469	static int tegra210_admaif_cput_mono_to_stereo(struct snd_kcontrol *kcontrol,
		470	struct snd_ctl_elem_value *ucontrol)
		471	{
		472	struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
		473	struct tegra_admaif *admaif = snd_soc_component_get_drvdata(cmpnt);
431	struct soc_enum ec = (struct soc_enum )kcontrol->private_value;	474	struct soc_enum ec = (struct soc_enum )kcontrol->private_value;
		475	unsigned int value = ucontrol->value.enumerated.item[0];
		476
		477	if (value == admaif->mono_to_stereo[ADMAIF_RX_PATH][ec->reg])
		478	return 0;
		479
		480	admaif->mono_to_stereo[ADMAIF_RX_PATH][ec->reg] = value;
		481
		482	return 1;
		483	}
		484
		485	static int tegra210_admaif_pget_stereo_to_mono(struct snd_kcontrol *kcontrol,
		486	struct snd_ctl_elem_value *ucontrol)
		487	{
		488	struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
432	struct tegra_admaif *admaif = snd_soc_component_get_drvdata(cmpnt);	489	struct tegra_admaif *admaif = snd_soc_component_get_drvdata(cmpnt);
433	long *uctl_val = &ucontrol->value.integer.value[0];	490	struct soc_enum ec = (struct soc_enum )kcontrol->private_value;
434		491
435	if (strstr(kcontrol->id.name, "Playback Mono To Stereo"))	492	ucontrol->value.enumerated.item[0] =
436	*uctl_val = admaif->mono_to_stereo[ADMAIF_TX_PATH][ec->reg];	493	admaif->stereo_to_mono[ADMAIF_TX_PATH][ec->reg];
437	else if (strstr(kcontrol->id.name, "Capture Mono To Stereo"))
438	*uctl_val = admaif->mono_to_stereo[ADMAIF_RX_PATH][ec->reg];
439	else if (strstr(kcontrol->id.name, "Playback Stereo To Mono"))
440	*uctl_val = admaif->stereo_to_mono[ADMAIF_TX_PATH][ec->reg];
441	else if (strstr(kcontrol->id.name, "Capture Stereo To Mono"))
442	*uctl_val = admaif->stereo_to_mono[ADMAIF_RX_PATH][ec->reg];
443		494
444	return 0;	495	return 0;
445	}	496	}
446		497
447	static int tegra_admaif_put_control(struct snd_kcontrol *kcontrol,	498	static int tegra210_admaif_pput_stereo_to_mono(struct snd_kcontrol *kcontrol,
448	struct snd_ctl_elem_value *ucontrol)	499	struct snd_ctl_elem_value *ucontrol)
449	{	500	{
450	struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);	501	struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
		502	struct tegra_admaif *admaif = snd_soc_component_get_drvdata(cmpnt);
451	struct soc_enum ec = (struct soc_enum )kcontrol->private_value;	503	struct soc_enum ec = (struct soc_enum )kcontrol->private_value;
		504	unsigned int value = ucontrol->value.enumerated.item[0];
		505
		506	if (value == admaif->stereo_to_mono[ADMAIF_TX_PATH][ec->reg])
		507	return 0;
		508
		509	admaif->stereo_to_mono[ADMAIF_TX_PATH][ec->reg] = value;
		510
		511	return 1;
		512	}
		513
		514	static int tegra210_admaif_cget_stereo_to_mono(struct snd_kcontrol *kcontrol,
		515	struct snd_ctl_elem_value *ucontrol)
		516	{
		517	struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
452	struct tegra_admaif *admaif = snd_soc_component_get_drvdata(cmpnt);	518	struct tegra_admaif *admaif = snd_soc_component_get_drvdata(cmpnt);
453	int value = ucontrol->value.integer.value[0];	519	struct soc_enum ec = (struct soc_enum )kcontrol->private_value;
454		520
455	if (strstr(kcontrol->id.name, "Playback Mono To Stereo"))	521	ucontrol->value.enumerated.item[0] =
456	admaif->mono_to_stereo[ADMAIF_TX_PATH][ec->reg] = value;	522	admaif->stereo_to_mono[ADMAIF_RX_PATH][ec->reg];
457	else if (strstr(kcontrol->id.name, "Capture Mono To Stereo"))
458	admaif->mono_to_stereo[ADMAIF_RX_PATH][ec->reg] = value;
459	else if (strstr(kcontrol->id.name, "Playback Stereo To Mono"))
460	admaif->stereo_to_mono[ADMAIF_TX_PATH][ec->reg] = value;
461	else if (strstr(kcontrol->id.name, "Capture Stereo To Mono"))
462	admaif->stereo_to_mono[ADMAIF_RX_PATH][ec->reg] = value;
463		523
464	return 0;	524	return 0;
465	}	525	}
466		526
		527	static int tegra210_admaif_cput_stereo_to_mono(struct snd_kcontrol *kcontrol,
		528	struct snd_ctl_elem_value *ucontrol)
		529	{
		530	struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
		531	struct tegra_admaif *admaif = snd_soc_component_get_drvdata(cmpnt);
		532	struct soc_enum ec = (struct soc_enum )kcontrol->private_value;
		533	unsigned int value = ucontrol->value.enumerated.item[0];
		534
		535	if (value == admaif->stereo_to_mono[ADMAIF_RX_PATH][ec->reg])
		536	return 0;
		537
		538	admaif->stereo_to_mono[ADMAIF_RX_PATH][ec->reg] = value;
		539
		540	return 1;
		541	}
		542
467	static int tegra_admaif_dai_probe(struct snd_soc_dai *dai)	543	static int tegra_admaif_dai_probe(struct snd_soc_dai *dai)
468	{	544	{
469	struct tegra_admaif *admaif = snd_soc_dai_get_drvdata(dai);	545	struct tegra_admaif *admaif = snd_soc_dai_get_drvdata(dai);
@@ -559,17 +635,21 @@ static const char * const tegra_admaif_mono_conv_text[] = { · 89 unmodified lines
559	}	635	}
560		636
561	#define TEGRA_ADMAIF_CIF_CTRL(reg) \	637	#define TEGRA_ADMAIF_CIF_CTRL(reg) \
562	NV_SOC_ENUM_EXT("ADMAIF" #reg " Playback Mono To Stereo", reg - 1,\	638	NV_SOC_ENUM_EXT("ADMAIF" #reg " Playback Mono To Stereo", reg - 1, \
563	tegra_admaif_get_control, tegra_admaif_put_control, \	639	tegra210_admaif_pget_mono_to_stereo, \
		640	tegra210_admaif_pput_mono_to_stereo, \
564	tegra_admaif_mono_conv_text), \	641	tegra_admaif_mono_conv_text), \
565	NV_SOC_ENUM_EXT("ADMAIF" #reg " Playback Stereo To Mono", reg - 1,\	642	NV_SOC_ENUM_EXT("ADMAIF" #reg " Playback Stereo To Mono", reg - 1, \
566	tegra_admaif_get_control, tegra_admaif_put_control, \	643	tegra210_admaif_pget_stereo_to_mono, \
		644	tegra210_admaif_pput_stereo_to_mono, \
567	tegra_admaif_stereo_conv_text), \	645	tegra_admaif_stereo_conv_text), \
568	NV_SOC_ENUM_EXT("ADMAIF" #reg " Capture Mono To Stereo", reg - 1, \	646	NV_SOC_ENUM_EXT("ADMAIF" #reg " Capture Mono To Stereo", reg - 1, \
569	tegra_admaif_get_control, tegra_admaif_put_control, \	647	tegra210_admaif_cget_mono_to_stereo, \
		648	tegra210_admaif_cput_mono_to_stereo, \
570	tegra_admaif_mono_conv_text), \	649	tegra_admaif_mono_conv_text), \
571	NV_SOC_ENUM_EXT("ADMAIF" #reg " Capture Stereo To Mono", reg - 1, \	650	NV_SOC_ENUM_EXT("ADMAIF" #reg " Capture Stereo To Mono", reg - 1, \
572	tegra_admaif_get_control, tegra_admaif_put_control, \	651	tegra210_admaif_cget_stereo_to_mono, \
		652	tegra210_admaif_cput_stereo_to_mono, \
573	tegra_admaif_stereo_conv_text)	653	tegra_admaif_stereo_conv_text)
574		654
575	static struct snd_kcontrol_new tegra210_admaif_controls[] = {	655	static struct snd_kcontrol_new tegra210_admaif_controls[] = {

sound/soc/tegra/tegra210_adx.c+5−2

 	struct soc_mixer_control *mc =
 		(struct soc_mixer_control *)kcontrol->private_value;;
+	if (value == bytes_map[mc->reg])
+		return 0;
 	if (value >= 0 && value <= 255) {
 		/* update byte map and enable slot */
 		bytes_map[mc->reg] = value;
 static const struct dev_pm_ops tegra210_adx_pm_ops = {
 	SET_RUNTIME_PM_OPS(tegra210_adx_runtime_suspend,
 			   tegra210_adx_runtime_resume, NULL)
-	SET_LATE_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
+	SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
-				     pm_runtime_force_resume)
+				pm_runtime_force_resume)
 };
 static struct platform_driver tegra210_adx_driver = {

sound/soc/tegra/tegra210_ahub.c+7−4

 	unsigned int *item = uctl->value.enumerated.item;
 	unsigned int value = e->values[item[0]];
 	unsigned int i, bit_pos, reg_idx = 0, reg_val = 0;
+	int change = 0;
 	if (item[0] >= e->items)
 		return -EINVAL;
 		/* Update widget power if state has changed */
 		if (snd_soc_component_test_bits(cmpnt, update[i].reg,
-						update[i].mask, update[i].val))
+						update[i].mask,
-			snd_soc_dapm_mux_update_power(dapm, kctl, item[0], e,
+						update[i].val))
-						      &update[i]);
+			change |= snd_soc_dapm_mux_update_power(dapm, kctl,
+								item[0], e,
+								&update[i]);
 	}
-	return 0;
+	return change;
 }
 static struct snd_soc_dai_driver tegra210_ahub_dais[] = {

sound/soc/tegra/tegra210_amx.c+5−2

 	int reg = mc->reg;
 	int value = ucontrol->value.integer.value[0];
+	if (value == bytes_map[reg])
+		return 0;
 	if (value >= 0 && value <= 255) {
 		/* Update byte map and enable slot */
 		bytes_map[reg] = value;
 static const struct dev_pm_ops tegra210_amx_pm_ops = {
 	SET_RUNTIME_PM_OPS(tegra210_amx_runtime_suspend,
 			   tegra210_amx_runtime_resume, NULL)
-	SET_LATE_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
+	SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
-				     pm_runtime_force_resume)
+				pm_runtime_force_resume)
 };
 static struct platform_driver tegra210_amx_driver = {

sound/soc/tegra/tegra210_dmic.c+149−35

@@ -156,51 +156,162 @@ static int tegra210_dmic_hw_params(struct snd_pcm_substream *substream, · 155 unmodified lines
156	return 0;	156	return 0;
157	}	157	}
158		158
159	static int tegra210_dmic_get_control(struct snd_kcontrol *kcontrol,	159	static int tegra210_dmic_get_boost_gain(struct snd_kcontrol *kcontrol,
		160	struct snd_ctl_elem_value *ucontrol)
		161	{
		162	struct snd_soc_component *comp = snd_soc_kcontrol_component(kcontrol);
		163	struct tegra210_dmic *dmic = snd_soc_component_get_drvdata(comp);
		164
		165	ucontrol->value.integer.value[0] = dmic->boost_gain;
		166
		167	return 0;
		168	}
		169
		170	static int tegra210_dmic_put_boost_gain(struct snd_kcontrol *kcontrol,
		171	struct snd_ctl_elem_value *ucontrol)
		172	{
		173	struct snd_soc_component *comp = snd_soc_kcontrol_component(kcontrol);
		174	struct tegra210_dmic *dmic = snd_soc_component_get_drvdata(comp);
		175	int value = ucontrol->value.integer.value[0];
		176
		177	if (value == dmic->boost_gain)
		178	return 0;
		179
		180	dmic->boost_gain = value;
		181
		182	return 1;
		183	}
		184
		185	static int tegra210_dmic_get_ch_select(struct snd_kcontrol *kcontrol,
		186	struct snd_ctl_elem_value *ucontrol)
		187	{
		188	struct snd_soc_component *comp = snd_soc_kcontrol_component(kcontrol);
		189	struct tegra210_dmic *dmic = snd_soc_component_get_drvdata(comp);
		190
		191	ucontrol->value.enumerated.item[0] = dmic->ch_select;
		192
		193	return 0;
		194	}
		195
		196	static int tegra210_dmic_put_ch_select(struct snd_kcontrol *kcontrol,
		197	struct snd_ctl_elem_value *ucontrol)
		198	{
		199	struct snd_soc_component *comp = snd_soc_kcontrol_component(kcontrol);
		200	struct tegra210_dmic *dmic = snd_soc_component_get_drvdata(comp);
		201	unsigned int value = ucontrol->value.enumerated.item[0];
		202
		203	if (value == dmic->ch_select)
		204	return 0;
		205
		206	dmic->ch_select = value;
		207
		208	return 1;
		209	}
		210
		211	static int tegra210_dmic_get_mono_to_stereo(struct snd_kcontrol *kcontrol,
		212	struct snd_ctl_elem_value *ucontrol)
		213	{
		214	struct snd_soc_component *comp = snd_soc_kcontrol_component(kcontrol);
		215	struct tegra210_dmic *dmic = snd_soc_component_get_drvdata(comp);
		216
		217	ucontrol->value.enumerated.item[0] = dmic->mono_to_stereo;
		218
		219	return 0;
		220	}
		221
		222	static int tegra210_dmic_put_mono_to_stereo(struct snd_kcontrol *kcontrol,
		223	struct snd_ctl_elem_value *ucontrol)
		224	{
		225	struct snd_soc_component *comp = snd_soc_kcontrol_component(kcontrol);
		226	struct tegra210_dmic *dmic = snd_soc_component_get_drvdata(comp);
		227	unsigned int value = ucontrol->value.enumerated.item[0];
		228
		229	if (value == dmic->mono_to_stereo)
		230	return 0;
		231
		232	dmic->mono_to_stereo = value;
		233
		234	return 1;
		235	}
		236
		237	static int tegra210_dmic_get_stereo_to_mono(struct snd_kcontrol *kcontrol,
		238	struct snd_ctl_elem_value *ucontrol)
		239	{
		240	struct snd_soc_component *comp = snd_soc_kcontrol_component(kcontrol);
		241	struct tegra210_dmic *dmic = snd_soc_component_get_drvdata(comp);
		242
		243	ucontrol->value.enumerated.item[0] = dmic->stereo_to_mono;
		244
		245	return 0;
		246	}
		247
		248	static int tegra210_dmic_put_stereo_to_mono(struct snd_kcontrol *kcontrol,
		249	struct snd_ctl_elem_value *ucontrol)
		250	{
		251	struct snd_soc_component *comp = snd_soc_kcontrol_component(kcontrol);
		252	struct tegra210_dmic *dmic = snd_soc_component_get_drvdata(comp);
		253	unsigned int value = ucontrol->value.enumerated.item[0];
		254
		255	if (value == dmic->stereo_to_mono)
		256	return 0;
		257
		258	dmic->stereo_to_mono = value;
		259
		260	return 1;
		261	}
		262
		263	static int tegra210_dmic_get_osr_val(struct snd_kcontrol *kcontrol,
160	struct snd_ctl_elem_value *ucontrol)	264	struct snd_ctl_elem_value *ucontrol)
161	{	265	{
162	struct snd_soc_component *comp = snd_soc_kcontrol_component(kcontrol);	266	struct snd_soc_component *comp = snd_soc_kcontrol_component(kcontrol);
163	struct tegra210_dmic *dmic = snd_soc_component_get_drvdata(comp);	267	struct tegra210_dmic *dmic = snd_soc_component_get_drvdata(comp);
164		268
165	if (strstr(kcontrol->id.name, "Boost Gain Volume"))	269	ucontrol->value.enumerated.item[0] = dmic->osr_val;
166	ucontrol->value.integer.value[0] = dmic->boost_gain;
167	else if (strstr(kcontrol->id.name, "Channel Select"))
168	ucontrol->value.integer.value[0] = dmic->ch_select;
169	else if (strstr(kcontrol->id.name, "Mono To Stereo"))
170	ucontrol->value.integer.value[0] = dmic->mono_to_stereo;
171	else if (strstr(kcontrol->id.name, "Stereo To Mono"))
172	ucontrol->value.integer.value[0] = dmic->stereo_to_mono;
173	else if (strstr(kcontrol->id.name, "OSR Value"))
174	ucontrol->value.integer.value[0] = dmic->osr_val;
175	else if (strstr(kcontrol->id.name, "LR Polarity Select"))
176	ucontrol->value.integer.value[0] = dmic->lrsel;
177		270
178	return 0;	271	return 0;
179	}	272	}
180		273
181	static int tegra210_dmic_put_control(struct snd_kcontrol *kcontrol,	274	static int tegra210_dmic_put_osr_val(struct snd_kcontrol *kcontrol,
182	struct snd_ctl_elem_value *ucontrol)	275	struct snd_ctl_elem_value *ucontrol)
183	{	276	{
184	struct snd_soc_component *comp = snd_soc_kcontrol_component(kcontrol);	277	struct snd_soc_component *comp = snd_soc_kcontrol_component(kcontrol);
185	struct tegra210_dmic *dmic = snd_soc_component_get_drvdata(comp);	278	struct tegra210_dmic *dmic = snd_soc_component_get_drvdata(comp);
186	int value = ucontrol->value.integer.value[0];	279	unsigned int value = ucontrol->value.enumerated.item[0];
187		280
188	if (strstr(kcontrol->id.name, "Boost Gain Volume"))	281	if (value == dmic->osr_val)
189	dmic->boost_gain = value;	282	return 0;
190	else if (strstr(kcontrol->id.name, "Channel Select"))	283
191	dmic->ch_select = ucontrol->value.integer.value[0];	284	dmic->osr_val = value;
192	else if (strstr(kcontrol->id.name, "Mono To Stereo"))	285
193	dmic->mono_to_stereo = value;	286	return 1;
194	else if (strstr(kcontrol->id.name, "Stereo To Mono"))	287	}
195	dmic->stereo_to_mono = value;	288
196	else if (strstr(kcontrol->id.name, "OSR Value"))	289	static int tegra210_dmic_get_pol_sel(struct snd_kcontrol *kcontrol,
197	dmic->osr_val = value;	290	struct snd_ctl_elem_value *ucontrol)
198	else if (strstr(kcontrol->id.name, "LR Polarity Select"))	291	{
199	dmic->lrsel = value;	292	struct snd_soc_component *comp = snd_soc_kcontrol_component(kcontrol);
		293	struct tegra210_dmic *dmic = snd_soc_component_get_drvdata(comp);
		294
		295	ucontrol->value.enumerated.item[0] = dmic->lrsel;
200		296
201	return 0;	297	return 0;
202	}	298	}
203		299
		300	static int tegra210_dmic_put_pol_sel(struct snd_kcontrol *kcontrol,
		301	struct snd_ctl_elem_value *ucontrol)
		302	{
		303	struct snd_soc_component *comp = snd_soc_kcontrol_component(kcontrol);
		304	struct tegra210_dmic *dmic = snd_soc_component_get_drvdata(comp);
		305	unsigned int value = ucontrol->value.enumerated.item[0];
		306
		307	if (value == dmic->lrsel)
		308	return 0;
		309
		310	dmic->lrsel = value;
		311
		312	return 1;
		313	}
		314
204	static const struct snd_soc_dai_ops tegra210_dmic_dai_ops = {	315	static const struct snd_soc_dai_ops tegra210_dmic_dai_ops = {
205	.hw_params = tegra210_dmic_hw_params,	316	.hw_params = tegra210_dmic_hw_params,
206	};	317	};
@@ -287,19 +398,22 @@ static const struct soc_enum tegra210_dmic_lrsel_enum = · 80 unmodified lines
287		398
288	static const struct snd_kcontrol_new tegra210_dmic_controls[] = {	399	static const struct snd_kcontrol_new tegra210_dmic_controls[] = {
289	SOC_SINGLE_EXT("Boost Gain Volume", 0, 0, MAX_BOOST_GAIN, 0,	400	SOC_SINGLE_EXT("Boost Gain Volume", 0, 0, MAX_BOOST_GAIN, 0,
290	tegra210_dmic_get_control, tegra210_dmic_put_control),	401	tegra210_dmic_get_boost_gain,
		402	tegra210_dmic_put_boost_gain),
291	SOC_ENUM_EXT("Channel Select", tegra210_dmic_ch_enum,	403	SOC_ENUM_EXT("Channel Select", tegra210_dmic_ch_enum,
292	tegra210_dmic_get_control, tegra210_dmic_put_control),	404	tegra210_dmic_get_ch_select, tegra210_dmic_put_ch_select),
293	SOC_ENUM_EXT("Mono To Stereo",	405	SOC_ENUM_EXT("Mono To Stereo",
294	tegra210_dmic_mono_conv_enum, tegra210_dmic_get_control,	406	tegra210_dmic_mono_conv_enum,
295	tegra210_dmic_put_control),	407	tegra210_dmic_get_mono_to_stereo,
		408	tegra210_dmic_put_mono_to_stereo),
296	SOC_ENUM_EXT("Stereo To Mono",	409	SOC_ENUM_EXT("Stereo To Mono",
297	tegra210_dmic_stereo_conv_enum, tegra210_dmic_get_control,	410	tegra210_dmic_stereo_conv_enum,
298	tegra210_dmic_put_control),	411	tegra210_dmic_get_stereo_to_mono,
		412	tegra210_dmic_put_stereo_to_mono),
299	SOC_ENUM_EXT("OSR Value", tegra210_dmic_osr_enum,	413	SOC_ENUM_EXT("OSR Value", tegra210_dmic_osr_enum,
300	tegra210_dmic_get_control, tegra210_dmic_put_control),	414	tegra210_dmic_get_osr_val, tegra210_dmic_put_osr_val),
301	SOC_ENUM_EXT("LR Polarity Select", tegra210_dmic_lrsel_enum,	415	SOC_ENUM_EXT("LR Polarity Select", tegra210_dmic_lrsel_enum,
302	tegra210_dmic_get_control, tegra210_dmic_put_control),	416	tegra210_dmic_get_pol_sel, tegra210_dmic_put_pol_sel),
303	};	417	};
304		418
305	static const struct snd_soc_component_driver tegra210_dmic_compnt = {	419	static const struct snd_soc_component_driver tegra210_dmic_compnt = {

sound/soc/tegra/tegra210_i2s.c+226−70

@@ -302,85 +302,235 @@ static int tegra210_i2s_set_tdm_slot(struct snd_soc_dai *dai, · 301 unmodified lines
302	return 0;	302	return 0;
303	}	303	}
304		304
305	static int tegra210_i2s_set_dai_bclk_ratio(struct snd_soc_dai *dai,	305	static int tegra210_i2s_get_loopback(struct snd_kcontrol *kcontrol,
306	unsigned int ratio)	306	struct snd_ctl_elem_value *ucontrol)
307	{	307	{
308	struct tegra210_i2s *i2s = snd_soc_dai_get_drvdata(dai);	308	struct snd_soc_component *compnt = snd_soc_kcontrol_component(kcontrol);
		309	struct tegra210_i2s *i2s = snd_soc_component_get_drvdata(compnt);
309		310
310	i2s->bclk_ratio = ratio;	311	ucontrol->value.integer.value[0] = i2s->loopback;
311		312
312	return 0;	313	return 0;
313	}	314	}
314		315
315	static int tegra210_i2s_get_control(struct snd_kcontrol *kcontrol,	316	static int tegra210_i2s_put_loopback(struct snd_kcontrol *kcontrol,
316	struct snd_ctl_elem_value *ucontrol)	317	struct snd_ctl_elem_value *ucontrol)
		318	{
		319	struct snd_soc_component *compnt = snd_soc_kcontrol_component(kcontrol);
		320	struct tegra210_i2s *i2s = snd_soc_component_get_drvdata(compnt);
		321	int value = ucontrol->value.integer.value[0];
		322
		323	if (value == i2s->loopback)
		324	return 0;
		325
		326	i2s->loopback = value;
		327
		328	regmap_update_bits(i2s->regmap, TEGRA210_I2S_CTRL, I2S_CTRL_LPBK_MASK,
		329	i2s->loopback << I2S_CTRL_LPBK_SHIFT);
		330
		331	return 1;
		332	}
		333
		334	static int tegra210_i2s_get_fsync_width(struct snd_kcontrol *kcontrol,
		335	struct snd_ctl_elem_value *ucontrol)
317	{	336	{
318	struct snd_soc_component *compnt = snd_soc_kcontrol_component(kcontrol);	337	struct snd_soc_component *compnt = snd_soc_kcontrol_component(kcontrol);
319	struct tegra210_i2s *i2s = snd_soc_component_get_drvdata(compnt);	338	struct tegra210_i2s *i2s = snd_soc_component_get_drvdata(compnt);
320	long *uctl_val = &ucontrol->value.integer.value[0];	339
321		340	ucontrol->value.integer.value[0] = i2s->fsync_width;
322	if (strstr(kcontrol->id.name, "Loopback"))
323	*uctl_val = i2s->loopback;
324	else if (strstr(kcontrol->id.name, "FSYNC Width"))
325	*uctl_val = i2s->fsync_width;
326	else if (strstr(kcontrol->id.name, "Capture Stereo To Mono"))
327	*uctl_val = i2s->stereo_to_mono[I2S_TX_PATH];
328	else if (strstr(kcontrol->id.name, "Capture Mono To Stereo"))
329	*uctl_val = i2s->mono_to_stereo[I2S_TX_PATH];
330	else if (strstr(kcontrol->id.name, "Playback Stereo To Mono"))
331	*uctl_val = i2s->stereo_to_mono[I2S_RX_PATH];
332	else if (strstr(kcontrol->id.name, "Playback Mono To Stereo"))
333	*uctl_val = i2s->mono_to_stereo[I2S_RX_PATH];
334	else if (strstr(kcontrol->id.name, "Playback FIFO Threshold"))
335	*uctl_val = i2s->rx_fifo_th;
336	else if (strstr(kcontrol->id.name, "BCLK Ratio"))
337	*uctl_val = i2s->bclk_ratio;
338		341
339	return 0;	342	return 0;
340	}	343	}
341		344
342	static int tegra210_i2s_put_control(struct snd_kcontrol *kcontrol,	345	static int tegra210_i2s_put_fsync_width(struct snd_kcontrol *kcontrol,
343	struct snd_ctl_elem_value *ucontrol)	346	struct snd_ctl_elem_value *ucontrol)
344	{	347	{
345	struct snd_soc_component *compnt = snd_soc_kcontrol_component(kcontrol);	348	struct snd_soc_component *compnt = snd_soc_kcontrol_component(kcontrol);
346	struct tegra210_i2s *i2s = snd_soc_component_get_drvdata(compnt);	349	struct tegra210_i2s *i2s = snd_soc_component_get_drvdata(compnt);
347	int value = ucontrol->value.integer.value[0];	350	int value = ucontrol->value.integer.value[0];
348		351
349	if (strstr(kcontrol->id.name, "Loopback")) {	352	if (value == i2s->fsync_width)
350	i2s->loopback = value;	353	return 0;
351		354
352	regmap_update_bits(i2s->regmap, TEGRA210_I2S_CTRL,	355	i2s->fsync_width = value;
353	I2S_CTRL_LPBK_MASK,
354	i2s->loopback << I2S_CTRL_LPBK_SHIFT);
355		356
356	} else if (strstr(kcontrol->id.name, "FSYNC Width")) {	357	/*
357	/*	358	* Frame sync width is used only for FSYNC modes and not
358	* Frame sync width is used only for FSYNC modes and not	359	* applicable for LRCK modes. Reset value for this field is "0",
359	* applicable for LRCK modes. Reset value for this field is "0",	360	* which means the width is one bit clock wide.
360	* which means the width is one bit clock wide.	361	* The width requirement may depend on the codec and in such
361	* The width requirement may depend on the codec and in such	362	* cases mixer control is used to update custom values. A value
362	* cases mixer control is used to update custom values. A value	363	* of "N" here means, width is "N + 1" bit clock wide.
363	* of "N" here means, width is "N + 1" bit clock wide.	364	*/
364	*/	365	regmap_update_bits(i2s->regmap, TEGRA210_I2S_CTRL,
365	i2s->fsync_width = value;	366	I2S_CTRL_FSYNC_WIDTH_MASK,
366		367	i2s->fsync_width << I2S_FSYNC_WIDTH_SHIFT);
367	regmap_update_bits(i2s->regmap, TEGRA210_I2S_CTRL,	368
368	I2S_CTRL_FSYNC_WIDTH_MASK,	369	return 1;
369	i2s->fsync_width << I2S_FSYNC_WIDTH_SHIFT);	370	}
370		371
371	} else if (strstr(kcontrol->id.name, "Capture Stereo To Mono")) {	372	static int tegra210_i2s_cget_stereo_to_mono(struct snd_kcontrol *kcontrol,
372	i2s->stereo_to_mono[I2S_TX_PATH] = value;	373	struct snd_ctl_elem_value *ucontrol)
373	} else if (strstr(kcontrol->id.name, "Capture Mono To Stereo")) {	374	{
374	i2s->mono_to_stereo[I2S_TX_PATH] = value;	375	struct snd_soc_component *compnt = snd_soc_kcontrol_component(kcontrol);
375	} else if (strstr(kcontrol->id.name, "Playback Stereo To Mono")) {	376	struct tegra210_i2s *i2s = snd_soc_component_get_drvdata(compnt);
376	i2s->stereo_to_mono[I2S_RX_PATH] = value;	377
377	} else if (strstr(kcontrol->id.name, "Playback Mono To Stereo")) {	378	ucontrol->value.enumerated.item[0] = i2s->stereo_to_mono[I2S_TX_PATH];
378	i2s->mono_to_stereo[I2S_RX_PATH] = value;	379
379	} else if (strstr(kcontrol->id.name, "Playback FIFO Threshold")) {	380	return 0;
380	i2s->rx_fifo_th = value;	381	}
381	} else if (strstr(kcontrol->id.name, "BCLK Ratio")) {	382
382	i2s->bclk_ratio = value;	383	static int tegra210_i2s_cput_stereo_to_mono(struct snd_kcontrol *kcontrol,
383	}	384	struct snd_ctl_elem_value *ucontrol)
		385	{
		386	struct snd_soc_component *compnt = snd_soc_kcontrol_component(kcontrol);
		387	struct tegra210_i2s *i2s = snd_soc_component_get_drvdata(compnt);
		388	unsigned int value = ucontrol->value.enumerated.item[0];
		389
		390	if (value == i2s->stereo_to_mono[I2S_TX_PATH])
		391	return 0;
		392
		393	i2s->stereo_to_mono[I2S_TX_PATH] = value;
		394
		395	return 1;
		396	}
		397
		398	static int tegra210_i2s_cget_mono_to_stereo(struct snd_kcontrol *kcontrol,
		399	struct snd_ctl_elem_value *ucontrol)
		400	{
		401	struct snd_soc_component *compnt = snd_soc_kcontrol_component(kcontrol);
		402	struct tegra210_i2s *i2s = snd_soc_component_get_drvdata(compnt);
		403
		404	ucontrol->value.enumerated.item[0] = i2s->mono_to_stereo[I2S_TX_PATH];
		405
		406	return 0;
		407	}
		408
		409	static int tegra210_i2s_cput_mono_to_stereo(struct snd_kcontrol *kcontrol,
		410	struct snd_ctl_elem_value *ucontrol)
		411	{
		412	struct snd_soc_component *compnt = snd_soc_kcontrol_component(kcontrol);
		413	struct tegra210_i2s *i2s = snd_soc_component_get_drvdata(compnt);
		414	unsigned int value = ucontrol->value.enumerated.item[0];
		415
		416	if (value == i2s->mono_to_stereo[I2S_TX_PATH])
		417	return 0;
		418
		419	i2s->mono_to_stereo[I2S_TX_PATH] = value;
		420
		421	return 1;
		422	}
		423
		424	static int tegra210_i2s_pget_stereo_to_mono(struct snd_kcontrol *kcontrol,
		425	struct snd_ctl_elem_value *ucontrol)
		426	{
		427	struct snd_soc_component *compnt = snd_soc_kcontrol_component(kcontrol);
		428	struct tegra210_i2s *i2s = snd_soc_component_get_drvdata(compnt);
		429
		430	ucontrol->value.enumerated.item[0] = i2s->stereo_to_mono[I2S_RX_PATH];
		431
		432	return 0;
		433	}
		434
		435	static int tegra210_i2s_pput_stereo_to_mono(struct snd_kcontrol *kcontrol,
		436	struct snd_ctl_elem_value *ucontrol)
		437	{
		438	struct snd_soc_component *compnt = snd_soc_kcontrol_component(kcontrol);
		439	struct tegra210_i2s *i2s = snd_soc_component_get_drvdata(compnt);
		440	unsigned int value = ucontrol->value.enumerated.item[0];
		441
		442	if (value == i2s->stereo_to_mono[I2S_RX_PATH])
		443	return 0;
		444
		445	i2s->stereo_to_mono[I2S_RX_PATH] = value;
		446
		447	return 1;
		448	}
		449
		450	static int tegra210_i2s_pget_mono_to_stereo(struct snd_kcontrol *kcontrol,
		451	struct snd_ctl_elem_value *ucontrol)
		452	{
		453	struct snd_soc_component *compnt = snd_soc_kcontrol_component(kcontrol);
		454	struct tegra210_i2s *i2s = snd_soc_component_get_drvdata(compnt);
		455
		456	ucontrol->value.enumerated.item[0] = i2s->mono_to_stereo[I2S_RX_PATH];
		457
		458	return 0;
		459	}
		460
		461	static int tegra210_i2s_pput_mono_to_stereo(struct snd_kcontrol *kcontrol,
		462	struct snd_ctl_elem_value *ucontrol)
		463	{
		464	struct snd_soc_component *compnt = snd_soc_kcontrol_component(kcontrol);
		465	struct tegra210_i2s *i2s = snd_soc_component_get_drvdata(compnt);
		466	unsigned int value = ucontrol->value.enumerated.item[0];
		467
		468	if (value == i2s->mono_to_stereo[I2S_RX_PATH])
		469	return 0;
		470
		471	i2s->mono_to_stereo[I2S_RX_PATH] = value;
		472
		473	return 1;
		474	}
		475
		476	static int tegra210_i2s_pget_fifo_th(struct snd_kcontrol *kcontrol,
		477	struct snd_ctl_elem_value *ucontrol)
		478	{
		479	struct snd_soc_component *compnt = snd_soc_kcontrol_component(kcontrol);
		480	struct tegra210_i2s *i2s = snd_soc_component_get_drvdata(compnt);
		481
		482	ucontrol->value.integer.value[0] = i2s->rx_fifo_th;
		483
		484	return 0;
		485	}
		486
		487	static int tegra210_i2s_pput_fifo_th(struct snd_kcontrol *kcontrol,
		488	struct snd_ctl_elem_value *ucontrol)
		489	{
		490	struct snd_soc_component *compnt = snd_soc_kcontrol_component(kcontrol);
		491	struct tegra210_i2s *i2s = snd_soc_component_get_drvdata(compnt);
		492	int value = ucontrol->value.integer.value[0];
		493
		494	if (value == i2s->rx_fifo_th)
		495	return 0;
		496
		497	i2s->rx_fifo_th = value;
		498
		499	return 1;
		500	}
		501
		502	static int tegra210_i2s_get_bclk_ratio(struct snd_kcontrol *kcontrol,
		503	struct snd_ctl_elem_value *ucontrol)
		504	{
		505	struct snd_soc_component *compnt = snd_soc_kcontrol_component(kcontrol);
		506	struct tegra210_i2s *i2s = snd_soc_component_get_drvdata(compnt);
		507
		508	ucontrol->value.integer.value[0] = i2s->bclk_ratio;
		509
		510	return 0;
		511	}
		512
		513	static int tegra210_i2s_put_bclk_ratio(struct snd_kcontrol *kcontrol,
		514	struct snd_ctl_elem_value *ucontrol)
		515	{
		516	struct snd_soc_component *compnt = snd_soc_kcontrol_component(kcontrol);
		517	struct tegra210_i2s *i2s = snd_soc_component_get_drvdata(compnt);
		518	int value = ucontrol->value.integer.value[0];
		519
		520	if (value == i2s->bclk_ratio)
		521	return 0;
		522
		523	i2s->bclk_ratio = value;
		524
		525	return 1;
		526	}
		527
		528	static int tegra210_i2s_set_dai_bclk_ratio(struct snd_soc_dai *dai,
		529	unsigned int ratio)
		530	{
		531	struct tegra210_i2s *i2s = snd_soc_dai_get_drvdata(dai);
		532
		533	i2s->bclk_ratio = ratio;
384		534
385	return 0;	535	return 0;
386	}	536	}
@@ -598,22 +748,28 @@ static const struct soc_enum tegra210_i2s_stereo_conv_enum = · 211 unmodified lines
598	tegra210_i2s_stereo_conv_text);	748	tegra210_i2s_stereo_conv_text);
599		749
600	static const struct snd_kcontrol_new tegra210_i2s_controls[] = {	750	static const struct snd_kcontrol_new tegra210_i2s_controls[] = {
601	SOC_SINGLE_EXT("Loopback", 0, 0, 1, 0, tegra210_i2s_get_control,	751	SOC_SINGLE_EXT("Loopback", 0, 0, 1, 0, tegra210_i2s_get_loopback,
602	tegra210_i2s_put_control),	752	tegra210_i2s_put_loopback),
603	SOC_SINGLE_EXT("FSYNC Width", 0, 0, 255, 0, tegra210_i2s_get_control,	753	SOC_SINGLE_EXT("FSYNC Width", 0, 0, 255, 0,
604	tegra210_i2s_put_control),	754	tegra210_i2s_get_fsync_width,
		755	tegra210_i2s_put_fsync_width),
605	SOC_ENUM_EXT("Capture Stereo To Mono", tegra210_i2s_stereo_conv_enum,	756	SOC_ENUM_EXT("Capture Stereo To Mono", tegra210_i2s_stereo_conv_enum,
606	tegra210_i2s_get_control, tegra210_i2s_put_control),	757	tegra210_i2s_cget_stereo_to_mono,
		758	tegra210_i2s_cput_stereo_to_mono),
607	SOC_ENUM_EXT("Capture Mono To Stereo", tegra210_i2s_mono_conv_enum,	759	SOC_ENUM_EXT("Capture Mono To Stereo", tegra210_i2s_mono_conv_enum,
608	tegra210_i2s_get_control, tegra210_i2s_put_control),	760	tegra210_i2s_cget_mono_to_stereo,
		761	tegra210_i2s_cput_mono_to_stereo),
609	SOC_ENUM_EXT("Playback Stereo To Mono", tegra210_i2s_stereo_conv_enum,	762	SOC_ENUM_EXT("Playback Stereo To Mono", tegra210_i2s_stereo_conv_enum,
610	tegra210_i2s_get_control, tegra210_i2s_put_control),	763	tegra210_i2s_pget_mono_to_stereo,
		764	tegra210_i2s_pput_mono_to_stereo),
611	SOC_ENUM_EXT("Playback Mono To Stereo", tegra210_i2s_mono_conv_enum,	765	SOC_ENUM_EXT("Playback Mono To Stereo", tegra210_i2s_mono_conv_enum,
612	tegra210_i2s_get_control, tegra210_i2s_put_control),	766	tegra210_i2s_pget_stereo_to_mono,
		767	tegra210_i2s_pput_stereo_to_mono),
613	SOC_SINGLE_EXT("Playback FIFO Threshold", 0, 0, I2S_RX_FIFO_DEPTH - 1,	768	SOC_SINGLE_EXT("Playback FIFO Threshold", 0, 0, I2S_RX_FIFO_DEPTH - 1,
614	0, tegra210_i2s_get_control, tegra210_i2s_put_control),	769	0, tegra210_i2s_pget_fifo_th, tegra210_i2s_pput_fifo_th),
615	SOC_SINGLE_EXT("BCLK Ratio", 0, 0, INT_MAX, 0, tegra210_i2s_get_control,	770	SOC_SINGLE_EXT("BCLK Ratio", 0, 0, INT_MAX, 0,
616	tegra210_i2s_put_control),	771	tegra210_i2s_get_bclk_ratio,
		772	tegra210_i2s_put_bclk_ratio),
617	};	773	};
618		774
619	static const struct snd_soc_dapm_widget tegra210_i2s_widgets[] = {	775	static const struct snd_soc_dapm_widget tegra210_i2s_widgets[] = {

sound/soc/tegra/tegra210_mixer.c+21−9

 	return 0;
 }
-static int tegra210_mixer_put_gain(struct snd_kcontrol *kcontrol,
+static int tegra210_mixer_apply_gain(struct snd_kcontrol *kcontrol,
-				   struct snd_ctl_elem_value *ucontrol)
+				     struct snd_ctl_elem_value *ucontrol,
+				     bool instant_gain)
 {
 	struct soc_mixer_control *mc =
 		(struct soc_mixer_control *)kcontrol->private_value;
 	struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
 	struct tegra210_mixer *mixer = snd_soc_component_get_drvdata(cmpnt);
 	unsigned int reg = mc->reg, id;
-	bool instant_gain = false;
 	int err;
-	if (strstr(kcontrol->id.name, "Instant Gain Volume"))
-		instant_gain = true;
 	/* Save gain value for specific MIXER input */
 	id = (reg - TEGRA210_MIXER_GAIN_CFG_RAM_ADDR_0) /
 	     TEGRA210_MIXER_GAIN_CFG_RAM_ADDR_STRIDE;
+	if (mixer->gain_value[id] == ucontrol->value.integer.value[0])
+		return 0;
 	mixer->gain_value[id] = ucontrol->value.integer.value[0];
 	err = tegra210_mixer_configure_gain(cmpnt, id, instant_gain);
 	return 1;
 }
+static int tegra210_mixer_put_gain(struct snd_kcontrol *kcontrol,
+				   struct snd_ctl_elem_value *ucontrol)
+{
+	return tegra210_mixer_apply_gain(kcontrol, ucontrol, false);
+}
+static int tegra210_mixer_put_instant_gain(struct snd_kcontrol *kcontrol,
+					   struct snd_ctl_elem_value *ucontrol)
+{
+	return tegra210_mixer_apply_gain(kcontrol, ucontrol, true);
+}
 static int tegra210_mixer_set_audio_cif(struct tegra210_mixer *mixer,
 					struct snd_pcm_hw_params *params,
 					unsigned int reg,
 	SOC_SINGLE_EXT("RX" #id " Instant Gain Volume",		\
 		       MIXER_GAIN_CFG_RAM_ADDR((id) - 1), 0,	\
 		       0x20000, 0, tegra210_mixer_get_gain,	\
-		       tegra210_mixer_put_gain),
+		       tegra210_mixer_put_instant_gain),
 /* Volume controls for all MIXER inputs */
 static const struct snd_kcontrol_new tegra210_mixer_gain_ctls[] = {
 static const struct dev_pm_ops tegra210_mixer_pm_ops = {
 	SET_RUNTIME_PM_OPS(tegra210_mixer_runtime_suspend,
 			   tegra210_mixer_runtime_resume, NULL)
-	SET_LATE_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
+	SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
-				     pm_runtime_force_resume)
+				pm_runtime_force_resume)
 };
 static struct platform_driver tegra210_mixer_driver = {

sound/soc/tegra/tegra210_mvc.c+26−12

 	struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
 	struct tegra210_mvc *mvc = snd_soc_component_get_drvdata(cmpnt);
 	unsigned int value;
-	u8 mute_mask;
+	u8 new_mask, old_mask;
 	int err;
 	pm_runtime_get_sync(cmpnt->dev);
 	if (err < 0)
 		goto end;
-	mute_mask = ucontrol->value.integer.value[0];
+	regmap_read(mvc->regmap, TEGRA210_MVC_CTRL, &value);
+	old_mask = (value >> TEGRA210_MVC_MUTE_SHIFT) & TEGRA210_MUTE_MASK_EN;
+	new_mask = ucontrol->value.integer.value[0];
+	if (new_mask == old_mask) {
+		err = 0;
+		goto end;
+	}
 	err = regmap_update_bits(mvc->regmap, mc->reg,
 				 TEGRA210_MVC_MUTE_MASK,
-				 mute_mask << TEGRA210_MVC_MUTE_SHIFT);
+				 new_mask << TEGRA210_MVC_MUTE_SHIFT);
 	if (err < 0)
 		goto end;
-	return 1;
+	err = 1;
 end:
 	pm_runtime_put(cmpnt->dev);
 	unsigned int reg = mc->reg;
 	unsigned int value;
 	u8 chan;
-	int err;
+	int err, old_volume;
 	pm_runtime_get_sync(cmpnt->dev);
 		goto end;
 	chan = (reg - TEGRA210_MVC_TARGET_VOL) / REG_SIZE;
+	old_volume = mvc->volume[chan];
 	tegra210_mvc_conv_vol(mvc, chan,
 			      ucontrol->value.integer.value[0]);
+	if (mvc->volume[chan] == old_volume) {
+		err = 0;
+		goto end;
+	}
 	/* Configure init volume same as target volume */
 	regmap_write(mvc->regmap,
 		TEGRA210_MVC_REG_OFFSET(TEGRA210_MVC_INIT_VOL, chan),
 			   TEGRA210_MVC_VOLUME_SWITCH_MASK,
 			   TEGRA210_MVC_VOLUME_SWITCH_TRIGGER);
-	return 1;
+	err = 1;
 end:
 	pm_runtime_put(cmpnt->dev);
 	struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
 	struct tegra210_mvc *mvc = snd_soc_component_get_drvdata(cmpnt);
-	ucontrol->value.integer.value[0] = mvc->curve_type;
+	ucontrol->value.enumerated.item[0] = mvc->curve_type;
 	return 0;
 }
 {
 	struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
 	struct tegra210_mvc *mvc = snd_soc_component_get_drvdata(cmpnt);
-	int value;
+	unsigned int value;
 	regmap_read(mvc->regmap, TEGRA210_MVC_ENABLE, &value);
 	if (value & TEGRA210_MVC_EN) {
 		return -EINVAL;
 	}
-	if (mvc->curve_type == ucontrol->value.integer.value[0])
+	if (mvc->curve_type == ucontrol->value.enumerated.item[0])
 		return 0;
-	mvc->curve_type = ucontrol->value.integer.value[0];
+	mvc->curve_type = ucontrol->value.enumerated.item[0];
 	tegra210_mvc_reset_vol_settings(mvc, cmpnt->dev);
 static const struct dev_pm_ops tegra210_mvc_pm_ops = {
 	SET_RUNTIME_PM_OPS(tegra210_mvc_runtime_suspend,
 			   tegra210_mvc_runtime_resume, NULL)
-	SET_LATE_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
+	SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
-				     pm_runtime_force_resume)
+				pm_runtime_force_resume)
 };
 static struct platform_driver tegra210_mvc_driver = {

sound/soc/tegra/tegra210_sfc.c+96−31

@@ -3244,46 +3244,107 @@ static int tegra210_sfc_init(struct snd_soc_dapm_widget *w, · 3243 unmodified lines
3244	return tegra210_sfc_write_coeff_ram(cmpnt);	3244	return tegra210_sfc_write_coeff_ram(cmpnt);
3245	}	3245	}
3246		3246
3247	static int tegra210_sfc_get_control(struct snd_kcontrol *kcontrol,	3247	static int tegra210_sfc_iget_stereo_to_mono(struct snd_kcontrol *kcontrol,
3248	struct snd_ctl_elem_value *ucontrol)	3248	struct snd_ctl_elem_value *ucontrol)
3249	{	3249	{
3250	struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);	3250	struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
3251	struct tegra210_sfc *sfc = snd_soc_component_get_drvdata(cmpnt);	3251	struct tegra210_sfc *sfc = snd_soc_component_get_drvdata(cmpnt);
3252		3252
3253	if (strstr(kcontrol->id.name, "Input Stereo To Mono"))	3253	ucontrol->value.enumerated.item[0] = sfc->stereo_to_mono[SFC_RX_PATH];
3254	ucontrol->value.integer.value[0] =
3255	sfc->stereo_to_mono[SFC_RX_PATH];
3256	else if (strstr(kcontrol->id.name, "Input Mono To Stereo"))
3257	ucontrol->value.integer.value[0] =
3258	sfc->mono_to_stereo[SFC_RX_PATH];
3259	else if (strstr(kcontrol->id.name, "Output Stereo To Mono"))
3260	ucontrol->value.integer.value[0] =
3261	sfc->stereo_to_mono[SFC_TX_PATH];
3262	else if (strstr(kcontrol->id.name, "Output Mono To Stereo"))
3263	ucontrol->value.integer.value[0] =
3264	sfc->mono_to_stereo[SFC_TX_PATH];
3265		3254
3266	return 0;	3255	return 0;
3267	}	3256	}
3268		3257
3269	static int tegra210_sfc_put_control(struct snd_kcontrol *kcontrol,	3258	static int tegra210_sfc_iput_stereo_to_mono(struct snd_kcontrol *kcontrol,
3270	struct snd_ctl_elem_value *ucontrol)	3259	struct snd_ctl_elem_value *ucontrol)
3271	{	3260	{
3272	struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);	3261	struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
3273	struct tegra210_sfc *sfc = snd_soc_component_get_drvdata(cmpnt);	3262	struct tegra210_sfc *sfc = snd_soc_component_get_drvdata(cmpnt);
3274	int value = ucontrol->value.integer.value[0];	3263	unsigned int value = ucontrol->value.enumerated.item[0];
3275		3264
3276	if (strstr(kcontrol->id.name, "Input Stereo To Mono"))	3265	if (value == sfc->stereo_to_mono[SFC_RX_PATH])
3277	sfc->stereo_to_mono[SFC_RX_PATH] = value;	3266	return 0;
3278	else if (strstr(kcontrol->id.name, "Input Mono To Stereo"))	3267
3279	sfc->mono_to_stereo[SFC_RX_PATH] = value;	3268	sfc->stereo_to_mono[SFC_RX_PATH] = value;
3280	else if (strstr(kcontrol->id.name, "Output Stereo To Mono"))	3269
3281	sfc->stereo_to_mono[SFC_TX_PATH] = value;	3270	return 1;
3282	else if (strstr(kcontrol->id.name, "Output Mono To Stereo"))	3271	}
3283	sfc->mono_to_stereo[SFC_TX_PATH] = value;	3272
3284	else	3273	static int tegra210_sfc_iget_mono_to_stereo(struct snd_kcontrol *kcontrol,
		3274	struct snd_ctl_elem_value *ucontrol)
		3275	{
		3276	struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
		3277	struct tegra210_sfc *sfc = snd_soc_component_get_drvdata(cmpnt);
		3278
		3279	ucontrol->value.enumerated.item[0] = sfc->mono_to_stereo[SFC_RX_PATH];
		3280
		3281	return 0;
		3282	}
		3283
		3284	static int tegra210_sfc_iput_mono_to_stereo(struct snd_kcontrol *kcontrol,
		3285	struct snd_ctl_elem_value *ucontrol)
		3286	{
		3287	struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
		3288	struct tegra210_sfc *sfc = snd_soc_component_get_drvdata(cmpnt);
		3289	unsigned int value = ucontrol->value.enumerated.item[0];
		3290
		3291	if (value == sfc->mono_to_stereo[SFC_RX_PATH])
3285	return 0;	3292	return 0;
3286		3293
		3294	sfc->mono_to_stereo[SFC_RX_PATH] = value;
		3295
		3296	return 1;
		3297	}
		3298
		3299	static int tegra210_sfc_oget_stereo_to_mono(struct snd_kcontrol *kcontrol,
		3300	struct snd_ctl_elem_value *ucontrol)
		3301	{
		3302	struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
		3303	struct tegra210_sfc *sfc = snd_soc_component_get_drvdata(cmpnt);
		3304
		3305	ucontrol->value.enumerated.item[0] = sfc->stereo_to_mono[SFC_TX_PATH];
		3306
		3307	return 0;
		3308	}
		3309
		3310	static int tegra210_sfc_oput_stereo_to_mono(struct snd_kcontrol *kcontrol,
		3311	struct snd_ctl_elem_value *ucontrol)
		3312	{
		3313	struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
		3314	struct tegra210_sfc *sfc = snd_soc_component_get_drvdata(cmpnt);
		3315	unsigned int value = ucontrol->value.enumerated.item[0];
		3316
		3317	if (value == sfc->stereo_to_mono[SFC_TX_PATH])
		3318	return 0;
		3319
		3320	sfc->stereo_to_mono[SFC_TX_PATH] = value;
		3321
		3322	return 1;
		3323	}
		3324
		3325	static int tegra210_sfc_oget_mono_to_stereo(struct snd_kcontrol *kcontrol,
		3326	struct snd_ctl_elem_value *ucontrol)
		3327	{
		3328	struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
		3329	struct tegra210_sfc *sfc = snd_soc_component_get_drvdata(cmpnt);
		3330
		3331	ucontrol->value.enumerated.item[0] = sfc->mono_to_stereo[SFC_TX_PATH];
		3332
		3333	return 0;
		3334	}
		3335
		3336	static int tegra210_sfc_oput_mono_to_stereo(struct snd_kcontrol *kcontrol,
		3337	struct snd_ctl_elem_value *ucontrol)
		3338	{
		3339	struct snd_soc_component *cmpnt = snd_soc_kcontrol_component(kcontrol);
		3340	struct tegra210_sfc *sfc = snd_soc_component_get_drvdata(cmpnt);
		3341	unsigned int value = ucontrol->value.enumerated.item[0];
		3342
		3343	if (value == sfc->mono_to_stereo[SFC_TX_PATH])
		3344	return 0;
		3345
		3346	sfc->mono_to_stereo[SFC_TX_PATH] = value;
		3347
3287	return 1;	3348	return 1;
3288	}	3349	}
3289		3350
@@ -3384,13 +3445,17 @@ static const struct soc_enum tegra210_sfc_mono_conv_enum = · 94 unmodified lines
3384		3445
3385	static const struct snd_kcontrol_new tegra210_sfc_controls[] = {	3446	static const struct snd_kcontrol_new tegra210_sfc_controls[] = {
3386	SOC_ENUM_EXT("Input Stereo To Mono", tegra210_sfc_stereo_conv_enum,	3447	SOC_ENUM_EXT("Input Stereo To Mono", tegra210_sfc_stereo_conv_enum,
3387	tegra210_sfc_get_control, tegra210_sfc_put_control),	3448	tegra210_sfc_iget_stereo_to_mono,
		3449	tegra210_sfc_iput_stereo_to_mono),
3388	SOC_ENUM_EXT("Input Mono To Stereo", tegra210_sfc_mono_conv_enum,	3450	SOC_ENUM_EXT("Input Mono To Stereo", tegra210_sfc_mono_conv_enum,
3389	tegra210_sfc_get_control, tegra210_sfc_put_control),	3451	tegra210_sfc_iget_mono_to_stereo,
		3452	tegra210_sfc_iput_mono_to_stereo),
3390	SOC_ENUM_EXT("Output Stereo To Mono", tegra210_sfc_stereo_conv_enum,	3453	SOC_ENUM_EXT("Output Stereo To Mono", tegra210_sfc_stereo_conv_enum,
3391	tegra210_sfc_get_control, tegra210_sfc_put_control),	3454	tegra210_sfc_oget_stereo_to_mono,
		3455	tegra210_sfc_oput_stereo_to_mono),
3392	SOC_ENUM_EXT("Output Mono To Stereo", tegra210_sfc_mono_conv_enum,	3456	SOC_ENUM_EXT("Output Mono To Stereo", tegra210_sfc_mono_conv_enum,
3393	tegra210_sfc_get_control, tegra210_sfc_put_control),	3457	tegra210_sfc_oget_mono_to_stereo,
		3458	tegra210_sfc_oput_mono_to_stereo),
3394	};	3459	};
3395		3460
3396	static const struct snd_soc_component_driver tegra210_sfc_cmpnt = {	3461	static const struct snd_soc_component_driver tegra210_sfc_cmpnt = {
@@ -3529,8 +3594,8 @@ static int tegra210_sfc_platform_remove(struct platform_device *pdev) · 132 unmodified lines
3529	static const struct dev_pm_ops tegra210_sfc_pm_ops = {	3594	static const struct dev_pm_ops tegra210_sfc_pm_ops = {
3530	SET_RUNTIME_PM_OPS(tegra210_sfc_runtime_suspend,	3595	SET_RUNTIME_PM_OPS(tegra210_sfc_runtime_suspend,
3531	tegra210_sfc_runtime_resume, NULL)	3596	tegra210_sfc_runtime_resume, NULL)
3532	SET_LATE_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,	3597	SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
3533	pm_runtime_force_resume)	3598	pm_runtime_force_resume)
3534	};	3599	};
3535		3600
3536	static struct platform_driver tegra210_sfc_driver = {	3601	static struct platform_driver tegra210_sfc_driver = {

sound/usb/mixer_quirks.c+5−5

@@ -3016,11 +3016,11 @@ static const struct snd_djm_ctl snd_djm_ctls_750mk2[] = { · 3015 unmodified lines
3016		3016
3017		3017
3018	static const struct snd_djm_device snd_djm_devices[] = {	3018	static const struct snd_djm_device snd_djm_devices[] = {
3019	SND_DJM_DEVICE(250mk2),	3019	[SND_DJM_250MK2_IDX] = SND_DJM_DEVICE(250mk2),
3020	SND_DJM_DEVICE(750),	3020	[SND_DJM_750_IDX] = SND_DJM_DEVICE(750),
3021	SND_DJM_DEVICE(750mk2),	3021	[SND_DJM_850_IDX] = SND_DJM_DEVICE(850),
3022	SND_DJM_DEVICE(850),	3022	[SND_DJM_900NXS2_IDX] = SND_DJM_DEVICE(900nxs2),
3023	SND_DJM_DEVICE(900nxs2)	3023	[SND_DJM_750MK2_IDX] = SND_DJM_DEVICE(750mk2),
3024	};	3024	};
3025		3025
3026		3026

tools/bpf/resolve_btfids/main.c+5−3

 		int	 cnt;
 	};
 	int		 addr_cnt;
+	bool		 is_set;
 	Elf64_Addr	 addr[ADDR_CNT];
 };
 			 * in symbol's size, together with 'cnt' field hence
 			 * that - 1.
 			 */
-			if (id)
+			if (id) {
 				id->cnt = sym.st_size / sizeof(int) - 1;
+				id->is_set = true;
+			}
 		} else {
 			pr_err("FAILED unsupported prefix %s\n", prefix);
 			return -1;
 	int *ptr = data->d_buf;
 	int i;
-	if (!id->id) {
+	if (!id->id && !id->is_set)
 		pr_err("WARN: resolve_btfids: unresolved symbol %s\n", id->name);
-	}
 	for (i = 0; i < id->addr_cnt; i++) {
 		unsigned long addr = id->addr[i];

tools/build/Makefile.feature+0−1

@@ -48,7 +48,6 @@ FEATURE_TESTS_BASIC := \ · 47 unmodified lines
48	numa_num_possible_cpus \	48	numa_num_possible_cpus \
49	libperl \	49	libperl \
50	libpython \	50	libpython \
51	libpython-version \
52	libslang \	51	libslang \
53	libslang-include-subdir \	52	libslang-include-subdir \
54	libtraceevent \	53	libtraceevent \

tools/build/feature/Makefile+0−4

          test-numa_num_possible_cpus.bin        \
          test-libperl.bin                       \
          test-libpython.bin                     \
-         test-libpython-version.bin             \
          test-libslang.bin                      \
          test-libslang-include-subdir.bin       \
          test-libtraceevent.bin                 \
 $(OUTPUT)test-libpython.bin:
 	$(BUILD) $(FLAGS_PYTHON_EMBED)
-$(OUTPUT)test-libpython-version.bin:
-	$(BUILD)
 $(OUTPUT)test-libbfd.bin:
 	$(BUILD) -DPACKAGE='"perf"' -lbfd -ldl

tools/build/feature/test-all.c+0−5

 # include "test-libpython.c"
 #undef main
-#define main main_test_libpython_version
-# include "test-libpython-version.c"
-#undef main
 #define main main_test_libperl
 # include "test-libperl.c"
 #undef main
 int main(int argc, char *argv[])
 {
 	main_test_libpython();
-	main_test_libpython_version();
 	main_test_libperl();
 	main_test_hello();
 	main_test_libelf();

tools/build/feature/test-libpython-version.c+0−11

@@ -1,11 +0,0 @@
1	// SPDX-License-Identifier: GPL-2.0
2	#include <Python.h>
3
4	#if PY_VERSION_HEX >= 0x03000000
5	#error
6	#endif
7
8	int main(void)
9	{
10	return 0;
11	}

tools/include/linux/debug_locks.h+0−14

@@ -1,14 +0,0 @@
1	/* SPDX-License-Identifier: GPL-2.0 */
2	#ifndef _LIBLOCKDEP_DEBUG_LOCKS_H_
3	#define _LIBLOCKDEP_DEBUG_LOCKS_H_
4
5	#include <stddef.h>
6	#include <linux/compiler.h>
7	#include <asm/bug.h>
8
9	#define DEBUG_LOCKS_WARN_ON(x) WARN_ON(x)
10
11	extern bool debug_locks;
12	extern bool debug_locks_silent;
13
14	#endif

tools/include/linux/hardirq.h+0−12

@@ -1,12 +0,0 @@
1	/* SPDX-License-Identifier: GPL-2.0 */
2	#ifndef _LIBLOCKDEP_LINUX_HARDIRQ_H_
3	#define _LIBLOCKDEP_LINUX_HARDIRQ_H_
4
5	#define SOFTIRQ_BITS 0UL
6	#define HARDIRQ_BITS 0UL
7	#define SOFTIRQ_SHIFT 0UL
8	#define HARDIRQ_SHIFT 0UL
9	#define hardirq_count() 0UL
10	#define softirq_count() 0UL
11
12	#endif

tools/include/linux/irqflags.h+0−39

@@ -1,39 +0,0 @@
1	/* SPDX-License-Identifier: GPL-2.0 */
2	#ifndef _LIBLOCKDEP_LINUX_TRACE_IRQFLAGS_H_
3	#define _LIBLOCKDEP_LINUX_TRACE_IRQFLAGS_H_
4
5	# define lockdep_hardirq_context() 0
6	# define lockdep_softirq_context(p) 0
7	# define lockdep_hardirqs_enabled() 0
8	# define lockdep_softirqs_enabled(p) 0
9	# define lockdep_hardirq_enter() do { } while (0)
10	# define lockdep_hardirq_exit() do { } while (0)
11	# define lockdep_softirq_enter() do { } while (0)
12	# define lockdep_softirq_exit() do { } while (0)
13	# define INIT_TRACE_IRQFLAGS
14
15	# define stop_critical_timings() do { } while (0)
16	# define start_critical_timings() do { } while (0)
17
18	#define raw_local_irq_disable() do { } while (0)
19	#define raw_local_irq_enable() do { } while (0)
20	#define raw_local_irq_save(flags) ((flags) = 0)
21	#define raw_local_irq_restore(flags) ((void)(flags))
22	#define raw_local_save_flags(flags) ((flags) = 0)
23	#define raw_irqs_disabled_flags(flags) ((void)(flags))
24	#define raw_irqs_disabled() 0
25	#define raw_safe_halt()
26
27	#define local_irq_enable() do { } while (0)
28	#define local_irq_disable() do { } while (0)
29	#define local_irq_save(flags) ((flags) = 0)
30	#define local_irq_restore(flags) ((void)(flags))
31	#define local_save_flags(flags) ((flags) = 0)
32	#define irqs_disabled() (1)
33	#define irqs_disabled_flags(flags) ((void)(flags), 0)
34	#define safe_halt() do { } while (0)
35
36	#define trace_lock_release(x, y)
37	#define trace_lock_acquire(a, b, c, d, e, f, g)
38
39	#endif

tools/include/linux/kernel.h+1−21

 #include <assert.h>
 #include <linux/build_bug.h>
 #include <linux/compiler.h>
+#include <linux/math.h>
 #include <endian.h>
 #include <byteswap.h>
 #define UINT_MAX	(~0U)
 #endif
-#define DIV_ROUND_UP(n,d) (((n) + (d) - 1) / (d))
 #define PERF_ALIGN(x, a)	__PERF_ALIGN_MASK(x, (typeof(x))(a)-1)
 #define __PERF_ALIGN_MASK(x, mask)	(((x)+(mask))&~(mask))
 	_min1 < _min2 ? _min1 : _min2; })
 #endif
-#ifndef roundup
-#define roundup(x, y) (                                \
-{                                                      \
-	const typeof(y) __y = y;		       \
-	(((x) + (__y - 1)) / __y) * __y;	       \
-}                                                      \
-)
-#endif
 #ifndef BUG_ON
 #ifdef NDEBUG
 #define BUG_ON(cond) do { if (cond) {} } while (0)
 #define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]) + __must_be_array(arr))
-/*
- * This looks more complex than it should be. But we need to
- * get the type for the ~ right in round_down (it needs to be
- * as wide as the result!), and we want to evaluate the macro
- * arguments just once each.
- */
-#define __round_mask(x, y) ((__typeof__(x))((y)-1))
-#define round_up(x, y) ((((x)-1) | __round_mask(x, y))+1)
-#define round_down(x, y) ((x) & ~__round_mask(x, y))
 #define current_gfp_context(k) 0
 #define synchronize_rcu()

tools/include/linux/lockdep.h+0−72

@@ -1,72 +0,0 @@
1	/* SPDX-License-Identifier: GPL-2.0 */
2	#ifndef _LIBLOCKDEP_LOCKDEP_H_
3	#define _LIBLOCKDEP_LOCKDEP_H_
4
5	#include <sys/prctl.h>
6	#include <sys/syscall.h>
7	#include <string.h>
8	#include <limits.h>
9	#include <linux/utsname.h>
10	#include <linux/compiler.h>
11	#include <linux/export.h>
12	#include <linux/kern_levels.h>
13	#include <linux/err.h>
14	#include <linux/rcu.h>
15	#include <linux/list.h>
16	#include <linux/hardirq.h>
17	#include <unistd.h>
18
19	#define MAX_LOCK_DEPTH 63UL
20
21	#define asmlinkage
22	#define __visible
23
24	#include "../../../include/linux/lockdep.h"
25
26	struct task_struct {
27	u64 curr_chain_key;
28	int lockdep_depth;
29	unsigned int lockdep_recursion;
30	struct held_lock held_locks[MAX_LOCK_DEPTH];
31	gfp_t lockdep_reclaim_gfp;
32	int pid;
33	int state;
34	char comm[17];
35	};
36
37	#define TASK_RUNNING 0
38
39	extern struct task_struct *__curr(void);
40
41	#define current (__curr())
42
43	static inline int debug_locks_off(void)
44	{
45	return 1;
46	}
47
48	#define task_pid_nr(tsk) ((tsk)->pid)
49
50	#define KSYM_NAME_LEN 128
51	#define printk(...) dprintf(STDOUT_FILENO, __VA_ARGS__)
52	#define pr_err(format, ...) fprintf (stderr, format, ## __VA_ARGS__)
53	#define pr_warn pr_err
54	#define pr_cont pr_err
55
56	#define list_del_rcu list_del
57
58	#define atomic_t unsigned long
59	#define atomic_inc(x) ((*(x))++)
60
61	#define print_tainted() ""
62	#define static_obj(x) 1
63
64	#define debug_show_all_locks()
65	extern void debug_check_no_locks_held(void);
66
67	static __used bool __is_kernel_percpu_address(unsigned long addr, void *can_addr)
68	{
69	return false;
70	}
71
72	#endif

tools/include/linux/math.h+25−0

@@ -0,0 +1,25 @@
	1	#ifndef _TOOLS_MATH_H
	2	#define _TOOLS_MATH_H
	3
	4	/*
	5	* This looks more complex than it should be. But we need to
	6	* get the type for the ~ right in round_down (it needs to be
	7	* as wide as the result!), and we want to evaluate the macro
	8	* arguments just once each.
	9	*/
	10	#define __round_mask(x, y) ((__typeof__(x))((y)-1))
	11	#define round_up(x, y) ((((x)-1) \| __round_mask(x, y))+1)
	12	#define round_down(x, y) ((x) & ~__round_mask(x, y))
	13
	14	#define DIV_ROUND_UP(n,d) (((n) + (d) - 1) / (d))
	15
	16	#ifndef roundup
	17	#define roundup(x, y) ( \
	18	{ \
	19	const typeof(y) __y = y; \
	20	(((x) + (__y - 1)) / __y) * __y; \
	21	} \
	22	)
	23	#endif
	24
	25	#endif

tools/include/linux/proc_fs.h+0−4

@@ -1,4 +0,0 @@
1	#ifndef _TOOLS_INCLUDE_LINUX_PROC_FS_H
2	#define _TOOLS_INCLUDE_LINUX_PROC_FS_H
3
4	#endif /* _TOOLS_INCLUDE_LINUX_PROC_FS_H */

tools/include/linux/spinlock.h+0−2

@@ -37,6 +37,4 @@ static inline bool arch_spin_is_locked(arch_spinlock_t *mutex) · 36 unmodified lines
37	return true;	37	return true;
38	}	38	}
39		39
40	#include <linux/lockdep.h>
41
42	#endif	40	#endif

tools/include/linux/stacktrace.h+0−33

@@ -1,33 +0,0 @@
1	/* SPDX-License-Identifier: GPL-2.0 */
2	#ifndef _LIBLOCKDEP_LINUX_STACKTRACE_H_
3	#define _LIBLOCKDEP_LINUX_STACKTRACE_H_
4
5	#include <execinfo.h>
6
7	struct stack_trace {
8	unsigned int nr_entries, max_entries;
9	unsigned long *entries;
10	int skip;
11	};
12
13	static inline void print_stack_trace(struct stack_trace *trace, int spaces)
14	{
15	backtrace_symbols_fd((void **)trace->entries, trace->nr_entries, 1);
16	}
17
18	#define save_stack_trace(trace) \
19	((trace)->nr_entries = \
20	backtrace((void **)(trace)->entries, (trace)->max_entries))
21
22	static inline int dump_stack(void)
23	{
24	void *array[64];
25	size_t size;
26
27	size = backtrace(array, 64);
28	backtrace_symbols_fd(array, size, 1);
29
30	return 0;
31	}
32
33	#endif

tools/objtool/elf.c+1−0

@@ -375,6 +375,7 @@ static int read_symbols(struct elf *elf) · 374 unmodified lines
375	return -1;	375	return -1;
376	}	376	}
377	memset(sym, 0, sizeof(*sym));	377	memset(sym, 0, sizeof(*sym));
		378	INIT_LIST_HEAD(&sym->pv_target);
378	sym->alias = sym;	379	sym->alias = sym;
379		380
380	sym->idx = i;	381	sym->idx = i;

tools/objtool/objtool.c+4−0

 	    !strcmp(func->name, "_paravirt_ident_64"))
 		return;
+	/* already added this function */
+	if (!list_empty(&func->pv_target))
+		return;
 	list_add(&func->pv_target, &f->pv_ops[idx].targets);
 	f->pv_ops[idx].clean = false;
 }

tools/perf/Makefile.config+0−2

@@ -271,8 +271,6 @@ endif · 270 unmodified lines
271		271
272	FEATURE_CHECK_CFLAGS-libpython := $(PYTHON_EMBED_CCOPTS)	272	FEATURE_CHECK_CFLAGS-libpython := $(PYTHON_EMBED_CCOPTS)
273	FEATURE_CHECK_LDFLAGS-libpython := $(PYTHON_EMBED_LDOPTS)	273	FEATURE_CHECK_LDFLAGS-libpython := $(PYTHON_EMBED_LDOPTS)
274	FEATURE_CHECK_CFLAGS-libpython-version := $(PYTHON_EMBED_CCOPTS)
275	FEATURE_CHECK_LDFLAGS-libpython-version := $(PYTHON_EMBED_LDOPTS)
276		274
277	FEATURE_CHECK_LDFLAGS-libaio = -lrt	275	FEATURE_CHECK_LDFLAGS-libaio = -lrt
278		276

tools/perf/arch/powerpc/entry/syscalls/syscall.tbl+1−0

@@ -528,3 +528,4 @@ · 527 unmodified lines
528	446 common landlock_restrict_self sys_landlock_restrict_self	528	446 common landlock_restrict_self sys_landlock_restrict_self
529	# 447 reserved for memfd_secret	529	# 447 reserved for memfd_secret
530	448 common process_mrelease sys_process_mrelease	530	448 common process_mrelease sys_process_mrelease
		531	449 common futex_waitv sys_futex_waitv

tools/perf/arch/s390/entry/syscalls/syscall.tbl+1−0

@@ -451,3 +451,4 @@ · 450 unmodified lines
451	446 common landlock_restrict_self sys_landlock_restrict_self sys_landlock_restrict_self	451	446 common landlock_restrict_self sys_landlock_restrict_self sys_landlock_restrict_self
452	# 447 reserved for memfd_secret	452	# 447 reserved for memfd_secret
453	448 common process_mrelease sys_process_mrelease sys_process_mrelease	453	448 common process_mrelease sys_process_mrelease sys_process_mrelease
		454	449 common futex_waitv sys_futex_waitv sys_futex_waitv

tools/perf/bench/sched-messaging.c+0−4

 		snd_ctx->out_fds[i] = fds[1];
 		if (!thread_mode)
 			close(fds[0]);
-		free(ctx);
 	}
 	/* Now we have all the fds, fork the senders */
 		for (i = 0; i < num_fds; i++)
 			close(snd_ctx->out_fds[i]);
-	free(snd_ctx);
 	/* Return number of children to reap */
 	return num_fds * 2;
 }

tools/perf/builtin-inject.c+1−1

@@ -820,7 +820,7 @@ static int __cmd_inject(struct perf_inject *inject) · 819 unmodified lines
820	inject->tool.ordered_events = true;	820	inject->tool.ordered_events = true;
821	inject->tool.ordering_requires_timestamps = true;	821	inject->tool.ordering_requires_timestamps = true;
822	/* Allow space in the header for new attributes */	822	/* Allow space in the header for new attributes */
823	output_data_offset = 4096;	823	output_data_offset = roundup(8192 + session->header.data_offset, 4096);
824	if (inject->strip)	824	if (inject->strip)
825	strip_init(inject);	825	strip_init(inject);
826	}	826	}

tools/perf/tests/expr.c+3−1

@@ -169,7 +169,9 @@ static int test__expr(struct test_suite *t __maybe_unused, int subtest __maybe_u · 168 unmodified lines
169	TEST_ASSERT_VAL("#num_dies", expr__parse(&num_dies, ctx, "#num_dies") == 0);	169	TEST_ASSERT_VAL("#num_dies", expr__parse(&num_dies, ctx, "#num_dies") == 0);
170	TEST_ASSERT_VAL("#num_cores >= #num_dies", num_cores >= num_dies);	170	TEST_ASSERT_VAL("#num_cores >= #num_dies", num_cores >= num_dies);
171	TEST_ASSERT_VAL("#num_packages", expr__parse(&num_packages, ctx, "#num_packages") == 0);	171	TEST_ASSERT_VAL("#num_packages", expr__parse(&num_packages, ctx, "#num_packages") == 0);
172	TEST_ASSERT_VAL("#num_dies >= #num_packages", num_dies >= num_packages);	172
		173	if (num_dies) // Some platforms do not have CPU die support, for example s390
		174	TEST_ASSERT_VAL("#num_dies >= #num_packages", num_dies >= num_packages);
173		175
174	/*	176	/*
175	* Source count returns the number of events aggregating in a leader	177	* Source count returns the number of events aggregating in a leader

tools/perf/tests/parse-metric.c+1−0

@@ -109,6 +109,7 @@ static void load_runtime_stat(struct runtime_stat st, struct evlist evlist, · 108 unmodified lines
109	struct evsel *evsel;	109	struct evsel *evsel;
110	u64 count;	110	u64 count;
111		111
		112	perf_stat__reset_shadow_stats();
112	evlist__for_each_entry(evlist, evsel) {	113	evlist__for_each_entry(evlist, evsel) {
113	count = find_value(evsel->name, vals);	114	count = find_value(evsel->name, vals);
114	perf_stat__update_shadow_stats(evsel, count, 0, st);	115	perf_stat__update_shadow_stats(evsel, count, 0, st);

tools/perf/util/bpf_skel/bperf.h+0−14

@@ -1,14 +0,0 @@
1	// SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
2	// Copyright (c) 2021 Facebook
3
4	#ifndef __BPERF_STAT_H
5	#define __BPERF_STAT_H
6
7	typedef struct {
8	__uint(type, BPF_MAP_TYPE_PERCPU_ARRAY);
9	__uint(key_size, sizeof(__u32));
10	__uint(value_size, sizeof(struct bpf_perf_event_value));
11	__uint(max_entries, 1);
12	} reading_map;
13
14	#endif /* __BPERF_STAT_H */

tools/perf/util/bpf_skel/bperf_follower.bpf.c+14−5

 // SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
 // Copyright (c) 2021 Facebook
-#include <linux/bpf.h>
+#include "vmlinux.h"
-#include <linux/perf_event.h>
 #include <bpf/bpf_helpers.h>
 #include <bpf/bpf_tracing.h>
-#include "bperf.h"
 #include "bperf_u.h"
-reading_map diff_readings SEC(".maps");
+struct {
-reading_map accum_readings SEC(".maps");
+	__uint(type, BPF_MAP_TYPE_PERCPU_ARRAY);
+	__uint(key_size, sizeof(__u32));
+	__uint(value_size, sizeof(struct bpf_perf_event_value));
+	__uint(max_entries, 1);
+} diff_readings SEC(".maps");
+struct {
+	__uint(type, BPF_MAP_TYPE_PERCPU_ARRAY);
+	__uint(key_size, sizeof(__u32));
+	__uint(value_size, sizeof(struct bpf_perf_event_value));
+	__uint(max_entries, 1);
+} accum_readings SEC(".maps");
 struct {
 	__uint(type, BPF_MAP_TYPE_HASH);

tools/perf/util/bpf_skel/bperf_leader.bpf.c+14−5

 // SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
 // Copyright (c) 2021 Facebook
-#include <linux/bpf.h>
+#include "vmlinux.h"
-#include <linux/perf_event.h>
 #include <bpf/bpf_helpers.h>
 #include <bpf/bpf_tracing.h>
-#include "bperf.h"
 struct {
 	__uint(type, BPF_MAP_TYPE_PERF_EVENT_ARRAY);
 	__uint(map_flags, BPF_F_PRESERVE_ELEMS);
 } events SEC(".maps");
-reading_map prev_readings SEC(".maps");
+struct {
-reading_map diff_readings SEC(".maps");
+	__uint(type, BPF_MAP_TYPE_PERCPU_ARRAY);
+	__uint(key_size, sizeof(__u32));
+	__uint(value_size, sizeof(struct bpf_perf_event_value));
+	__uint(max_entries, 1);
+} prev_readings SEC(".maps");
+struct {
+	__uint(type, BPF_MAP_TYPE_PERCPU_ARRAY);
+	__uint(key_size, sizeof(__u32));
+	__uint(value_size, sizeof(struct bpf_perf_event_value));
+	__uint(max_entries, 1);
+} diff_readings SEC(".maps");
 SEC("raw_tp/sched_switch")
 int BPF_PROG(on_switch)

tools/perf/util/bpf_skel/bpf_prog_profiler.bpf.c+1−1

@@ -1,6 +1,6 @@
1	// SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)	1	// SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
2	// Copyright (c) 2020 Facebook	2	// Copyright (c) 2020 Facebook
3	#include <linux/bpf.h>	3	#include "vmlinux.h"
4	#include <bpf/bpf_helpers.h>	4	#include <bpf/bpf_helpers.h>
5	#include <bpf/bpf_tracing.h>	5	#include <bpf/bpf_tracing.h>
6		6

tools/perf/util/event.h+4−1

 /* perf sample has 16 bits size limit */
 #define PERF_SAMPLE_MAX_SIZE (1 << 16)
+/* number of register is bound by the number of bits in regs_dump::mask (64) */
+#define PERF_SAMPLE_REGS_CACHE_SIZE (8 * sizeof(u64))
 struct regs_dump {
 	u64 abi;
 	u64 mask;
 	u64 *regs;
 	/* Cached values/mask filled by first register access. */
-	u64 cache_regs[PERF_REGS_MAX];
+	u64 cache_regs[PERF_SAMPLE_REGS_CACHE_SIZE];
 	u64 cache_mask;
 };

tools/perf/util/header.c+10−5

@@ -2321,6 +2321,7 @@ out: · 2320 unmodified lines
2321	#define FEAT_PROCESS_STR_FUN(__feat, __feat_env) \	2321	#define FEAT_PROCESS_STR_FUN(__feat, __feat_env) \
2322	static int process_##__feat(struct feat_fd ff, void data __maybe_unused) \	2322	static int process_##__feat(struct feat_fd ff, void data __maybe_unused) \
2323	{\	2323	{\
		2324	free(ff->ph->env.__feat_env); \
2324	ff->ph->env.__feat_env = do_read_string(ff); \	2325	ff->ph->env.__feat_env = do_read_string(ff); \
2325	return ff->ph->env.__feat_env ? 0 : -ENOMEM; \	2326	return ff->ph->env.__feat_env ? 0 : -ENOMEM; \
2326	}	2327	}
@@ -4124,6 +4125,7 @@ int perf_event__process_feature(struct perf_session *session, · 1797 unmodified lines
4124	struct perf_record_header_feature fe = (struct perf_record_header_feature )event;	4125	struct perf_record_header_feature fe = (struct perf_record_header_feature )event;
4125	int type = fe->header.type;	4126	int type = fe->header.type;
4126	u64 feat = fe->feat_id;	4127	u64 feat = fe->feat_id;
		4128	int ret = 0;
4127		4129
4128	if (type < 0 \|\| type >= PERF_RECORD_HEADER_MAX) {	4130	if (type < 0 \|\| type >= PERF_RECORD_HEADER_MAX) {
4129	pr_warning("invalid record type %d in pipe-mode\n", type);	4131	pr_warning("invalid record type %d in pipe-mode\n", type);
@@ -4141,11 +4143,13 @@ int perf_event__process_feature(struct perf_session *session, · 11 unmodified lines
4141	ff.size = event->header.size - sizeof(*fe);	4143	ff.size = event->header.size - sizeof(*fe);
4142	ff.ph = &session->header;	4144	ff.ph = &session->header;
4143		4145
4144	if (feat_ops[feat].process(&ff, NULL))	4146	if (feat_ops[feat].process(&ff, NULL)) {
4145	return -1;	4147	ret = -1;
		4148	goto out;
		4149	}
4146		4150
4147	if (!feat_ops[feat].print \|\| !tool->show_feat_hdr)	4151	if (!feat_ops[feat].print \|\| !tool->show_feat_hdr)
4148	return 0;	4152	goto out;
4149		4153
4150	if (!feat_ops[feat].full_only \|\|	4154	if (!feat_ops[feat].full_only \|\|
4151	tool->show_feat_hdr >= SHOW_FEAT_HEADER_FULL_INFO) {	4155	tool->show_feat_hdr >= SHOW_FEAT_HEADER_FULL_INFO) {
@@ -4154,8 +4158,9 @@ int perf_event__process_feature(struct perf_session *session, · 2 unmodified lines
4154	fprintf(stdout, "# %s info available, use -I to display\n",	4158	fprintf(stdout, "# %s info available, use -I to display\n",
4155	feat_ops[feat].name);	4159	feat_ops[feat].name);
4156	}	4160	}
4157		4161	out:
4158	return 0;	4162	free_event_desc(ff.events);
		4163	return ret;
4159	}	4164	}
4160		4165
4161	size_t perf_event__fprintf_event_update(union perf_event event, FILE fp)	4166	size_t perf_event__fprintf_event_update(union perf_event event, FILE fp)

tools/perf/util/intel-pt-decoder/intel-pt-decoder.c+55−30

 static bool intel_pt_fup_event(struct intel_pt_decoder *decoder)
 {
+	enum intel_pt_sample_type type = decoder->state.type;
 	bool ret = false;
+	decoder->state.type &= ~INTEL_PT_BRANCH;
 	if (decoder->set_fup_tx_flags) {
 		decoder->set_fup_tx_flags = false;
 		decoder->tx_flags = decoder->fup_tx_flags;
-		decoder->state.type = INTEL_PT_TRANSACTION;
+		decoder->state.type |= INTEL_PT_TRANSACTION;
 		if (decoder->fup_tx_flags & INTEL_PT_ABORT_TX)
 			decoder->state.type |= INTEL_PT_BRANCH;
-		decoder->state.from_ip = decoder->ip;
-		decoder->state.to_ip = 0;
 		decoder->state.flags = decoder->fup_tx_flags;
-		return true;
+		ret = true;
 	}
 	if (decoder->set_fup_ptw) {
 		decoder->set_fup_ptw = false;
-		decoder->state.type = INTEL_PT_PTW;
+		decoder->state.type |= INTEL_PT_PTW;
 		decoder->state.flags |= INTEL_PT_FUP_IP;
-		decoder->state.from_ip = decoder->ip;
-		decoder->state.to_ip = 0;
 		decoder->state.ptw_payload = decoder->fup_ptw_payload;
-		return true;
+		ret = true;
 	}
 	if (decoder->set_fup_mwait) {
 		decoder->set_fup_mwait = false;
-		decoder->state.type = INTEL_PT_MWAIT_OP;
+		decoder->state.type |= INTEL_PT_MWAIT_OP;
-		decoder->state.from_ip = decoder->ip;
-		decoder->state.to_ip = 0;
 		decoder->state.mwait_payload = decoder->fup_mwait_payload;
 		ret = true;
 	}
 	if (decoder->set_fup_pwre) {
 		decoder->set_fup_pwre = false;
 		decoder->state.type |= INTEL_PT_PWR_ENTRY;
-		decoder->state.type &= ~INTEL_PT_BRANCH;
-		decoder->state.from_ip = decoder->ip;
-		decoder->state.to_ip = 0;
 		decoder->state.pwre_payload = decoder->fup_pwre_payload;
 		ret = true;
 	}
 	if (decoder->set_fup_exstop) {
 		decoder->set_fup_exstop = false;
 		decoder->state.type |= INTEL_PT_EX_STOP;
-		decoder->state.type &= ~INTEL_PT_BRANCH;
 		decoder->state.flags |= INTEL_PT_FUP_IP;
-		decoder->state.from_ip = decoder->ip;
-		decoder->state.to_ip = 0;
 		ret = true;
 	}
 	if (decoder->set_fup_bep) {
 		decoder->set_fup_bep = false;
 		decoder->state.type |= INTEL_PT_BLK_ITEMS;
-		decoder->state.type &= ~INTEL_PT_BRANCH;
+		ret = true;
+	}
+	if (decoder->overflow) {
+		decoder->overflow = false;
+		if (!ret && !decoder->pge) {
+			if (decoder->hop) {
+				decoder->state.type = 0;
+				decoder->pkt_state = INTEL_PT_STATE_RESAMPLE;
+			}
+			decoder->pge = true;
+			decoder->state.type |= INTEL_PT_BRANCH | INTEL_PT_TRACE_BEGIN;
+			decoder->state.from_ip = 0;
+			decoder->state.to_ip = decoder->ip;
+			return true;
+		}
+	}
+	if (ret) {
 		decoder->state.from_ip = decoder->ip;
 		decoder->state.to_ip = 0;
-		ret = true;
+	} else {
+		decoder->state.type = type;
 	}
 	return ret;
 }
 	intel_pt_clear_tx_flags(decoder);
 	intel_pt_set_nr(decoder);
 	decoder->timestamp_insn_cnt = 0;
-	decoder->pkt_state = INTEL_PT_STATE_ERR_RESYNC;
+	decoder->pkt_state = INTEL_PT_STATE_IN_SYNC;
+	decoder->state.from_ip = decoder->ip;
+	decoder->ip = 0;
+	decoder->pge = false;
+	decoder->set_fup_tx_flags = false;
+	decoder->set_fup_ptw = false;
+	decoder->set_fup_mwait = false;
+	decoder->set_fup_pwre = false;
+	decoder->set_fup_exstop = false;
+	decoder->set_fup_bep = false;
 	decoder->overflow = true;
 	return -EOVERFLOW;
 }
 /* Hop mode: Ignore TNT, do not walk code, but get ip from FUPs and TIPs */
 static int intel_pt_hop_trace(struct intel_pt_decoder *decoder, bool *no_tip, int *err)
 {
+	*err = 0;
 	/* Leap from PSB to PSB, getting ip from FUP within PSB+ */
 	if (decoder->leap && !decoder->in_psb && decoder->packet.type != INTEL_PT_PSB) {
 		*err = intel_pt_scan_for_psb(decoder);
 		return HOP_IGNORE;
 	case INTEL_PT_TIP_PGD:
+		decoder->pge = false;
 		if (!decoder->packet.count) {
 			intel_pt_set_nr(decoder);
 			return HOP_IGNORE;
 		if (!decoder->packet.count)
 			return HOP_IGNORE;
 		intel_pt_set_ip(decoder);
-		if (intel_pt_fup_event(decoder))
+		if (decoder->set_fup_mwait || decoder->set_fup_pwre)
-			return HOP_RETURN;
+			*no_tip = true;
-		if (!decoder->branch_enable)
+		if (!decoder->branch_enable || !decoder->pge)
 			*no_tip = true;
 		if (*no_tip) {
 			decoder->state.type = INTEL_PT_INSTRUCTION;
 			decoder->state.from_ip = decoder->ip;
 			decoder->state.to_ip = 0;
+			intel_pt_fup_event(decoder);
 			return HOP_RETURN;
 		}
+		intel_pt_fup_event(decoder);
+		decoder->state.type |= INTEL_PT_INSTRUCTION | INTEL_PT_BRANCH;
 		*err = intel_pt_walk_fup_tip(decoder);
-		if (!*err)
+		if (!*err && decoder->state.to_ip)
 			decoder->pkt_state = INTEL_PT_STATE_RESAMPLE;
 		return HOP_RETURN;
 {
 	struct intel_pt_psb_info data = { .fup = false };
-	if (!decoder->branch_enable || !decoder->pge)
+	if (!decoder->branch_enable)
 		return false;
 	intel_pt_pkt_lookahead(decoder, intel_pt_psb_lookahead_cb, &data);
 		if (err)
 			return err;
 next:
+		err = 0;
 		if (decoder->cyc_threshold) {
 			if (decoder->sample_cyc && last_packet_type != INTEL_PT_CYC)
 				decoder->sample_cyc = false;
 		case INTEL_PT_TIP_PGE: {
 			decoder->pge = true;
+			decoder->overflow = false;
 			intel_pt_mtc_cyc_cnt_pge(decoder);
 			intel_pt_set_nr(decoder);
 			if (decoder->packet.count == 0) {
 				break;
 			}
 			intel_pt_set_last_ip(decoder);
-			if (!decoder->branch_enable) {
+			if (!decoder->branch_enable || !decoder->pge) {
 				decoder->ip = decoder->last_ip;
 				if (intel_pt_fup_event(decoder))
 					return 0;
 	decoder->set_fup_pwre = false;
 	decoder->set_fup_exstop = false;
 	decoder->set_fup_bep = false;
+	decoder->overflow = false;
 	if (!decoder->branch_enable) {
 		decoder->pkt_state = INTEL_PT_STATE_IN_SYNC;
-		decoder->overflow = false;
 		decoder->state.type = 0; /* Do not have a sample */
 		return 0;
 	}
 		decoder->pkt_state = INTEL_PT_STATE_RESAMPLE;
 	else
 		decoder->pkt_state = INTEL_PT_STATE_IN_SYNC;
-	decoder->overflow = false;
 	decoder->state.from_ip = 0;
 	decoder->state.to_ip = decoder->ip;
 	}
 	decoder->have_last_ip = true;
-	decoder->pkt_state = INTEL_PT_STATE_NO_IP;
+	decoder->pkt_state = INTEL_PT_STATE_IN_SYNC;
 	err = intel_pt_walk_psb(decoder);
 	if (err)
 	if (err) {
 		decoder->state.err = intel_pt_ext_err(err);
-		decoder->state.from_ip = decoder->ip;
+		if (err != -EOVERFLOW)
+			decoder->state.from_ip = decoder->ip;
 		intel_pt_update_sample_time(decoder);
 		decoder->sample_tot_cyc_cnt = decoder->tot_cyc_cnt;
 		intel_pt_set_nr(decoder);

tools/perf/util/intel-pt.c+1−0

@@ -2565,6 +2565,7 @@ static int intel_pt_run_decoder(struct intel_pt_queue ptq, u64 timestamp) · 2564 unmodified lines
2565	ptq->sync_switch = false;	2565	ptq->sync_switch = false;
2566	intel_pt_next_tid(pt, ptq);	2566	intel_pt_next_tid(pt, ptq);
2567	}	2567	}
		2568	ptq->timestamp = state->est_timestamp;
2568	if (pt->synth_opts.errors) {	2569	if (pt->synth_opts.errors) {
2569	err = intel_ptq_synth_error(ptq, state);	2570	err = intel_ptq_synth_error(ptq, state);
2570	if (err)	2571	if (err)

tools/perf/util/perf_regs.c+3−0

@@ -25,6 +25,9 @@ int perf_reg_value(u64 valp, struct regs_dump regs, int id) · 24 unmodified lines
25	int i, idx = 0;	25	int i, idx = 0;
26	u64 mask = regs->mask;	26	u64 mask = regs->mask;
27		27
		28	if ((u64)id >= PERF_SAMPLE_REGS_CACHE_SIZE)
		29	return -EINVAL;
		30
28	if (regs->cache_mask & (1ULL << id))	31	if (regs->cache_mask & (1ULL << id))
29	goto out;	32	goto out;
30		33

tools/perf/util/python.c+1−1

@@ -461,7 +461,7 @@ get_tracepoint_field(struct pyrf_event pevent, PyObject attr_name) · 460 unmodified lines
461	struct tep_event *tp_format;	461	struct tep_event *tp_format;
462		462
463	tp_format = trace_event__tp_format_id(evsel->core.attr.config);	463	tp_format = trace_event__tp_format_id(evsel->core.attr.config);
464	if (!tp_format)	464	if (IS_ERR_OR_NULL(tp_format))
465	return NULL;	465	return NULL;
466		466
467	evsel->tp_format = tp_format;	467	evsel->tp_format = tp_format;

tools/perf/util/smt.c+1−1

@@ -15,7 +15,7 @@ int smt_on(void) · 14 unmodified lines
15	if (cached)	15	if (cached)
16	return cached_result;	16	return cached_result;
17		17
18	if (sysfs__read_int("devices/system/cpu/smt/active", &cached_result) > 0)	18	if (sysfs__read_int("devices/system/cpu/smt/active", &cached_result) >= 0)
19	goto done;	19	goto done;
20		20
21	ncpu = sysconf(_SC_NPROCESSORS_CONF);	21	ncpu = sysconf(_SC_NPROCESSORS_CONF);

tools/power/acpi/Makefile.config+1−0

@@ -69,6 +69,7 @@ KERNEL_INCLUDE := $(OUTPUT)include · 68 unmodified lines
69	ACPICA_INCLUDE := $(srctree)/../../../drivers/acpi/acpica	69	ACPICA_INCLUDE := $(srctree)/../../../drivers/acpi/acpica
70	CFLAGS += -D_LINUX -I$(KERNEL_INCLUDE) -I$(ACPICA_INCLUDE)	70	CFLAGS += -D_LINUX -I$(KERNEL_INCLUDE) -I$(ACPICA_INCLUDE)
71	CFLAGS += $(WARNINGS)	71	CFLAGS += $(WARNINGS)
		72	MKDIR = mkdir
72		73
73	ifeq ($(strip $(V)),false)	74	ifeq ($(strip $(V)),false)
74	QUIET=@	75	QUIET=@

tools/power/acpi/Makefile.rules+1−0

@@ -21,6 +21,7 @@ $(KERNEL_INCLUDE): · 20 unmodified lines
21		21
22	$(objdir)%.o: %.c $(KERNEL_INCLUDE)	22	$(objdir)%.o: %.c $(KERNEL_INCLUDE)
23	$(ECHO) " CC " $(subst $(OUTPUT),,$@)	23	$(ECHO) " CC " $(subst $(OUTPUT),,$@)
		24	$(QUIET) $(MKDIR) -p $(objdir) 2>/dev/null
24	$(QUIET) $(CC) -c $(CFLAGS) -o $@ $<	25	$(QUIET) $(CC) -c $(CFLAGS) -o $@ $<
25		26
26	all: $(OUTPUT)$(TOOL)	27	all: $(OUTPUT)$(TOOL)

tools/testing/radix-tree/linux/lockdep.h+3−0

@@ -1,5 +1,8 @@
1	#ifndef _LINUX_LOCKDEP_H	1	#ifndef _LINUX_LOCKDEP_H
2	#define _LINUX_LOCKDEP_H	2	#define _LINUX_LOCKDEP_H
		3
		4	#include <linux/spinlock.h>
		5
3	struct lock_class_key {	6	struct lock_class_key {
4	unsigned int a;	7	unsigned int a;
5	};	8	};

tools/testing/selftests/bpf/verifier/xdp_direct_packet_access.c+600−32

@@ -35,7 +35,7 @@ · 34 unmodified lines
35	.prog_type = BPF_PROG_TYPE_XDP,	35	.prog_type = BPF_PROG_TYPE_XDP,
36	},	36	},
37	{	37	{
38	"XDP pkt read, pkt_data' > pkt_end, good access",	38	"XDP pkt read, pkt_data' > pkt_end, corner case, good access",
39	.insns = {	39	.insns = {
40	BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),	40	BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
41	BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,	41	BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
@@ -87,6 +87,41 @@ · 45 unmodified lines
87	.prog_type = BPF_PROG_TYPE_XDP,	87	.prog_type = BPF_PROG_TYPE_XDP,
88	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,	88	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
89	},	89	},
		90	{
		91	"XDP pkt read, pkt_data' > pkt_end, corner case +1, good access",
		92	.insns = {
		93	BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
		94	BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
		95	offsetof(struct xdp_md, data_end)),
		96	BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
		97	BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 9),
		98	BPF_JMP_REG(BPF_JGT, BPF_REG_1, BPF_REG_3, 1),
		99	BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -9),
		100	BPF_MOV64_IMM(BPF_REG_0, 0),
		101	BPF_EXIT_INSN(),
		102	},
		103	.result = ACCEPT,
		104	.prog_type = BPF_PROG_TYPE_XDP,
		105	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
		106	},
		107	{
		108	"XDP pkt read, pkt_data' > pkt_end, corner case -1, bad access",
		109	.insns = {
		110	BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
		111	BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
		112	offsetof(struct xdp_md, data_end)),
		113	BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
		114	BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 7),
		115	BPF_JMP_REG(BPF_JGT, BPF_REG_1, BPF_REG_3, 1),
		116	BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -7),
		117	BPF_MOV64_IMM(BPF_REG_0, 0),
		118	BPF_EXIT_INSN(),
		119	},
		120	.errstr = "R1 offset is outside of the packet",
		121	.result = REJECT,
		122	.prog_type = BPF_PROG_TYPE_XDP,
		123	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
		124	},
90	{	125	{
91	"XDP pkt read, pkt_end > pkt_data', good access",	126	"XDP pkt read, pkt_end > pkt_data', good access",
92	.insns = {	127	.insns = {
@@ -106,16 +141,16 @@ · 13 unmodified lines
106	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,	141	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
107	},	142	},
108	{	143	{
109	"XDP pkt read, pkt_end > pkt_data', bad access 1",	144	"XDP pkt read, pkt_end > pkt_data', corner case -1, bad access",
110	.insns = {	145	.insns = {
111	BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),	146	BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
112	BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,	147	BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
113	offsetof(struct xdp_md, data_end)),	148	offsetof(struct xdp_md, data_end)),
114	BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),	149	BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
115	BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),	150	BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 6),
116	BPF_JMP_REG(BPF_JGT, BPF_REG_3, BPF_REG_1, 1),	151	BPF_JMP_REG(BPF_JGT, BPF_REG_3, BPF_REG_1, 1),
117	BPF_JMP_IMM(BPF_JA, 0, 0, 1),	152	BPF_JMP_IMM(BPF_JA, 0, 0, 1),
118	BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8),	153	BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -6),
119	BPF_MOV64_IMM(BPF_REG_0, 0),	154	BPF_MOV64_IMM(BPF_REG_0, 0),
120	BPF_EXIT_INSN(),	155	BPF_EXIT_INSN(),
121	},	156	},
@@ -142,6 +177,42 @@ · 20 unmodified lines
142	.prog_type = BPF_PROG_TYPE_XDP,	177	.prog_type = BPF_PROG_TYPE_XDP,
143	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,	178	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
144	},	179	},
		180	{
		181	"XDP pkt read, pkt_end > pkt_data', corner case, good access",
		182	.insns = {
		183	BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
		184	BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
		185	offsetof(struct xdp_md, data_end)),
		186	BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
		187	BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 7),
		188	BPF_JMP_REG(BPF_JGT, BPF_REG_3, BPF_REG_1, 1),
		189	BPF_JMP_IMM(BPF_JA, 0, 0, 1),
		190	BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -7),
		191	BPF_MOV64_IMM(BPF_REG_0, 0),
		192	BPF_EXIT_INSN(),
		193	},
		194	.result = ACCEPT,
		195	.prog_type = BPF_PROG_TYPE_XDP,
		196	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
		197	},
		198	{
		199	"XDP pkt read, pkt_end > pkt_data', corner case +1, good access",
		200	.insns = {
		201	BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
		202	BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
		203	offsetof(struct xdp_md, data_end)),
		204	BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
		205	BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),
		206	BPF_JMP_REG(BPF_JGT, BPF_REG_3, BPF_REG_1, 1),
		207	BPF_JMP_IMM(BPF_JA, 0, 0, 1),
		208	BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8),
		209	BPF_MOV64_IMM(BPF_REG_0, 0),
		210	BPF_EXIT_INSN(),
		211	},
		212	.result = ACCEPT,
		213	.prog_type = BPF_PROG_TYPE_XDP,
		214	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
		215	},
145	{	216	{
146	"XDP pkt read, pkt_data' < pkt_end, good access",	217	"XDP pkt read, pkt_data' < pkt_end, good access",
147	.insns = {	218	.insns = {
@@ -161,16 +232,16 @@ · 13 unmodified lines
161	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,	232	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
162	},	233	},
163	{	234	{
164	"XDP pkt read, pkt_data' < pkt_end, bad access 1",	235	"XDP pkt read, pkt_data' < pkt_end, corner case -1, bad access",
165	.insns = {	236	.insns = {
166	BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),	237	BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
167	BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,	238	BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
168	offsetof(struct xdp_md, data_end)),	239	offsetof(struct xdp_md, data_end)),
169	BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),	240	BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
170	BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),	241	BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 6),
171	BPF_JMP_REG(BPF_JLT, BPF_REG_1, BPF_REG_3, 1),	242	BPF_JMP_REG(BPF_JLT, BPF_REG_1, BPF_REG_3, 1),
172	BPF_JMP_IMM(BPF_JA, 0, 0, 1),	243	BPF_JMP_IMM(BPF_JA, 0, 0, 1),
173	BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8),	244	BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -6),
174	BPF_MOV64_IMM(BPF_REG_0, 0),	245	BPF_MOV64_IMM(BPF_REG_0, 0),
175	BPF_EXIT_INSN(),	246	BPF_EXIT_INSN(),
176	},	247	},
@@ -198,7 +269,43 @@ · 21 unmodified lines
198	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,	269	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
199	},	270	},
200	{	271	{
201	"XDP pkt read, pkt_end < pkt_data', good access",	272	"XDP pkt read, pkt_data' < pkt_end, corner case, good access",
		273	.insns = {
		274	BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
		275	BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
		276	offsetof(struct xdp_md, data_end)),
		277	BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
		278	BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 7),
		279	BPF_JMP_REG(BPF_JLT, BPF_REG_1, BPF_REG_3, 1),
		280	BPF_JMP_IMM(BPF_JA, 0, 0, 1),
		281	BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -7),
		282	BPF_MOV64_IMM(BPF_REG_0, 0),
		283	BPF_EXIT_INSN(),
		284	},
		285	.result = ACCEPT,
		286	.prog_type = BPF_PROG_TYPE_XDP,
		287	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
		288	},
		289	{
		290	"XDP pkt read, pkt_data' < pkt_end, corner case +1, good access",
		291	.insns = {
		292	BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
		293	BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
		294	offsetof(struct xdp_md, data_end)),
		295	BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
		296	BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),
		297	BPF_JMP_REG(BPF_JLT, BPF_REG_1, BPF_REG_3, 1),
		298	BPF_JMP_IMM(BPF_JA, 0, 0, 1),
		299	BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8),
		300	BPF_MOV64_IMM(BPF_REG_0, 0),
		301	BPF_EXIT_INSN(),
		302	},
		303	.result = ACCEPT,
		304	.prog_type = BPF_PROG_TYPE_XDP,
		305	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
		306	},
		307	{
		308	"XDP pkt read, pkt_end < pkt_data', corner case, good access",
202	.insns = {	309	.insns = {
203	BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),	310	BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
204	BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,	311	BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
@@ -250,6 +357,41 @@ · 45 unmodified lines
250	.prog_type = BPF_PROG_TYPE_XDP,	357	.prog_type = BPF_PROG_TYPE_XDP,
251	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,	358	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
252	},	359	},
		360	{
		361	"XDP pkt read, pkt_end < pkt_data', corner case +1, good access",
		362	.insns = {
		363	BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
		364	BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
		365	offsetof(struct xdp_md, data_end)),
		366	BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
		367	BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 9),
		368	BPF_JMP_REG(BPF_JLT, BPF_REG_3, BPF_REG_1, 1),
		369	BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -9),
		370	BPF_MOV64_IMM(BPF_REG_0, 0),
		371	BPF_EXIT_INSN(),
		372	},
		373	.result = ACCEPT,
		374	.prog_type = BPF_PROG_TYPE_XDP,
		375	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
		376	},
		377	{
		378	"XDP pkt read, pkt_end < pkt_data', corner case -1, bad access",
		379	.insns = {
		380	BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
		381	BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
		382	offsetof(struct xdp_md, data_end)),
		383	BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
		384	BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 7),
		385	BPF_JMP_REG(BPF_JLT, BPF_REG_3, BPF_REG_1, 1),
		386	BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -7),
		387	BPF_MOV64_IMM(BPF_REG_0, 0),
		388	BPF_EXIT_INSN(),
		389	},
		390	.errstr = "R1 offset is outside of the packet",
		391	.result = REJECT,
		392	.prog_type = BPF_PROG_TYPE_XDP,
		393	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
		394	},
253	{	395	{
254	"XDP pkt read, pkt_data' >= pkt_end, good access",	396	"XDP pkt read, pkt_data' >= pkt_end, good access",
255	.insns = {	397	.insns = {
@@ -268,15 +410,15 @@ · 12 unmodified lines
268	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,	410	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
269	},	411	},
270	{	412	{
271	"XDP pkt read, pkt_data' >= pkt_end, bad access 1",	413	"XDP pkt read, pkt_data' >= pkt_end, corner case -1, bad access",
272	.insns = {	414	.insns = {
273	BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),	415	BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
274	BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,	416	BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
275	offsetof(struct xdp_md, data_end)),	417	offsetof(struct xdp_md, data_end)),
276	BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),	418	BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
277	BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),	419	BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 6),
278	BPF_JMP_REG(BPF_JGE, BPF_REG_1, BPF_REG_3, 1),	420	BPF_JMP_REG(BPF_JGE, BPF_REG_1, BPF_REG_3, 1),
279	BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8),	421	BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -6),
280	BPF_MOV64_IMM(BPF_REG_0, 0),	422	BPF_MOV64_IMM(BPF_REG_0, 0),
281	BPF_EXIT_INSN(),	423	BPF_EXIT_INSN(),
282	},	424	},
@@ -304,7 +446,41 @@ · 21 unmodified lines
304	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,	446	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
305	},	447	},
306	{	448	{
307	"XDP pkt read, pkt_end >= pkt_data', good access",	449	"XDP pkt read, pkt_data' >= pkt_end, corner case, good access",
		450	.insns = {
		451	BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
		452	BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
		453	offsetof(struct xdp_md, data_end)),
		454	BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
		455	BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 7),
		456	BPF_JMP_REG(BPF_JGE, BPF_REG_1, BPF_REG_3, 1),
		457	BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -7),
		458	BPF_MOV64_IMM(BPF_REG_0, 0),
		459	BPF_EXIT_INSN(),
		460	},
		461	.result = ACCEPT,
		462	.prog_type = BPF_PROG_TYPE_XDP,
		463	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
		464	},
		465	{
		466	"XDP pkt read, pkt_data' >= pkt_end, corner case +1, good access",
		467	.insns = {
		468	BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
		469	BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
		470	offsetof(struct xdp_md, data_end)),
		471	BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
		472	BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),
		473	BPF_JMP_REG(BPF_JGE, BPF_REG_1, BPF_REG_3, 1),
		474	BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8),
		475	BPF_MOV64_IMM(BPF_REG_0, 0),
		476	BPF_EXIT_INSN(),
		477	},
		478	.result = ACCEPT,
		479	.prog_type = BPF_PROG_TYPE_XDP,
		480	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
		481	},
		482	{
		483	"XDP pkt read, pkt_end >= pkt_data', corner case, good access",
308	.insns = {	484	.insns = {
309	BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),	485	BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
310	BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,	486	BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
@@ -359,7 +535,44 @@ · 48 unmodified lines
359	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,	535	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
360	},	536	},
361	{	537	{
362	"XDP pkt read, pkt_data' <= pkt_end, good access",	538	"XDP pkt read, pkt_end >= pkt_data', corner case +1, good access",
		539	.insns = {
		540	BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
		541	BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
		542	offsetof(struct xdp_md, data_end)),
		543	BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
		544	BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 9),
		545	BPF_JMP_REG(BPF_JGE, BPF_REG_3, BPF_REG_1, 1),
		546	BPF_JMP_IMM(BPF_JA, 0, 0, 1),
		547	BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -9),
		548	BPF_MOV64_IMM(BPF_REG_0, 0),
		549	BPF_EXIT_INSN(),
		550	},
		551	.result = ACCEPT,
		552	.prog_type = BPF_PROG_TYPE_XDP,
		553	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
		554	},
		555	{
		556	"XDP pkt read, pkt_end >= pkt_data', corner case -1, bad access",
		557	.insns = {
		558	BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
		559	BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
		560	offsetof(struct xdp_md, data_end)),
		561	BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
		562	BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 7),
		563	BPF_JMP_REG(BPF_JGE, BPF_REG_3, BPF_REG_1, 1),
		564	BPF_JMP_IMM(BPF_JA, 0, 0, 1),
		565	BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -7),
		566	BPF_MOV64_IMM(BPF_REG_0, 0),
		567	BPF_EXIT_INSN(),
		568	},
		569	.errstr = "R1 offset is outside of the packet",
		570	.result = REJECT,
		571	.prog_type = BPF_PROG_TYPE_XDP,
		572	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
		573	},
		574	{
		575	"XDP pkt read, pkt_data' <= pkt_end, corner case, good access",
363	.insns = {	576	.insns = {
364	BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),	577	BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
365	BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,	578	BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
@@ -413,6 +626,43 @@ · 47 unmodified lines
413	.prog_type = BPF_PROG_TYPE_XDP,	626	.prog_type = BPF_PROG_TYPE_XDP,
414	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,	627	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
415	},	628	},
		629	{
		630	"XDP pkt read, pkt_data' <= pkt_end, corner case +1, good access",
		631	.insns = {
		632	BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
		633	BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
		634	offsetof(struct xdp_md, data_end)),
		635	BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
		636	BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 9),
		637	BPF_JMP_REG(BPF_JLE, BPF_REG_1, BPF_REG_3, 1),
		638	BPF_JMP_IMM(BPF_JA, 0, 0, 1),
		639	BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -9),
		640	BPF_MOV64_IMM(BPF_REG_0, 0),
		641	BPF_EXIT_INSN(),
		642	},
		643	.result = ACCEPT,
		644	.prog_type = BPF_PROG_TYPE_XDP,
		645	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
		646	},
		647	{
		648	"XDP pkt read, pkt_data' <= pkt_end, corner case -1, bad access",
		649	.insns = {
		650	BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
		651	BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
		652	offsetof(struct xdp_md, data_end)),
		653	BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
		654	BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 7),
		655	BPF_JMP_REG(BPF_JLE, BPF_REG_1, BPF_REG_3, 1),
		656	BPF_JMP_IMM(BPF_JA, 0, 0, 1),
		657	BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -7),
		658	BPF_MOV64_IMM(BPF_REG_0, 0),
		659	BPF_EXIT_INSN(),
		660	},
		661	.errstr = "R1 offset is outside of the packet",
		662	.result = REJECT,
		663	.prog_type = BPF_PROG_TYPE_XDP,
		664	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
		665	},
416	{	666	{
417	"XDP pkt read, pkt_end <= pkt_data', good access",	667	"XDP pkt read, pkt_end <= pkt_data', good access",
418	.insns = {	668	.insns = {
@@ -431,15 +681,15 @@ · 12 unmodified lines
431	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,	681	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
432	},	682	},
433	{	683	{
434	"XDP pkt read, pkt_end <= pkt_data', bad access 1",	684	"XDP pkt read, pkt_end <= pkt_data', corner case -1, bad access",
435	.insns = {	685	.insns = {
436	BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),	686	BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
437	BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,	687	BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
438	offsetof(struct xdp_md, data_end)),	688	offsetof(struct xdp_md, data_end)),
439	BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),	689	BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
440	BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),	690	BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 6),
441	BPF_JMP_REG(BPF_JLE, BPF_REG_3, BPF_REG_1, 1),	691	BPF_JMP_REG(BPF_JLE, BPF_REG_3, BPF_REG_1, 1),
442	BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8),	692	BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -6),
443	BPF_MOV64_IMM(BPF_REG_0, 0),	693	BPF_MOV64_IMM(BPF_REG_0, 0),
444	BPF_EXIT_INSN(),	694	BPF_EXIT_INSN(),
445	},	695	},
@@ -467,7 +717,41 @@ · 21 unmodified lines
467	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,	717	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
468	},	718	},
469	{	719	{
470	"XDP pkt read, pkt_meta' > pkt_data, good access",	720	"XDP pkt read, pkt_end <= pkt_data', corner case, good access",
		721	.insns = {
		722	BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
		723	BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
		724	offsetof(struct xdp_md, data_end)),
		725	BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
		726	BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 7),
		727	BPF_JMP_REG(BPF_JLE, BPF_REG_3, BPF_REG_1, 1),
		728	BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -7),
		729	BPF_MOV64_IMM(BPF_REG_0, 0),
		730	BPF_EXIT_INSN(),
		731	},
		732	.result = ACCEPT,
		733	.prog_type = BPF_PROG_TYPE_XDP,
		734	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
		735	},
		736	{
		737	"XDP pkt read, pkt_end <= pkt_data', corner case +1, good access",
		738	.insns = {
		739	BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, offsetof(struct xdp_md, data)),
		740	BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1,
		741	offsetof(struct xdp_md, data_end)),
		742	BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
		743	BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),
		744	BPF_JMP_REG(BPF_JLE, BPF_REG_3, BPF_REG_1, 1),
		745	BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8),
		746	BPF_MOV64_IMM(BPF_REG_0, 0),
		747	BPF_EXIT_INSN(),
		748	},
		749	.result = ACCEPT,
		750	.prog_type = BPF_PROG_TYPE_XDP,
		751	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
		752	},
		753	{
		754	"XDP pkt read, pkt_meta' > pkt_data, corner case, good access",
471	.insns = {	755	.insns = {
472	BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,	756	BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
473	offsetof(struct xdp_md, data_meta)),	757	offsetof(struct xdp_md, data_meta)),
@@ -519,6 +803,41 @@ · 45 unmodified lines
519	.prog_type = BPF_PROG_TYPE_XDP,	803	.prog_type = BPF_PROG_TYPE_XDP,
520	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,	804	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
521	},	805	},
		806	{
		807	"XDP pkt read, pkt_meta' > pkt_data, corner case +1, good access",
		808	.insns = {
		809	BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
		810	offsetof(struct xdp_md, data_meta)),
		811	BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
		812	BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
		813	BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 9),
		814	BPF_JMP_REG(BPF_JGT, BPF_REG_1, BPF_REG_3, 1),
		815	BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -9),
		816	BPF_MOV64_IMM(BPF_REG_0, 0),
		817	BPF_EXIT_INSN(),
		818	},
		819	.result = ACCEPT,
		820	.prog_type = BPF_PROG_TYPE_XDP,
		821	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
		822	},
		823	{
		824	"XDP pkt read, pkt_meta' > pkt_data, corner case -1, bad access",
		825	.insns = {
		826	BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
		827	offsetof(struct xdp_md, data_meta)),
		828	BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
		829	BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
		830	BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 7),
		831	BPF_JMP_REG(BPF_JGT, BPF_REG_1, BPF_REG_3, 1),
		832	BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -7),
		833	BPF_MOV64_IMM(BPF_REG_0, 0),
		834	BPF_EXIT_INSN(),
		835	},
		836	.errstr = "R1 offset is outside of the packet",
		837	.result = REJECT,
		838	.prog_type = BPF_PROG_TYPE_XDP,
		839	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
		840	},
522	{	841	{
523	"XDP pkt read, pkt_data > pkt_meta', good access",	842	"XDP pkt read, pkt_data > pkt_meta', good access",
524	.insns = {	843	.insns = {
@@ -538,16 +857,16 @@ · 13 unmodified lines
538	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,	857	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
539	},	858	},
540	{	859	{
541	"XDP pkt read, pkt_data > pkt_meta', bad access 1",	860	"XDP pkt read, pkt_data > pkt_meta', corner case -1, bad access",
542	.insns = {	861	.insns = {
543	BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,	862	BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
544	offsetof(struct xdp_md, data_meta)),	863	offsetof(struct xdp_md, data_meta)),
545	BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),	864	BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
546	BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),	865	BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
547	BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),	866	BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 6),
548	BPF_JMP_REG(BPF_JGT, BPF_REG_3, BPF_REG_1, 1),	867	BPF_JMP_REG(BPF_JGT, BPF_REG_3, BPF_REG_1, 1),
549	BPF_JMP_IMM(BPF_JA, 0, 0, 1),	868	BPF_JMP_IMM(BPF_JA, 0, 0, 1),
550	BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8),	869	BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -6),
551	BPF_MOV64_IMM(BPF_REG_0, 0),	870	BPF_MOV64_IMM(BPF_REG_0, 0),
552	BPF_EXIT_INSN(),	871	BPF_EXIT_INSN(),
553	},	872	},
@@ -574,6 +893,42 @@ · 20 unmodified lines
574	.prog_type = BPF_PROG_TYPE_XDP,	893	.prog_type = BPF_PROG_TYPE_XDP,
575	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,	894	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
576	},	895	},
		896	{
		897	"XDP pkt read, pkt_data > pkt_meta', corner case, good access",
		898	.insns = {
		899	BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
		900	offsetof(struct xdp_md, data_meta)),
		901	BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
		902	BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
		903	BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 7),
		904	BPF_JMP_REG(BPF_JGT, BPF_REG_3, BPF_REG_1, 1),
		905	BPF_JMP_IMM(BPF_JA, 0, 0, 1),
		906	BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -7),
		907	BPF_MOV64_IMM(BPF_REG_0, 0),
		908	BPF_EXIT_INSN(),
		909	},
		910	.result = ACCEPT,
		911	.prog_type = BPF_PROG_TYPE_XDP,
		912	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
		913	},
		914	{
		915	"XDP pkt read, pkt_data > pkt_meta', corner case +1, good access",
		916	.insns = {
		917	BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
		918	offsetof(struct xdp_md, data_meta)),
		919	BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
		920	BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
		921	BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),
		922	BPF_JMP_REG(BPF_JGT, BPF_REG_3, BPF_REG_1, 1),
		923	BPF_JMP_IMM(BPF_JA, 0, 0, 1),
		924	BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8),
		925	BPF_MOV64_IMM(BPF_REG_0, 0),
		926	BPF_EXIT_INSN(),
		927	},
		928	.result = ACCEPT,
		929	.prog_type = BPF_PROG_TYPE_XDP,
		930	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
		931	},
577	{	932	{
578	"XDP pkt read, pkt_meta' < pkt_data, good access",	933	"XDP pkt read, pkt_meta' < pkt_data, good access",
579	.insns = {	934	.insns = {
@@ -593,16 +948,16 @@ · 13 unmodified lines
593	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,	948	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
594	},	949	},
595	{	950	{
596	"XDP pkt read, pkt_meta' < pkt_data, bad access 1",	951	"XDP pkt read, pkt_meta' < pkt_data, corner case -1, bad access",
597	.insns = {	952	.insns = {
598	BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,	953	BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
599	offsetof(struct xdp_md, data_meta)),	954	offsetof(struct xdp_md, data_meta)),
600	BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),	955	BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
601	BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),	956	BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
602	BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),	957	BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 6),
603	BPF_JMP_REG(BPF_JLT, BPF_REG_1, BPF_REG_3, 1),	958	BPF_JMP_REG(BPF_JLT, BPF_REG_1, BPF_REG_3, 1),
604	BPF_JMP_IMM(BPF_JA, 0, 0, 1),	959	BPF_JMP_IMM(BPF_JA, 0, 0, 1),
605	BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8),	960	BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -6),
606	BPF_MOV64_IMM(BPF_REG_0, 0),	961	BPF_MOV64_IMM(BPF_REG_0, 0),
607	BPF_EXIT_INSN(),	962	BPF_EXIT_INSN(),
608	},	963	},
@@ -630,7 +985,43 @@ · 21 unmodified lines
630	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,	985	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
631	},	986	},
632	{	987	{
633	"XDP pkt read, pkt_data < pkt_meta', good access",	988	"XDP pkt read, pkt_meta' < pkt_data, corner case, good access",
		989	.insns = {
		990	BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
		991	offsetof(struct xdp_md, data_meta)),
		992	BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
		993	BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
		994	BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 7),
		995	BPF_JMP_REG(BPF_JLT, BPF_REG_1, BPF_REG_3, 1),
		996	BPF_JMP_IMM(BPF_JA, 0, 0, 1),
		997	BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -7),
		998	BPF_MOV64_IMM(BPF_REG_0, 0),
		999	BPF_EXIT_INSN(),
		1000	},
		1001	.result = ACCEPT,
		1002	.prog_type = BPF_PROG_TYPE_XDP,
		1003	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
		1004	},
		1005	{
		1006	"XDP pkt read, pkt_meta' < pkt_data, corner case +1, good access",
		1007	.insns = {
		1008	BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
		1009	offsetof(struct xdp_md, data_meta)),
		1010	BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
		1011	BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
		1012	BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),
		1013	BPF_JMP_REG(BPF_JLT, BPF_REG_1, BPF_REG_3, 1),
		1014	BPF_JMP_IMM(BPF_JA, 0, 0, 1),
		1015	BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8),
		1016	BPF_MOV64_IMM(BPF_REG_0, 0),
		1017	BPF_EXIT_INSN(),
		1018	},
		1019	.result = ACCEPT,
		1020	.prog_type = BPF_PROG_TYPE_XDP,
		1021	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
		1022	},
		1023	{
		1024	"XDP pkt read, pkt_data < pkt_meta', corner case, good access",
634	.insns = {	1025	.insns = {
635	BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,	1026	BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
636	offsetof(struct xdp_md, data_meta)),	1027	offsetof(struct xdp_md, data_meta)),
@@ -682,6 +1073,41 @@ · 45 unmodified lines
682	.prog_type = BPF_PROG_TYPE_XDP,	1073	.prog_type = BPF_PROG_TYPE_XDP,
683	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,	1074	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
684	},	1075	},
		1076	{
		1077	"XDP pkt read, pkt_data < pkt_meta', corner case +1, good access",
		1078	.insns = {
		1079	BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
		1080	offsetof(struct xdp_md, data_meta)),
		1081	BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
		1082	BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
		1083	BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 9),
		1084	BPF_JMP_REG(BPF_JLT, BPF_REG_3, BPF_REG_1, 1),
		1085	BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -9),
		1086	BPF_MOV64_IMM(BPF_REG_0, 0),
		1087	BPF_EXIT_INSN(),
		1088	},
		1089	.result = ACCEPT,
		1090	.prog_type = BPF_PROG_TYPE_XDP,
		1091	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
		1092	},
		1093	{
		1094	"XDP pkt read, pkt_data < pkt_meta', corner case -1, bad access",
		1095	.insns = {
		1096	BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
		1097	offsetof(struct xdp_md, data_meta)),
		1098	BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
		1099	BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
		1100	BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 7),
		1101	BPF_JMP_REG(BPF_JLT, BPF_REG_3, BPF_REG_1, 1),
		1102	BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -7),
		1103	BPF_MOV64_IMM(BPF_REG_0, 0),
		1104	BPF_EXIT_INSN(),
		1105	},
		1106	.errstr = "R1 offset is outside of the packet",
		1107	.result = REJECT,
		1108	.prog_type = BPF_PROG_TYPE_XDP,
		1109	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
		1110	},
685	{	1111	{
686	"XDP pkt read, pkt_meta' >= pkt_data, good access",	1112	"XDP pkt read, pkt_meta' >= pkt_data, good access",
687	.insns = {	1113	.insns = {
@@ -700,15 +1126,15 @@ · 12 unmodified lines
700	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,	1126	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
701	},	1127	},
702	{	1128	{
703	"XDP pkt read, pkt_meta' >= pkt_data, bad access 1",	1129	"XDP pkt read, pkt_meta' >= pkt_data, corner case -1, bad access",
704	.insns = {	1130	.insns = {
705	BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,	1131	BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
706	offsetof(struct xdp_md, data_meta)),	1132	offsetof(struct xdp_md, data_meta)),
707	BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),	1133	BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
708	BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),	1134	BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
709	BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),	1135	BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 6),
710	BPF_JMP_REG(BPF_JGE, BPF_REG_1, BPF_REG_3, 1),	1136	BPF_JMP_REG(BPF_JGE, BPF_REG_1, BPF_REG_3, 1),
711	BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8),	1137	BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -6),
712	BPF_MOV64_IMM(BPF_REG_0, 0),	1138	BPF_MOV64_IMM(BPF_REG_0, 0),
713	BPF_EXIT_INSN(),	1139	BPF_EXIT_INSN(),
714	},	1140	},
@@ -736,7 +1162,41 @@ · 21 unmodified lines
736	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,	1162	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
737	},	1163	},
738	{	1164	{
739	"XDP pkt read, pkt_data >= pkt_meta', good access",	1165	"XDP pkt read, pkt_meta' >= pkt_data, corner case, good access",
		1166	.insns = {
		1167	BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
		1168	offsetof(struct xdp_md, data_meta)),
		1169	BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
		1170	BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
		1171	BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 7),
		1172	BPF_JMP_REG(BPF_JGE, BPF_REG_1, BPF_REG_3, 1),
		1173	BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -7),
		1174	BPF_MOV64_IMM(BPF_REG_0, 0),
		1175	BPF_EXIT_INSN(),
		1176	},
		1177	.result = ACCEPT,
		1178	.prog_type = BPF_PROG_TYPE_XDP,
		1179	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
		1180	},
		1181	{
		1182	"XDP pkt read, pkt_meta' >= pkt_data, corner case +1, good access",
		1183	.insns = {
		1184	BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
		1185	offsetof(struct xdp_md, data_meta)),
		1186	BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
		1187	BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
		1188	BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 8),
		1189	BPF_JMP_REG(BPF_JGE, BPF_REG_1, BPF_REG_3, 1),
		1190	BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -8),
		1191	BPF_MOV64_IMM(BPF_REG_0, 0),
		1192	BPF_EXIT_INSN(),
		1193	},
		1194	.result = ACCEPT,
		1195	.prog_type = BPF_PROG_TYPE_XDP,
		1196	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
		1197	},
		1198	{
		1199	"XDP pkt read, pkt_data >= pkt_meta', corner case, good access",
740	.insns = {	1200	.insns = {
741	BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,	1201	BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
742	offsetof(struct xdp_md, data_meta)),	1202	offsetof(struct xdp_md, data_meta)),
@@ -791,7 +1251,44 @@ · 48 unmodified lines
791	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,	1251	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
792	},	1252	},
793	{	1253	{
794	"XDP pkt read, pkt_meta' <= pkt_data, good access",	1254	"XDP pkt read, pkt_data >= pkt_meta', corner case +1, good access",
		1255	.insns = {
		1256	BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
		1257	offsetof(struct xdp_md, data_meta)),
		1258	BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
		1259	BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
		1260	BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 9),
		1261	BPF_JMP_REG(BPF_JGE, BPF_REG_3, BPF_REG_1, 1),
		1262	BPF_JMP_IMM(BPF_JA, 0, 0, 1),
		1263	BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -9),
		1264	BPF_MOV64_IMM(BPF_REG_0, 0),
		1265	BPF_EXIT_INSN(),
		1266	},
		1267	.result = ACCEPT,
		1268	.prog_type = BPF_PROG_TYPE_XDP,
		1269	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
		1270	},
		1271	{
		1272	"XDP pkt read, pkt_data >= pkt_meta', corner case -1, bad access",
		1273	.insns = {
		1274	BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
		1275	offsetof(struct xdp_md, data_meta)),
		1276	BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
		1277	BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
		1278	BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 7),
		1279	BPF_JMP_REG(BPF_JGE, BPF_REG_3, BPF_REG_1, 1),
		1280	BPF_JMP_IMM(BPF_JA, 0, 0, 1),
		1281	BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -7),
		1282	BPF_MOV64_IMM(BPF_REG_0, 0),
		1283	BPF_EXIT_INSN(),
		1284	},
		1285	.errstr = "R1 offset is outside of the packet",
		1286	.result = REJECT,
		1287	.prog_type = BPF_PROG_TYPE_XDP,
		1288	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
		1289	},
		1290	{
		1291	"XDP pkt read, pkt_meta' <= pkt_data, corner case, good access",
795	.insns = {	1292	.insns = {
796	BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,	1293	BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
797	offsetof(struct xdp_md, data_meta)),	1294	offsetof(struct xdp_md, data_meta)),
@@ -845,6 +1342,43 @@ · 47 unmodified lines
845	.prog_type = BPF_PROG_TYPE_XDP,	1342	.prog_type = BPF_PROG_TYPE_XDP,
846	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,	1343	.flags = F_NEEDS_EFFICIENT_UNALIGNED_ACCESS,
847	},	1344	},
		1345	{
		1346	"XDP pkt read, pkt_meta' <= pkt_data, corner case +1, good access",
		1347	.insns = {
		1348	BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1,
		1349	offsetof(struct xdp_md, data_meta)),
		1350	BPF_LDX_MEM(BPF_W, BPF_REG_3, BPF_REG_1, offsetof(struct xdp_md, data)),
		1351	BPF_MOV64_REG(BPF_REG_1, BPF_REG_2),
		1352	BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, 9),
		1353	BPF_JMP_REG(BPF_JLE, BPF_REG_1, BPF_REG_3, 1),
		1354	BPF_JMP_IMM(BPF_JA, 0, 0, 1),
		1355	BPF_LDX_MEM(BPF_DW, BPF_REG_0, BPF_REG_1, -9),
		1356	BPF_MOV64_IMM(BPF_REG_0, 0),
		1357	BPF_EXIT_INSN(),
		1358	},
		1359	.result = ACCEPT,
		1360	.prog_type = BPF_PROG_TYPE_XDP,

81 more lines aren’t shown here.

tools/testing/selftests/damon/.gitignore+2−0

This diff is large: its 3 lines aren’t shown here.

tools/testing/selftests/damon/Makefile+5−2

This diff is large: its 13 lines aren’t shown here.

tools/testing/selftests/damon/_debugfs_common.sh+52−0

This diff is large: its 53 lines aren’t shown here.

tools/testing/selftests/damon/debugfs_attrs.sh+1−72

This diff is large: its 84 lines aren’t shown here.

tools/testing/selftests/damon/debugfs_empty_targets.sh+13−0

This diff is large: its 14 lines aren’t shown here.

tools/testing/selftests/damon/debugfs_huge_count_read_write.sh+22−0

This diff is large: its 23 lines aren’t shown here.

tools/testing/selftests/damon/debugfs_schemes.sh+19−0

This diff is large: its 20 lines aren’t shown here.

tools/testing/selftests/damon/debugfs_target_ids.sh+19−0

This diff is large: its 20 lines aren’t shown here.

tools/testing/selftests/damon/huge_count_read_write.c+39−0

This diff is large: its 40 lines aren’t shown here.

tools/testing/selftests/kvm/.gitignore+1−0

This diff is large: its 8 lines aren’t shown here.

tools/testing/selftests/kvm/Makefile+1−0

This diff is large: its 8 lines aren’t shown here.

tools/testing/selftests/kvm/include/kvm_util.h+9−0

This diff is large: its 16 lines aren’t shown here.

tools/testing/selftests/kvm/kvm_create_max_vcpus.c+30−0

This diff is large: its 48 lines aren’t shown here.

tools/testing/selftests/kvm/kvm_page_table_test.c+1−1

This diff is large: its 9 lines aren’t shown here.

tools/testing/selftests/kvm/lib/kvm_util.c+1−1

This diff is large: its 9 lines aren’t shown here.

tools/testing/selftests/kvm/lib/x86_64/processor.c+68−0

This diff is large: its 72 lines aren’t shown here.

tools/testing/selftests/kvm/x86_64/hyperv_features.c+71−69

This diff is large: its 213 lines aren’t shown here.

tools/testing/selftests/kvm/x86_64/sev_migrate_tests.c+155−10

This diff is large: its 222 lines aren’t shown here.

tools/testing/selftests/kvm/x86_64/svm_int_ctl_test.c+1−1

This diff is large: its 9 lines aren’t shown here.

tools/testing/selftests/kvm/x86_64/userspace_io_test.c+114−0

This diff is large: its 115 lines aren’t shown here.

tools/testing/selftests/net/fcnal-test.sh+10−2

This diff is large: its 23 lines aren’t shown here.

tools/testing/selftests/net/fib_tests.sh+49−10

This diff is large: its 74 lines aren’t shown here.

tools/testing/selftests/net/tls.c+36−0

This diff is large: its 57 lines aren’t shown here.

tools/testing/selftests/netfilter/conntrack_vrf.sh+26−4

This diff is large: its 60 lines aren’t shown here.

tools/testing/selftests/netfilter/nft_concat_range.sh+21−3

This diff is large: its 45 lines aren’t shown here.

tools/testing/selftests/netfilter/nft_zones_many.sh+13−6

This diff is large: its 33 lines aren’t shown here.

tools/testing/selftests/tc-testing/config+2−0

This diff is large: its 9 lines aren’t shown here.

tools/testing/selftests/tc-testing/tdc.py+5−3

This diff is large: its 35 lines aren’t shown here.

tools/testing/selftests/tc-testing/tdc.sh+1−0

This diff is large: its 7 lines aren’t shown here.

tools/testing/selftests/wireguard/netns.sh+28−2

This diff is large: its 51 lines aren’t shown here.

tools/testing/selftests/wireguard/qemu/debug.config+1−1

This diff is large: its 9 lines aren’t shown here.

tools/testing/selftests/wireguard/qemu/kernel.config+1−0

This diff is large: its 8 lines aren’t shown here.

virt/kvm/kvm_main.c+37−19

This diff is large: its 150 lines aren’t shown here.

Merge v5.15-rc5 into char-misc-next

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code

@@ -670,7 +670,7 @@ void __init mlx4_en_init_ptys2ethtool_map(void) · 669 unmodified lines
670	MLX4_BUILD_PTYS2ETHTOOL_CONFIG(MLX4_1000BASE_T, SPEED_1000,	670	MLX4_BUILD_PTYS2ETHTOOL_CONFIG(MLX4_1000BASE_T, SPEED_1000,
671	ETHTOOL_LINK_MODE_1000baseT_Full_BIT);	671	ETHTOOL_LINK_MODE_1000baseT_Full_BIT);
672	MLX4_BUILD_PTYS2ETHTOOL_CONFIG(MLX4_1000BASE_CX_SGMII, SPEED_1000,	672	MLX4_BUILD_PTYS2ETHTOOL_CONFIG(MLX4_1000BASE_CX_SGMII, SPEED_1000,
673	ETHTOOL_LINK_MODE_1000baseKX_Full_BIT);	673	ETHTOOL_LINK_MODE_1000baseX_Full_BIT);
674	MLX4_BUILD_PTYS2ETHTOOL_CONFIG(MLX4_1000BASE_KX, SPEED_1000,	674	MLX4_BUILD_PTYS2ETHTOOL_CONFIG(MLX4_1000BASE_KX, SPEED_1000,
675	ETHTOOL_LINK_MODE_1000baseKX_Full_BIT);	675	ETHTOOL_LINK_MODE_1000baseKX_Full_BIT);
676	MLX4_BUILD_PTYS2ETHTOOL_CONFIG(MLX4_10GBASE_T, SPEED_10000,	676	MLX4_BUILD_PTYS2ETHTOOL_CONFIG(MLX4_10GBASE_T, SPEED_10000,
@@ -682,9 +682,9 @@ void __init mlx4_en_init_ptys2ethtool_map(void) · 5 unmodified lines
682	MLX4_BUILD_PTYS2ETHTOOL_CONFIG(MLX4_10GBASE_KR, SPEED_10000,	682	MLX4_BUILD_PTYS2ETHTOOL_CONFIG(MLX4_10GBASE_KR, SPEED_10000,
683	ETHTOOL_LINK_MODE_10000baseKR_Full_BIT);	683	ETHTOOL_LINK_MODE_10000baseKR_Full_BIT);
684	MLX4_BUILD_PTYS2ETHTOOL_CONFIG(MLX4_10GBASE_CR, SPEED_10000,	684	MLX4_BUILD_PTYS2ETHTOOL_CONFIG(MLX4_10GBASE_CR, SPEED_10000,
685	ETHTOOL_LINK_MODE_10000baseKR_Full_BIT);	685	ETHTOOL_LINK_MODE_10000baseCR_Full_BIT);
686	MLX4_BUILD_PTYS2ETHTOOL_CONFIG(MLX4_10GBASE_SR, SPEED_10000,	686	MLX4_BUILD_PTYS2ETHTOOL_CONFIG(MLX4_10GBASE_SR, SPEED_10000,
687	ETHTOOL_LINK_MODE_10000baseKR_Full_BIT);	687	ETHTOOL_LINK_MODE_10000baseSR_Full_BIT);
688	MLX4_BUILD_PTYS2ETHTOOL_CONFIG(MLX4_20GBASE_KR2, SPEED_20000,	688	MLX4_BUILD_PTYS2ETHTOOL_CONFIG(MLX4_20GBASE_KR2, SPEED_20000,
689	ETHTOOL_LINK_MODE_20000baseMLD2_Full_BIT,	689	ETHTOOL_LINK_MODE_20000baseMLD2_Full_BIT,
690	ETHTOOL_LINK_MODE_20000baseKR2_Full_BIT);	690	ETHTOOL_LINK_MODE_20000baseKR2_Full_BIT);