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 21B32C531D0 for ; Sat, 25 Jul 2026 05:16:35 +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:MIME-Version:Reply-To:List-Subscribe: List-Help:List-Post:List-Archive:List-Unsubscribe:List-Id:Message-Id:Date: References:In-Reply-To:Cc:To:Subject:From:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=ll6fQoyqSjaug2R+gTYeJVqMtimaOV8ouD3uQkx2yM4=; b=uXPoKW0/w7QLYU seDsAZYBy+/PY4a6ScJxE0DVBJuolCn9ju/08KfSlrcouI5ilo6yLUwpOd4474KdnSdb21wtK0W7h zV0+KpjHMqXmManPo3SGmndLmkzuA5xacsJWM7in+i37jCwHiqSqgGU4rIcMNyCHw1rftBbppRq7O VlHhIiqX5stbLp4+5gJ4S5msS/yoR2maBcykb4xhxnYUwGJFcJJ0x+V127In+APWA9J93nABZwadP Z5pK+4zTm0yYUsRLmyfRolmjKxNwmUlLs1SlPvn+/eURPj5xcdiDDyLePGmWs2kjWlNBvybvNczbd 2dntBqmFII1J7MmC28tQ==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.99.1 #2 (Red Hat Linux)) id 1wnUkU-000000003v2-3V17; Sat, 25 Jul 2026 05:16:34 +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 1wnUkT-000000003uv-30eV for linux-phy@lists.infradead.org; Sat, 25 Jul 2026 05:16:33 +0000 Received: from smtp.kernel.org (quasi.space.kernel.org [100.103.45.18]) by sea.source.kernel.org (Postfix) with ESMTP id 4A2C743B1F; Sat, 25 Jul 2026 05:16:33 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id B26341F000E9; Sat, 25 Jul 2026 05:16:32 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1784956593; bh=XAKNe4Xav4AmQ2UV4OyG/MZDDnkWslDHAQDtv/PFkF4=; h=From:Subject:Reply-To:To:Cc:In-Reply-To:References:Date; b=AizyW1TdCvHMzpFE/YJ3JQvqRsixlMU3M8G6Hp84PzvB+/uwR3lPJTXws93Bcz5Tp uXTWdidghy/+ZsdWLcxSfl8ZprTW25vAhrtrOTMXDymYWTJegD5F4BoaJeHpM1NiFm IemDLqDkNaIwWQVGNaIaMYzMxX7dK29tJdmZ528VRZ9bpXtQ7+DBvgg27mueTXxqEM aS7egEIGtoO1cJM/Kid+NX/PHutMduPNLcmQRlC7t41PniosLilfNh5sx3AP3lhiTj hjx1eRXM9wLPgsFYz+zoRV9Sy4t958KXAub+MoJSkQKRg7AADke2SSX3IIsCmSgRT3 s9rYYB++/0jdQ== From: sashiko-bot@kernel.org Subject: Re: [PATCH 05/17] phy: spacemit: add Innosilicon DP TX PHY driver To: "Cody Kang" Cc: devicetree@vger.kernel.org, conor+dt@kernel.org, olteanv@gmail.com, linux-phy@lists.infradead.org, vkoul@kernel.org, neil.armstrong@linaro.org, dri-devel@lists.freedesktop.org, robh@kernel.org In-Reply-To: <20260724-k3-display-v1-5-f22a10a52867@gmail.com> References: <20260724-k3-display-v1-0-f22a10a52867@gmail.com> <20260724-k3-display-v1-5-f22a10a52867@gmail.com> Date: Sat, 25 Jul 2026 05:16:32 +0000 Message-Id: <20260725051632.B26341F000E9@smtp.kernel.org> X-BeenThere: linux-phy@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: Linux Phy Mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Reply-To: sashiko-reviews@lists.linux.dev MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-phy" Errors-To: linux-phy-bounces+linux-phy=archiver.kernel.org@lists.infradead.org VGhhbmsgeW91IGZvciB5b3VyIGNvbnRyaWJ1dGlvbiEgU2FzaGlrbyBBSSByZXZpZXcgZm91bmQg NyBwb3RlbnRpYWwgaXNzdWUocykgdG8gY29uc2lkZXI6Ci0gW0hpZ2hdIEhhcmR3YXJlIHN0YXRl IChQUkVQTEwpIGlzIGFjY2Vzc2VkIGNvbmN1cnJlbnRseSB3aXRob3V0IHByb3RlY3Rpb24gYWNy b3NzIFBIWSBhbmQgQ0NGIGZyYW1ld29ya3MuCi0gW01lZGl1bV0gVGhlIGRyaXZlciBmYWlscyB0 byBwb3dlciBvZmYgdGhlIGNvcmUgRFAgbGluayBQTEwgKE1QTEwpIHdoZW4gdGhlIFBIWSBpcyBk aXNhYmxlZCwgY2F1c2luZyBhIHBvd2VyIGxlYWsuCi0gW01lZGl1bV0gTWlzc2luZyBjbGVhbnVw IGluIHRoZSBgazNfaW5ub19kcF9waHlfcG93ZXJfb25gIGVycm9yIHBhdGhzIGxlYXZlcyBQSFkg Y29tcG9uZW50cyBhY3RpdmVseSBjb25zdW1pbmcgcG93ZXIuCi0gW01lZGl1bV0gRHluYW1pY2Fs bHkgcmVkdWNpbmcgdGhlIGxhbmUgY291bnQgdmlhIGBwaHlfY29uZmlndXJlKClgIGRvZXMgbm90 IGRpc2FibGUgdGhlIHVudXNlZCB0cmFuc21pdCBsYW5lIGRyaXZlcnMuCi0gW01lZGl1bV0gVW5j b25kaXRpb25hbCBQTEwgcG93ZXItdXAgZHVyaW5nIHJhdGUgY29uZmlndXJhdGlvbiBvdmVycmlk ZXMgdGhlIFBIWSBwb3dlciBzdGF0ZS4KLSBbTWVkaXVtXSBNaXNzaW5nIGJvdW5kcyBjaGVjayBv biBgb3B0cy0+bGFuZXNgIGNhdXNlcyBvdXQtb2YtYm91bmRzIGFycmF5IHJlYWRzIGFuZCB1bmRl ZmluZWQgc2hpZnQgYmVoYXZpb3IgaW4gYGszX2lubm9fZHBfcGh5X3NldF92b2x0YWdlc2AuCi0g W01lZGl1bV0gVGhlIHBpeGVsIGNsb2NrIChgcHhjbGtgKSBpcyByZWdpc3RlcmVkIHdpdGggdGhl IENDRiB3aXRob3V0IGAucHJlcGFyZWAvYC51bnByZXBhcmVgIG9yIGAuZW5hYmxlYC9gLmRpc2Fi bGVgIGhvb2tzLCB5ZXQgaXRzIHBvd2VyIHN0YXRlIGlzIG1hbmlwdWxhdGVkIGltcGxpY2l0bHku Ci0tCgotLS0gUGF0Y2ggWzVdOiBbUEFUQ0ggMDUvMTddIHBoeTogc3BhY2VtaXQ6IGFkZCBJbm5v c2lsaWNvbiBEUCBUWCBQSFkgZHJpdmVyIC0tLQpjb21taXQgNDZiNzY0ZDkxYTk3N2JkYzc5NmU0 MDRkN2VhYWJiMDM2MmU3NTNiMApBdXRob3I6IENvZHkgS2FuZyA8Y29keWthbmcuaGtAZ21haWwu Y29tPgpTdWJqZWN0OiBwaHk6IHNwYWNlbWl0OiBhZGQgSW5ub3NpbGljb24gRFAgVFggUEhZIGRy aXZlcgoKVGhpcyBjb21taXQgYWRkcyBzdXBwb3J0IGZvciB0aGUgSW5ub3NpbGljb24gRGlzcGxh eVBvcnQgdHJhbnNtaXQgUEhZCmludGVncmF0ZWQgaW4gdGhlIFNwYWNlbWlUIEszIFNvQy4gVGhl IFBIWSBzaGFyZXMgaXRzIE1NSU8gd2luZG93IHdpdGggaXRzCnBhcmVudCBEUC9lRFAgY29udHJv bGxlciBhbmQgZXhwb3NlcyBsYW5lLCByYXRlLCBhbmQgdm9sdGFnZSBjb250cm9sLiBJdAphbHNv IHJlZ2lzdGVycyBpdHMgcGl4ZWwgUExMIGFzIGEgY2xvY2sgcHJvdmlkZXIuCgo+IGRpZmYgLS1n aXQgYS9kcml2ZXJzL3BoeS9zcGFjZW1pdC9waHktazMtaW5uby1kcC5jIGIvZHJpdmVycy9waHkv c3BhY2VtaXQvcGh5LWszLWlubm8tZHAuYwo+IG5ldyBmaWxlIG1vZGUgMTAwNjQ0Cj4gaW5kZXgg MDAwMDAwMDAwMDAwMC4uOWRkNjJlZGI3YTVhZgo+IC0tLSAvZGV2L251bGwKPiArKysgYi9kcml2 ZXJzL3BoeS9zcGFjZW1pdC9waHktazMtaW5uby1kcC5jCgpbIC4uLiBdCgo+IEBAIC0xMDMsNDUg KzEwMyw0NSBAQCBzdGF0aWMgaW50IGszX2lubm9fZHBfcGh5X3Bvd2VyX29uKHN0cnVjdCBwaHkg KnBoeSkKPiArCXN0cnVjdCBrM19pbm5vX2RwX3BoeSAqcCA9IHBoeV9nZXRfZHJ2ZGF0YShwaHkp Owo+ICsJdTMyIGxhbmVfZW47Cj4gKwl1MzIgdmFsOwo+ICsJaW50IHJldDsKPiArCj4gKwlzd2l0 Y2ggKHAtPmxhbmVzKSB7Cj4gKwljYXNlIDE6Cj4gKwkJbGFuZV9lbiA9IDB4MTsKPiArCQlicmVh azsKPiArCWNhc2UgMjoKPiArCQlsYW5lX2VuID0gMHgzOwo+ICsJCWJyZWFrOwo+ICsJY2FzZSA0 Ogo+ICsJZGVmYXVsdDoKPiArCQlsYW5lX2VuID0gMHhmOwo+ICsJCWJyZWFrOwo+ICsJfQo+ICsK PiArCXJldCA9IHJlZ21hcF93cml0ZV9iaXRzKHAtPnJlZ21hcCwgRFBUWF9BTkFfTVBMTCwgRFBU WF9BTkFfTVBMTF9QRCwgMCk7Cj4gKwlpZiAocmV0KQo+ICsJCXJldHVybiByZXQ7Cj4gKwlyZXQg PSByZWdtYXBfd3JpdGVfYml0cyhwLT5yZWdtYXAsIERQVFhfQU5BX1BSRVBMTCwKPiArCQkJCURQ VFhfQU5BX1BSRVBMTF9QRCwgMCk7Cj4gKwlpZiAocmV0KQo+ICsJCXJldHVybiByZXQ7CgpbU2V2 ZXJpdHk6IEhpZ2hdCkFyZSB0aGVyZSBwb3RlbnRpYWwgY29uY3VycmVuY3kgaXNzdWVzIGJldHdl ZW4gdGhlIENDRiBhbmQgUEhZIGZyYW1ld29ya3Mgd2hlbiAKYWNjZXNzaW5nIHRoZSBQUkVQTEw/ CgpUaGUgQ0NGIGNhbGxzIGszX2lubm9fZHBfcHhjbGtfc2V0X3JhdGUoKSBob2xkaW5nIHRoZSBw cmVwYXJlX2xvY2ssIHdoaWNoIApwb3dlcnMgZG93biB0aGUgUFJFUExMLCBzbGVlcHMsIGFuZCBw cm9ncmFtcyByZWdpc3RlcnMuIE1lYW53aGlsZSwgdGhlIFBIWSAKZnJhbWV3b3JrIGNhbGxzIGsz X2lubm9fZHBfcGh5X3Bvd2VyX29uKCkgaG9sZGluZyBwaHktPm11dGV4LiAKCkNvdWxkIGEgY29u Y3VycmVudCBwaHlfcG93ZXJfb24oKSBjbGVhciB0aGUgUFJFUExMX1BEIGJpdCBkdXJpbmcgdGhl IHNsZWVwIAp3aW5kb3csIGNhdXNpbmcgdGhlIGNsb2NrIGZyYW1ld29yayB0byB3cml0ZSBjb25m aWd1cmF0aW9uIHZhbHVlcyB0byBhIApydW5uaW5nIFBMTD8KCj4gKwl1c2xlZXBfcmFuZ2UoMjAw MCwgNDAwMCk7Cj4gKwo+ICsJcmV0ID0gcmVnbWFwX3dyaXRlX2JpdHMocC0+cmVnbWFwLCBEUFRY X1BIWV9DVFJMLAo+ICsJCQkJRFBUWF9QSFlfQ1RSTF9YTUlUX0VOLAo+ICsJCQkJRklFTERfUFJF UChEUFRYX1BIWV9DVFJMX1hNSVRfRU4sIGxhbmVfZW4pKTsKPiArCWlmIChyZXQpCj4gKwkJcmV0 dXJuIHJldDsKPiArCXVzbGVlcF9yYW5nZSgyMDAwLCA0MDAwKTsKPiArCj4gKwlyZXQgPSByZWdt YXBfcmVhZF9wb2xsX3RpbWVvdXQocC0+cmVnbWFwLCBEUFRYX0FOQV9NUExMLCB2YWwsCj4gKwkJ CQkgICAgICAgdmFsICYgRFBUWF9BTkFfTVBMTF9MT0NLRUQsCj4gKwkJCQkgICAgICAgMjAwMCwg MTAgKiAxMDAwKTsKPiArCWlmIChyZXQpIHsKPiArCQlkZXZfZXJyKHAtPmRldiwgIkRQIFBIWSBj b3JlIFBMTCBsb2NrIHRpbWVkIG91dFxuIik7Cj4gKwkJcmV0dXJuIHJldDsKPiArCX0KCltTZXZl cml0eTogTWVkaXVtXQpJZiByZWdtYXBfcmVhZF9wb2xsX3RpbWVvdXQoKSB0aW1lcyBvdXQgaGVy ZSBvciBvbiB0aGUgUFJFUExMIGxvY2ssIHdlIHJldHVybiAKYW4gZXJyb3Igd2l0aG91dCByZXZl cnRpbmcgdGhlIHBvd2VyZWQtdXAgaGFyZHdhcmUgc3RhdGUuCgpTaW5jZSB0aGUgUEhZIGNvcmUg ZnJhbWV3b3JrIGRvZXNuJ3QgaW52b2tlIHBoeV9wb3dlcl9vZmYoKSBpZiBwaHlfcG93ZXJfb24o KSAKZmFpbHMsIGRvZXMgdGhpcyBsZWF2ZSB0aGUgTVBMTCwgUFJFUExMLCBhbmQgdHJhbnNtaXQg bGFuZXMgaW5kZWZpbml0ZWx5IApwb3dlcmVkIG9uIGluIGFuIGVycm9yIHN0YXRlPwoKPiArCj4g KwlyZXQgPSByZWdtYXBfcmVhZF9wb2xsX3RpbWVvdXQocC0+cmVnbWFwLCBEUFRYX0FOQV9QUkVQ TEwsIHZhbCwKPiArCQkJCSAgICAgICB2YWwgJiBEUFRYX0FOQV9QUkVQTExfTE9DS0VELAo+ICsJ CQkJICAgICAgIDIwMDAsIDEwICogMTAwMCk7Cj4gKwlpZiAocmV0KQo+ICsJCWRldl9lcnIocC0+ ZGV2LCAiRFAgUEhZIHBpeGVsIFBMTCBsb2NrIHRpbWVkIG91dFxuIik7Cj4gKwo+ICsJcmV0dXJu IHJldDsKPiArfQo+ICsKPiArc3RhdGljIGludCBrM19pbm5vX2RwX3BoeV9wb3dlcl9vZmYoc3Ry dWN0IHBoeSAqcGh5KQo+ICt7Cj4gKwlzdHJ1Y3QgazNfaW5ub19kcF9waHkgKnAgPSBwaHlfZ2V0 X2RydmRhdGEocGh5KTsKPiArCj4gKwlyZWdtYXBfd3JpdGVfYml0cyhwLT5yZWdtYXAsIERQVFhf UEhZX0NUUkwsIERQVFhfUEhZX0NUUkxfWE1JVF9FTiwgMCk7Cj4gKwl1c2xlZXBfcmFuZ2UoMjAw MCwgNDAwMCk7Cj4gKwo+ICsJcmVnbWFwX3dyaXRlX2JpdHMocC0+cmVnbWFwLCBEUFRYX0FOQV9Q UkVQTEwsIERQVFhfQU5BX1BSRVBMTF9QRCwKPiArCQkJICBEUFRYX0FOQV9QUkVQTExfUEQpOwo+ ICsJdXNsZWVwX3JhbmdlKDIwMDAsIDQwMDApOwo+ICsKPiArCXJldHVybiAwOwo+ICt9CgpbU2V2 ZXJpdHk6IE1lZGl1bV0KVGhpcyBwb3dlcnMgZG93biB0aGUgcGl4ZWwgUExMIGFuZCBkaXNhYmxl cyB0aGUgdHJhbnNtaXQgbGFuZXMsIGJ1dCBpdAphcHBlYXJzIHRvIHNraXAgcG93ZXJpbmcgZG93 biB0aGUgY29yZSBEUCBsaW5rIFBMTC4KCkRvZXMgdGhpcyBsZWF2ZSB0aGUgTVBMTCBydW5uaW5n IGluZGVmaW5pdGVseSBhbmQgbGVha2luZyBwb3dlciB3aGVuIHRoZSBQSFkgCmlzIG1lYW50IHRv IGJlIGRpc2FibGVkPyBTaG91bGQgd2UgYWxzbyBiZSBzZXR0aW5nIERQVFhfQU5BX01QTExfUEQg aGVyZT8KClsgLi4uIF0KCj4gK3N0YXRpYyBpbnQgazNfaW5ub19kcF9waHlfc2V0X2xhbmVzKHN0 cnVjdCBrM19pbm5vX2RwX3BoeSAqcCwgdTggbGFuZXMpCj4gK3sKPiArCXUzMiB2YWw7Cj4gKwlp bnQgcmV0OwoKWyAuLi4gXQoKPiArCXJldCA9IHJlZ21hcF93cml0ZV9iaXRzKHAtPnJlZ21hcCwg RFBUWF9QSFlfQ1RSTCwKPiArCQkJCURQVFhfUEhZX0NUUkxfTlVNX0xBTkVTLAo+ICsJCQkJRklF TERfUFJFUChEUFRYX1BIWV9DVFJMX05VTV9MQU5FUywgdmFsKSk7Cj4gKwlpZiAocmV0KQo+ICsJ CXJldHVybiByZXQ7Cj4gKwo+ICsJcC0+bGFuZXMgPSBsYW5lczsKPiArCXJldHVybiAwOwo+ICt9 CgpbU2V2ZXJpdHk6IE1lZGl1bV0KSWYgYSBjYWxsZXIgZHluYW1pY2FsbHkgcmVkdWNlcyB0aGUg bGFuZSBjb3VudCB2aWEgcGh5X2NvbmZpZ3VyZSgpIChmb3IgCmluc3RhbmNlLCBmYWxsaW5nIGJh Y2sgZnJvbSA0IGxhbmVzIHRvIDIgZHVyaW5nIERQIGxpbmsgdHJhaW5pbmcpLCB0aGlzIAp1cGRh dGVzIHRoZSBsb2dpY2FsIGxhbmUgY291bnQgYnV0IGRvZXNuJ3Qgc3luY2hyb25pemUgdGhlIApE UFRYX1BIWV9DVFJMX1hNSVRfRU4gcmVnaXN0ZXIgYml0cy4KCldpbGwgdGhpcyBsZWF2ZSB0aGUg dW51c2VkIHBoeXNpY2FsIHRyYW5zbWl0IGxhbmUgZHJpdmVycyBhY3RpdmVseSBkcml2ZW4/Cgpb IC4uLiBdCgo+ICtzdGF0aWMgdm9pZCBrM19pbm5vX2RwX3BoeV9wcm9ncmFtX21wbGwoc3RydWN0 IGszX2lubm9fZHBfcGh5ICpwLAo+ICsJCQkJCWNvbnN0IHN0cnVjdCBrM19pbm5vX2RwX21wbGxf Y2ZnICpjZmcpCj4gK3sKPiArCXN0cnVjdCByZWdtYXAgKnJtID0gcC0+cmVnbWFwOwoKWyAuLi4g XQoKPiArCXJlZ21hcF93cml0ZV9iaXRzKHJtLCBEUFRYX0FOQV9QUkVQTExfQ1RSTCwgRFBUWF9B TkFfUFJFUExMX0xPQ0tfQllQRU4sCj4gKwkJRklFTERfUFJFUChEUFRYX0FOQV9QUkVQTExfTE9D S19CWVBFTiwgMSkpOwo+ICsKPiArCXJlZ21hcF93cml0ZV9iaXRzKHJtLCBEUFRYX0FOQV9NUExM LCBEUFRYX0FOQV9NUExMX1BELAo+ICsJCUZJRUxEX1BSRVAoRFBUWF9BTkFfTVBMTF9QRCwgMCkp Owo+ICsJdXNsZWVwX3JhbmdlKDIwMDAsIDQwMDApOwo+ICt9CgpbU2V2ZXJpdHk6IE1lZGl1bV0K V2hlbiBjb25maWd1cmluZyB0aGUgUExMIHJhdGUsIHRoaXMgY2xlYXJzIHRoZSBwb3dlciBkb3du IGJpdCAKKERQVFhfQU5BX01QTExfUEQpIGF0IHRoZSBlbmQgb2YgdGhlIHByb2dyYW1taW5nIHNl cXVlbmNlLgoKSWYgYSByYXRlIGNvbmZpZ3VyYXRpb24gb2NjdXJzIHdoaWxlIHRoZSBQSFkgaXMg aW50ZW50aW9uYWxseSBzdXNwZW5kZWQsIHdpbGwgCnRoaXMgZm9yY2UgdGhlIFBMTHMgb24gYW5k IG92ZXJyaWRlIHRoZSBQSFkncyBpbnRlbmRlZCBwb3dlciBzdGF0ZT8KClsgLi4uIF0KCj4gK3N0 YXRpYyBpbnQgazNfaW5ub19kcF9waHlfc2V0X3ZvbHRhZ2VzKHN0cnVjdCBrM19pbm5vX2RwX3Bo eSAqcCwKPiArCQkJCSAgICAgICBzdHJ1Y3QgcGh5X2NvbmZpZ3VyZV9vcHRzX2RwICpvcHRzKQo+ ICt7Cj4gKwl1OCBsYW5lOwo+ICsJaW50IHJldDsKPiArCj4gKwlmb3IgKGxhbmUgPSAwOyBsYW5l IDwgb3B0cy0+bGFuZXM7IGxhbmUrKykgewo+ICsJCXVuc2lnbmVkIGludCBzaGlmdCA9IGxhbmUg KiBEUFRYX1BIWV9MQU5FX0JJVFNfUEVSOwo+ICsJCXUzMiBtYXNrID0gRFBUWF9QSFlfTEFORV9G SUVMRF9NQVNLIDw8IHNoaWZ0Owo+ICsJCXUzMiB2YWwgID0gKCgob3B0cy0+dm9sdGFnZVtsYW5l XSAmIDB4MykgPDwgRFBUWF9QSFlfTEFORV9WU1dJTkdfU0hJRlQpIHwKPiArCQkJICAgIChvcHRz LT5wcmVbbGFuZV0gJiAweDMpKSA8PCBzaGlmdDsKCltTZXZlcml0eTogTWVkaXVtXQpDb3VsZCBh biB1bnZhbGlkYXRlZCBvciB1bmluaXRpYWxpemVkIG9wdHMtPmxhbmVzIGNhdXNlIGFuIG91dC1v Zi1ib3VuZHMKYXJyYXkgcmVhZCBvbiBvcHRzLT52b2x0YWdlIGFuZCBvcHRzLT5wcmUsIGFzIHdl bGwgYXMgdW5kZWZpbmVkIGJpdCBzaGlmdHMKaGVyZT8KCkluIGszX2lubm9fZHBfcGh5X2NvbmZp Z3VyZSgpLCBrM19pbm5vX2RwX3BoeV9zZXRfbGFuZXMoKSBpcyBvbmx5IGNhbGxlZCBpZiAKb3B0 cy0+ZHAuc2V0X2xhbmVzIGlzIHRydWUuIElmIGEgY2FsbGVyIHBhc3NlcyBvcHRzLT5kcC5zZXRf bGFuZXMgPSAwIGJ1dCAKb3B0cy0+ZHAuc2V0X3ZvbHRhZ2VzID0gMSwgb3B0cy0+ZHAubGFuZXMg c2tpcHMgdmFsaWRhdGlvbi4KClsgLi4uIF0KCj4gK3N0YXRpYyB2b2lkIGszX2lubm9fZHBfcHJv Z3JhbV9wcmVwbGwoc3RydWN0IGszX2lubm9fZHBfcGh5ICpwLAo+ICsJCQkJICAgICAgY29uc3Qg c3RydWN0IGszX2lubm9fZHBfcHJlcGxsX2NmZyAqY2ZnKQo+ICt7Cj4gKwlyZWdtYXBfd3JpdGVf Yml0cyhwLT5yZWdtYXAsIERQVFhfQU5BX1BSRVBMTCwgRFBUWF9BTkFfUFJFUExMX1BELAo+ICsJ CUZJRUxEX1BSRVAoRFBUWF9BTkFfUFJFUExMX1BELCAxKSk7Cj4gKwl1c2xlZXBfcmFuZ2UoMjAw MCwgNDAwMCk7Cj4gKwoKWyAuLi4gXQoKPiArCXJlZ21hcF93cml0ZV9iaXRzKHAtPnJlZ21hcCwg RFBUWF9BTkFfUFJFUExMLCBEUFRYX0FOQV9QUkVQTExfUEQsCj4gKwkJRklFTERfUFJFUChEUFRY X0FOQV9QUkVQTExfUEQsIDApKTsKPiArCXVzbGVlcF9yYW5nZSgyMDAwLCA0MDAwKTsKPiArfQoK W1NldmVyaXR5OiBNZWRpdW1dClNpbWlsYXIgdG8gdGhlIE1QTEwgY29uZmlndXJhdGlvbiwgdGhp cyB1bmNvbmRpdGlvbmFsbHkgY2xlYXJzIHRoZSBQUkVQTEwgCnBvd2VyIGRvd24gYml0IGF0IHRo ZSBlbmQgb2YgcHJvZ3JhbW1pbmcsIHBvdGVudGlhbGx5IG92ZXJyaWRpbmcgdGhlIGludGVuZGVk IApwb3dlciBzdGF0ZSBvZiB0aGUgUEhZLgoKWyAuLi4gXQoKPiArc3RhdGljIGNvbnN0IHN0cnVj dCBjbGtfb3BzIGszX2lubm9fZHBfcHhjbGtfb3BzID0gewo+ICsJLnJlY2FsY19yYXRlCT0gazNf aW5ub19kcF9weGNsa19yZWNhbGNfcmF0ZSwKPiArCS5kZXRlcm1pbmVfcmF0ZQk9IGszX2lubm9f ZHBfcHhjbGtfZGV0ZXJtaW5lX3JhdGUsCj4gKwkuc2V0X3JhdGUJPSBrM19pbm5vX2RwX3B4Y2xr X3NldF9yYXRlLAo+ICt9OwoKW1NldmVyaXR5OiBNZWRpdW1dClRoZSBwaXhlbCBjbG9jayBpcyBy ZWdpc3RlcmVkIHdpdGggdGhlIENvbW1vbiBDbG9jayBGcmFtZXdvcmsgd2l0aG91dCAKLnByZXBh cmUvLnVucHJlcGFyZSBvciAuZW5hYmxlLy5kaXNhYmxlIGhvb2tzLgoKU2luY2UgdGhlIENDRiB0 cmFja3MgdGhlIGNsb2NrIHN0YXRlIHB1cmVseSBpbiBzb2Z0d2FyZSB3aGlsZSBwaHlfcG93ZXJf b2ZmKCkgCnBoeXNpY2FsbHkgcG93ZXJzIGRvd24gdGhlIFBSRVBMTCwgY2FuIHRoaXMgY2F1c2Ug YSBtaXNtYXRjaCB3aGVyZSBkb3duc3RyZWFtIApjb25zdW1lcnMgbG9zZSB0aGVpciBjbG9jayB1 bmV4cGVjdGVkbHkgd2hpbGUgdGhlIENDRiB0aGlua3MgaXQgaXMgc3RpbGwgCnJ1bm5pbmc/Cgot LSAKU2FzaGlrbyBBSSByZXZpZXcgwrcgaHR0cHM6Ly9zYXNoaWtvLmRldi8jL3BhdGNoc2V0LzIw MjYwNzI0LWszLWRpc3BsYXktdjEtMC1mMjJhMTBhNTI4NjdAZ21haWwuY29tP3BhcnQ9NQoKLS0g CmxpbnV4LXBoeSBtYWlsaW5nIGxpc3QKbGludXgtcGh5QGxpc3RzLmluZnJhZGVhZC5vcmcKaHR0 cHM6Ly9saXN0cy5pbmZyYWRlYWQub3JnL21haWxtYW4vbGlzdGluZm8vbGludXgtcGh5Cg== 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 gabe.freedesktop.org (gabe.freedesktop.org [131.252.210.177]) (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 46F28C53200 for ; Sat, 25 Jul 2026 05:16:36 +0000 (UTC) Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id A69C210F50D; Sat, 25 Jul 2026 05:16:35 +0000 (UTC) Authentication-Results: gabe.freedesktop.org; dkim=pass (2048-bit key; unprotected) header.d=kernel.org header.i=@kernel.org header.b="AizyW1Td"; dkim-atps=neutral Received: from sea.source.kernel.org (sea.source.kernel.org [172.234.252.31]) by gabe.freedesktop.org (Postfix) with ESMTPS id 943D510F50C for ; Sat, 25 Jul 2026 05:16:33 +0000 (UTC) Received: from smtp.kernel.org (quasi.space.kernel.org [100.103.45.18]) by sea.source.kernel.org (Postfix) with ESMTP id 4A2C743B1F; Sat, 25 Jul 2026 05:16:33 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id B26341F000E9; Sat, 25 Jul 2026 05:16:32 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1784956593; bh=XAKNe4Xav4AmQ2UV4OyG/MZDDnkWslDHAQDtv/PFkF4=; h=From:Subject:Reply-To:To:Cc:In-Reply-To:References:Date; b=AizyW1TdCvHMzpFE/YJ3JQvqRsixlMU3M8G6Hp84PzvB+/uwR3lPJTXws93Bcz5Tp uXTWdidghy/+ZsdWLcxSfl8ZprTW25vAhrtrOTMXDymYWTJegD5F4BoaJeHpM1NiFm IemDLqDkNaIwWQVGNaIaMYzMxX7dK29tJdmZ528VRZ9bpXtQ7+DBvgg27mueTXxqEM aS7egEIGtoO1cJM/Kid+NX/PHutMduPNLcmQRlC7t41PniosLilfNh5sx3AP3lhiTj hjx1eRXM9wLPgsFYz+zoRV9Sy4t958KXAub+MoJSkQKRg7AADke2SSX3IIsCmSgRT3 s9rYYB++/0jdQ== From: sashiko-bot@kernel.org Subject: Re: [PATCH 05/17] phy: spacemit: add Innosilicon DP TX PHY driver To: "Cody Kang" Cc: devicetree@vger.kernel.org, conor+dt@kernel.org, olteanv@gmail.com, linux-phy@lists.infradead.org, vkoul@kernel.org, neil.armstrong@linaro.org, dri-devel@lists.freedesktop.org, robh@kernel.org In-Reply-To: <20260724-k3-display-v1-5-f22a10a52867@gmail.com> References: <20260724-k3-display-v1-0-f22a10a52867@gmail.com> <20260724-k3-display-v1-5-f22a10a52867@gmail.com> Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: quoted-printable Date: Sat, 25 Jul 2026 05:16:32 +0000 Message-Id: <20260725051632.B26341F000E9@smtp.kernel.org> X-BeenThere: dri-devel@lists.freedesktop.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Direct Rendering Infrastructure - Development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Reply-To: sashiko-reviews@lists.linux.dev Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" Thank you for your contribution! Sashiko AI review found 7 potential issue(= s) to consider: - [High] Hardware state (PREPLL) is accessed concurrently without protectio= n across PHY and CCF frameworks. - [Medium] The driver fails to power off the core DP link PLL (MPLL) when t= he PHY is disabled, causing a power leak. - [Medium] Missing cleanup in the `k3_inno_dp_phy_power_on` error paths lea= ves PHY components actively consuming power. - [Medium] Dynamically reducing the lane count via `phy_configure()` does n= ot disable the unused transmit lane drivers. - [Medium] Unconditional PLL power-up during rate configuration overrides t= he PHY power state. - [Medium] Missing bounds check on `opts->lanes` causes out-of-bounds array= reads and undefined shift behavior in `k3_inno_dp_phy_set_voltages`. - [Medium] The pixel clock (`pxclk`) is registered with the CCF without `.p= repare`/`.unprepare` or `.enable`/`.disable` hooks, yet its power state is = manipulated implicitly. -- --- Patch [5]: [PATCH 05/17] phy: spacemit: add Innosilicon DP TX PHY drive= r --- commit 46b764d91a977bdc796e404d7eaabb0362e753b0 Author: Cody Kang Subject: phy: spacemit: add Innosilicon DP TX PHY driver This commit adds support for the Innosilicon DisplayPort transmit PHY integrated in the SpacemiT K3 SoC. The PHY shares its MMIO window with its parent DP/eDP controller and exposes lane, rate, and voltage control. It also registers its pixel PLL as a clock provider. > diff --git a/drivers/phy/spacemit/phy-k3-inno-dp.c b/drivers/phy/spacemit= /phy-k3-inno-dp.c > new file mode 100644 > index 0000000000000..9dd62edb7a5af > --- /dev/null > +++ b/drivers/phy/spacemit/phy-k3-inno-dp.c [ ... ] > @@ -103,45 +103,45 @@ static int k3_inno_dp_phy_power_on(struct phy *phy) > + struct k3_inno_dp_phy *p =3D phy_get_drvdata(phy); > + u32 lane_en; > + u32 val; > + int ret; > + > + switch (p->lanes) { > + case 1: > + lane_en =3D 0x1; > + break; > + case 2: > + lane_en =3D 0x3; > + break; > + case 4: > + default: > + lane_en =3D 0xf; > + break; > + } > + > + ret =3D regmap_write_bits(p->regmap, DPTX_ANA_MPLL, DPTX_ANA_MPLL_PD, 0= ); > + if (ret) > + return ret; > + ret =3D regmap_write_bits(p->regmap, DPTX_ANA_PREPLL, > + DPTX_ANA_PREPLL_PD, 0); > + if (ret) > + return ret; [Severity: High] Are there potential concurrency issues between the CCF and PHY frameworks w= hen=20 accessing the PREPLL? The CCF calls k3_inno_dp_pxclk_set_rate() holding the prepare_lock, which=20 powers down the PREPLL, sleeps, and programs registers. Meanwhile, the PHY= =20 framework calls k3_inno_dp_phy_power_on() holding phy->mutex.=20 Could a concurrent phy_power_on() clear the PREPLL_PD bit during the sleep= =20 window, causing the clock framework to write configuration values to a=20 running PLL? > + usleep_range(2000, 4000); > + > + ret =3D regmap_write_bits(p->regmap, DPTX_PHY_CTRL, > + DPTX_PHY_CTRL_XMIT_EN, > + FIELD_PREP(DPTX_PHY_CTRL_XMIT_EN, lane_en)); > + if (ret) > + return ret; > + usleep_range(2000, 4000); > + > + ret =3D regmap_read_poll_timeout(p->regmap, DPTX_ANA_MPLL, val, > + val & DPTX_ANA_MPLL_LOCKED, > + 2000, 10 * 1000); > + if (ret) { > + dev_err(p->dev, "DP PHY core PLL lock timed out\n"); > + return ret; > + } [Severity: Medium] If regmap_read_poll_timeout() times out here or on the PREPLL lock, we retu= rn=20 an error without reverting the powered-up hardware state. Since the PHY core framework doesn't invoke phy_power_off() if phy_power_on= ()=20 fails, does this leave the MPLL, PREPLL, and transmit lanes indefinitely=20 powered on in an error state? > + > + ret =3D regmap_read_poll_timeout(p->regmap, DPTX_ANA_PREPLL, val, > + val & DPTX_ANA_PREPLL_LOCKED, > + 2000, 10 * 1000); > + if (ret) > + dev_err(p->dev, "DP PHY pixel PLL lock timed out\n"); > + > + return ret; > +} > + > +static int k3_inno_dp_phy_power_off(struct phy *phy) > +{ > + struct k3_inno_dp_phy *p =3D phy_get_drvdata(phy); > + > + regmap_write_bits(p->regmap, DPTX_PHY_CTRL, DPTX_PHY_CTRL_XMIT_EN, 0); > + usleep_range(2000, 4000); > + > + regmap_write_bits(p->regmap, DPTX_ANA_PREPLL, DPTX_ANA_PREPLL_PD, > + DPTX_ANA_PREPLL_PD); > + usleep_range(2000, 4000); > + > + return 0; > +} [Severity: Medium] This powers down the pixel PLL and disables the transmit lanes, but it appears to skip powering down the core DP link PLL. Does this leave the MPLL running indefinitely and leaking power when the PH= Y=20 is meant to be disabled? Should we also be setting DPTX_ANA_MPLL_PD here? [ ... ] > +static int k3_inno_dp_phy_set_lanes(struct k3_inno_dp_phy *p, u8 lanes) > +{ > + u32 val; > + int ret; [ ... ] > + ret =3D regmap_write_bits(p->regmap, DPTX_PHY_CTRL, > + DPTX_PHY_CTRL_NUM_LANES, > + FIELD_PREP(DPTX_PHY_CTRL_NUM_LANES, val)); > + if (ret) > + return ret; > + > + p->lanes =3D lanes; > + return 0; > +} [Severity: Medium] If a caller dynamically reduces the lane count via phy_configure() (for=20 instance, falling back from 4 lanes to 2 during DP link training), this=20 updates the logical lane count but doesn't synchronize the=20 DPTX_PHY_CTRL_XMIT_EN register bits. Will this leave the unused physical transmit lane drivers actively driven? [ ... ] > +static void k3_inno_dp_phy_program_mpll(struct k3_inno_dp_phy *p, > + const struct k3_inno_dp_mpll_cfg *cfg) > +{ > + struct regmap *rm =3D p->regmap; [ ... ] > + regmap_write_bits(rm, DPTX_ANA_PREPLL_CTRL, DPTX_ANA_PREPLL_LOCK_BYPEN, > + FIELD_PREP(DPTX_ANA_PREPLL_LOCK_BYPEN, 1)); > + > + regmap_write_bits(rm, DPTX_ANA_MPLL, DPTX_ANA_MPLL_PD, > + FIELD_PREP(DPTX_ANA_MPLL_PD, 0)); > + usleep_range(2000, 4000); > +} [Severity: Medium] When configuring the PLL rate, this clears the power down bit=20 (DPTX_ANA_MPLL_PD) at the end of the programming sequence. If a rate configuration occurs while the PHY is intentionally suspended, wi= ll=20 this force the PLLs on and override the PHY's intended power state? [ ... ] > +static int k3_inno_dp_phy_set_voltages(struct k3_inno_dp_phy *p, > + struct phy_configure_opts_dp *opts) > +{ > + u8 lane; > + int ret; > + > + for (lane =3D 0; lane < opts->lanes; lane++) { > + unsigned int shift =3D lane * DPTX_PHY_LANE_BITS_PER; > + u32 mask =3D DPTX_PHY_LANE_FIELD_MASK << shift; > + u32 val =3D (((opts->voltage[lane] & 0x3) << DPTX_PHY_LANE_VSWING_SHI= FT) | > + (opts->pre[lane] & 0x3)) << shift; [Severity: Medium] Could an unvalidated or uninitialized opts->lanes cause an out-of-bounds array read on opts->voltage and opts->pre, as well as undefined bit shifts here? In k3_inno_dp_phy_configure(), k3_inno_dp_phy_set_lanes() is only called if= =20 opts->dp.set_lanes is true. If a caller passes opts->dp.set_lanes =3D 0 but= =20 opts->dp.set_voltages =3D 1, opts->dp.lanes skips validation. [ ... ] > +static void k3_inno_dp_program_prepll(struct k3_inno_dp_phy *p, > + const struct k3_inno_dp_prepll_cfg *cfg) > +{ > + regmap_write_bits(p->regmap, DPTX_ANA_PREPLL, DPTX_ANA_PREPLL_PD, > + FIELD_PREP(DPTX_ANA_PREPLL_PD, 1)); > + usleep_range(2000, 4000); > + [ ... ] > + regmap_write_bits(p->regmap, DPTX_ANA_PREPLL, DPTX_ANA_PREPLL_PD, > + FIELD_PREP(DPTX_ANA_PREPLL_PD, 0)); > + usleep_range(2000, 4000); > +} [Severity: Medium] Similar to the MPLL configuration, this unconditionally clears the PREPLL=20 power down bit at the end of programming, potentially overriding the intend= ed=20 power state of the PHY. [ ... ] > +static const struct clk_ops k3_inno_dp_pxclk_ops =3D { > + .recalc_rate =3D k3_inno_dp_pxclk_recalc_rate, > + .determine_rate =3D k3_inno_dp_pxclk_determine_rate, > + .set_rate =3D k3_inno_dp_pxclk_set_rate, > +}; [Severity: Medium] The pixel clock is registered with the Common Clock Framework without=20 .prepare/.unprepare or .enable/.disable hooks. Since the CCF tracks the clock state purely in software while phy_power_off= ()=20 physically powers down the PREPLL, can this cause a mismatch where downstre= am=20 consumers lose their clock unexpectedly while the CCF thinks it is still=20 running? --=20 Sashiko AI review =C2=B7 https://sashiko.dev/#/patchset/20260724-k3-display= -v1-0-f22a10a52867@gmail.com?part=3D5