From nobody Sun Sep 27 03:12:52 2026 Received: from mail-wm1-f48.google.com (mail-wm1-f48.google.com [209.85.128.48]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 18C2533ADAE for ; Sun, 6 Sep 2026 17:45:51 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.128.48 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1788716754; cv=none; b=YSn/WAc4tLcPwDO/zUNVXWcjHVfd5jQ/i4qqMAxc4oiw9tqkh8DH7dh0OtqdOucHjs+0ekTVBsb0zXlcsn+cVi7r008D70MYnjXQoSTz1m6jExSsx2Tec0Qg2DZGHakaG/d3vPivbf8RCpGBe1k5qhnqfEz4MKfDVBnttvMYzf4= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1788716754; c=relaxed/simple; bh=eTj+v4XZ/mc1fs4KGXNTWMfLWYAfDj0EedWktiYlkHQ=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=Gt+03EnnChN6v2taJDbhVdY0AR782NevFJ1wSr0A9M1x+rjtGvMBn/ulpGCCvfyEV4uMWHdXZjQAhg510Y/Cc+0TPjMYYvMxLMOMdp8uaviJARKgmfcN7kTFwcJ3JWewVJ2BrmLl3XQUxOebmoo4fuPNqrpnaKDczfhgNF3qTf8= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=lex.la; spf=pass smtp.mailfrom=lex.la; dkim=pass (2048-bit key) header.d=lex.la header.i=@lex.la header.b=iqShrAT9; arc=none smtp.client-ip=209.85.128.48 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=lex.la Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=lex.la Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=lex.la header.i=@lex.la header.b="iqShrAT9" Received: by mail-wm1-f48.google.com with SMTP id 5b1f17b1804b1-49b8eeb3ff2so23935365e9.2 for ; Sun, 06 Sep 2026 10:45:51 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=lex.la; s=google; t=1788716750; x=1789321550; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to:content-type; bh=1CaAy/OOlyYaqWLAHRZ+LDOoXJmE0/3wBUASyxhKepw=; b=iqShrAT9e7JfEmgnyioc9eKb1fqXFNjntNRZhBQ2Oa8ScrBWZsKTWcU8B7mz2LpAWe 7O4Bx1AEdDqZADPXIEYvApnWtuPnS1Cbce2sE0T5R8gHlrJ2/C1mLwShWIKgWiPNOHYQ a1gTTFuHST37Xj5AKb2BHy91RXU8+m7wdK5hWbJ49NpglmmijgBgz3mw8Dt+oCV+m5ac rk00+lkxnMckvq/J22363yUZoeTnvPVbO+GvSqhNPFdiq2cBtGGUhdJdVqlDRWi6FKo9 dtLuGvH+GPnp4YSouDS3feuys+LrIJRW95Pw4Nh7KIPSGqIqG7zLLW0dxs1cooNUnEzq FgXw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1788716750; x=1789321550; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to:content-type; bh=1CaAy/OOlyYaqWLAHRZ+LDOoXJmE0/3wBUASyxhKepw=; b=He6AQSKs24wJ9wYe/gaqtLewgExFBpyHAooyC80gsed0/D1l9xFAka4UgVJE6VKY7x VZNHL+LtmH451v5jMobY2HexzVQwLISUv2DSEetiJ/14VjpBT7R3o3CRe2sdgshdURlc jyM4XLzHNtZ/GfTjYBtbdSXA84jRdN/IS4Fe1HvggTC18ZCUbm01bNvbrPAt3zvC/OWU WqvzVWePhFo6LANi60E+KEHbLVsaj9ksgzEOQ4WWBOIJo0r2OXZxzr41Zhh2GPNcO7j5 oR0IfGKLa2pvFBj0ve9RzamT1VIuuJA9/z7B+IyHPNmQqGWX2GbS2p7G0OHpWCAqm4dx Khlw== X-Forwarded-Encrypted: i=1; AKwUvBxczmL2IKKbIp8TlQkK9c0vU5Q/u9BaBtkr9OTr+58pMCsNm4XuHxfmxSXO3mFYC6WEEsWoRX+MNE90dpA=@vger.kernel.org X-Gm-Message-State: AFuF++nJPGOvygT2Fkc15UmDwUeXCnNVCJoTzeM15s+JnGnbbXEGwPBJ uCY89Qmi3Kg0YE2N/9BkBNEg71TsyFoUVEQc/dyqbMhvDycol6LED2bRH5TgVr/hTgs= X-Gm-Gg: AYBFou0SxqmSZ08z3esyykRwOf6ZaidU5p0bfxmp7ZdU8FsLI645AsI7Mrd3IFykevU klBmQErxESRkgLe5VE+wIbpZnbvM1/+//XMPUUDT4sdcu70g0QFIk/o4Zkc4Ta4EHCan9NSJVfD Exj41wYNofLPTiG3dxc4EqM7A4fJa+FliGZcXYQlV+zR7VgLkUXYV+m6YMY27kLvboCFDuxn3+d /eFCxz0DjLyOL/vaOYl6sxYeCi5nHHKh9uXGMaitCmm3WnWidyv4gggHmz3qicIhZQaBXwbfHvJ 6hV5w3CIMjzjiSh5qDCHQg7tnDfDTF9+ZuWCjA8pYB4m+u1WKYrsq41gFvdfxDCHWV7oPx8OAL7 /A0YmT5vIUfTPeU6OsVw+oV8ghLJhbZQpTTtV8y63W32wTEUKWmPMO5ZSoGrEEH7fvWO64FvqQr XouB3nod0XbL6GMyZ4Ajk/vew1WLcK6BFeQGS6hKY= X-Received: by 2002:a05:600c:3b1f:b0:49c:ee06:9c58 with SMTP id 5b1f17b1804b1-49cf821eff7mr182941215e9.4.1788716750222; Sun, 06 Sep 2026 10:45:50 -0700 (PDT) Received: from remote-01 ([84.17.55.227]) by smtp.gmail.com with ESMTPSA id 5b1f17b1804b1-49cf755c22esm245418805e9.0.2026.09.06.10.45.48 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 06 Sep 2026 10:45:49 -0700 (PDT) From: Aleksei Sviridkin To: andrew@lunn.ch, andrew+netdev@lunn.ch, hkallweit1@gmail.com, linux@armlinux.org.uk, davem@davemloft.net, edumazet@google.com, kuba@kernel.org, pabeni@redhat.com, horms@kernel.org, robh@kernel.org, krzk+dt@kernel.org, conor+dt@kernel.org Cc: ericwouds@gmail.com, netdev@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org Subject: [RFC PATCH net-next 1/7] dt-bindings: net: add Airoha EN8811H PHY MCU Date: Sun, 6 Sep 2026 17:45:37 +0000 Message-ID: <20260906174548.4106801-1-f@lex.la> X-Mailer: git-send-email 2.53.0 In-Reply-To: References: Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" The EN8811H answers its PHY ID from power-on, but a link is only possible once its MD32 MCU runs firmware that the host loads over MDIO into volatile RAM. On systems that keep the firmware files in a filesystem, the files arrive long after the MDIO bus was scanned, and the PHY node alone cannot express that gap. Describe the MCU as an MDIO device of its own, with the PHY node on a child bus underneath it. The device downloads the firmware when the files appear, or adopts firmware the bootloader left running, and registers the child bus only then, so the PHY never becomes visible before the chip can serve it. The reset line belongs to this node, not to the PHY node: firmware lives in volatile RAM, so reset may be asserted only while the MCU is not executing it. On a PHY node the line would be pulsed by every phy_detach() and wipe the running firmware. Assisted-by: LLM Signed-off-by: Aleksei Sviridkin --- .../bindings/net/airoha,en8811h-mcu.yaml | 117 ++++++++++++++++++ MAINTAINERS | 6 + 2 files changed, 123 insertions(+) create mode 100644 Documentation/devicetree/bindings/net/airoha,en8811h-mc= u.yaml diff --git a/Documentation/devicetree/bindings/net/airoha,en8811h-mcu.yaml = b/Documentation/devicetree/bindings/net/airoha,en8811h-mcu.yaml new file mode 100644 index 000000000000..7be0ab862266 --- /dev/null +++ b/Documentation/devicetree/bindings/net/airoha,en8811h-mcu.yaml @@ -0,0 +1,117 @@ +# SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause) +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/net/airoha,en8811h-mcu.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml# + +title: Airoha EN8811H PHY MCU + +maintainers: + - Aleksei Sviridkin + +description: | + The Airoha EN8811H 2.5G PHY is built around an MD32 core that executes + firmware from volatile RAM. The chip answers an MDIO address from + power-on, but the PHY function does not exist until firmware has been + loaded over MDIO, and it disappears again if that RAM is cleared. + + This node describes the MD32 core. The PHY function answers on a child + MDIO bus below it, at the same address the core occupies on the parent + bus, and only while firmware is running. + + The reset line is wired to the core, and asserting it clears the + firmware RAM. It therefore belongs to this node: a reset described on + the PHY node would be pulsed by that node's own lifecycle, whatever + the core is doing. + + A board that has firmware in hand while its MDIO bus is enumerated can + describe the PHY on its own, as airoha,en8811h.yaml does, and that form + stays valid. This binding is for the boards where firmware arrives + later, so that there is no PHY to describe until the core has it. + +properties: + $nodename: + pattern: "^mcu@[0-9a-f]+$" + + compatible: + const: airoha,en8811h-mcu + + reg: + maxItems: 1 + + reset-gpios: + maxItems: 1 + description: + The GPIO phandle and specifier for the reset signal wired to the + MD32 core. + + reset-assert-us: + description: + Delay after the reset was asserted in microseconds. If this + property is missing the delay will be skipped. + + reset-deassert-us: + description: + Delay after the reset was deasserted in microseconds. If this + property is missing the delay will be skipped. + + mdio: + $ref: mdio.yaml# + description: + The bus the PHY function answers on while firmware is running, at + the same address this node occupies on the parent bus. Only that + one address is passed through. + + patternProperties: + '^ethernet-phy@[0-9a-f]+$': + type: object + $ref: ethernet-phy.yaml# + unevaluatedProperties: false + + properties: + reset-gpios: false + reset-assert-us: false + reset-deassert-us: false + + description: + The reset line belongs to the MCU node above. A reset described + here would be pulsed by this node's own lifecycle, and that eras= es + the firmware that created this PHY. + + unevaluatedProperties: false + +required: + - compatible + - reg + - mdio + +additionalProperties: false + +examples: + - | + #include + #include + + mdio { + #address-cells =3D <1>; + #size-cells =3D <0>; + + mcu@d { + compatible =3D "airoha,en8811h-mcu"; + reg =3D <0xd>; + reset-gpios =3D <&pio 14 GPIO_ACTIVE_LOW>; + reset-assert-us =3D <10000>; + reset-deassert-us =3D <20000>; + + mdio { + #address-cells =3D <1>; + #size-cells =3D <0>; + + ethernet-phy@d { + compatible =3D "ethernet-phy-id03a2.a411"; + reg =3D <0xd>; + interrupts-extended =3D <&pio 15 IRQ_TYPE_LEVEL_LOW>; + }; + }; + }; + }; diff --git a/MAINTAINERS b/MAINTAINERS index b23fb6f2f4ef..4ca19275f4d0 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -750,6 +750,12 @@ S: Supported F: fs/aio.c F: include/linux/*aio*.h =20 +AIROHA EN8811H MCU MDIO DRIVER +M: Aleksei Sviridkin +L: netdev@vger.kernel.org +S: Maintained +F: Documentation/devicetree/bindings/net/airoha,en8811h-mcu.yaml + AIROHA ETHERNET DRIVER M: Lorenzo Bianconi L: linux-arm-kernel@lists.infradead.org (moderated for non-subscribers) --=20 2.53.0 From nobody Sun Sep 27 03:12:52 2026 Received: from mail-wm1-f49.google.com (mail-wm1-f49.google.com [209.85.128.49]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 7CD3B3C1D46 for ; Sun, 6 Sep 2026 17:45:53 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.128.49 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1788716755; cv=none; b=mc+5lyFO3qrC5xl7g0nKVOiDzTDnJ3EBelMUmyGcLdNDMgID04t7Z0hdTlOVZ5K/RwSM4MYrplgDmXvSiukB/gQRfIlCPBz1GfJOOEcseUDDbcaTuwZM01gMvu/3+PaZpMNGTPh5M9Jdm0bkCUt1BfL3p3cRmDTDaez5kXPFD7A= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1788716755; c=relaxed/simple; bh=K244GoaR/SBN1qTkqznMbdB/qRyg1uAQxHof7eZyYLA=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=Ggouyb9tGqx5hiq1tb7qsmdVQfMOVGY1+YJG8VymonU7E88MPAi4iC/D0b9HCtI6sU4waS8Znh1Yo2rbwb902PVXyoVgmBeevRrgeDMlkR2qcbpR5tZXn8hitoSS2OtvBALmFs5EL3vtAFh+mmMOzIi5UYzqRnmFQ6cmuX5ULGg= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=lex.la; spf=pass smtp.mailfrom=lex.la; dkim=pass (2048-bit key) header.d=lex.la header.i=@lex.la header.b=LZHeNUA8; arc=none smtp.client-ip=209.85.128.49 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=lex.la Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=lex.la Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=lex.la header.i=@lex.la header.b="LZHeNUA8" Received: by mail-wm1-f49.google.com with SMTP id 5b1f17b1804b1-49a97714f5dso24766175e9.0 for ; Sun, 06 Sep 2026 10:45:53 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=lex.la; s=google; t=1788716751; x=1789321551; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to:content-type; bh=nwJE/G6DLPhkatwmSaqyq8HEYQKnbZm9tru5auWihS0=; b=LZHeNUA8ThlfHJ8IUWW5tpcRcoPmef+VXkClscU0s6ZK6Nj27WWGu17wGcstjFDm7Y +tNQrHe0TtDATUG1ZSaXaodU+oo9mxcFBfzTDA596/Ku5NAm2Cg/gClIOcsjQif0wLW1 7lk+vZAXy8dsa9kPgRrxqi8bQFfGAxmx8frQynJ3fbAMasX8VHmGIdWY2poVhbxD/bja xxMbNXpfeXqzqAA2prRe2pzqVm+qA3Jceanbar2QTN/Gs09ACL/QFR/fi3hNGb15f7iV vMbpSACLaGiW5eJ7Dn98xtTmVSFytal6qZ8EvOvADUugsxZk5zMjLB86TLOSHjiZsQlT in1w== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1788716751; x=1789321551; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to:content-type; bh=nwJE/G6DLPhkatwmSaqyq8HEYQKnbZm9tru5auWihS0=; b=ighBeew1ThzhzT+Dbg6xGqObhtlUAzI2B72xi+UygZez3mfXk/+QZFnt4IHyl5mib+ sI6de+YlP9HuvKsWN4sSOwEfJoBG5hyEZbIoa+nozoo6QGHvJh1twrPs/c69BFckbbvX GaPi/NHiLsBzAwdsRccAeRC90UHcU2TTAjGdTPJjq7AcTxujRNX9sOUtIHWn0jtcFS0F D8x59lRAV8h7jSGLzyCz6hRSOARkPRSKy7DKEDoD61cKvdgHisvhmt+o9oedyEr7VBng Ii3P6407nTv68ZZ0wpy92vsVo/lcPk9JbuIhWQ0DDWOrlcCzM7IXjY4CAH5nsZzRUaKe mjDw== X-Forwarded-Encrypted: i=1; AKwUvBwO4UpFi5duVJIv0Y6e5PyVOHWU77wkfCRNzeTECZyVU+0v7YHrKeGQXNqn5m4o5clcMejXMy0MLazneI8=@vger.kernel.org X-Gm-Message-State: AFuF++mCmmVgn7xfAPeL9rG6SGNYEo7d66dK2DDh9Z6QBVf5YT7I22PE LabnM/9RAtJTq8+4gkeg6P4bsqkAH+X1/oMiGeqrYJrceQXnuHMy1PYDiNI+iCu4xLM= X-Gm-Gg: AYBFou0fzwVou8EiTkLKUj3NARDoxghtu9hfCSOUSHEWZsedbkoBSXhhhP03JAWGxb/ R07+U3pbnGjBLZHYagh9H35G0C2qh18gKsxf9WePkcNvjkDdo0icrvfvLvKHiX3/K1pu4S3YCQK Kv90aRdzs4KiTxIY/eHA/uCm8a8cirsJVlYwRTA3S7ljWlk/aub+BowuPxv/skqikjGoNaN7NZX cBpER54cviUSBbb0qAnLz/mvjTn1jwBWt0+iE+ugRV1nl/NwpX5MB8Ep/PYSptVdkyF/KfTjTRg MfoCvZ/TY/gTHtLj71EaQ1kJbzLcUtA9thrYHp4wMbALIMCkEW6htt6cbIdlBIMndT1bE5tKm9T Q6PfixN3pdHNQ8Fn/5pqoFMLD8Ttng0hsp5x1PgcjOssj1TvlU2cpmkR3Lyyc36ms8YCEM/+/Yi P5140gIvLrB2tZP0dcodwi4kx4VcXZMdhti+F+hrM= X-Received: by 2002:a05:600c:314f:b0:49c:ffde:45ff with SMTP id 5b1f17b1804b1-49cffde4629mr130539685e9.17.1788716751586; Sun, 06 Sep 2026 10:45:51 -0700 (PDT) Received: from remote-01 ([84.17.55.227]) by smtp.gmail.com with ESMTPSA id 5b1f17b1804b1-49cf755c22esm245418805e9.0.2026.09.06.10.45.50 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 06 Sep 2026 10:45:51 -0700 (PDT) From: Aleksei Sviridkin To: andrew@lunn.ch, andrew+netdev@lunn.ch, hkallweit1@gmail.com, linux@armlinux.org.uk, davem@davemloft.net, edumazet@google.com, kuba@kernel.org, pabeni@redhat.com, horms@kernel.org, robh@kernel.org, krzk+dt@kernel.org, conor+dt@kernel.org Cc: ericwouds@gmail.com, netdev@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org Subject: [RFC PATCH net-next 2/7] net: phy: add mdiodev_lock(), mdiodev_lock_nested() and mdiodev_unlock() Date: Sun, 6 Sep 2026 17:45:38 +0000 Message-ID: <20260906174548.4106801-2-f@lex.la> X-Mailer: git-send-email 2.53.0 In-Reply-To: References: Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Code that holds the MDIO bus across a burst of transactions has phy_lock_mdio_bus(), which needs a phy_device. A library serving a chip before its phy_device exists has to open-code the same mutex. Add the mdio_device spelling beside it. The nested form is for a library whose caller already holds the bus one level up, which is what the EN8811H MDIO driver later in this series does. Assisted-by: LLM Signed-off-by: Aleksei Sviridkin --- include/linux/phy.h | 16 ++++++++++++++++ 1 file changed, 16 insertions(+) diff --git a/include/linux/phy.h b/include/linux/phy.h index 3d8afe6b7f1c..e74a8f5cf5c6 100644 --- a/include/linux/phy.h +++ b/include/linux/phy.h @@ -2284,6 +2284,22 @@ static inline void phy_unlock_mdio_bus(struct phy_de= vice *phydev) mutex_unlock(&phydev->mdio.bus->mdio_lock); } =20 +static inline void mdiodev_lock(struct mdio_device *mdiodev) +{ + mutex_lock(&mdiodev->bus->mdio_lock); +} + +/* For a bus reached through another one, as mdiobus_read_nested() is. */ +static inline void mdiodev_lock_nested(struct mdio_device *mdiodev) +{ + mutex_lock_nested(&mdiodev->bus->mdio_lock, MDIO_MUTEX_NESTED); +} + +static inline void mdiodev_unlock(struct mdio_device *mdiodev) +{ + mutex_unlock(&mdiodev->bus->mdio_lock); +} + void phy_attached_print(struct phy_device *phydev, const char *fmt, ...) __printf(2, 3); char *phy_attached_info_irq(struct phy_device *phydev) --=20 2.53.0 From nobody Sun Sep 27 03:12:52 2026 Received: from mail-wm1-f45.google.com (mail-wm1-f45.google.com [209.85.128.45]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id E1E3F3C6A57 for ; Sun, 6 Sep 2026 17:45:54 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.128.45 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1788716757; cv=none; b=uiU+gKfm1UMjc5+gIRK7w4pjNiLCjpwAkEH7yJV+94D1isBHbrFGsJNiJkNYFZmbSHZcOe4du50XLwgR0djglW0IFGwyFDxfui76xL46FEi9qu8YnDvkbb8AMl4o6eKFSKj2VOnpMkcTlKQkKlmU0C3dU5yK0TmprW554wayTUo= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1788716757; c=relaxed/simple; bh=mzH/5XaUhv6NQCYgufBy5oWC9jpITM+/znfPg5sAlv0=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=I1vk2gFN4FuVH5gtV8gGPCDkkH8S7gN+ujsZK/Sw45p49GMFsa2YjBhYBfINEkEpntO33fDidaPX/1UaebfILZ2NqCl6eqK4D2E1IbKo2/fYkJuKlzMaW4JyLUDIgcL8RM47JhK3Ifg8gAlbJd5Zg+3cthp3+F+L0dB61Kv0ugM= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=lex.la; spf=pass smtp.mailfrom=lex.la; dkim=pass (2048-bit key) header.d=lex.la header.i=@lex.la header.b=D+SUdOLd; arc=none smtp.client-ip=209.85.128.45 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=lex.la Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=lex.la Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=lex.la header.i=@lex.la header.b="D+SUdOLd" Received: by mail-wm1-f45.google.com with SMTP id 5b1f17b1804b1-4954a9e8490so20115985e9.1 for ; Sun, 06 Sep 2026 10:45:54 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=lex.la; s=google; t=1788716753; x=1789321553; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to:content-type; bh=YfiP06w66PJnEqo2UKKQtS6GK/rrfhVqIhL6B6Ho9XA=; b=D+SUdOLdyIGNFF9OLO7kNZBN3kfBiRVuBDM2Ij1okCk5SUwaURxQ9IKWBZxdEEAxQr zf6rwpKqKIMoF4v6pFvHv9sez/4JUYtmJsPJMIG+CorOgO4NrdFIHI68v38iJW6xQ4EB 0pXk8PCNNdbUwDiP7XcL/+rbDdtii0RSONnKC4ciHq79UUnF3V1DOgvn7RXXd7FoCNtf bw+WeqHiGwZ9IoeTPoY86zdwgtlM2yQKby6qM10Ou3WJRZ0DFOzNUJPE4DVLgmk3awN4 DAhNYtG1b96MqnB31ULK2Dv3NyltEQ/LJovzwxvlwzBPaTNKJ6YZF/Uv7FyeynXN8F40 +RiQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1788716753; x=1789321553; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to:content-type; bh=YfiP06w66PJnEqo2UKKQtS6GK/rrfhVqIhL6B6Ho9XA=; b=NM3YAmZgW76tFoLGkBp6NAXXEheYn68TJHstSo4upGjzYz7ThT5ruJiQEXr+LKBuZw 6RGuWB/o2u7gCb5GmBxa7vhtOIFmB3qmTX2J/I3e3wUhRsZHh49/IBCShOIMhw9oMFSg cieOcgNDKB0RvwALahx/uT8oTh+3L2Ycuhk33lmk/b9EZo1ffDeDHxOXXbit+h3/q6Sy X8bHSpcv/1iEY77VVJiFEQEkqRAIC2czd2w8FErSAeUYjxRB6z0tkA6tLFTRBwUNLzYp NwPYVyeK7cHqQJhhunTGCn8MjNNS2cInDHIbD8qtKvSWlqHZ3amzbVhyMqzGc2MYEn9I fmEw== X-Forwarded-Encrypted: i=1; AKwUvBziDZqqXB8sC1Hh8R9uDqcpOp2Gk12XZcWhPF9J7syxREvrQPn9H+USKm/xhiLcPEw88bvHeF+w8G0kWvI=@vger.kernel.org X-Gm-Message-State: AFuF++nPNMPVu7HOoAe4uFcDlU8DVHXf7UGQ/zpH0tkGLFNM5z6iWcNs cHIxkgLXzDMCmC8Y7E9TV8gskA55n4XSSIuYGuezoIe6wtVkITuRhUgf17gRA+TnNgc= X-Gm-Gg: AYBFou2g7wupGkXjnFjmj9tCG0NeHuDqf5xnUReUS9o6+kPey7C2XtbyrEhLueSiP4/ H7Lbi++1cL+yQE9tUHuAlhls58Wtjhtb5RcVuGrzpaX7pcPFGpYKFQNN2We8fp12NIJ9y+BximP zeTMQvSlhsPkeheeuna+MT5YzqJvcaU7o4yJG2q/bye2XaEtKFDsSI2Bpuk7YptCJ/NL+3vqdsV rXZTYhMzKcffIxafJRfVFhflzDtz+TUsAuh6E7GsFKZtS2ufjjN6WVt7A1lUC1seOfevQ42skHy 8pJ67AlUFjtaxBimS7jXoUkglmyWxsnkS/fjAVZ6a2NAQSUCaN5/Gi+PNoizAlnnNMnKX51FkvN lkka2E1FzxiZUd04NjAaPBHA3tvxH15mcwbwX0nSrc92N6A7b5OhQWlu9Jf4Q2luoztMSI/ktPI N+/2DoSxFpAl3b3Qse9Q1lHOED8ZwM8za0iYhK2Kw= X-Received: by 2002:a05:600c:a05:b0:49c:f501:e428 with SMTP id 5b1f17b1804b1-49cf82e5b1amr170477405e9.8.1788716753028; Sun, 06 Sep 2026 10:45:53 -0700 (PDT) Received: from remote-01 ([84.17.55.227]) by smtp.gmail.com with ESMTPSA id 5b1f17b1804b1-49cf755c22esm245418805e9.0.2026.09.06.10.45.51 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 06 Sep 2026 10:45:52 -0700 (PDT) From: Aleksei Sviridkin To: andrew@lunn.ch, andrew+netdev@lunn.ch, hkallweit1@gmail.com, linux@armlinux.org.uk, davem@davemloft.net, edumazet@google.com, kuba@kernel.org, pabeni@redhat.com, horms@kernel.org, robh@kernel.org, krzk+dt@kernel.org, conor+dt@kernel.org Cc: ericwouds@gmail.com, netdev@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org Subject: [RFC PATCH net-next 3/7] net: phy: air: type the buckpbus core on the mdio device Date: Sun, 6 Sep 2026 17:45:39 +0000 Message-ID: <20260906174548.4106801-3-f@lex.la> X-Mailer: git-send-email 2.53.0 In-Reply-To: References: Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" The buckpbus accessors only need an MDIO device, but they take a phy_device, which ties them to a probed PHY. An upcoming MDIO device driver needs the same register access before any phy_device exists, since it runs precisely to make the PHY presentable. Retype the internal helpers onto an mdio_device and keep the exported phy_device API as page-selecting wrappers that pass &phydev->mdio. The EN8811H driver already reaches the AN8811HB pbus through an mdio_device, so this follows an existing direction rather than opening a new one. No functional change. Assisted-by: LLM Signed-off-by: Aleksei Sviridkin --- drivers/net/phy/air_phy_lib.c | 80 ++++++++++++++++++----------------- 1 file changed, 42 insertions(+), 38 deletions(-) diff --git a/drivers/net/phy/air_phy_lib.c b/drivers/net/phy/air_phy_lib.c index 5141db19fa5e..e314717843ae 100644 --- a/drivers/net/phy/air_phy_lib.c +++ b/drivers/net/phy/air_phy_lib.c @@ -14,31 +14,32 @@ =20 #include "air_phy_lib.h" =20 -static int __air_buckpbus_reg_read(struct phy_device *phydev, +static int __air_buckpbus_reg_read(struct mdio_device *mdiodev, u32 pbus_address, u32 *pbus_data) { int pbus_data_low, pbus_data_high; int ret; =20 - ret =3D __phy_write(phydev, AIR_BPBUS_MODE, AIR_BPBUS_MODE_ADDR_FIXED); + ret =3D __mdiodev_write(mdiodev, AIR_BPBUS_MODE, + AIR_BPBUS_MODE_ADDR_FIXED); if (ret < 0) return ret; =20 - ret =3D __phy_write(phydev, AIR_BPBUS_RD_ADDR_HIGH, - upper_16_bits(pbus_address)); + ret =3D __mdiodev_write(mdiodev, AIR_BPBUS_RD_ADDR_HIGH, + upper_16_bits(pbus_address)); if (ret < 0) return ret; =20 - ret =3D __phy_write(phydev, AIR_BPBUS_RD_ADDR_LOW, - lower_16_bits(pbus_address)); + ret =3D __mdiodev_write(mdiodev, AIR_BPBUS_RD_ADDR_LOW, + lower_16_bits(pbus_address)); if (ret < 0) return ret; =20 - pbus_data_high =3D __phy_read(phydev, AIR_BPBUS_RD_DATA_HIGH); + pbus_data_high =3D __mdiodev_read(mdiodev, AIR_BPBUS_RD_DATA_HIGH); if (pbus_data_high < 0) return pbus_data_high; =20 - pbus_data_low =3D __phy_read(phydev, AIR_BPBUS_RD_DATA_LOW); + pbus_data_low =3D __mdiodev_read(mdiodev, AIR_BPBUS_RD_DATA_LOW); if (pbus_data_low < 0) return pbus_data_low; =20 @@ -46,64 +47,66 @@ static int __air_buckpbus_reg_read(struct phy_device *p= hydev, return 0; } =20 -static int __air_buckpbus_reg_write(struct phy_device *phydev, +static int __air_buckpbus_reg_write(struct mdio_device *mdiodev, u32 pbus_address, u32 pbus_data) { int ret; =20 - ret =3D __phy_write(phydev, AIR_BPBUS_MODE, AIR_BPBUS_MODE_ADDR_FIXED); + ret =3D __mdiodev_write(mdiodev, AIR_BPBUS_MODE, + AIR_BPBUS_MODE_ADDR_FIXED); if (ret < 0) return ret; =20 - ret =3D __phy_write(phydev, AIR_BPBUS_WR_ADDR_HIGH, - upper_16_bits(pbus_address)); + ret =3D __mdiodev_write(mdiodev, AIR_BPBUS_WR_ADDR_HIGH, + upper_16_bits(pbus_address)); if (ret < 0) return ret; =20 - ret =3D __phy_write(phydev, AIR_BPBUS_WR_ADDR_LOW, - lower_16_bits(pbus_address)); + ret =3D __mdiodev_write(mdiodev, AIR_BPBUS_WR_ADDR_LOW, + lower_16_bits(pbus_address)); if (ret < 0) return ret; =20 - ret =3D __phy_write(phydev, AIR_BPBUS_WR_DATA_HIGH, - upper_16_bits(pbus_data)); + ret =3D __mdiodev_write(mdiodev, AIR_BPBUS_WR_DATA_HIGH, + upper_16_bits(pbus_data)); if (ret < 0) return ret; =20 - ret =3D __phy_write(phydev, AIR_BPBUS_WR_DATA_LOW, - lower_16_bits(pbus_data)); + ret =3D __mdiodev_write(mdiodev, AIR_BPBUS_WR_DATA_LOW, + lower_16_bits(pbus_data)); if (ret < 0) return ret; =20 return 0; } =20 -static int __air_buckpbus_reg_modify(struct phy_device *phydev, +static int __air_buckpbus_reg_modify(struct mdio_device *mdiodev, u32 pbus_address, u32 mask, u32 set) { int pbus_data_low, pbus_data_high; u32 pbus_data_old, pbus_data_new; int ret; =20 - ret =3D __phy_write(phydev, AIR_BPBUS_MODE, AIR_BPBUS_MODE_ADDR_FIXED); + ret =3D __mdiodev_write(mdiodev, AIR_BPBUS_MODE, + AIR_BPBUS_MODE_ADDR_FIXED); if (ret < 0) return ret; =20 - ret =3D __phy_write(phydev, AIR_BPBUS_RD_ADDR_HIGH, - upper_16_bits(pbus_address)); + ret =3D __mdiodev_write(mdiodev, AIR_BPBUS_RD_ADDR_HIGH, + upper_16_bits(pbus_address)); if (ret < 0) return ret; =20 - ret =3D __phy_write(phydev, AIR_BPBUS_RD_ADDR_LOW, - lower_16_bits(pbus_address)); + ret =3D __mdiodev_write(mdiodev, AIR_BPBUS_RD_ADDR_LOW, + lower_16_bits(pbus_address)); if (ret < 0) return ret; =20 - pbus_data_high =3D __phy_read(phydev, AIR_BPBUS_RD_DATA_HIGH); + pbus_data_high =3D __mdiodev_read(mdiodev, AIR_BPBUS_RD_DATA_HIGH); if (pbus_data_high < 0) return pbus_data_high; =20 - pbus_data_low =3D __phy_read(phydev, AIR_BPBUS_RD_DATA_LOW); + pbus_data_low =3D __mdiodev_read(mdiodev, AIR_BPBUS_RD_DATA_LOW); if (pbus_data_low < 0) return pbus_data_low; =20 @@ -112,23 +115,23 @@ static int __air_buckpbus_reg_modify(struct phy_devic= e *phydev, if (pbus_data_new =3D=3D pbus_data_old) return 0; =20 - ret =3D __phy_write(phydev, AIR_BPBUS_WR_ADDR_HIGH, - upper_16_bits(pbus_address)); + ret =3D __mdiodev_write(mdiodev, AIR_BPBUS_WR_ADDR_HIGH, + upper_16_bits(pbus_address)); if (ret < 0) return ret; =20 - ret =3D __phy_write(phydev, AIR_BPBUS_WR_ADDR_LOW, - lower_16_bits(pbus_address)); + ret =3D __mdiodev_write(mdiodev, AIR_BPBUS_WR_ADDR_LOW, + lower_16_bits(pbus_address)); if (ret < 0) return ret; =20 - ret =3D __phy_write(phydev, AIR_BPBUS_WR_DATA_HIGH, - upper_16_bits(pbus_data_new)); + ret =3D __mdiodev_write(mdiodev, AIR_BPBUS_WR_DATA_HIGH, + upper_16_bits(pbus_data_new)); if (ret < 0) return ret; =20 - ret =3D __phy_write(phydev, AIR_BPBUS_WR_DATA_LOW, - lower_16_bits(pbus_data_new)); + ret =3D __mdiodev_write(mdiodev, AIR_BPBUS_WR_DATA_LOW, + lower_16_bits(pbus_data_new)); if (ret < 0) return ret; =20 @@ -144,7 +147,8 @@ int air_phy_buckpbus_reg_read(struct phy_device *phydev= , u32 pbus_address, saved_page =3D phy_select_page(phydev, AIR_PHY_PAGE_EXTENDED_4); =20 if (saved_page >=3D 0) { - ret =3D __air_buckpbus_reg_read(phydev, pbus_address, pbus_data); + ret =3D __air_buckpbus_reg_read(&phydev->mdio, pbus_address, + pbus_data); if (ret < 0) phydev_err(phydev, "%s 0x%08x failed: %d\n", __func__, pbus_address, ret); @@ -163,7 +167,7 @@ int air_phy_buckpbus_reg_write(struct phy_device *phyde= v, u32 pbus_address, saved_page =3D phy_select_page(phydev, AIR_PHY_PAGE_EXTENDED_4); =20 if (saved_page >=3D 0) { - ret =3D __air_buckpbus_reg_write(phydev, pbus_address, + ret =3D __air_buckpbus_reg_write(&phydev->mdio, pbus_address, pbus_data); if (ret < 0) phydev_err(phydev, "%s 0x%08x failed: %d\n", __func__, @@ -183,8 +187,8 @@ int air_phy_buckpbus_reg_modify(struct phy_device *phyd= ev, u32 pbus_address, saved_page =3D phy_select_page(phydev, AIR_PHY_PAGE_EXTENDED_4); =20 if (saved_page >=3D 0) { - ret =3D __air_buckpbus_reg_modify(phydev, pbus_address, mask, - set); + ret =3D __air_buckpbus_reg_modify(&phydev->mdio, pbus_address, + mask, set); if (ret < 0) phydev_err(phydev, "%s 0x%08x failed: %d\n", __func__, pbus_address, ret); --=20 2.53.0 From nobody Sun Sep 27 03:12:52 2026 Received: from mail-wr1-f49.google.com (mail-wr1-f49.google.com [209.85.221.49]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 667E43C13E6 for ; Sun, 6 Sep 2026 17:45:56 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.221.49 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1788716759; cv=none; b=pEpGcihiFEjsJtbM6l/6PI+YDQQnLWnwKfonOS4RpVhEKatwaUZBIxH+PtC2VBzF9cm/kykIqgHiGxJLWf6nysJQc5MDM0Fh9d1RDsKPaiG1vO6Vn7NVyI98wM0kaAfZFAiYo0l/iBv7jY8wpKb0IlF1fzl32j16F7sHX9aSegI= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1788716759; c=relaxed/simple; bh=xdisZz+DkVGtPIWoZoRqXSljlwpgnhj3MZcVyEplODs=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=beuZP8uuayK+IBjue+B/Qbx5r04PVo2jaAXwr3gQ7AFRMqpiRk7ufRwKLeIV/Qn2JbTmGZDnaeLTmUrhxaxt70aoWga4YYvOlmaSrzWrqPFATDGGKWnxcNc2bR+ic7TvUO/J5uHyX8X6eeD/F+nTVnINKoZCZ6Hl8Y9QaU+893Y= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=lex.la; spf=pass smtp.mailfrom=lex.la; dkim=pass (2048-bit key) header.d=lex.la header.i=@lex.la header.b=iSDIjEge; arc=none smtp.client-ip=209.85.221.49 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=lex.la Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=lex.la Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=lex.la header.i=@lex.la header.b="iSDIjEge" Received: by mail-wr1-f49.google.com with SMTP id ffacd0b85a97d-47f96c5b722so1801486f8f.0 for ; Sun, 06 Sep 2026 10:45:56 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=lex.la; s=google; t=1788716754; x=1789321554; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to:content-type; bh=o5yq0K7Toe89sHS+2VR4FOJB6v/+peITAwOBRO1SMuw=; b=iSDIjEge5bGv/ln2407pHaMoeoavRp+dvQlyIZidBq/QDW5lW27vCK0FBAKybpG73P Fl/LZmzPx6v35IBlMVrvjnm0zE1VaPp35ySU4xtmEAMaHFVHtBMPaSEJCdMjRG/42QYC QaHGeXpA7uTOR6x23mcWNiXtViFPP9VlQVuuSBgtiHX7q3aWXxxZsePES/zH+0XzCbDh GzrL1R+CPEnjULmn2j2jdQTW5s4sAOxChG2DkRSuTwJ6zRVz1Wqe15GLL5iDkD+jMhEG 89sfvaJ/HF+h0q9UEMLxv/dFqVVTOgM6JjR2QEUCo3fl74vaJy48p5rNjUsTKZ4AAzw9 AN0Q== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1788716754; x=1789321554; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to:content-type; bh=o5yq0K7Toe89sHS+2VR4FOJB6v/+peITAwOBRO1SMuw=; b=jK/3kk6qXxrY5WntecR7pmqb2mkRKBv4ciJ6l9/w4fThdKeOUdLzZSeW2opaM4iE2P pLtgdJjeb1dBPlFc8ldsHwNLExUQUCEJLTrQrkmMqn/XaxzeiwL6QdHjcNjYVjsDeAIu 9K/ibMcBCRsgVPYSdd2iZDcFqXuh+UWXT0Dtt7afoUW0DsUOCcfrQyCT13eOaI5IArun PCaXt+MroL+K9iwaaWFxWBpFj4Tp3s3Xm3PTqbb2qq7tXhBc2xCxIMNUS1qADr5+vh5T U4OEL0Tabb8m/r/9zdoFpMViaX6d3oUrxLtuebiY2MXwHHVpVRwf0UF3CEJrvyABzv/7 FZJg== X-Forwarded-Encrypted: i=1; AKwUvBxcB9rJ3jffTJyD012ve+nIv8rsEQz/DdlJRNNSu/tUH+yYnNh8GegPp/LBPk9QsRT66eTgJn3Y09X3raw=@vger.kernel.org X-Gm-Message-State: AFuF++lkchVEHoumQAAURVbg7kUrQUV/Un4MYG5jAkmcS+thMFFSexRO e3Dt8BbgFywfjaXv/xU36TEgZVSWCzWL4vy02mjdMDiPOycD76NL8KMyM9mopwvOqbk= X-Gm-Gg: AYBFou2irljK0YZEI36JWUDR/oCGlB1iKAOVLDKkcy8mYZ1PlZHTar3IJJS81tyUv8w 1zffQ6aV0lyadrIKVMjH2ujfiAVQteUTwUMDCAPtTvvsLL1FW4Mp2NYzwumCiw3zWnBkj17lKPu dg+3YiKXhZqoK75xekb8gIMhRnBy7qIygotos5RzLJWHrkoEkXxPNsjjiTJ79lcyUcBc5Wi9Tzs 6WrWm1+6/6Q35mNQa2xc3YOpgKsa0oEZTJHYnQPrhukO9W02anIz/ISR5LL+CXM5kE4ES57Eyf1 AnhaZeWTRXVOLgc82r7dsaMdLTq8XxMIQ7LArVunM+xP1FJ5PYZxRIJcuX4NN1XfRvYhrG3FVfp gTOBd1I9ha8RsaWXcozGuL7CQaIL77pMl9012MxUwAFiglM7QFkHA90ZgIzyfiBRgiVMRR8rBrN TUu62KSIX29+/hWTXsq6vIqBVYh9rX21LvFC73yZ2gGGDpvoz8QQ== X-Received: by 2002:a05:600c:4e90:b0:49c:f3dd:e166 with SMTP id 5b1f17b1804b1-49cf826ca60mr177274745e9.13.1788716754356; Sun, 06 Sep 2026 10:45:54 -0700 (PDT) Received: from remote-01 ([84.17.55.227]) by smtp.gmail.com with ESMTPSA id 5b1f17b1804b1-49cf755c22esm245418805e9.0.2026.09.06.10.45.53 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 06 Sep 2026 10:45:54 -0700 (PDT) From: Aleksei Sviridkin To: andrew@lunn.ch, andrew+netdev@lunn.ch, hkallweit1@gmail.com, linux@armlinux.org.uk, davem@davemloft.net, edumazet@google.com, kuba@kernel.org, pabeni@redhat.com, horms@kernel.org, robh@kernel.org, krzk+dt@kernel.org, conor+dt@kernel.org Cc: ericwouds@gmail.com, netdev@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org Subject: [RFC PATCH net-next 4/7] net: phy: air: move the EN8811H firmware download into the library Date: Sun, 6 Sep 2026 17:45:40 +0000 Message-ID: <20260906174548.4106801-4-f@lex.la> X-Mailer: git-send-email 2.53.0 In-Reply-To: References: Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" The EN8811H firmware loader is welded to the PHY driver, but the next patch adds an MDIO device driver that must perform the same download before any phy_device exists. Move the download engine into the shared library, typed on the MDIO device like the buckpbus core. The moved helpers take the bus lock and save and restore the page register themselves, since phy_select_page() needs a phy_device. The write loop is broken into chunks that each take the bus lock on their own, because the larger of the two blobs held it for 65536 register writes at a stretch and stalled every other PHY on the bus. It did not matter while this only ran from phy_probe() on a quiet bus at boot; the next patches run it on a live system. The status poll asks for the MMD register through the Clause 22 indirection unconditionally. phy_read_mmd() resolved that from phydev->is_c45, which the Clause 22 probe path leaves false, so the constant records what the code already did rather than choosing it. It does the three selection writes itself rather than through mmd_phy_read(), which discards their errors and would let a failed selection read a different register back as a success. The readiness poll's timeout message moves out to the PHY driver's wrapper, which is where the errno was already being reported to a human. The poll is about to gain a caller that retries forever, and an unconditional message there would repeat with every retry; the status value it used to name stays behind at debug level. Two return values change with the move. The version read at the end of the download is now checked, so a bus error there fails the load instead of leaving the version at zero; en8811h_print_fw_version() still discards it on the AN8811HB path, which does not go through this download. And the readiness poll hands back the errno from a failed status read rather than -ENODEV, which reaches the AN8811HB probe too, since it shares the wait. Assisted-by: LLM Signed-off-by: Aleksei Sviridkin --- drivers/net/phy/air_en8811h.c | 146 +---------------- drivers/net/phy/air_phy_lib.c | 301 ++++++++++++++++++++++++++++++++++ drivers/net/phy/air_phy_lib.h | 29 ++++ 3 files changed, 337 insertions(+), 139 deletions(-) diff --git a/drivers/net/phy/air_en8811h.c b/drivers/net/phy/air_en8811h.c index ec7c44ca68e7..920cc0ea1f67 100644 --- a/drivers/net/phy/air_en8811h.c +++ b/drivers/net/phy/air_en8811h.c @@ -20,21 +20,15 @@ #include #include #include -#include =20 #include "air_phy_lib.h" =20 #define EN8811H_PHY_ID 0x03a2a411 #define AN8811HB_PHY_ID 0xc0ff04a0 =20 -#define EN8811H_MD32_DM "airoha/EthMD32.dm.bin" -#define EN8811H_MD32_DSP "airoha/EthMD32.DSP.bin" #define AN8811HB_MD32_DM "airoha/an8811hb/EthMD32_CRC.DM.bin" #define AN8811HB_MD32_DSP "airoha/an8811hb/EthMD32_CRC.DSP.bin" =20 -#define AIR_FW_ADDR_DM 0x00000000 -#define AIR_FW_ADDR_DSP 0x00100000 - /* MII Registers */ #define AIR_AUX_CTRL_STATUS 0x1d #define AIR_AUX_CTRL_STATUS_SPEED_MASK GENMASK(4, 2) @@ -44,8 +38,6 @@ #define AIR_AUX_CTRL_STATUS_SPEED_2500 0xc =20 /* Registers on MDIO_MMD_VEND1 */ -#define EN8811H_PHY_FW_STATUS 0x8009 -#define EN8811H_PHY_READY 0x02 =20 #define AIR_PHY_MCU_CMD_0 0x800b #define AIR_PHY_MCU_CMD_1 0x800c @@ -108,8 +100,6 @@ #define EN8811H_2P5G_LPA 0x3b30 #define EN8811H_2P5G_LPA_2P5G BIT(0) =20 -#define EN8811H_FW_VERSION 0x3b3c - #define EN8811H_POLARITY 0xca0f8 #define EN8811H_POLARITY_TX_NORMAL BIT(0) #define EN8811H_POLARITY_RX_REVERSE BIT(1) @@ -122,12 +112,6 @@ #define EN8811H_CLK_CGM 0xcf958 #define EN8811H_CLK_CGM_CKO BIT(26) =20 -#define EN8811H_FW_CTRL_1 0x0f0018 -#define EN8811H_FW_CTRL_1_START 0x0 -#define EN8811H_FW_CTRL_1_FINISH 0x1 -#define EN8811H_FW_CTRL_2 0x800000 -#define EN8811H_FW_CTRL_2_LOADING BIT(11) - #define AN8811HB_CRC_PM_SET1 0xf020c #define AN8811HB_CRC_PM_MON2 0xf0218 #define AN8811HB_CRC_PM_MON3 0xf021c @@ -270,86 +254,14 @@ static int __air_pbus_reg_write(struct mdio_device *m= diodev, upper_16_bits(pbus_data)); } =20 -static int __air_write_buf(struct phy_device *phydev, u32 address, - const struct firmware *fw) -{ - unsigned int offset; - int ret; - u16 val; - - ret =3D __phy_write(phydev, AIR_BPBUS_MODE, AIR_BPBUS_MODE_ADDR_INCR); - if (ret < 0) - return ret; - - ret =3D __phy_write(phydev, AIR_BPBUS_WR_ADDR_HIGH, - upper_16_bits(address)); - if (ret < 0) - return ret; - - ret =3D __phy_write(phydev, AIR_BPBUS_WR_ADDR_LOW, - lower_16_bits(address)); - if (ret < 0) - return ret; - - for (offset =3D 0; offset < fw->size; offset +=3D 4) { - val =3D get_unaligned_le16(&fw->data[offset + 2]); - ret =3D __phy_write(phydev, AIR_BPBUS_WR_DATA_HIGH, val); - if (ret < 0) - return ret; - - val =3D get_unaligned_le16(&fw->data[offset]); - ret =3D __phy_write(phydev, AIR_BPBUS_WR_DATA_LOW, val); - if (ret < 0) - return ret; - } - - return 0; -} - -static int air_write_buf(struct phy_device *phydev, u32 address, - const struct firmware *fw) -{ - int saved_page; - int ret =3D 0; - - if (fw->size % 4) { - phydev_err(phydev, "firmware size %zu is not a multiple of 4\n", - fw->size); - return -EINVAL; - } - - saved_page =3D phy_select_page(phydev, AIR_PHY_PAGE_EXTENDED_4); - - if (saved_page >=3D 0) { - ret =3D __air_write_buf(phydev, address, fw); - if (ret < 0) - phydev_err(phydev, "%s 0x%08x failed: %d\n", __func__, - address, ret); - } - - return phy_restore_page(phydev, saved_page, ret); -} - static int en8811h_wait_mcu_ready(struct phy_device *phydev) { - int ret, reg_value; + int ret =3D air_en8811h_wait_mcu_ready(&phydev->mdio); =20 - ret =3D air_phy_buckpbus_reg_write(phydev, EN8811H_FW_CTRL_1, - EN8811H_FW_CTRL_1_FINISH); - if (ret) - return ret; + if (ret < 0) + phydev_err(phydev, "MCU not ready: %pe\n", ERR_PTR(ret)); =20 - /* Because of mdio-lock, may have to wait for multiple loads */ - ret =3D phy_read_mmd_poll_timeout(phydev, MDIO_MMD_VEND1, - EN8811H_PHY_FW_STATUS, reg_value, - reg_value =3D=3D EN8811H_PHY_READY, - 20000, 7500000, true); - if (ret) { - phydev_err(phydev, "MCU not ready: 0x%x\n", reg_value); - return -ENODEV; - } - - return 0; + return ret; } =20 static int an8811hb_check_crc(struct phy_device *phydev, u32 set1, @@ -411,7 +323,7 @@ static int an8811hb_load_file(struct phy_device *phydev= , const char *name, if (ret < 0) return ret; =20 - ret =3D air_write_buf(phydev, address, fw); + ret =3D air_fw_write_buf(&phydev->mdio, address, fw); release_firmware(fw); return ret; } @@ -507,54 +419,10 @@ static int an8811hb_load_firmware(struct phy_device *= phydev) =20 static int en8811h_load_firmware(struct phy_device *phydev) { - struct device *dev =3D &phydev->mdio.dev; - const struct firmware *fw1, *fw2; + struct en8811h_priv *priv =3D phydev->priv; int ret; =20 - ret =3D request_firmware_direct(&fw1, EN8811H_MD32_DM, dev); - if (ret < 0) - return ret; - - ret =3D request_firmware_direct(&fw2, EN8811H_MD32_DSP, dev); - if (ret < 0) - goto en8811h_load_firmware_rel1; - - ret =3D air_phy_buckpbus_reg_write(phydev, EN8811H_FW_CTRL_1, - EN8811H_FW_CTRL_1_START); - if (ret < 0) - goto en8811h_load_firmware_out; - - ret =3D air_phy_buckpbus_reg_modify(phydev, EN8811H_FW_CTRL_2, - EN8811H_FW_CTRL_2_LOADING, - EN8811H_FW_CTRL_2_LOADING); - if (ret < 0) - goto en8811h_load_firmware_out; - - ret =3D air_write_buf(phydev, AIR_FW_ADDR_DM, fw1); - if (ret < 0) - goto en8811h_load_firmware_out; - - ret =3D air_write_buf(phydev, AIR_FW_ADDR_DSP, fw2); - if (ret < 0) - goto en8811h_load_firmware_out; - - ret =3D air_phy_buckpbus_reg_modify(phydev, EN8811H_FW_CTRL_2, - EN8811H_FW_CTRL_2_LOADING, 0); - if (ret < 0) - goto en8811h_load_firmware_out; - - ret =3D en8811h_wait_mcu_ready(phydev); - if (ret < 0) - goto en8811h_load_firmware_out; - - en8811h_print_fw_version(phydev); - -en8811h_load_firmware_out: - release_firmware(fw2); - -en8811h_load_firmware_rel1: - release_firmware(fw1); - + ret =3D air_en8811h_fw_download(&phydev->mdio, &priv->firmware_version); if (ret < 0) phydev_err(phydev, "Load firmware failed: %d\n", ret); =20 diff --git a/drivers/net/phy/air_phy_lib.c b/drivers/net/phy/air_phy_lib.c index e314717843ae..5b7427e0d977 100644 --- a/drivers/net/phy/air_phy_lib.c +++ b/drivers/net/phy/air_phy_lib.c @@ -8,8 +8,12 @@ */ =20 #include +#include +#include +#include #include #include +#include #include =20 #include "air_phy_lib.h" @@ -198,6 +202,303 @@ int air_phy_buckpbus_reg_modify(struct phy_device *ph= ydev, u32 pbus_address, } EXPORT_SYMBOL_GPL(air_phy_buckpbus_reg_modify); =20 +static int __air_write_buf(struct mdio_device *mdiodev, u32 address, + const u8 *data, size_t len) +{ + unsigned int offset; + int ret; + u16 val; + + ret =3D __mdiodev_write(mdiodev, AIR_BPBUS_MODE, + AIR_BPBUS_MODE_ADDR_INCR); + if (ret < 0) + return ret; + + ret =3D __mdiodev_write(mdiodev, AIR_BPBUS_WR_ADDR_HIGH, + upper_16_bits(address)); + if (ret < 0) + return ret; + + ret =3D __mdiodev_write(mdiodev, AIR_BPBUS_WR_ADDR_LOW, + lower_16_bits(address)); + if (ret < 0) + return ret; + + for (offset =3D 0; offset < len; offset +=3D 4) { + val =3D get_unaligned_le16(&data[offset + 2]); + ret =3D __mdiodev_write(mdiodev, AIR_BPBUS_WR_DATA_HIGH, val); + if (ret < 0) + return ret; + + val =3D get_unaligned_le16(&data[offset]); + ret =3D __mdiodev_write(mdiodev, AIR_BPBUS_WR_DATA_LOW, val); + if (ret < 0) + return ret; + } + + return 0; +} + +/* phy_select_page() needs a phy_device, which does not exist yet. */ +static int __air_mdio_select_page(struct mdio_device *mdiodev, int page) +{ + int saved_page, ret; + + saved_page =3D __mdiodev_read(mdiodev, AIR_EXT_PAGE_ACCESS); + if (saved_page < 0) + return saved_page; + + if (saved_page !=3D page) { + ret =3D __mdiodev_write(mdiodev, AIR_EXT_PAGE_ACCESS, page); + if (ret < 0) + return ret; + } + + return saved_page; +} + +static int __air_mdio_restore_page(struct mdio_device *mdiodev, + int saved_page, int page, int ret) +{ + int restore; + + if (saved_page !=3D page) { + restore =3D __mdiodev_write(mdiodev, AIR_EXT_PAGE_ACCESS, + saved_page); + if (ret >=3D 0 && restore < 0) + ret =3D restore; + } + + return ret; +} + +int air_fw_write_buf(struct mdio_device *mdiodev, u32 address, + const struct firmware *fw) +{ + size_t chunk, done =3D 0; + int saved_page, ret; + + if (fw->size % 4) { + dev_err(&mdiodev->dev, "firmware size %zu is not a multiple of 4\n", + fw->size); + return -EINVAL; + } + + while (done < fw->size) { + chunk =3D min_t(size_t, fw->size - done, AIR_FW_CHUNK_BYTES); + + mdiodev_lock(mdiodev); + + saved_page =3D __air_mdio_select_page(mdiodev, + AIR_PHY_PAGE_EXTENDED_4); + if (saved_page < 0) { + ret =3D saved_page; + } else { + ret =3D __air_write_buf(mdiodev, address + done, + fw->data + done, chunk); + ret =3D __air_mdio_restore_page(mdiodev, saved_page, + AIR_PHY_PAGE_EXTENDED_4, + ret); + } + + mdiodev_unlock(mdiodev); + if (ret < 0) + return ret; + + done +=3D chunk; + } + + return 0; +} +EXPORT_SYMBOL_GPL(air_fw_write_buf); + +static int air_mdio_buckpbus_reg_read(struct mdio_device *mdiodev, + u32 pbus_address, u32 *pbus_data) +{ + int saved_page, ret; + + mdiodev_lock(mdiodev); + + saved_page =3D __air_mdio_select_page(mdiodev, AIR_PHY_PAGE_EXTENDED_4); + if (saved_page < 0) { + ret =3D saved_page; + } else { + ret =3D __air_buckpbus_reg_read(mdiodev, pbus_address, pbus_data); + ret =3D __air_mdio_restore_page(mdiodev, saved_page, + AIR_PHY_PAGE_EXTENDED_4, ret); + } + + mdiodev_unlock(mdiodev); + return ret; +} + +static int air_mdio_buckpbus_reg_write(struct mdio_device *mdiodev, + u32 pbus_address, u32 pbus_data) +{ + int saved_page, ret; + + mdiodev_lock(mdiodev); + + saved_page =3D __air_mdio_select_page(mdiodev, AIR_PHY_PAGE_EXTENDED_4); + if (saved_page < 0) { + ret =3D saved_page; + } else { + ret =3D __air_buckpbus_reg_write(mdiodev, pbus_address, + pbus_data); + ret =3D __air_mdio_restore_page(mdiodev, saved_page, + AIR_PHY_PAGE_EXTENDED_4, ret); + } + + mdiodev_unlock(mdiodev); + return ret; +} + +static int air_mdio_buckpbus_reg_modify(struct mdio_device *mdiodev, + u32 pbus_address, u32 mask, u32 set) +{ + int saved_page, ret; + + mdiodev_lock(mdiodev); + + saved_page =3D __air_mdio_select_page(mdiodev, AIR_PHY_PAGE_EXTENDED_4); + if (saved_page < 0) { + ret =3D saved_page; + } else { + ret =3D __air_buckpbus_reg_modify(mdiodev, pbus_address, + mask, set); + ret =3D __air_mdio_restore_page(mdiodev, saved_page, + AIR_PHY_PAGE_EXTENDED_4, ret); + } + + mdiodev_unlock(mdiodev); + return ret; +} + +/* mmd_phy_read() drops the errors from the three writes that select the + * register, so a failed selection reads a different one back as success. + */ +static int __air_mmd_read(struct mdio_device *mdiodev, u16 devad, u16 regn= um) +{ + struct mii_bus *bus =3D mdiodev->bus; + int addr =3D mdiodev->addr; + int ret; + + ret =3D __mdiobus_write(bus, addr, MII_MMD_CTRL, devad); + if (ret < 0) + return ret; + + ret =3D __mdiobus_write(bus, addr, MII_MMD_DATA, regnum); + if (ret < 0) + return ret; + + ret =3D __mdiobus_write(bus, addr, MII_MMD_CTRL, + devad | MII_MMD_CTRL_NOINCR); + if (ret < 0) + return ret; + + return __mdiobus_read(bus, addr, MII_MMD_DATA); +} + +static int air_mmd_status_read(struct mdio_device *mdiodev) +{ + int ret; + + mdiodev_lock(mdiodev); + ret =3D __air_mmd_read(mdiodev, MDIO_MMD_VEND1, EN8811H_PHY_FW_STATUS); + mdiodev_unlock(mdiodev); + + return ret; +} + +int air_en8811h_wait_mcu_ready(struct mdio_device *mdiodev) +{ + int ret, reg_value; + + ret =3D air_mdio_buckpbus_reg_write(mdiodev, EN8811H_FW_CTRL_1, + EN8811H_FW_CTRL_1_FINISH); + if (ret) + return ret; + + /* Because of mdio-lock, may have to wait for multiple loads. A read + * error ends the poll at once, like phy_read_mmd_poll_timeout(). + */ + ret =3D read_poll_timeout(air_mmd_status_read, reg_value, + reg_value < 0 || + reg_value =3D=3D EN8811H_PHY_READY, + 20000, 7500000, true, mdiodev); + if (reg_value < 0) + return reg_value; + if (ret) { + dev_dbg(&mdiodev->dev, "MCU not ready: 0x%x\n", reg_value); + return -ENODEV; + } + + return 0; +} +EXPORT_SYMBOL_GPL(air_en8811h_wait_mcu_ready); + +int air_en8811h_fw_download(struct mdio_device *mdiodev, u32 *fw_version) +{ + const struct firmware *fw1, *fw2; + struct device *dev =3D &mdiodev->dev; + int ret; + + ret =3D request_firmware_direct(&fw1, EN8811H_MD32_DM, dev); + if (ret < 0) + return ret; + + ret =3D request_firmware_direct(&fw2, EN8811H_MD32_DSP, dev); + if (ret < 0) + goto air_fw_download_rel1; + + ret =3D air_mdio_buckpbus_reg_write(mdiodev, EN8811H_FW_CTRL_1, + EN8811H_FW_CTRL_1_START); + if (ret < 0) + goto air_fw_download_out; + + ret =3D air_mdio_buckpbus_reg_modify(mdiodev, EN8811H_FW_CTRL_2, + EN8811H_FW_CTRL_2_LOADING, + EN8811H_FW_CTRL_2_LOADING); + if (ret < 0) + goto air_fw_download_out; + + ret =3D air_fw_write_buf(mdiodev, AIR_FW_ADDR_DM, fw1); + if (ret < 0) + goto air_fw_download_out; + + ret =3D air_fw_write_buf(mdiodev, AIR_FW_ADDR_DSP, fw2); + if (ret < 0) + goto air_fw_download_out; + + ret =3D air_mdio_buckpbus_reg_modify(mdiodev, EN8811H_FW_CTRL_2, + EN8811H_FW_CTRL_2_LOADING, 0); + if (ret < 0) + goto air_fw_download_out; + + ret =3D air_en8811h_wait_mcu_ready(mdiodev); + if (ret < 0) + goto air_fw_download_out; + + ret =3D air_mdio_buckpbus_reg_read(mdiodev, EN8811H_FW_VERSION, + fw_version); + if (ret < 0) + goto air_fw_download_out; + + dev_info(dev, "MD32 firmware version: %08x\n", *fw_version); + +air_fw_download_out: + release_firmware(fw2); + +air_fw_download_rel1: + release_firmware(fw1); + + /* No error print: callers log on their own terms, and a poller + * would repeat it on every retry. + */ + return ret; +} +EXPORT_SYMBOL_GPL(air_en8811h_fw_download); + int air_phy_read_page(struct phy_device *phydev) { return __phy_read(phydev, AIR_EXT_PAGE_ACCESS); diff --git a/drivers/net/phy/air_phy_lib.h b/drivers/net/phy/air_phy_lib.h index 01bb32e7c7c9..70c8ba66bd73 100644 --- a/drivers/net/phy/air_phy_lib.h +++ b/drivers/net/phy/air_phy_lib.h @@ -16,6 +16,11 @@ #define AIR_PHY_PAGE_EXTENDED_1 0x0001 #define AIR_PHY_PAGE_EXTENDED_4 0x0004 =20 +/* Bytes written between bus releases, so the other PHYs on it get a turn. + * At a 2.5 MHz MDC this size holds the bus for about 30 ms. + */ +#define AIR_FW_CHUNK_BYTES 2304 + /* MII Registers Page 4*/ #define AIR_BPBUS_MODE 0x10 #define AIR_BPBUS_MODE_ADDR_FIXED 0x0000 @@ -29,6 +34,23 @@ #define AIR_BPBUS_RD_DATA_HIGH 0x17 #define AIR_BPBUS_RD_DATA_LOW 0x18 =20 +#define EN8811H_MD32_DM "airoha/EthMD32.dm.bin" +#define EN8811H_MD32_DSP "airoha/EthMD32.DSP.bin" + +#define AIR_FW_ADDR_DM 0x00000000 +#define AIR_FW_ADDR_DSP 0x00100000 + +#define EN8811H_FW_CTRL_1 0x0f0018 +#define EN8811H_FW_CTRL_1_START 0x0 +#define EN8811H_FW_CTRL_1_FINISH 0x1 +#define EN8811H_FW_CTRL_2 0x800000 +#define EN8811H_FW_CTRL_2_LOADING BIT(11) + +#define EN8811H_PHY_FW_STATUS 0x8009 +#define EN8811H_PHY_READY 0x02 + +#define EN8811H_FW_VERSION 0x3b3c + int air_phy_buckpbus_reg_modify(struct phy_device *phydev, u32 pbus_addres= s, u32 mask, u32 set); int air_phy_buckpbus_reg_read(struct phy_device *phydev, u32 pbus_address, @@ -38,4 +60,11 @@ int air_phy_buckpbus_reg_write(struct phy_device *phydev= , u32 pbus_address, int air_phy_read_page(struct phy_device *phydev); int air_phy_write_page(struct phy_device *phydev, int page); =20 +struct firmware; + +int air_fw_write_buf(struct mdio_device *mdiodev, u32 address, + const struct firmware *fw); +int air_en8811h_wait_mcu_ready(struct mdio_device *mdiodev); +int air_en8811h_fw_download(struct mdio_device *mdiodev, u32 *fw_version); + #endif /* __AIR_PHY_LIB_H */ --=20 2.53.0 From nobody Sun Sep 27 03:12:52 2026 Received: from mail-wm1-f42.google.com (mail-wm1-f42.google.com [209.85.128.42]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 01CF83CC7CC for ; Sun, 6 Sep 2026 17:45:57 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.128.42 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1788716759; cv=none; b=UPO9uTF29qmhNeAuFAUnglR0Z6tWGKPA6NRgzmNdEHFMk8+mHpU/VuBGh2ABhx/LkTBFEgzJqdW7bvpreSBJAVPYJoAdWfup8uD1v6E9Gjpo0HkE7/eAwnK6e7sSPjK/9/7E0XZtlbxkOYmB5CnMKWF8EmA5NcnB9dV7DxpVvDs= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1788716759; c=relaxed/simple; bh=mfqQI09wuYrBVevDapzW2RZDyiJlShiW65OxVXhZH7Y=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=dwBru9609Ghl49FD+9znC3E98HG6cvjCN2O0g9zw+K8pBbsPC3Qcnu1qzf6b3Gb303d9F8WnlAoM8Wt06qVMEwNrIR4SP0kadufoD9/sbE/eE9E6uh6oSLu9L8ZU12r8Nouw6hni1CkVCgEZ+WDoa12I4V37Z0h6JaV0eztcdJU= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=lex.la; spf=pass smtp.mailfrom=lex.la; dkim=pass (2048-bit key) header.d=lex.la header.i=@lex.la header.b=Z6joZECq; arc=none smtp.client-ip=209.85.128.42 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=lex.la Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=lex.la Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=lex.la header.i=@lex.la header.b="Z6joZECq" Received: by mail-wm1-f42.google.com with SMTP id 5b1f17b1804b1-495590dde14so38829685e9.0 for ; Sun, 06 Sep 2026 10:45:57 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=lex.la; s=google; t=1788716756; x=1789321556; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to:content-type; bh=hv48dP/ayYcrEmiR2YWQTT03r7gYDIp+vhAiB2fDDRI=; b=Z6joZECqwSQWuAkVMS3Qa07BhLVJmG82rx385TkDD7gJivhUcGTZ0NAg/PM1HQZsNg V5+YCV0P0xGbeliPHe5a6znH+nC8bWo5n5rwBF0i33nt7nPAJoCb+o37FeSo+wQIzE/9 iKzwKIK8QShX/i8TJCOtYmqY03y8T55/Php9olanRehHk6xh/3EDXOU/2+PSG6rREeyV DNhjo3cgDvU0ykIydZrBjrE+PWlF8QOnC/UhG4cW1jdxZCPOpEtwf6ysK1a3rSqbEC3/ 4JrmabYSACP8/rBfvmGMyFkGAb/oZBeXhXawWH01RKPXkcoK3nVrtLVylaH8/URzbm1E AYnQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1788716756; x=1789321556; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to:content-type; bh=hv48dP/ayYcrEmiR2YWQTT03r7gYDIp+vhAiB2fDDRI=; b=CDF301E0iIHythaX9PS1EGxU7KYnMr51vDFhxyS8Br0VPIvLt2aV4gPb7dJUJJUVXx NlRWWR5YNC5gsQStV//VWQlBFG/TUoOZMIYB2ZyxxvO9rpXlj74lO+KVJbZN9K4+7u+A nxsIc1IrwQcDYBpb3RWVdzHCSalZSrEfgJQ6c9JIZ6P59tJJfMAelVPT5ouKvEoyAzgw Z7SbogFH9em7qwrGkd/zGhgTOiIWT1c58bXKhvERb50NmkZ5aDpWiZOBTOKlrp5f4uKd /toitRZkuHgIMKwrcUKku46NO+y46gTvi004M0w+Qooe5Jtc5GiigRh69fLZ6wH7yKa7 C2Ig== X-Forwarded-Encrypted: i=1; AKwUvByGKZLvsFyFVQT823KuyU3idkPN3CDB6bbSrGuSP8n3lrlzNIqgOtbPETA/QvgdY2v7ZqO2R4u0h5sBW7E=@vger.kernel.org X-Gm-Message-State: AFuF++kkBfparRGp/ggMT9k9NlXXm4zJVsMBvXwvD61Ts6hjQRkU+haM YDKRlVbByTOtGcT8r3pxdM1gfzTZTHb3/ImEQPN0E29W+Lbkbo/h2lkhCnwbNM5H5Uo= X-Gm-Gg: AYBFou3CG9l50EB/ZajW8Lj7GclO2lHhUtfiUQZh/Suana+hby+kdm3bSAA6ULNcfrZ OwbrAKHh8RYxHwICaL5s4Lg2Afvs8/F01FzA2RVb8ZN42AL1EC4It2J2kZgMvTL+VtjkbbIFuE8 xpGDB9isIdUmTUX72cJ1rCC2kPAYPxonfq89nR8nQq+3T3CHmw4DdUQJ2SChdLlJyoQRdv1drBZ s8OCTRT/r+WU0IWLdX1P8NfLuKptm6JNQ3X30FsfWkY6wPN1zQZ3t1Bu/xWz0Q4sE4GrZQjGday jCxI8Czk6wjTNXK/xbhNMB8wJBc+MlV/5LD0KfeyKY2S6OMT6KlwmwPyHh3DPv3iDZculssBVe1 Dnaoynm9n6RFJers5THUZP9mhyD4q80EQKMm7NetzZX6uxrUb/7MCf8ry/QK3xYKGGOy3LEfch3 YGFrPatfGrzD3wHOBxOJ2rkzVFlnKXhv/i1diJyLo= X-Received: by 2002:a05:600c:a00a:b0:49c:ed94:cdd8 with SMTP id 5b1f17b1804b1-49cf81f6736mr374127555e9.6.1788716755666; Sun, 06 Sep 2026 10:45:55 -0700 (PDT) Received: from remote-01 ([84.17.55.227]) by smtp.gmail.com with ESMTPSA id 5b1f17b1804b1-49cf755c22esm245418805e9.0.2026.09.06.10.45.54 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 06 Sep 2026 10:45:55 -0700 (PDT) From: Aleksei Sviridkin To: andrew@lunn.ch, andrew+netdev@lunn.ch, hkallweit1@gmail.com, linux@armlinux.org.uk, davem@davemloft.net, edumazet@google.com, kuba@kernel.org, pabeni@redhat.com, horms@kernel.org, robh@kernel.org, krzk+dt@kernel.org, conor+dt@kernel.org Cc: ericwouds@gmail.com, netdev@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org Subject: [RFC PATCH net-next 5/7] net: phy: air: skip the download when the MD32 is already running Date: Sun, 6 Sep 2026 17:45:41 +0000 Message-ID: <20260906174548.4106801-5-f@lex.la> X-Mailer: git-send-email 2.53.0 In-Reply-To: References: Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" The download is unconditional, so a chip whose firmware was loaded by something else - a bootloader, an earlier bind of the PHY driver, or an MDIO device serving the chip - is reprogrammed at 144KB per probe. Read the status register the loader already polls for readiness and skip the download when it reports ready, only picking up the running firmware's version. Adopting is reported back distinctly from loading, because nothing on that path touches FW_CTRL_1: the PHY driver must leave the MCU restart to .config_init() rather than assume probe already did it. The image in RAM now wins over the files on disk. Where the PHY node carries no reset-gpios nothing clears that RAM on unbind, so writing new firmware files and rebinding keeps the old image running and reports its version as the current one. A power cycle, or a reset line on the PHY node for phy_detach() to assert, brings the reload back. Assisted-by: LLM Signed-off-by: Aleksei Sviridkin --- drivers/net/phy/air_en8811h.c | 4 ++-- drivers/net/phy/air_phy_lib.c | 26 ++++++++++++++++++++++++++ drivers/net/phy/air_phy_lib.h | 3 +++ 3 files changed, 31 insertions(+), 2 deletions(-) diff --git a/drivers/net/phy/air_en8811h.c b/drivers/net/phy/air_en8811h.c index 920cc0ea1f67..786c0b26ae65 100644 --- a/drivers/net/phy/air_en8811h.c +++ b/drivers/net/phy/air_en8811h.c @@ -1024,8 +1024,8 @@ static int en8811h_probe(struct phy_device *phydev) if (ret < 0) return ret; =20 - /* mcu has just restarted after firmware load */ - priv->mcu_needs_restart =3D false; + /* Adopted firmware was never restarted here. */ + priv->mcu_needs_restart =3D (ret =3D=3D 1); =20 /* MDIO_DEVS1/2 empty, so set mmds_present bits here */ phydev->c45_ids.mmds_present |=3D MDIO_DEVS_PMAPMD | MDIO_DEVS_AN; diff --git a/drivers/net/phy/air_phy_lib.c b/drivers/net/phy/air_phy_lib.c index 5b7427e0d977..a5b6b3606bec 100644 --- a/drivers/net/phy/air_phy_lib.c +++ b/drivers/net/phy/air_phy_lib.c @@ -410,6 +410,17 @@ static int air_mmd_status_read(struct mdio_device *mdi= odev) return ret; } =20 +int air_en8811h_mcu_running(struct mdio_device *mdiodev) +{ + int ret =3D air_mmd_status_read(mdiodev); + + if (ret < 0) + return ret; + + return ret =3D=3D EN8811H_PHY_READY; +} +EXPORT_SYMBOL_GPL(air_en8811h_mcu_running); + int air_en8811h_wait_mcu_ready(struct mdio_device *mdiodev) { int ret, reg_value; @@ -443,6 +454,21 @@ int air_en8811h_fw_download(struct mdio_device *mdiode= v, u32 *fw_version) struct device *dev =3D &mdiodev->dev; int ret; =20 + ret =3D air_en8811h_mcu_running(mdiodev); + if (ret < 0) + return ret; + + if (ret) { + ret =3D air_mdio_buckpbus_reg_read(mdiodev, EN8811H_FW_VERSION, + fw_version); + if (ret < 0) + return ret; + + dev_info(dev, "MD32 already running, firmware %08x\n", + *fw_version); + return 1; + } + ret =3D request_firmware_direct(&fw1, EN8811H_MD32_DM, dev); if (ret < 0) return ret; diff --git a/drivers/net/phy/air_phy_lib.h b/drivers/net/phy/air_phy_lib.h index 70c8ba66bd73..226dc9f2eb07 100644 --- a/drivers/net/phy/air_phy_lib.h +++ b/drivers/net/phy/air_phy_lib.h @@ -64,7 +64,10 @@ struct firmware; =20 int air_fw_write_buf(struct mdio_device *mdiodev, u32 address, const struct firmware *fw); +/* Returns 1 running, 0 dormant, negative on a failed status read. */ +int air_en8811h_mcu_running(struct mdio_device *mdiodev); int air_en8811h_wait_mcu_ready(struct mdio_device *mdiodev); +/* Returns 1 when it adopted firmware that was already running. */ int air_en8811h_fw_download(struct mdio_device *mdiodev, u32 *fw_version); =20 #endif /* __AIR_PHY_LIB_H */ --=20 2.53.0 From nobody Sun Sep 27 03:12:52 2026 Received: from mail-wm1-f46.google.com (mail-wm1-f46.google.com [209.85.128.46]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 3E4D03CEB98 for ; Sun, 6 Sep 2026 17:45:59 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.128.46 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1788716762; cv=none; b=r4qHjnr/Fq/GpBu+KZtHpXKpdaUomajkjOn2QRZMxUTAKvaEpx83ZifNAB5WnD9WcE+myIaWrY+B0nQTplpu9Jf5o0IHubDMFLJ6O57iX0RsVpZ4D9yZ8rw8WQmQlgW0mEUzmFiON80NMRF2nW1jgiqf6iyi1CXst0J/jt1F41Q= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1788716762; c=relaxed/simple; bh=Ao/8J7UTQtuDshYKUS2qutRCBUl/5UwBjXZJzZrvRTw=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=U3Lp0BKhEeMW4XQcW1RGAbGLsY6Y9hfgcuvLIA266yuLt5adjnP/4znE69oTxDhW7RB3wFXiosz2caiaF9P4Z6quMZDYVfNRYSgOmXLvf3PC9ceh423U8bdYpR+fY1OLmuevAnJHo90kQoG0lNANheLud/1mzNCuidp+5fLcjrY= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=lex.la; spf=pass smtp.mailfrom=lex.la; dkim=pass (2048-bit key) header.d=lex.la header.i=@lex.la header.b=RMqfoaAW; arc=none smtp.client-ip=209.85.128.46 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=lex.la Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=lex.la Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=lex.la header.i=@lex.la header.b="RMqfoaAW" Received: by mail-wm1-f46.google.com with SMTP id 5b1f17b1804b1-49cd77e0f95so23347935e9.3 for ; Sun, 06 Sep 2026 10:45:59 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=lex.la; s=google; t=1788716757; x=1789321557; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to:content-type; bh=IkXgniOUiPREmfv+HSLCD0A+Drz8mQTli5pp/XRi4lU=; b=RMqfoaAWLBTeNuhDw5Sxl8/sQk1tdOwn1Kr6ZSi3sbkOQ8k/Ah4tQg36hyMysOUHuh ruqjFXD2YMiTbgDC5O12mHl0pehqnWPs63uO0qwM/vG3XiBuyCsLbst4kxropYKGHo8P E3JDVov+DDhT9164fBpRjOCjSy+Glxt7G4a6kZrgILrJ7TrUJZJpvnaDGGu6bJZAEHFP ZpaWyKBVRuAKrfAX2sdKtBePKvfsniALGWA2ckH8gsGVqPULB+r093AjHMrNEy7Ch7UN 4qOQn4TBHq43eX6bWVC9LJEDPveM5pkZFpWHyOY4MMif6MWOA0dWMXVmMrJPHGdvFGvD 1qcg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1788716757; x=1789321557; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to:content-type; bh=IkXgniOUiPREmfv+HSLCD0A+Drz8mQTli5pp/XRi4lU=; b=Izvfy43/cPJ0UxUi1ngyyp+ZW2KhFeyJb7rbC48fCJ2Rcl5Bu6PvBn22EuAxLrO53H qywdE0ewBAb3AIWq0ag6VA4CmzqMElJibIpPnjAHtXWs7CH5y+hJMpn49pRCEiA0QmeL tj3CUahMiWDqqG7PBnDh4pPVbqn6HsKH0g7Rn1dCgYQAkk831yjP4B3WHUNZBsfec44m aRUnosDjehMl76xvNb57ij0TdEBdAaMzj889Gb4d7HF2Sy25hG3zAaES6AawMnXHGGp/ 5BOkDJaFViLJzLAmaOq48i+L4XtS1fh4UTGVr3ri0tG46hajV9SSEH05kAQ/1Ci97eYL Ditg== X-Forwarded-Encrypted: i=1; AKwUvBw7LpysuX0qUEAkOVjx4+kLEVla6YTtfqmA8W42tIpTQqItNIv7AwLWy6tvsnMlW11ckxKRStVqA9pCTlE=@vger.kernel.org X-Gm-Message-State: AFuF++mhzPdzq5jJUPJUHsnGIMTyUjdFeqdeyTwotjKr38onGS+uaIEy WPvSx2x+bVrBhFFCOHfOJrk0dYJTAuoYI0SYYtux4+bZ6LNhreNzgbGJ29kLI+qxtSE= X-Gm-Gg: AYBFou2dtoB43JR5QExY+Ihvg975QN2Hf2J/9/MjjgU7Gsfbl2l28Gz6suP7v8PB8sL Xue73D7dcSTq5tCq8zqHbvJ1HgsI/cehQhK2Anzqv+MQtPSdkQmtJD+JD8X5RFREX02cUTPXqAZ 2wGcoC8agHMlK+IRpCsvuAmnPDFeIy8TBo2/iy6FQOFuwd2LYEw603v+b9WHSBn4vJU4qjdS/a4 VgrZVeO5iWCzkOfFFoPGvwo2NgwVCoutnJEtQHBdW9zbFzeER9NZn1B0ZY2eunCJz8xcjmh+XOg 7Rm+l6Sz+eEveGoPIMFbE/Blm5jt4f7HXQ7kf6VPZukiUfoSMK2MetiB9WBondt/+zZylg1og5Z L4Dx/DWhQNPSmKanm5CnoS35RM9c7CGNClLgA67GW6BiGmn6Mud2ay3byC31QZXnACtsPOjGfTU kmSWrk7ut4ff3iSrKCRjfIh7ZmCzE1XyweMmJLML8= X-Received: by 2002:a05:600d:864a:10b0:49c:fc89:59cb with SMTP id 5b1f17b1804b1-49cfc8960ccmr109213605e9.5.1788716757248; Sun, 06 Sep 2026 10:45:57 -0700 (PDT) Received: from remote-01 ([84.17.55.227]) by smtp.gmail.com with ESMTPSA id 5b1f17b1804b1-49cf755c22esm245418805e9.0.2026.09.06.10.45.55 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 06 Sep 2026 10:45:56 -0700 (PDT) From: Aleksei Sviridkin To: andrew@lunn.ch, andrew+netdev@lunn.ch, hkallweit1@gmail.com, linux@armlinux.org.uk, davem@davemloft.net, edumazet@google.com, kuba@kernel.org, pabeni@redhat.com, horms@kernel.org, robh@kernel.org, krzk+dt@kernel.org, conor+dt@kernel.org Cc: ericwouds@gmail.com, netdev@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org Subject: [RFC PATCH net-next 6/7] net: mdio: add Airoha EN8811H MDIO device driver Date: Sun, 6 Sep 2026 17:45:42 +0000 Message-ID: <20260906174548.4106801-6-f@lex.la> X-Mailer: git-send-email 2.53.0 In-Reply-To: References: Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Until its firmware has been downloaded the EN8811H is not an Ethernet PHY, it is an MD32 microcontroller waiting in its bootloader. On systems that keep the firmware files in a filesystem, the files become readable long after the MDIO bus was scanned, and the PHY driver's probe-time download then cannot work at boot. Describe the chip as an MDIO device that polls for the files and downloads through the shared library helper once they can be read; a chip left running by the bootloader is adopted as-is. Polling rather than deferred probing because request_firmware_direct() has no usermode-helper fallback: an unmounted rootfs fails at once, and a deferral only parks the device until something else triggers the pending list, which need not happen when the files appear. There is no give-up path, since installing the firmware package on a running system is a normal thing to do. The reset line is claimed here rather than on the PHY node, and it is cycled only while the MD32 does not report a running firmware: that firmware lives in volatile RAM, so an assert on a running chip - such as the one phy_detach() performs on a PHY-node reset - would wipe it. A status read that fails says nothing about the firmware, so the line is left alone unless it is already asserted, which is reason enough for the chip not to have answered. Resume repeats the reset decision and the download in line, since a suspend that cut power leaves the MD32 back in its bootloader. Nothing yet publishes a PHY: this driver takes the chip over, and the bus that exposes it to the device tree is the next patch. Splitting there keeps the download and its retry policy separate from what registering a bus costs, which is its own failure mode with its own backoff. Assisted-by: LLM Signed-off-by: Aleksei Sviridkin --- MAINTAINERS | 2 + drivers/net/mdio/Kconfig | 13 ++ drivers/net/mdio/Makefile | 1 + drivers/net/mdio/mdio-airoha-en8811h.c | 199 +++++++++++++++++++++++ drivers/net/phy/air_phy_lib.h | 9 +- include/linux/mdio/mdio-airoha-en8811h.h | 24 +++ 6 files changed, 241 insertions(+), 7 deletions(-) create mode 100644 drivers/net/mdio/mdio-airoha-en8811h.c create mode 100644 include/linux/mdio/mdio-airoha-en8811h.h diff --git a/MAINTAINERS b/MAINTAINERS index 4ca19275f4d0..3bd86df2be57 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -755,6 +755,8 @@ M: Aleksei Sviridkin L: netdev@vger.kernel.org S: Maintained F: Documentation/devicetree/bindings/net/airoha,en8811h-mcu.yaml +F: drivers/net/mdio/mdio-airoha-en8811h.c +F: include/linux/mdio/mdio-airoha-en8811h.h =20 AIROHA ETHERNET DRIVER M: Lorenzo Bianconi diff --git a/drivers/net/mdio/Kconfig b/drivers/net/mdio/Kconfig index d44278f26fab..33efc6bc875f 100644 --- a/drivers/net/mdio/Kconfig +++ b/drivers/net/mdio/Kconfig @@ -29,6 +29,19 @@ config MDIO_AIROHA This module provides a driver for the MDIO busses found in the Airoha AN7583 SoC's. =20 +config MDIO_AIROHA_EN8811H + tristate "Airoha EN8811H MDIO device support" + depends on OF_MDIO + depends on FW_LOADER + select AIR_NET_PHYLIB + imply AIR_EN8811H_PHY + help + This module provides a driver for the Airoha EN8811H, which is an + MD32 microcontroller until firmware is downloaded into it and only + becomes an Ethernet PHY afterwards. The driver downloads that + firmware once it becomes readable, or adopts firmware a bootloader + left running. + config MDIO_SUN4I tristate "Allwinner sun4i MDIO interface support" depends on ARCH_SUNXI || COMPILE_TEST diff --git a/drivers/net/mdio/Makefile b/drivers/net/mdio/Makefile index 048586746026..06d096675dac 100644 --- a/drivers/net/mdio/Makefile +++ b/drivers/net/mdio/Makefile @@ -6,6 +6,7 @@ obj-$(CONFIG_FWNODE_MDIO) +=3D fwnode_mdio.o obj-$(CONFIG_OF_MDIO) +=3D of_mdio.o =20 obj-$(CONFIG_MDIO_AIROHA) +=3D mdio-airoha.o +obj-$(CONFIG_MDIO_AIROHA_EN8811H) +=3D mdio-airoha-en8811h.o obj-$(CONFIG_MDIO_ASPEED) +=3D mdio-aspeed.o obj-$(CONFIG_MDIO_BCM_IPROC) +=3D mdio-bcm-iproc.o obj-$(CONFIG_MDIO_BCM_UNIMAC) +=3D mdio-bcm-unimac.o diff --git a/drivers/net/mdio/mdio-airoha-en8811h.c b/drivers/net/mdio/mdio= -airoha-en8811h.c new file mode 100644 index 000000000000..d94d74d85f10 --- /dev/null +++ b/drivers/net/mdio/mdio-airoha-en8811h.c @@ -0,0 +1,199 @@ +// SPDX-License-Identifier: GPL-2.0+ +/* + * Airoha EN8811H MDIO device driver + * + * The EN8811H is an MD32 microcontroller until firmware is downloaded into + * it, and only then an Ethernet PHY. + * + * Copyright (C) 2026 Aleksei Sviridkin + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#define EN8811H_FW_POLL_MIN_MS 1000 +#define EN8811H_FW_POLL_MAX_MS 30000 +#define EN8811H_FW_WARN_MS 60000 + +struct en8811h_mcu { + struct mdio_device *mdiodev; + struct gpio_desc *reset_gpio; + struct delayed_work fw_poll; + unsigned int poll_ms; + unsigned int waited_ms; + u32 fw_version; + bool warned; +}; + +static void en8811h_mcu_fw_poll(struct work_struct *work) +{ + struct en8811h_mcu *mcu =3D container_of(to_delayed_work(work), + struct en8811h_mcu, fw_poll); + struct device *dev =3D &mcu->mdiodev->dev; + int ret; + + ret =3D air_en8811h_fw_download(mcu->mdiodev, &mcu->fw_version); + if (ret >=3D 0) { + dev_dbg(dev, "firmware %08x running after %ums\n", + mcu->fw_version, mcu->waited_ms); + ret =3D firmware_request_cache(dev, EN8811H_MD32_DM) ?: + firmware_request_cache(dev, EN8811H_MD32_DSP); + if (ret) + dev_dbg(dev, "not cached, resume will want the files: %pe\n", + ERR_PTR(ret)); + return; + } + + mcu->waited_ms +=3D mcu->poll_ms; + if (!mcu->warned && mcu->waited_ms >=3D EN8811H_FW_WARN_MS) { + if (ret =3D=3D -ENOENT) + dev_warn(dev, "still waiting for %s and %s\n", + EN8811H_MD32_DM, EN8811H_MD32_DSP); + else + dev_warn(dev, "firmware download keeps failing: %pe\n", + ERR_PTR(ret)); + mcu->warned =3D true; + } + + mcu->poll_ms =3D min(mcu->poll_ms * 2, EN8811H_FW_POLL_MAX_MS); + queue_delayed_work(system_freezable_wq, &mcu->fw_poll, + msecs_to_jiffies(mcu->poll_ms)); +} + +/* The firmware lives in volatile RAM: no reset while the MD32 reports rea= dy. */ +static void en8811h_mcu_reset_if_dormant(struct en8811h_mcu *mcu) +{ + struct mdio_device *mdiodev =3D mcu->mdiodev; + struct device *dev =3D &mdiodev->dev; + u32 assert_us =3D 0, deassert_us =3D 0; + int ret; + + ret =3D air_en8811h_mcu_running(mdiodev); + if (ret > 0) { + dev_dbg(dev, "MD32 already running, leaving reset alone\n"); + return; + } + + if (!mcu->reset_gpio) + return; + + /* A failed read is not a dormant chip, so do not touch a line that + * is already deasserted. An asserted one is why the read failed. + */ + if (ret < 0 && gpiod_get_value_cansleep(mcu->reset_gpio) <=3D 0) { + dev_dbg(dev, "MD32 state unknown (%d), leaving reset alone\n", + ret); + return; + } + + device_property_read_u32(dev, "reset-assert-us", &assert_us); + device_property_read_u32(dev, "reset-deassert-us", &deassert_us); + + ret =3D gpiod_direction_output(mcu->reset_gpio, 1); + if (ret) { + dev_warn(dev, "reset not asserted: %pe\n", ERR_PTR(ret)); + return; + } + + if (assert_us) + fsleep(assert_us); + + gpiod_set_value_cansleep(mcu->reset_gpio, 0); + if (deassert_us) + fsleep(deassert_us); +} + +static int en8811h_mcu_probe(struct mdio_device *mdiodev) +{ + struct device *dev =3D &mdiodev->dev; + struct en8811h_mcu *mcu; + + mcu =3D devm_kzalloc(dev, sizeof(*mcu), GFP_KERNEL); + if (!mcu) + return -ENOMEM; + + mcu->mdiodev =3D mdiodev; + mdiodev_set_drvdata(mdiodev, mcu); + + /* The core claims reset-gpios only for devices flagged as PHYs. */ + mcu->reset_gpio =3D devm_gpiod_get_optional(dev, "reset", GPIOD_ASIS); + if (IS_ERR(mcu->reset_gpio)) + return dev_err_probe(dev, PTR_ERR(mcu->reset_gpio), + "failed to get reset GPIO\n"); + + if (mcu->reset_gpio) + gpiod_set_consumer_name(mcu->reset_gpio, "EN8811H reset"); + + en8811h_mcu_reset_if_dormant(mcu); + + mcu->poll_ms =3D EN8811H_FW_POLL_MIN_MS; + INIT_DELAYED_WORK(&mcu->fw_poll, en8811h_mcu_fw_poll); + /* Freezable: neither the file lookup nor the download may land on + * a suspending bus. + */ + queue_delayed_work(system_freezable_wq, &mcu->fw_poll, 0); + + return 0; +} + +static void en8811h_mcu_remove(struct mdio_device *mdiodev) +{ + struct en8811h_mcu *mcu =3D mdiodev_get_drvdata(mdiodev); + + cancel_delayed_work_sync(&mcu->fw_poll); +} + +static int en8811h_mcu_resume(struct device *dev) +{ + struct en8811h_mcu *mcu =3D dev_get_drvdata(dev); + + int ret; + + /* Not on the workqueue: the child PHY's own resume calls + * phy_init_hw() straight after this one and needs the firmware by + * then. request_firmware() is answered from the cache the download + * registered, so it does not wait for a filesystem. + */ + en8811h_mcu_reset_if_dormant(mcu); + ret =3D air_en8811h_fw_download(mcu->mdiodev, &mcu->fw_version); + if (ret < 0) + dev_err(dev, "firmware not restored: %pe\n", ERR_PTR(ret)); + + return 0; +} + +static DEFINE_SIMPLE_DEV_PM_OPS(en8811h_mcu_pm_ops, NULL, en8811h_mcu_resu= me); + +static const struct of_device_id en8811h_mcu_of_match[] =3D { + { .compatible =3D "airoha,en8811h-mcu" }, + { } +}; +MODULE_DEVICE_TABLE(of, en8811h_mcu_of_match); + +static struct mdio_driver en8811h_mcu_driver =3D { + .probe =3D en8811h_mcu_probe, + .remove =3D en8811h_mcu_remove, + .mdiodrv.driver =3D { + .name =3D "airoha-en8811h-mcu", + .of_match_table =3D en8811h_mcu_of_match, + .pm =3D pm_sleep_ptr(&en8811h_mcu_pm_ops), + }, +}; + +mdio_module_driver(en8811h_mcu_driver); + +MODULE_FIRMWARE(EN8811H_MD32_DM); +MODULE_FIRMWARE(EN8811H_MD32_DSP); + +MODULE_DESCRIPTION("Airoha EN8811H MDIO device driver"); +MODULE_AUTHOR("Aleksei Sviridkin "); +MODULE_LICENSE("GPL"); diff --git a/drivers/net/phy/air_phy_lib.h b/drivers/net/phy/air_phy_lib.h index 226dc9f2eb07..3391396aecd1 100644 --- a/drivers/net/phy/air_phy_lib.h +++ b/drivers/net/phy/air_phy_lib.h @@ -10,6 +10,8 @@ =20 #include =20 +#include + #define AIR_EXT_PAGE_ACCESS 0x1f =20 #define AIR_PHY_PAGE_STANDARD 0x0000 @@ -34,9 +36,6 @@ #define AIR_BPBUS_RD_DATA_HIGH 0x17 #define AIR_BPBUS_RD_DATA_LOW 0x18 =20 -#define EN8811H_MD32_DM "airoha/EthMD32.dm.bin" -#define EN8811H_MD32_DSP "airoha/EthMD32.DSP.bin" - #define AIR_FW_ADDR_DM 0x00000000 #define AIR_FW_ADDR_DSP 0x00100000 =20 @@ -64,10 +63,6 @@ struct firmware; =20 int air_fw_write_buf(struct mdio_device *mdiodev, u32 address, const struct firmware *fw); -/* Returns 1 running, 0 dormant, negative on a failed status read. */ -int air_en8811h_mcu_running(struct mdio_device *mdiodev); int air_en8811h_wait_mcu_ready(struct mdio_device *mdiodev); -/* Returns 1 when it adopted firmware that was already running. */ -int air_en8811h_fw_download(struct mdio_device *mdiodev, u32 *fw_version); =20 #endif /* __AIR_PHY_LIB_H */ diff --git a/include/linux/mdio/mdio-airoha-en8811h.h b/include/linux/mdio/= mdio-airoha-en8811h.h new file mode 100644 index 000000000000..0d23811e90dc --- /dev/null +++ b/include/linux/mdio/mdio-airoha-en8811h.h @@ -0,0 +1,24 @@ +/* SPDX-License-Identifier: GPL-2.0+ */ +/* + * Copyright (C) 2026 Airoha Technology Corp. + * Copyright (C) 2026 Collabora Ltd. + * Louis-Alexis Eyraud + * Copyright (C) 2026 Aleksei Sviridkin + */ + +#ifndef __LINUX_MDIO_AIROHA_EN8811H_H +#define __LINUX_MDIO_AIROHA_EN8811H_H + +#include + +struct mdio_device; + +#define EN8811H_MD32_DM "airoha/EthMD32.dm.bin" +#define EN8811H_MD32_DSP "airoha/EthMD32.DSP.bin" + +/* Returns 1 running, 0 dormant, negative on a failed status read. */ +int air_en8811h_mcu_running(struct mdio_device *mdiodev); +/* Returns 1 when it adopted firmware that was already running. */ +int air_en8811h_fw_download(struct mdio_device *mdiodev, u32 *fw_version); + +#endif /* __LINUX_MDIO_AIROHA_EN8811H_H */ --=20 2.53.0 From nobody Sun Sep 27 03:12:52 2026 Received: from mail-wr1-f43.google.com (mail-wr1-f43.google.com [209.85.221.43]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 0ACB13D0930 for ; Sun, 6 Sep 2026 17:46:00 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.221.43 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1788716763; cv=none; b=bQrun473+y7OUwD0hHB74a/60pHLMR2ohUjSwAweEUeuCv3o8rJ/Fq6x+YhZdArDaHBlbC9A7cx2LAOS74qz8c3ETAuCi1Pkz0RIbDBI4LZ5J+6g862u9LtwS9DraDKgzUkh8/ecBoE0QpTDg20ouSlaH811ogTnYaISkizfuHo= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1788716763; c=relaxed/simple; bh=2BqZuNQUsuhU72t6ZGDmgpOXQYFq0A4B3/A2iWLl/PE=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=TnzNkxoo3y7i1cBep7E2h0n2xzZQ18oqneAsDDa5ibgpPCPtQnHIy2CmCWLioPkTDhCNQDAVfHsLY45cImUyebP3V8lx+ivq82hOjm1VFCvrGWfzdk2b0zdmhZIp+YEOS1yV3A1SPt27e+FnqM4gD1a0wUZqQ0k0oxGnpO8CRVs= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=lex.la; spf=pass smtp.mailfrom=lex.la; dkim=pass (2048-bit key) header.d=lex.la header.i=@lex.la header.b=gg4M2ko3; arc=none smtp.client-ip=209.85.221.43 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=lex.la Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=lex.la Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=lex.la header.i=@lex.la header.b="gg4M2ko3" Received: by mail-wr1-f43.google.com with SMTP id ffacd0b85a97d-482e257a23aso1859859f8f.0 for ; Sun, 06 Sep 2026 10:46:00 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=lex.la; s=google; t=1788716759; x=1789321559; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to:content-type; bh=zTZmo3y5f7B2FX3QbSoe4vubstq0cEhJ4K9Y6fE9NwU=; b=gg4M2ko3ZEKHnlsSOTuL9oycsbihXNQkt6Mbv+BwBj5Xk5C/ElOIVlRySTo2iVShEN kcxs2B2ZdPOwO0J3w352Qp5vcoRaZf9jXHXW2iz/oZf8gpAQqPBO8jcUZwUGwSBwwUs4 8B8cHdOv1GI9RWfXkpRlXVo33aA5eu5g5sFv3iue2jWMJzqV7LwWwi5WgiPBkTbWHgd2 OKFqW/McMthdBCXHpkUa9yuuUp+EdficsTEq0MDYzBu+JOR/9pwecjEWcksLe93sUP98 sQo0oA/Hf0WD/gFEHzSOJCg1WI5CYtChs0K+6u+Eh9fnpEoulINWg5LrAssEYabErtkZ pKhQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1788716759; x=1789321559; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to:content-type; bh=zTZmo3y5f7B2FX3QbSoe4vubstq0cEhJ4K9Y6fE9NwU=; b=mlZh++q+MapdyLx/Tp2SZ3q53WVnqcAMZrWqqQ6eyNqQaU7+0AZ2OnqH4gPk6AxdGz Knqw0BbZzGoHWdKc8uX9y74Ju3n4vmKM6i393WXEYOcXcvP9BJMqE8qVjNaejtQoSg3F 3K1VBrOGeVz0eigoIT+dssr/ibpl+grzToxu6/Cg2/+3PBoDz8OWHS77moDuEy4foaFP Kjy63U1XV5E8dctX+q7uPH36a9JboyNdSj1NeRFb8NSY035yUZf8VXaseZEC5sjKVtYi ciID7Itw7uRCC8zgM8Yy0pvPg2adiLTHBUN2N2/TwznM8Jc6vf+VBWHKgZoG5GwDy+nC tk6w== X-Forwarded-Encrypted: i=1; AKwUvByRhoeqd1Oe43FpmaEO/oStIFrgCb36SQqEthHK+VK7JMzwc5/PP10pOLuQeK2S7lnXBTeGlCsa4hgOZ0I=@vger.kernel.org X-Gm-Message-State: AFuF++mUzL7rklEXiuJYe6YBheDf8DP0uBgjopaae6qpREPu8nBHJGFQ 1mT0qSdTKbCq0/SFqJz9UNKOz8ROQ8hYYrWruHCwJQ+I3Xd14ipvM4uwXiOUGIcPCRk= X-Gm-Gg: AYBFou1cMyjRJGCGV4Kxby9aENdlSvJ76PgLU0JwsRXxb+p/7wTN+mGC9X7GpXSX2GR 1+ZJYry3+9ITzYGkjNFscVIftfosVycv80ZPP99OFh/7oKSdze0SXoUI99xNeYeEpLvm95HR/XJ fn0ztTzU+pWOoviC5DA/98r3I56JwW2Mthvd+a/sSz6I7EWbzIT6cva20nz0IrE4xLOoa+vT2g/ ySo0U4i08+7V5Xm/dnJU9/xlS6sZgijoc7t9RiUgvkU7BNJavoyF/TN9wE/rFM7pm49pNOmNpcW cc/Nns00DmXGxdV5i/9EL/gNa7RONxGBwWi+DKekYk/9k0MuAQy7TzAyN+CMHxKCYBH90ypcXg7 /Qzhbb5xEuPMYfRhA5INhg0now9ZAtoCG4ebw0/KBLWlgjQLGNXYpf1DMx6RiRLHD+KzfJxvgo0 EC5OJfjfzIaYolFpSNcPOWqySZ66DPn9niPNbIjGU= X-Received: by 2002:a05:600c:64c6:b0:49c:fa20:cc02 with SMTP id 5b1f17b1804b1-49cfa20ccaemr153286775e9.25.1788716758759; Sun, 06 Sep 2026 10:45:58 -0700 (PDT) Received: from remote-01 ([84.17.55.227]) by smtp.gmail.com with ESMTPSA id 5b1f17b1804b1-49cf755c22esm245418805e9.0.2026.09.06.10.45.57 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Sun, 06 Sep 2026 10:45:58 -0700 (PDT) From: Aleksei Sviridkin To: andrew@lunn.ch, andrew+netdev@lunn.ch, hkallweit1@gmail.com, linux@armlinux.org.uk, davem@davemloft.net, edumazet@google.com, kuba@kernel.org, pabeni@redhat.com, horms@kernel.org, robh@kernel.org, krzk+dt@kernel.org, conor+dt@kernel.org Cc: ericwouds@gmail.com, netdev@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org Subject: [RFC PATCH net-next 7/7] net: mdio: en8811h: add the nested bus Date: Sun, 6 Sep 2026 17:45:43 +0000 Message-ID: <20260906174548.4106801-7-f@lex.la> X-Mailer: git-send-email 2.53.0 In-Reply-To: References: Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Registering the bus is what publishes the PHY, so it must happen only once the MD32 is running its firmware. Put the PHY on a bus of its own rather than on the parent so that the device tree can describe it normally, interrupts included, and so that the MCU keeps ownership of the reset line the PHY must not touch. Only the address the MD32 answers on is passed through. Publishing the PHY there splits the two agents that drive this chip onto two mutexes: the PHY holds the child bus lock across a whole paged sequence while each frame under it takes the parent alone, so a download holding only the parent would land between two of those frames and leave the PHY writing to a page it did not select. This driver therefore takes the child bus lock around its own chip access once the bus exists, and the library beneath it takes the parent one level down. The level cannot be baked into the library: reached from here the parent sits below a lock already held, while reached from the PHY driver on this same bus the library takes the child itself. The caller passes it down. MDIO_MUTEX_NESTED is what the child bus's own accessors already use for the parent, so this adds no edge lockdep did not have; the enum's remaining value belongs to mdio-mux, so a bus stacked under another nested bus would want a new one. The download becomes the first of two phases, since registering the bus can fail on its own and wants its own backoff and warning. That second phase gives up once its minute is spent, where the first does not: firmware files can be installed at any time, but a registration that keeps failing repeats a bus creation, a message from the MDIO core and a pair of uevents on every retry, and only a deferred probe resolves by itself. A driver that stopped there needs to be unbound and bound again. Resume now puts a failed reload back to the poller rather than leaving it, but that restores the chip and not the port: the PHY below has run its own resume by then and failed, and nothing calls phy_init_hw() a second time, so it stays unconfigured until its driver is rebound. Telling a consumer to re-initialise is the same mechanism this driver lacks for telling one to let go, and it is not invented here. The sysfs bind attributes are suppressed, because unregistering this bus while its PHY is attached leaves the consumer holding a phy_device whose driver is gone, and the driver cannot disconnect a consumer it does not know. Module unload was already refused, since attaching a PHY takes a reference on the bus owner. Removing the parent MDIO bus still reaches this driver's remove and is not covered; that wants a way for a bus to tell its PHYs' consumers to let go. Assisted-by: LLM Signed-off-by: Aleksei Sviridkin --- drivers/net/mdio/mdio-airoha-en8811h.c | 223 +++++++++++++++++++++-- drivers/net/phy/air_en8811h.c | 7 +- drivers/net/phy/air_phy_lib.c | 64 ++++--- drivers/net/phy/air_phy_lib.h | 4 +- include/linux/mdio/mdio-airoha-en8811h.h | 5 +- 5 files changed, 251 insertions(+), 52 deletions(-) diff --git a/drivers/net/mdio/mdio-airoha-en8811h.c b/drivers/net/mdio/mdio= -airoha-en8811h.c index d94d74d85f10..722455891472 100644 --- a/drivers/net/mdio/mdio-airoha-en8811h.c +++ b/drivers/net/mdio/mdio-airoha-en8811h.c @@ -14,6 +14,8 @@ #include #include #include +#include +#include #include #include #include @@ -28,21 +30,144 @@ struct en8811h_mcu { struct mdio_device *mdiodev; struct gpio_desc *reset_gpio; struct delayed_work fw_poll; + struct mii_bus *bus; unsigned int poll_ms; unsigned int waited_ms; u32 fw_version; bool warned; + bool fw_running; }; =20 +static int en8811h_mcu_read(struct mii_bus *bus, int addr, int regnum) +{ + struct en8811h_mcu *mcu =3D bus->priv; + + if (addr !=3D mcu->mdiodev->addr) + return -ENODEV; + + return mdiobus_read_nested(mcu->mdiodev->bus, addr, regnum); +} + +static int en8811h_mcu_write(struct mii_bus *bus, int addr, int regnum, u1= 6 val) +{ + struct en8811h_mcu *mcu =3D bus->priv; + + if (addr !=3D mcu->mdiodev->addr) + return -ENODEV; + + return mdiobus_write_nested(mcu->mdiodev->bus, addr, regnum, val); +} + +static int en8811h_mcu_read_c45(struct mii_bus *bus, int addr, int devad, + int regnum) +{ + struct en8811h_mcu *mcu =3D bus->priv; + + if (addr !=3D mcu->mdiodev->addr) + return -ENODEV; + + return mdiobus_c45_read_nested(mcu->mdiodev->bus, addr, devad, regnum); +} + +static int en8811h_mcu_write_c45(struct mii_bus *bus, int addr, int devad, + int regnum, u16 val) +{ + struct en8811h_mcu *mcu =3D bus->priv; + + if (addr !=3D mcu->mdiodev->addr) + return -ENODEV; + + return mdiobus_c45_write_nested(mcu->mdiodev->bus, addr, devad, regnum, + val); +} + +static int en8811h_mcu_bus_register(struct en8811h_mcu *mcu) +{ + struct mii_bus *parent =3D mcu->mdiodev->bus; + struct device *dev =3D &mcu->mdiodev->dev; + struct device_node *np; + struct mii_bus *bus; + int ret; + + np =3D of_get_child_by_name(dev->of_node, "mdio"); + if (!np) + return -ENODEV; + + /* Not devm: this is retried, and a devm bus would only be freed at + * detach. + */ + bus =3D mdiobus_alloc(); + if (!bus) { + of_node_put(np); + return -ENOMEM; + } + + bus->name =3D "airoha-en8811h"; + snprintf(bus->id, MII_BUS_ID_SIZE, "%s", dev_name(dev)); + bus->priv =3D mcu; + bus->parent =3D dev; + if (parent->read) { + bus->read =3D en8811h_mcu_read; + bus->write =3D en8811h_mcu_write; + } + if (parent->read_c45) { + bus->read_c45 =3D en8811h_mcu_read_c45; + bus->write_c45 =3D en8811h_mcu_write_c45; + } + + ret =3D of_mdiobus_register(bus, np); + of_node_put(np); + if (!ret && !mdiobus_get_phy(bus, mcu->mdiodev->addr)) { + /* An ID read that failed leaves the bus registered and the + * PHY absent; of_mdiobus_register() returns 0 either way. + */ + mdiobus_unregister(bus); + ret =3D -ENODEV; + } + if (ret) { + mdiobus_free(bus); + return ret; + } + + mcu->bus =3D bus; + return 0; +} + +/* Serialise with the PHY below, which reaches the same registers under + * this lock through phy_select_page(). + */ +static struct mii_bus *en8811h_mcu_chip_lock(struct en8811h_mcu *mcu) +{ + struct mii_bus *bus =3D mcu->bus; + + if (bus) + mutex_lock(&bus->mdio_lock); + + return bus; +} + +static void en8811h_mcu_chip_unlock(struct mii_bus *bus) +{ + if (bus) + mutex_unlock(&bus->mdio_lock); +} + static void en8811h_mcu_fw_poll(struct work_struct *work) { struct en8811h_mcu *mcu =3D container_of(to_delayed_work(work), struct en8811h_mcu, fw_poll); struct device *dev =3D &mcu->mdiodev->dev; + struct mii_bus *chip; int ret; =20 - ret =3D air_en8811h_fw_download(mcu->mdiodev, &mcu->fw_version); - if (ret >=3D 0) { + if (!mcu->fw_running) { + chip =3D en8811h_mcu_chip_lock(mcu); + ret =3D air_en8811h_fw_download(mcu->mdiodev, &mcu->fw_version, + !!chip); + en8811h_mcu_chip_unlock(chip); + if (ret < 0) + goto retry; + dev_dbg(dev, "firmware %08x running after %ums\n", mcu->fw_version, mcu->waited_ms); ret =3D firmware_request_cache(dev, EN8811H_MD32_DM) ?: @@ -50,34 +175,58 @@ static void en8811h_mcu_fw_poll(struct work_struct *wo= rk) if (ret) dev_dbg(dev, "not cached, resume will want the files: %pe\n", ERR_PTR(ret)); - return; + mcu->fw_running =3D true; + mcu->poll_ms =3D EN8811H_FW_POLL_MIN_MS; + mcu->waited_ms =3D 0; + mcu->warned =3D false; } =20 - mcu->waited_ms +=3D mcu->poll_ms; + /* Resume re-runs the download, so the bus can already be here, and + * fwnode_mdio defers while the PHY node's interrupt controller is + * missing, so a failure is not necessarily permanent. + */ + ret =3D mcu->bus ? 0 : en8811h_mcu_bus_register(mcu); + if (!ret) + return; + +retry: if (!mcu->warned && mcu->waited_ms >=3D EN8811H_FW_WARN_MS) { - if (ret =3D=3D -ENOENT) - dev_warn(dev, "still waiting for %s and %s\n", - EN8811H_MD32_DM, EN8811H_MD32_DSP); + if (!mcu->fw_running) + dev_warn(dev, "no firmware after %ums of waiting for %s and %s: %pe\n", + mcu->waited_ms, EN8811H_MD32_DM, + EN8811H_MD32_DSP, ERR_PTR(ret)); else - dev_warn(dev, "firmware download keeps failing: %pe\n", + dev_warn(dev, "no PHY at address %d, %ums after the firmware started: %= pe\n", + mcu->mdiodev->addr, mcu->waited_ms, ERR_PTR(ret)); mcu->warned =3D true; } =20 + /* Past its budget, only a deferral will change on its own: every + * other error repeats a bus registration, its message from the MDIO + * core and its uevents for the uptime. Firmware files are the + * exception, since they can be installed at any time. + */ + if (mcu->fw_running && ret !=3D -EPROBE_DEFER && + mcu->waited_ms >=3D EN8811H_FW_WARN_MS) + return; + mcu->poll_ms =3D min(mcu->poll_ms * 2, EN8811H_FW_POLL_MAX_MS); + /* Count the sleep ahead: the first run was immediate. */ + mcu->waited_ms +=3D mcu->poll_ms; queue_delayed_work(system_freezable_wq, &mcu->fw_poll, msecs_to_jiffies(mcu->poll_ms)); } =20 /* The firmware lives in volatile RAM: no reset while the MD32 reports rea= dy. */ -static void en8811h_mcu_reset_if_dormant(struct en8811h_mcu *mcu) +static void en8811h_mcu_reset_if_dormant(struct en8811h_mcu *mcu, bool nes= ted) { struct mdio_device *mdiodev =3D mcu->mdiodev; struct device *dev =3D &mdiodev->dev; u32 assert_us =3D 0, deassert_us =3D 0; int ret; =20 - ret =3D air_en8811h_mcu_running(mdiodev); + ret =3D air_en8811h_mcu_running(mdiodev, nested); if (ret > 0) { dev_dbg(dev, "MD32 already running, leaving reset alone\n"); return; @@ -116,6 +265,7 @@ static int en8811h_mcu_probe(struct mdio_device *mdiode= v) { struct device *dev =3D &mdiodev->dev; struct en8811h_mcu *mcu; + struct device_node *np; =20 mcu =3D devm_kzalloc(dev, sizeof(*mcu), GFP_KERNEL); if (!mcu) @@ -124,6 +274,15 @@ static int en8811h_mcu_probe(struct mdio_device *mdiod= ev) mcu->mdiodev =3D mdiodev; mdiodev_set_drvdata(mdiodev, mcu); =20 + /* Registration needs this only once the firmware runs, but a DT + * hole should fail the bind now, not as a work-item error later. + */ + np =3D of_get_child_by_name(dev->of_node, "mdio"); + if (!np) + return dev_err_probe(dev, -ENODEV, + "no mdio node describing the PHY\n"); + of_node_put(np); + /* The core claims reset-gpios only for devices flagged as PHYs. */ mcu->reset_gpio =3D devm_gpiod_get_optional(dev, "reset", GPIOD_ASIS); if (IS_ERR(mcu->reset_gpio)) @@ -133,7 +292,7 @@ static int en8811h_mcu_probe(struct mdio_device *mdiode= v) if (mcu->reset_gpio) gpiod_set_consumer_name(mcu->reset_gpio, "EN8811H reset"); =20 - en8811h_mcu_reset_if_dormant(mcu); + en8811h_mcu_reset_if_dormant(mcu, false); =20 mcu->poll_ms =3D EN8811H_FW_POLL_MIN_MS; INIT_DELAYED_WORK(&mcu->fw_poll, en8811h_mcu_fw_poll); @@ -150,23 +309,43 @@ static void en8811h_mcu_remove(struct mdio_device *md= iodev) struct en8811h_mcu *mcu =3D mdiodev_get_drvdata(mdiodev); =20 cancel_delayed_work_sync(&mcu->fw_poll); + if (mcu->bus) { + mdiobus_unregister(mcu->bus); + mdiobus_free(mcu->bus); + mcu->bus =3D NULL; + } } =20 static int en8811h_mcu_resume(struct device *dev) { struct en8811h_mcu *mcu =3D dev_get_drvdata(dev); - + struct mii_bus *chip; int ret; =20 - /* Not on the workqueue: the child PHY's own resume calls - * phy_init_hw() straight after this one and needs the firmware by - * then. request_firmware() is answered from the cache the download - * registered, so it does not wait for a filesystem. + /* Nothing to redo: the poll is armed and thaws with everything else. */ + if (!mcu->fw_running) + return 0; + + /* Not on the workqueue: a DSA port's PHY resumes right after this + * one and calls phy_init_hw(), which needs the firmware by then. */ - en8811h_mcu_reset_if_dormant(mcu); - ret =3D air_en8811h_fw_download(mcu->mdiodev, &mcu->fw_version); - if (ret < 0) - dev_err(dev, "firmware not restored: %pe\n", ERR_PTR(ret)); + chip =3D en8811h_mcu_chip_lock(mcu); + en8811h_mcu_reset_if_dormant(mcu, !!chip); + ret =3D air_en8811h_fw_download(mcu->mdiodev, &mcu->fw_version, !!chip); + en8811h_mcu_chip_unlock(chip); + if (ret < 0) { + /* The reload restores this chip, not the PHY below it: its + * own resume has already failed by then and nothing calls + * phy_init_hw() twice. + */ + dev_err(dev, "firmware not restored, reloading: %pe\n", + ERR_PTR(ret)); + mcu->fw_running =3D false; + mcu->poll_ms =3D EN8811H_FW_POLL_MIN_MS; + mcu->waited_ms =3D 0; + mcu->warned =3D false; + queue_delayed_work(system_freezable_wq, &mcu->fw_poll, 0); + } =20 return 0; } @@ -186,6 +365,10 @@ static struct mdio_driver en8811h_mcu_driver =3D { .name =3D "airoha-en8811h-mcu", .of_match_table =3D en8811h_mcu_of_match, .pm =3D pm_sleep_ptr(&en8811h_mcu_pm_ops), + /* Tearing the child bus down under an attached PHY is not + * something this driver can make safe on its own. + */ + .suppress_bind_attrs =3D true, }, }; =20 diff --git a/drivers/net/phy/air_en8811h.c b/drivers/net/phy/air_en8811h.c index 786c0b26ae65..861b8fe49e24 100644 --- a/drivers/net/phy/air_en8811h.c +++ b/drivers/net/phy/air_en8811h.c @@ -256,7 +256,7 @@ static int __air_pbus_reg_write(struct mdio_device *mdi= odev, =20 static int en8811h_wait_mcu_ready(struct phy_device *phydev) { - int ret =3D air_en8811h_wait_mcu_ready(&phydev->mdio); + int ret =3D air_en8811h_wait_mcu_ready(&phydev->mdio, false); =20 if (ret < 0) phydev_err(phydev, "MCU not ready: %pe\n", ERR_PTR(ret)); @@ -323,7 +323,7 @@ static int an8811hb_load_file(struct phy_device *phydev= , const char *name, if (ret < 0) return ret; =20 - ret =3D air_fw_write_buf(&phydev->mdio, address, fw); + ret =3D air_fw_write_buf(&phydev->mdio, address, fw, false); release_firmware(fw); return ret; } @@ -422,7 +422,8 @@ static int en8811h_load_firmware(struct phy_device *phy= dev) struct en8811h_priv *priv =3D phydev->priv; int ret; =20 - ret =3D air_en8811h_fw_download(&phydev->mdio, &priv->firmware_version); + ret =3D air_en8811h_fw_download(&phydev->mdio, &priv->firmware_version, + false); if (ret < 0) phydev_err(phydev, "Load firmware failed: %d\n", ret); =20 diff --git a/drivers/net/phy/air_phy_lib.c b/drivers/net/phy/air_phy_lib.c index a5b6b3606bec..7f7530273601 100644 --- a/drivers/net/phy/air_phy_lib.c +++ b/drivers/net/phy/air_phy_lib.c @@ -272,8 +272,17 @@ static int __air_mdio_restore_page(struct mdio_device = *mdiodev, return ret; } =20 +/* Nested when the caller already holds the bus this chip hangs below. */ +static void air_mdiodev_lock(struct mdio_device *mdiodev, bool nested) +{ + if (nested) + mdiodev_lock_nested(mdiodev); + else + mdiodev_lock(mdiodev); +} + int air_fw_write_buf(struct mdio_device *mdiodev, u32 address, - const struct firmware *fw) + const struct firmware *fw, bool nested) { size_t chunk, done =3D 0; int saved_page, ret; @@ -287,7 +296,7 @@ int air_fw_write_buf(struct mdio_device *mdiodev, u32 a= ddress, while (done < fw->size) { chunk =3D min_t(size_t, fw->size - done, AIR_FW_CHUNK_BYTES); =20 - mdiodev_lock(mdiodev); + air_mdiodev_lock(mdiodev, nested); =20 saved_page =3D __air_mdio_select_page(mdiodev, AIR_PHY_PAGE_EXTENDED_4); @@ -313,11 +322,12 @@ int air_fw_write_buf(struct mdio_device *mdiodev, u32= address, EXPORT_SYMBOL_GPL(air_fw_write_buf); =20 static int air_mdio_buckpbus_reg_read(struct mdio_device *mdiodev, - u32 pbus_address, u32 *pbus_data) + u32 pbus_address, u32 *pbus_data, + bool nested) { int saved_page, ret; =20 - mdiodev_lock(mdiodev); + air_mdiodev_lock(mdiodev, nested); =20 saved_page =3D __air_mdio_select_page(mdiodev, AIR_PHY_PAGE_EXTENDED_4); if (saved_page < 0) { @@ -333,11 +343,12 @@ static int air_mdio_buckpbus_reg_read(struct mdio_dev= ice *mdiodev, } =20 static int air_mdio_buckpbus_reg_write(struct mdio_device *mdiodev, - u32 pbus_address, u32 pbus_data) + u32 pbus_address, u32 pbus_data, + bool nested) { int saved_page, ret; =20 - mdiodev_lock(mdiodev); + air_mdiodev_lock(mdiodev, nested); =20 saved_page =3D __air_mdio_select_page(mdiodev, AIR_PHY_PAGE_EXTENDED_4); if (saved_page < 0) { @@ -354,11 +365,12 @@ static int air_mdio_buckpbus_reg_write(struct mdio_de= vice *mdiodev, } =20 static int air_mdio_buckpbus_reg_modify(struct mdio_device *mdiodev, - u32 pbus_address, u32 mask, u32 set) + u32 pbus_address, u32 mask, u32 set, + bool nested) { int saved_page, ret; =20 - mdiodev_lock(mdiodev); + air_mdiodev_lock(mdiodev, nested); =20 saved_page =3D __air_mdio_select_page(mdiodev, AIR_PHY_PAGE_EXTENDED_4); if (saved_page < 0) { @@ -399,20 +411,20 @@ static int __air_mmd_read(struct mdio_device *mdiodev= , u16 devad, u16 regnum) return __mdiobus_read(bus, addr, MII_MMD_DATA); } =20 -static int air_mmd_status_read(struct mdio_device *mdiodev) +static int air_mmd_status_read(struct mdio_device *mdiodev, bool nested) { int ret; =20 - mdiodev_lock(mdiodev); + air_mdiodev_lock(mdiodev, nested); ret =3D __air_mmd_read(mdiodev, MDIO_MMD_VEND1, EN8811H_PHY_FW_STATUS); mdiodev_unlock(mdiodev); =20 return ret; } =20 -int air_en8811h_mcu_running(struct mdio_device *mdiodev) +int air_en8811h_mcu_running(struct mdio_device *mdiodev, bool nested) { - int ret =3D air_mmd_status_read(mdiodev); + int ret =3D air_mmd_status_read(mdiodev, nested); =20 if (ret < 0) return ret; @@ -421,12 +433,12 @@ int air_en8811h_mcu_running(struct mdio_device *mdiod= ev) } EXPORT_SYMBOL_GPL(air_en8811h_mcu_running); =20 -int air_en8811h_wait_mcu_ready(struct mdio_device *mdiodev) +int air_en8811h_wait_mcu_ready(struct mdio_device *mdiodev, bool nested) { int ret, reg_value; =20 ret =3D air_mdio_buckpbus_reg_write(mdiodev, EN8811H_FW_CTRL_1, - EN8811H_FW_CTRL_1_FINISH); + EN8811H_FW_CTRL_1_FINISH, nested); if (ret) return ret; =20 @@ -436,7 +448,7 @@ int air_en8811h_wait_mcu_ready(struct mdio_device *mdio= dev) ret =3D read_poll_timeout(air_mmd_status_read, reg_value, reg_value < 0 || reg_value =3D=3D EN8811H_PHY_READY, - 20000, 7500000, true, mdiodev); + 20000, 7500000, true, mdiodev, nested); if (reg_value < 0) return reg_value; if (ret) { @@ -448,19 +460,20 @@ int air_en8811h_wait_mcu_ready(struct mdio_device *md= iodev) } EXPORT_SYMBOL_GPL(air_en8811h_wait_mcu_ready); =20 -int air_en8811h_fw_download(struct mdio_device *mdiodev, u32 *fw_version) +int air_en8811h_fw_download(struct mdio_device *mdiodev, u32 *fw_version, + bool nested) { const struct firmware *fw1, *fw2; struct device *dev =3D &mdiodev->dev; int ret; =20 - ret =3D air_en8811h_mcu_running(mdiodev); + ret =3D air_en8811h_mcu_running(mdiodev, nested); if (ret < 0) return ret; =20 if (ret) { ret =3D air_mdio_buckpbus_reg_read(mdiodev, EN8811H_FW_VERSION, - fw_version); + fw_version, nested); if (ret < 0) return ret; =20 @@ -478,35 +491,36 @@ int air_en8811h_fw_download(struct mdio_device *mdiod= ev, u32 *fw_version) goto air_fw_download_rel1; =20 ret =3D air_mdio_buckpbus_reg_write(mdiodev, EN8811H_FW_CTRL_1, - EN8811H_FW_CTRL_1_START); + EN8811H_FW_CTRL_1_START, nested); if (ret < 0) goto air_fw_download_out; =20 ret =3D air_mdio_buckpbus_reg_modify(mdiodev, EN8811H_FW_CTRL_2, EN8811H_FW_CTRL_2_LOADING, - EN8811H_FW_CTRL_2_LOADING); + EN8811H_FW_CTRL_2_LOADING, nested); if (ret < 0) goto air_fw_download_out; =20 - ret =3D air_fw_write_buf(mdiodev, AIR_FW_ADDR_DM, fw1); + ret =3D air_fw_write_buf(mdiodev, AIR_FW_ADDR_DM, fw1, nested); if (ret < 0) goto air_fw_download_out; =20 - ret =3D air_fw_write_buf(mdiodev, AIR_FW_ADDR_DSP, fw2); + ret =3D air_fw_write_buf(mdiodev, AIR_FW_ADDR_DSP, fw2, nested); if (ret < 0) goto air_fw_download_out; =20 ret =3D air_mdio_buckpbus_reg_modify(mdiodev, EN8811H_FW_CTRL_2, - EN8811H_FW_CTRL_2_LOADING, 0); + EN8811H_FW_CTRL_2_LOADING, 0, + nested); if (ret < 0) goto air_fw_download_out; =20 - ret =3D air_en8811h_wait_mcu_ready(mdiodev); + ret =3D air_en8811h_wait_mcu_ready(mdiodev, nested); if (ret < 0) goto air_fw_download_out; =20 ret =3D air_mdio_buckpbus_reg_read(mdiodev, EN8811H_FW_VERSION, - fw_version); + fw_version, nested); if (ret < 0) goto air_fw_download_out; =20 diff --git a/drivers/net/phy/air_phy_lib.h b/drivers/net/phy/air_phy_lib.h index 3391396aecd1..56ba987a68cc 100644 --- a/drivers/net/phy/air_phy_lib.h +++ b/drivers/net/phy/air_phy_lib.h @@ -62,7 +62,7 @@ int air_phy_write_page(struct phy_device *phydev, int pag= e); struct firmware; =20 int air_fw_write_buf(struct mdio_device *mdiodev, u32 address, - const struct firmware *fw); -int air_en8811h_wait_mcu_ready(struct mdio_device *mdiodev); + const struct firmware *fw, bool nested); +int air_en8811h_wait_mcu_ready(struct mdio_device *mdiodev, bool nested); =20 #endif /* __AIR_PHY_LIB_H */ diff --git a/include/linux/mdio/mdio-airoha-en8811h.h b/include/linux/mdio/= mdio-airoha-en8811h.h index 0d23811e90dc..4494dc6c1022 100644 --- a/include/linux/mdio/mdio-airoha-en8811h.h +++ b/include/linux/mdio/mdio-airoha-en8811h.h @@ -17,8 +17,9 @@ struct mdio_device; #define EN8811H_MD32_DSP "airoha/EthMD32.DSP.bin" =20 /* Returns 1 running, 0 dormant, negative on a failed status read. */ -int air_en8811h_mcu_running(struct mdio_device *mdiodev); +int air_en8811h_mcu_running(struct mdio_device *mdiodev, bool nested); /* Returns 1 when it adopted firmware that was already running. */ -int air_en8811h_fw_download(struct mdio_device *mdiodev, u32 *fw_version); +int air_en8811h_fw_download(struct mdio_device *mdiodev, u32 *fw_version, + bool nested); =20 #endif /* __LINUX_MDIO_AIROHA_EN8811H_H */ --=20 2.53.0