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 9FE81CD98E2 for ; Wed, 17 Jun 2026 11:18:06 +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=K8CjxHd16Pn1I4aSYVhV3JX9wkHxl025uAyDQa9ed8U=; b=UIa03tQxKVHKiY 7kLFopVS8iVkivUaTVBdq02CKsnI2/I3QrMtBJK0ZZQ8ghqkmPyh8Q5NgM7jxMg0m5Scww8SKojzR g8xvxRvGjBwVdQIkvy4q4uiIqD0rd2XAkFRXbYV5MUWcSvIPEhV8bCiwFqkw8Qga0mngS2bvUqk11 8FuvG6gfODEAAHyKG7rBDPQFd7+LqYOMa/r7nvgsgmwcak4iXWvRx+3Fb0AbLpUXlnAiet92SVU7J e/B0+kD8Conb0posDAdV9JfXqrZIJoizbrlYJpTlMOMCTtl4sE5aVBpnuWDZMc/B+3hq7Plv1GAF6 0B+ixtPczSxBb6lHzxCQ==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.99.1 #2 (Red Hat Linux)) id 1wZoHW-0000000HDXG-1iCs; Wed, 17 Jun 2026 11:18:06 +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 1wZoHV-0000000HDWr-2U8Q for linux-i3c@lists.infradead.org; Wed, 17 Jun 2026 11:18:05 +0000 Received: from smtp.kernel.org (quasi.space.kernel.org [100.103.45.18]) by sea.source.kernel.org (Postfix) with ESMTP id 5D212418B7; Wed, 17 Jun 2026 11:18:05 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id ABFF71F00A3D; Wed, 17 Jun 2026 11:18:04 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1781695085; bh=0O7n1x2uoPuiR0pxuOx+prQXqwOkZgkFZTU+B/41iyU=; h=From:Subject:Reply-To:To:Cc:In-Reply-To:References:Date; b=YAD/20LJu29GU0Q+FrjODWS7FbZcojsq1dkBg26694uTX+bWR1Uf+dMl0jT+FdIHy c41y36wWgUpzP5uCDmfmNBHi69pwWJOpzpH0uEry7z9yAGMsESBTclNa5WNNlhREsd SJZCy72y3kmppNUB9MaIpptxTqllhCr/isWkm4cKlKvQ29VFDSyHdVzOg+o5Q4kPkA ldFadGCQkvDXE1g0wNQSxysx1woLnz4y7emoBgMg1D5cKvUlQ8L2Lg/r9aXGDbLHct VOUzxjqoDV5jkUi/oZLS+fOcCwKMoJHOB+IAAUkvu03JNs3AotJEoS0b0t829Lb7tY IoUD+uAVDotug== From: sashiko-bot@kernel.org Subject: Re: [PATCH v12 5/7] i3c: hub: Add support for the I3C interface in the I3C hub To: "Lakshay Piplani" Cc: robh@kernel.org, conor+dt@kernel.org, Frank.Li@kernel.org, devicetree@vger.kernel.org, linux-i3c@lists.infradead.org In-Reply-To: <20260617110355.1591844-6-lakshay.piplani@nxp.com> References: <20260617110355.1591844-1-lakshay.piplani@nxp.com> <20260617110355.1591844-6-lakshay.piplani@nxp.com> Date: Wed, 17 Jun 2026 11:18:04 +0000 Message-Id: <20260617111804.ABFF71F00A3D@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 OCBwb3RlbnRpYWwgaXNzdWUocykgdG8gY29uc2lkZXI6Ci0gW0NyaXRpY2FsXSBEZXRlcm1pbmlz dGljIE5VTEwgcG9pbnRlciBkZXJlZmVyZW5jZSBpbiBgaTNjX2h1Yl9mcmVlX2liaSgpYCBkdWUg dG8gcmVjdXJzaXZlIGNhbGxiYWNrIGNoYWluLgotIFtDcml0aWNhbF0gTWVtb3J5IGxlYWsgYW5k IGRvdWJsZS1mcmVlIG1lbW9yeSBjb3JydXB0aW9uIGluIGBpM2NfaHViX3JlcXVlc3RfaWJpKClg IGVycm9yIHBhdGhzLgotIFtDcml0aWNhbF0gQ3JpdGljYWwgcmFjZSBjb25kaXRpb24gYW5kIHBh cmVudCBidXMgc3RhdGUgY29ycnVwdGlvbiBpbiBgaTNjX2h1Yl9tYXN0ZXJfcHJpdl94ZmVycygp YCBkdWUgdG8gdW5sb2NrZWQgYWRkcmVzcyBtdXRhdGlvbi4KLSBbQ3JpdGljYWxdIFVuaW1wbGVt ZW50ZWQgYGkzY19odWJfcmVjeWNsZV9pYmlfc2xvdCgpYCBwZXJtYW5lbnRseSBsZWFrcyBoYXJk d2FyZSBJQkkgc2xvdHMuCi0gW0NyaXRpY2FsXSBBcmNoaXRlY3R1cmFsIGJ5cGFzcyBpbiBgaTNj X2h1Yl9kb19kYWEoKWAgYXR0YWNoZXMgZHluYW1pY2FsbHkgZGlzY292ZXJlZCBkZXZpY2VzIHRv IHRoZSBwYXJlbnQgYnVzIGluc3RlYWQgb2YgdGhlIHZpcnR1YWwgaHViIGJ1cy4KLSBbSGlnaF0g Q2FsbGluZyBgaTNjX2h1Yl9lbmFibGVfcG9ydCgpYCBvdXRzaWRlIG9mIGFueSBsb2NrcyBhbGxv d3MgY29uY3VycmVudCBvcGVyYXRpb25zIHRvIHBoeXNpY2FsbHkgZW5hYmxlIG11bHRpcGxlIGRv d25zdHJlYW0gcG9ydHMgc2ltdWx0YW5lb3VzbHksIGJyZWFraW5nIGVsZWN0cmljYWwgaXNvbGF0 aW9uLgotIFtIaWdoXSBTaWxlbnRseSBkcm9wcGluZyBicm9hZGNhc3QgUlNUREFBIGNvbW1hbmRz IHByZXZlbnRzIHJlc2V0dGluZyBvZiBkb3duc3RyZWFtIGRldmljZXMuCi0gW01lZGl1bV0gQWNj ZXB0aW5nIEkyQyBkZXZpY2VzIHdoaWxlIHVuY29uZGl0aW9uYWxseSByZWplY3RpbmcgYWxsIEky QyB0cmFuc2ZlcnMgdmlvbGF0ZXMgdGhlIEFQSSBjb250cmFjdC4KLS0KCmNvbW1pdCAyYTIwMWE5 ZTBlOWE1NWIzMTQ2N2Q4NzQzNDAwODUyNDBiMzRhZmMzCkF1dGhvcjogTGFrc2hheSBQaXBsYW5p IDxsYWtzaGF5LnBpcGxhbmlAbnhwLmNvbT4KCmkzYzogaHViOiBBZGQgc3VwcG9ydCBmb3IgdGhl IEkzQyBpbnRlcmZhY2UgaW4gdGhlIEkzQyBodWIKClRoaXMgcGF0Y2ggYWRkcyB2aXJ0dWFsIEkz QyBidXMgc3VwcG9ydCBmb3IgdGhlIGh1YiBhbmQgcHJvdmlkZXMgYW4KaW50ZXJmYWNlIHRvIGVu YWJsZSBvciBkaXNhYmxlIGRvd25zdHJlYW0gcG9ydHMuCgo+IGRpZmYgLS1naXQgYS9kcml2ZXJz L2kzYy9odWIuYyBiL2RyaXZlcnMvaTNjL2h1Yi5jCj4gbmV3IGZpbGUgbW9kZSAxMDA2NDQKPiBp bmRleCAwMDAwMDAwMDAwMDAwLi5lODc0NGI1MTcyMzQwCj4gLS0tIC9kZXYvbnVsbAo+ICsrKyBi L2RyaXZlcnMvaTNjL2h1Yi5jCj4gQEAgLTAsMCArMSw0ODMgQEAKClsgLi4uIF0KCj4gK3N0YXRp YyBpbnQgaTNjX2h1Yl9kb19kYWEoc3RydWN0IGkzY19odWIgKmh1YiwKPiArCQkJICBzdHJ1Y3Qg aTNjX21hc3Rlcl9jb250cm9sbGVyICpjb250cm9sbGVyKQo+ICt7Cj4gKwlzdHJ1Y3QgaTNjX21h c3Rlcl9jb250cm9sbGVyICpwYXJlbnQ7Cj4gKwlpbnQgcmV0Owo+ICsKPiArCWlmICghaHViIHx8 ICFodWItPmh1Yl9kZXYpCj4gKwkJcmV0dXJuIC1FTk9ERVY7Cj4gKwo+ICsJcGFyZW50ID0gaTNj X2Rldl9nZXRfbWFzdGVyKGh1Yi0+aHViX2Rldi0+ZGVzYyk7Cj4gKwlpZiAoIXBhcmVudCkKPiAr CQlyZXR1cm4gLUVOT0RFVjsKPiArCj4gKwlpM2NfaHViX2VuYWJsZV9wb3J0KGNvbnRyb2xsZXIp Owo+ICsJcmV0ID0gaTNjX21hc3Rlcl9kb19kYWEocGFyZW50KTsKCltTZXZlcml0eTogQ3JpdGlj YWxdClNpbmNlIGBpM2NfbWFzdGVyX2RvX2RhYSgpYCBleGVjdXRlcyB0aGUgREFBIHNlcXVlbmNl IG5hdGl2ZWx5IG9uIHRoZSBwYXJlbnQKY29udHJvbGxlciwgd2lsbCB0aGUgbmV3bHkgZGlzY292 ZXJlZCBkZXZpY2VzIGJlIGFsbG9jYXRlZCBhbmQgYXR0YWNoZWQKZGlyZWN0bHkgdG8gdGhlIHBh cmVudCBidXMgaW5zdGVhZCBvZiB0aGlzIHZpcnR1YWwgaHViJ3MgYnVzPyAKCklmIHRoZXkgYXJl IGF0dGFjaGVkIHRvIHRoZSBwYXJlbnQgYnVzLCB3b24ndCBzdWJzZXF1ZW50IHRyYW5zZmVycyBj b21wbGV0ZWx5CmJ5cGFzcyBgaTNjX2h1Yl9tYXN0ZXJfcHJpdl94ZmVycygpYCwgY2F1c2luZyBj b21tdW5pY2F0aW9uIHdpdGggdGhlc2UKZHluYW1pY2FsbHkgZW51bWVyYXRlZCBkZXZpY2VzIHRv IGZhaWw/CgpbU2V2ZXJpdHk6IEhpZ2hdCklzIHRoZXJlIGEgcmlzayBvZiBicmVha2luZyBlbGVj dHJpY2FsIGlzb2xhdGlvbiBoZXJlPyBgaTNjX2h1Yl9lbmFibGVfcG9ydCgpYAppcyBjYWxsZWQg YmVmb3JlIGFjcXVpcmluZyBhbnkgcGFyZW50IGJ1cyBsb2Nrcy4gCgpJZiBtdWx0aXBsZSB0aHJl YWRzIG9wZXJhdGUgb24gZGlmZmVyZW50IHZpcnR1YWwgY29udHJvbGxlcnMgY29uY3VycmVudGx5 LApjb3VsZCB0aGV5IHBoeXNpY2FsbHkgZW5hYmxlIG11bHRpcGxlIGRvd25zdHJlYW0gcG9ydHMg YXQgdGhlIHNhbWUgdGltZQpiZWZvcmUgdGhlIGJ1cyBsb2NrIGlzIGFjcXVpcmVkPwoKPiArCWkz Y19odWJfZGlzYWJsZV9wb3J0KGNvbnRyb2xsZXIpOwo+ICsKPiArCXJldHVybiByZXQ7Cj4gK30K ClsgLi4uIF0KCj4gK3N0YXRpYyBpbnQgaTNjX2h1Yl9zZW5kX2NjY19jbWQoc3RydWN0IGkzY19o dWIgKmh1YiwKPiArCQkJCXN0cnVjdCBpM2NfbWFzdGVyX2NvbnRyb2xsZXIgKmNvbnRyb2xsZXIs Cj4gKwkJCQlzdHJ1Y3QgaTNjX2NjY19jbWQgKmNtZCkKPiArewo+ICsJc3RydWN0IGkzY19tYXN0 ZXJfY29udHJvbGxlciAqcGFyZW50Owo+ICsJaW50IHJldDsKPiArCj4gKwlpZiAoIWh1YiB8fCAh aHViLT5odWJfZGV2KQo+ICsJCXJldHVybiAtRU5PREVWOwo+ICsKPiArCXBhcmVudCA9IGkzY19k ZXZfZ2V0X21hc3RlcihodWItPmh1Yl9kZXYtPmRlc2MpOwo+ICsJaWYgKCFwYXJlbnQpCj4gKwkJ cmV0dXJuIC1FTk9ERVY7Cj4gKwo+ICsJaTNjX2h1Yl9lbmFibGVfcG9ydChjb250cm9sbGVyKTsK PiArCXJldCA9IGkzY19tYXN0ZXJfc2VuZF9jY2NfY21kKHBhcmVudCwgY21kKTsKCltTZXZlcml0 eTogSGlnaF0KU2ltaWxhciB0byBgaTNjX2h1Yl9kb19kYWEoKWAsIGRvZXMgY2FsbGluZyBgaTNj X2h1Yl9lbmFibGVfcG9ydCgpYCB3aXRob3V0IGEKbG9jayByaXNrIGVuYWJsaW5nIG11bHRpcGxl IHBvcnRzIGNvbmN1cnJlbnRseSBpZiBtdWx0aXBsZSBDQ0MgY29tbWFuZHMgYXJlCmlzc3VlZCBv biBkaWZmZXJlbnQgcG9ydHM/Cgo+ICsJaTNjX2h1Yl9kaXNhYmxlX3BvcnQoY29udHJvbGxlcik7 Cj4gKwo+ICsJcmV0dXJuIHJldDsKPiArfQoKWyAuLi4gXQoKPiArc3RhdGljIGludCBpM2NfaHVi X21hc3Rlcl9wcml2X3hmZXJzKHN0cnVjdCBpM2NfZGV2X2Rlc2MgKmRldiwKPiArCQkJCSAgICAg c3RydWN0IGkzY194ZmVyICp4ZmVycywKPiArCQkJCSAgICAgaW50IG54ZmVycywKPiArCQkJCSAg ICAgZW51bSBpM2NfeGZlcl9tb2RlIG1vZGUpCj4gK3sKClsgLi4uIF0KCj4gKwlpZiAoaHViX2Fk ZHIgIT0gdGFyZ2V0X2FkZHIpIHsKPiArCQlkb3duX3dyaXRlKCZwYXJlbnQtPmJ1cy5sb2NrKTsK PiArCQlodWJfZGV2LT5pbmZvLmR5bl9hZGRyID0gdGFyZ2V0X2FkZHI7Cj4gKwo+ICsJCXJldCA9 IGkzY19tYXN0ZXJfcmVhdHRhY2hfaTNjX2Rldl9sb2NrZWQoaHViX2RldiwgaHViX2FkZHIpOwo+ ICsJCXVwX3dyaXRlKCZwYXJlbnQtPmJ1cy5sb2NrKTsKPiArCQlpZiAocmV0KSB7Cj4gKwkJCWh1 Yl9kZXYtPmluZm8uZHluX2FkZHIgPSBodWJfYWRkcjsKPiArCQkJZ290byBkaXNhYmxlOwo+ICsJ CX0KPiArCX0KPiArCj4gKwlyZXQgPSBpM2NfZGV2aWNlX2RvX3hmZXJzKGh1Yi0+aHViX2Rldiwg eGZlcnMsIG54ZmVycywgbW9kZSk7CgpbU2V2ZXJpdHk6IENyaXRpY2FsXQpEb2VzIGRyb3BwaW5n IGBwYXJlbnQtPmJ1cy5sb2NrYCBiZWZvcmUgY2FsbGluZyBgaTNjX2RldmljZV9kb194ZmVycygp YCBleHBvc2UKYSByYWNlIGNvbmRpdGlvbj8gCgpJZiBtdWx0aXBsZSBkb3duc3RyZWFtIHBvcnRz IGluaXRpYXRlIHRyYW5zZmVycyBjb25jdXJyZW50bHksIGNvdWxkIHRoZXkKb3ZlcndyaXRlIHRo ZSBzaGFyZWQgYGh1Yl9kZXYtPmluZm8uZHluX2FkZHJgIGJlZm9yZSB0aGUgdHJhbnNmZXIgY29t cGxldGVzLApjYXVzaW5nIHBhY2tldHMgdG8gYmUgcm91dGVkIHRvIHRoZSB3cm9uZyBwaHlzaWNh bCBkZXZpY2U/Cgo+ICsKPiArCWlmIChodWJfYWRkciAhPSB0YXJnZXRfYWRkcikgewo+ICsJCWRv d25fd3JpdGUoJnBhcmVudC0+YnVzLmxvY2spOwo+ICsJCWh1Yl9kZXYtPmluZm8uZHluX2FkZHIg PSBodWJfYWRkcjsKPiArCj4gKwkJeGZlcl9yZXQgPSBpM2NfbWFzdGVyX3JlYXR0YWNoX2kzY19k ZXZfbG9ja2VkKGh1Yl9kZXYsCj4gKwkJCQkJCQkgICAgICB0YXJnZXRfYWRkcik7CgpbU2V2ZXJp dHk6IENyaXRpY2FsXQpDb3VsZCBwYXNzaW5nIGB0YXJnZXRfYWRkcmAgYXMgdGhlIG9sZCBhZGRy ZXNzIGNvcnJ1cHQgdGhlIHBhcmVudCBidXMgc3RhdGU/CgpgaTNjX21hc3Rlcl9yZWF0dGFjaF9p M2NfZGV2X2xvY2tlZCgpYCBmcmVlcyB0aGUgb2xkIGFkZHJlc3Mgc2xvdCBpbiB0aGUgYnVzCnNs b3QgbWFwLiBXaWxsIHRoaXMgZXJyb25lb3VzbHkgbWFyayBgdGFyZ2V0X2FkZHJgIGFzIGBJM0Nf QUREUl9TTE9UX0ZSRUVgCm9uIHRoZSBwYXJlbnQgYnVzPwoKPiArCj4gKwkJdXBfd3JpdGUoJnBh cmVudC0+YnVzLmxvY2spOwo+ICsJCWlmICghcmV0KQo+ICsJCQlyZXQgPSB4ZmVyX3JldDsKPiAr CX0KPiArZGlzYWJsZToKPiArCWkzY19odWJfZGlzYWJsZV9wb3J0KGNvbnRyb2xsZXIpOwo+ICsJ cmV0dXJuIHJldDsKPiArfQo+ICsKPiArc3RhdGljIGludCBpM2NfaHViX2F0dGFjaF9pMmNfZGV2 KHN0cnVjdCBpMmNfZGV2X2Rlc2MgKmRldikKPiArewo+ICsJcmV0dXJuIDA7Cj4gK30KClsgLi4u IF0KCj4gK3N0YXRpYyBpbnQgaTNjX2h1Yl9pMmNfeGZlcnMoc3RydWN0IGkyY19kZXZfZGVzYyAq ZGV2LAo+ICsJCQkgICAgIHN0cnVjdCBpMmNfbXNnICp4ZmVycywgaW50IG54ZmVycykKPiArewo+ ICsJcmV0dXJuIC1FT1BOT1RTVVBQOwo+ICt9CgpbU2V2ZXJpdHk6IE1lZGl1bV0KSXMgaXQgaW50 ZW50aW9uYWwgdG8gcmV0dXJuIGAwYCBmcm9tIGBpM2NfaHViX2F0dGFjaF9pMmNfZGV2KClgIHdo aWxlIHJlamVjdGluZwphbGwgSTJDIHRyYW5zZmVycyB3aXRoIGAtRU9QTk9UU1VQUGA/IAoKV291 bGQgaXQgYmUgc2FmZXIgdG8gcmV0dXJuIGFuIGVycm9yIGZyb20gdGhlIGF0dGFjaCBjYWxsYmFj ayB0byBjbGVhbmx5CnByZXZlbnQgSTJDIGRyaXZlciBiaW5kaW5nIGlmIHRoZSBodWIgZG9lcyBu b3Qgc3VwcG9ydCBJMkMgZm9yd2FyZGluZz8KClsgLi4uIF0KCj4gK3N0YXRpYyBpbnQgaTNjX2h1 Yl9tYXN0ZXJfc2VuZF9jY2NfY21kKHN0cnVjdCBpM2NfbWFzdGVyX2NvbnRyb2xsZXIgKmNvbnRy b2xsZXIsCj4gKwkJCQkgICAgICAgc3RydWN0IGkzY19jY2NfY21kICpjbWQpCj4gK3sKPiArCXN0 cnVjdCBpM2NfaHViX2NvbnRyb2xsZXIgKmh1Yl9jb250cm9sbGVyOwo+ICsJc3RydWN0IGkzY19o dWIgKmh1YjsKPiArCj4gKwlodWJfY29udHJvbGxlciA9IGRldl9nZXRfZHJ2ZGF0YSgmY29udHJv bGxlci0+ZGV2KTsKPiArCWlmICghaHViX2NvbnRyb2xsZXIgfHwgIWh1Yl9jb250cm9sbGVyLT5o dWIpCj4gKwkJcmV0dXJuIC1FTk9ERVY7Cj4gKwo+ICsJaHViID0gaHViX2NvbnRyb2xsZXItPmh1 YjsKPiArCj4gKwlpZiAoIWh1Yi0+aHViX2RldikKPiArCQlyZXR1cm4gLUVOT0RFVjsKPiArCj4g KwlpZiAoY21kLT5pZCA9PSBJM0NfQ0NDX1JTVERBQSh0cnVlKSkKPiArCQlyZXR1cm4gMDsKCltT ZXZlcml0eTogSGlnaF0KRG9lcyBzaWxlbnRseSBkcm9wcGluZyB0aGUgYnJvYWRjYXN0IFJTVERB QSBjb21tYW5kIHByZXZlbnQgZG93bnN0cmVhbSBkZXZpY2VzCmZyb20gYmVpbmcgY29ycmVjdGx5 IHJlc2V0IGJ5IHRoZSBodWI/IAoKSWYgdGhlIGNvbW1hbmQgaXMgZHJvcHBlZCBpbnN0ZWFkIG9m IGJlaW5nIGZvcndhcmRlZCB0byB0aGUgZG93bnN0cmVhbSBwb3J0cywKd2lsbCBkZXZpY2VzIHJl dGFpbiB0aGVpciBvbGQgZHluYW1pYyBhZGRyZXNzZXMgYW5kIGZhaWwgdG8gcmUtaW5pdGlhbGl6 ZQpkdXJpbmcgaG90LXBsdWcgcmVjb3Zlcnk/Cgo+ICsKPiArCXJldHVybiBpM2NfaHViX3NlbmRf Y2NjX2NtZChodWIsIGNvbnRyb2xsZXIsIGNtZCk7Cj4gK30KClsgLi4uIF0KCj4gK3N0YXRpYyBp bnQgaTNjX2h1Yl9yZXF1ZXN0X2liaShzdHJ1Y3QgaTNjX2Rldl9kZXNjICpkZXNjLAo+ICsJCQkg ICAgICAgY29uc3Qgc3RydWN0IGkzY19pYmlfc2V0dXAgKnJlcSkKPiArewoKWyAuLi4gXQoKPiAr CXJldCA9IGkzY19tYXN0ZXJfZGlyZWN0X2F0dGFjaF9pM2NfZGV2X2xvY2tlZChwYXJlbnQsIGRl c2MpOwo+ICsJaWYgKHJldCkgewo+ICsJCWkzY19odWJfdXBkYXRlX2Rlc2NfcGFyZW50KCZkZXNj LT5jb21tb24sIG9yaWdfcGFyZW50KTsKPiArCQl1cF93cml0ZSgmcGFyZW50LT5idXMubG9jayk7 Cj4gKwkJcmV0dXJuIHJldDsKPiArCX0KPiArCj4gKwlrZnJlZShkZXNjLT5pYmkpOwoKW1NldmVy aXR5OiBDcml0aWNhbF0KRG9lcyBmcmVlaW5nIGBkZXNjLT5pYmlgIGhlcmUgbGVhayBgZGVzYy0+ aWJpLT53cWA/CgpXaGVuIHRoZSBjb3JlIGZ1bmN0aW9uIGBpM2NfZGV2X3JlcXVlc3RfaWJpX2xv Y2tlZCgpYCBhbGxvY2F0ZXMgYGliaWAsIGl0IGFsc28KYWxsb2NhdGVzIGBpYmktPndxYC4gCgpB bHNvLCBpZiB0aGUgaW5uZXIgY2FsbCB0byBgaTNjX2Rldl9yZXF1ZXN0X2liaV9sb2NrZWQoKWAg ZmFpbHMsIHRoaXMgZnVuY3Rpb24KcmV0dXJucyBhbiBlcnJvciB0byB0aGUgb3JpZ2luYWwgY29y ZSBjYWxsZXIuIFdpbGwgdGhlIG91dGVyIGNhbGxlcidzIGVycm9yCnBhdGggZXhlY3V0ZSBga2Zy ZWUoaWJpKWAgb24gaXRzIGxvY2FsIHZhcmlhYmxlLCByZXN1bHRpbmcgaW4gYSBkb3VibGUtZnJl ZQpzaW5jZSBpdCB3YXMgYWxyZWFkeSBmcmVlZCBoZXJlPwoKPiArCWRlc2MtPmliaSA9IE5VTEw7 Cj4gKwlyZXQgPSBpM2NfZGV2X3JlcXVlc3RfaWJpX2xvY2tlZChkZXNjLCByZXEpOwo+ICsJaWYg KHJldCkKPiArCQlpM2NfbWFzdGVyX2RpcmVjdF9kZXRhY2hfaTNjX2Rldl9sb2NrZWQoZGVzYyk7 Cj4gKwo+ICsJaTNjX2h1Yl91cGRhdGVfZGVzY19wYXJlbnQoJmRlc2MtPmNvbW1vbiwgb3JpZ19w YXJlbnQpOwo+ICsKPiArCXVwX3dyaXRlKCZwYXJlbnQtPmJ1cy5sb2NrKTsKPiArCj4gKwlyZXR1 cm4gcmV0Owo+ICt9Cj4gKwo+ICtzdGF0aWMgdm9pZCBpM2NfaHViX2ZyZWVfaWJpKHN0cnVjdCBp M2NfZGV2X2Rlc2MgKmRlc2MpCj4gK3sKClsgLi4uIF0KCj4gKwlpM2NfaHViX2VuYWJsZV9wb3J0 KGNvbnRyb2xsZXIpOwo+ICsKPiArCWRvd25fd3JpdGUoJnBhcmVudC0+YnVzLmxvY2spOwo+ICsJ b3JpZ19wYXJlbnQgPSBpM2NfaHViX3VwZGF0ZV9kZXNjX3BhcmVudCgmZGVzYy0+Y29tbW9uLCBw YXJlbnQpOwo+ICsJaTNjX21hc3Rlcl9kaXJlY3RfZGV0YWNoX2kzY19kZXZfbG9ja2VkKGRlc2Mp Owo+ICsJaTNjX2Rldl9mcmVlX2liaV9sb2NrZWQoZGVzYyk7CgpbU2V2ZXJpdHk6IENyaXRpY2Fs XQpDYW4gdGhpcyByZWN1cnNpdmUgY2FsbCB0byBgaTNjX2Rldl9mcmVlX2liaV9sb2NrZWQoZGVz YylgIGNhdXNlIGEgbnVsbApwb2ludGVyIGRlcmVmZXJlbmNlPwoKV2hlbiB0aGUgY29yZSBpbml0 aWFsbHkgY2FsbHMgYGkzY19kZXZfZnJlZV9pYmlfbG9ja2VkKGRlc2MpYCwgaXQgaW52b2tlcwp0 aGlzIGh1YiBjYWxsYmFjay4gVGhlIGlubmVyIGNhbGwgaGVyZSBzdWNjZXNzZnVsbHkgZnJlZXMg YGRlc2MtPmliaWAgYW5kIHNldHMKaXQgdG8gbnVsbC4gCgpXaGVuIGNvbnRyb2wgcmV0dXJucyB0 byB0aGUgb3V0ZXIgY29yZSBmdW5jdGlvbiwgaXQgdW5jb25kaXRpb25hbGx5IGV2YWx1YXRlczoK CiAgICBpZiAoZGV2LT5pYmktPndxKSB7CgpXaWxsIHRoaXMgaW1tZWRpYXRlbHkgZGVyZWZlcmVu Y2UgdGhlIG51bGwgcG9pbnRlcj8KCj4gKwlpM2NfaHViX3VwZGF0ZV9kZXNjX3BhcmVudCgmZGVz Yy0+Y29tbW9uLCBvcmlnX3BhcmVudCk7Cj4gKwl1cF93cml0ZSgmcGFyZW50LT5idXMubG9jayk7 Cj4gKwo+ICsJaTNjX2h1Yl9kaXNhYmxlX3BvcnQoY29udHJvbGxlcik7Cj4gK30KClsgLi4uIF0K Cj4gK3N0YXRpYyB2b2lkIGkzY19odWJfcmVjeWNsZV9pYmlfc2xvdChzdHJ1Y3QgaTNjX2Rldl9k ZXNjICpkZXNjLAo+ICsJCQkJICAgICBzdHJ1Y3QgaTNjX2liaV9zbG90ICpzbG90KQo+ICt7Cj4g K30KCltTZXZlcml0eTogQ3JpdGljYWxdCkRvZXMgbGVhdmluZyB0aGlzIGZ1bmN0aW9uIGVtcHR5 IHBlcm1hbmVudGx5IGxlYWsgaGFyZHdhcmUgSUJJIHNsb3RzPwoKV2hlbiB0aGUgY29yZSBmaW5p c2hlcyBwcm9jZXNzaW5nIGFuIElCSSwgaXQgcmV0dXJucyB0aGUgc2xvdCB0byB0aGUgdmlydHVh bApjb250cm9sbGVyLiBCZWNhdXNlIHRoaXMgZG9lc24ndCBmb3J3YXJkIHRoZSByZWN5Y2xlIHJl cXVlc3QgdG8gdGhlIHBhcmVudApoYXJkd2FyZSBjb250cm9sbGVyLCB3aWxsIHRoZSBwYXJlbnQg Y29udHJvbGxlciBldmVudHVhbGx5IGV4aGF1c3QgaXRzIGhhcmR3YXJlCnNsb3RzIGFuZCBwZXJt YW5lbnRseSBzdG9wIHByb2Nlc3NpbmcgSUJJcz8KCi0tIApTYXNoaWtvIEFJIHJldmlldyDCtyBo dHRwczovL3Nhc2hpa28uZGV2LyMvcGF0Y2hzZXQvMjAyNjA2MTcxMTAzNTUuMTU5MTg0NC0xLWxh a3NoYXkucGlwbGFuaUBueHAuY29tP3BhcnQ9NQoKLS0gCmxpbnV4LWkzYyBtYWlsaW5nIGxpc3QK bGludXgtaTNjQGxpc3RzLmluZnJhZGVhZC5vcmcKaHR0cDovL2xpc3RzLmluZnJhZGVhZC5vcmcv bWFpbG1hbi9saXN0aW5mby9saW51eC1pM2MK 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 B4BFD282F3A for ; Wed, 17 Jun 2026 11:18:05 +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=1781695090; cv=none; b=sSmBKXwsuxJ3v6GZxTCjGka/r92kaTPae2wtylIAfKMW3Gnb1y8hRWuj4+DYo4JzOydjGZ4xUjxhDHWp074qooFQEBpww7Dv+/G/UkSm0zLGVzcI9vX3+rEcLn8cUnPPr8Hm3mCnTr3bnuXLOA3J3C1kFXGFGSjTXpBH1x3LE2o= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1781695090; c=relaxed/simple; bh=aD8dD5p+/44c8fB9QiBdWQ+hcmF5aAlKG34iBDx5a7E=; h=From:Subject:To:Cc:In-Reply-To:References:Content-Type:Date: Message-Id; b=UdEQ8ypUG5d+GJ+OPfVj5icTtndCRs3NDrnFIaszqFCku6HaHWG0XaC3zawXP7QYAXrK12/9eJgLxXgHhJwAAUglfBxqNQFapBa9QAlvt65hJ74IJ4B2Tf4fN/hzOWTYx9mhnZcjwr4t+k9XU34XLHDzGUh4zr9nzFuJeg7J4vw= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=YAD/20LJ; 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="YAD/20LJ" Received: by smtp.kernel.org (Postfix) with ESMTPSA id ABFF71F00A3D; Wed, 17 Jun 2026 11:18:04 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1781695085; bh=0O7n1x2uoPuiR0pxuOx+prQXqwOkZgkFZTU+B/41iyU=; h=From:Subject:Reply-To:To:Cc:In-Reply-To:References:Date; b=YAD/20LJu29GU0Q+FrjODWS7FbZcojsq1dkBg26694uTX+bWR1Uf+dMl0jT+FdIHy c41y36wWgUpzP5uCDmfmNBHi69pwWJOpzpH0uEry7z9yAGMsESBTclNa5WNNlhREsd SJZCy72y3kmppNUB9MaIpptxTqllhCr/isWkm4cKlKvQ29VFDSyHdVzOg+o5Q4kPkA ldFadGCQkvDXE1g0wNQSxysx1woLnz4y7emoBgMg1D5cKvUlQ8L2Lg/r9aXGDbLHct VOUzxjqoDV5jkUi/oZLS+fOcCwKMoJHOB+IAAUkvu03JNs3AotJEoS0b0t829Lb7tY IoUD+uAVDotug== From: sashiko-bot@kernel.org Subject: Re: [PATCH v12 5/7] i3c: hub: Add support for the I3C interface in the I3C hub Reply-To: sashiko-reviews@lists.linux.dev To: "Lakshay Piplani" Cc: robh@kernel.org, conor+dt@kernel.org, Frank.Li@kernel.org, devicetree@vger.kernel.org, linux-i3c@lists.infradead.org In-Reply-To: <20260617110355.1591844-6-lakshay.piplani@nxp.com> References: <20260617110355.1591844-1-lakshay.piplani@nxp.com> <20260617110355.1591844-6-lakshay.piplani@nxp.com> Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: quoted-printable Date: Wed, 17 Jun 2026 11:18:04 +0000 Message-Id: <20260617111804.ABFF71F00A3D@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 8 potential issue(= s) to consider: - [Critical] Deterministic NULL pointer dereference in `i3c_hub_free_ibi()`= due to recursive callback chain. - [Critical] Memory leak and double-free memory corruption in `i3c_hub_requ= est_ibi()` error paths. - [Critical] Critical race condition and parent bus state corruption in `i3= c_hub_master_priv_xfers()` due to unlocked address mutation. - [Critical] Unimplemented `i3c_hub_recycle_ibi_slot()` permanently leaks h= ardware IBI slots. - [Critical] Architectural bypass in `i3c_hub_do_daa()` attaches dynamicall= y discovered devices to the parent bus instead of the virtual hub bus. - [High] Calling `i3c_hub_enable_port()` outside of any locks allows concur= rent operations to physically enable multiple downstream ports simultaneous= ly, breaking electrical isolation. - [High] Silently dropping broadcast RSTDAA commands prevents resetting of = downstream devices. - [Medium] Accepting I2C devices while unconditionally rejecting all I2C tr= ansfers violates the API contract. -- commit 2a201a9e0e9a55b31467d874340085240b34afc3 Author: Lakshay Piplani i3c: hub: Add support for the I3C interface in the I3C hub This patch adds virtual I3C bus support for the hub and provides an interface to enable or disable downstream ports. > diff --git a/drivers/i3c/hub.c b/drivers/i3c/hub.c > new file mode 100644 > index 0000000000000..e8744b5172340 > --- /dev/null > +++ b/drivers/i3c/hub.c > @@ -0,0 +1,483 @@ [ ... ] > +static int i3c_hub_do_daa(struct i3c_hub *hub, > + struct i3c_master_controller *controller) > +{ > + struct i3c_master_controller *parent; > + int ret; > + > + if (!hub || !hub->hub_dev) > + return -ENODEV; > + > + parent =3D i3c_dev_get_master(hub->hub_dev->desc); > + if (!parent) > + return -ENODEV; > + > + i3c_hub_enable_port(controller); > + ret =3D i3c_master_do_daa(parent); [Severity: Critical] Since `i3c_master_do_daa()` executes the DAA sequence natively on the parent controller, will the newly discovered devices be allocated and attached directly to the parent bus instead of this virtual hub's bus?=20 If they are attached to the parent bus, won't subsequent transfers complete= ly bypass `i3c_hub_master_priv_xfers()`, causing communication with these dynamically enumerated devices to fail? [Severity: High] Is there a risk of breaking electrical isolation here? `i3c_hub_enable_port= ()` is called before acquiring any parent bus locks.=20 If multiple threads operate on different virtual controllers concurrently, could they physically enable multiple downstream ports at the same time before the bus lock is acquired? > + i3c_hub_disable_port(controller); > + > + return ret; > +} [ ... ] > +static int i3c_hub_send_ccc_cmd(struct i3c_hub *hub, > + struct i3c_master_controller *controller, > + struct i3c_ccc_cmd *cmd) > +{ > + struct i3c_master_controller *parent; > + int ret; > + > + if (!hub || !hub->hub_dev) > + return -ENODEV; > + > + parent =3D i3c_dev_get_master(hub->hub_dev->desc); > + if (!parent) > + return -ENODEV; > + > + i3c_hub_enable_port(controller); > + ret =3D i3c_master_send_ccc_cmd(parent, cmd); [Severity: High] Similar to `i3c_hub_do_daa()`, does calling `i3c_hub_enable_port()` without= a lock risk enabling multiple ports concurrently if multiple CCC commands are issued on different ports? > + i3c_hub_disable_port(controller); > + > + return ret; > +} [ ... ] > +static int i3c_hub_master_priv_xfers(struct i3c_dev_desc *dev, > + struct i3c_xfer *xfers, > + int nxfers, > + enum i3c_xfer_mode mode) > +{ [ ... ] > + if (hub_addr !=3D target_addr) { > + down_write(&parent->bus.lock); > + hub_dev->info.dyn_addr =3D target_addr; > + > + ret =3D i3c_master_reattach_i3c_dev_locked(hub_dev, hub_addr); > + up_write(&parent->bus.lock); > + if (ret) { > + hub_dev->info.dyn_addr =3D hub_addr; > + goto disable; > + } > + } > + > + ret =3D i3c_device_do_xfers(hub->hub_dev, xfers, nxfers, mode); [Severity: Critical] Does dropping `parent->bus.lock` before calling `i3c_device_do_xfers()` exp= ose a race condition?=20 If multiple downstream ports initiate transfers concurrently, could they overwrite the shared `hub_dev->info.dyn_addr` before the transfer completes, causing packets to be routed to the wrong physical device? > + > + if (hub_addr !=3D target_addr) { > + down_write(&parent->bus.lock); > + hub_dev->info.dyn_addr =3D hub_addr; > + > + xfer_ret =3D i3c_master_reattach_i3c_dev_locked(hub_dev, > + target_addr); [Severity: Critical] Could passing `target_addr` as the old address corrupt the parent bus state? `i3c_master_reattach_i3c_dev_locked()` frees the old address slot in the bus slot map. Will this erroneously mark `target_addr` as `I3C_ADDR_SLOT_FREE` on the parent bus? > + > + up_write(&parent->bus.lock); > + if (!ret) > + ret =3D xfer_ret; > + } > +disable: > + i3c_hub_disable_port(controller); > + return ret; > +} > + > +static int i3c_hub_attach_i2c_dev(struct i2c_dev_desc *dev) > +{ > + return 0; > +} [ ... ] > +static int i3c_hub_i2c_xfers(struct i2c_dev_desc *dev, > + struct i2c_msg *xfers, int nxfers) > +{ > + return -EOPNOTSUPP; > +} [Severity: Medium] Is it intentional to return `0` from `i3c_hub_attach_i2c_dev()` while rejec= ting all I2C transfers with `-EOPNOTSUPP`?=20 Would it be safer to return an error from the attach callback to cleanly prevent I2C driver binding if the hub does not support I2C forwarding? [ ... ] > +static int i3c_hub_master_send_ccc_cmd(struct i3c_master_controller *con= troller, > + struct i3c_ccc_cmd *cmd) > +{ > + struct i3c_hub_controller *hub_controller; > + struct i3c_hub *hub; > + > + hub_controller =3D dev_get_drvdata(&controller->dev); > + if (!hub_controller || !hub_controller->hub) > + return -ENODEV; > + > + hub =3D hub_controller->hub; > + > + if (!hub->hub_dev) > + return -ENODEV; > + > + if (cmd->id =3D=3D I3C_CCC_RSTDAA(true)) > + return 0; [Severity: High] Does silently dropping the broadcast RSTDAA command prevent downstream devi= ces from being correctly reset by the hub?=20 If the command is dropped instead of being forwarded to the downstream port= s, will devices retain their old dynamic addresses and fail to re-initialize during hot-plug recovery? > + > + return i3c_hub_send_ccc_cmd(hub, controller, cmd); > +} [ ... ] > +static int i3c_hub_request_ibi(struct i3c_dev_desc *desc, > + const struct i3c_ibi_setup *req) > +{ [ ... ] > + ret =3D i3c_master_direct_attach_i3c_dev_locked(parent, desc); > + if (ret) { > + i3c_hub_update_desc_parent(&desc->common, orig_parent); > + up_write(&parent->bus.lock); > + return ret; > + } > + > + kfree(desc->ibi); [Severity: Critical] Does freeing `desc->ibi` here leak `desc->ibi->wq`? When the core function `i3c_dev_request_ibi_locked()` allocates `ibi`, it a= lso allocates `ibi->wq`.=20 Also, if the inner call to `i3c_dev_request_ibi_locked()` fails, this funct= ion returns an error to the original core caller. Will the outer caller's error path execute `kfree(ibi)` on its local variable, resulting in a double-free since it was already freed here? > + desc->ibi =3D NULL; > + ret =3D i3c_dev_request_ibi_locked(desc, req); > + if (ret) > + i3c_master_direct_detach_i3c_dev_locked(desc); > + > + i3c_hub_update_desc_parent(&desc->common, orig_parent); > + > + up_write(&parent->bus.lock); > + > + return ret; > +} > + > +static void i3c_hub_free_ibi(struct i3c_dev_desc *desc) > +{ [ ... ] > + i3c_hub_enable_port(controller); > + > + down_write(&parent->bus.lock); > + orig_parent =3D i3c_hub_update_desc_parent(&desc->common, parent); > + i3c_master_direct_detach_i3c_dev_locked(desc); > + i3c_dev_free_ibi_locked(desc); [Severity: Critical] Can this recursive call to `i3c_dev_free_ibi_locked(desc)` cause a null pointer dereference? When the core initially calls `i3c_dev_free_ibi_locked(desc)`, it invokes this hub callback. The inner call here successfully frees `desc->ibi` and s= ets it to null.=20 When control returns to the outer core function, it unconditionally evaluat= es: if (dev->ibi->wq) { Will this immediately dereference the null pointer? > + i3c_hub_update_desc_parent(&desc->common, orig_parent); > + up_write(&parent->bus.lock); > + > + i3c_hub_disable_port(controller); > +} [ ... ] > +static void i3c_hub_recycle_ibi_slot(struct i3c_dev_desc *desc, > + struct i3c_ibi_slot *slot) > +{ > +} [Severity: Critical] Does leaving this function empty permanently leak hardware IBI slots? When the core finishes processing an IBI, it returns the slot to the virtual controller. Because this doesn't forward the recycle request to the parent hardware controller, will the parent controller eventually exhaust its hard= ware slots and permanently stop processing IBIs? --=20 Sashiko AI review =C2=B7 https://sashiko.dev/#/patchset/20260617110355.1591= 844-1-lakshay.piplani@nxp.com?part=3D5