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 F281CF588C3 for ; Mon, 20 Apr 2026 13:25: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:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:MIME-Version:References:In-Reply-To: Message-ID:Date:Subject:Cc:To:From:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=r1sKLk6syXDhidoJfq7sj46aY+8rLoLl+NAcuPptVAc=; b=eBtMjaKsr/QBsb tWtfunYw7obm7JTQxALKvadKdamAVwmI7y0FOGBz/nYjv/DGirzeyK9z0g82Y/AFgtaCnZ9+g+M3h YL2wleH6lpJM1C35s4gRJ2WHDgM2P0eZcDnAh3MFr31fDTyUStDVdNOew+oqsPlRyFPvMjWuG75BZ 0TjaoeaCnGlqCDgNQeAcbpwaJRvkAG3vbAVig++0reewWlu56GsLRJLcEfVGHQjI0UAIFhLClZTi7 TCxN4N9rln/sHHyU+88BVZMen46D0MsruNgqA0v+8noEcNcJstmm8sYmD3wAK8zyVSyPswLYnY+lb jcEWd72QfQyXzPV5dzKg==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.98.2 #2 (Red Hat Linux)) id 1wEod5-0000000707W-39AU; Mon, 20 Apr 2026 13:25:35 +0000 Received: from tor.source.kernel.org ([172.105.4.254]) by bombadil.infradead.org with esmtps (Exim 4.98.2 #2 (Red Hat Linux)) id 1wEod4-0000000706v-1DV8 for linux-i3c@lists.infradead.org; Mon, 20 Apr 2026 13:25:34 +0000 Received: from smtp.kernel.org (transwarp.subspace.kernel.org [100.75.92.58]) by tor.source.kernel.org (Postfix) with ESMTP id 9EE506012B; Mon, 20 Apr 2026 13:25:33 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id EEDBEC2BCB4; Mon, 20 Apr 2026 13:25:31 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1776691533; bh=WYswN/ROswEAsJMjhIx+uqRHKp+65BaQFPOFnwBgM3A=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=TWwN9/KiFOi8KofX2NLDsLSH3+AhHWaskkGVjuYmT9nx7zfNlMpYy9+s7++AmjkwO Hl5onZE159VSwHd1TTC4/DrHFOPvnUHP2BhAJLHEDQ6eDzPgvXSUs+/iwrwBx0wTqN H2uEs9Jnqcmv00pWp58VlSkyClVQKJZwSJmzRam94aZmGJUwc2HXDcr5/eB41ZxQTQ O+f4/Pb8VBChDKRaVCmShv+fudqI76ULIum0sU8oeetEdIwu3M9qT3T/xqDnmQVVoK 6aR+76QyWYW6PkP3EZr9+qA/FDaGVbycmh14KDKdBASUiE2kMO4SuqQDygDHHCeMeh YEB8aF8od/FAA== From: Sasha Levin To: patches@lists.linux.dev, stable@vger.kernel.org Cc: Jorge Marques , Frank Li , Adrian Hunter , Alexandre Belloni , Sasha Levin , linux-i3c@lists.infradead.org, linux-kernel@vger.kernel.org Subject: [PATCH AUTOSEL 7.0-6.1] i3c: master: Move bus_init error suppression Date: Mon, 20 Apr 2026 09:17:59 -0400 Message-ID: <20260420132314.1023554-85-sashal@kernel.org> X-Mailer: git-send-email 2.53.0 In-Reply-To: <20260420132314.1023554-1-sashal@kernel.org> References: <20260420132314.1023554-1-sashal@kernel.org> MIME-Version: 1.0 X-stable: review X-Patchwork-Hint: Ignore X-stable-base: Linux 7.0 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: , 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 RnJvbTogSm9yZ2UgTWFycXVlcyA8am9yZ2UubWFycXVlc0BhbmFsb2cuY29tPgoKWyBVcHN0cmVh bSBjb21taXQgNDk3NzVhZmE5ODNlM2U1Y2U4ZTdkMDBlZTI0MTc5MTA3M2JlMjE0ZCBdCgpQcmVw YXJlIHRvIGZpeCBpbXByb3BlciBNeCBwb3NpdGl2ZSBlcnJvciBwcm9wYWdhdGlvbiBpbiBsYXRl ciBjb21taXRzCmJ5IGhhbmRsaW5nIE14IGVycm9yIGNvZGVzIHdoZXJlIHRoZSBpM2NfY2NjX2Nt ZCBjb21tYW5kIGlzIGFsbG9jYXRlZC4KVGhlIENDQyBESVNFQyB0byBicm9hZGNhc3QgYWRkcmVz cyBpcyBpbnZva2VkIHdpdGgKaTNjX21hc3Rlcl9lbmVjX2Rpc2VjX2xvY2tlZCgpIGFuZCB5aWVs ZHMgZXJyb3IgSTNDX0VSUk9SX00yIGlmIHRoZXJlCmFyZSBubyBkZXZpY2VzIGFjdGl2ZSBvbiB0 aGUgYnVzLiBUaGlzIGlzIGV4cGVjdGVkIGF0IHRoZSBidXMKaW5pdGlhbGl6YXRpb24gc3RhZ2Us IHdoZXJlIGl0IGlzIG5vdCBrbm93biB5ZXQgdGhhdCB0aGVyZSBhcmUgbm8gYWN0aXZlCmRldmlj ZXMgb24gdGhlIGJ1cy4gQWRkIGJvb2wgc3VwcHJlc3NfbTIgYXJndW1lbnQgdG8KaTNjX21hc3Rl cl9lbmVjX2Rpc2VjX2xvY2tlZCgpIGFuZCB1cGRhdGUgdGhlIGNhbGwgc2l0ZSBhdAppM2NfbWFz dGVyX2J1c19pbml0KCkgd2l0aCB0aGUgZXhhY3QgY29ybmVyIGNhc2UgdG8gbm90IHJlcXVpcmUK cHJvcGFnYXRpbmcgcG9zaXRpdmUgTXggZXJyb3IgY29kZXMuIE90aGVyIGNhbGwgc2l0ZSBzaG91 bGQgbm90IHN1cHByZXNzCnRoZSBlcnJvciBjb2RlLCBmb3IgZXhhbXBsZSwgaWYgYSBkcml2ZXIg cmVxdWVzdHMgdG8gcGVyaXBoZXJhbCB0bwpkaXNhYmxlIGV2ZW50cyBhbmQgdGhlIHRyYW5zZmVy IGlzIG5vdCBhY2tub3dsZWRnZWQsIHRoaXMgaXMgYW4gZXJyb3IKYW5kIHNob3VsZCBub3QgcHJv Y2VlZC4KClJldmlld2VkLWJ5OiBGcmFuayBMaSA8RnJhbmsuTGlAbnhwLmNvbT4KUmV2aWV3ZWQt Ynk6IEFkcmlhbiBIdW50ZXIgPGFkcmlhbi5odW50ZXJAaW50ZWwuY29tPgpTaWduZWQtb2ZmLWJ5 OiBKb3JnZSBNYXJxdWVzIDxqb3JnZS5tYXJxdWVzQGFuYWxvZy5jb20+Ckxpbms6IGh0dHBzOi8v cGF0Y2gubXNnaWQubGluay8yMDI2MDMyMy1hZDQwNjItcG9zaXRpdmUtZXJyb3ItZml4LXYzLTMt MzBiZGM2ODAwNGJlQGFuYWxvZy5jb20KU2lnbmVkLW9mZi1ieTogQWxleGFuZHJlIEJlbGxvbmkg PGFsZXhhbmRyZS5iZWxsb25pQGJvb3RsaW4uY29tPgpTaWduZWQtb2ZmLWJ5OiBTYXNoYSBMZXZp biA8c2FzaGFsQGtlcm5lbC5vcmc+Ci0tLQoKTExNIEdlbmVyYXRlZCBleHBsYW5hdGlvbnMsIG1h eSBiZSBjb21wbGV0ZWx5IGJvZ3VzOgoKSSBub3cgaGF2ZSBzdWZmaWNpZW50IGluZm9ybWF0aW9u LiBMZXQgbWUgd3JpdGUgdGhlIGNvbXBsZXRlIGFuYWx5c2lzLgoKLS0tCgojIyBQSEFTRSAxOiBD T01NSVQgTUVTU0FHRSBGT1JFTlNJQ1MKCioqU3RlcCAxLjE6IFBhcnNlIHN1YmplY3QgbGluZSoq ClJlY29yZDogU3Vic3lzdGVtIGBpM2M6IG1hc3RlcjpgLCBhY3Rpb24gdmVyYiBgTW92ZWAgKHJl ZmFjdG9yaW5nKSwKc3VtbWFyeTogTW92ZSBidXNfaW5pdCBlcnJvciBzdXBwcmVzc2lvbiBmb3Ig RElTRUMgTTIgZXJyb3JzLgoKKipTdGVwIDEuMjogUGFyc2UgdGFncyoqClJlY29yZDoKLSBSZXZp ZXdlZC1ieTogRnJhbmsgTGkgPEZyYW5rLkxpQG54cC5jb20+Ci0gUmV2aWV3ZWQtYnk6IEFkcmlh biBIdW50ZXIgPGFkcmlhbi5odW50ZXJAaW50ZWwuY29tPgotIFNpZ25lZC1vZmYtYnk6IEpvcmdl IE1hcnF1ZXMgPGpvcmdlLm1hcnF1ZXNAYW5hbG9nLmNvbT4KLSBMaW5rOiBwYXRjaC5tc2dpZC5s aW5rLzIwMjYwMzIzLWFkNDA2Mi1wb3NpdGl2ZS1lcnJvci1maXgtdjMtMwotIFNpZ25lZC1vZmYt Ynk6IEFsZXhhbmRyZSBCZWxsb25pIChtYWludGFpbmVyKQotICoqTm8gUmVwb3J0ZWQtYnksIG5v IEZpeGVzOiwgbm8gQ2M6IHN0YWJsZSoqCgoqKlN0ZXAgMS4zOiBDb21taXQgYm9keSBhbmFseXNp cyoqClJlY29yZDogQm9keSBleHBsaWNpdGx5IHN0YXRlcyAiUHJlcGFyZSB0byBmaXggaW1wcm9w ZXIgTXggcG9zaXRpdmUKZXJyb3IgcHJvcGFnYXRpb24gaW4gbGF0ZXIgY29tbWl0cyIuIERlc2Ny aWJlcyBhZGRpbmcgYHN1cHByZXNzX20yYAphcmd1bWVudCB0byBgaTNjX21hc3Rlcl9lbmVjX2Rp c2VjX2xvY2tlZCgpYCBzbyBjYWxsZXJzIGRvbid0IG5lZWQgdG8KaGFuZGxlIHBvc2l0aXZlIE14 IGNvZGVzLiBObyBzdGFjayB0cmFjZXMsIG5vIGNyYXNoIGRlc2NyaXB0aW9uLCBubwp1c2VyLXZp c2libGUgc3ltcHRvbSBkZXNjcmliZWQuIFRoaXMgaXMgYXV0aG9yLWRlY2xhcmVkIHByZXBhcmF0 aW9uIGZvcgphIGZ1dHVyZSBmaXguCgoqKlN0ZXAgMS40OiBIaWRkZW4gYnVnIGZpeGVzKioKUmVj b3JkOiBOT1QgYSBoaWRkZW4gYnVnIGZpeCAtIHRoZSBhdXRob3IgZXhwbGljaXRseSBzYXlzICJQ cmVwYXJlIHRvCmZpeCAuLi4gaW4gbGF0ZXIgY29tbWl0cyIuIEZ1bmN0aW9uYWxseSB0aGlzIGlz IGEgbm8tb3A6IE0yIHdhcwpzdXBwcmVzc2VkIHZpYSBgcmV0ICE9IEkzQ19FUlJPUl9NMmAgYXQg Y2FsbHNpdGUgYmVmb3JlLCBub3cgdmlhCmBzdXBwcmVzc19tMj10cnVlYCBpbnNpZGUgdGhlIGhl bHBlci4KCiMjIFBIQVNFIDI6IERJRkYgQU5BTFlTSVMKCioqU3RlcCAyLjE6IEludmVudG9yeSoq ClJlY29yZDogU2luZ2xlIGZpbGUgYGRyaXZlcnMvaTNjL21hc3Rlci5jYCwgMTUgaW5zZXJ0aW9u cyAvIDggZGVsZXRpb25zLgpNb2RpZmllcyBzdGF0aWMgaGVscGVyIGBpM2NfbWFzdGVyX2VuZWNf ZGlzZWNfbG9ja2VkKClgIHNpZ25hdHVyZSwKdXBkYXRlcyAyIHN0YXRpYyB3cmFwcGVycyAoYGkz Y19tYXN0ZXJfZGlzZWNfbG9ja2VkYCwKYGkzY19tYXN0ZXJfZW5lY19sb2NrZWRgKSwgdXBkYXRl cyBvbmUgY2FsbHNpdGUgaW4KYGkzY19tYXN0ZXJfYnVzX2luaXQoKWAuCgoqKlN0ZXAgMi4yOiBD b2RlIGZsb3cqKgpSZWNvcmQ6Ci0gQmVmb3JlOiBgaTNjX21hc3Rlcl9idXNfaW5pdGAgY2FsbGVk IGBpM2NfbWFzdGVyX2Rpc2VjX2xvY2tlZGAgdGhlbgogIGNoZWNrZWQgYGlmIChyZXQgJiYgcmV0 ICE9IEkzQ19FUlJPUl9NMikgZ290byBlcnJgLgotIEFmdGVyOiBgaTNjX21hc3Rlcl9idXNfaW5p dGAgY2FsbHMgYGkzY19tYXN0ZXJfZW5lY19kaXNlY19sb2NrZWRgCiAgZGlyZWN0bHkgd2l0aCBg c3VwcHJlc3NfbTI9dHJ1ZWA7IHRoZSBoZWxwZXIgcmV0dXJucyAwIHdoZW4gY21kLmVyciA9PQog IEkzQ19FUlJPUl9NMjsgY2FsbHNpdGUganVzdCBjaGVja3MgYGlmIChyZXQpIGdvdG8gZXJyYC4K LSBOZXQgYmVoYXZpb3I6IEZ1bmN0aW9uYWxseSBpZGVudGljYWwgdW5kZXIgdGhlIGN1cnJlbnQg c3RhdGUgb2YKICBgaTNjX21hc3Rlcl9zZW5kX2NjY19jbWRfbG9ja2VkKClgLgoKKipTdGVwIDIu MzogQnVnIG1lY2hhbmlzbSoqClJlY29yZDogTm9uZSDigJQgdGhpcyBpcyAoaCkgcmVmYWN0b3Jp bmcgbW92aW5nIGxvZ2ljIGZyb20gY2FsbHNpdGUgdG8KY2FsbGVlLiBObyBidWcgY2xhc3MgZml4 ZWQgYnkgdGhpcyBjb21taXQgYWxvbmUuCgoqKlN0ZXAgMi40OiBRdWFsaXR5KioKUmVjb3JkOiBT bWFsbCwgc3VyZ2ljYWwsIHJldmlld2VkIGJ5IHR3byBtYWludGFpbmVycy4gUmlzazogbG93LiBC dXQgYnkKaXRzZWxmIG9mZmVycyBubyBmdW5jdGlvbmFsIGJlbmVmaXQg4oCUIGl0IG9ubHkgbWF0 dGVycyBpbiBjb25qdW5jdGlvbgp3aXRoIHBhdGNoIDQvNSB0aGF0IHN0b3BzIHByb3BhZ2F0aW5n IGNtZC0+ZXJyLgoKIyMgUEhBU0UgMzogR0lUIEhJU1RPUlkgSU5WRVNUSUdBVElPTgoKKipTdGVw IDMuMTogQmxhbWUqKgpSZWNvcmQ6IGBpM2NfbWFzdGVyX2VuZWNfZGlzZWNfbG9ja2VkKClgIGhh cyBiZWVuIHRoZSBpbXBsZW1lbnRhdGlvbiBvZgp0aGUgRElTRUMgaGVscGVyIHNpbmNlIHRoZSBp M2Mgc3Vic3lzdGVtIHdhcyBpbnRyb2R1Y2VkIGluIGNvbW1pdAozYTM3OWJiY2VhMGEgKCJpM2M6 IEFkZCBjb3JlIEkzQyBpbmZyYXN0cnVjdHVyZSIpLCB3aGljaCBpcyB2NC4xNy4KCioqU3RlcCAz LjI6IEZpeGVzIHRhZyoqClJlY29yZDogTm8gRml4ZXM6IHRhZyBvbiB0aGlzIGNvbW1pdC4gVGhl IHJlbGF0ZWQgZml4IGNvbW1pdCBpbiB0aGUKc2VyaWVzIChlZjhiNTIyOTM0OGYwICJpM2M6IG1h c3RlcjogRml4IGVycm9yIGNvZGVzIGF0IHNlbmRfY2NjX2NtZCIpCmhhcyBgRml4ZXM6IDNhMzc5 YmJjZWEwYWAg4oCUIHBvaW50aW5nIHRvIHRoZSBpbml0aWFsIGkzYyBjb21taXQuCgoqKlN0ZXAg My4zOiBGaWxlIGhpc3RvcnkqKgpSZWNvcmQ6IFRoaXMgY29tbWl0IGlzIHBhcnQgb2YgYSA1LXBh dGNoIHNlcmllcyAodjMpOgotIDEvNSBgMTlhMWI2MWZhNjIzN2AgIk1vdmUgcnN0ZGFhIGVycm9y IHN1cHByZXNzaW9uIiAocHJlcCkKLSAyLzUgYDQyMjQ3ZmZmYjMwNDRgICJNb3ZlIGVudGRhYSBl cnJvciBzdXBwcmVzc2lvbiIgKHByZXApCi0gKiozLzUgYDQ5Nzc1YWZhOTgzZTNgICJNb3ZlIGJ1 c19pbml0IGVycm9yIHN1cHByZXNzaW9uIiAoVEhJUyBDT01NSVQsCiAgcHJlcCkqKgotIDQvNSBg ZWY4YjUyMjkzNDhmMGAgIkZpeCBlcnJvciBjb2RlcyBhdCBzZW5kX2NjY19jbWQiICh0aGUgYWN0 dWFsIGZpeCkKLSA1LzUgYDBiNzNkYTk2YjZlYjZgICJhZGk6IEZpeCBlcnJvciBwcm9wYWdhdGlv biBmb3IgQ0NDcyIgKGFkaS0KICBzcGVjaWZpYyBmb2xsb3ctdXApCgpUaGUgZml4IGNvbW1pdCA0 LzUgZXhwbGljaXRseSBuYW1lcyB0aGlzIGNvbW1pdCBhcyBhIHByZXJlcXVpc2l0ZSBpbiBpdHMK bWVzc2FnZTogIlRoZSBwcmVyZXF1aXNpdGUgcGF0Y2hlcyBmb3IgdGhlIGZpeCBhcmU6IC4uLiBp M2M6IG1hc3RlcjoKTW92ZSBidXNfaW5pdCBlcnJvciBzdXBwcmVzc2lvbiIuCgoqKlN0ZXAgMy40 OiBBdXRob3IncyB3b3JrKioKUmVjb3JkOiBKb3JnZSBNYXJxdWVzIChBbmFsb2cgRGV2aWNlcykg aXMgY29udHJpYnV0b3Igb2YgdGhlCmFkaS1pM2MtbWFzdGVyIGRyaXZlcjsgbm90IHRoZSBpM2Mg Y29yZSBtYWludGFpbmVyLiBBbGV4YW5kcmUgQmVsbG9uaSBpcwp0aGUgaTNjIG1haW50YWluZXIg KHByb3ZpZGVkIGZpbmFsIFNPQikuIFRoZSBzZXJpZXMgd2FzIHJldmlld2VkIGJ5CkZyYW5rIExp IChOWFAsIGFjdGl2ZSBpM2MgcmV2aWV3ZXIpIGFuZCBBZHJpYW4gSHVudGVyIChJbnRlbCkuCgoq KlN0ZXAgMy41OiBEZXBlbmRlbmNpZXMqKgpSZWNvcmQ6IFRoaXMgY29tbWl0IGlzIGEgcHJlcmVx dWlzaXRlIGZvciBjb21taXQgNC81IG9mIHRoZSBzYW1lIHNlcmllcy4KV2l0aG91dCBhbGwgdGhy ZWUgcHJlcCBjb21taXRzICgxLzUsIDIvNSwgMy81KSwgY29tbWl0IDQvNSBjYXVzZXMgYQpyZWdy ZXNzaW9uLgoKIyMgUEhBU0UgNDogTUFJTElORyBMSVNUIFJFU0VBUkNICgoqKlN0ZXAgNC4xOiBP cmlnaW5hbCBzdWJtaXNzaW9uKioKUmVjb3JkOiBgYjQgZGlnIC1jIDQ5Nzc1YWZhOTgzZTNgIGZv dW5kIG9yaWdpbmFsIHN1Ym1pc3Npb24gYXQKaHR0cHM6Ly9wYXRjaC5tc2dpZC5saW5rLzIwMjYw MzIzLWFkNDA2Mi1wb3NpdGl2ZS1lcnJvci0KZml4LXYzLTMtMzBiZGM2ODAwNGJlQGFuYWxvZy5j b20uIFBhdGNoIGlzIHRoZSBmaW5hbCB2MyBvZiAzIHJldmlzaW9ucwoodjEg4oaSIHYyIOKGkiB2 MykuIENvdmVyIGxldHRlciBleHBsYWlucyB0aGUgc2VyaWVzIHdhcyB0cmlnZ2VyZWQgYnkgYQoq KlNtYXRjaCB3YXJuaW5nIG9uIGlpby9hZGMvYWQ0MDYyLmMqKiwgbm90IGEgdXNlci1yZXBvcnRl ZCBydW50aW1lCmNyYXNoLgoKKipTdGVwIDQuMjogUmV2aWV3ZXJzKioKUmVjb3JkOiBSZWNpcGll bnRzID0gQWxleGFuZHJlIEJlbGxvbmkgKG1haW50YWluZXIpLCBGcmFuayBMaSAoTlhQCnJldmll d2VyKSwgUHJ6ZW15c8WCYXcgR2FqIChDYWRlbmNlKS4gQ0M6IGxpbnV4LWkzYywgRGFuIENhcnBl bnRlcgooU21hdGNoIHJlcG9ydGVyKSwgSm9uYXRoYW4gQ2FtZXJvbiwgQWRyaWFuIEh1bnRlci4g Qm90aCBSZXZpZXdlZC1ieQp0YWdzIChGcmFuayBMaSwgQWRyaWFuIEh1bnRlcikgYXJlIGZyb20g Y3JlZGlibGUgcmV2aWV3ZXJzLgoKKipTdGVwIDQuMzogQnVnIHJlcG9ydCoqClJlY29yZDogQ2xv c2VzIGxpbmsgaW4gdGhlIGZpeCBjb21taXQgKHBhdGNoIDQvNSkgcG9pbnRzIHRvCmh0dHBzOi8v bG9yZS5rZXJuZWwub3JnL2xpbnV4LWlpby9hWVh2VDVGVzBoWFF3aG1fQHN0YW5sZXkubW91bnRh aW4vIOKAlApEYW4gQ2FycGVudGVyJ3MgU21hdGNoIHJlcG9ydC4gTm8gdXNlci1yZXBvcnRlZCBj cmFzaGVzLCBubyBzeXpib3QsIG5vCktBU0FOL0tNU0FOL0tDU0FOIHJlcG9ydC4gVGhlIGJ1ZyBp cyBzdGF0aWMtYW5hbHlzaXMtZGV0ZWN0ZWQgQVBJCmNvcnJlY3RuZXNzLgoKKipTdGVwIDQuNDog UmVsYXRlZCBwYXRjaGVzKioKUmVjb3JkOiBDb25maXJtZWQgYXMgcGFydCBvZiA1LXBhdGNoIHNl cmllcy4gUGF0Y2hlcyAxLzUsIDIvNSwgMy81IGFyZQpwcmVwYXJhdGlvbjsgcGF0Y2hlcyA0LzUs IDUvNSBhcmUgdGhlIGFjdHVhbCBmaXhlcy4gTm8gQ2M6IHN0YWJsZSBpbiBhbnkKdmVyc2lvbi4K CioqU3RlcCA0LjU6IFN0YWJsZSBtYWlsaW5nIGxpc3QqKgpSZWNvcmQ6IE5vIHN0YWJsZS1zcGVj aWZpYyBkaXNjdXNzaW9uIGZvdW5kIGluIHRoZSB0aHJlYWQuIE5vIHJldmlld2VyCnN1Z2dlc3Rl ZCBDYzogc3RhYmxlLgoKIyMgUEhBU0UgNTogQ09ERSBTRU1BTlRJQyBBTkFMWVNJUwoKKipTdGVw IDUuMTogRnVuY3Rpb25zKioKUmVjb3JkOiBgaTNjX21hc3Rlcl9lbmVjX2Rpc2VjX2xvY2tlZCgp YCAoc3RhdGljLCBzaWduYXR1cmUgY2hhbmdlKSwKYGkzY19tYXN0ZXJfZGlzZWNfbG9ja2VkKClg IChleHBvcnRlZCB3cmFwcGVyKSwKYGkzY19tYXN0ZXJfZW5lY19sb2NrZWQoKWAgKGV4cG9ydGVk IHdyYXBwZXIpLCBgaTNjX21hc3Rlcl9idXNfaW5pdCgpYAooY2FsbGVyIHVwZGF0ZWQpLgoKKipT dGVwIDUuMjogQ2FsbGVycyoqClJlY29yZDogYGkzY19tYXN0ZXJfYnVzX2luaXQoKWAgaXMgY2Fs bGVkIGZyb20gYGkzY19tYXN0ZXJfcmVnaXN0ZXIoKWAKZHVyaW5nIGRyaXZlciBwcm9iZSAoY29t bW9uIGhhcmR3YXJlIGluaXQgcGF0aCkuCmBpM2NfbWFzdGVyX2Rpc2VjX2xvY2tlZCgpYC9gaTNj X21hc3Rlcl9lbmVjX2xvY2tlZCgpYCBhcmUgZXhwb3J0ZWQgYW5kCmNhbGxlZCBmcm9tIGNvbnRy b2xsZXIgZHJpdmVycyAoZHcsIHN2YywgY2RucywgbWlwaS1oY2ksIHJlbmVzYXMsIGFkaSkKZm9y IGVuYWJsZS9kaXNhYmxlIGliaSBvcGVyYXRpb25zLgoKKipTdGVwIDUuMzogQ2FsbGVlcyoqClJl Y29yZDogYGkzY19tYXN0ZXJfc2VuZF9jY2NfY21kX2xvY2tlZCgpYCBkZWxlZ2F0ZXMgdG8KYG1h c3Rlci0+b3BzLT5zZW5kX2NjY19jbWQoKWAuIEluIHRoZSBjdXJyZW50IHN0YWJsZSBwcmUtZml4 IHN0YXRlLCBpdApzdGlsbCByZXR1cm5zIHBvc2l0aXZlIE14IGNvZGVzOyBhZnRlciB0aGUgc2Vy aWVzJyBwYXRjaCA0LzUsIGl0IHJldHVybnMKMC9uZWdhdGl2ZSBvbmx5LgoKKipTdGVwIDUuNDog UmVhY2hhYmlsaXR5KioKUmVjb3JkOiBCdXMgaW5pdCBwYXRoIGlzIHJlYWNoYWJsZSBhdCBldmVy eSBJM0MgbWFzdGVyIGRldmljZSBwcm9iZSDigJQKcnVucyBvbiBldmVyeSBib290L2luaXQgd2l0 aCBJM0MgaGFyZHdhcmUuCgoqKlN0ZXAgNS41OiBTaW1pbGFyIHBhdHRlcm5zKioKUmVjb3JkOiBU d28gc2libGluZyBwcmVwYXJhdGlvbiBjb21taXRzICgxLzUgcnN0ZGFhLCAyLzUgZW50ZGFhKSBm b2xsb3cKaWRlbnRpY2FsIHBhdHRlcm4gb2YgbW92aW5nIE0yIHN1cHByZXNzaW9uIGludG8gaGVs cGVyIGZ1bmN0aW9ucy4KCiMjIFBIQVNFIDY6IENST1NTLVJFRkVSRU5DSU5HIEFORCBTVEFCTEUg VFJFRSBBTkFMWVNJUwoKKipTdGVwIDYuMTogQ29kZSBleGlzdHMgaW4gc3RhYmxlPyoqClJlY29y ZDogVGhlIGBpM2NfbWFzdGVyX2VuZWNfZGlzZWNfbG9ja2VkKClgIGhlbHBlciBhbmQgaXRzIE0y LWhhbmRsaW5nCmNhbGwgc2l0ZSBpbiBgaTNjX21hc3Rlcl9idXNfaW5pdCgpYCBleGlzdCBlc3Nl bnRpYWxseSB1bmNoYW5nZWQgc2luY2UKdjQuMTcuIFRoZSBidWdneSBNMi1wcm9wYWdhdGlvbiBw YXR0ZXJuIGV4aXN0cyBpbiBldmVyeSBhY3RpdmUgc3RhYmxlCnRyZWUuCgoqKlN0ZXAgNi4yOiBC YWNrcG9ydCBkaWZmaWN1bHR5KioKUmVjb3JkOiBXb3VsZCBhcHBseSB3aXRoIG1pbm9yIGNvbmZs aWN0cyB0byBvbGRlciBzdGFibGVzIGR1ZSB0bwp1bnJlbGF0ZWQgY2h1cm4gaW4gYnVzX2luaXQu CgoqKlN0ZXAgNi4zOiBSZWxhdGVkIGZpeGVzIGluIHN0YWJsZSoqClJlY29yZDogKipDcml0aWNh bCBvYnNlcnZhdGlvbioqIOKAlCBpbiB0aGUgc3RhYmxlIGNhbmRpZGF0ZSBicmFuY2ggdW5kZXIK ZXZhbHVhdGlvbiwgdGhlIHNlcmllcycgZml4IGNvbW1pdCAocGF0Y2ggNC81KSBpcyBwcmVzZW50 IGJ1dCB0aGlzCnByZXBhcmF0aW9uIGNvbW1pdCAoMy81KSBhbmQgdGhlIG90aGVyIHR3byBwcmVw YXJhdGlvbiBjb21taXRzICgxLzUsCjIvNSkgYXJlIE5PVC4gSSB2ZXJpZmllZCBgaTNjX21hc3Rl cl9idXNfaW5pdCgpYCBpbiB0aGUgc3RhYmxlIGJyYW5jaApzdGF0ZSBzdGlsbCBoYXMgYGlmIChy ZXQgJiYgcmV0ICE9IEkzQ19FUlJPUl9NMilgIGF0IHRoZSBESVNFQyBjYWxsc2l0ZS4KQmVjYXVz ZSB0aGUgZml4IDQvNSBzdG9wcyBgaTNjX21hc3Rlcl9zZW5kX2NjY19jbWRfbG9ja2VkKClgIGZy b20KcmV0dXJuaW5nIHBvc2l0aXZlIE0yLCB0aGUgZHJpdmVyJ3MgdW5kZXJseWluZyBgLUVJT2Av YC1FVElNRURPVVRgIG5vdwpwcm9wYWdhdGVzLiBUaGF0IHZhbHVlIGAhPSBJM0NfRVJST1JfTTJg LCBzbyB0aGUgY2hlY2sgZmFpbHMgYW5kCmJ1c19pbml0IGFib3J0cyB3aGVuIG5vIEkzQyBkZXZp Y2UgYWNrcyBESVNFQyDigJQgdGhpcyBpcyBleGFjdGx5IHRoZSAibm8KYWN0aXZlIGRldmljZXMg b24gdGhlIGJ1cyIgY2FzZSB0aGF0IE0yIGlzIG1lYW50IHRvIGluZGljYXRlLiBUaGlzIGlzIGEK KipyZWFsIHJlZ3Jlc3Npb24qKiB0aGF0IHRoZSBwcmVwIGNvbW1pdHMgcHJldmVudC4KCiMjIFBI QVNFIDc6IFNVQlNZU1RFTSBBTkQgTUFJTlRBSU5FUiBDT05URVhUCgoqKlN0ZXAgNy4xOiBTdWJz eXN0ZW0qKgpSZWNvcmQ6IGBkcml2ZXJzL2kzYy9gIOKAlCBJM0MgYnVzIHN1YnN5c3RlbS4gQ3Jp dGljYWxpdHk6IFBFUklQSEVSQUwKKGFmZmVjdHMgc3lzdGVtcyB3aXRoIEkzQyBoYXJkd2FyZSBv bmx5LCBhIHJlbGF0aXZlbHkgbmljaGUgYnV0IGdyb3dpbmcKYnVzKSwgYnV0IG9uIHRob3NlIHN5 c3RlbXMgYnVzX2luaXQgaXMgbWFuZGF0b3J5IHNvIGltcGFjdCBpcyAxMDAlIG9mCmFmZmVjdGVk IHVzZXJzLgoKKipTdGVwIDcuMjogQWN0aXZpdHkqKgpSZWNvcmQ6IEFjdGl2ZSBzdWJzeXN0ZW0s IG1vZGVyYXRlIGNodXJuLCBuZXcgY29udHJvbGxlciBkcml2ZXJzIGJlaW5nCmFkZGVkLgoKIyMg UEhBU0UgODogSU1QQUNUIEFORCBSSVNLIEFTU0VTU01FTlQKCioqU3RlcCA4LjE6IEFmZmVjdGVk IHVzZXJzKioKUmVjb3JkOiBBbnkgc3RhYmxlIHN5c3RlbSBydW5uaW5nIGFuIEkzQyBjb250cm9s bGVyIGRyaXZlci4gQnVzIGluaXQKcnVucyBvbiBldmVyeSBwcm9iZS4KCioqU3RlcCA4LjI6IFRy aWdnZXIgY29uZGl0aW9ucyoqClJlY29yZDogVGhpcyBjb21taXQgYWxvbmUgaGFzIG5vIHRyaWdn ZXIgKG5vIGJlaGF2aW9yIGNoYW5nZSkuIFRoZQpzY2VuYXJpbyBpdCBhZGRyZXNzZXM6IGJ1c19p bml0IHdoZW4gbm8gYWN0aXZlIEkzQyBkZXZpY2UgYWNrbm93bGVkZ2VzCkRJU0VDIGJyb2FkY2Fz dC4gVmVyeSBjb21tb24gZHVyaW5nIGVhcmx5IGJvb3Qgb2YgSTNDIGNvbnRyb2xsZXJzIHdoZXJl CmRldmljZXMgbWF5IGJlIHBvd2VyZWQgb2ZmIG9yIGFic2VudC4KCioqU3RlcCA4LjM6IEZhaWx1 cmUgbW9kZSoqClJlY29yZDogSW4gaXNvbGF0aW9uLCB0aGlzIGNvbW1pdCBjaGFuZ2VzIG5vdGhp bmcuIFdoZW4gdGFrZW4gdG9nZXRoZXIKd2l0aCBwYXRjaCA0LzUgKHRoZSBhY3R1YWwgZml4KSwg aXRzIGFic2VuY2UgY2F1c2VzIGJ1c19pbml0IHRvIGZhaWwgYW5kCnRoZSBJM0MgY29udHJvbGxl ciB0byBmYWlsIHRvIHByb2JlLiBTZXZlcml0eSBpbiB0aGF0IGNvbWJpbmVkIHNjZW5hcmlvOgpI SUdIIChib290LXRpbWUgcHJvYmUgZmFpbHVyZSkuCgoqKlN0ZXAgOC40OiBSaXNrLWJlbmVmaXQq KgpSZWNvcmQ6Ci0gU3RhbmRhbG9uZSBiZW5lZml0OiB6ZXJvIChubyBidWcgZml4ZWQgYnkgaXRz ZWxmKS4KLSBTZXJpZXMtbGV2ZWwgYmVuZWZpdDogUHJldmVudHMgYSByZWdyZXNzaW9uIGluIHRo ZSBmaXgtZm9yLXN0YWJsZS4KICBXaXRob3V0IGl0LCB0aGUgZml4IGJyZWFrcyBidXNfaW5pdC4K LSBSaXNrOiB2ZXJ5IGxvdyAoMTUvOCBsaW5lcywgc3RhdGljIGhlbHBlciwgZnVuY3Rpb25hbGx5 IGVxdWl2YWxlbnQgdG8KICBwcmlvciBjb2RlKS4KCiMjIFBIQVNFIDk6IEZJTkFMIFNZTlRIRVNJ UwoKKipTdGVwIDkuMTogRXZpZGVuY2UqKgpGT1IgYmFja3BvcnRpbmc6Ci0gSXQgaXMgYW4gZXhw bGljaXQsIGF1dGhvci1uYW1lZCBwcmVyZXF1aXNpdGUgZm9yIHBhdGNoIDQvNSAoImkzYzoKICBt YXN0ZXI6IEZpeCBlcnJvciBjb2RlcyBhdCBzZW5kX2NjY19jbWQiKSwgd2hpY2ggaXMgaXRzZWxm IGEgcmVhbCBidWcKICBmaXggKFNtYXRjaC1yZXBvcnRlZCwgRml4ZXM6IHRoZSBpbml0aWFsIGkz YyBjb3JlIGNvbW1pdCwgYWZmZWN0cyBhbgogIGV4cG9ydGVkIEFQSSBjb250cmFjdCkuCi0gV2l0 aG91dCB0aGlzIGNvbW1pdCwgYXBwbHlpbmcgcGF0Y2ggNC81IHRvIHN0YWJsZSBjYXVzZXMgYSBy ZWdyZXNzaW9uCiAgYXQgYnVzX2luaXQgKHZlcmlmaWVkIGJ5IGluc3BlY3RpbmcgYGkzY19tYXN0 ZXJfYnVzX2luaXQoKWAgaW4gdGhlCiAgc3RhYmxlIGJyYW5jaCBzdGF0ZSDigJQgdGhlIGByZXQg IT0gSTNDX0VSUk9SX00yYCBjaGVjayBzdGlsbCBwcmVzZW50LAogIGJ1dCBgcmV0YCB3aWxsIG5v IGxvbmdlciBldmVyIGJlIHBvc2l0aXZlIEkzQ19FUlJPUl9NMiwgc28gdGhlIGNoZWNrCiAgYWx3 YXlzIGZhaWxzIGludG8gZXJyb3IgcGF0aCkuCi0gU21hbGwsIGNvbnRhaW5lZCAoMjMgbGluZXMg aW4gb25lIGZpbGUpLCByZXZpZXdlZCBieSB0d28gaTNjIHJldmlld2VycwogIGluY2x1ZGluZyBB ZHJpYW4gSHVudGVyLgotIFRvdWNoZXMgb25seSBhIHN0YXRpYyBoZWxwZXIgYW5kIGEgc2luZ2xl IGNhbGxzaXRlOyByaXNrIGlzIG1pbmltYWwuCgpBR0FJTlNUIGJhY2twb3J0aW5nOgotIEJ5IGl0 cyBvd24gY29tbWl0IG1lc3NhZ2UsIGl0IGlzIGV4cGxpY2l0bHkgYSBwcmVwYXJhdGlvbi9yZWZh Y3RvcgogIHRoYXQgInByZXBhcmVzIHRvIGZpeCBpbiBsYXRlciBjb21taXRzIiwgd2l0aCBubyBz dGFuZGFsb25lIGJ1ZyBmaXgg4oCUCiAgYSBjYW5vbmljYWwgU1RST05HIE5PIHNpZ25hbCBwZXIg dGhlIGd1aWRlbGluZXMuCi0gTm8gQ2M6IHN0YWJsZSwgbm8gUmVwb3J0ZWQtYnksIG5vIEZpeGVz OiB0YWcgb24gdGhpcyBjb21taXQgaXRzZWxmLgotIElmIGF1dG9zZWwgc2VsZWN0cyB0aGlzIGJ1 dCBub3QgcGF0Y2ggNC81LCBpdCBwcm92aWRlcyB6ZXJvIGJlbmVmaXQKICAocHVyZSByZWZhY3Rv cmluZyBpbiBzdGFibGUpLgotIFRoZSBvcmlnaW5hbCBidWcncyBzZXZlcml0eSBpcyBtZWRpdW0g KEFQSS1jb250cmFjdCBjb3JyZWN0bmVzcywKICBTbWF0Y2gtZm91bmQsIG5vIHVzZXIgcnVudGlt ZSByZXBvcnQpLgoKKipTdGVwIDkuMjogU3RhYmxlIHJ1bGVzIGNoZWNrbGlzdCoqCjEuIE9idmlv dXNseSBjb3JyZWN0IGFuZCB0ZXN0ZWQ6IFlFUyAocmV2aWV3ZWQsIG1pbm9yIHJlZmFjdG9yLAog ICBtYWlubGluZS10ZXN0ZWQpCjIuIEZpeGVzIGEgcmVhbCBidWc6IE5PIG9uIGl0cyBvd24uIFlF UyBvbmx5IHRyYW5zaXRpdmVseSBhcyBwcmVyZXEgdG8KICAgNC81LgozLiBJbXBvcnRhbnQgaXNz dWU6IE5PIHN0YW5kYWxvbmUuIE1lZGl1bSBpbiBzZXJpZXMuCjQuIFNtYWxsIGFuZCBjb250YWlu ZWQ6IFlFUyAoc2luZ2xlIGZpbGUsIH4yMyBsaW5lcykKNS4gTm8gbmV3IGZlYXR1cmVzL0FQSXM6 IFlFUyAoc3RhdGljIGhlbHBlciBzaWduYXR1cmUgb25seSkKNi4gQXBwbGllcyBjbGVhbmx5OiBZ RVMgd2l0aCBtaW5vciBjb250ZXh0IGFkanVzdG1lbnRzCgoqKlN0ZXAgOS4zOiBFeGNlcHRpb24g Y2F0ZWdvcmllcyoqClJlY29yZDogTm9uZSBhcHBseSDigJQgbm90IGEgZGV2aWNlIElELCBxdWly aywgRFQsIGJ1aWxkIGZpeCwgb3IgZG9jIGZpeC4KCioqU3RlcCA5LjQ6IERlY2lzaW9uKioKVGhp cyBpcyBhIGdlbnVpbmVseSBib3JkZXJsaW5lICJwYXRjaCAzLzUgaXMgYSBwcmVwYXJhdGlvbiBj b21taXQiIGNhc2UuClRoZSBzdHJpY3QgcmVhZGluZyBvZiBzdGFibGUgcnVsZXMgbWFya3MgcHJl cGFyYXRpb24gY29tbWl0cyBhcyBTVFJPTkcKTk8uIEhvd2V2ZXIsIHRoZSBndWlkZWxpbmVzIGFs c28gZXhwbGljaXRseSBjYWxsIG91dCBpbmNvbXBsZXRlIGZpeApzZXJpZXMgYXMgYm9yZGVybGlu ZSBjYXNlcyByZXF1aXJpbmcgZGVwZW5kZW5jeSBhbmFseXNpcy4gTXkKdmVyaWZpY2F0aW9uIHNo b3dzOgoKMS4gUGF0Y2ggNC81IG9mIHRoZSBzZXJpZXMgaXMgdGhlIGFjdHVhbCBidWcgZml4IHRh cmdldGluZyBhIHJlYWwgKGlmCiAgIG1lZGl1bS1zZXZlcml0eSkgQVBJLWNvbnRyYWN0IGJ1ZyB0 aGF0IGhhcyBleGlzdGVkIHNpbmNlIGkzYyB3YXMKICAgaW50cm9kdWNlZC4KMi4gUGF0Y2ggNC81 ICoqY2Fubm90IGJlIGJhY2twb3J0ZWQgc2FmZWx5IHdpdGhvdXQgdGhpcyBwcmVyZXF1aXNpdGUq KiDigJQKICAgSSB2ZXJpZmllZCB0aGUgcmVzdWx0aW5nIGJ1c19pbml0IGNvZGUgd291bGQgcmVn cmVzcyAoZHJpdmVyLXJldHVybmVkCiAgIGAtRUlPYCBmYWxscyBpbnRvIHRoZSBlcnJvciBwYXRo IHdoZW4gdGhlIG9sZCBjb2RlIHJlbGllZCBvbiBwb3NpdGl2ZQogICBNMiBwcm9wYWdhdGlvbiB0 byB0YWtlIHRoZSAibm8gZGV2aWNlcyIgaGFwcHkgcGF0aCkuCjMuIFRoZSBjb3N0IG9mIGluY2x1 ZGluZyB0aGlzIHByZXAgY29tbWl0IGlzIG5lZ2xpZ2libGUgKHB1cmUgcmVmYWN0b3IsCiAgIHJl dmlld2VkLCBzbWFsbCBzY29wZSkuCjQuIFRoZSBjb3N0IG9mIGV4Y2x1ZGluZyBpdCwgaWYgcGF0 Y2ggNC81IGlzIHNlbGVjdGVkLCBpcyBhIGJvb3QvcHJvYmUKICAgcmVncmVzc2lvbiBmb3IgSTND LWVuYWJsZWQgc3lzdGVtcy4KCkdpdmVuIHRoZSBjbGVhciB0cmFuc2l0aXZlIHZhbHVlIChwcmV2 ZW50aW5nIGEgcmVncmVzc2lvbiBpbiBhbgphY2NvbXBhbnlpbmcgZml4KSBhbmQgdGhlIG1pbmlt YWwgcmlzayBwcm9maWxlLCB0aGlzIHNob3VsZCB0cmF2ZWwgd2l0aAppdHMgZml4IHNlcmllcyBy YXRoZXIgdGhhbiBiZSBldmFsdWF0ZWQgaW4gaXNvbGF0aW9uLgoKLS0tCgojIyBWZXJpZmljYXRp b24KCi0gW1BoYXNlIDFdIFBhcnNlZCB0YWdzIGZyb20gY29tbWl0IG1lc3NhZ2U6IHR3byBSZXZp ZXdlZC1ieSAoRnJhbmsgTGkKICBOWFAsIEFkcmlhbiBIdW50ZXIgSW50ZWwpLCB0d28gU09CIChh dXRob3IgKyBtYWludGFpbmVyIEJlbGxvbmkpLCBMaW5rCiAgdG8gbG9yZS9wYXRjaC5tc2dpZC4g Tm8gRml4ZXM6LCBubyBDYzogc3RhYmxlLCBubyBSZXBvcnRlZC1ieS4KLSBbUGhhc2UgMV0gQ29t bWl0IGJvZHkgZXhwbGljaXRseSBzdGF0ZXMgIlByZXBhcmUgdG8gZml4IGltcHJvcGVyIE14CiAg cG9zaXRpdmUgZXJyb3IgcHJvcGFnYXRpb24gaW4gbGF0ZXIgY29tbWl0cyIg4oCUIGF1dGhvci1k ZWNsYXJlZAogIHByZXBhcmF0aW9uLgotIFtQaGFzZSAyXSBEaWZmIGludmVudG9yeTogc2luZ2xl IGZpbGUsIDE1Ky84LSwgbW9kaWZpZXMgb25lIHN0YXRpYwogIGhlbHBlciArIDIgc3RhdGljIHdy YXBwZXJzICsgMSBjYWxsc2l0ZS4gQ29uZmlybWVkIGZ1bmN0aW9uYWwKICBlcXVpdmFsZW5jZSB1 bmRlciBjdXJyZW50IGBpM2NfbWFzdGVyX3NlbmRfY2NjX2NtZF9sb2NrZWQoKWAgYmVoYXZpb3Iu Ci0gW1BoYXNlIDNdIGBnaXQgbG9nIC0tb25lbGluZSAtLSBkcml2ZXJzL2kzYy9tYXN0ZXIuY2Ag Y29uZmlybWVkCiAgcmVjZW50LWZpbGUgaGlzdG9yeTsgdGhpcyBjb21taXQgaXMgbm90IHlldCB2 aXNpYmxlIHZpYSBIRUFEJ3MKICByZWFjaGFibGUgaGlzdG9yeSAob25seSBpbiBidXMtbmV4dCku Ci0gW1BoYXNlIDNdIGBnaXQgYnJhbmNoIC0tY29udGFpbnMgNDk3NzVhZmE5ODNlM2Ag4oaSIGBi dXMtbmV4dGA7IHNhbWUgZm9yCiAgcGF0Y2hlcyAxLzUgYW5kIDIvNS4gYGdpdCBicmFuY2ggLS1j b250YWlucyAxOGRiNTM3OTNkNzg3YCDihpIgYGZvci0KICBncmVnLzcuMC0xMDBgIChzdGFibGUg Y2FuZGlkYXRlIGJyYW5jaCkg4oCUIHRoZSBmaXggaXMgYmVpbmcgcHJlcGFyZWQKICBmb3Igc3Rh YmxlIGJ1dCB0aGUgcHJlcmVxcyBhcmUgTk9UIGluIHRoYXQgYnJhbmNoLgotIFtQaGFzZSAzXSBg Z2l0IHNob3cgZWY4YjUyMjkzNDhmMGAgY29uZmlybWVkIHRoZSBmaXggY29tbWl0IGV4cGxpY2l0 bHkKICBuYW1lcyB0aGlzIGNvbW1pdCBpbiB0aGUgcHJlcmVxdWlzaXRlIGxpc3QgaW5zaWRlIGl0 cyBib2R5LgotIFtQaGFzZSA0XSBgYjQgZGlnIC1jIDQ5Nzc1YWZhOTgzZTNgIHJldHVybmVkIHRo ZSBsb3JlIFVSTAogIGh0dHBzOi8vcGF0Y2gubXNnaWQubGluay8yMDI2MDMyMy1hZDQwNjItcG9z aXRpdmUtZXJyb3ItCiAgZml4LXYzLTMtMzBiZGM2ODAwNGJlQGFuYWxvZy5jb20uCi0gW1BoYXNl IDRdIGBiNCBkaWcgLWMgNDk3NzVhZmE5ODNlMyAtYWAgc2hvd2VkIHRocmVlIHNlcmllcyByZXZp c2lvbnMKICAodjEg4oaSIHYyIOKGkiB2Myk7IHRoZSBhcHBsaWVkIHZlcnNpb24gaXMgdGhlIGxh dGVzdC4KLSBbUGhhc2UgNF0gYGI0IGRpZyAtYyA0OTc3NWFmYTk4M2UzIC1tYCBzYXZlZCB0aHJl YWQ7IHJlYWQgY292ZXIgbGV0dGVyCiAg4oCUIHNlcmllcyB3YXMgdHJpZ2dlcmVkIGJ5IERhbiBD YXJwZW50ZXIncyBTbWF0Y2ggd2FybmluZyBvbgogIGlpby9hZGMvYWQ0MDYyOyBubyBDYzogc3Rh YmxlIHJlcXVlc3RlZCBieSBhdXRob3Igb3IgcmV2aWV3ZXJzLgotIFtQaGFzZSA0XSBHcmVwcGVk IG1ib3ggZm9yIGBzdGFibGVAfENjOi4qc3RhYmxlYCDigJQgbm8gaGl0cyByZWxhdGVkIHRvCiAg c3RhYmxlIG5vbWluYXRpb24uCi0gW1BoYXNlIDVdIENvbmZpcm1lZCBieSByZWFkaW5nIHRoZSBm aWxlOgogIGBpM2NfbWFzdGVyX2VuZWNfZGlzZWNfbG9ja2VkYCBpcyBzdGF0aWMgYW5kIG9ubHkg aW52b2tlZCB2aWEKICBgaTNjX21hc3Rlcl9kaXNlY19sb2NrZWRgL2BpM2NfbWFzdGVyX2VuZWNf bG9ja2VkYC4KLSBbUGhhc2UgNl0gYGdpdCBzaG93IDE4ZGI1Mzc5M2Q3ODc6ZHJpdmVycy9pM2Mv bWFzdGVyLmNgIGNvbmZpcm1lZAogIGJ1c19pbml0IGluIHRoZSBzdGFibGUtY2FuZGlkYXRlIGJy YW5jaCBzdGlsbCBjb250YWlucyBgaWYgKHJldCAmJiByZXQKICAhPSBJM0NfRVJST1JfTTIpYCBh dCB0aGUgRElTRUMgY2FsbCDigJQgdmVyaWZpZXMgdGhlIHJlZ3Jlc3Npb24gc2NlbmFyaW8KICBp ZiBwcmVyZXEgaXMgb21pdHRlZC4KLSBbUGhhc2UgNl0gQ3Jvc3MtcmVmZXJlbmNlZCBzZXJpZXMg Y292ZXIgbGV0dGVyOiBjb250cm9sbGVycyByZXR1cm4KICBgLUVJT2AvYC1FSU5WQUxgIG9uIE0y IE5BQ0sg4oCUIGNvbmZpcm1zIHJlZ3Jlc3Npb24gcGF0aC4KLSBbUGhhc2UgOF0gU2V2ZXJpdHkg YXNzZXNzbWVudCBiYXNlZCBvbiB2ZXJpZmllZCBkZXBlbmRlbmN5OiBISUdIIChib290CiAgcHJv YmUgZmFpbHVyZSkgaWYgZml4IDQvNSBnb2VzIHdpdGhvdXQgdGhpczsgemVybyBpbXBhY3QgaW4g aXNvbGF0aW9uLgotIFVOVkVSSUZJRUQ6IENvdWxkIG5vdCBmZXRjaCB0aGUgbG9yZSB0aHJlYWQg ZGlyZWN0bHkgb3ZlciBIVFRQIChBbnViaXMKICBib3QtY2hhbGxlbmdlIGJsb2NrZWQgV2ViRmV0 Y2gpLCBidXQgYjQgZGlnIHJldHJpZXZlZCB0aGUgZnVsbCBtYm94CiAgZm9yIGFuYWx5c2lzIGlu c3RlYWQuCi0gVU5WRVJJRklFRDogRGlkIG5vdCB0ZXN0IGJhY2twb3J0IGFwcGx5IHRvIHNwZWNp ZmljIHN0YWJsZSBrZXJuZWxzCiAgKDYuMSwgNi42LCA2LjEyKSDigJQgc3RhdGVkICJtaW5vciBj b25mbGljdHMiIGJhc2VkIG9uIGZpbGUgY2h1cm4KICBvYnNlcnZhdGlvbiBvbmx5LgoKLS0tCgpU aGlzIGNvbW1pdCBpcyBleHBsaWNpdGx5IGEgcHJlcGFyYXRpb24vcmVmYWN0b3Igd2l0aCBubyBz dGFuZGFsb25lIGJ1ZwpmaXgg4oCUIHRoZSBjYW5vbmljYWwgIlNUUk9ORyBOTyIgcGF0dGVybiBp biBzdGFibGUgcnVsZXMuIEhvd2V2ZXIsIGl0IGlzCmEgKipuYW1lZCwgZG9jdW1lbnRlZCBwcmVy ZXF1aXNpdGUqKiBmb3IgYSBidWctZml4IGNvbW1pdCBpbiB0aGUgc2FtZQo1LXBhdGNoIHNlcmll cywgYW5kIEkgaGF2ZSB2ZXJpZmllZCB0aGF0IGFwcGx5aW5nIHRoYXQgZml4IHdpdGhvdXQgdGhp cwpwcmVwYXJhdGlvbiB3b3VsZCBjYXVzZSBhIHJlYWwgcmVncmVzc2lvbiBhdCBJM0MgYnVzIGlu aXQgKGEgY29tbW9uCmJvb3QtcGF0aCBjb2RlIHBhdGgpLiBTdGFibGUgc2FuaXR5IGRlbWFuZHMg dGhlIHNlcmllcyB0cmF2ZWxzIGFzIGEgdW5pdApvciBub3QgYXQgYWxsLgoKKipZRVMqKgoKIGRy aXZlcnMvaTNjL21hc3Rlci5jIHwgMjMgKysrKysrKysrKysrKysrLS0tLS0tLS0KIDEgZmlsZSBj aGFuZ2VkLCAxNSBpbnNlcnRpb25zKCspLCA4IGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL2Ry aXZlcnMvaTNjL21hc3Rlci5jIGIvZHJpdmVycy9pM2MvbWFzdGVyLmMKaW5kZXggOWU2YmU0OWJl YmIyYy4uYjkxZGMxZTczNGVkOCAxMDA2NDQKLS0tIGEvZHJpdmVycy9pM2MvbWFzdGVyLmMKKysr IGIvZHJpdmVycy9pM2MvbWFzdGVyLmMKQEAgLTEwNTEsNyArMTA1MSw4IEBAIGludCBpM2NfbWFz dGVyX2VudGRhYV9sb2NrZWQoc3RydWN0IGkzY19tYXN0ZXJfY29udHJvbGxlciAqbWFzdGVyKQog RVhQT1JUX1NZTUJPTF9HUEwoaTNjX21hc3Rlcl9lbnRkYWFfbG9ja2VkKTsKIAogc3RhdGljIGlu dCBpM2NfbWFzdGVyX2VuZWNfZGlzZWNfbG9ja2VkKHN0cnVjdCBpM2NfbWFzdGVyX2NvbnRyb2xs ZXIgKm1hc3RlciwKLQkJCQkJdTggYWRkciwgYm9vbCBlbmFibGUsIHU4IGV2dHMpCisJCQkJCXU4 IGFkZHIsIGJvb2wgZW5hYmxlLCB1OCBldnRzLAorCQkJCQlib29sIHN1cHByZXNzX20yKQogewog CXN0cnVjdCBpM2NfY2NjX2V2ZW50cyAqZXZlbnRzOwogCXN0cnVjdCBpM2NfY2NjX2NtZF9kZXN0 IGRlc3Q7CkBAIC0xMDcxLDYgKzEwNzIsOSBAQCBzdGF0aWMgaW50IGkzY19tYXN0ZXJfZW5lY19k aXNlY19sb2NrZWQoc3RydWN0IGkzY19tYXN0ZXJfY29udHJvbGxlciAqbWFzdGVyLAogCXJldCA9 IGkzY19tYXN0ZXJfc2VuZF9jY2NfY21kX2xvY2tlZChtYXN0ZXIsICZjbWQpOwogCWkzY19jY2Nf Y21kX2Rlc3RfY2xlYW51cCgmZGVzdCk7CiAKKwlpZiAoc3VwcHJlc3NfbTIgJiYgcmV0ICYmIGNt ZC5lcnIgPT0gSTNDX0VSUk9SX00yKQorCQlyZXQgPSAwOworCiAJcmV0dXJuIHJldDsKIH0KIApA QCAtMTA5MSw3ICsxMDk1LDcgQEAgc3RhdGljIGludCBpM2NfbWFzdGVyX2VuZWNfZGlzZWNfbG9j a2VkKHN0cnVjdCBpM2NfbWFzdGVyX2NvbnRyb2xsZXIgKm1hc3RlciwKIGludCBpM2NfbWFzdGVy X2Rpc2VjX2xvY2tlZChzdHJ1Y3QgaTNjX21hc3Rlcl9jb250cm9sbGVyICptYXN0ZXIsIHU4IGFk ZHIsCiAJCQkgICAgdTggZXZ0cykKIHsKLQlyZXR1cm4gaTNjX21hc3Rlcl9lbmVjX2Rpc2VjX2xv Y2tlZChtYXN0ZXIsIGFkZHIsIGZhbHNlLCBldnRzKTsKKwlyZXR1cm4gaTNjX21hc3Rlcl9lbmVj X2Rpc2VjX2xvY2tlZChtYXN0ZXIsIGFkZHIsIGZhbHNlLCBldnRzLCBmYWxzZSk7CiB9CiBFWFBP UlRfU1lNQk9MX0dQTChpM2NfbWFzdGVyX2Rpc2VjX2xvY2tlZCk7CiAKQEAgLTExMTIsNyArMTEx Niw3IEBAIEVYUE9SVF9TWU1CT0xfR1BMKGkzY19tYXN0ZXJfZGlzZWNfbG9ja2VkKTsKIGludCBp M2NfbWFzdGVyX2VuZWNfbG9ja2VkKHN0cnVjdCBpM2NfbWFzdGVyX2NvbnRyb2xsZXIgKm1hc3Rl ciwgdTggYWRkciwKIAkJCSAgIHU4IGV2dHMpCiB7Ci0JcmV0dXJuIGkzY19tYXN0ZXJfZW5lY19k aXNlY19sb2NrZWQobWFzdGVyLCBhZGRyLCB0cnVlLCBldnRzKTsKKwlyZXR1cm4gaTNjX21hc3Rl cl9lbmVjX2Rpc2VjX2xvY2tlZChtYXN0ZXIsIGFkZHIsIHRydWUsIGV2dHMsIGZhbHNlKTsKIH0K IEVYUE9SVF9TWU1CT0xfR1BMKGkzY19tYXN0ZXJfZW5lY19sb2NrZWQpOwogCkBAIC0yMTAyLDEx ICsyMTA2LDE0IEBAIHN0YXRpYyBpbnQgaTNjX21hc3Rlcl9idXNfaW5pdChzdHJ1Y3QgaTNjX21h c3Rlcl9jb250cm9sbGVyICptYXN0ZXIpCiAJCQlnb3RvIGVycl9idXNfY2xlYW51cDsKIAl9CiAK LQkvKiBEaXNhYmxlIGFsbCBzbGF2ZSBldmVudHMgYmVmb3JlIHN0YXJ0aW5nIERBQS4gKi8KLQly ZXQgPSBpM2NfbWFzdGVyX2Rpc2VjX2xvY2tlZChtYXN0ZXIsIEkzQ19CUk9BRENBU1RfQUREUiwK LQkJCQkgICAgICBJM0NfQ0NDX0VWRU5UX1NJUiB8IEkzQ19DQ0NfRVZFTlRfTVIgfAotCQkJCSAg ICAgIEkzQ19DQ0NfRVZFTlRfSEopOwotCWlmIChyZXQgJiYgcmV0ICE9IEkzQ19FUlJPUl9NMikK KwkvKgorCSAqIERpc2FibGUgYWxsIHNsYXZlIGV2ZW50cyBiZWZvcmUgc3RhcnRpbmcgREFBLiBX aGVuIG5vIGFjdGl2ZSBkZXZpY2UKKwkgKiBpcyBvbiB0aGUgYnVzLCByZXR1cm5zIE14IGVycm9y IGNvZGUgTTIsIHRoaXMgZXJyb3IgaXMgaWdub3JlZC4KKwkgKi8KKwlyZXQgPSBpM2NfbWFzdGVy X2VuZWNfZGlzZWNfbG9ja2VkKG1hc3RlciwgSTNDX0JST0FEQ0FTVF9BRERSLCBmYWxzZSwKKwkJ CQkJICAgSTNDX0NDQ19FVkVOVF9TSVIgfCBJM0NfQ0NDX0VWRU5UX01SIHwKKwkJCQkJICAgSTND X0NDQ19FVkVOVF9ISiwgdHJ1ZSk7CisJaWYgKHJldCkKIAkJZ290byBlcnJfYnVzX2NsZWFudXA7 CiAKIAkvKgotLSAKMi41My4wCgoKLS0gCmxpbnV4LWkzYyBtYWlsaW5nIGxpc3QKbGludXgtaTNj QGxpc3RzLmluZnJhZGVhZC5vcmcKaHR0cDovL2xpc3RzLmluZnJhZGVhZC5vcmcvbWFpbG1hbi9s aXN0aW5mby9saW51eC1pM2MK From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (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 9E11D3F0AA4; Mon, 20 Apr 2026 13:25:33 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1776691533; cv=none; b=EToVZnEZQ6VevX6OehHXJynB59nBgufC8+f6Jxuhm6D67EFlety+pSwT9AOSHthr7bxsKlcvuEZembosq673k4TabCy/bpt0oMO/OnNfVblYlN63080/F3XdKtR99nvIQ96CbS84XImPrg+QCMisCxBDVyuEt4v1Sr7rWiRsx70= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1776691533; c=relaxed/simple; bh=WYswN/ROswEAsJMjhIx+uqRHKp+65BaQFPOFnwBgM3A=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=lcJCphbANDLR4ewy2ncbQE9Vr03StizuN5J5xlYTWz2dtm6u1YKW6rEu7cHH4upUrtf1cSuoiwqGAQe3ZhOd4H1DjLDxobF3T7y0TCborev4vynk7C5PkzXWaRkM5fq0wBhoam4JZCZ087xWYq1cbhB1AOijRC4/pNFkrixH5nA= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=TWwN9/Ki; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="TWwN9/Ki" Received: by smtp.kernel.org (Postfix) with ESMTPSA id EEDBEC2BCB4; Mon, 20 Apr 2026 13:25:31 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1776691533; bh=WYswN/ROswEAsJMjhIx+uqRHKp+65BaQFPOFnwBgM3A=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=TWwN9/KiFOi8KofX2NLDsLSH3+AhHWaskkGVjuYmT9nx7zfNlMpYy9+s7++AmjkwO Hl5onZE159VSwHd1TTC4/DrHFOPvnUHP2BhAJLHEDQ6eDzPgvXSUs+/iwrwBx0wTqN H2uEs9Jnqcmv00pWp58VlSkyClVQKJZwSJmzRam94aZmGJUwc2HXDcr5/eB41ZxQTQ O+f4/Pb8VBChDKRaVCmShv+fudqI76ULIum0sU8oeetEdIwu3M9qT3T/xqDnmQVVoK 6aR+76QyWYW6PkP3EZr9+qA/FDaGVbycmh14KDKdBASUiE2kMO4SuqQDygDHHCeMeh YEB8aF8od/FAA== From: Sasha Levin To: patches@lists.linux.dev, stable@vger.kernel.org Cc: Jorge Marques , Frank Li , Adrian Hunter , Alexandre Belloni , Sasha Levin , linux-i3c@lists.infradead.org, linux-kernel@vger.kernel.org Subject: [PATCH AUTOSEL 7.0-6.1] i3c: master: Move bus_init error suppression Date: Mon, 20 Apr 2026 09:17:59 -0400 Message-ID: <20260420132314.1023554-85-sashal@kernel.org> X-Mailer: git-send-email 2.53.0 In-Reply-To: <20260420132314.1023554-1-sashal@kernel.org> References: <20260420132314.1023554-1-sashal@kernel.org> Precedence: bulk X-Mailing-List: patches@lists.linux.dev List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 X-stable: review X-Patchwork-Hint: Ignore X-stable-base: Linux 7.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit From: Jorge Marques [ Upstream commit 49775afa983e3e5ce8e7d00ee241791073be214d ] Prepare to fix improper Mx positive error propagation in later commits by handling Mx error codes where the i3c_ccc_cmd command is allocated. The CCC DISEC to broadcast address is invoked with i3c_master_enec_disec_locked() and yields error I3C_ERROR_M2 if there are no devices active on the bus. This is expected at the bus initialization stage, where it is not known yet that there are no active devices on the bus. Add bool suppress_m2 argument to i3c_master_enec_disec_locked() and update the call site at i3c_master_bus_init() with the exact corner case to not require propagating positive Mx error codes. Other call site should not suppress the error code, for example, if a driver requests to peripheral to disable events and the transfer is not acknowledged, this is an error and should not proceed. Reviewed-by: Frank Li Reviewed-by: Adrian Hunter Signed-off-by: Jorge Marques Link: https://patch.msgid.link/20260323-ad4062-positive-error-fix-v3-3-30bdc68004be@analog.com Signed-off-by: Alexandre Belloni Signed-off-by: Sasha Levin --- LLM Generated explanations, may be completely bogus: I now have sufficient information. Let me write the complete analysis. --- ## PHASE 1: COMMIT MESSAGE FORENSICS **Step 1.1: Parse subject line** Record: Subsystem `i3c: master:`, action verb `Move` (refactoring), summary: Move bus_init error suppression for DISEC M2 errors. **Step 1.2: Parse tags** Record: - Reviewed-by: Frank Li - Reviewed-by: Adrian Hunter - Signed-off-by: Jorge Marques - Link: patch.msgid.link/20260323-ad4062-positive-error-fix-v3-3 - Signed-off-by: Alexandre Belloni (maintainer) - **No Reported-by, no Fixes:, no Cc: stable** **Step 1.3: Commit body analysis** Record: Body explicitly states "Prepare to fix improper Mx positive error propagation in later commits". Describes adding `suppress_m2` argument to `i3c_master_enec_disec_locked()` so callers don't need to handle positive Mx codes. No stack traces, no crash description, no user-visible symptom described. This is author-declared preparation for a future fix. **Step 1.4: Hidden bug fixes** Record: NOT a hidden bug fix - the author explicitly says "Prepare to fix ... in later commits". Functionally this is a no-op: M2 was suppressed via `ret != I3C_ERROR_M2` at callsite before, now via `suppress_m2=true` inside the helper. ## PHASE 2: DIFF ANALYSIS **Step 2.1: Inventory** Record: Single file `drivers/i3c/master.c`, 15 insertions / 8 deletions. Modifies static helper `i3c_master_enec_disec_locked()` signature, updates 2 static wrappers (`i3c_master_disec_locked`, `i3c_master_enec_locked`), updates one callsite in `i3c_master_bus_init()`. **Step 2.2: Code flow** Record: - Before: `i3c_master_bus_init` called `i3c_master_disec_locked` then checked `if (ret && ret != I3C_ERROR_M2) goto err`. - After: `i3c_master_bus_init` calls `i3c_master_enec_disec_locked` directly with `suppress_m2=true`; the helper returns 0 when cmd.err == I3C_ERROR_M2; callsite just checks `if (ret) goto err`. - Net behavior: Functionally identical under the current state of `i3c_master_send_ccc_cmd_locked()`. **Step 2.3: Bug mechanism** Record: None — this is (h) refactoring moving logic from callsite to callee. No bug class fixed by this commit alone. **Step 2.4: Quality** Record: Small, surgical, reviewed by two maintainers. Risk: low. But by itself offers no functional benefit — it only matters in conjunction with patch 4/5 that stops propagating cmd->err. ## PHASE 3: GIT HISTORY INVESTIGATION **Step 3.1: Blame** Record: `i3c_master_enec_disec_locked()` has been the implementation of the DISEC helper since the i3c subsystem was introduced in commit 3a379bbcea0a ("i3c: Add core I3C infrastructure"), which is v4.17. **Step 3.2: Fixes tag** Record: No Fixes: tag on this commit. The related fix commit in the series (ef8b5229348f0 "i3c: master: Fix error codes at send_ccc_cmd") has `Fixes: 3a379bbcea0a` — pointing to the initial i3c commit. **Step 3.3: File history** Record: This commit is part of a 5-patch series (v3): - 1/5 `19a1b61fa6237` "Move rstdaa error suppression" (prep) - 2/5 `42247fffb3044` "Move entdaa error suppression" (prep) - **3/5 `49775afa983e3` "Move bus_init error suppression" (THIS COMMIT, prep)** - 4/5 `ef8b5229348f0` "Fix error codes at send_ccc_cmd" (the actual fix) - 5/5 `0b73da96b6eb6` "adi: Fix error propagation for CCCs" (adi- specific follow-up) The fix commit 4/5 explicitly names this commit as a prerequisite in its message: "The prerequisite patches for the fix are: ... i3c: master: Move bus_init error suppression". **Step 3.4: Author's work** Record: Jorge Marques (Analog Devices) is contributor of the adi-i3c-master driver; not the i3c core maintainer. Alexandre Belloni is the i3c maintainer (provided final SOB). The series was reviewed by Frank Li (NXP, active i3c reviewer) and Adrian Hunter (Intel). **Step 3.5: Dependencies** Record: This commit is a prerequisite for commit 4/5 of the same series. Without all three prep commits (1/5, 2/5, 3/5), commit 4/5 causes a regression. ## PHASE 4: MAILING LIST RESEARCH **Step 4.1: Original submission** Record: `b4 dig -c 49775afa983e3` found original submission at https://patch.msgid.link/20260323-ad4062-positive-error- fix-v3-3-30bdc68004be@analog.com. Patch is the final v3 of 3 revisions (v1 → v2 → v3). Cover letter explains the series was triggered by a **Smatch warning on iio/adc/ad4062.c**, not a user-reported runtime crash. **Step 4.2: Reviewers** Record: Recipients = Alexandre Belloni (maintainer), Frank Li (NXP reviewer), Przemysław Gaj (Cadence). CC: linux-i3c, Dan Carpenter (Smatch reporter), Jonathan Cameron, Adrian Hunter. Both Reviewed-by tags (Frank Li, Adrian Hunter) are from credible reviewers. **Step 4.3: Bug report** Record: Closes link in the fix commit (patch 4/5) points to https://lore.kernel.org/linux-iio/aYXvT5FW0hXQwhm_@stanley.mountain/ — Dan Carpenter's Smatch report. No user-reported crashes, no syzbot, no KASAN/KMSAN/KCSAN report. The bug is static-analysis-detected API correctness. **Step 4.4: Related patches** Record: Confirmed as part of 5-patch series. Patches 1/5, 2/5, 3/5 are preparation; patches 4/5, 5/5 are the actual fixes. No Cc: stable in any version. **Step 4.5: Stable mailing list** Record: No stable-specific discussion found in the thread. No reviewer suggested Cc: stable. ## PHASE 5: CODE SEMANTIC ANALYSIS **Step 5.1: Functions** Record: `i3c_master_enec_disec_locked()` (static, signature change), `i3c_master_disec_locked()` (exported wrapper), `i3c_master_enec_locked()` (exported wrapper), `i3c_master_bus_init()` (caller updated). **Step 5.2: Callers** Record: `i3c_master_bus_init()` is called from `i3c_master_register()` during driver probe (common hardware init path). `i3c_master_disec_locked()`/`i3c_master_enec_locked()` are exported and called from controller drivers (dw, svc, cdns, mipi-hci, renesas, adi) for enable/disable ibi operations. **Step 5.3: Callees** Record: `i3c_master_send_ccc_cmd_locked()` delegates to `master->ops->send_ccc_cmd()`. In the current stable pre-fix state, it still returns positive Mx codes; after the series' patch 4/5, it returns 0/negative only. **Step 5.4: Reachability** Record: Bus init path is reachable at every I3C master device probe — runs on every boot/init with I3C hardware. **Step 5.5: Similar patterns** Record: Two sibling preparation commits (1/5 rstdaa, 2/5 entdaa) follow identical pattern of moving M2 suppression into helper functions. ## PHASE 6: CROSS-REFERENCING AND STABLE TREE ANALYSIS **Step 6.1: Code exists in stable?** Record: The `i3c_master_enec_disec_locked()` helper and its M2-handling call site in `i3c_master_bus_init()` exist essentially unchanged since v4.17. The buggy M2-propagation pattern exists in every active stable tree. **Step 6.2: Backport difficulty** Record: Would apply with minor conflicts to older stables due to unrelated churn in bus_init. **Step 6.3: Related fixes in stable** Record: **Critical observation** — in the stable candidate branch under evaluation, the series' fix commit (patch 4/5) is present but this preparation commit (3/5) and the other two preparation commits (1/5, 2/5) are NOT. I verified `i3c_master_bus_init()` in the stable branch state still has `if (ret && ret != I3C_ERROR_M2)` at the DISEC callsite. Because the fix 4/5 stops `i3c_master_send_ccc_cmd_locked()` from returning positive M2, the driver's underlying `-EIO`/`-ETIMEDOUT` now propagates. That value `!= I3C_ERROR_M2`, so the check fails and bus_init aborts when no I3C device acks DISEC — this is exactly the "no active devices on the bus" case that M2 is meant to indicate. This is a **real regression** that the prep commits prevent. ## PHASE 7: SUBSYSTEM AND MAINTAINER CONTEXT **Step 7.1: Subsystem** Record: `drivers/i3c/` — I3C bus subsystem. Criticality: PERIPHERAL (affects systems with I3C hardware only, a relatively niche but growing bus), but on those systems bus_init is mandatory so impact is 100% of affected users. **Step 7.2: Activity** Record: Active subsystem, moderate churn, new controller drivers being added. ## PHASE 8: IMPACT AND RISK ASSESSMENT **Step 8.1: Affected users** Record: Any stable system running an I3C controller driver. Bus init runs on every probe. **Step 8.2: Trigger conditions** Record: This commit alone has no trigger (no behavior change). The scenario it addresses: bus_init when no active I3C device acknowledges DISEC broadcast. Very common during early boot of I3C controllers where devices may be powered off or absent. **Step 8.3: Failure mode** Record: In isolation, this commit changes nothing. When taken together with patch 4/5 (the actual fix), its absence causes bus_init to fail and the I3C controller to fail to probe. Severity in that combined scenario: HIGH (boot-time probe failure). **Step 8.4: Risk-benefit** Record: - Standalone benefit: zero (no bug fixed by itself). - Series-level benefit: Prevents a regression in the fix-for-stable. Without it, the fix breaks bus_init. - Risk: very low (15/8 lines, static helper, functionally equivalent to prior code). ## PHASE 9: FINAL SYNTHESIS **Step 9.1: Evidence** FOR backporting: - It is an explicit, author-named prerequisite for patch 4/5 ("i3c: master: Fix error codes at send_ccc_cmd"), which is itself a real bug fix (Smatch-reported, Fixes: the initial i3c core commit, affects an exported API contract). - Without this commit, applying patch 4/5 to stable causes a regression at bus_init (verified by inspecting `i3c_master_bus_init()` in the stable branch state — the `ret != I3C_ERROR_M2` check still present, but `ret` will no longer ever be positive I3C_ERROR_M2, so the check always fails into error path). - Small, contained (23 lines in one file), reviewed by two i3c reviewers including Adrian Hunter. - Touches only a static helper and a single callsite; risk is minimal. AGAINST backporting: - By its own commit message, it is explicitly a preparation/refactor that "prepares to fix in later commits", with no standalone bug fix — a canonical STRONG NO signal per the guidelines. - No Cc: stable, no Reported-by, no Fixes: tag on this commit itself. - If autosel selects this but not patch 4/5, it provides zero benefit (pure refactoring in stable). - The original bug's severity is medium (API-contract correctness, Smatch-found, no user runtime report). **Step 9.2: Stable rules checklist** 1. Obviously correct and tested: YES (reviewed, minor refactor, mainline-tested) 2. Fixes a real bug: NO on its own. YES only transitively as prereq to 4/5. 3. Important issue: NO standalone. Medium in series. 4. Small and contained: YES (single file, ~23 lines) 5. No new features/APIs: YES (static helper signature only) 6. Applies cleanly: YES with minor context adjustments **Step 9.3: Exception categories** Record: None apply — not a device ID, quirk, DT, build fix, or doc fix. **Step 9.4: Decision** This is a genuinely borderline "patch 3/5 is a preparation commit" case. The strict reading of stable rules marks preparation commits as STRONG NO. However, the guidelines also explicitly call out incomplete fix series as borderline cases requiring dependency analysis. My verification shows: 1. Patch 4/5 of the series is the actual bug fix targeting a real (if medium-severity) API-contract bug that has existed since i3c was introduced. 2. Patch 4/5 **cannot be backported safely without this prerequisite** — I verified the resulting bus_init code would regress (driver-returned `-EIO` falls into the error path when the old code relied on positive M2 propagation to take the "no devices" happy path). 3. The cost of including this prep commit is negligible (pure refactor, reviewed, small scope). 4. The cost of excluding it, if patch 4/5 is selected, is a boot/probe regression for I3C-enabled systems. Given the clear transitive value (preventing a regression in an accompanying fix) and the minimal risk profile, this should travel with its fix series rather than be evaluated in isolation. --- ## Verification - [Phase 1] Parsed tags from commit message: two Reviewed-by (Frank Li NXP, Adrian Hunter Intel), two SOB (author + maintainer Belloni), Link to lore/patch.msgid. No Fixes:, no Cc: stable, no Reported-by. - [Phase 1] Commit body explicitly states "Prepare to fix improper Mx positive error propagation in later commits" — author-declared preparation. - [Phase 2] Diff inventory: single file, 15+/8-, modifies one static helper + 2 static wrappers + 1 callsite. Confirmed functional equivalence under current `i3c_master_send_ccc_cmd_locked()` behavior. - [Phase 3] `git log --oneline -- drivers/i3c/master.c` confirmed recent-file history; this commit is not yet visible via HEAD's reachable history (only in bus-next). - [Phase 3] `git branch --contains 49775afa983e3` → `bus-next`; same for patches 1/5 and 2/5. `git branch --contains 18db53793d787` → `for- greg/7.0-100` (stable candidate branch) — the fix is being prepared for stable but the prereqs are NOT in that branch. - [Phase 3] `git show ef8b5229348f0` confirmed the fix commit explicitly names this commit in the prerequisite list inside its body. - [Phase 4] `b4 dig -c 49775afa983e3` returned the lore URL https://patch.msgid.link/20260323-ad4062-positive-error- fix-v3-3-30bdc68004be@analog.com. - [Phase 4] `b4 dig -c 49775afa983e3 -a` showed three series revisions (v1 → v2 → v3); the applied version is the latest. - [Phase 4] `b4 dig -c 49775afa983e3 -m` saved thread; read cover letter — series was triggered by Dan Carpenter's Smatch warning on iio/adc/ad4062; no Cc: stable requested by author or reviewers. - [Phase 4] Grepped mbox for `stable@|Cc:.*stable` — no hits related to stable nomination. - [Phase 5] Confirmed by reading the file: `i3c_master_enec_disec_locked` is static and only invoked via `i3c_master_disec_locked`/`i3c_master_enec_locked`. - [Phase 6] `git show 18db53793d787:drivers/i3c/master.c` confirmed bus_init in the stable-candidate branch still contains `if (ret && ret != I3C_ERROR_M2)` at the DISEC call — verifies the regression scenario if prereq is omitted. - [Phase 6] Cross-referenced series cover letter: controllers return `-EIO`/`-EINVAL` on M2 NACK — confirms regression path. - [Phase 8] Severity assessment based on verified dependency: HIGH (boot probe failure) if fix 4/5 goes without this; zero impact in isolation. - UNVERIFIED: Could not fetch the lore thread directly over HTTP (Anubis bot-challenge blocked WebFetch), but b4 dig retrieved the full mbox for analysis instead. - UNVERIFIED: Did not test backport apply to specific stable kernels (6.1, 6.6, 6.12) — stated "minor conflicts" based on file churn observation only. --- This commit is explicitly a preparation/refactor with no standalone bug fix — the canonical "STRONG NO" pattern in stable rules. However, it is a **named, documented prerequisite** for a bug-fix commit in the same 5-patch series, and I have verified that applying that fix without this preparation would cause a real regression at I3C bus init (a common boot-path code path). Stable sanity demands the series travels as a unit or not at all. **YES** drivers/i3c/master.c | 23 +++++++++++++++-------- 1 file changed, 15 insertions(+), 8 deletions(-) diff --git a/drivers/i3c/master.c b/drivers/i3c/master.c index 9e6be49bebb2c..b91dc1e734ed8 100644 --- a/drivers/i3c/master.c +++ b/drivers/i3c/master.c @@ -1051,7 +1051,8 @@ int i3c_master_entdaa_locked(struct i3c_master_controller *master) EXPORT_SYMBOL_GPL(i3c_master_entdaa_locked); static int i3c_master_enec_disec_locked(struct i3c_master_controller *master, - u8 addr, bool enable, u8 evts) + u8 addr, bool enable, u8 evts, + bool suppress_m2) { struct i3c_ccc_events *events; struct i3c_ccc_cmd_dest dest; @@ -1071,6 +1072,9 @@ static int i3c_master_enec_disec_locked(struct i3c_master_controller *master, ret = i3c_master_send_ccc_cmd_locked(master, &cmd); i3c_ccc_cmd_dest_cleanup(&dest); + if (suppress_m2 && ret && cmd.err == I3C_ERROR_M2) + ret = 0; + return ret; } @@ -1091,7 +1095,7 @@ static int i3c_master_enec_disec_locked(struct i3c_master_controller *master, int i3c_master_disec_locked(struct i3c_master_controller *master, u8 addr, u8 evts) { - return i3c_master_enec_disec_locked(master, addr, false, evts); + return i3c_master_enec_disec_locked(master, addr, false, evts, false); } EXPORT_SYMBOL_GPL(i3c_master_disec_locked); @@ -1112,7 +1116,7 @@ EXPORT_SYMBOL_GPL(i3c_master_disec_locked); int i3c_master_enec_locked(struct i3c_master_controller *master, u8 addr, u8 evts) { - return i3c_master_enec_disec_locked(master, addr, true, evts); + return i3c_master_enec_disec_locked(master, addr, true, evts, false); } EXPORT_SYMBOL_GPL(i3c_master_enec_locked); @@ -2102,11 +2106,14 @@ static int i3c_master_bus_init(struct i3c_master_controller *master) goto err_bus_cleanup; } - /* Disable all slave events before starting DAA. */ - ret = i3c_master_disec_locked(master, I3C_BROADCAST_ADDR, - I3C_CCC_EVENT_SIR | I3C_CCC_EVENT_MR | - I3C_CCC_EVENT_HJ); - if (ret && ret != I3C_ERROR_M2) + /* + * Disable all slave events before starting DAA. When no active device + * is on the bus, returns Mx error code M2, this error is ignored. + */ + ret = i3c_master_enec_disec_locked(master, I3C_BROADCAST_ADDR, false, + I3C_CCC_EVENT_SIR | I3C_CCC_EVENT_MR | + I3C_CCC_EVENT_HJ, true); + if (ret) goto err_bus_cleanup; /* -- 2.53.0