From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id CBA88CCF2C9 for ; Sun, 18 Oct 2026 06:45:50 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender: Content-Transfer-Encoding:Content-Type:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:MIME-Version:References:In-Reply-To: Message-ID:Date:Cc:To:From:Subject:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=zeTxo4mxTBThgZI4FM/EIa8BM/uxKcbq9LxDPC7rR3s=; b=tClUVmZMO9YWWB btb09EszZqzobv9XwqTeEAvVzxcmvJ8l2DlroWo5RrFEfxdzgb7KCogHmm5ObYg7uYuI01RI8TpmI cFZVuQP+CC6wUVzAXovP3RjRkWJt5uHNT5W94ZsbJbLQ2zSJWniZWEZOwLaHSQd4oRhiTO24LxPOQ 8vL5tzxlwxRc4t2xJ5JcpogrmLJlp1urF01FwH9Xqsfw8C+Mkzy4XX0bsWkZbiwtFr0sYsfFnPa11 I16wGaIL1xHAxI57HfUgUXB7G6JVl4EDWv4nmh2FJBWM08O3XpWbH9RrSROoaG4v9UaTb5aJHWolr pQ7Nd7ZYMJlk8JY4BFqw==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.99.1 #2 (Red Hat Linux)) id 1xIKeO-00000005doc-1b0o; Sun, 18 Oct 2026 06:45:44 +0000 Received: from sea.source.kernel.org ([2600:3c0a:e001:78e:0:1991:8:25]) by bombadil.infradead.org with esmtps (Exim 4.99.1 #2 (Red Hat Linux)) id 1xIKeC-00000005diP-1KyD; Sun, 18 Oct 2026 06:45:34 +0000 Received: from smtp.kernel.org (quasi.space.kernel.org [100.103.45.18]) by sea.source.kernel.org (Postfix) with ESMTP id 1689143D9D; Sun, 18 Oct 2026 06:45:32 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id D0AE61F000C4; Sun, 18 Oct 2026 06:45:30 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1792305932; bh=nwoQYoQto1YAJAYheTDELDgBOILwkL0JCAKNhO6a2hY=; h=Subject:From:To:Cc:Date:In-Reply-To:References; b=h4tTjBwM6zpfQOywL3uF1jwlI56Xdkk7WyoAmFRcXqbxCqhbxKPR8ateniSXxhWf7 iZrGYpvwzyC0S+PlHAAAguyoNOlKtZTS/jPetIMqTf8mgvcyG/miJZMGB1DG5AQIJ3 c7kwAktY40uPE61DOUXRT/voGdkkLQA+vf6sVj/pnp9FBXx2n2hSCTrpVuL4SG4SyZ KksJtcCIYQHcAlrDFj3kpbKICRvNUM6sC/IXIiK3k7Xh7kqIvoDSrrmtmk3dH7k912 JhZ4Ce2z0+7IW/sQbt4Lzr5+vmUxupTzI1fXjvxPpPeL+j0H8N8260BH5EgayOyS/r 8dg0H1C/tngIQ== Subject: Re: [PATCH net-next v12 3/6] net: pcs: xpcs: add Rockchip RK3568 platform glue driver From: netdev-bot+sashiko@kernel.org To: coiaprant@gmail.com Cc: kuba@kernel.org, netdev@vger.kernel.org, andrew+netdev@lunn.ch, davem@davemloft.net, edumazet@kernel.org, pabeni@redhat.com, robh@kernel.org, krzk+dt@kernel.org, conor+dt@kernel.org, heiko@sntech.de, maxime.chevallier@bootlin.com, mcoquelin.stm32@gmail.com, alexandre.torgue@foss.st.com, hkallweit1@gmail.com, linux@armlinux.org.uk, david.wu@rock-chips.com, linux-rockchip@lists.infradead.org, devicetree@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org Date: Sun, 18 Oct 2026 06:45:30 +0000 Message-ID: <179230593040.3135.11436989904007018210@kernel.org> In-Reply-To: <20261017054406.1828061-4-coiaprant@gmail.com> References: <20261017054406.1828061-4-coiaprant@gmail.com> X-sashiko-severity: High MIME-Version: 1.0 X-BeenThere: linux-rockchip@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: Upstream kernel work for Rockchip platforms List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "Linux-rockchip" Errors-To: linux-rockchip-bounces+linux-rockchip=archiver.kernel.org@lists.infradead.org VGhhbmsgeW91IGZvciB5b3VyIGNvbnRyaWJ1dGlvbiEgU2FzaGlrbyBBSSByZXZpZXcgZm91bmQg NCBwb3RlbnRpYWwKaXNzdWUocykgdG8gY29uc2lkZXIuCgpDcml0aWNhbDogMCDCtyBIaWdoOiAx IMK3IE1lZGl1bTogMSDCtyBMb3c6IDIKCklmIHlvdSBiZWxpZXZlIG5vbmUgb2YgdGhlIGlzc3Vl cyBhcmUgbGVnaXRpbWF0ZSwgcGxlYXNlIHJlcGx5IHRvIGVhY2gKaXNzdWUgb2YgTWVkaXVtIHNl dmVyaXR5IG9yIGhpZ2hlciBhbmQgZXhwbGFpbiB3aHkgdGhlIEFJIGlzIHdyb25nLgpJZiBhbnkg b2YgdGhlbSBhcmUgbGVnaXRpbWF0ZSBhbmQgeW91IHBsYW4gdG8gcmVzcGluLCBwbGVhc2UgbGV0 IHBhdGNod29yawprbm93IGJ5IGluY2x1ZGluZyAicHctYm90OiBjciIgYXMgYSBzZXBhcmF0ZSBs aW5lIGF0IHRoZSBlbmQgb2YgeW91ciByZXBseQoob25lIHN1Y2ggcmVwbHkgcGVyIHNlcmllcyBp cyBlbm91Z2gpLgoKLSBbSGlnaF0gVGhlIHN5c3RlbS1zdXNwZW5kIGRlc2lnbiBmb3Iga2VlcGlu ZyBQRF9QSVBFIHBvd2VyZWQgZG9lcyBub3QKICB3b3JrLgotIFtNZWRpdW1dIHhwY3NfcmtfY3Jl YXRlKCkgKGRyaXZlcnMvbmV0L3Bjcy9wY3MteHBjcy1yay5jOjQ4MSkgZmlyc3QKICBjYWxscyBk ZXZpY2VfbGlua19hZGQoZGV2LCAmcGRldi0+ZGV2LCBETF9GTEFHX0FVVE9SRU1PVkVfQ09OU1VN RVIp4oCmCi0gW0xvd10gVGhlIHBhdGNoIG1vdmVzIHBjcy14cGNzLXBsYXQubyAodGhlIGdlbmVy aWMgc25wcyxkdy14cGNzCiAgcGxhdGZvcm0gZHJpdmVyLCBuYW1lICJkd3hwY3MiKSBvdXQgb2Yg dGhlIHBjc194cGNzIGNvbXBvc2l0ZSBvYmplY3TigKYKLSBbTG93XSBDb25jZXJuOiB4cGNzX3Jr X2NyZWF0ZSgpIGlzIGV4cG9ydGVkIHdpdGggbm8gaW4tdHJlZSBjYWxsZXIsIGFuZAogIGluY2x1 ZGUvbGludXgvcGNzL3Bjcy14cGNzLXJrLmggaGFzIG5vICFDT05GSUdfUENTX1hQQ1NfUk9DS0NI SVAgc3R1YizigKYKCi0tCgpuZXQ6IHBjczogeHBjczogYWRkIFJvY2tjaGlwIFJLMzU2OCBwbGF0 Zm9ybSBnbHVlIGRyaXZlcgoKVGhpcyBhZGRzIGEgcGxhdGZvcm0gZ2x1ZSBkcml2ZXIgZm9yIHRo ZSBTeW5vcHN5cyBEZXNpZ25XYXJlIFhQQ1MgaW4gdGhlClJLMzU2OC4gVGhlIGRyaXZlciBleHBv c2VzIHRoZSBYUENTIEFQQjMgcmVnaXN0ZXJzIHRocm91Z2ggYSB2aXJ0dWFsIE1ESU8KYnVzIGFu ZCByZW1hcHMgdGhlIE1NRCBwZXIgcG9ydC4gSXQgYWxzbyBtb3ZlcyBwY3MteHBjcy1wbGF0Lm8g b3V0IG9mIHRoZQpwY3NfeHBjcyBjb21wb3NpdGUgb2JqZWN0IGJlaGluZCBhIG5ldyBQQ1NfWFBD U19QTEFURk9STSBzeW1ib2wsIGFuZCB0cmllcwp0byBrZWVwIFBEX1BJUEUgcG93ZXJlZCBhY3Jv c3Mgc3lzdGVtIHN1c3BlbmQgd2l0aApkZXZpY2Vfc2V0X3dha2V1cF9wYXRoKCkuCgpMaW5rOiBo dHRwczovL2RsLnJhZHhhLmNvbS9yb2NrMy9kb2NzL2h3L2RhdGFzaGVldC9Sb2NrY2hpcCUyMFJL MzU2OCUyMFRSTSUyMFBhcnQxJTIwVjEuMS0yMDIxMDMwMS5wZGYgKFBhZ2UgNTksIENSVV9DTEtT RUxfQ09OMjkpCkxpbms6IGh0dHBzOi8vZGwucmFkeGEuY29tL3JvY2szL2RvY3MvaHcvZGF0YXNo ZWV0L1JvY2tjaGlwJTIwUkszNTY4JTIwVFJNJTIwUGFydDIlMjBWMS4xLTIwMjEwMzAxLnBkZiAo UGFnZSAyMDc4KQoKPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9uZXQvcGNzL0tjb25maWcgYi9kcml2 ZXJzL25ldC9wY3MvS2NvbmZpZwo+IGluZGV4IGU0MTdmZDY2ZjY2MGEuLjEwOGQ0NzI1N2JlZTIg MTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9uZXQvcGNzL0tjb25maWcKPiArKysgYi9kcml2ZXJzL25l dC9wY3MvS2NvbmZpZwo+IEBAIC0xMiw2ICsxMiwyOSBAQCBjb25maWcgUENTX1hQQ1MKPiAgCSAg VGhpcyBtb2R1bGUgcHJvdmlkZXMgYSBkcml2ZXIgYW5kIGhlbHBlciBmdW5jdGlvbnMgZm9yIFN5 bm9wc3lzCj4gIAkgIERlc2lnbldhcmUgWFBDUyBjb250cm9sbGVycy4KPiAgCj4gK2lmIFBDU19Y UENTCj4gKwo+ICtjb25maWcgUENTX1hQQ1NfUExBVEZPUk0KPiArCXRyaXN0YXRlICJHZW5lcmlj IFhQQ1MgY29udHJvbGxlciBzdXBwb3J0Igo+ICsJaGVscAo+ICsJICBHZW5lcmljIERXWFBDUyBk cml2ZXIgZm9yIHBsYXRmb3JtcyB0aGF0IGRvbid0IHJlcXVpcmUgYW55Cj4gKwkgIHBsYXRmb3Jt IHNwZWNpZmljIGNvZGUgdG8gZnVuY3Rpb24gb3IgaXMgdXNpbmcgcGxhdGZvcm0KPiArCSAgZGF0 YSBmb3Igc2V0dXAuCj4gKwo+ICsJICBJZiB5b3UgaGF2ZSBhIGNvbnRyb2xsZXIgd2l0aCB0aGlz IGludGVyZmFjZSwgc2F5IFkgb3IgTSBoZXJlLgo+ICsKClsgLi4uIF0KCj4gZGlmZiAtLWdpdCBh L2RyaXZlcnMvbmV0L3Bjcy9NYWtlZmlsZSBiL2RyaXZlcnMvbmV0L3Bjcy9NYWtlZmlsZQo+IGlu ZGV4IDRmNzkyMDYxOGI5MDAuLmY5ZjZjZjI1NzhkNzIgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9u ZXQvcGNzL01ha2VmaWxlCj4gKysrIGIvZHJpdmVycy9uZXQvcGNzL01ha2VmaWxlCj4gQEAgLTEs MTAgKzEsMTEgQEAKPiAgIyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMAo+ICAjIE1h a2VmaWxlIGZvciBMaW51eCBQQ1MgZHJpdmVycwo+ICAKPiAtcGNzX3hwY3MtJChDT05GSUdfUENT X1hQQ1MpCTo9IHBjcy14cGNzLm8gcGNzLXhwY3MtcGxhdC5vIFwKPiAtCQkJCSAgIHBjcy14cGNz LW54cC5vIHBjcy14cGNzLXd4Lm8KPiArcGNzX3hwY3MtJChDT05GSUdfUENTX1hQQ1MpCTo9IHBj cy14cGNzLm8gcGNzLXhwY3MtbnhwLm8gcGNzLXhwY3Mtd3gubwo+ICAKPiAgb2JqLSQoQ09ORklH X1BDU19YUENTKQkJKz0gcGNzX3hwY3Mubwo+ICtvYmotJChDT05GSUdfUENTX1hQQ1NfUExBVEZP Uk0pICs9IHBjcy14cGNzLXBsYXQubwoKW1NldmVyaXR5OiBMb3ddCklzIGl0IGludGVuZGVkIHRo YXQgZXhpc3RpbmcgY29uZmlncyBsb3NlIHRoZSBnZW5lcmljIHNucHMsZHcteHBjcwpwbGF0Zm9y bSBkcml2ZXIgaGVyZT8KCkJlZm9yZSB0aGlzIGNoYW5nZSwgYW55IGNvbmZpZyB3aXRoIFBDU19Y UENTIGVuYWJsZWQgKGZvciBleGFtcGxlIHRocm91Z2gKdGhlIHNlbGVjdCBQQ1NfWFBDUyBpbiBT VE1NQUNfRVRIKSBhbHdheXMgYnVpbHQgcGNzLXhwY3MtcGxhdC5vLiBUaGUgbmV3ClBDU19YUENT X1BMQVRGT1JNIGhhcyBubyBkZWZhdWx0LCBzbyBtYWtlIG9sZGRlZmNvbmZpZyBzaWxlbnRseSB0 dXJucyB0aGUKZ2VuZXJpYyBnbHVlIG9mZi4KClNvbWUgc3lzdGVtcyBoYXZlIGEgRFQsIGZvciBp bnN0YW5jZSBvbmUgcHJvdmlkZWQgYnkgZmlybXdhcmUsIHdpdGggYW4KTU1JTyBub2RlIHVzaW5n IHRoZSBkb2N1bWVudGVkIHNucHMsZHcteHBjcyBiaW5kaW5nLiBPbiB0aG9zZSBzeXN0ZW1zIG5v Ck1ESU8gZGV2aWNlIHdvdWxkIGJlIGNyZWF0ZWQgZm9yIHRoYXQgbm9kZSwgYW5kIGEgTUFDIGNh bGxpbmcKeHBjc19jcmVhdGVfZndub2RlKCkgd291bGQgZ2V0IC1FUFJPQkVfREVGRVIgZm9yZXZl cjoKCmRyaXZlcnMvbmV0L3Bjcy9wY3MteHBjcy5jOnhwY3NfY3JlYXRlX2Z3bm9kZSgpIHsKICAg IC4uLgoJbWRpb2RldiA9IGZ3bm9kZV9tZGlvX2ZpbmRfZGV2aWNlKGZ3bm9kZSk7CglpZiAoIW1k aW9kZXYpCgkJcmV0dXJuIEVSUl9QVFIoLUVQUk9CRV9ERUZFUik7CiAgICAuLi4KfQoKTm8gaW4t dHJlZSBEVFMgdXNlcyB0aGUgYmluZGluZywgYW5kIHRoZSBjb21taXQgbWVzc2FnZSBzYXlzIHRo ZSBjaGFuZ2UKaXMgZGVsaWJlcmF0ZS4gSG93ZXZlciwgdGhlIFJvY2tjaGlwIGdsdWUgb25seSB1 c2VzIGV4cG9ydGVkIGNvcmUKc3ltYm9scywgc28gaXQgZG9lcyBub3Qgc2VlbSB0byBuZWVkIHRo ZSBzcGxpdC4KCldvdWxkIGFkZGluZyAiZGVmYXVsdCBQQ1NfWFBDUyIga2VlcCB0aGUgb2xkIGJl aGF2aW91cj8gQWx0ZXJuYXRpdmVseSwKY291bGQgdGhlIHNwbGl0IGdvIGludG8gaXRzIG93biBw YXRjaD8KCj4gK29iai0kKENPTkZJR19QQ1NfWFBDU19ST0NLQ0hJUCkgKz0gcGNzLXhwY3Mtcmsu bwo+ICBvYmotJChDT05GSUdfUENTX0xZTlgpCQkrPSBwY3MtbHlueC5vCj4gIG9iai0kKENPTkZJ R19QQ1NfTVRLX0xZTlhJKQkrPSBwY3MtbXRrLWx5bnhpLm8KPiAgb2JqLSQoQ09ORklHX1BDU19S Wk4xX01JSUMpCSs9IHBjcy1yem4xLW1paWMubwo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL25ldC9w Y3MvcGNzLXhwY3MtcmsuYyBiL2RyaXZlcnMvbmV0L3Bjcy9wY3MteHBjcy1yay5jCj4gbmV3IGZp bGUgbW9kZSAxMDA2NDQKPiBpbmRleCAwMDAwMDAwMDAwMDAwLi42OThhNDNiNzUzMzQxCj4gLS0t IC9kZXYvbnVsbAo+ICsrKyBiL2RyaXZlcnMvbmV0L3Bjcy9wY3MteHBjcy1yay5jCj4gQEAgLTAs MCArMSw1OTggQEAKClsgLi4uIF0KCj4gK3N0cnVjdCBkd194cGNzICp4cGNzX3JrX2NyZWF0ZShz dHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVjdCBkZXZpY2Vfbm9kZSAqcGNzLCBpbnQgcG9ydCkKPiAr ewoKWyAuLi4gXQoKPiArCXBkZXYgPSBvZl9maW5kX2RldmljZV9ieV9ub2RlKHBjcyk7Cj4gKwlp ZiAoIXBkZXYpCj4gKwkJcmV0dXJuIEVSUl9QVFIoLUVQUk9CRV9ERUZFUik7Cj4gKwo+ICsJLyoK PiArCSAqIEVzdGFibGlzaCB0aGUgZGV2aWNlIGxpbmsgYmVmb3JlIHJlYWRpbmcgdGhlIHN1cHBs aWVyJ3MgZHJ2ZGF0YS4KPiArCSAqIGRldmljZV9saW5rX2FkZCgpIGRvZXMgbm90IGZhaWwgb24g YSBzdXBwbGllciB0aGF0IGlzIHVuYmluZGluZzsKPiArCSAqIGl0IGNyZWF0ZXMgdGhlIGxpbmsg aW4gRExfU1RBVEVfU1VQUExJRVJfVU5CSU5ELgo+ICsJICoKPiArCSAqIFRoZSBjaGVjayBiZWxv dyBvbmx5IGNvbmZpcm1zIHRoYXQgdGhlIHN1cHBsaWVyIGlzIGJvdW5kIGF0IHRoaXMKPiArCSAq IHBvaW50LiBJdCBkb2VzIG5vdCBmdWxseSBwcm90ZWN0IGFnYWluc3QgYSBjb25jdXJyZW50IHVu YmluZAo+ICsJICogYmV0d2VlbiBoZXJlIGFuZCB4cGNzX2NyZWF0ZV9tZGlvZGV2KCk7IGNsb3Np bmcgdGhhdCB3aW5kb3cgd291bGQKPiArCSAqIHJlcXVpcmUgcmVhZGluZyBhIG1hbmFnZWQgbGlu aydzIHN0YXR1cyBvciBkZXZpY2VfbG9jaygpLCBuZWl0aGVyCj4gKwkgKiBvZiB3aGljaCBpcyBh Y2NlcHRhYmxlIG9uIHRoaXMgcGF0aC4gVGhlIHdpbmRvdyBpcyBzbWFsbCBhbmQKPiArCSAqIHJl cXVpcmVzIGFuIGV4cGxpY2l0IHVuYmluZCBmcm9tIHVzZXJzcGFjZS4gRGlzY3Vzc2VkIG9uCj4g KwkgKiBkcml2ZXItY29yZS4KPiArCSAqCj4gKwkgKiBUaGUgbGluayBpcyByZWxlYXNlZCBhdXRv bWF0aWNhbGx5IHdoZW4gdGhlIGNvbnN1bWVyIGRldmljZSBpcwo+ICsJICogZGVzdHJveWVkIChE TF9GTEFHX0FVVE9SRU1PVkVfQ09OU1VNRVIpLCBzbyBubyBleHBsaWNpdAo+ICsJICogZGV2aWNl X2xpbmtfcmVtb3ZlKCkgaXMgbmVlZGVkIG9uIHRoZSBmYWlsdXJlIHBhdGhzLgo+ICsJICovCj4g KwlpZiAoIWRldmljZV9saW5rX2FkZChkZXYsICZwZGV2LT5kZXYsIERMX0ZMQUdfQVVUT1JFTU9W RV9DT05TVU1FUikpIHsKPiArCQlwdXRfZGV2aWNlKCZwZGV2LT5kZXYpOwo+ICsJCXJldHVybiBF UlJfUFRSKC1FUFJPQkVfREVGRVIpOwo+ICsJfQo+ICsKPiArCWlmIChSRUFEX09OQ0UocGRldi0+ ZGV2LmxpbmtzLnN0YXR1cykgIT0gRExfREVWX0RSSVZFUl9CT1VORCkgewo+ICsJCXB1dF9kZXZp Y2UoJnBkZXYtPmRldik7Cj4gKwkJcmV0dXJuIEVSUl9QVFIoLUVQUk9CRV9ERUZFUik7Cj4gKwl9 CgpbU2V2ZXJpdHk6IE1lZGl1bV0KRG9lcyB0aGlzIGNoZWNrIHByb3RlY3QgdGhlIHJlc3Qgb2Yg dGhlIE1BQyBwcm9iZT8KCnBjcy1oYW5kbGUgaXMgbm90IGEgZndfZGV2bGluayBzdXBwbGllciBi aW5kaW5nLCBzbyB0aGUgTUFDIGNhbiByZWFjaAp0aGlzIHBvaW50IHdoaWxlIHRoZSBYUENTIGlz IHN0aWxsIHVuYm91bmQuIEluIHRoYXQgY2FzZQpkZXZpY2VfbGlua19pbml0X3N0YXR1cygpIGNy ZWF0ZXMgdGhlIGxpbmsgYXMgRExfU1RBVEVfRE9STUFOVC4KClRoZSBYUENTIHByb2JlIGNhbiBm aW5pc2ggb24gYW5vdGhlciBDUFUgYmV0d2VlbiBkZXZpY2VfbGlua19hZGQoKSBhbmQKdGhlIFJF QURfT05DRSgpLCBmb3IgZXhhbXBsZSB3aXRoIHBhcmFsbGVsIG1vZHVsZSBsb2FkaW5nIG9yIGFz eW5jIHByb2JlOgoKQ1BVMSAoTUFDIHByb2JlKSAgICAgICAgICAgICAgICAgICAgICBDUFUyIChY UENTIHByb2JlKQp4cGNzX3JrX2NyZWF0ZSgpCiAgZGV2aWNlX2xpbmtfYWRkKCkKICAgIGxpbmsg aXMgRExfU1RBVEVfRE9STUFOVAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IGRldmljZV9saW5rc19kcml2ZXJfYm91bmQoKQogICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgbGluayBiZWNvbWVzIERMX1NUQVRFX0FWQUlMQUJMRQogIFJFQURfT05DRShw ZGV2LT5kZXYubGlua3Muc3RhdHVzKQogICAgaXMgRExfREVWX0RSSVZFUl9CT1VORCwgcGFzc2Vz CiAgeHBjc19jcmVhdGVfbWRpb2RldihweHBjcy0+YnVzLCBwb3J0KQoKZGV2aWNlX2xpbmtzX2J1 c3koKSBvbmx5IGNvdW50cyBDT05TVU1FUl9QUk9CRSBhbmQgQUNUSVZFIGFzIGJ1c3k6Cgpkcml2 ZXJzL2Jhc2UvY29yZS5jOmRldmljZV9saW5rc19idXN5KCkgewogICAgLi4uCgkJaWYgKGxpbmst PnN0YXR1cyA9PSBETF9TVEFURV9DT05TVU1FUl9QUk9CRQoJCSAgICB8fCBsaW5rLT5zdGF0dXMg PT0gRExfU1RBVEVfQUNUSVZFKSB7CgkJCXJldCA9IHRydWU7CiAgICAuLi4KfQoKU28gdW50aWwg dGhlIE1BQyBmaW5pc2hlcyBwcm9iaW5nLCBhIHN5c2ZzIHVuYmluZCBvciBtb2R1bGUgdW5sb2Fk IG9mCnRoZSBYUENTIHdvdWxkIG5vdCB3YWl0IGZvciBpdC4gVGhlIFhQQ1MgZGV2cmVzIHRlYXJk b3duIHdvdWxkIHRoZW4gZnJlZQpweHBjcyBhbmQgdGhlIG1paV9idXMuIE1lYW53aGlsZSB4cGNz X3JrX2NyZWF0ZSgpIG9yIHRoZSByZXN0IG9mIHRoZQpzdG1tYWMgcHJvYmUgY2FuIHN0aWxsIHJl YWNoIHRoZW0gdGhyb3VnaCBidXMtPnByaXYgYW5kIHJlZ19iYXNlIGluCnhwY3NfcmtfcmVhZF9j NDUoKSBhbmQgeHBjc19ya193cml0ZV9jNDUoKS4KCkNhbiB0aGlzIGxlYWQgdG8gYSB1c2UtYWZ0 ZXItZnJlZSBvZiBweHBjcz8KCkV2ZW4gd2l0aG91dCBhbiB1bmJpbmQsIHdvdWxkbid0IHRoZSBN QUMncyBvd24gYmluZCBoaXQgdGhpcyB3YXJuaW5nIG9uCnRoZSBBVkFJTEFCTEUgbGluaz8KCmRy aXZlcnMvYmFzZS9jb3JlLmM6ZGV2aWNlX2xpbmtzX2RyaXZlcl9ib3VuZCgpIHsKICAgIC4uLgoJ CQlXQVJOX09OKGxpbmstPnN0YXR1cyAhPSBETF9TVEFURV9DT05TVU1FUl9QUk9CRSk7CgkJCVdS SVRFX09OQ0UobGluay0+c3RhdHVzLCBETF9TVEFURV9BQ1RJVkUpOwogICAgLi4uCn0KCkFsc28s IGlmIHRoZSBzdXBwbGllciB1bmJpbmRzIHdoaWxlIHRoaXMgQVVUT1JFTU9WRV9DT05TVU1FUiBs aW5rIGlzCnN0aWxsIHByZXNlbnQsIGRldmljZV9saW5rc19kcml2ZXJfY2xlYW51cCgpIHdvdWxk IHRyaWdnZXI6CgoJV0FSTl9PTihkZXZpY2VfbGlua190ZXN0KGxpbmssIERMX0ZMQUdfQVVUT1JF TU9WRV9DT05TVU1FUikpOwoKVGhlIGNvbW1lbnQgYWJvdmUgb25seSBjb3ZlcnMgYSB3aW5kb3cg dXAgdG8geHBjc19jcmVhdGVfbWRpb2RldigpIG9wZW5lZApieSBhbiBleHBsaWNpdCB1c2Vyc3Bh Y2UgdW5iaW5kLiBJbiB0aGlzIHJhY2UsIHRoZSBsaW5rIG5ldmVyIGdldHMKQ09OU1VNRVJfUFJP QkUgcHJvdGVjdGlvbiBmb3IgdGhlIHJlc3Qgb2YgdGhlIE1BQyBwcm9iZS4KCldvdWxkIGl0IHdv cmsgdG8gY2hlY2sgdGhlIHN0YXR1cyBvZiB0aGUgbGluayByZXR1cm5lZCBieQpkZXZpY2VfbGlu a19hZGQoKSBpbnN0ZWFkPyBUaGF0IHdvdWxkIG1lYW4gcmVxdWlyaW5nIERMX1NUQVRFX0NPTlNV TUVSX1BST0JFCm9yIERMX1NUQVRFX0FDVElWRSwgYW5kIG90aGVyd2lzZSBjYWxsaW5nIGRldmlj ZV9saW5rX2RlbCgpIGFuZCByZXR1cm5pbmcKLUVQUk9CRV9ERUZFUi4gSWYgdGhlIHN1cHBsaWVy IGlzIGFscmVhZHkgYm91bmQgd2hlbiB0aGUgbGluayBpcyBjcmVhdGVkLAp0aGUgbGluayBzdGFy dHMgYXMgQ09OU1VNRVJfUFJPQkUgYW5kIHRoYXQgcGF0aCBsb29rcyBmaW5lLgoKPiArCj4gKwlw eHBjcyA9IHBsYXRmb3JtX2dldF9kcnZkYXRhKHBkZXYpOwo+ICsJaWYgKCFweHBjcyB8fCAhcHhw Y3MtPmJ1cykgewo+ICsJCXB1dF9kZXZpY2UoJnBkZXYtPmRldik7Cj4gKwkJcmV0dXJuIEVSUl9Q VFIoLUVQUk9CRV9ERUZFUik7Cj4gKwl9Cj4gKwo+ICsJeHBjcyA9IHhwY3NfY3JlYXRlX21kaW9k ZXYocHhwY3MtPmJ1cywgcG9ydCk7CgpbIC4uLiBdCgo+ICtzdGF0aWMgaW50IHhwY3Nfcmtfc3lz dGVtX3N1c3BlbmQoc3RydWN0IGRldmljZSAqZGV2KQo+ICt7Cj4gKwkvKgo+ICsJICogS2VlcCB0 aGUgUERfUElQRSBwb3dlciBkb21haW4gb24gZHVyaW5nIHN5c3RlbSBzdXNwZW5kLgo+ICsJICoK PiArCSAqIFBEX1BJUEUgaXMgc2hhcmVkIHdpdGggU0FUQS9QQ0llIGFuZCB3b3VsZCBiZSBwb3dl cmVkIGRvd24gYnkKPiArCSAqIGdlbnBkIG9uY2UgYWxsIGl0cyBjb25zdW1lcnMgYXJlIHN1c3Bl bmRlZCwga2lsbGluZyB0aGUgU2VyRGVzCj4gKwkgKiBhbmQgYnJlYWtpbmcgTUFDIFdvTC4gIE1h cmsgdGhlIFhQQ1MgYXMgcGFydCBvZiB0aGUgd2FrZXVwIHBhdGgKPiArCSAqIHNvIGdlbnBkIGtl ZXBzIHRoZSBkb21haW4gb24uICBVbmNvbmRpdGlvbmFsIGJlY2F1c2UgdGhlIFhQQ1MKPiArCSAq IGNvcmUgaGFzIG5vIGNhbGxiYWNrIHRvIGNvbnZleSB0aGUgTUFDIFdvTCBzdGF0ZS4KPiArCSAq Lwo+ICsJZGV2aWNlX3NldF93YWtldXBfcGF0aChkZXYpOwo+ICsJcmV0dXJuIDA7Cj4gK30KPiAr Cj4gK3N0YXRpYyBpbnQgeHBjc19ya19zeXN0ZW1fcmVzdW1lKHN0cnVjdCBkZXZpY2UgKmRldikK PiArewo+ICsJcmV0dXJuIDA7Cj4gK30KCltTZXZlcml0eTogSGlnaF0KRG9lcyBkZXZpY2Vfc2V0 X3dha2V1cF9wYXRoKCkgaW4geHBjc19ya19zeXN0ZW1fc3VzcGVuZCgpIGFjdHVhbGx5IGtlZXAK UERfUElQRSBvbj8KCmdlbnBkIG9ubHkgaG9ub3VycyB0aGUgd2FrZXVwIHBhdGggd2hlbiB0aGUg ZG9tYWluIGhhcwpHRU5QRF9GTEFHX0FDVElWRV9XQUtFVVA6Cgpkcml2ZXJzL3BtZG9tYWluL2Nv cmUuYzpnZW5wZF9maW5pc2hfc3VzcGVuZCgpIHsKICAgIC4uLgoJaWYgKGRldmljZV9hd2FrZV9w YXRoKGRldikgJiYgZ2VucGRfaXNfYWN0aXZlX3dha2V1cChnZW5wZCkgJiYKCSAgICAhZGV2aWNl X291dF9iYW5kX3dha2V1cChkZXYpKQoJCXJldHVybiAwOwogICAgLi4uCn0KClRoZSBjb21taXQg bWVzc2FnZSBzYXlzOgoKICAiZ2VucGQgdGhlbiBsZWF2ZXMgdGhlIGRvbWFpbiBwb3dlcmVkLCBi ZWNhdXNlIHRoZSBSb2NrY2hpcCBwb3dlcgogIGRvbWFpbiBkcml2ZXIgc2V0cyBHRU5QRF9GTEFH X0FDVElWRV9XQUtFVVAgb24gUERfUElQRSIKCkhvd2V2ZXIsIFBEX1BJUEUgaXMgZGVjbGFyZWQg d2l0aCB3YWtldXAgc2V0IHRvIGZhbHNlOgoKZHJpdmVycy9wbWRvbWFpbi9yb2NrY2hpcC9wbS1k b21haW5zLmM6CglbUkszNTY4X1BEX1BJUEVdCT0gRE9NQUlOX1JLMzU2OCgicGlwZSIsIEJJVCg4 KSwgQklUKDExKSwgZmFsc2UsIGZhbHNlKSwKCnJvY2tjaGlwX3BtX2FkZF9vbmVfZG9tYWluKCkg b25seSBhZGRzIHRoZSBmbGFnIHdoZW4gYWN0aXZlX3dha2V1cCBpcwpzZXQ6CgoJcGQtPmdlbnBk LmZsYWdzID0gR0VOUERfRkxBR19QTV9DTEsgfCBHRU5QRF9GTEFHX05PX1NUQVlfT047CglpZiAo cGRfaW5mby0+YWN0aXZlX3dha2V1cCkKCQlwZC0+Z2VucGQuZmxhZ3MgfD0gR0VOUERfRkxBR19B Q1RJVkVfV0FLRVVQOwoKU28gdGhlIGVhcmx5IHJldHVybiBpcyBuZXZlciB0YWtlbi4gc3VzcGVu ZGVkX2NvdW50IGlzIGluY3JlbWVudGVkIGFuZApnZW5wZF9zeW5jX3Bvd2VyX29mZigpIHJ1bnMu IFRoYXQgZnVuY3Rpb24gaWdub3JlcyB0aGUgcGVyLWRldmljZQpycG1fYWx3YXlzX29uIHNldCBi eSBkZXZfcG1fZ2VucGRfcnBtX2Fsd2F5c19vbigpLiBPbmNlIFNBVEEsIFBDSWUgYW5kCnRoZSBY UENTIGFyZSBhbGwgc3VzcGVuZGVkLCBQRF9QSVBFIHdvdWxkIGJlIHBvd2VyZWQgb2ZmIGluIHRo ZSBub2lycQpwaGFzZS4KCldvdWxkbid0IHRoYXQgYnJlYWsgTUFDIFdvTCBvdmVyIFNHTUlJLCB3 aGljaCB0aGlzIGNvZGUgaXMgbWVhbnQgdG8KcHJlc2VydmU/CgpJZiBQRF9QSVBFIGlzIHBvd2Vy LWN5Y2xlZCwgeHBjc19ya19zeXN0ZW1fcmVzdW1lKCkgZG9lcyBub3QgcmVwZWF0IHRoZQpwcm9i ZS10aW1lIHNldHVwIGVpdGhlci4gVGhlIHByb2JlIGNvbW1lbnQgc2F5cyB0aGUgU2VyRGVzIHBo eV9pbml0KCkKYW5kIHBoeV9wb3dlcl9vbigpIGFyZSBuZWVkZWQgZm9yIHJlZ2lzdGVyIGFjY2Vz cyBhbmQgc29mdCByZXNldC4gQWxzbywKbmVlZF9yZXNldCBpbiB0aGUgY29yZSBpcyBvbmx5IHNl dCBpbiB4cGNzX2NyZWF0ZSgpLCBzbyB0aGUgWFBDUyBzb2Z0CnJlc2V0IGlzIG5vdCBydW4gYWdh aW4gYWZ0ZXIgcG93ZXIgbG9zcy4KCl9ERUZJTkVfREVWX1BNX09QUygpIGFsc28gbWFwcyBmcmVl emUvdGhhdy9wb3dlcm9mZi9yZXN0b3JlIHRvIHRoZXNlCmNhbGxiYWNrcywgc28gaGliZXJuYXRp b24gc2VlbXMgdG8gaGF2ZSB0aGUgc2FtZSBnYXAuCgpXb3VsZCB0aGlzIG5lZWQgZWl0aGVyIGEg Y2hhbmdlIHRvIHRoZSBQRF9QSVBFIGFjdGl2ZV93YWtldXAgc2V0dGluZwood2hpY2ggYWxzbyBh ZmZlY3RzIFBDSWUgYW5kIFNBVEEpLCBvciBhIHJlc3VtZSBwYXRoIHRoYXQgcmVzdG9yZXMgdGhl ClNlckRlcyBhbmQgdGhlIFhQQ1M/CgotLSAKU2FzaGlrbyBBSSByZXZpZXcgwrcgaHR0cHM6Ly9u ZXRkZXYtYWkuYm90cy5saW51eC5kZXYvc2FzaGlrby8jL3BhdGNoc2V0LzIwMjYxMDE3MDU0NDA2 LjE4MjgwNjEtMS1jb2lhcHJhbnQlNDBnbWFpbC5jb20KCl9fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fCkxpbnV4LXJvY2tjaGlwIG1haWxpbmcgbGlzdApMaW51 eC1yb2NrY2hpcEBsaXN0cy5pbmZyYWRlYWQub3JnCmh0dHA6Ly9saXN0cy5pbmZyYWRlYWQub3Jn L21haWxtYW4vbGlzdGluZm8vbGludXgtcm9ja2NoaXAK From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 54D05442380; Sun, 18 Oct 2026 06:45:32 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1792305933; cv=none; b=C3BI8jdzenyzGSqUrjuoeFkSeg1QCoKQZ4nz7Y0sJsuv8RDJOPkQKIJBmp31ZSBuvbjmsZZVcVEWM+q8Zb3nHFATNilDjbHijq5gQWKn1NE80bONJMw3pR7o4C7w4M5y1/czNVXm04Zdl/MzMSdQHJ309H4Ooh21o0sA8+71LIM= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1792305933; c=relaxed/simple; bh=7JYsESJxdmD+ewgea22YvZqiUBr62VnQW+NVePX4znQ=; h=Subject:From:To:Cc:Date:Message-ID:In-Reply-To:References: Content-Type:MIME-Version; b=Xwvw7gUJHtUCeDzlFO1kZp2MYDX5282iVgiThAqvjnPFQHcSxURKbrm5AaPyyS4NQhdz5vqXbLWX23XNkltxPg9zep4tRizq4i0H7ypOYj3Hi0H1ALMZFkKQz27+u0vFP6tTEFQ18bDOh1nttOA2/Ufwq7fX65xYd6nIfK3ieAs= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=h4tTjBwM; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="h4tTjBwM" Received: by smtp.kernel.org (Postfix) with ESMTPSA id D0AE61F000C4; Sun, 18 Oct 2026 06:45:30 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1792305932; bh=nwoQYoQto1YAJAYheTDELDgBOILwkL0JCAKNhO6a2hY=; h=Subject:From:To:Cc:Date:In-Reply-To:References; b=h4tTjBwM6zpfQOywL3uF1jwlI56Xdkk7WyoAmFRcXqbxCqhbxKPR8ateniSXxhWf7 iZrGYpvwzyC0S+PlHAAAguyoNOlKtZTS/jPetIMqTf8mgvcyG/miJZMGB1DG5AQIJ3 c7kwAktY40uPE61DOUXRT/voGdkkLQA+vf6sVj/pnp9FBXx2n2hSCTrpVuL4SG4SyZ KksJtcCIYQHcAlrDFj3kpbKICRvNUM6sC/IXIiK3k7Xh7kqIvoDSrrmtmk3dH7k912 JhZ4Ce2z0+7IW/sQbt4Lzr5+vmUxupTzI1fXjvxPpPeL+j0H8N8260BH5EgayOyS/r 8dg0H1C/tngIQ== Subject: Re: [PATCH net-next v12 3/6] net: pcs: xpcs: add Rockchip RK3568 platform glue driver From: netdev-bot+sashiko@kernel.org To: coiaprant@gmail.com Cc: kuba@kernel.org, netdev@vger.kernel.org, andrew+netdev@lunn.ch, davem@davemloft.net, edumazet@kernel.org, pabeni@redhat.com, robh@kernel.org, krzk+dt@kernel.org, conor+dt@kernel.org, heiko@sntech.de, maxime.chevallier@bootlin.com, mcoquelin.stm32@gmail.com, alexandre.torgue@foss.st.com, hkallweit1@gmail.com, linux@armlinux.org.uk, david.wu@rock-chips.com, linux-rockchip@lists.infradead.org, devicetree@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org Date: Sun, 18 Oct 2026 06:45:30 +0000 Message-ID: <179230593040.3135.11436989904007018210@kernel.org> In-Reply-To: <20261017054406.1828061-4-coiaprant@gmail.com> References: <20261017054406.1828061-4-coiaprant@gmail.com> X-sashiko-severity: High Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: 8bit Precedence: bulk X-Mailing-List: devicetree@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Thank you for your contribution! Sashiko AI review found 4 potential issue(s) to consider. Critical: 0 · High: 1 · Medium: 1 · Low: 2 If you believe none of the issues are legitimate, please reply to each issue of Medium severity or higher and explain why the AI is wrong. If any of them are legitimate and you plan to respin, please let patchwork know by including "pw-bot: cr" as a separate line at the end of your reply (one such reply per series is enough). - [High] The system-suspend design for keeping PD_PIPE powered does not work. - [Medium] xpcs_rk_create() (drivers/net/pcs/pcs-xpcs-rk.c:481) first calls device_link_add(dev, &pdev->dev, DL_FLAG_AUTOREMOVE_CONSUMER)… - [Low] The patch moves pcs-xpcs-plat.o (the generic snps,dw-xpcs platform driver, name "dwxpcs") out of the pcs_xpcs composite object… - [Low] Concern: xpcs_rk_create() is exported with no in-tree caller, and include/linux/pcs/pcs-xpcs-rk.h has no !CONFIG_PCS_XPCS_ROCKCHIP stub,… -- net: pcs: xpcs: add Rockchip RK3568 platform glue driver This adds a platform glue driver for the Synopsys DesignWare XPCS in the RK3568. The driver exposes the XPCS APB3 registers through a virtual MDIO bus and remaps the MMD per port. It also moves pcs-xpcs-plat.o out of the pcs_xpcs composite object behind a new PCS_XPCS_PLATFORM symbol, and tries to keep PD_PIPE powered across system suspend with device_set_wakeup_path(). Link: https://dl.radxa.com/rock3/docs/hw/datasheet/Rockchip%20RK3568%20TRM%20Part1%20V1.1-20210301.pdf (Page 59, CRU_CLKSEL_CON29) Link: https://dl.radxa.com/rock3/docs/hw/datasheet/Rockchip%20RK3568%20TRM%20Part2%20V1.1-20210301.pdf (Page 2078) > diff --git a/drivers/net/pcs/Kconfig b/drivers/net/pcs/Kconfig > index e417fd66f660a..108d47257bee2 100644 > --- a/drivers/net/pcs/Kconfig > +++ b/drivers/net/pcs/Kconfig > @@ -12,6 +12,29 @@ config PCS_XPCS > This module provides a driver and helper functions for Synopsys > DesignWare XPCS controllers. > > +if PCS_XPCS > + > +config PCS_XPCS_PLATFORM > + tristate "Generic XPCS controller support" > + help > + Generic DWXPCS driver for platforms that don't require any > + platform specific code to function or is using platform > + data for setup. > + > + If you have a controller with this interface, say Y or M here. > + [ ... ] > diff --git a/drivers/net/pcs/Makefile b/drivers/net/pcs/Makefile > index 4f7920618b900..f9f6cf2578d72 100644 > --- a/drivers/net/pcs/Makefile > +++ b/drivers/net/pcs/Makefile > @@ -1,10 +1,11 @@ > # SPDX-License-Identifier: GPL-2.0 > # Makefile for Linux PCS drivers > > -pcs_xpcs-$(CONFIG_PCS_XPCS) := pcs-xpcs.o pcs-xpcs-plat.o \ > - pcs-xpcs-nxp.o pcs-xpcs-wx.o > +pcs_xpcs-$(CONFIG_PCS_XPCS) := pcs-xpcs.o pcs-xpcs-nxp.o pcs-xpcs-wx.o > > obj-$(CONFIG_PCS_XPCS) += pcs_xpcs.o > +obj-$(CONFIG_PCS_XPCS_PLATFORM) += pcs-xpcs-plat.o [Severity: Low] Is it intended that existing configs lose the generic snps,dw-xpcs platform driver here? Before this change, any config with PCS_XPCS enabled (for example through the select PCS_XPCS in STMMAC_ETH) always built pcs-xpcs-plat.o. The new PCS_XPCS_PLATFORM has no default, so make olddefconfig silently turns the generic glue off. Some systems have a DT, for instance one provided by firmware, with an MMIO node using the documented snps,dw-xpcs binding. On those systems no MDIO device would be created for that node, and a MAC calling xpcs_create_fwnode() would get -EPROBE_DEFER forever: drivers/net/pcs/pcs-xpcs.c:xpcs_create_fwnode() { ... mdiodev = fwnode_mdio_find_device(fwnode); if (!mdiodev) return ERR_PTR(-EPROBE_DEFER); ... } No in-tree DTS uses the binding, and the commit message says the change is deliberate. However, the Rockchip glue only uses exported core symbols, so it does not seem to need the split. Would adding "default PCS_XPCS" keep the old behaviour? Alternatively, could the split go into its own patch? > +obj-$(CONFIG_PCS_XPCS_ROCKCHIP) += pcs-xpcs-rk.o > obj-$(CONFIG_PCS_LYNX) += pcs-lynx.o > obj-$(CONFIG_PCS_MTK_LYNXI) += pcs-mtk-lynxi.o > obj-$(CONFIG_PCS_RZN1_MIIC) += pcs-rzn1-miic.o > diff --git a/drivers/net/pcs/pcs-xpcs-rk.c b/drivers/net/pcs/pcs-xpcs-rk.c > new file mode 100644 > index 0000000000000..698a43b753341 > --- /dev/null > +++ b/drivers/net/pcs/pcs-xpcs-rk.c > @@ -0,0 +1,598 @@ [ ... ] > +struct dw_xpcs *xpcs_rk_create(struct device *dev, struct device_node *pcs, int port) > +{ [ ... ] > + pdev = of_find_device_by_node(pcs); > + if (!pdev) > + return ERR_PTR(-EPROBE_DEFER); > + > + /* > + * Establish the device link before reading the supplier's drvdata. > + * device_link_add() does not fail on a supplier that is unbinding; > + * it creates the link in DL_STATE_SUPPLIER_UNBIND. > + * > + * The check below only confirms that the supplier is bound at this > + * point. It does not fully protect against a concurrent unbind > + * between here and xpcs_create_mdiodev(); closing that window would > + * require reading a managed link's status or device_lock(), neither > + * of which is acceptable on this path. The window is small and > + * requires an explicit unbind from userspace. Discussed on > + * driver-core. > + * > + * The link is released automatically when the consumer device is > + * destroyed (DL_FLAG_AUTOREMOVE_CONSUMER), so no explicit > + * device_link_remove() is needed on the failure paths. > + */ > + if (!device_link_add(dev, &pdev->dev, DL_FLAG_AUTOREMOVE_CONSUMER)) { > + put_device(&pdev->dev); > + return ERR_PTR(-EPROBE_DEFER); > + } > + > + if (READ_ONCE(pdev->dev.links.status) != DL_DEV_DRIVER_BOUND) { > + put_device(&pdev->dev); > + return ERR_PTR(-EPROBE_DEFER); > + } [Severity: Medium] Does this check protect the rest of the MAC probe? pcs-handle is not a fw_devlink supplier binding, so the MAC can reach this point while the XPCS is still unbound. In that case device_link_init_status() creates the link as DL_STATE_DORMANT. The XPCS probe can finish on another CPU between device_link_add() and the READ_ONCE(), for example with parallel module loading or async probe: CPU1 (MAC probe) CPU2 (XPCS probe) xpcs_rk_create() device_link_add() link is DL_STATE_DORMANT device_links_driver_bound() link becomes DL_STATE_AVAILABLE READ_ONCE(pdev->dev.links.status) is DL_DEV_DRIVER_BOUND, passes xpcs_create_mdiodev(pxpcs->bus, port) device_links_busy() only counts CONSUMER_PROBE and ACTIVE as busy: drivers/base/core.c:device_links_busy() { ... if (link->status == DL_STATE_CONSUMER_PROBE || link->status == DL_STATE_ACTIVE) { ret = true; ... } So until the MAC finishes probing, a sysfs unbind or module unload of the XPCS would not wait for it. The XPCS devres teardown would then free pxpcs and the mii_bus. Meanwhile xpcs_rk_create() or the rest of the stmmac probe can still reach them through bus->priv and reg_base in xpcs_rk_read_c45() and xpcs_rk_write_c45(). Can this lead to a use-after-free of pxpcs? Even without an unbind, wouldn't the MAC's own bind hit this warning on the AVAILABLE link? drivers/base/core.c:device_links_driver_bound() { ... WARN_ON(link->status != DL_STATE_CONSUMER_PROBE); WRITE_ONCE(link->status, DL_STATE_ACTIVE); ... } Also, if the supplier unbinds while this AUTOREMOVE_CONSUMER link is still present, device_links_driver_cleanup() would trigger: WARN_ON(device_link_test(link, DL_FLAG_AUTOREMOVE_CONSUMER)); The comment above only covers a window up to xpcs_create_mdiodev() opened by an explicit userspace unbind. In this race, the link never gets CONSUMER_PROBE protection for the rest of the MAC probe. Would it work to check the status of the link returned by device_link_add() instead? That would mean requiring DL_STATE_CONSUMER_PROBE or DL_STATE_ACTIVE, and otherwise calling device_link_del() and returning -EPROBE_DEFER. If the supplier is already bound when the link is created, the link starts as CONSUMER_PROBE and that path looks fine. > + > + pxpcs = platform_get_drvdata(pdev); > + if (!pxpcs || !pxpcs->bus) { > + put_device(&pdev->dev); > + return ERR_PTR(-EPROBE_DEFER); > + } > + > + xpcs = xpcs_create_mdiodev(pxpcs->bus, port); [ ... ] > +static int xpcs_rk_system_suspend(struct device *dev) > +{ > + /* > + * Keep the PD_PIPE power domain on during system suspend. > + * > + * PD_PIPE is shared with SATA/PCIe and would be powered down by > + * genpd once all its consumers are suspended, killing the SerDes > + * and breaking MAC WoL. Mark the XPCS as part of the wakeup path > + * so genpd keeps the domain on. Unconditional because the XPCS > + * core has no callback to convey the MAC WoL state. > + */ > + device_set_wakeup_path(dev); > + return 0; > +} > + > +static int xpcs_rk_system_resume(struct device *dev) > +{ > + return 0; > +} [Severity: High] Does device_set_wakeup_path() in xpcs_rk_system_suspend() actually keep PD_PIPE on? genpd only honours the wakeup path when the domain has GENPD_FLAG_ACTIVE_WAKEUP: drivers/pmdomain/core.c:genpd_finish_suspend() { ... if (device_awake_path(dev) && genpd_is_active_wakeup(genpd) && !device_out_band_wakeup(dev)) return 0; ... } The commit message says: "genpd then leaves the domain powered, because the Rockchip power domain driver sets GENPD_FLAG_ACTIVE_WAKEUP on PD_PIPE" However, PD_PIPE is declared with wakeup set to false: drivers/pmdomain/rockchip/pm-domains.c: [RK3568_PD_PIPE] = DOMAIN_RK3568("pipe", BIT(8), BIT(11), false, false), rockchip_pm_add_one_domain() only adds the flag when active_wakeup is set: pd->genpd.flags = GENPD_FLAG_PM_CLK | GENPD_FLAG_NO_STAY_ON; if (pd_info->active_wakeup) pd->genpd.flags |= GENPD_FLAG_ACTIVE_WAKEUP; So the early return is never taken. suspended_count is incremented and genpd_sync_power_off() runs. That function ignores the per-device rpm_always_on set by dev_pm_genpd_rpm_always_on(). Once SATA, PCIe and the XPCS are all suspended, PD_PIPE would be powered off in the noirq phase. Wouldn't that break MAC WoL over SGMII, which this code is meant to preserve? If PD_PIPE is power-cycled, xpcs_rk_system_resume() does not repeat the probe-time setup either. The probe comment says the SerDes phy_init() and phy_power_on() are needed for register access and soft reset. Also, need_reset in the core is only set in xpcs_create(), so the XPCS soft reset is not run again after power loss. _DEFINE_DEV_PM_OPS() also maps freeze/thaw/poweroff/restore to these callbacks, so hibernation seems to have the same gap. Would this need either a change to the PD_PIPE active_wakeup setting (which also affects PCIe and SATA), or a resume path that restores the SerDes and the XPCS? -- Sashiko AI review · https://netdev-ai.bots.linux.dev/sashiko/#/patchset/20261017054406.1828061-1-coiaprant%40gmail.com