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 83890C43458 for ; Tue, 14 Jul 2026 11:14:37 +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=PTiqo0GKhoOIzmJYwvHYFjtrN3X01H1YMfjpPTTWSNM=; b=2b2RxsY68hHKWe A4SyDmi/IZ7LgSpf5fwBx0rerJ28Vhp762tEa2flDa2p365NPFGHJfRxTpE/X2vJdGmGNGa0LnXjs FKjoDWUJS5daQCh12bViOGHUtsNwJm5T4JBfWMVFqeYaiUcVePgU1ZfwUpMxEH1xZviHawSS858fQ aDc/zCP2XaB7+oh1AlYgEKNOtCuSjZtPqrVzAlUA7FQtqSSSdmMR4lyMbF2ZKPTAMmbrOV/HtU3MX twyE5gzkUB0mwdoJhlIu7lItTDmmCYNrDH2mjCSbaj+Dg1cVIoIeU1ZtIheOB7Bszk4pAiky3ckF+ xwnDxs3SgRUOf+g2u/7w==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.99.1 #2 (Red Hat Linux)) id 1wjb5w-0000000BebB-0Vua; Tue, 14 Jul 2026 11:14:36 +0000 Received: from tor.source.kernel.org ([2600:3c04:e001:324:0:1991:8:25]) by bombadil.infradead.org with esmtps (Exim 4.99.1 #2 (Red Hat Linux)) id 1wjb5v-0000000Beb4-1SFH for linux-i3c@lists.infradead.org; Tue, 14 Jul 2026 11:14:35 +0000 Received: from smtp.kernel.org (quasi.space.kernel.org [100.103.45.18]) by tor.source.kernel.org (Postfix) with ESMTP id 73BBF60120; Tue, 14 Jul 2026 11:14:34 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id C33891F000E9; Tue, 14 Jul 2026 11:14:33 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1784027674; bh=nBMBZk/qqZXEz8kQDgWMRRZhqCt2GlX/dZfpUwL++CA=; h=From:Subject:Reply-To:To:Cc:In-Reply-To:References:Date; b=CO2uXR0qmy3m2ys/euVa9r/aYAUqVQy6req3SGNhpPWZWCbyXctqCiw6G3VLzRSRN TLZmvJ5Gnhv5AssQmIrTZ/2b2sNiQIkzGh1vnJn7dIIHyBK5afyX2DX9fqSgmH5Pks 3wh336pdUPc/H9guUTwXzVnT/wrCD9verHl+xGCWlRCqTK2cAU45LCXa/PaOTBR+uW qTy/UzsjnjeaBZ2xkG+EUcosdQt2rjdDNR2m43Tf5z0hTSjOGrm6zz7AJ38TYTtUgD KznepsQ71/XdqDDow8Py3we5iF9cS8muhkCYks9p2e22J7T9xk48JvJIOgRRTSsiWc SkdM2xhVwVNDQ== From: sashiko-bot@kernel.org Subject: Re: [PATCH v14 6/8] i3c: hub: Add support for the I3C interface in the I3C hub To: "Lakshay Piplani" Cc: linux-i3c@lists.infradead.org, "Alexandre Belloni" , conor+dt@kernel.org, Frank.Li@kernel.org, devicetree@vger.kernel.org, robh@kernel.org In-Reply-To: <20260714092053.2461482-7-lakshay.piplani@nxp.com> References: <20260714092053.2461482-1-lakshay.piplani@nxp.com> <20260714092053.2461482-7-lakshay.piplani@nxp.com> Date: Tue, 14 Jul 2026 11:14:32 +0000 Message-Id: <20260714111433.C33891F000E9@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 OCBwb3RlbnRpYWwgaXNzdWUocykgdG8gY29uc2lkZXI6Ci0gW0hpZ2hdIFRlbXBvcmFyeSBodWIg YWRkcmVzcyBzd2FwcGluZyBpbiBgaTNjX2h1Yl9tYXN0ZXJfcHJpdl94ZmVyc2AgcGVybWFuZW50 bHkgZnJlZXMgZG93bnN0cmVhbSBhZGRyZXNzIHNsb3RzLgotIFtIaWdoXSBEZXRhY2hpbmcgdGhl IGRvd25zdHJlYW0gZGV2aWNlIGluIElCSSByZXF1ZXN0L2ZyZWUgcGF0aHMgdW5jb25kaXRpb25h bGx5IGZyZWVzIGl0cyBwYXJlbnQgYnVzIGFkZHJlc3Mgc2xvdHMuCi0gW0hpZ2hdIEZvcndhcmRp bmcgREFBIGRpcmVjdGx5IHRvIHRoZSBwYXJlbnQgY29udHJvbGxlciBhdHRhY2hlcyBkb3duc3Ry ZWFtIGRldmljZXMgdG8gdGhlIHdyb25nIGJ1cyB0b3BvbG9neS4KLSBbSGlnaF0gVGhlIG5vLW9w IGByZWN5Y2xlX2liaV9zbG90YCBjYWxsYmFjayBwZXJtYW5lbnRseSBsZWFrcyBoYXJkd2FyZSBJ Qkkgc2xvdHMgYWxsb2NhdGVkIGJ5IHRoZSBwYXJlbnQgY29udHJvbGxlci4KLSBbSGlnaF0gYGkz Y19odWJfcmVxdWVzdF9pYmkoKWAgZmFpbHMgd2l0aCBgLUVCVVNZYCBkdWUgdG8gY29uZmxpY3Rp bmcgYWRkcmVzcyByZXNlcnZhdGlvbnMgb3IgY29ycnVwdHMgcGFyZW50IERBVC4KLSBbSGlnaF0g UmVjdXJzaXZlIGxvY2sgYWNxdWlzaXRpb24gb2YgYGh1Yi0+bG9ja2AgY2F1c2VzIGRlYWRsb2Nr cyB3aXRoIElCSSB3b3JrcXVldWUgaGFuZGxlcnMuCi0gW0hpZ2hdIE1vZGlmeWluZyB0aGUgZGV2 aWNlIGRlc2NyaXB0b3IncyBtYXN0ZXIgcG9pbnRlciB1bmRlciBhIHNoYXJlZCByZWFkLWxvY2sg Y2F1c2VzIGRhdGEgcmFjZXMsIG1pc3JvdXRpbmcgcHJpdmF0ZSB0cmFuc2ZlcnMuCi0gW0hpZ2hd IEZvcndhcmRpbmcgZGlyZWN0IENDQyBjb21tYW5kcyB1bm1vZGlmaWVkIHRocm91Z2ggdGhlIGh1 YiBjYXVzZXMgYSBOVUxMIHBvaW50ZXIgZGVyZWZlcmVuY2UgaW4gdGhlIHBhcmVudCBkcml2ZXIu Ci0tCgotLS0gUGF0Y2ggWzZdOiBbUEFUQ0ggdjE0IDYvOF0gaTNjOiBodWI6IEFkZCBzdXBwb3J0 IGZvciB0aGUgSTNDIGludGVyZmFjZSBpbiB0aGUgSTNDIGh1YiAtLS0KY29tbWl0IDAyZTc5NDY1 M2RhZjJiNTU0ZjBjOTYyYzM1NWQwYmI3YWJiMjYzNzQKQXV0aG9yOiBMYWtzaGF5IFBpcGxhbmkg PGxha3NoYXkucGlwbGFuaUBueHAuY29tPgpTdWJqZWN0OiBpM2M6IGh1YjogQWRkIHN1cHBvcnQg Zm9yIHRoZSBJM0MgaW50ZXJmYWNlIGluIHRoZSBJM0MgaHViCgpUaGlzIGNvbW1pdCBhZGRzIHZp cnR1YWwgSTNDIGJ1cyBzdXBwb3J0IGZvciB0aGUgaHViLCBjcmVhdGluZyB2aXJ0dWFsCm1hc3Rl ciBjb250cm9sbGVycyBmb3IgZG93bnN0cmVhbSBwb3J0cyBhbmQgZm9yd2FyZGluZyBvcGVyYXRp b25zIHRocm91Z2gKdGhlIHBhcmVudCBjb250cm9sbGVyLgoKPiBkaWZmIC0tZ2l0IGEvZHJpdmVy cy9pM2MvaHViLmMgYi9kcml2ZXJzL2kzYy9odWIuYwo+IGluZGV4IDAwMDAwMDAwMDAwMDAuLjYx MDViYjcxMGJlNjkKPiAtLS0gL2Rldi9udWxsCj4gKysrIGIvZHJpdmVycy9pM2MvaHViLmMKWyAu Li4gXQo+ICtzdGF0aWMgaW50IGkzY19odWJfZG9fZGFhKHN0cnVjdCBpM2NfaHViICpodWIsCj4g KwkJCSAgc3RydWN0IGkzY19tYXN0ZXJfY29udHJvbGxlciAqY29udHJvbGxlcikKPiArewpbIC4u LiBdCj4gKwkvKgo+ICsJICogRG93bnN0cmVhbSBkZXZpY2VzIHJlYWNoYWJsZSB0aHJvdWdoIGh1 YiB0YXJnZXQtcG9ydCByb3V0ZXMgc2hhcmUgdGhlCj4gKwkgKiBwYXJlbnQgY29udHJvbGxlcidz IEkzQyBhZGRyZXNzIHNwYWNlLiBUaGUgaHViIGdhdGVzIGFjY2VzcyB0byBhCj4gKwkgKiB0YXJn ZXQtcG9ydCBuZXR3b3JrLCBidXQgaXQgZG9lcyBub3QgY3JlYXRlIGFuIGluZGVwZW5kZW50IGR5 bmFtaWMKPiArCSAqIGFkZHJlc3MgZG9tYWluIHBlciB2aXJ0dWFsIGJ1cy4KPiArCSAqCj4gKwkg KiBSdW4gREFBIG9uIHRoZSBwYXJlbnQgY29udHJvbGxlciBzbyBkeW5hbWljIGFkZHJlc3NlcyBy ZW1haW4gdW5pcXVlCj4gKwkgKiBhY3Jvc3MgYWxsIGRvd25zdHJlYW0gZGV2aWNlcywgZXZlbiB3 aGVuIHRoZXkgYXJlIGJlaGluZCBkaWZmZXJlbnQKPiArCSAqIHRhcmdldCBwb3J0cy4KPiArCSAq Lwo+ICsJcmV0ID0gaTNjX21hc3Rlcl9kb19kYWEocGFyZW50KTsKCltTZXZlcml0eTogSGlnaF0K RG9lcyBmb3J3YXJkaW5nIERBQSBkaXJlY3RseSB0byB0aGUgcGFyZW50IGNvbnRyb2xsZXIgYXR0 YWNoIGR5bmFtaWNhbGx5CmRpc2NvdmVyZWQgZG93bnN0cmVhbSBkZXZpY2VzIGRpcmVjdGx5IHRv IHRoZSBwYXJlbnQgYnVzIGluc3RlYWQgb2YgdGhlCnZpcnR1YWwgaHViIGNvbnRyb2xsZXI/CgpJ ZiB0aGVzZSBkZXZpY2VzIGFyZSBib3VuZCB0byB0aGUgcGh5c2ljYWwgcGFyZW50LCBzdWJzZXF1 ZW50IHRyYW5zZmVycyAKbWlnaHQgYnlwYXNzIGkzY19odWJfbWFzdGVyX3ByaXZfeGZlcnMoKSBl bnRpcmVseSwgbGVhdmluZyB0aGUgaHViIHBvcnQgCmNsb3NlZCBhbmQgY2F1c2luZyBjb21tdW5p Y2F0aW9uIHRvIGZhaWwuCgpbIC4uLiBdCj4gK3N0YXRpYyBpbnQgaTNjX2h1Yl9zZW5kX2NjY19j bWQoc3RydWN0IGkzY19odWIgKmh1YiwKPiArCQkJCXN0cnVjdCBpM2NfbWFzdGVyX2NvbnRyb2xs ZXIgKmNvbnRyb2xsZXIsCj4gKwkJCQlzdHJ1Y3QgaTNjX2NjY19jbWQgKmNtZCkKPiArewpbIC4u LiBdCj4gKwltdXRleF9sb2NrKCZodWItPmxvY2spOwo+ICsJaTNjX2h1Yl9lbmFibGVfcG9ydChj b250cm9sbGVyKTsKPiArCXJldCA9IGkzY19tYXN0ZXJfc2VuZF9jY2NfY21kKHBhcmVudCwgY21k KTsKCltTZXZlcml0eTogSGlnaF0KV2hlbiBmb3J3YXJkaW5nIGRpcmVjdCBDQ0MgY29tbWFuZHMg dG8gdGhlIHBhcmVudCBjb250cm9sbGVyLCB0aGUgY29tbWFuZCAKc3RydWN0dXJlIHN0aWxsIGNv bnRhaW5zIHZpcnR1YWwgYnVzIGRlc2NyaXB0b3JzIGluIGl0cyBkZXN0cyBhcnJheS4gCgpTaW5j ZSB2aXJ0dWFsIGRldmljZXMgZG8gbm90IGFsbG9jYXRlIGEgcGh5c2ljYWwgbWFzdGVyX3ByaXYg Y29udGV4dCwgY2FuIAp0aGUgcGh5c2ljYWwgcGFyZW50IGNvbnRyb2xsZXIgZHJpdmVyIGRlcmVm ZXJlbmNlIGEgTlVMTCBwb2ludGVyIGhlcmUgd2hlbiAKaXQgYXNzdW1lcyB0aGVzZSBkZXZpY2Vz IGFyZSBuYXRpdmVseSBhdHRhY2hlZD8KCj4gKwlpM2NfaHViX2Rpc2FibGVfcG9ydChjb250cm9s bGVyKTsKPiArCW11dGV4X3VubG9jaygmaHViLT5sb2NrKTsKPiArCj4gKwlyZXR1cm4gcmV0Owo+ ICt9ClsgLi4uIF0KPiArc3RhdGljIGludCBpM2NfaHViX21hc3Rlcl9wcml2X3hmZXJzKHN0cnVj dCBpM2NfZGV2X2Rlc2MgKmRldiwKPiArCQkJCSAgICAgc3RydWN0IGkzY194ZmVyICp4ZmVycywK PiArCQkJCSAgICAgaW50IG54ZmVycywKPiArCQkJCSAgICAgZW51bSBpM2NfeGZlcl9tb2RlIG1v ZGUpCj4gK3sKWyAuLi4gXQo+ICsJaWYgKGh1Yl9hZGRyICE9IHRhcmdldF9hZGRyKSB7Cj4gKwkJ aHViX2Rldi0+aW5mby5keW5fYWRkciA9IHRhcmdldF9hZGRyOwo+ICsKPiArCQlyZXQgPSBpM2Nf bWFzdGVyX3JlYXR0YWNoX2kzY19kZXZfbG9ja2VkKGh1Yl9kZXYsIGh1Yl9hZGRyKTsKCltTZXZl cml0eTogSGlnaF0KV2hlbiB0aGUgaHViIGFkZHJlc3MgaXMgdGVtcG9yYXJpbHkgc3dhcHBlZCBo ZXJlLCBkb2VzIAppM2NfbWFzdGVyX3JlYXR0YWNoX2kzY19kZXZfbG9ja2VkKCkgdW5jb25kaXRp b25hbGx5IG1hcmsgdGhlIG9yaWdpbmFsIAphZGRyZXNzIChvbGRfZHluX2FkZHIpIGFzIGZyZWU/ CgpUaGlzIGFwcGVhcnMgdG8gcGVybWFuZW50bHkgZnJlZSBkb3duc3RyZWFtIGFkZHJlc3Mgc2xv dHMgYW5kIGNvdWxkIGxlYWQgCnRvIGFkZHJlc3MgY29sbGlzaW9ucyBvbiB0aGUgcGFyZW50IGJ1 cy4KCj4gKwkJaWYgKHJldCkgewo+ICsJCQlodWJfZGV2LT5pbmZvLmR5bl9hZGRyID0gaHViX2Fk ZHI7Cj4gKwkJCWdvdG8gb3V0X3VubG9ja19wYXJlbnQ7Cj4gKwkJfQo+ICsJfQpbIC4uLiBdCj4g K3N0YXRpYyBpbnQgaTNjX2h1Yl9yZXF1ZXN0X2liaShzdHJ1Y3QgaTNjX2Rldl9kZXNjICpkZXNj LAo+ICsJCQkgICAgICAgY29uc3Qgc3RydWN0IGkzY19pYmlfc2V0dXAgKnJlcSkKPiArewpbIC4u LiBdCj4gKwlpM2NfYnVzX21haW50ZW5hbmNlX2xvY2soJnBhcmVudC0+YnVzKTsKPiArCj4gKwlv cmlnX3BhcmVudCA9IGkzY19odWJfdXBkYXRlX2Rlc2NfcGFyZW50KCZkZXNjLT5jb21tb24sIHBh cmVudCk7CgpbU2V2ZXJpdHk6IEhpZ2hdCklzIGl0IHNhZmUgdG8gbW9kaWZ5IGRlc2MtPm1hc3Rl ciBoZXJlIHdoaWxlIG9ubHkgaG9sZGluZyBhIHJlYWQgbG9jayAKb24gdGhlIGJ1cz8KCkEgY29u Y3VycmVudCBwcml2YXRlIHRyYW5zZmVyIG1pZ2h0IHJlYWQgZGVzYy0+bWFzdGVyIGFuZCByZXNv bHZlIGl0IHRvIAp0aGUgcGh5c2ljYWwgcGFyZW50IGNvbnRyb2xsZXIsIG1pc3JvdXRpbmcgdGhl IHRyYW5zZmVyIGFuZCBieXBhc3NpbmcgCmh1YiByb3V0aW5nIGVudGlyZWx5LgoKPiArCj4gKwkv Kgo+ICsJICogRG93bnN0cmVhbSBkZXZpY2VzIGFyZSBleHBvc2VkIHRocm91Z2ggdGhlIHZpcnR1 YWwgaHViIGNvbnRyb2xsZXIuCj4gKwkgKiBQcml2YXRlIHRyYW5zZmVycyBvbmx5IHVzZSB0aGUg aHViIGRldmljZSB0ZW1wb3JhcmlseSB3aXRoIHRoZQo+ICsJICogZG93bnN0cmVhbSBkZXZpY2Un cyBkeW5hbWljIGFkZHJlc3M7IHRoZXkgZG8gbm90IGF0dGFjaCB0aGUgZG93bnN0cmVhbQo+ICsJ ICogZGV2aWNlIHRvIHRoZSBwYXJlbnQgY29udHJvbGxlci4KPiArCSAqCj4gKwkgKiBBdHRhY2gg dGhlIGRldmljZSB0byB0aGUgcGFyZW50IGNvbnRyb2xsZXIgYmVmb3JlIHJlcXVlc3RpbmcgSUJJ IHNvCj4gKwkgKiB0aGUgcGFyZW50IGNhbiBhbGxvY2F0ZSBhbnkgY29udHJvbGxlci1wcml2YXRl IElCSSBzdGF0ZS4KPiArCSAqLwo+ICsJcmV0ID0gaTNjX21hc3Rlcl9kaXJlY3RfYXR0YWNoX2kz Y19kZXZfbG9ja2VkKHBhcmVudCwgZGVzYyk7CgpbU2V2ZXJpdHk6IEhpZ2hdCkNvdWxkIGF0dGFj aGluZyB0aGUgZG93bnN0cmVhbSBkZXZpY2UgZGlyZWN0bHkgdG8gdGhlIHBhcmVudCBjb250cm9s bGVyIApmYWlsIHdpdGggLUVCVVNZIGlmIHRoZSBhZGRyZXNzIHdhcyBhbHJlYWR5IHJlc2VydmVk PyAKCkFkZGl0aW9uYWxseSwgaWYgaXQgc3VjY2VlZHMsIG1pZ2h0IHRoaXMgbGVhdmUgZHVwbGlj YXRlIERBVCBlbnRyaWVzIGluIAp0aGUgcGFyZW50IGhhcmR3YXJlIHdoZW4gdGhlIGh1YiBsYXRl ciBtYXNxdWVyYWRlcyBhcyB0aGlzIHRhcmdldCBhZGRyZXNzPwoKPiArCWlmIChyZXQpIHsKPiAr CQlpM2NfaHViX3VwZGF0ZV9kZXNjX3BhcmVudCgmZGVzYy0+Y29tbW9uLCBvcmlnX3BhcmVudCk7 Cj4gKwkJaTNjX2J1c19tYWludGVuYW5jZV91bmxvY2soJnBhcmVudC0+YnVzKTsKPiArCQlyZXR1 cm4gcmV0Owo+ICsJfQo+ICsKPiArCWlmIChkZXNjLT5pYmkpIHsKPiArCQlpZiAoZGVzYy0+aWJp LT53cSkgewo+ICsJCQlkZXN0cm95X3dvcmtxdWV1ZShkZXNjLT5pYmktPndxKTsKPiArCQkJZGVz Yy0+aWJpLT53cSA9IE5VTEw7Cj4gKwkJfQo+ICsKPiArCQlrZnJlZShkZXNjLT5pYmkpOwo+ICsJ CWRlc2MtPmliaSA9IE5VTEw7Cj4gKwl9Cj4gKwlyZXQgPSBpM2NfZGV2X3JlcXVlc3RfaWJpX2xv Y2tlZChkZXNjLCByZXEpOwo+ICsJaWYgKHJldCkKPiArCQlpM2NfbWFzdGVyX2RpcmVjdF9kZXRh Y2hfaTNjX2Rldl9sb2NrZWQoZGVzYyk7CgpbU2V2ZXJpdHk6IEhpZ2hdCkRvZXMgZGV0YWNoaW5n IHRoZSBkb3duc3RyZWFtIGRldmljZSBoZXJlIHVuY29uZGl0aW9uYWxseSBmcmVlIGl0cyBzdGF0 aWMgCmFuZCBkeW5hbWljIGFkZHJlc3NlcyBvbiB0aGUgcGFyZW50IGJ1cz8gCgpUaGUgZGV2aWNl IGlzIHN0aWxsIHBoeXNpY2FsbHkgcHJlc2VudCBhbmQgdXNpbmcgdGhvc2UgYWRkcmVzc2VzLCBz byBmcmVlaW5nIAp0aGVtIGNvdWxkIGxlYWQgdG8gYWRkcmVzcyBjb2xsaXNpb25zLgoKPiArCj4g KwlpM2NfaHViX3VwZGF0ZV9kZXNjX3BhcmVudCgmZGVzYy0+Y29tbW9uLCBvcmlnX3BhcmVudCk7 Cj4gKwo+ICsJaTNjX2J1c19tYWludGVuYW5jZV91bmxvY2soJnBhcmVudC0+YnVzKTsKPiArCj4g KwlyZXR1cm4gcmV0Owo+ICt9Cj4gKwo+ICtzdGF0aWMgdm9pZCBpM2NfaHViX2ZyZWVfaWJpKHN0 cnVjdCBpM2NfZGV2X2Rlc2MgKmRlc2MpCj4gK3sKWyAuLi4gXQo+ICsJbXV0ZXhfbG9jaygmaHVi LT5sb2NrKTsKPiArCWkzY19odWJfZW5hYmxlX3BvcnQoY29udHJvbGxlcik7Cj4gKwo+ICsJaTNj X2J1c19tYWludGVuYW5jZV9sb2NrKCZwYXJlbnQtPmJ1cyk7Cj4gKwlvcmlnX3BhcmVudCA9IGkz Y19odWJfdXBkYXRlX2Rlc2NfcGFyZW50KCZkZXNjLT5jb21tb24sIHBhcmVudCk7Cj4gKwlpM2Nf ZGV2X2ZyZWVfaWJpX2xvY2tlZChkZXNjKTsKCltTZXZlcml0eTogSGlnaF0KQ2FuIGhvbGRpbmcg aHViLT5sb2NrIGhlcmUgY2F1c2UgYSBkZWFkbG9jayBpZiB0aGVyZSBhcmUgcGVuZGluZyBJQkkg d29yayAKaGFuZGxlcnM/IAoKQ2FsbGluZyBpM2NfZGV2X2ZyZWVfaWJpX2xvY2tlZCgpIGJsb2Nr cyB3aGlsZSBkZXN0cm95aW5nIHRoZSB3b3JrcXVldWUuIApJZiBhbiBhY3RpdmUgSUJJIGhhbmRs ZXIgYXR0ZW1wdHMgdG8gcmVhZCB0aGUgSUJJIHBheWxvYWQsIGl0IHdpbGwgaW52b2tlIAppM2Nf aHViX21hc3Rlcl9wcml2X3hmZXJzKCksIHdoaWNoIGF0dGVtcHRzIHRvIGFjcXVpcmUgdGhpcyBl eGFjdCBzYW1lIGxvY2suCgo+ICsKPiArCS8qCj4gKwkgKiBEcm9wIHRoZSB0ZW1wb3JhcnkgcGFy ZW50IGF0dGFjaG1lbnQgY3JlYXRlZCBmb3IgSUJJIHNldHVwLgo+ICsJICogVGhlIGRvd25zdHJl YW0gZGV2aWNlIHJlbWFpbnMgZXhwb3NlZCB0aHJvdWdoIHRoZSB2aXJ0dWFsIGh1Ygo+ICsJICog Y29udHJvbGxlci4KPiArCSAqLwo+ICsJaTNjX21hc3Rlcl9kaXJlY3RfZGV0YWNoX2kzY19kZXZf bG9ja2VkKGRlc2MpOwoKW1NldmVyaXR5OiBIaWdoXQpEb2VzIGRldGFjaGluZyB0aGUgZGV2aWNl IG9uIHRoaXMgcGF0aCBhbHNvIGluY29ycmVjdGx5IGZyZWUgdGhlIApkb3duc3RyZWFtIGRldmlj ZSdzIGFkZHJlc3NlcyBvbiB0aGUgcGFyZW50IGJ1cz8KCj4gKwlpM2NfaHViX3VwZGF0ZV9kZXNj X3BhcmVudCgmZGVzYy0+Y29tbW9uLCBvcmlnX3BhcmVudCk7Cj4gKwlpM2NfYnVzX21haW50ZW5h bmNlX3VubG9jaygmcGFyZW50LT5idXMpOwo+ICsKPiArCWkzY19odWJfZGlzYWJsZV9wb3J0KGNv bnRyb2xsZXIpOwo+ICsJbXV0ZXhfdW5sb2NrKCZodWItPmxvY2spOwo+ICt9ClsgLi4uIF0KPiAr c3RhdGljIGludCBpM2NfaHViX2Rpc2FibGVfaWJpKHN0cnVjdCBpM2NfZGV2X2Rlc2MgKmRlc2Mp Cj4gK3sKWyAuLi4gXQo+ICsJbXV0ZXhfbG9jaygmaHViLT5sb2NrKTsKPiArCWkzY19odWJfZW5h YmxlX3BvcnQoY29udHJvbGxlcik7Cj4gKwo+ICsJb3JpZ19wYXJlbnQgPSBpM2NfaHViX3VwZGF0 ZV9kZXNjX3BhcmVudCgmZGVzYy0+Y29tbW9uLCBwYXJlbnQpOwo+ICsKPiArCWkzY19idXNfbWFp bnRlbmFuY2VfbG9jaygmcGFyZW50LT5idXMpOwo+ICsJcmV0ID0gaTNjX2Rldl9kaXNhYmxlX2li aV9sb2NrZWQoZGVzYyk7CgpbU2V2ZXJpdHk6IEhpZ2hdCkNvdWxkIGhvbGRpbmcgaHViLT5sb2Nr IHdoaWxlIGNhbGxpbmcgaTNjX2Rldl9kaXNhYmxlX2liaV9sb2NrZWQoKSBhbHNvIApsZWFkIHRv IHRoZSBzYW1lIEFCQkEgZGVhZGxvY2sgd2l0aCBwZW5kaW5nIElCSSB3b3JrZXJzIHRyeWluZyB0 byBhY3F1aXJlIApodWItPmxvY2sgdmlhIGkzY19odWJfbWFzdGVyX3ByaXZfeGZlcnMoKT8KCj4g KwlpM2NfYnVzX21haW50ZW5hbmNlX3VubG9jaygmcGFyZW50LT5idXMpOwo+ICsKPiArCWkzY19o dWJfdXBkYXRlX2Rlc2NfcGFyZW50KCZkZXNjLT5jb21tb24sIG9yaWdfcGFyZW50KTsKPiArCj4g KwlpM2NfaHViX2Rpc2FibGVfcG9ydChjb250cm9sbGVyKTsKPiArCW11dGV4X3VubG9jaygmaHVi LT5sb2NrKTsKPiArCj4gKwlyZXR1cm4gcmV0Owo+ICt9Cj4gKwo+ICtzdGF0aWMgdm9pZCBpM2Nf aHViX3JlY3ljbGVfaWJpX3Nsb3Qoc3RydWN0IGkzY19kZXZfZGVzYyAqZGVzYywKPiArCQkJCSAg ICAgc3RydWN0IGkzY19pYmlfc2xvdCAqc2xvdCkKPiArewo+ICsJLyoKPiArCSAqIFRPRE86IEZv cndhcmQgSUJJIHNsb3QgcmVjeWNsaW5nIHRvIHRoZSBwYXJlbnQgY29udHJvbGxlciB3aGVuCj4g KwkgKiBkb3duc3RyZWFtLWRldmljZSBJQkkgc3VwcG9ydCBpcyBmdWxseSBlbmFibGVkLiBDdXJy ZW50IHVzZXJzIG9ubHkKPiArCSAqIHJlbHkgb24gdGhlIGh1YiBkZXZpY2UgSUJJIHBhdGggZm9y IFNNQnVzLWFnZW50IGV2ZW50cywgc28gbm8gcGFyZW50Cj4gKwkgKiBoYXJkd2FyZSBzbG90IGlz IHJlY3ljbGVkIHRocm91Z2ggdGhpcyB2aXJ0dWFsIGNhbGxiYWNrIGN1cnJlbnRseS4KPiArCSAq Lwo+ICt9CgpbU2V2ZXJpdHk6IEhpZ2hdCkRvZXMgdGhpcyBlbXB0eSBpbXBsZW1lbnRhdGlvbiBw ZXJtYW5lbnRseSBsZWFrIGhhcmR3YXJlIElCSSBzbG90cyAKYWxsb2NhdGVkIGJ5IHRoZSBwYXJl bnQgY29udHJvbGxlcj8gCgpPdmVyIHRpbWUsIGZhaWxpbmcgdG8gcmV0dXJuIHRoZXNlIHNsb3Rz IGNvdWxkIGV4aGF1c3QgdGhlIHBvb2wgYW5kIHByZXZlbnQgCmZ1cnRoZXIgSUJJIHJlY2VwdGlv bi4KCj4gKwo+ICtzdGF0aWMgY29uc3Qgc3RydWN0IGkzY19tYXN0ZXJfY29udHJvbGxlcl9vcHMg aTNjX2h1Yl9tYXN0ZXJfb3BzX2RhdGEgPSB7Cj4gKwkuYnVzX2luaXQgPSBpM2NfaHViX21hc3Rl cl9idXNfaW5pdCwKWyAuLi4gXQo+IGRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L2kzYy9odWIu aCBiL2luY2x1ZGUvbGludXgvaTNjL2h1Yi5oCj4gaW5kZXggMDAwMDAwMDAwMDAwMC4uOGFkMmNm M2M5ZDViOAo+IC0tLSAvZGV2L251bGwKPiArKysgYi9pbmNsdWRlL2xpbnV4L2kzYy9odWIuaAo+ IEBAIC0wLDAgKzEsMTAyIEBAClsgLi4uIF0KPiArc3RhdGljIGlubGluZSBzdHJ1Y3QgaTNjX21h c3Rlcl9jb250cm9sbGVyICoKPiAraTNjX2h1Yl91cGRhdGVfZGVzY19wYXJlbnQoc3RydWN0IGkz Y19pMmNfZGV2X2Rlc2MgKmRlc2MsCj4gKwkJCSAgIHN0cnVjdCBpM2NfbWFzdGVyX2NvbnRyb2xs ZXIgKnBhcmVudCkKPiArewo+ICsJc3RydWN0IGkzY19tYXN0ZXJfY29udHJvbGxlciAqb3JpZ19w YXJlbnQgPSBkZXNjLT5tYXN0ZXI7Cj4gKwo+ICsJZGVzYy0+bWFzdGVyID0gcGFyZW50OwoKW1Nl dmVyaXR5OiBIaWdoXQpEb2VzIG1vZGlmeWluZyBkZXNjLT5tYXN0ZXIgaGVyZSBjcmVhdGUgYSBk YXRhIHJhY2Ugd2l0aCBjb25jdXJyZW50IAp0cmFuc2ZlcnMgdXNpbmcgdGhlIEkzQyBjb3JlIHRy YW5zZmVyIGZ1bmN0aW9ucz8KCj4gKwlyZXR1cm4gb3JpZ19wYXJlbnQ7Cj4gK30KCi0tIApTYXNo aWtvIEFJIHJldmlldyDCtyBodHRwczovL3Nhc2hpa28uZGV2LyMvcGF0Y2hzZXQvMjAyNjA3MTQw OTIwNTMuMjQ2MTQ4Mi0xLWxha3NoYXkucGlwbGFuaUBueHAuY29tP3BhcnQ9NgoKLS0gCmxpbnV4 LWkzYyBtYWlsaW5nIGxpc3QKbGludXgtaTNjQGxpc3RzLmluZnJhZGVhZC5vcmcKaHR0cDovL2xp c3RzLmluZnJhZGVhZC5vcmcvbWFpbG1hbi9saXN0aW5mby9saW51eC1pM2MK 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 5CE9D37DE98 for ; Tue, 14 Jul 2026 11:14:34 +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=1784027675; cv=none; b=AB9nCVp6oOR54j0vGYX7NBJGKp5D/BAziC/kUwEhIPf5IlvnAbfXdb9kmBOkjj+gvRFUitjPMTHtia8nWxVhn8X/oIMSOY7ZVH+QTBMQ1YKt6L4QPmxUK+WiX9cQvIs9WV6mzqXoWVBSVix+bxyMNqTti24p353bgFvCMGmLS2k= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1784027675; c=relaxed/simple; bh=pfCTKdcvKaSg9oN2jVa8B2BBErG0YXuTqSEcIa26Mj0=; h=From:Subject:To:Cc:In-Reply-To:References:Content-Type:Date: Message-Id; b=Uyc3yAdWrbkTxvgYY9dDwPmIcy4Pv3g1Yh0mzoLqy521ZehmYjjVHbDqiU2TL6Be9/cZc/vd9g1zPoZhJO8TpGqEBuGKmmFEohO58IoRuD05mZrZyu/gxwS92LMxxMsHUbB4XhKmCo9KQfzHz+DvfEd7S8ZJ5lmtpnuoqZg9vSA= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=CO2uXR0q; 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="CO2uXR0q" Received: by smtp.kernel.org (Postfix) with ESMTPSA id C33891F000E9; Tue, 14 Jul 2026 11:14:33 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1784027674; bh=nBMBZk/qqZXEz8kQDgWMRRZhqCt2GlX/dZfpUwL++CA=; h=From:Subject:Reply-To:To:Cc:In-Reply-To:References:Date; b=CO2uXR0qmy3m2ys/euVa9r/aYAUqVQy6req3SGNhpPWZWCbyXctqCiw6G3VLzRSRN TLZmvJ5Gnhv5AssQmIrTZ/2b2sNiQIkzGh1vnJn7dIIHyBK5afyX2DX9fqSgmH5Pks 3wh336pdUPc/H9guUTwXzVnT/wrCD9verHl+xGCWlRCqTK2cAU45LCXa/PaOTBR+uW qTy/UzsjnjeaBZ2xkG+EUcosdQt2rjdDNR2m43Tf5z0hTSjOGrm6zz7AJ38TYTtUgD KznepsQ71/XdqDDow8Py3we5iF9cS8muhkCYks9p2e22J7T9xk48JvJIOgRRTSsiWc SkdM2xhVwVNDQ== From: sashiko-bot@kernel.org Subject: Re: [PATCH v14 6/8] i3c: hub: Add support for the I3C interface in the I3C hub Reply-To: sashiko-reviews@lists.linux.dev To: "Lakshay Piplani" Cc: linux-i3c@lists.infradead.org, "Alexandre Belloni" , conor+dt@kernel.org, Frank.Li@kernel.org, devicetree@vger.kernel.org, robh@kernel.org In-Reply-To: <20260714092053.2461482-7-lakshay.piplani@nxp.com> References: <20260714092053.2461482-1-lakshay.piplani@nxp.com> <20260714092053.2461482-7-lakshay.piplani@nxp.com> Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: quoted-printable Date: Tue, 14 Jul 2026 11:14:32 +0000 Message-Id: <20260714111433.C33891F000E9@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: - [High] Temporary hub address swapping in `i3c_hub_master_priv_xfers` perm= anently frees downstream address slots. - [High] Detaching the downstream device in IBI request/free paths uncondit= ionally frees its parent bus address slots. - [High] Forwarding DAA directly to the parent controller attaches downstre= am devices to the wrong bus topology. - [High] The no-op `recycle_ibi_slot` callback permanently leaks hardware I= BI slots allocated by the parent controller. - [High] `i3c_hub_request_ibi()` fails with `-EBUSY` due to conflicting add= ress reservations or corrupts parent DAT. - [High] Recursive lock acquisition of `hub->lock` causes deadlocks with IB= I workqueue handlers. - [High] Modifying the device descriptor's master pointer under a shared re= ad-lock causes data races, misrouting private transfers. - [High] Forwarding direct CCC commands unmodified through the hub causes a= NULL pointer dereference in the parent driver. -- --- Patch [6]: [PATCH v14 6/8] i3c: hub: Add support for the I3C interface = in the I3C hub --- commit 02e794653daf2b554f0c962c355d0bb7abb26374 Author: Lakshay Piplani Subject: i3c: hub: Add support for the I3C interface in the I3C hub This commit adds virtual I3C bus support for the hub, creating virtual master controllers for downstream ports and forwarding operations through the parent controller. > diff --git a/drivers/i3c/hub.c b/drivers/i3c/hub.c > index 0000000000000..6105bb710be69 > --- /dev/null > +++ b/drivers/i3c/hub.c [ ... ] > +static int i3c_hub_do_daa(struct i3c_hub *hub, > + struct i3c_master_controller *controller) > +{ [ ... ] > + /* > + * Downstream devices reachable through hub target-port routes share the > + * parent controller's I3C address space. The hub gates access to a > + * target-port network, but it does not create an independent dynamic > + * address domain per virtual bus. > + * > + * Run DAA on the parent controller so dynamic addresses remain unique > + * across all downstream devices, even when they are behind different > + * target ports. > + */ > + ret =3D i3c_master_do_daa(parent); [Severity: High] Does forwarding DAA directly to the parent controller attach dynamically discovered downstream devices directly to the parent bus instead of the virtual hub controller? If these devices are bound to the physical parent, subsequent transfers=20 might bypass i3c_hub_master_priv_xfers() entirely, leaving the hub port=20 closed and causing communication to fail. [ ... ] > +static int i3c_hub_send_ccc_cmd(struct i3c_hub *hub, > + struct i3c_master_controller *controller, > + struct i3c_ccc_cmd *cmd) > +{ [ ... ] > + mutex_lock(&hub->lock); > + i3c_hub_enable_port(controller); > + ret =3D i3c_master_send_ccc_cmd(parent, cmd); [Severity: High] When forwarding direct CCC commands to the parent controller, the command=20 structure still contains virtual bus descriptors in its dests array.=20 Since virtual devices do not allocate a physical master_priv context, can=20 the physical parent controller driver dereference a NULL pointer here when= =20 it assumes these devices are natively attached? > + i3c_hub_disable_port(controller); > + mutex_unlock(&hub->lock); > + > + 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) { > + hub_dev->info.dyn_addr =3D target_addr; > + > + ret =3D i3c_master_reattach_i3c_dev_locked(hub_dev, hub_addr); [Severity: High] When the hub address is temporarily swapped here, does=20 i3c_master_reattach_i3c_dev_locked() unconditionally mark the original=20 address (old_dyn_addr) as free? This appears to permanently free downstream address slots and could lead=20 to address collisions on the parent bus. > + if (ret) { > + hub_dev->info.dyn_addr =3D hub_addr; > + goto out_unlock_parent; > + } > + } [ ... ] > +static int i3c_hub_request_ibi(struct i3c_dev_desc *desc, > + const struct i3c_ibi_setup *req) > +{ [ ... ] > + i3c_bus_maintenance_lock(&parent->bus); > + > + orig_parent =3D i3c_hub_update_desc_parent(&desc->common, parent); [Severity: High] Is it safe to modify desc->master here while only holding a read lock=20 on the bus? A concurrent private transfer might read desc->master and resolve it to=20 the physical parent controller, misrouting the transfer and bypassing=20 hub routing entirely. > + > + /* > + * Downstream devices are exposed through the virtual hub controller. > + * Private transfers only use the hub device temporarily with the > + * downstream device's dynamic address; they do not attach the downstre= am > + * device to the parent controller. > + * > + * Attach the device to the parent controller before requesting IBI so > + * the parent can allocate any controller-private IBI state. > + */ > + ret =3D i3c_master_direct_attach_i3c_dev_locked(parent, desc); [Severity: High] Could attaching the downstream device directly to the parent controller=20 fail with -EBUSY if the address was already reserved?=20 Additionally, if it succeeds, might this leave duplicate DAT entries in=20 the parent hardware when the hub later masquerades as this target address? > + if (ret) { > + i3c_hub_update_desc_parent(&desc->common, orig_parent); > + i3c_bus_maintenance_unlock(&parent->bus); > + return ret; > + } > + > + if (desc->ibi) { > + if (desc->ibi->wq) { > + destroy_workqueue(desc->ibi->wq); > + desc->ibi->wq =3D NULL; > + } > + > + kfree(desc->ibi); > + desc->ibi =3D NULL; > + } > + ret =3D i3c_dev_request_ibi_locked(desc, req); > + if (ret) > + i3c_master_direct_detach_i3c_dev_locked(desc); [Severity: High] Does detaching the downstream device here unconditionally free its static=20 and dynamic addresses on the parent bus?=20 The device is still physically present and using those addresses, so freein= g=20 them could lead to address collisions. > + > + i3c_hub_update_desc_parent(&desc->common, orig_parent); > + > + i3c_bus_maintenance_unlock(&parent->bus); > + > + return ret; > +} > + > +static void i3c_hub_free_ibi(struct i3c_dev_desc *desc) > +{ [ ... ] > + mutex_lock(&hub->lock); > + i3c_hub_enable_port(controller); > + > + i3c_bus_maintenance_lock(&parent->bus); > + orig_parent =3D i3c_hub_update_desc_parent(&desc->common, parent); > + i3c_dev_free_ibi_locked(desc); [Severity: High] Can holding hub->lock here cause a deadlock if there are pending IBI work=20 handlers?=20 Calling i3c_dev_free_ibi_locked() blocks while destroying the workqueue.=20 If an active IBI handler attempts to read the IBI payload, it will invoke=20 i3c_hub_master_priv_xfers(), which attempts to acquire this exact same lock. > + > + /* > + * Drop the temporary parent attachment created for IBI setup. > + * The downstream device remains exposed through the virtual hub > + * controller. > + */ > + i3c_master_direct_detach_i3c_dev_locked(desc); [Severity: High] Does detaching the device on this path also incorrectly free the=20 downstream device's addresses on the parent bus? > + i3c_hub_update_desc_parent(&desc->common, orig_parent); > + i3c_bus_maintenance_unlock(&parent->bus); > + > + i3c_hub_disable_port(controller); > + mutex_unlock(&hub->lock); > +} [ ... ] > +static int i3c_hub_disable_ibi(struct i3c_dev_desc *desc) > +{ [ ... ] > + mutex_lock(&hub->lock); > + i3c_hub_enable_port(controller); > + > + orig_parent =3D i3c_hub_update_desc_parent(&desc->common, parent); > + > + i3c_bus_maintenance_lock(&parent->bus); > + ret =3D i3c_dev_disable_ibi_locked(desc); [Severity: High] Could holding hub->lock while calling i3c_dev_disable_ibi_locked() also=20 lead to the same ABBA deadlock with pending IBI workers trying to acquire=20 hub->lock via i3c_hub_master_priv_xfers()? > + i3c_bus_maintenance_unlock(&parent->bus); > + > + i3c_hub_update_desc_parent(&desc->common, orig_parent); > + > + i3c_hub_disable_port(controller); > + mutex_unlock(&hub->lock); > + > + return ret; > +} > + > +static void i3c_hub_recycle_ibi_slot(struct i3c_dev_desc *desc, > + struct i3c_ibi_slot *slot) > +{ > + /* > + * TODO: Forward IBI slot recycling to the parent controller when > + * downstream-device IBI support is fully enabled. Current users only > + * rely on the hub device IBI path for SMBus-agent events, so no parent > + * hardware slot is recycled through this virtual callback currently. > + */ > +} [Severity: High] Does this empty implementation permanently leak hardware IBI slots=20 allocated by the parent controller?=20 Over time, failing to return these slots could exhaust the pool and prevent= =20 further IBI reception. > + > +static const struct i3c_master_controller_ops i3c_hub_master_ops_data = =3D { > + .bus_init =3D i3c_hub_master_bus_init, [ ... ] > diff --git a/include/linux/i3c/hub.h b/include/linux/i3c/hub.h > index 0000000000000..8ad2cf3c9d5b8 > --- /dev/null > +++ b/include/linux/i3c/hub.h > @@ -0,0 +1,102 @@ [ ... ] > +static inline struct i3c_master_controller * > +i3c_hub_update_desc_parent(struct i3c_i2c_dev_desc *desc, > + struct i3c_master_controller *parent) > +{ > + struct i3c_master_controller *orig_parent =3D desc->master; > + > + desc->master =3D parent; [Severity: High] Does modifying desc->master here create a data race with concurrent=20 transfers using the I3C core transfer functions? > + return orig_parent; > +} --=20 Sashiko AI review =C2=B7 https://sashiko.dev/#/patchset/20260714092053.2461= 482-1-lakshay.piplani@nxp.com?part=3D6