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 BD88BCD98F1 for ; Wed, 17 Jun 2026 11:18:49 +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=Bfeh4kHKjev6+rta7QoPsKtNugoSrQjaUKXMQ1I93AM=; b=v78A3HOTZg/8+L YBSGxFGucM6IMtoeYi6YBh6wvqZ5DMtU3IVSEcAoaZxUOu60twNCFCeOFlq78QKL2jX0FKva9tjD/ wv6MY5dPdTlnGkL+J9DYbx2lHed6cMfiL9+bmqFztL43z16og744yw4yL3QPPTMQTaHwK1V2eyx0i LkffdjDGhg3qIWQ9hCd5Vmx6Ziyxvu7CNvmb7bRfuNVpJe5ElQxnW+m3/YWsYNPw/e4WsK8alhZ4f 8M5Rkmi4Ui3WN4dRS9LAD0H9slkhAwIn9x0wPBrSiNpi0cHsp5lNLRNrSMaJ9bVonRqkjn4Rh1/2m 4bUyHBHaIeoPhDvESCDg==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.99.1 #2 (Red Hat Linux)) id 1wZoID-0000000HDbi-2DMQ; Wed, 17 Jun 2026 11:18:49 +0000 Received: from tor.source.kernel.org ([172.105.4.254]) by bombadil.infradead.org with esmtps (Exim 4.99.1 #2 (Red Hat Linux)) id 1wZoIC-0000000HDbO-2yZv for linux-i3c@lists.infradead.org; Wed, 17 Jun 2026 11:18:48 +0000 Received: from smtp.kernel.org (quasi.space.kernel.org [100.103.45.18]) by tor.source.kernel.org (Postfix) with ESMTP id 7947160103; Wed, 17 Jun 2026 11:18:47 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id EAB851F000E9; Wed, 17 Jun 2026 11:18:46 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1781695127; bh=/ggDIh5HpxDzxQfMuZNmvcq2gxXxOJ5/RLT0nk2nkQg=; h=From:Subject:Reply-To:To:Cc:In-Reply-To:References:Date; b=MPPwPF6yLJmh/XY5aat+IIx5qolx1yD7eTJNTT7TnH8lM8QWlm+9OF2Fw+szGcQ7J 5DbI9aYMKyo6JD8J73Y5pT+177qY3YTkI3coPGjO1V+IGC1ktbJwyAYg002OQ69LRV /FdKROH/Gr4hwTs4TMAT5fCt/iSyAm0dA0RjMwyvBqAGsOYO+FCoM9ag3LKbnlUrlK bY46EGlQr+uEkARa1Ufue8fVrPAX4kL4ZxAmjPuI1hWo8LX/X1Cyd7Kk21ij7Q6xLE sjwPs/jbduOliV6ul7MovE8QlULr4yV3E+VpgRdJwZqD1DvfaLpwpxYhF46ZpruDE3 ahnHmsgOwnXUw== From: sashiko-bot@kernel.org Subject: Re: [PATCH v12 6/7] i3c: hub: p3h2x4x: Add support for NXP P3H2x4x I3C hub functionality To: "Lakshay Piplani" Cc: devicetree@vger.kernel.org, robh@kernel.org, linux-i3c@lists.infradead.org, Frank.Li@kernel.org, conor+dt@kernel.org In-Reply-To: <20260617110355.1591844-7-lakshay.piplani@nxp.com> References: <20260617110355.1591844-1-lakshay.piplani@nxp.com> <20260617110355.1591844-7-lakshay.piplani@nxp.com> Date: Wed, 17 Jun 2026 11:18:46 +0000 Message-Id: <20260617111846.EAB851F000E9@smtp.kernel.org> X-BeenThere: linux-i3c@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: 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-i3c" Errors-To: linux-i3c-bounces+linux-i3c=archiver.kernel.org@lists.infradead.org VGhhbmsgeW91IGZvciB5b3VyIGNvbnRyaWJ1dGlvbiEgU2FzaGlrbyBBSSByZXZpZXcgZm91bmQg NSBwb3RlbnRpYWwgaXNzdWUocykgdG8gY29uc2lkZXI6Ci0gW0hpZ2hdIFRoZSBTTUJ1cyB0cmFu c2FjdGlvbiB3YWl0IGxvZ2ljIHVzZXMgYSBmaXhlZCBzbGVlcCBpbnN0ZWFkIG9mIHBvbGxpbmcg dGhlIGhhcmR3YXJlIGNvbXBsZXRpb24gZmxhZywgbGVhZGluZyB0byBwcmVtYXR1cmUgcmVhZHMg b2YgaW5jb21wbGV0ZSB0cmFuc2FjdGlvbnMgYW5kIGRhdGEgY29ycnVwdGlvbi4KLSBbSGlnaF0g T3ZlcndyaXRpbmcgdGhlIHBhcmVudCBkZXZpY2UncyBgb2Zfbm9kZWAgcG9pbnRlciBpdGVyYXRp dmVseSBjYXVzZXMgYSBtZW1vcnkgbGVhayBvZiB0aGUgb3JpZ2luYWwgcGFyZW50IG5vZGUsIGEg ZG91YmxlLWZyZWUgb2YgdGhlIHRhcmdldCBwb3J0IG5vZGVzLCBhbmQgc3RhdGUgY29ycnVwdGlv bi4KLSBbTWVkaXVtXSBQb3RlbnRpYWwgYG9mX25vZGVgIHJlZmVyZW5jZSBsZWFrIGluIGBwM2gy eDR4X2dldF90YXJnZXRfcG9ydF9kdF9jb25mKClgIGlmIG11bHRpcGxlIGNoaWxkIG5vZGVzIHNw ZWNpZnkgdGhlIHNhbWUgdGFyZ2V0IHBvcnQgaW5kZXguCi0gW01lZGl1bV0gVGhlIGh1YidzIHBy b3RlY3RlZCByZWdpc3RlcnMgcmVtYWluIHBlcm1hbmVudGx5IHVubG9ja2VkIGlmIHRoZSBoYXJk d2FyZSBjb25maWd1cmF0aW9uIG9yIGJ1cyByZWdpc3RyYXRpb24gZmFpbHMgZHVyaW5nIHByb2Jl LgotIFtMb3ddIENvbW1lbnQgZGVzY3JpYmVzIGEgcmVhZCBmb2xsb3dlZCBieSBhIHdyaXRlLCBi dXQgdGhlIGNvZGUgaW1wbGVtZW50cyBhIHdyaXRlIGZvbGxvd2VkIGJ5IGEgcmVhZC4KLS0KCmNv bW1pdCAxYzk4MmVjZjcxYzZmYjNiNzY1Y2FmMjU1MTkxYTgyMWE1ZTM3Y2I1CkF1dGhvcjogQW1h biBLdW1hciBQYW5kZXkgPGFtYW4ua3VtYXJwYW5kZXlAbnhwLmNvbT4KCmkzYzogaHViOiBwM2gy eDR4OiBBZGQgc3VwcG9ydCBmb3IgTlhQIFAzSDJ4NHggSTNDIGh1YiBmdW5jdGlvbmFsaXR5CgpB ZGQgSTNDIGh1YiBmdW5jdGlvbmFsaXR5IGZvciB0aGUgTlhQIFAzSDJ4NHggZmFtaWx5IG9mIG11 bHRpcG9ydCBodWJzLgpUaGVzZSBkZXZpY2VzIHN1cHBvcnQgZG93bnN0cmVhbSB0YXJnZXQgcG9y dHMgdGhhdCBjYW4gYmUgY29uZmlndXJlZAphcyBJM0MsIEkyQywgb3IgU01CdXMuCgo+IGRpZmYg LS1naXQgYS9kcml2ZXJzL2kzYy9odWIvcDNoMjg0MF9pM2NfaHViX2NvbW1vbi5jIGIvZHJpdmVy cy9pM2MvaHViL3AzaDI4NDBfaTNjX2h1Yl9jb21tb24uYwo+IG5ldyBmaWxlIG1vZGUgMTAwNjQ0 Cj4gaW5kZXggMDAwMDAwMDAwMDAwMC4uMDVlMTliZmYyMGQ1Ywo+IC0tLSAvZGV2L251bGwKPiAr KysgYi9kcml2ZXJzL2kzYy9odWIvcDNoMjg0MF9pM2NfaHViX2NvbW1vbi5jClsgLi4uIF0KPiAr c3RhdGljIHZvaWQgcDNoMng0eF9nZXRfdGFyZ2V0X3BvcnRfZHRfY29uZihzdHJ1Y3QgZGV2aWNl ICpkZXYsCj4gKwkJCQkJICAgIGNvbnN0IHN0cnVjdCBkZXZpY2Vfbm9kZSAqbm9kZSkKPiArewo+ ICsJc3RydWN0IHAzaDJ4NHhfaTNjX2h1Yl9kZXYgKnAzaDJ4NHhfaTNjX2h1YiA9IGRldl9nZXRf ZHJ2ZGF0YShkZXYpOwo+ICsJdTY0IHRwX3BvcnQ7Cj4gKwo+ICsJZm9yX2VhY2hfYXZhaWxhYmxl X2NoaWxkX29mX25vZGVfc2NvcGVkKG5vZGUsIGRldl9ub2RlKSB7Cj4gKwkJaWYgKG9mX3Byb3Bl cnR5X3JlYWRfcmVnKGRldl9ub2RlLCAwLCAmdHBfcG9ydCwgTlVMTCkpCj4gKwkJCWNvbnRpbnVl Owo+ICsKPiArCQlpZiAodHBfcG9ydCA8IFAzSDJYNFhfVFBfTUFYX0NPVU5UKSB7Cj4gKwkJCXAz aDJ4NHhfaTNjX2h1Yi0+dHBfYnVzW3RwX3BvcnRdLm9mX25vZGUgPSBvZl9ub2RlX2dldChkZXZf bm9kZSk7CgpbU2V2ZXJpdHk6IE1lZGl1bV0KQ291bGQgdGhpcyBsZWFrIHRoZSBvZl9ub2RlIHJl ZmVyZW5jZSBpZiBhIG1hbGZvcm1lZCBkZXZpY2UgdHJlZSBzcGVjaWZpZXMKbXVsdGlwbGUgY2hp bGQgbm9kZXMgd2l0aCB0aGUgc2FtZSB0YXJnZXQgcG9ydCBpbmRleD8KCklmIG11bHRpcGxlIGNo aWxkIG5vZGVzIHNwZWNpZnkgdGhlIHNhbWUgcmVnIHZhbHVlLCB0aGUgcG9pbnRlciBpcwpvdmVy d3JpdHRlbiB3aXRoIGEgbmV3IG9mX25vZGVfZ2V0KCkgcmVzdWx0LCB3aGljaCBhYmFuZG9ucyB0 aGUgcHJldmlvdXMKcmVmZXJlbmNlLgoKPiArCQkJcDNoMng0eF9pM2NfaHViLT50cF9idXNbdHBf cG9ydF0udHBfbWFzayA9IFAzSDJYNFhfU0VUX0JJVCh0cF9wb3J0KTsKPiArCQkJcDNoMng0eF9p M2NfaHViLT50cF9idXNbdHBfcG9ydF0ucDNoMng0eF9pM2NfaHViID0gcDNoMng0eF9pM2NfaHVi Owo+ICsJCQlwM2gyeDR4X2kzY19odWItPnRwX2J1c1t0cF9wb3J0XS50cF9wb3J0ID0gdHBfcG9y dDsKPiArCQl9Cj4gKwl9Cj4gK30KWyAuLi4gXQo+ICtzdGF0aWMgaW50IHAzaDJ4NHhfaTNjX2h1 Yl9wcm9iZShzdHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQo+ICt7ClsgLi4uIF0KPiArCS8q IFVubG9jayBhY2Nlc3MgdG8gcHJvdGVjdGVkIHJlZ2lzdGVycyAqLwo+ICsJcmV0ID0gcmVnbWFw X3dyaXRlKHAzaDJ4NHhfaTNjX2h1Yi0+cmVnbWFwLCBQM0gyWDRYX0RFVl9SRUdfUFJPVEVDVElP Tl9DT0RFLAo+ICsJCQkgICBQM0gyWDRYX1JFR0lTVEVSU19VTkxPQ0tfQ09ERSk7Cj4gKwlpZiAo cmV0KQo+ICsJCXJldHVybiBkZXZfZXJyX3Byb2JlKGRldiwgcmV0LCAiRmFpbGVkIHRvIHVubG9j ayBIVUIncyBwcm90ZWN0ZWQgcmVnaXN0ZXJzXG4iKTsKPiArCj4gKwlyZXQgPSBwM2gyeDR4X2Nv bmZpZ3VyZV9odyhkZXYpOwo+ICsJaWYgKHJldCkKPiArCQlyZXR1cm4gZGV2X2Vycl9wcm9iZShk ZXYsIHJldCwgIkZhaWxlZCB0byBjb25maWd1cmUgdGhlIEhVQlxuIik7CgpbU2V2ZXJpdHk6IE1l ZGl1bV0KQXJlIHRoZSBodWIncyBwcm90ZWN0ZWQgcmVnaXN0ZXJzIGxlZnQgcGVybWFuZW50bHkg dW5sb2NrZWQgaWYgcHJvYmUgZmFpbHMKZHVyaW5nIHAzaDJ4NHhfY29uZmlndXJlX2h3KCkgb3Ig YnVzIHJlZ2lzdHJhdGlvbj8KClRoZSBkcml2ZXIgdW5sb2NrcyB0aGUgaGFyZHdhcmUgcmVnaXN0 ZXJzIGF0IHRoZSBzdGFydCBvZiBwcm9iZSBhbmQgbG9ja3MKdGhlbSBhdCB0aGUgdmVyeSBlbmQu IEhvd2V2ZXIsIGlmIGFueSBpbml0aWFsaXphdGlvbiBzdGVwIGZhaWxzIGFuZCByZXR1cm5zCmFu IGVycm9yLCB0aGUgZnVuY3Rpb24gZXhpdHMgaW1tZWRpYXRlbHkgd2l0aG91dCBsb2NraW5nIHRo ZSByZWdpc3RlcnMgYWdhaW4uCgpDb3VsZCB0aGlzIGJlIG1pdGlnYXRlZCBieSB1c2luZyBhIGRl dm1fYWRkX2FjdGlvbl9vcl9yZXNldCgpIGNhbGxiYWNrIG9yCmV4cGxpY2l0IGVycm9yIGhhbmRs aW5nIGxhYmVscyB0byBlbnN1cmUgdGhlIHJlZ2lzdGVycyBhcmUgc2FmZWx5IHJlbG9ja2VkPwoK PiArCj4gKwkvKiBSZWdpc3RlciB2aXJ0dWFsIEkzQyBtYXN0ZXIgY29udHJvbGxlcnMgZm9yIEkz QyB0YXJnZXQgcG9ydHMgKi8KPiArCWlmIChwM2gyeDR4LT5pM2NkZXYpIHsKWyAuLi4gXQo+IGRp ZmYgLS1naXQgYS9kcml2ZXJzL2kzYy9odWIvcDNoMjg0MF9pM2NfaHViX2kzYy5jIGIvZHJpdmVy cy9pM2MvaHViL3AzaDI4NDBfaTNjX2h1Yl9pM2MuYwo+IG5ldyBmaWxlIG1vZGUgMTAwNjQ0Cj4g aW5kZXggMDAwMDAwMDAwMDAwMC4uOGFkYjIzNWI5OTJjMAo+IC0tLSAvZGV2L251bGwKPiArKysg Yi9kcml2ZXJzL2kzYy9odWIvcDNoMjg0MF9pM2NfaHViX2kzYy5jClsgLi4uIF0KPiAraW50IHAz aDJ4NHhfdHBfaTNjX2FsZ28oc3RydWN0IHAzaDJ4NHhfaTNjX2h1Yl9kZXYgKnAzaDJ4NHhfaHVi KQo+ICt7ClsgLi4uIF0KPiArCWZvciAodHAgPSAwOyB0cCA8IFAzSDJYNFhfVFBfTUFYX0NPVU5U OyB0cCsrKSB7Cj4gKwkJaWYgKCFwM2gyeDR4X2h1Yi0+dHBfYnVzW3RwXS5vZl9ub2RlIHx8Cj4g KwkJICAgIHAzaDJ4NHhfaHViLT5odWJfY29uZmlnLnRwX2NvbmZpZ1t0cF0ubW9kZSAhPSBQM0gy WDRYX1RQX01PREVfSTNDKQo+ICsJCQljb250aW51ZTsKPiArCj4gKwkJLyogQXNzaWduIERUIG5v ZGUgZm9yIHRoaXMgVFAgKi8KPiArCQlwM2gyeDR4X2h1Yi0+ZGV2LT5vZl9ub2RlID0gcDNoMng0 eF9odWItPnRwX2J1c1t0cF0ub2Zfbm9kZTsKCltTZXZlcml0eTogSGlnaF0KRG9lcyBvdmVyd3Jp dGluZyB0aGUgcGFyZW50IGRldmljZSdzIG9mX25vZGUgcG9pbnRlciBpdGVyYXRpdmVseSBjYXVz ZSBhCm1lbW9yeSBsZWFrIG9mIHRoZSBvcmlnaW5hbCBwYXJlbnQgbm9kZSBhbmQgYSBkb3VibGUt ZnJlZSBvZiB0aGUgdGFyZ2V0IHBvcnQKbm9kZXM/CgpUaGUgbG9vcCBvdmVyIHRhcmdldCBwb3J0 cyBkaXJlY3RseSBtdXRhdGVzIHRoZSBzaGFyZWQgcGRldi0+ZGV2Lm9mX25vZGUKcG9pbnRlciB3 aGljaCB3YXMgcG9wdWxhdGVkIGluIHByb2JlIHVzaW5nIGRldmljZV9zZXRfb2Zfbm9kZV9mcm9t X2RldigpLgpUaGlzIGxlYWtzIHRoZSByZWZlcmVuY2UgdG8gdGhlIG9yaWdpbmFsIHBhcmVudCBu b2RlLCBhbmQgbGVhdmVzCmRldi0+b2Zfbm9kZSBwb2ludGluZyB0byB0aGUgbGFzdCB0YXJnZXQg cG9ydCBub2RlLgoKV2hlbiB0aGUgZHJpdmVyIGlzIHVuYm91bmQsIHRoZSBkcml2ZXIgY29yZSB3 aWxsIGRyb3AgYSByZWZlcmVuY2Ugb24KZGV2LT5vZl9ub2RlLCBidXQgcDNoMng0eF9wdXRfdGFy Z2V0X3BvcnRfb2Zfbm9kZXMoKSBhbHNvIGRyb3BzIGEgcmVmZXJlbmNlCm9uIHRoZSBzYW1lIG5v ZGUsIHdoaWNoIGNhbiBjYXVzZSBhIHVzZS1hZnRlci1mcmVlIG9yIGRvdWJsZS1mcmVlIHJlZmNv dW50CnVuZGVyZmxvdy4gTXV0YXRpbmcgZGV2LT5vZl9ub2RlIGFsc28gY3JlYXRlcyBhIHJhY2Ug d2l0aCBzeXNmcy91ZXZlbnQuCgpTaG91bGQgdGhlIGRyaXZlciBhc3NpZ24gdGhlIG5vZGUgdG8g Y29udHJvbGxlci0+ZGV2Lm9mX25vZGUgZGlyZWN0bHkKaW5zdGVhZCBvZiBtdXRhdGluZyB0aGUg cGFyZW50J3MgcG9pbnRlcj8KCj4gKwo+ICsJCXN0cnVjdCBpM2NfaHViX2NvbnRyb2xsZXIgKmh1 Yl9jb250cm9sbGVyID0KPiArCQkJCSZwM2gyeDR4X2h1Yi0+dHBfYnVzW3RwXS5odWJfY29udHJv bGxlcjsKWyAuLi4gXQo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL2kzYy9odWIvcDNoMjg0MF9pM2Nf aHViX3NtYnVzLmMgYi9kcml2ZXJzL2kzYy9odWIvcDNoMjg0MF9pM2NfaHViX3NtYnVzLmMKPiBu ZXcgZmlsZSBtb2RlIDEwMDY0NAo+IGluZGV4IDAwMDAwMDAwMDAwMDAuLmNmNjY0NDI1YWYwNzEK PiAtLS0gL2Rldi9udWxsCj4gKysrIGIvZHJpdmVycy9pM2MvaHViL3AzaDI4NDBfaTNjX2h1Yl9z bWJ1cy5jClsgLi4uIF0KPiArc3RhdGljIGludCBwM2gyeDR4X3JlYWRfc21idXNfdHJhbnNhY3Rp b25fc3RhdHVzKHN0cnVjdCBwM2gyeDR4X2kzY19odWJfZGV2ICpodWIsCj4gKwkJCQkJCSB1OCB0 YXJnZXRfcG9ydF9zdGF0dXMsCj4gKwkJCQkJCSB1OCBkYXRhX2xlbmd0aCkKPiArewo+ICsJdTMy IHN0YXR1c19yZWFkOwo+ICsJdTggc3RhdHVzOwo+ICsJaW50IHJldDsKPiArCj4gKwlmc2xlZXAo UDNIMlg0WF9TTUJVU180MDBrSHpfVFJBTlNGRVJfVElNRU9VVChkYXRhX2xlbmd0aCkpOwo+ICsK PiArCXJldCA9IHJlZ21hcF9yZWFkKGh1Yi0+cmVnbWFwLCB0YXJnZXRfcG9ydF9zdGF0dXMsICZz dGF0dXNfcmVhZCk7CgpbU2V2ZXJpdHk6IEhpZ2hdCkRvZXMgdXNpbmcgYSBoYXJkY29kZWQgc2xl ZXAgYmFzZWQgb24gYnl0ZXMgdHJhbnNmZXJyZWQgaW5zdGVhZCBvZiBwb2xsaW5nIGEKaGFyZHdh cmUgY29tcGxldGlvbiBzdGF0dXMgYml0IGxlYWQgdG8gcHJlbWF0dXJlIHJlYWRzIG9mIGluY29t cGxldGUKdHJhbnNhY3Rpb25zPwoKSWYgdGhlIGRvd25zdHJlYW0gZGV2aWNlIHBlcmZvcm1zIGNs b2NrIHN0cmV0Y2hpbmcgb3IgaXMgc2xvdyB0byByZXNwb25kLAp0aGUgdHJhbnNmZXIgd2lsbCB0 YWtlIGxvbmdlciB0aGFuIHRoZSBoYXJkY29kZWQgdGltZW91dC4gVGhlIGRyaXZlciB0aGVuCnJl YWRzIHRhcmdldF9wb3J0X3N0YXR1cyBhbmQgc2hpZnRzIHRvIGNoZWNrIHRoZSBzdGF0dXMgYml0 cy4KClNpbmNlIGFuIG9uZ29pbmcgdHJhbnNhY3Rpb24gbGVhdmVzIHRoZSBzdGF0dXMgYml0cyBh dCAwCihQM0gyWDRYX1NNQlVTX0NOVFJMX1NUQVRVU19UWE5fT0spLCB0aGUgZHJpdmVyIHdpbGwg aW5jb3JyZWN0bHkgYXNzdW1lIHRoZQp0cmFuc2FjdGlvbiBoYXMgZmluaXNoZWQgc3VjY2Vzc2Z1 bGx5LiBJdCB3aWxsIHRoZW4gcHJvY2VlZCB0byByZWFkIHN0YWxlIG9yCnVuaW5pdGlhbGl6ZWQg bWVtb3J5IGJ1ZmZlcnMgYW5kIHJldHVybiBnYXJiYWdlIGRhdGEuCgpDb3VsZCB0aGlzIGJlIHVw ZGF0ZWQgdG8gdXNlIGEgcG9sbGluZyBsb29wIGNoZWNraW5nIHRoZSBmaW5pc2ggZmxhZz8KCj4g KwlpZiAocmV0KQo+ICsJCXJldHVybiByZXQ7Cj4gKwo+ICsJc3RhdHVzID0gKHU4KXN0YXR1c19y ZWFkOwpbIC4uLiBdCj4gK3N0YXRpYyBzMzIgcDNoMng0eF90cF9pMmNfeGZlcihzdHJ1Y3QgaTJj X2FkYXB0ZXIgKmFkYXAsIHN0cnVjdCBpMmNfbXNnICptc2dzLCBpbnQgbnVtKQo+ICt7ClsgLi4u IF0KPiArCQlydyA9IChtc2dzW21zZ19jb3VudF0uZmxhZ3MgJiBJMkNfTV9SRCkgPyAxIDogMDsK PiArCQlpZiAoIXJ3KSB7Cj4gKwkJCS8qIElmIGEgcmVhZCBtZXNzYWdlIGlzIGltbWVkaWF0ZWx5 IGZvbGxvd2VkIGJ5IGEgd3JpdGUgbWVzc2FnZSB0bwo+ICsJCQkgKiB0aGUgc2FtZSBhZGRyZXNz LCAgY29uc2lkZXIgY29tYmluaW5nIHRoZW0gaW50byBhIHNpbmdsZSB0cmFuc2FjdGlvbi4KPiAr CQkJICovCgpbU2V2ZXJpdHk6IExvd10KVGhpcyBpc24ndCBhIGJ1ZywgYnV0IHRoZSBjb21tZW50 IGRlc2NyaWJlcyBhIHJlYWQgZm9sbG93ZWQgYnkgYSB3cml0ZSB3aGlsZQp0aGUgY29kZSBpbXBs ZW1lbnRzIGEgd3JpdGUgZm9sbG93ZWQgYnkgYSByZWFkLgoKVGhlIGFjdHVhbCBjb2RlIGJsb2Nr IGNoZWNrcyAhcncgZm9yIHRoZSBmaXJzdCBtZXNzYWdlIGFuZCBmbGFncyAmIEkyQ19NX1JECmZv ciB0aGUgc2Vjb25kIG1lc3NhZ2UsIHdoaWNoIGFjY3VyYXRlbHkgaGFuZGxlcyBhIHdyaXRlIG1l c3NhZ2UgaW1tZWRpYXRlbHkKZm9sbG93ZWQgYnkgYSByZWFkIG1lc3NhZ2UuCgo+ICsJCQlpZiAo bXNnX2NvdW50ICsgMSA8IG51bSAmJgo+ICsJCQkgICAgbXNnc1ttc2dfY291bnRdLmFkZHIgPT0g bXNnc1ttc2dfY291bnQgKyAxXS5hZGRyICYmCj4gKwkJCSAgICAobXNnc1ttc2dfY291bnQgKyAx XS5mbGFncyAmIEkyQ19NX1JEKSkgewo+ICsJCQkJaWYgKG1zZ3NbbXNnX2NvdW50XS5sZW4gKyBt c2dzW21zZ19jb3VudCArIDFdLmxlbiA+Cj4gKwkJCQkgICAgUDNIMlg0WF9TTUJVU19QQVlMT0FE X1NJWkUpCj4gKwkJCQkJcmV0dXJuIC1FSU5WQUw7CgotLSAKU2FzaGlrbyBBSSByZXZpZXcgwrcg aHR0cHM6Ly9zYXNoaWtvLmRldi8jL3BhdGNoc2V0LzIwMjYwNjE3MTEwMzU1LjE1OTE4NDQtMS1s YWtzaGF5LnBpcGxhbmlAbnhwLmNvbT9wYXJ0PTYKCi0tIApsaW51eC1pM2MgbWFpbGluZyBsaXN0 CmxpbnV4LWkzY0BsaXN0cy5pbmZyYWRlYWQub3JnCmh0dHA6Ly9saXN0cy5pbmZyYWRlYWQub3Jn L21haWxtYW4vbGlzdGluZm8vbGludXgtaTNjCg== 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 C8C76285CAD for ; Wed, 17 Jun 2026 11:18:47 +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=1781695130; cv=none; b=CPs6Rs8Xv4AKvQxmW7a6PD9sJpqwa67yYyBlayjI/qqk1BXNjZLwRBcFjNuPHrf0cGm+MlZFp7HIE0HFF6zmeOWPk5iGfpVgd71Lsr1D9KpCei4PO2it0mnjthjnlxFiQ2kcr2uCD+U1rIhQI4sWIgrlgZhnpJcVJzd0tYhqZpE= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1781695130; c=relaxed/simple; bh=wJWIUNsmyq7Fw5CVCzGiEhWTgjXaeCRkSJ50QQm7u1w=; h=From:Subject:To:Cc:In-Reply-To:References:Content-Type:Date: Message-Id; b=YvN/2Ppx0J2kOujdIkgInjFQbfuxhNHUVxQkbClQAXstOoNb9ywX0I6xgyKrGknxuUdLmauJwbwguuwg9bPjPlarJIdqg2kHSFvMtgsyOwpVr6Qt7IvQ8CJCOLxZqwNvXL6SgkjS6Q34ew4i9+CUNNbBY8C4/6MpPQy/O9YqSvI= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=MPPwPF6y; 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="MPPwPF6y" Received: by smtp.kernel.org (Postfix) with ESMTPSA id EAB851F000E9; Wed, 17 Jun 2026 11:18:46 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1781695127; bh=/ggDIh5HpxDzxQfMuZNmvcq2gxXxOJ5/RLT0nk2nkQg=; h=From:Subject:Reply-To:To:Cc:In-Reply-To:References:Date; b=MPPwPF6yLJmh/XY5aat+IIx5qolx1yD7eTJNTT7TnH8lM8QWlm+9OF2Fw+szGcQ7J 5DbI9aYMKyo6JD8J73Y5pT+177qY3YTkI3coPGjO1V+IGC1ktbJwyAYg002OQ69LRV /FdKROH/Gr4hwTs4TMAT5fCt/iSyAm0dA0RjMwyvBqAGsOYO+FCoM9ag3LKbnlUrlK bY46EGlQr+uEkARa1Ufue8fVrPAX4kL4ZxAmjPuI1hWo8LX/X1Cyd7Kk21ij7Q6xLE sjwPs/jbduOliV6ul7MovE8QlULr4yV3E+VpgRdJwZqD1DvfaLpwpxYhF46ZpruDE3 ahnHmsgOwnXUw== From: sashiko-bot@kernel.org Subject: Re: [PATCH v12 6/7] i3c: hub: p3h2x4x: Add support for NXP P3H2x4x I3C hub functionality Reply-To: sashiko-reviews@lists.linux.dev To: "Lakshay Piplani" Cc: devicetree@vger.kernel.org, robh@kernel.org, linux-i3c@lists.infradead.org, Frank.Li@kernel.org, conor+dt@kernel.org In-Reply-To: <20260617110355.1591844-7-lakshay.piplani@nxp.com> References: <20260617110355.1591844-1-lakshay.piplani@nxp.com> <20260617110355.1591844-7-lakshay.piplani@nxp.com> Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: quoted-printable Date: Wed, 17 Jun 2026 11:18:46 +0000 Message-Id: <20260617111846.EAB851F000E9@smtp.kernel.org> Precedence: bulk X-Mailing-List: devicetree@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: Thank you for your contribution! Sashiko AI review found 5 potential issue(= s) to consider: - [High] The SMBus transaction wait logic uses a fixed sleep instead of pol= ling the hardware completion flag, leading to premature reads of incomplete= transactions and data corruption. - [High] Overwriting the parent device's `of_node` pointer iteratively caus= es a memory leak of the original parent node, a double-free of the target p= ort nodes, and state corruption. - [Medium] Potential `of_node` reference leak in `p3h2x4x_get_target_port_d= t_conf()` if multiple child nodes specify the same target port index. - [Medium] The hub's protected registers remain permanently unlocked if the= hardware configuration or bus registration fails during probe. - [Low] Comment describes a read followed by a write, but the code implemen= ts a write followed by a read. -- commit 1c982ecf71c6fb3b765caf255191a821a5e37cb5 Author: Aman Kumar Pandey i3c: hub: p3h2x4x: Add support for NXP P3H2x4x I3C hub functionality Add I3C hub functionality for the NXP P3H2x4x family of multiport hubs. These devices support downstream target ports that can be configured as I3C, I2C, or SMBus. > diff --git a/drivers/i3c/hub/p3h2840_i3c_hub_common.c b/drivers/i3c/hub/p= 3h2840_i3c_hub_common.c > new file mode 100644 > index 0000000000000..05e19bff20d5c > --- /dev/null > +++ b/drivers/i3c/hub/p3h2840_i3c_hub_common.c [ ... ] > +static void p3h2x4x_get_target_port_dt_conf(struct device *dev, > + const struct device_node *node) > +{ > + struct p3h2x4x_i3c_hub_dev *p3h2x4x_i3c_hub =3D dev_get_drvdata(dev); > + u64 tp_port; > + > + for_each_available_child_of_node_scoped(node, dev_node) { > + if (of_property_read_reg(dev_node, 0, &tp_port, NULL)) > + continue; > + > + if (tp_port < P3H2X4X_TP_MAX_COUNT) { > + p3h2x4x_i3c_hub->tp_bus[tp_port].of_node =3D of_node_get(dev_node); [Severity: Medium] Could this leak the of_node reference if a malformed device tree specifies multiple child nodes with the same target port index? If multiple child nodes specify the same reg value, the pointer is overwritten with a new of_node_get() result, which abandons the previous reference. > + p3h2x4x_i3c_hub->tp_bus[tp_port].tp_mask =3D P3H2X4X_SET_BIT(tp_port); > + p3h2x4x_i3c_hub->tp_bus[tp_port].p3h2x4x_i3c_hub =3D p3h2x4x_i3c_hub; > + p3h2x4x_i3c_hub->tp_bus[tp_port].tp_port =3D tp_port; > + } > + } > +} [ ... ] > +static int p3h2x4x_i3c_hub_probe(struct platform_device *pdev) > +{ [ ... ] > + /* Unlock access to protected registers */ > + ret =3D regmap_write(p3h2x4x_i3c_hub->regmap, P3H2X4X_DEV_REG_PROTECTIO= N_CODE, > + P3H2X4X_REGISTERS_UNLOCK_CODE); > + if (ret) > + return dev_err_probe(dev, ret, "Failed to unlock HUB's protected regis= ters\n"); > + > + ret =3D p3h2x4x_configure_hw(dev); > + if (ret) > + return dev_err_probe(dev, ret, "Failed to configure the HUB\n"); [Severity: Medium] Are the hub's protected registers left permanently unlocked if probe fails during p3h2x4x_configure_hw() or bus registration? The driver unlocks the hardware registers at the start of probe and locks them at the very end. However, if any initialization step fails and returns an error, the function exits immediately without locking the registers agai= n. Could this be mitigated by using a devm_add_action_or_reset() callback or explicit error handling labels to ensure the registers are safely relocked? > + > + /* Register virtual I3C master controllers for I3C target ports */ > + if (p3h2x4x->i3cdev) { [ ... ] > diff --git a/drivers/i3c/hub/p3h2840_i3c_hub_i3c.c b/drivers/i3c/hub/p3h2= 840_i3c_hub_i3c.c > new file mode 100644 > index 0000000000000..8adb235b992c0 > --- /dev/null > +++ b/drivers/i3c/hub/p3h2840_i3c_hub_i3c.c [ ... ] > +int p3h2x4x_tp_i3c_algo(struct p3h2x4x_i3c_hub_dev *p3h2x4x_hub) > +{ [ ... ] > + for (tp =3D 0; tp < P3H2X4X_TP_MAX_COUNT; tp++) { > + if (!p3h2x4x_hub->tp_bus[tp].of_node || > + p3h2x4x_hub->hub_config.tp_config[tp].mode !=3D P3H2X4X_TP_MODE_I3= C) > + continue; > + > + /* Assign DT node for this TP */ > + p3h2x4x_hub->dev->of_node =3D p3h2x4x_hub->tp_bus[tp].of_node; [Severity: High] Does overwriting the parent device's of_node pointer iteratively cause a memory leak of the original parent node and a double-free of the target port nodes? The loop over target ports directly mutates the shared pdev->dev.of_node pointer which was populated in probe using device_set_of_node_from_dev(). This leaks the reference to the original parent node, and leaves dev->of_node pointing to the last target port node. When the driver is unbound, the driver core will drop a reference on dev->of_node, but p3h2x4x_put_target_port_of_nodes() also drops a reference on the same node, which can cause a use-after-free or double-free refcount underflow. Mutating dev->of_node also creates a race with sysfs/uevent. Should the driver assign the node to controller->dev.of_node directly instead of mutating the parent's pointer? > + > + struct i3c_hub_controller *hub_controller =3D > + &p3h2x4x_hub->tp_bus[tp].hub_controller; [ ... ] > diff --git a/drivers/i3c/hub/p3h2840_i3c_hub_smbus.c b/drivers/i3c/hub/p3= h2840_i3c_hub_smbus.c > new file mode 100644 > index 0000000000000..cf664425af071 > --- /dev/null > +++ b/drivers/i3c/hub/p3h2840_i3c_hub_smbus.c [ ... ] > +static int p3h2x4x_read_smbus_transaction_status(struct p3h2x4x_i3c_hub_= dev *hub, > + u8 target_port_status, > + u8 data_length) > +{ > + u32 status_read; > + u8 status; > + int ret; > + > + fsleep(P3H2X4X_SMBUS_400kHz_TRANSFER_TIMEOUT(data_length)); > + > + ret =3D regmap_read(hub->regmap, target_port_status, &status_read); [Severity: High] Does using a hardcoded sleep based on bytes transferred instead of polling a hardware completion status bit lead to premature reads of incomplete transactions? If the downstream device performs clock stretching or is slow to respond, the transfer will take longer than the hardcoded timeout. The driver then reads target_port_status and shifts to check the status bits. Since an ongoing transaction leaves the status bits at 0 (P3H2X4X_SMBUS_CNTRL_STATUS_TXN_OK), the driver will incorrectly assume the transaction has finished successfully. It will then proceed to read stale or uninitialized memory buffers and return garbage data. Could this be updated to use a polling loop checking the finish flag? > + if (ret) > + return ret; > + > + status =3D (u8)status_read; [ ... ] > +static s32 p3h2x4x_tp_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg = *msgs, int num) > +{ [ ... ] > + rw =3D (msgs[msg_count].flags & I2C_M_RD) ? 1 : 0; > + if (!rw) { > + /* If a read message is immediately followed by a write message to > + * the same address, consider combining them into a single transacti= on. > + */ [Severity: Low] This isn't a bug, but the comment describes a read followed by a write while the code implements a write followed by a read. The actual code block checks !rw for the first message and flags & I2C_M_RD for the second message, which accurately handles a write message immediately followed by a read message. > + if (msg_count + 1 < num && > + msgs[msg_count].addr =3D=3D msgs[msg_count + 1].addr && > + (msgs[msg_count + 1].flags & I2C_M_RD)) { > + if (msgs[msg_count].len + msgs[msg_count + 1].len > > + P3H2X4X_SMBUS_PAYLOAD_SIZE) > + return -EINVAL; --=20 Sashiko AI review =C2=B7 https://sashiko.dev/#/patchset/20260617110355.1591= 844-1-lakshay.piplani@nxp.com?part=3D6