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 B018DC624A4 for ; Mon, 31 Aug 2026 13:51:38 +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=QMH75/YXuYumUYnNwyTOeYXzuWt0hARj8yLBh4DtDI4=; b=JF68oBDxM/Kwwg tQm07jmimJxEy1NnkKiac7+6iSx97F2LTTwpvD0CPu4zc4Z1kVKmW0vByIlbqVGtzQO61kJoMYp/1 CvK1kJlpAD2qaUK5bCFOfuwce0f868XtzpqMbdTiR2Sp5Zg1AqB93dYpLBIunSzpwUV9gva4OVD0+ 88ORQu7SexTKXscFm9oRwqnpCVhQi2+5QmcD5kwcR3GoI8EcH001K7TMAfxufK27U4AxWope7wm+a BGdMLyHJMTs2GeiWR5NEBeUwI+nmFtuTS8esS8JRLMRXTrlMvYI2OoP5oOXuZP48QA39qbXBM0m/1 OXeem1vrbfCrlJgxYzXw==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.99.1 #2 (Red Hat Linux)) id 1x12QE-00000009YVl-1dqn; Mon, 31 Aug 2026 13:51:38 +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 1x12QD-00000009YUx-0Rno for linux-i3c@lists.infradead.org; Mon, 31 Aug 2026 13:51:37 +0000 Received: from smtp.kernel.org (quasi.space.kernel.org [100.103.45.18]) by sea.source.kernel.org (Postfix) with ESMTP id C0AAD41970; Mon, 31 Aug 2026 13:51:36 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 7E5E41F00A3D; Mon, 31 Aug 2026 13:51:35 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1788184296; bh=KFrji6sAEM01oX6Klu9JH/k5CoftNiOX7x3iUh3LoAA=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=CxBtHd88uXelOluNaufe+NjtlDvdfT/eeqECvUk6KjWlIUGKKc/i0zLeeswXYBlxd gRTopZz91WF39jAyQ7kx9bvVrKYmXHZWo0XLFeWY94+K/OXkGlfQEAIpDSYnJe1DyD FTDR0yiwQfYiG3i3CIk5VmilK6pYP+Ye9qNoOMZAh+VSFz5s+2WfcDK6lP99E41hIx IHSZ8kpVACum83Q15XszJRa4W9DUJpG/ebDX/8lAlrfYD0rOSRdHdYL9iLtwLcvF/C +Orr+8+t4VVkdOXw9nqjHayzNs0KyMcgUOO2sVtwm5DUtTFpALX05Yl6+6pfZcLz+R 6xEO+pUu93cLg== From: Sasha Levin To: patches@lists.linux.dev, stable@vger.kernel.org Cc: Adrian Hunter , Frank Li , Alexandre Belloni , Sasha Levin , linux-i3c@lists.infradead.org, linux-kernel@vger.kernel.org Subject: [PATCH AUTOSEL 6.18-5.15] i3c: mipi-i3c-hci: Tolerate i3c_master_add_i3c_dev_locked() failures in DAA Date: Mon, 31 Aug 2026 09:30:36 -0400 Message-ID: <20260831133314.4125787-608-sashal@kernel.org> X-Mailer: git-send-email 2.53.0 In-Reply-To: <20260831133314.4125787-1-sashal@kernel.org> References: <20260831133314.4125787-1-sashal@kernel.org> MIME-Version: 1.0 X-stable: review X-Patchwork-Hint: Ignore X-stable-base: Linux 6.18.48 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 RnJvbTogQWRyaWFuIEh1bnRlciA8YWRyaWFuLmh1bnRlckBpbnRlbC5jb20+CgpbIFVwc3RyZWFt IGNvbW1pdCBjMjM2NTYzYzhhODQyMzlkMzFhMWU2ZWM0NDQ0ODg3YTdiNWVkOThmIF0KCmkzY19t YXN0ZXJfYWRkX2kzY19kZXZfbG9ja2VkKCkgbm8gbG9uZ2VyIGxlYXZlcyB0aGUgYWRkcmVzcyBt YXJrZWQgYXMKZnJlZSBvbiBmYWlsdXJlLCBzbyBhYm9ydGluZyB0aGUgREFBIHNlcXVlbmNlIG9u IGl0cyBlcnJvciBpcyB1bm5lY2Vzc2FyeS4KCkZhaWx1cmUgdG8gcmVnaXN0ZXIgYSBkaXNjb3Zl cmVkIGRldmljZSBkb2VzIG5vdCBpbnZhbGlkYXRlIHRoZSBlbnRpcmUKRHluYW1pYyBBZGRyZXNz IEFzc2lnbm1lbnQgKERBQSkgcHJvY2VkdXJlLiAgQWxpZ24gd2l0aCB0aGUgYmVoYXZpb3Igb2YK b3RoZXIgSTNDIG1hc3RlciBkcml2ZXJzIGJ5IGlnbm9yaW5nIGVycm9ycyBmcm9tCmkzY19tYXN0 ZXJfYWRkX2kzY19kZXZfbG9ja2VkKCkgYW5kIGNvbnRpbnVpbmcgZW51bWVyYXRpb24uCgpTaWdu ZWQtb2ZmLWJ5OiBBZHJpYW4gSHVudGVyIDxhZHJpYW4uaHVudGVyQGludGVsLmNvbT4KUmV2aWV3 ZWQtYnk6IEZyYW5rIExpIDxGcmFuay5MaUBueHAuY29tPgpMaW5rOiBodHRwczovL3BhdGNoLm1z Z2lkLmxpbmsvMjAyNjA2MTIwODAxMDcuMTE2MDYtNS1hZHJpYW4uaHVudGVyQGludGVsLmNvbQpT aWduZWQtb2ZmLWJ5OiBBbGV4YW5kcmUgQmVsbG9uaSA8YWxleGFuZHJlLmJlbGxvbmlAYm9vdGxp bi5jb20+ClNpZ25lZC1vZmYtYnk6IFNhc2hhIExldmluIDxzYXNoYWxAa2VybmVsLm9yZz4KLS0t CgpMTE0gR2VuZXJhdGVkIGV4cGxhbmF0aW9ucywgbWF5IGJlIGNvbXBsZXRlbHkgYm9ndXM6Cgoj IyBQaGFzZSAxOiBDb21taXQgTWVzc2FnZSBGb3JlbnNpY3MKCiMjIyBTdGVwIDEuMTogU3ViamVj dCBMaW5lCioqUmVjb3JkOioqIGBbaTNjOiBtaXBpLWkzYy1oY2ldYCBgW1RvbGVyYXRlXWAg4oCU IFN0b3AgYWJvcnRpbmcgREFBIHdoZW4KYGkzY19tYXN0ZXJfYWRkX2kzY19kZXZfbG9ja2VkKClg IGZhaWxzOyBjb250aW51ZSBlbnVtZXJhdGlvbiBpbnN0ZWFkLgoKIyMjIFN0ZXAgMS4yOiBUYWdz CioqUmVjb3JkOioqCi0gKipTaWduZWQtb2ZmLWJ5OioqIEFkcmlhbiBIdW50ZXIgYDxhZHJpYW4u aHVudGVyQGludGVsLmNvbT5gIChhdXRob3IpCi0gKipSZXZpZXdlZC1ieToqKiBGcmFuayBMaSBg PEZyYW5rLkxpQG54cC5jb20+YCAoTlhQIEkzQyBtYWludGFpbmVyKQotICoqTGluazoqKiBodHRw czovL3BhdGNoLm1zZ2lkLmxpbmsvMjAyNjA2MTIwODAxMDcuMTE2MDYtNS0KICBhZHJpYW4uaHVu dGVyQGludGVsLmNvbQotICoqU2lnbmVkLW9mZi1ieToqKiBBbGV4YW5kcmUgQmVsbG9uaSBgPGFs ZXhhbmRyZS5iZWxsb25pQGJvb3RsaW4uY29tPmAKICAoSTNDIHN1YnN5c3RlbSBtYWludGFpbmVy KQotIE5vIEZpeGVzOiwgUmVwb3J0ZWQtYnk6LCBUZXN0ZWQtYnk6LCBDYzogc3RhYmxlLCBvciBz eXpib3QgdGFncwotIE5vdGFibGU6IFJldmlld2VkIGJ5IHN1YnN5c3RlbSBleHBlcnQ7IHBhcnQg b2YgVjQgNC83IHNlcmllcwoKIyMjIFN0ZXAgMS4zOiBCb2R5IEFuYWx5c2lzCioqUmVjb3JkOioq Ci0gKipCdWc6KiogYG1pcGktaTNjLWhjaWAgYWJvcnRzIHRoZSBlbnRpcmUgREFBIGxvb3Agd2hl bgogIGBpM2NfbWFzdGVyX2FkZF9pM2NfZGV2X2xvY2tlZCgpYCBmYWlscyBmb3Igb25lIGRldmlj ZS4KLSAqKlN5bXB0b206KiogUmVtYWluaW5nIEkzQyBkZXZpY2VzIG9uIHRoZSBidXMgYXJlIG5l dmVyCiAgZW51bWVyYXRlZC9yZWdpc3RlcmVkIGFmdGVyIGEgc2luZ2xlIGRldmljZS1hZGQgZmFp bHVyZS4KLSAqKlJvb3QgY2F1c2UgKHBlciBhdXRob3IpOioqIEFmdGVyIGNvbW1pdCBgMzhkM2Qz M2AgKCJQcmV2ZW50IHJldXNlIG9mCiAgZHluYW1pYyBhZGRyZXNzIG9uIGRldmljZSBhZGQgZmFp bHVyZSIpLCBmYWlsZWQgcmVnaXN0cmF0aW9uIG5vIGxvbmdlcgogIGZyZWVzIHRoZSBhZGRyZXNz IHNsb3QsIHNvIGFib3J0aW5nIERBQSBpcyB1bm5lY2Vzc2FyeSBhbmQgaGFybWZ1bC4KLSAqKkZp eCBhcHByb2FjaDoqKiBJZ25vcmUgdGhlIHJldHVybiB2YWx1ZSBhbmQgY29udGludWUgREFBLCBt YXRjaGluZwogIGBzdmMtaTNjLW1hc3RlcmAsIGBjZG5zYCwgYHJlbmVzYXNgLCBgZHdgLCBhbmQg YGFkaWAgZHJpdmVycy4KLSBObyBleHBsaWNpdCBrZXJuZWwgdmVyc2lvbiByYW5nZSBpbiBtZXNz YWdlLgoKIyMjIFN0ZXAgMS40OiBIaWRkZW4gQnVnIEZpeCBEZXRlY3Rpb24KKipSZWNvcmQ6Kiog WWVzIOKAlCBkZXNjcmliZWQgYXMgYWxpZ25tZW50L2NsZWFudXAsIGJ1dCBpdCBmaXhlcyBhIHJl YWwKbG9naWMgYnVnOiBwcmVtYXR1cmUgREFBIHRlcm1pbmF0aW9uIGxlYXZlcyBkZXZpY2VzIHVu ZGlzY292ZXJlZC4gU2FtZQpjbGFzcyBvZiBidWcgZml4ZWQgaW4gYHN2Yy1pM2MtbWFzdGVyYCAo Y29tbWl0IGAzYjJhYzgxMGAsIENjOiBzdGFibGUpLgoKLS0tCgojIyBQaGFzZSAyOiBEaWZmIEFu YWx5c2lzCgojIyMgU3RlcCAyLjE6IEludmVudG9yeQoqKlJlY29yZDoqKgotIGBkcml2ZXJzL2kz Yy9tYXN0ZXIvbWlwaS1pM2MtaGNpL2NtZF92MS5jYDog4oiSMyBsaW5lcyAocmVtb3ZlIHJldCBj aGVjawogICsgYnJlYWspCi0gYGRyaXZlcnMvaTNjL21hc3Rlci9taXBpLWkzYy1oY2kvY21kX3Yy LmNgOiDiiJIzIGxpbmVzIChzYW1lKQotIEZ1bmN0aW9uczogYGhjaV9jbWRfdjFfZGFhKClgLCBg aGNpX2NtZF92Ml9kYWEoKWAKLSBTY29wZTogc2luZ2xlLWZpbGUgc3VyZ2ljYWwgZml4IGluIG9u ZSBkcml2ZXIgKDIgY29tbWFuZCB2YXJpYW50cykKCiMjIyBTdGVwIDIuMjogQ29kZSBGbG93IENo YW5nZQoqKlJlY29yZDoqKgotICoqSHVuayAxIChgY21kX3YxLmNgKToqKiBCZWZvcmU6IGFzc2ln biBhZGRyZXNzIHZpYSBoYXJkd2FyZSBEQUEg4oaSCiAgY2FsbCBgaTNjX21hc3Rlcl9hZGRfaTNj X2Rldl9sb2NrZWQoKWAg4oaSIG9uIGVycm9yLCBgYnJlYWtgIG91dCBvZiBEQUEKICBsb29wLiBB ZnRlcjogY2FsbCBmdW5jdGlvbiB3aXRob3V0IGNoZWNraW5nIHJldHVybjsgbG9vcCBjb250aW51 ZXMgdG8KICBuZXh0IGRldmljZS4KLSAqKkh1bmsgMiAoYGNtZF92Mi5jYCk6KiogSWRlbnRpY2Fs IGJlaGF2aW9yYWwgY2hhbmdlIGluIHYyIERBQSBwYXRoLgotIEFmZmVjdGVkIHBhdGg6IG5vcm1h bCBEQUEgZW51bWVyYXRpb24gbG9vcCBkdXJpbmcgYnVzIHByb2JlIC8gaG90LQogIGpvaW4uCgoj IyMgU3RlcCAyLjM6IEJ1ZyBNZWNoYW5pc20KKipSZWNvcmQ6KioKLSAqKkNhdGVnb3J5OioqIExv Z2ljL2NvcnJlY3RuZXNzIGZpeCAoZXJyb3ItcGF0aCBoYW5kbGluZykKLSAqKk1lY2hhbmlzbToq KiBUcmVhdGluZyBhIHBlci1kZXZpY2UgcmVnaXN0cmF0aW9uIGZhaWx1cmUgYXMgZmF0YWwgdG8K ICB0aGUgZW50aXJlIG11bHRpLWRldmljZSBEQUEgc2VxdWVuY2UuIFdpdGggcHJlcmVxdWlzaXRl IGAzOGQzZDMzYCwgdGhlCiAgYWRkcmVzcyBpcyByZXRhaW5lZCBvbiBmYWlsdXJlLCBzbyBjb250 aW51aW5nIGlzIHNhZmUuIEFib3J0aW5nCiAgcHJldmVudHMgcmVnaXN0cmF0aW9uIG9mIHN1YnNl cXVlbnRseSBkaXNjb3ZlcmVkIGRldmljZXMuCgojIyMgU3RlcCAyLjQ6IEZpeCBRdWFsaXR5Cioq UmVjb3JkOioqIE9idmlvdXNseSBjb3JyZWN0IOKAlCBtYXRjaGVzIGVzdGFibGlzaGVkIHBhdHRl cm4gaW4gZml2ZQpvdGhlciBJM0MgbWFzdGVyIGRyaXZlcnMuIE1pbmltYWwgY2hhbmdlLiBMb3cg cmVncmVzc2lvbiByaXNrOiBvbmx5CnJlbW92ZXMgYW4gb3Zlcmx5IGFnZ3Jlc3NpdmUgZWFybHkt ZXhpdDsgcmVhbCBidXMvdHJhbnNmZXIgZXJyb3JzIHN0aWxsCmJyZWFrIHRoZSBsb29wIHZpYSBg UkVTUF9TVEFUVVNgIGNoZWNrcy4KCi0tLQoKIyMgUGhhc2UgMzogR2l0IEhpc3RvcnkgSW52ZXN0 aWdhdGlvbgoKIyMjIFN0ZXAgMy4xOiBCbGFtZQoqKlJlY29yZDoqKiBCdWdneSBgaWYgKHJldCkg YnJlYWs7YCBwYXR0ZXJuIGludHJvZHVjZWQgaW4KYDlhZDlhNTJjY2UyODJgIChOb3YgMjAyMCwg ImkzYy9tYXN0ZXI6IGludHJvZHVjZSB0aGUgbWlwaS1pM2MtaGNpCmRyaXZlciIpLiBQcmVzZW50 IHNpbmNlIGRyaXZlciBpbnRyb2R1Y3Rpb24uCgojIyMgU3RlcCAzLjI6IEZpeGVzOiBUYWcKKipS ZWNvcmQ6KiogTi9BIOKAlCBubyBGaXhlczogdGFnLiBQcmVyZXF1aXNpdGUgaWRlbnRpZmllZCBm cm9tIGNvbW1pdAptZXNzYWdlOiBgMzhkM2QzM2JmNDJjMmAgLyB1cHN0cmVhbSBgYjNiYTgzODNk YTRkMGAgKCJQcmV2ZW50IHJldXNlIG9mCmR5bmFtaWMgYWRkcmVzcyBvbiBkZXZpY2UgYWRkIGZh aWx1cmUiKSwgd2hpY2ggY2hhbmdlcwpgaTNjX21hc3Rlcl9hZGRfaTNjX2Rldl9sb2NrZWQoKWAg dG8gbWFyayBhZGRyZXNzZXMgYXMgb2NjdXBpZWQgb24KZmFpbHVyZSB2aWEgYGVycl9wcmV2ZW50 X2FkZHJfcmV1c2VgLiAqKkNvbmZpcm1lZCBwcmVzZW50IGluIHRoaXMgdHJlZSoqCihgZ2l0IG1l cmdlLWJhc2UgLS1pcy1hbmNlc3RvcmAgcGFzc2VzKS4KCiMjIyBTdGVwIDMuMzogUmVsYXRlZCBG aWxlIEhpc3RvcnkKKipSZWNvcmQ6KiogUmVjZW50IHJlbGF0ZWQgY29tbWl0cyBpbiB0cmVlOgot IGAzOGQzZDMzYCDigJQgcHJlcmVxdWlzaXRlIChhbHJlYWR5IGJhY2twb3J0ZWQgdG8gNi4xOC55 KQotIGAzYjJhYzgxMGAg4oCUIHN2YyBkcml2ZXI6IGlkZW50aWNhbCAiZG9uJ3QgY2hlY2sgcmV0 dXJuIHZhbHVlIiBmaXggKGluCiAgdHJlZSwgQ2M6IHN0YWJsZSkKLSBGaXggY29tbWl0IGBjMjM2 NTYzYzhhODQyYCBpcyBpbiBtYWlubGluZSBidXQgKipub3QgeWV0IGluIHRoaXMKICA2LjE4LjQ0 IGNoZWNrb3V0KioKCiMjIyBTdGVwIDMuNDogQXV0aG9yIENvbnRleHQKKipSZWNvcmQ6KiogQWRy aWFuIEh1bnRlciBpcyBhbiBhY3RpdmUgSW50ZWwgSTNDIGNvbnRyaWJ1dG9yLiBNdWx0aXBsZQpy ZWxhdGVkIGZpeGVzIGluIGBkcml2ZXJzL2kzYy9gIGFyb3VuZCBEQUEsIGhvdC1qb2luLCBhbmQg YWRkcmVzcwptYW5hZ2VtZW50IChKdW4gMjAyNiBzZXJpZXMpLgoKIyMjIFN0ZXAgMy41OiBEZXBl bmRlbmNpZXMKKipSZWNvcmQ6KioKLSAqKkhhcmQgZGVwZW5kZW5jeToqKiBgMzhkM2QzM2AgKGFs cmVhZHkgaW4gdHJlZSkg4oCUIHdpdGhvdXQgaXQsCiAgY29udGludWluZyBEQUEgYWZ0ZXIgZmFp bHVyZSBjb3VsZCByZWFzc2lnbiBhZGRyZXNzZXMuCi0gKipOb3QgcmVxdWlyZWQ6KiogUGF0Y2hl cyAxLzcgKHJhY2UgZml4KSwgMi83IChESVNFQyksIDXigJM3LzcgKHJldHVybi0KICB2b2lkIEFQ SSBjaGFuZ2UgKyByZWNvbmNpbGlhdGlvbiDigJQgKipub3QgbWVyZ2VkIHRvIG1haW5saW5lKiop LgotICoqU3RhbmRhbG9uZToqKiBZZXMsIGZvciBzdGFibGUgcHVycG9zZXMsIGdpdmVuIHByZXJl cXVpc2l0ZSBpcwogIHByZXNlbnQuCgotLS0KCiMjIFBoYXNlIDQ6IE1haWxpbmcgTGlzdCBhbmQg RXh0ZXJuYWwgUmVzZWFyY2gKCiMjIyBTdGVwIDQuMTogT3JpZ2luYWwgRGlzY3Vzc2lvbgoqKlJl Y29yZDoqKgotICoqVVJMOioqIGh0dHBzOi8vcGF0Y2gubXNnaWQubGluay8yMDI2MDYxMjA4MDEw Ny4xMTYwNi01LQogIGFkcmlhbi5odW50ZXJAaW50ZWwuY29tCi0gKipTZXJpZXM6KiogVjHihpJW NCwgcGF0Y2ggNC83OyBhcHBsaWVkIHZlcnNpb24gaXMgbGF0ZXN0IChWNCkKLSAqKkNvdmVyIGxl dHRlciAoVjQgMC83KToqKiAiUGF0Y2hlcyAzLTcgZml4IGFkZHJlc3MgbWFuYWdlbWVudAogIGlz c3Vlcy4uLiB3aGVuIERBQSBkb2VzIG5vdCBjb21wbGV0ZSBjbGVhbmx5IgotICoqUmV2aWV3ZXIg ZmVlZGJhY2s6KiogIkFwcGxpZWQsIHRoYW5rcyEiIGZyb20gbWFpbnRhaW5lciBvbiBjb3Zlcgog IGxldHRlcgotIE5vIGV4cGxpY2l0IHN0YWJsZSBub21pbmF0aW9uIGZvdW5kIGluIG1ib3ggZm9y IHRoaXMgc3BlY2lmaWMgcGF0Y2gKCiMjIyBTdGVwIDQuMjogUmV2aWV3ZXJzCioqUmVjb3JkOioq IENDJ2Q6IGBhbGV4YW5kcmUuYmVsbG9uaUBib290bGluLmNvbWAsIGBGcmFuay5MaUBueHAuY29t YCwKYGxpbnV4LWkzY0BsaXN0cy5pbmZyYWRlYWQub3JnYCwgYGxpbnV4LWtlcm5lbEB2Z2VyLmtl cm5lbC5vcmdgLgpSZXZpZXdlZC1ieSBGcmFuayBMaSAoTlhQKS4KCiMjIyBTdGVwIDQuMzogQnVn IFJlcG9ydAoqKlJlY29yZDoqKiBObyBleHRlcm5hbCBidWcgcmVwb3J0IG9yIHN5emJvdCBsaW5r LiBCdWcgaWRlbnRpZmllZAp0aHJvdWdoIGNvZGUgcmV2aWV3IC8gc2VyaWVzIGRldmVsb3BtZW50 LiBQcmVjZWRlbnQ6IGAzYjJhYzgxMGAKZG9jdW1lbnRlZCBpZGVudGljYWwgZmFpbHVyZSBtb2Rl IGZvciBzdmMgZHJpdmVyIHdpdGggZXhwbGljaXQgSTNDIHNwZWMKdmlvbGF0aW9uIHNjZW5hcmlv LgoKIyMjIFN0ZXAgNC40OiBSZWxhdGVkIFBhdGNoZXMKKipSZWNvcmQ6KiogUGFydCBvZiA3LXBh dGNoIFY0IHNlcmllcy4gUGF0Y2hlcyA14oCTNyAoQVBJIGNoYW5nZSB0byB2b2lkCnJldHVybiAr IHBvc3QtREFBIHJlY29uY2lsaWF0aW9uKSB3ZXJlICoqbm90KiogbWVyZ2VkIHVwc3RyZWFtLiBU aGlzCnBhdGNoIHdhcyBtZXJnZWQgc3RhbmRhbG9uZSB3aXRoIHBhdGNoIDMuCgojIyMgU3RlcCA0 LjU6IFN0YWJsZSBMaXN0IEhpc3RvcnkKKipSZWNvcmQ6KiogTm8gc3RhYmxlLWxpc3QgZGlzY3Vz c2lvbiBmb3VuZCBmb3IgdGhpcyBzcGVjaWZpYyBwYXRjaC4KUHJlcmVxdWlzaXRlIGAzOGQzZDMz YCB3YXMgYmFja3BvcnRlZCB0byB0aGlzIHRyZWUgKGhhcyB1cHN0cmVhbS1jb21taXQKbWFya2Vy IGFuZCBHcmVnIEsgY29tbWl0KS4KCi0tLQoKIyMgUGhhc2UgNTogQ29kZSBTZW1hbnRpYyBBbmFs eXNpcwoKIyMjIFN0ZXAgNS4xOiBLZXkgRnVuY3Rpb25zCioqUmVjb3JkOioqIGBoY2lfY21kX3Yx X2RhYSgpYCwgYGhjaV9jbWRfdjJfZGFhKClgLCBjYWxsZWQgdmlhCmBpM2NfaGNpX2RhYSgpYCBp biBgY29yZS5jYC4KCiMjIyBTdGVwIDUuMjogQ2FsbGVycwoqKlJlY29yZDoqKiBgaTNjX2hjaV9k YWEoKWAg4oaSIHJlZ2lzdGVyZWQgYXMgYG1hc3Rlci0+b3BzLmRvX2RhYWAg4oaSCmludm9rZWQg YnkgYGkzY19tYXN0ZXJfZG9fZGFhKClgIC8gYGkzY19tYXN0ZXJfZG9fZGFhX2V4dCgpYCBkdXJp bmcgYnVzCmluaXRpYWxpemF0aW9uIGFuZCBob3Qtam9pbiBEQUEuIENhbGxlZCBkdXJpbmcgZGV2 aWNlIHByb2JlLCBub3QgYSBob3QKc3lzY2FsbCBwYXRoLgoKIyMjIFN0ZXAgNS4zOiBDYWxsZWVz CioqUmVjb3JkOioqIGBpM2NfbWFzdGVyX2FkZF9pM2NfZGV2X2xvY2tlZCgpYCDigJQgYWxsb2Nh dGVzIGRldmljZSwKcmV0cmlldmVzIENDQyBpbmZvLCBhdHRhY2hlcyB0byBidXMuIE9uIGZhaWx1 cmUgKHdpdGggYDM4ZDNkMzNgKTogbG9ncwplcnJvciwgbWFya3MgYWRkcmVzcyBzbG90IG9jY3Vw aWVkLCByZXR1cm5zIGVycm9yIGNvZGUuCgojIyMgU3RlcCA1LjQ6IFJlYWNoYWJpbGl0eQoqKlJl Y29yZDoqKiBUcmlnZ2VyZWQgZHVyaW5nIEkzQyBidXMgZW51bWVyYXRpb24gb24gc3lzdGVtcyB1 c2luZwpgbWlwaS1pM2MtaGNpYCAoSW50ZWwgYW5kIG90aGVyIE1JUEkgSENJIHBsYXRmb3Jtcyku IE11bHRpLWRldmljZSBidXNlcwphcmUgY29tbW9uIChzZW5zb3JzLCBQTUlDcywgZXRjLikuIEZh aWx1cmUgb2Ygb25lIGRldmljZSdzIHJlZ2lzdHJhdGlvbgppcyBwbGF1c2libGUgKHRyYW5zaWVu dCBDQ0MgZXJyb3JzLCBmaXJtd2FyZSBxdWlya3MpLgoKIyMjIFN0ZXAgNS41OiBTaW1pbGFyIFBh dHRlcm5zCioqUmVjb3JkOioqIEFsbCBvdGhlciBJM0MgbWFzdGVyIGRyaXZlcnMgaWdub3JlCmBp M2NfbWFzdGVyX2FkZF9pM2NfZGV2X2xvY2tlZCgpYCByZXR1cm4gZHVyaW5nIERBQToKCmBgYDEy MjQ6MTIyNTpkcml2ZXJzL2kzYy9tYXN0ZXIvc3ZjLWkzYy1tYXN0ZXIuYwogICAgICAgIGZvciAo aSA9IDA7IGkgPCBkZXZfbmI7IGkrKykKICAgICAgICAgICAgICAgIGkzY19tYXN0ZXJfYWRkX2kz Y19kZXZfbG9ja2VkKG0sIGFkZHJzW2ldKTsKYGBgCgpTYW1lIHBhdHRlcm4gaW4gYHJlbmVzYXMt aTNjLmNgLCBgaTNjLW1hc3Rlci1jZG5zLmNgLCBgZHctaTNjLW1hc3Rlci5jYCwKYGFkaS1pM2Mt bWFzdGVyLmNgLiBgbWlwaS1pM2MtaGNpYCBpcyB0aGUgb25seSBvdXRsaWVyLgoKLS0tCgojIyBQ aGFzZSA2OiBDcm9zcy1SZWZlcmVuY2UgQWdhaW5zdCBMb2NhbCBUcmVlCgojIyMgU3RlcCA2LjE6 IEJ1Z2d5IENvZGUgRXhpc3RzPwoqKlJlY29yZDoqKiAqKlllcy4qKiBMb2NhbCB0cmVlIGlzICoq bGludXgtNi4xOC55KiogKGB2Ni4xOC40NGApLiBCb3RoCmBjbWRfdjEuYzozNjUtMzY3YCBhbmQg YGNtZF92Mi5jOjMwMy0zMDVgIHN0aWxsIGhhdmUgYHJldCA9CmkzY19tYXN0ZXJfYWRkX2kzY19k ZXZfbG9ja2VkKC4uLik7IGlmIChyZXQpIGJyZWFrO2AuIEJ1ZyBwcmVzZW50IHNpbmNlCmRyaXZl ciBpbnRyb2R1Y3Rpb24gKDIwMjApLgoKIyMjIFN0ZXAgNi4yOiBCYWNrcG9ydCBDb21wbGljYXRp b25zCioqUmVjb3JkOioqICoqQ2xlYW4gYXBwbHkuKiogYGdpdCBjaGVycnktcGljayAtLW5vLWNv bW1pdCBjMjM2NTYzYzhhODQyYAphdXRvLW1lcmdlZCBib3RoIGZpbGVzIHdpdGhvdXQgY29uZmxp Y3RzLgoKIyMjIFN0ZXAgNi4zOiBSZWxhdGVkIEZpeGVzIEFscmVhZHkgUHJlc2VudD8KKipSZWNv cmQ6KioKLSBQcmVyZXF1aXNpdGUgYDM4ZDNkMzNgIOKAlCAqKnByZXNlbnQqKgotIFN2YyBkcml2 ZXIgZXF1aXZhbGVudCBmaXggYDNiMmFjODEwYCDigJQgKipwcmVzZW50KioKLSBUaGlzIHNwZWNp ZmljIG1pcGktaTNjLWhjaSBmaXgg4oCUICoqbm90IHByZXNlbnQqKgoKLS0tCgojIyBQaGFzZSA3 OiBTdWJzeXN0ZW0gYW5kIE1haW50YWluZXIgQ29udGV4dAoKIyMjIFN0ZXAgNy4xOiBTdWJzeXN0 ZW0gQ3JpdGljYWxpdHkKKipSZWNvcmQ6KiogYGRyaXZlcnMvaTNjL21hc3Rlci9taXBpLWkzYy1o Y2kvYCDigJQgKipJTVBPUlRBTlQqKiAoYnVzCmRyaXZlciBhZmZlY3RpbmcgYWxsIEkzQyBwZXJp cGhlcmFscyBvbiBIQ0ktYmFzZWQgcGxhdGZvcm1zLCBidXQKaGFyZHdhcmUtc3BlY2lmaWMpLgoK IyMjIFN0ZXAgNy4yOiBTdWJzeXN0ZW0gQWN0aXZpdHkKKipSZWNvcmQ6KiogQWN0aXZlbHkgbWFp bnRhaW5lZCDigJQgbXVsdGlwbGUgbWlwaS1pM2MtaGNpIGZpeGVzIGluIDYuMTgueQooaG90LWpv aW4sIERNQSwgSVJRIGhhbmRsaW5nKS4KCi0tLQoKIyMgUGhhc2UgODogSW1wYWN0IGFuZCBSaXNr IEFzc2Vzc21lbnQKCiMjIyBTdGVwIDguMTogV2hvIElzIEFmZmVjdGVkCioqUmVjb3JkOioqIFVz ZXJzIG9mIGBDT05GSUdfSTNDYCB3aXRoIGBtaXBpLWkzYy1oY2lgIGhhcmR3YXJlIGFuZAptdWx0 aXBsZSBJM0MgZGV2aWNlcyBvbiB0aGUgYnVzLgoKIyMjIFN0ZXAgOC4yOiBUcmlnZ2VyIENvbmRp dGlvbnMKKipSZWNvcmQ6KiogREFBIGRpc2NvdmVycyDiiaUyIGRldmljZXM7IGBpM2NfbWFzdGVy X2FkZF9pM2NfZGV2X2xvY2tlZCgpYApmYWlscyBmb3IgYW4gZWFybHkgZGV2aWNlIChhbGxvY2F0 aW9uIGZhaWx1cmUsIENDQyByZXRyaWV2YWwgZXJyb3IsCmR1cGxpY2F0ZSBoYW5kbGluZywgZXRj LikuIE5vdCB0aW1pbmctZGVwZW5kZW50LiBSZXF1aXJlcyBgQ09ORklHX0kzQ2AgKwptaXBpLWkz Yy1oY2kuIFVucHJpdmlsZWdlZCB1c2VycyBjYW5ub3QgZGlyZWN0bHkgdHJpZ2dlciwgYnV0IGFm ZmVjdHMKc3lzdGVtIGhhcmR3YXJlIGZ1bmN0aW9uYWxpdHkgYXQgYm9vdC9wcm9iZS4KCiMjIyBT dGVwIDguMzogRmFpbHVyZSBNb2RlIFNldmVyaXR5CioqUmVjb3JkOioqIFN1YnNlcXVlbnQgSTND IGRldmljZXMgZmFpbCB0byByZWdpc3RlciDigJQKc2Vuc29ycy9wZXJpcGhlcmFscyBtaXNzaW5n LCBwb3RlbnRpYWwgYnVzIHN0YXRlIGluY29uc2lzdGVuY3kgKGhhcmR3YXJlCmhhcyBhZGRyZXNz IGFzc2lnbmVkLCBrZXJuZWwgdW5hd2FyZSkuICoqU2V2ZXJpdHk6IE1FRElVTS1ISUdIKiogZm9y CmFmZmVjdGVkIGhhcmR3YXJlIChmdW5jdGlvbmFsIGZhaWx1cmUsIG5vdCBrZXJuZWwgY3Jhc2gp LiBQcmUtYDM4ZDNkMzNgLApjb3VsZCBhbHNvIGNhdXNlIGFkZHJlc3MgY29uZmxpY3RzIG9uIGhv dC1qb2luIChkb2N1bWVudGVkIGluIHN2YyBmaXgpOwp0aGF0IHBhcnQgaXMgZml4ZWQsIGJ1dCBw YXJ0aWFsIGVudW1lcmF0aW9uIHJlbWFpbnMuCgojIyMgU3RlcCA4LjQ6IFJpc2stQmVuZWZpdAoq KlJlY29yZDoqKgotICoqQmVuZWZpdDoqKiBISUdIIGZvciBhZmZlY3RlZCBwbGF0Zm9ybXMg4oCU IHJlc3RvcmVzIG11bHRpLWRldmljZQogIGVudW1lcmF0aW9uOyBjb21wbGV0ZXMgYmVoYXZpb3Ig Y2hhbmdlIHN0YXJ0ZWQgYnkgYDM4ZDNkMzNgIGJhY2twb3J0Ci0gKipSaXNrOioqIFZFUlkgTE9X IOKAlCA2LWxpbmUgdG90YWwgcmVtb3ZhbCwgbWF0Y2hlcyBmaXZlIG90aGVyIGRyaXZlcnMsCiAg cHJlcmVxdWlzaXRlIGFscmVhZHkgaW4gdHJlZQotICoqUmF0aW86KiogU3Ryb25nIGJlbmVmaXQs IG1pbmltYWwgcmlzawoKLS0tCgojIyBQaGFzZSA5OiBGaW5hbCBTeW50aGVzaXMKCiMjIyBTdGVw IDkuMTogRXZpZGVuY2UgU3VtbWFyeQoKKipGT1IgYmFja3BvcnQ6KioKLSBSZWFsIGZ1bmN0aW9u YWwgYnVnIHdpdGggZG9jdW1lbnRlZCBwcmVjZWRlbnQgKGAzYjJhYzgxMGAsIENjOiBzdGFibGUp Ci0gUHJlcmVxdWlzaXRlIGAzOGQzZDMzYCBhbHJlYWR5IGluIDYuMTgueQotIFN1cmdpY2FsIDYt bGluZSBmaXgsIHJldmlld2VkIGJ5IE5YUCBtYWludGFpbmVyCi0gQXBwbGllcyBjbGVhbmx5Ci0g QWxpZ25zIG1pcGktaTNjLWhjaSB3aXRoIGFsbCBvdGhlciBJM0MgbWFzdGVyIGRyaXZlcnMKLSBD b21wbGV0ZXMgYWRkcmVzcy1tYW5hZ2VtZW50IGZpeCBzZXJpZXMgcGFydGlhbGx5IGJhY2twb3J0 ZWQgdG8gc3RhYmxlCgoqKkFHQUlOU1QgYmFja3BvcnQ6KioKLSBObyBjcmFzaCwgc2VjdXJpdHkg aXNzdWUsIG9yIGRhdGEgY29ycnVwdGlvbgotIEhhcmR3YXJlLXNwZWNpZmljIChtaXBpLWkzYy1o Y2kgb25seSkKLSBSZXF1aXJlcyBgaTNjX21hc3Rlcl9hZGRfaTNjX2Rldl9sb2NrZWQoKWAgZmFp bHVyZSAobm90IGV2ZXJ5ZGF5LCBidXQKICBwbGF1c2libGUpCi0gUGFydCBvZiBsYXJnZXIgc2Vy aWVzIChidXQgdGhpcyBwYXRjaCBpcyBzZWxmLWNvbnRhaW5lZCB3aXRoCiAgcHJlcmVxdWlzaXRl KQoKKipVbnJlc29sdmVkOioqIE5vIHVzZXIgYnVnIHJlcG9ydCBvciBzeXpib3QgcmVwcm9kdWN0 aW9uOyBpbXBhY3QKaW5mZXJyZWQgZnJvbSBjb2RlIGFuYWx5c2lzIGFuZCBzdmMtZHJpdmVyIHBy ZWNlZGVudC4KCiMjIyBTdGVwIDkuMjogU3RhYmxlIFJ1bGVzIENoZWNrbGlzdAoxLiBPYnZpb3Vz bHkgY29ycmVjdCBhbmQgdGVzdGVkPyAqKlBBU1MqKiDigJQgbWF0Y2hlcyBlc3RhYmxpc2hlZCBk cml2ZXIKICAgcGF0dGVybjsgUmV2aWV3ZWQtYnkgRnJhbmsgTGkKMi4gRml4ZXMgYSByZWFsIGJ1 Zz8gKipQQVNTKiog4oCUIHByZW1hdHVyZSBEQUEgYWJvcnQgbGVhdmVzIGRldmljZXMKICAgdW5k aXNjb3ZlcmVkCjMuIEltcG9ydGFudCBpc3N1ZT8gKipQQVNTKiog4oCUIGZ1bmN0aW9uYWwgaGFy ZHdhcmUgZmFpbHVyZSBvbiBtdWx0aS0KICAgZGV2aWNlIEkzQyBidXNlcyAoTUVESVVNLUhJR0gg Zm9yIGFmZmVjdGVkIHVzZXJzKQo0LiBTbWFsbCBhbmQgY29udGFpbmVkPyAqKlBBU1MqKiDigJQg MiBmaWxlcywgNiBsaW5lcyByZW1vdmVkCjUuIE5vIG5ldyBmZWF0dXJlcy9BUElzPyAqKlBBU1Mq KiDigJQgYmVoYXZpb3IgYWxpZ25tZW50IG9ubHkKNi4gQ2FuIGFwcGx5IHRvIGxvY2FsIHRyZWU/ ICoqUEFTUyoqIOKAlCBjbGVhbiBjaGVycnktcGljazsgcHJlcmVxdWlzaXRlCiAgIHByZXNlbnQK CiMjIyBTdGVwIDkuMzogRXhjZXB0aW9uIENhdGVnb3JpZXMKKipSZWNvcmQ6KiogTi9BIOKAlCBu b3QgYSBkZXZpY2UgSUQsIHF1aXJrLCBEVCwgYnVpbGQsIG9yIGRvY3MgZml4LgpTdGFuZGFyZCBk cml2ZXIgYnVnIGZpeC4KCiMjIyBTdGVwIDkuNDogRGVjaXNpb24gUmF0aW9uYWxlClRoaXMgZml4 IHNob3VsZCBiZSBiYWNrcG9ydGVkIHRvICoqbGludXgtNi4xOC55KiogYmVjYXVzZSB0aGUKcHJl cmVxdWlzaXRlIGNvbW1pdCBjaGFuZ2luZyBgaTNjX21hc3Rlcl9hZGRfaTNjX2Rldl9sb2NrZWQo KWAgZmFpbHVyZQpzZW1hbnRpY3MgaXMgYWxyZWFkeSBpbiB0aGUgdHJlZSwgYnV0IGBtaXBpLWkz Yy1oY2lgIHN0aWxsIGFib3J0cyBEQUEgb24KcmVnaXN0cmF0aW9uIGZhaWx1cmUg4oCUIGxlYXZp bmcgc3Vic2VxdWVudCBkZXZpY2VzIHVuZGlzY292ZXJlZC4gVGhlCmlkZW50aWNhbCBpc3N1ZSB3 YXMgZml4ZWQgYW5kIHN0YWJsZS1ub21pbmF0ZWQgZm9yIHRoZSBzdmMgZHJpdmVyLiBUaGlzCmlz IHRoZSBjb21wYW5pb24gZml4IGZvciB0aGUgSENJIGRyaXZlciwgc21hbGwgYW5kIGxvdy1yaXNr LgoKLS0tCgojIyBWZXJpZmljYXRpb24KCi0gW1BoYXNlIDFdIGBnaXQgc2hvdyBjMjM2NTYzYzhh ODQyYDogcGFyc2VkIHN1YmplY3QsIHRhZ3MsIGJvZHkKLSBbUGhhc2UgMl0gRGlmZjogMiBmaWxl cywgYGhjaV9jbWRfdjFfZGFhYC9gaGNpX2NtZF92Ml9kYWFgLCA2IGxpbmVzCiAgcmVtb3ZlZAot IFtQaGFzZSAzXSBgZ2l0IGJsYW1lIGNtZF92MS5jOjM2NS0zNjdgOiBpbnRyb2R1Y2VkIGA5YWQ5 YTUyYCAoMjAyMCkKLSBbUGhhc2UgM10gYGdpdCBtZXJnZS1iYXNlIC0taXMtYW5jZXN0b3IgMzhk M2QzM2JmNDJjMiBIRUFEYDoKICBwcmVyZXF1aXNpdGUgcHJlc2VudAotIFtQaGFzZSAzXSBgZ2l0 IHNob3cgMzhkM2QzM2A6IGBlcnJfcHJldmVudF9hZGRyX3JldXNlYCBoYW5kbGVyCiAgY29uZmly bWVkCi0gW1BoYXNlIDNdIGBnaXQgc2hvdyAzYjJhYzgxMGA6IHN2YyBkcml2ZXIgaWRlbnRpY2Fs IGZpeCB3aXRoIENjOgogIHN0YWJsZQotIFtQaGFzZSAzXSBgZ2l0IG1lcmdlLWJhc2UgLS1pcy1h bmNlc3RvciAzYjJhYzgxMCBIRUFEYDogc3ZjIGZpeCBpbgogIHRyZWUKLSBbUGhhc2UgNF0gYGI0 IGRpZyAtYyBjMjM2NTYzYzhhODQyYDogbG9yZSBVUkwgZm91bmQKLSBbUGhhc2UgNF0gYGI0IGRp ZyAtYWA6IFYx4oCTVjQgc2VyaWVzLCBwYXRjaCA0LzcKLSBbUGhhc2UgNF0gYGI0IGRpZyAtd2A6 IG1haW50YWluZXJzIENDJ2QKLSBbUGhhc2UgNF0gYC90bXAvaTNjX2RhYS5tYm94YDogY292ZXIg bGV0dGVyLCBwYXRjaGVzIDHigJM3IHN1YmplY3RzOwogIHBhdGNoIDcgbm90IG1lcmdlZCB1cHN0 cmVhbQotIFtQaGFzZSA1XSBgZ3JlcCBpM2NfbWFzdGVyX2FkZF9pM2NfZGV2X2xvY2tlZCBkcml2 ZXJzL2kzYy9tYXN0ZXIvYDogNQogIG90aGVyIGRyaXZlcnMgaWdub3JlIHJldHVybgotIFtQaGFz ZSA1XSBgY29yZS5jOjI2Ni0yNzBgOiBgaTNjX2hjaV9kYWFgIOKGkiBgcGVyZm9ybV9kYWFgIGNh bGwgY2hhaW4KLSBbUGhhc2UgNl0gYGdpdCBkZXNjcmliZSBIRUFEYDogdjYuMTguNDQgKGxpbnV4 LTYuMTgueSkKLSBbUGhhc2UgNl0gUmVhZCBgY21kX3YxLmM6MzY1LTM2N2AsIGBjbWRfdjIuYzoz MDMtMzA1YDogYnVnZ3kgY29kZQogIHByZXNlbnQKLSBbUGhhc2UgNl0gYGdpdCBjaGVycnktcGlj ayAtLW5vLWNvbW1pdCBjMjM2NTYzYzhhODQyYDogY2xlYW4gYXBwbHkKLSBbUGhhc2UgNl0gYGdp dCBsb2cgSEVBRC4uYzIzNjU2M2M4YTg0MiAtLQogIGRyaXZlcnMvaTNjL21hc3Rlci9taXBpLWkz Yy1oY2kvYDogZml4IG5vdCBpbiB0cmVlCi0gW1BoYXNlIDddIGBnaXQgbG9nIC0yMCAtLSBkcml2 ZXJzL2kzYy9tYXN0ZXIvbWlwaS1pM2MtaGNpL2A6IGFjdGl2ZQogIHN1YnN5c3RlbQotIFtQaGFz ZSA4XSBSZWFkIGBzdmMtaTNjLW1hc3Rlci5jOjEyMDUtMTIyNWA6IGRvY3VtZW50ZWQgZmFpbHVy ZSBtb2RlCgoqKllFUyoqCgogZHJpdmVycy9pM2MvbWFzdGVyL21pcGktaTNjLWhjaS9jbWRfdjEu YyB8IDQgKy0tLQogZHJpdmVycy9pM2MvbWFzdGVyL21pcGktaTNjLWhjaS9jbWRfdjIuYyB8IDQg Ky0tLQogMiBmaWxlcyBjaGFuZ2VkLCAyIGluc2VydGlvbnMoKyksIDYgZGVsZXRpb25zKC0pCgpk aWZmIC0tZ2l0IGEvZHJpdmVycy9pM2MvbWFzdGVyL21pcGktaTNjLWhjaS9jbWRfdjEuYyBiL2Ry aXZlcnMvaTNjL21hc3Rlci9taXBpLWkzYy1oY2kvY21kX3YxLmMKaW5kZXggZWZiN2ExZjkyNjQx Yy4uYjZiYTE4Y2NkZDJkMyAxMDA2NDQKLS0tIGEvZHJpdmVycy9pM2MvbWFzdGVyL21pcGktaTNj LWhjaS9jbWRfdjEuYworKysgYi9kcml2ZXJzL2kzYy9tYXN0ZXIvbWlwaS1pM2MtaGNpL2NtZF92 MS5jCkBAIC0zNjIsOSArMzYyLDcgQEAgc3RhdGljIGludCBoY2lfY21kX3YxX2RhYShzdHJ1Y3Qg aTNjX2hjaSAqaGNpKQogCQkgKiBUT0RPOiBFeHRlbmQgdGhlIHN1YnN5c3RlbSBsYXllciB0byBh bGxvdyBmb3IgcmVnaXN0ZXJpbmcKIAkJICogbmV3IGRldmljZSBhbmQgcHJvdmlkZSBCQ1IvRENS L1BJRCBhdCB0aGUgc2FtZSB0aW1lLgogCQkgKi8KLQkJcmV0ID0gaTNjX21hc3Rlcl9hZGRfaTNj X2Rldl9sb2NrZWQoJmhjaS0+bWFzdGVyLCBuZXh0X2FkZHIpOwotCQlpZiAocmV0KQotCQkJYnJl YWs7CisJCWkzY19tYXN0ZXJfYWRkX2kzY19kZXZfbG9ja2VkKCZoY2ktPm1hc3RlciwgbmV4dF9h ZGRyKTsKIAl9CiAKIAlpZiAoZGF0X2lkeCA+PSAwKQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9pM2Mv bWFzdGVyL21pcGktaTNjLWhjaS9jbWRfdjIuYyBiL2RyaXZlcnMvaTNjL21hc3Rlci9taXBpLWkz Yy1oY2kvY21kX3YyLmMKaW5kZXggNWZjMmU0YzU1ZWJiMC4uZDc5OTlkMzQxYTIyNyAxMDA2NDQK LS0tIGEvZHJpdmVycy9pM2MvbWFzdGVyL21pcGktaTNjLWhjaS9jbWRfdjIuYworKysgYi9kcml2 ZXJzL2kzYy9tYXN0ZXIvbWlwaS1pM2MtaGNpL2NtZF92Mi5jCkBAIC0zMDAsOSArMzAwLDcgQEAg c3RhdGljIGludCBoY2lfY21kX3YyX2RhYShzdHJ1Y3QgaTNjX2hjaSAqaGNpKQogCQkgKiBUT0RP OiBFeHRlbmQgdGhlIHN1YnN5c3RlbSBsYXllciB0byBhbGxvdyBmb3IgcmVnaXN0ZXJpbmcKIAkJ ICogbmV3IGRldmljZSBhbmQgcHJvdmlkZSBCQ1IvRENSL1BJRCBhdCB0aGUgc2FtZSB0aW1lLgog CQkgKi8KLQkJcmV0ID0gaTNjX21hc3Rlcl9hZGRfaTNjX2Rldl9sb2NrZWQoJmhjaS0+bWFzdGVy LCBuZXh0X2FkZHIpOwotCQlpZiAocmV0KQotCQkJYnJlYWs7CisJCWkzY19tYXN0ZXJfYWRkX2kz Y19kZXZfbG9ja2VkKCZoY2ktPm1hc3RlciwgbmV4dF9hZGRyKTsKIAl9CiAKIAloY2lfZnJlZV94 ZmVyKHhmZXIsIDIpOwotLSAKMi41My4wCgoKLS0gCmxpbnV4LWkzYyBtYWlsaW5nIGxpc3QKbGlu dXgtaTNjQGxpc3RzLmluZnJhZGVhZC5vcmcKaHR0cDovL2xpc3RzLmluZnJhZGVhZC5vcmcvbWFp bG1hbi9saXN0aW5mby9saW51eC1pM2MK 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 250E859A950; Mon, 31 Aug 2026 13:51:36 +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=1788184299; cv=none; b=UuVBWtNdE1ZMTGKjkESH86PD4PClHeZ7V4Pw7QgnO+VgUNun3bAIQaNJKyABI1MhM60qSXtPaFysJvDbpoNwe4VPiWO8VURZLeA4FhB92ZjqsjXD+/TeRq6Qcds4nGB4/f6FvmQc4KjXQWOAGfyOTZUxeeCeHYvN5Xbp99VWAik= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1788184299; c=relaxed/simple; bh=T1tr1av3QJ/VTZ36RUanPPipkl7YvT0IjXBL4vUX3Fc=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=ppQduPVHa1sPU+oaAVc4GoQtrHc2Qx4VbalSqEiFLznYeuHwyM7P6fgN95CjV7++QDxylKxJ96TzVe1GXoAtZ1w5YoQwyQTGHs6LvTdrgafMfagT+WJggMoGyEzzjnNMHw+5PfmvncGK7UdBLv7nklyi28YI+RcraC4zO1WMR7Y= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=CxBtHd88; 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="CxBtHd88" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 7E5E41F00A3D; Mon, 31 Aug 2026 13:51:35 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1788184296; bh=KFrji6sAEM01oX6Klu9JH/k5CoftNiOX7x3iUh3LoAA=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=CxBtHd88uXelOluNaufe+NjtlDvdfT/eeqECvUk6KjWlIUGKKc/i0zLeeswXYBlxd gRTopZz91WF39jAyQ7kx9bvVrKYmXHZWo0XLFeWY94+K/OXkGlfQEAIpDSYnJe1DyD FTDR0yiwQfYiG3i3CIk5VmilK6pYP+Ye9qNoOMZAh+VSFz5s+2WfcDK6lP99E41hIx IHSZ8kpVACum83Q15XszJRa4W9DUJpG/ebDX/8lAlrfYD0rOSRdHdYL9iLtwLcvF/C +Orr+8+t4VVkdOXw9nqjHayzNs0KyMcgUOO2sVtwm5DUtTFpALX05Yl6+6pfZcLz+R 6xEO+pUu93cLg== From: Sasha Levin To: patches@lists.linux.dev, stable@vger.kernel.org Cc: Adrian Hunter , Frank Li , Alexandre Belloni , Sasha Levin , linux-i3c@lists.infradead.org, linux-kernel@vger.kernel.org Subject: [PATCH AUTOSEL 6.18-5.15] i3c: mipi-i3c-hci: Tolerate i3c_master_add_i3c_dev_locked() failures in DAA Date: Mon, 31 Aug 2026 09:30:36 -0400 Message-ID: <20260831133314.4125787-608-sashal@kernel.org> X-Mailer: git-send-email 2.53.0 In-Reply-To: <20260831133314.4125787-1-sashal@kernel.org> References: <20260831133314.4125787-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 6.18.48 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit From: Adrian Hunter [ Upstream commit c236563c8a84239d31a1e6ec4444887a7b5ed98f ] i3c_master_add_i3c_dev_locked() no longer leaves the address marked as free on failure, so aborting the DAA sequence on its error is unnecessary. Failure to register a discovered device does not invalidate the entire Dynamic Address Assignment (DAA) procedure. Align with the behavior of other I3C master drivers by ignoring errors from i3c_master_add_i3c_dev_locked() and continuing enumeration. Signed-off-by: Adrian Hunter Reviewed-by: Frank Li Link: https://patch.msgid.link/20260612080107.11606-5-adrian.hunter@intel.com Signed-off-by: Alexandre Belloni Signed-off-by: Sasha Levin --- LLM Generated explanations, may be completely bogus: ## Phase 1: Commit Message Forensics ### Step 1.1: Subject Line **Record:** `[i3c: mipi-i3c-hci]` `[Tolerate]` — Stop aborting DAA when `i3c_master_add_i3c_dev_locked()` fails; continue enumeration instead. ### Step 1.2: Tags **Record:** - **Signed-off-by:** Adrian Hunter `` (author) - **Reviewed-by:** Frank Li `` (NXP I3C maintainer) - **Link:** https://patch.msgid.link/20260612080107.11606-5- adrian.hunter@intel.com - **Signed-off-by:** Alexandre Belloni `` (I3C subsystem maintainer) - No Fixes:, Reported-by:, Tested-by:, Cc: stable, or syzbot tags - Notable: Reviewed by subsystem expert; part of V4 4/7 series ### Step 1.3: Body Analysis **Record:** - **Bug:** `mipi-i3c-hci` aborts the entire DAA loop when `i3c_master_add_i3c_dev_locked()` fails for one device. - **Symptom:** Remaining I3C devices on the bus are never enumerated/registered after a single device-add failure. - **Root cause (per author):** After commit `38d3d33` ("Prevent reuse of dynamic address on device add failure"), failed registration no longer frees the address slot, so aborting DAA is unnecessary and harmful. - **Fix approach:** Ignore the return value and continue DAA, matching `svc-i3c-master`, `cdns`, `renesas`, `dw`, and `adi` drivers. - No explicit kernel version range in message. ### Step 1.4: Hidden Bug Fix Detection **Record:** Yes — described as alignment/cleanup, but it fixes a real logic bug: premature DAA termination leaves devices undiscovered. Same class of bug fixed in `svc-i3c-master` (commit `3b2ac810`, Cc: stable). --- ## Phase 2: Diff Analysis ### Step 2.1: Inventory **Record:** - `drivers/i3c/master/mipi-i3c-hci/cmd_v1.c`: −3 lines (remove ret check + break) - `drivers/i3c/master/mipi-i3c-hci/cmd_v2.c`: −3 lines (same) - Functions: `hci_cmd_v1_daa()`, `hci_cmd_v2_daa()` - Scope: single-file surgical fix in one driver (2 command variants) ### Step 2.2: Code Flow Change **Record:** - **Hunk 1 (`cmd_v1.c`):** Before: assign address via hardware DAA → call `i3c_master_add_i3c_dev_locked()` → on error, `break` out of DAA loop. After: call function without checking return; loop continues to next device. - **Hunk 2 (`cmd_v2.c`):** Identical behavioral change in v2 DAA path. - Affected path: normal DAA enumeration loop during bus probe / hot- join. ### Step 2.3: Bug Mechanism **Record:** - **Category:** Logic/correctness fix (error-path handling) - **Mechanism:** Treating a per-device registration failure as fatal to the entire multi-device DAA sequence. With prerequisite `38d3d33`, the address is retained on failure, so continuing is safe. Aborting prevents registration of subsequently discovered devices. ### Step 2.4: Fix Quality **Record:** Obviously correct — matches established pattern in five other I3C master drivers. Minimal change. Low regression risk: only removes an overly aggressive early-exit; real bus/transfer errors still break the loop via `RESP_STATUS` checks. --- ## Phase 3: Git History Investigation ### Step 3.1: Blame **Record:** Buggy `if (ret) break;` pattern introduced in `9ad9a52cce282` (Nov 2020, "i3c/master: introduce the mipi-i3c-hci driver"). Present since driver introduction. ### Step 3.2: Fixes: Tag **Record:** N/A — no Fixes: tag. Prerequisite identified from commit message: `38d3d33bf42c2` / upstream `b3ba8383da4d0` ("Prevent reuse of dynamic address on device add failure"), which changes `i3c_master_add_i3c_dev_locked()` to mark addresses as occupied on failure via `err_prevent_addr_reuse`. **Confirmed present in this tree** (`git merge-base --is-ancestor` passes). ### Step 3.3: Related File History **Record:** Recent related commits in tree: - `38d3d33` — prerequisite (already backported to 6.18.y) - `3b2ac810` — svc driver: identical "don't check return value" fix (in tree, Cc: stable) - Fix commit `c236563c8a842` is in mainline but **not yet in this 6.18.44 checkout** ### Step 3.4: Author Context **Record:** Adrian Hunter is an active Intel I3C contributor. Multiple related fixes in `drivers/i3c/` around DAA, hot-join, and address management (Jun 2026 series). ### Step 3.5: Dependencies **Record:** - **Hard dependency:** `38d3d33` (already in tree) — without it, continuing DAA after failure could reassign addresses. - **Not required:** Patches 1/7 (race fix), 2/7 (DISEC), 5–7/7 (return- void API change + reconciliation — **not merged to mainline**). - **Standalone:** Yes, for stable purposes, given prerequisite is present. --- ## Phase 4: Mailing List and External Research ### Step 4.1: Original Discussion **Record:** - **URL:** https://patch.msgid.link/20260612080107.11606-5- adrian.hunter@intel.com - **Series:** V1→V4, patch 4/7; applied version is latest (V4) - **Cover letter (V4 0/7):** "Patches 3-7 fix address management issues... when DAA does not complete cleanly" - **Reviewer feedback:** "Applied, thanks!" from maintainer on cover letter - No explicit stable nomination found in mbox for this specific patch ### Step 4.2: Reviewers **Record:** CC'd: `alexandre.belloni@bootlin.com`, `Frank.Li@nxp.com`, `linux-i3c@lists.infradead.org`, `linux-kernel@vger.kernel.org`. Reviewed-by Frank Li (NXP). ### Step 4.3: Bug Report **Record:** No external bug report or syzbot link. Bug identified through code review / series development. Precedent: `3b2ac810` documented identical failure mode for svc driver with explicit I3C spec violation scenario. ### Step 4.4: Related Patches **Record:** Part of 7-patch V4 series. Patches 5–7 (API change to void return + post-DAA reconciliation) were **not** merged upstream. This patch was merged standalone with patch 3. ### Step 4.5: Stable List History **Record:** No stable-list discussion found for this specific patch. Prerequisite `38d3d33` was backported to this tree (has upstream-commit marker and Greg K commit). --- ## Phase 5: Code Semantic Analysis ### Step 5.1: Key Functions **Record:** `hci_cmd_v1_daa()`, `hci_cmd_v2_daa()`, called via `i3c_hci_daa()` in `core.c`. ### Step 5.2: Callers **Record:** `i3c_hci_daa()` → registered as `master->ops.do_daa` → invoked by `i3c_master_do_daa()` / `i3c_master_do_daa_ext()` during bus initialization and hot-join DAA. Called during device probe, not a hot syscall path. ### Step 5.3: Callees **Record:** `i3c_master_add_i3c_dev_locked()` — allocates device, retrieves CCC info, attaches to bus. On failure (with `38d3d33`): logs error, marks address slot occupied, returns error code. ### Step 5.4: Reachability **Record:** Triggered during I3C bus enumeration on systems using `mipi-i3c-hci` (Intel and other MIPI HCI platforms). Multi-device buses are common (sensors, PMICs, etc.). Failure of one device's registration is plausible (transient CCC errors, firmware quirks). ### Step 5.5: Similar Patterns **Record:** All other I3C master drivers ignore `i3c_master_add_i3c_dev_locked()` return during DAA: ```1224:1225:drivers/i3c/master/svc-i3c-master.c for (i = 0; i < dev_nb; i++) i3c_master_add_i3c_dev_locked(m, addrs[i]); ``` Same pattern in `renesas-i3c.c`, `i3c-master-cdns.c`, `dw-i3c-master.c`, `adi-i3c-master.c`. `mipi-i3c-hci` is the only outlier. --- ## Phase 6: Cross-Reference Against Local Tree ### Step 6.1: Buggy Code Exists? **Record:** **Yes.** Local tree is **linux-6.18.y** (`v6.18.44`). Both `cmd_v1.c:365-367` and `cmd_v2.c:303-305` still have `ret = i3c_master_add_i3c_dev_locked(...); if (ret) break;`. Bug present since driver introduction (2020). ### Step 6.2: Backport Complications **Record:** **Clean apply.** `git cherry-pick --no-commit c236563c8a842` auto-merged both files without conflicts. ### Step 6.3: Related Fixes Already Present? **Record:** - Prerequisite `38d3d33` — **present** - Svc driver equivalent fix `3b2ac810` — **present** - This specific mipi-i3c-hci fix — **not present** --- ## Phase 7: Subsystem and Maintainer Context ### Step 7.1: Subsystem Criticality **Record:** `drivers/i3c/master/mipi-i3c-hci/` — **IMPORTANT** (bus driver affecting all I3C peripherals on HCI-based platforms, but hardware-specific). ### Step 7.2: Subsystem Activity **Record:** Actively maintained — multiple mipi-i3c-hci fixes in 6.18.y (hot-join, DMA, IRQ handling). --- ## Phase 8: Impact and Risk Assessment ### Step 8.1: Who Is Affected **Record:** Users of `CONFIG_I3C` with `mipi-i3c-hci` hardware and multiple I3C devices on the bus. ### Step 8.2: Trigger Conditions **Record:** DAA discovers ≥2 devices; `i3c_master_add_i3c_dev_locked()` fails for an early device (allocation failure, CCC retrieval error, duplicate handling, etc.). Not timing-dependent. Requires `CONFIG_I3C` + mipi-i3c-hci. Unprivileged users cannot directly trigger, but affects system hardware functionality at boot/probe. ### Step 8.3: Failure Mode Severity **Record:** Subsequent I3C devices fail to register — sensors/peripherals missing, potential bus state inconsistency (hardware has address assigned, kernel unaware). **Severity: MEDIUM-HIGH** for affected hardware (functional failure, not kernel crash). Pre-`38d3d33`, could also cause address conflicts on hot-join (documented in svc fix); that part is fixed, but partial enumeration remains. ### Step 8.4: Risk-Benefit **Record:** - **Benefit:** HIGH for affected platforms — restores multi-device enumeration; completes behavior change started by `38d3d33` backport - **Risk:** VERY LOW — 6-line total removal, matches five other drivers, prerequisite already in tree - **Ratio:** Strong benefit, minimal risk --- ## Phase 9: Final Synthesis ### Step 9.1: Evidence Summary **FOR backport:** - Real functional bug with documented precedent (`3b2ac810`, Cc: stable) - Prerequisite `38d3d33` already in 6.18.y - Surgical 6-line fix, reviewed by NXP maintainer - Applies cleanly - Aligns mipi-i3c-hci with all other I3C master drivers - Completes address-management fix series partially backported to stable **AGAINST backport:** - No crash, security issue, or data corruption - Hardware-specific (mipi-i3c-hci only) - Requires `i3c_master_add_i3c_dev_locked()` failure (not everyday, but plausible) - Part of larger series (but this patch is self-contained with prerequisite) **Unresolved:** No user bug report or syzbot reproduction; impact inferred from code analysis and svc-driver precedent. ### Step 9.2: Stable Rules Checklist 1. Obviously correct and tested? **PASS** — matches established driver pattern; Reviewed-by Frank Li 2. Fixes a real bug? **PASS** — premature DAA abort leaves devices undiscovered 3. Important issue? **PASS** — functional hardware failure on multi- device I3C buses (MEDIUM-HIGH for affected users) 4. Small and contained? **PASS** — 2 files, 6 lines removed 5. No new features/APIs? **PASS** — behavior alignment only 6. Can apply to local tree? **PASS** — clean cherry-pick; prerequisite present ### Step 9.3: Exception Categories **Record:** N/A — not a device ID, quirk, DT, build, or docs fix. Standard driver bug fix. ### Step 9.4: Decision Rationale This fix should be backported to **linux-6.18.y** because the prerequisite commit changing `i3c_master_add_i3c_dev_locked()` failure semantics is already in the tree, but `mipi-i3c-hci` still aborts DAA on registration failure — leaving subsequent devices undiscovered. The identical issue was fixed and stable-nominated for the svc driver. This is the companion fix for the HCI driver, small and low-risk. --- ## Verification - [Phase 1] `git show c236563c8a842`: parsed subject, tags, body - [Phase 2] Diff: 2 files, `hci_cmd_v1_daa`/`hci_cmd_v2_daa`, 6 lines removed - [Phase 3] `git blame cmd_v1.c:365-367`: introduced `9ad9a52` (2020) - [Phase 3] `git merge-base --is-ancestor 38d3d33bf42c2 HEAD`: prerequisite present - [Phase 3] `git show 38d3d33`: `err_prevent_addr_reuse` handler confirmed - [Phase 3] `git show 3b2ac810`: svc driver identical fix with Cc: stable - [Phase 3] `git merge-base --is-ancestor 3b2ac810 HEAD`: svc fix in tree - [Phase 4] `b4 dig -c c236563c8a842`: lore URL found - [Phase 4] `b4 dig -a`: V1–V4 series, patch 4/7 - [Phase 4] `b4 dig -w`: maintainers CC'd - [Phase 4] `/tmp/i3c_daa.mbox`: cover letter, patches 1–7 subjects; patch 7 not merged upstream - [Phase 5] `grep i3c_master_add_i3c_dev_locked drivers/i3c/master/`: 5 other drivers ignore return - [Phase 5] `core.c:266-270`: `i3c_hci_daa` → `perform_daa` call chain - [Phase 6] `git describe HEAD`: v6.18.44 (linux-6.18.y) - [Phase 6] Read `cmd_v1.c:365-367`, `cmd_v2.c:303-305`: buggy code present - [Phase 6] `git cherry-pick --no-commit c236563c8a842`: clean apply - [Phase 6] `git log HEAD..c236563c8a842 -- drivers/i3c/master/mipi-i3c-hci/`: fix not in tree - [Phase 7] `git log -20 -- drivers/i3c/master/mipi-i3c-hci/`: active subsystem - [Phase 8] Read `svc-i3c-master.c:1205-1225`: documented failure mode **YES** drivers/i3c/master/mipi-i3c-hci/cmd_v1.c | 4 +--- drivers/i3c/master/mipi-i3c-hci/cmd_v2.c | 4 +--- 2 files changed, 2 insertions(+), 6 deletions(-) diff --git a/drivers/i3c/master/mipi-i3c-hci/cmd_v1.c b/drivers/i3c/master/mipi-i3c-hci/cmd_v1.c index efb7a1f92641c..b6ba18ccdd2d3 100644 --- a/drivers/i3c/master/mipi-i3c-hci/cmd_v1.c +++ b/drivers/i3c/master/mipi-i3c-hci/cmd_v1.c @@ -362,9 +362,7 @@ static int hci_cmd_v1_daa(struct i3c_hci *hci) * TODO: Extend the subsystem layer to allow for registering * new device and provide BCR/DCR/PID at the same time. */ - ret = i3c_master_add_i3c_dev_locked(&hci->master, next_addr); - if (ret) - break; + i3c_master_add_i3c_dev_locked(&hci->master, next_addr); } if (dat_idx >= 0) diff --git a/drivers/i3c/master/mipi-i3c-hci/cmd_v2.c b/drivers/i3c/master/mipi-i3c-hci/cmd_v2.c index 5fc2e4c55ebb0..d7999d341a227 100644 --- a/drivers/i3c/master/mipi-i3c-hci/cmd_v2.c +++ b/drivers/i3c/master/mipi-i3c-hci/cmd_v2.c @@ -300,9 +300,7 @@ static int hci_cmd_v2_daa(struct i3c_hci *hci) * TODO: Extend the subsystem layer to allow for registering * new device and provide BCR/DCR/PID at the same time. */ - ret = i3c_master_add_i3c_dev_locked(&hci->master, next_addr); - if (ret) - break; + i3c_master_add_i3c_dev_locked(&hci->master, next_addr); } hci_free_xfer(xfer, 2); -- 2.53.0