From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 2C9A4302CC7 for ; Tue, 14 Oct 2025 16:56:17 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1760460978; cv=none; b=U0kYU8UtS3RWvkC1PW07GOfHe4Nt39quC64H17wqYUvuvC5BDNGBdV6fVnT8SWeRR76gtJ4FsYWgCul/vzPlQTSg++oPdL4at63FXsivAdBqboNBfTKSzz+1C0U95SsTXFNu6hPzVRRmz0+7nGljiIPvYgVS5WBQWioQNoIyqSI= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1760460978; c=relaxed/simple; bh=QoMVJb45Y9NTxBXyk2hjN2vNoE35t3zjlN5O7L6MW1o=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=dBzKmu/U3A8VRg/zJaaOm1c8jH/Es7brEc4XI2exR26jgCQ+t8VTJ7YZYji+rGnlKKqeNrv8n6y4Bi7Ri15UOi0fV9SxIuheRH0nOZv5FDYjM12Ex+JEMUo88MTys1Bp6b2LofKIF+XJW52cuaR+dNFMqZFCQJt+TOB+fvrzxFo= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=HJ6WfqNp; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="HJ6WfqNp" Received: by smtp.kernel.org (Postfix) with ESMTPSA id EFC7BC4CEE7; Tue, 14 Oct 2025 16:56:16 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1760460977; bh=QoMVJb45Y9NTxBXyk2hjN2vNoE35t3zjlN5O7L6MW1o=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=HJ6WfqNpBrTZR1TWyM0WVPmEihkeQM9ZPXLA22bxTWAsCYDeQUujesHs2pWQtZ1bk 2UPZgcMVpI7z5MWD4IMVovvu9NL73ZS5XMLw6DYqYma0gTq2PybK9HZCTrKPtRHmdD QltMdmnX2kh0TFxIrhoRVO9zoLiuBXWHd55XXtDTJjssnf0gGo+UByewYVna2aUAT9 k9/1DXNtcCRBNIC8htniQzGMNMpDslHWqrljjsWQm2yq+i5CmXfTsnZWCNpd/pjWYI oevGaRmbXWekgG3EsUb1nrVA4eyMa+fF+lJNM1FGT4utRyDvyhhjwuZCXb3HeLzYA4 HTvOPb46Rzvug== From: Sasha Levin To: stable@vger.kernel.org Cc: Oleksij Rempel , =?UTF-8?q?Hubert=20Wi=C5=9Bniewski?= , Marek Szyprowski , Paolo Abeni , Sasha Levin Subject: [PATCH 5.15.y] net: usb: asix: hold PM usage ref to avoid PM/MDIO + RTNL deadlock Date: Tue, 14 Oct 2025 12:56:14 -0400 Message-ID: <20251014165614.192458-1-sashal@kernel.org> X-Mailer: git-send-email 2.51.0 In-Reply-To: <2025101349-reptile-seldom-427d@gregkh> References: <2025101349-reptile-seldom-427d@gregkh> Precedence: bulk X-Mailing-List: stable@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit From: Oleksij Rempel [ Upstream commit 3d3c4cd5c62f24bb3cb4511b7a95df707635e00a ] Prevent USB runtime PM (autosuspend) for AX88772* in bind. usbnet enables runtime PM (autosuspend) by default, so disabling it via the usb_driver flag is ineffective. On AX88772B, autosuspend shows no measurable power saving with current driver (no link partner, admin up/down). The ~0.453 W -> ~0.248 W drop on v6.1 comes from phylib powering the PHY off on admin-down, not from USB autosuspend. The real hazard is that with runtime PM enabled, ndo_open() (under RTNL) may synchronously trigger autoresume (usb_autopm_get_interface()) into asix_resume() while the USB PM lock is held. Resume paths then invoke phylink/phylib and MDIO, which also expect RTNL, leading to possible deadlocks or PM lock vs MDIO wake issues. To avoid this, keep the device runtime-PM active by taking a usage reference in ax88772_bind() and dropping it in unbind(). A non-zero PM usage count blocks runtime suspend regardless of userspace policy (.../power/control - pm_runtime_allow/forbid), making this approach robust against sysfs overrides. Holding a runtime-PM usage ref does not affect system-wide suspend; system sleep/resume callbacks continue to run as before. Fixes: 4a2c7217cd5a ("net: usb: asix: ax88772: manage PHY PM from MAC") Reported-by: Hubert Wiśniewski Closes: https://lore.kernel.org/all/DCGHG5UJT9G3.2K1GHFZ3H87T0@gmail.com Tested-by: Hubert Wiśniewski Reported-by: Marek Szyprowski Closes: https://lore.kernel.org/all/b5ea8296-f981-445d-a09a-2f389d7f6fdd@samsung.com Cc: stable@vger.kernel.org Signed-off-by: Oleksij Rempel Link: https://patch.msgid.link/20251005081203.3067982-1-o.rempel@pengutronix.de Signed-off-by: Paolo Abeni [ adapted to phylib-only ] Signed-off-by: Sasha Levin --- drivers/net/usb/asix_devices.c | 35 +++++++++++++++++++++++++++++++++- 1 file changed, 34 insertions(+), 1 deletion(-) diff --git a/drivers/net/usb/asix_devices.c b/drivers/net/usb/asix_devices.c index 97d2037e7fee7..2e22be26921b8 100644 --- a/drivers/net/usb/asix_devices.c +++ b/drivers/net/usb/asix_devices.c @@ -608,6 +608,21 @@ static void ax88772_suspend(struct usbnet *dev) asix_read_medium_status(dev, 1)); } +/* Notes on PM callbacks and locking context: + * + * - asix_suspend()/asix_resume() are invoked for both runtime PM and + * system-wide suspend/resume. For struct usb_driver the ->resume() + * callback does not receive pm_message_t, so the resume type cannot + * be distinguished here. + * + * - The MAC driver must hold RTNL when calling phylink interfaces such as + * phylink_suspend()/resume(). Those calls will also perform MDIO I/O. + * + * - Taking RTNL and doing MDIO from a runtime-PM resume callback (while + * the USB PM lock is held) is fragile. Since autosuspend brings no + * measurable power saving here, we block it by holding a PM usage + * reference in ax88772_bind(). + */ static int asix_suspend(struct usb_interface *intf, pm_message_t message) { struct usbnet *dev = usb_get_intfdata(intf); @@ -809,7 +824,18 @@ static int ax88772_bind(struct usbnet *dev, struct usb_interface *intf) if (ret) return ret; - return ax88772_init_phy(dev); + ret = ax88772_init_phy(dev); + if (ret) + return ret; + + /* Keep this interface runtime-PM active by taking a usage ref. + * Prevents runtime suspend while bound and avoids resume paths + * that could deadlock (autoresume under RTNL while USB PM lock + * is held, phylink/MDIO wants RTNL). + */ + pm_runtime_get_noresume(&intf->dev); + + return 0; } static int ax88772_stop(struct usbnet *dev) @@ -827,6 +853,8 @@ static void ax88772_unbind(struct usbnet *dev, struct usb_interface *intf) phy_disconnect(priv->phydev); asix_rx_fixup_common_free(dev->driver_priv); + /* Drop the PM usage ref taken in bind() */ + pm_runtime_put(&intf->dev); } static void ax88178_unbind(struct usbnet *dev, struct usb_interface *intf) @@ -1452,6 +1480,11 @@ static struct usb_driver asix_driver = { .resume = asix_resume, .reset_resume = asix_resume, .disconnect = usbnet_disconnect, + /* usbnet enables autosuspend by default (supports_autosuspend=1). + * We keep runtime-PM active for AX88772* by taking a PM usage + * reference in ax88772_bind() (pm_runtime_get_noresume()) and + * dropping it in unbind(), which effectively blocks autosuspend. + */ .supports_autosuspend = 1, .disable_hub_initiated_lpm = 1, }; -- 2.51.0