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 A064A57C718; Mon, 31 Aug 2026 13:49:29 +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=1788184172; cv=none; b=ECtlt5Ri2dtO7SXco913ciRfv+FD5EwBlgNwrlsTKFTMVo1u0cfEnYIW7OZhRtVR1fsPsvr7Qizg118taHL1g4CUuqTpKzbSMaPGg0yhfWS1vD3v6+ecNOJrhIYm5lVIcZcqfvc4jRTqzQNn5xNG88Kw0NBTDu7XdtTpnIDUs1o= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1788184172; c=relaxed/simple; bh=F++zOrZUfFCl4dMqyhUNgy1wujKjS2nvZvxLdPsb8nU=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version:Content-Type; b=ozbir6V9XP5nGW9uuxf1DWiSRLTmvZOR4OqSv7nzuL/WhAGeaRio3Jyi1rSntvefEGQyirO3CApG6rweSyhfOWE35zCA5B7l1tcTOPeJVqIJ9s09tzHjT7GYT52baVhExhAHUxEN/entfxddFrfvfJ8VkzjuBqdhF3kowi0v6SU= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=Iz8Pt/+m; 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="Iz8Pt/+m" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 79D861F00A3D; Mon, 31 Aug 2026 13:49:27 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1788184169; bh=aNzPL9t3Ch3R/81vyFJ8KYM8BGwN9BjbkzaDJlczB9s=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=Iz8Pt/+mpkLUwne18t+ToVQdXGELRBTYvz3hfQL+/T6qfMb2E8Yo0vIGmeNqbpdqG ntdEoAnDVU7m2wkdoAxWboItzoOETjby2C2B3JbPF1hquVVNH4KTTMCB4p5N+649Ki 0Q21KSw1hzzReD6BeXfo3/4lLlXXdwJzOfkc9qGxKX2+gYlXqvQRLcrkiKj6t+Z/l7 xb3w+Od84Z0J6fXzPJH9iGrbCvkDVaYwgBN8Ceg8fQw+6Gf2B9y2yTDiR6Rojjduv2 Rv1fZ791/RSi47C2jQBpfBJjcQF1H99jqIpvaywjrFg9FCbcrbpBd5GnkoSe4nsmim QB3FOfh/YcPiA== From: Sasha Levin To: patches@lists.linux.dev, stable@vger.kernel.org Cc: bui duc phuc , Sashiko AI Review , Mark Brown , Sasha Levin , lgirdwood@gmail.com, perex@perex.cz, tiwai@suse.com, heiko@sntech.de, linux-sound@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-rockchip@lists.infradead.org, linux-kernel@vger.kernel.org Subject: [PATCH AUTOSEL 6.18-5.10] ASoC: rockchip: spdif: Restore regcache cache-only mode on sync failure Date: Mon, 31 Aug 2026 09:29:20 -0400 Message-ID: <20260831133314.4125787-532-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: linux-sound@vger.kernel.org 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: bui duc phuc [ Upstream commit 3546e9aa691ac981e4734fedd1646d0180784893 ] If regcache_sync() fails during runtime resume, the driver disables the clocks and returns an error. However, the regmap cache-only mode is left disabled. Restore cache-only mode in the error path so subsequent register accesses continue to use the cache while the device is inactive. Reported-by: Sashiko AI Review Closes: https://lore.kernel.org/all/20260522103713.6C09D1F000E9@smtp.kernel.org/ Signed-off-by: bui duc phuc Link: https://patch.msgid.link/20260602101608.45137-5-phucduc.bui@gmail.com Signed-off-by: Mark Brown Signed-off-by: Sasha Levin --- LLM Generated explanations, may be completely bogus: ## Phase 1: Commit Message Forensics ### Step 1.1: Subject Line **Record:** `[ASoC: rockchip: spdif] [Restore] Restore regcache cache- only mode on sync failure during runtime resume error path` ### Step 1.2: Commit Tags **Record:** - **Reported-by:** Sashiko AI Review `` — automated review bot, not a user crash report - **Closes:** https://lore.kernel.org/all/20260522103713.6C09D1F000E9@sm tp.kernel.org/ — Sashiko review thread - **Signed-off-by:** bui duc phuc `` — author - **Link:** https://patch.msgid.link/20260602101608.45137-5-phucduc.bui@gmail.com — patch 5 of a series (message-id suffix) - **Signed-off-by:** Mark Brown `` — ASoC subsystem maintainer - **No Fixes:** tag (expected for manual review pipeline) - **No Cc: stable@vger.kernel.org** (expected; not a negative signal) - **No Tested-by / Reviewed-by / Acked-by** Notable: maintainer sign-off from Mark Brown; same author (`phucduc.bui`) recently landed an analogous `regcache_cache_only` error-path fix for `gpio-pca953x` with `Cc: stable@vger.kernel.org`. ### Step 1.3: Commit Body Analysis **Record:** - **Bug:** On `regcache_sync()` failure in `rk_spdif_runtime_resume()`, clocks are disabled and an error is returned, but `regcache_cache_only(false)` is never reverted. - **Symptom:** After a failed resume, regmap leaves cache-only mode while the device is inactive; subsequent register accesses attempt hardware I/O instead of using the cache. - **Root cause:** Incomplete error-path state restoration — suspend sets `cache_only(true)`, resume sets `cache_only(false)` before sync, but the sync-failure path omits restoring `cache_only(true)`. - **Version info:** None stated in the commit message. ### Step 1.4: Hidden Bug Fix Detection **Record:** Not disguised — this is an explicit error-path state-machine bug fix, though the subject uses "Restore" rather than "fix". --- ## Phase 2: Diff Analysis ### Step 2.1: Change Inventory **Record:** - **Files:** `sound/soc/rockchip/rockchip_spdif.c` — 1 line added (+1 net in the shown hunk) - **Function modified:** `rk_spdif_runtime_resume()` - **Scope:** Single-file, surgical fix Note: upstream diff shows `hclk` enabled before `mclk`; this tree enables `mclk` then `hclk`. The added line placement (inside the `regcache_sync()` failure block, before clock disable) is identical in intent. ### Step 2.2: Code Flow Change **Record:** - **Hunk (regcache_sync error path):** - **Before:** On sync failure → disable clocks → return error, leaving `cache_only == false` - **After:** On sync failure → `regcache_cache_only(map, true)` → disable clocks → return error - **Affected path:** Runtime PM resume error path only (not the success path) ### Step 2.3: Bug Mechanism **Record:** - **Category:** Error-path / state consistency bug (regmap cache-mode invariant violation) - **Mechanism:** `rk_spdif_runtime_suspend()` sets cache-only; resume clears it before sync; failed sync leaves the map in "live hardware" mode while clocks are off and the device is inactive. The fix restores the suspended-state invariant. ### Step 2.4: Fix Quality **Record:** - **Quality:** Obviously correct — mirrors the established pattern in `sgtl5000.c` and the recently backported `pca953x` fix by the same author. - **Regression risk:** Very low — one line on an already-rare error path. - **Red flags:** None. --- ## Phase 3: Git History Investigation ### Step 3.1: Blame **Record:** - Buggy `regcache_sync()` error path introduced by **3628c6987fb45** (2016-09-07): "ASoC: rockchip: spdif: restore register during runtime_suspend/resume cycle" - Related prior fix: **6d94d0090527b** (2022-12-08) added missing `clk_disable_unprepare()` on hclk failure — same function, same class of incomplete error handling - PM runtime integration: **f50d67f9eff62** (2020-07-13) ### Step 3.2: Fixes: Tag **Record:** Not applicable — no `Fixes:` tag in the commit message. ### Step 3.3: Related File History **Record:** - Recent changes to this file are cleanups (`RUNTIME_PM_OPS`, remove callback, DAI merge) — no overlapping fix for this bug. - Fix commit message not found in this tree — **fix is not yet applied locally**. - Patch appears standalone (single line, one file); message-id `-5` suggests a series, but no series dependency is evident from the diff. ### Step 3.4: Author Context **Record:** - Author `phucduc.bui` has no other commits under `sound/soc/rockchip/` in this tree. - Same author authored **2e4bc8422cdee** (`gpio: pca953x: fix cache_only ... on restore_context() failure`), which was backported to this stable tree with `Cc: stable@vger.kernel.org`. ### Step 3.5: Dependencies **Record:** No prerequisites — self-contained one-line addition. Applies cleanly to this tree (clock order differs cosmetically, hunk location unchanged). --- ## Phase 4: Mailing List and External Research ### Step 4.1: Original Patch Discussion **Record:** `b4 dig -m "Restore regcache cache-only mode on sync failure"` returned no match. `b4 dig -m "20260602101608.45137-5-phucduc.bui@gmail.com"` returned no match. Lore/patch.msgid.link URLs blocked by Anubis bot protection — **could not read review thread content**. ### Step 4.2: Reviewers **Record:** `b4 dig -w` not usable (no thread match). Mark Brown (maintainer) Signed-off-by confirms maintainer acceptance. ### Step 4.3: Bug Report **Record:** Reported by Sashiko AI Review (automated static analysis), not syzbot or a user crash report. Underlying issue is code-review- identified state inconsistency, not a filed oops trace. ### Step 4.4: Related Patches **Record:** Same author/class of fix in `gpio-pca953x` (already in this tree at `2e4bc8422cdee`). `sgtl5000.c` already implements the correct pattern at lines 1135–1139. ### Step 4.5: Stable List History **Record:** Could not search lore stable list (Anubis blocking). The analogous pca953x fix from this author explicitly carried `Cc: stable@vger.kernel.org` and was merged here by Greg K-H. --- ## Phase 5: Code Semantic Analysis ### Step 5.1: Key Functions **Record:** `rk_spdif_runtime_resume()` modified; related: `rk_spdif_runtime_suspend()`, `rk_spdif_hw_params()`, `rk_spdif_trigger()` ### Step 5.2: Callers **Record:** - `rk_spdif_runtime_resume()` registered via `RUNTIME_PM_OPS()` at line 377 — invoked by PM core on runtime resume - Direct call from `rk_spdif_probe()` when PM runtime is disabled (lines 338–341) - Regmap users: `rk_spdif_hw_params()`, `rk_spdif_trigger()` — ASoC PCM/DAI paths during active audio ### Step 5.3: Callees **Record:** `clk_prepare_enable()`, `regcache_cache_only()`, `regcache_mark_dirty()`, `regcache_sync()`, `clk_disable_unprepare()` ### Step 5.4: Reachability **Record:** - Resume path reachable on every runtime PM resume (suspend/resume cycles, audio start on Rockchip boards) - Bug triggers only when `regcache_sync()` returns error (uncommon but real — bus/clock/hardware failure during sync) - After bug triggers, any regmap access while device is inactive hits hardware path instead of cache — reachable from subsequent resume retries or regmap ops if PM state is inconsistent ### Step 5.5: Similar Patterns **Record:** - **Correct pattern:** `sound/soc/codecs/sgtl5000.c:1135-1139` restores `cache_only(true)` on sync failure - **Same bug class, same author:** `drivers/gpio/gpio-pca953x.c` `pca953x_restore_context()` err path - **Same bug present:** `sound/soc/rockchip/rockchip_sai.c:251-277` — also lacks cache-only restore on sync failure (out of scope for this commit) --- ## Phase 6: Cross-Reference Against Local Tree ### Step 6.1: Buggy Code Present? **Record:** **YES.** Local tree is **v6.18.44** (`6.18.44`). Buggy code at: ```98:102:sound/soc/rockchip/rockchip_spdif.c ret = regcache_sync(spdif->regmap); if (ret) { clk_disable_unprepare(spdif->mclk); clk_disable_unprepare(spdif->hclk); } ``` Missing `regcache_cache_only(spdif->regmap, true)`. Bug present since 3628c6987fb45 (2016). ### Step 6.2: Backport Complications **Record:** Clean apply expected — add one line inside existing `if (ret)` block. Clock enable order differs from upstream diff but hunk location is unchanged. ### Step 6.3: Related Fixes Already Present? **Record:** No equivalent fix in this tree. Prior related fix 6d94d0090527b (missing clk disable) is present. Fix commit not found via grep or git log. --- ## Phase 7: Subsystem Context ### Step 7.1: Subsystem and Criticality **Record:** **ASoC / Rockchip SPDIF driver** — **PERIPHERAL** (Rockchip embedded SoC audio output). Affects boards using the in-SoC SPDIF controller (RK3288, RK3399, RK3568, etc.). ### Step 7.2: Subsystem Activity **Record:** Moderate recent activity (SAI driver additions, cleanups); SPDIF driver itself is mature with infrequent changes. --- ## Phase 8: Impact and Risk Assessment ### Step 8.1: Who Is Affected **Record:** Users of Rockchip platforms with `CONFIG_SND_SOC_ROCKCHIP_SPDIF` and the built-in SPDIF DAI — embedded/ARM boards, not universal x86 users. ### Step 8.2: Trigger Conditions **Record:** - **Trigger:** `regcache_sync()` failure during runtime resume - **Likelihood:** Uncommon (requires hardware/bus/clock issue during sync) - **Unprivileged trigger:** No — requires device access and a resume failure condition ### Step 8.3: Failure Mode Severity **Record:** - **Failure mode:** Regmap attempts live MMIO (`devm_regmap_init_mmio_clk` uses `hclk`) while driver considers device suspended; register state may be inconsistent; subsequent resume/audio operations may fail, hang, or produce silent corruption - **Severity:** **MEDIUM** — real functional bug on an error path, not a common crash, but can leave driver in an unrecoverable inconsistent state without the fix ### Step 8.4: Risk-Benefit **Record:** - **Benefit:** Restores correct PM/regmap state invariant; prevents post-failure regmap/hardware mismatch on Rockchip SPDIF; aligns with established kernel patterns - **Risk:** Very low — one line, error path only - **Ratio:** Favorable for backport --- ## Phase 9: Final Synthesis ### Step 9.1: Evidence Summary **FOR backport:** - Real bug — incomplete error-path state restoration since 2016 - Bug confirmed present in v6.18.44 tree - One-line, obviously correct fix matching `sgtl5000` and backported `pca953x` precedent - ASoC maintainer (Mark Brown) Signed-off-by - Same author successfully got analogous fix into this stable tree - Low regression risk **AGAINST backport:** - Rare trigger (`regcache_sync()` failure) - Driver-specific, embedded Rockchip only - No user crash report or syzbot — flagged by AI review bot - Medium not critical severity **UNRESOLVED:** - Full lore review thread content (Anubis blocked) - Whether reviewers explicitly nominated for stable - Whether patch 5/N series has other dependencies (diff appears standalone) ### Step 9.2: Stable Rules Checklist 1. Obviously correct and tested? **PASS** — pattern proven elsewhere; maintainer SOB; no Tested-by 2. Fixes a real bug affecting users? **PASS** — state-machine bug on resume error path for Rockchip SPDIF users 3. Important issue? **PASS (MEDIUM)** — can cause driver malfunction/hang on error path, not security/data-corruption in common case 4. Small and contained? **PASS** — 1 line, 1 file 5. No new features or APIs? **PASS** 6. Can apply to local tree? **PASS** — buggy code present, clean apply ### Step 9.3: Exception Categories **Record:** Not applicable — standard bug fix, not device ID/quirk/build/doc exception. ### Step 9.4: Decision Rationale This is a well-understood error-path invariant fix: when runtime resume fails after disabling cache-only mode, the driver must restore cache- only mode before turning clocks off — exactly what suspend established. The bug has existed since the regcache resume logic was added in 2016 and is present in this 6.18.y tree. While the trigger is uncommon and impact is driver-specific, the fix is trivial, low-risk, maintainer- approved, and follows a pattern already accepted for stable (pca953x, sgtl5000). Conservative stable policy favors such surgical error-path fixes that prevent leaving hardware drivers in inconsistent states. --- ## Verification - **[Phase 1]** Parsed commit message and all tags from user-provided commit text - **[Phase 2]** Diff analysis: 1 line added in `rk_spdif_runtime_resume()` error path - **[Phase 3]** `git describe HEAD`: v6.18.44-1-g2736c32da98b9 / kernel 6.18.44 - **[Phase 3]** `git blame -L 77,105`: regcache error path from 3628c6987fb45 (2016) - **[Phase 3]** `git show 3628c6987fb45`: confirmed introduction of regcache_sync without cache-only restore on error - **[Phase 3]** `git show 6d94d0090527b`: related prior error-path fix in same function - **[Phase 3]** `git log --grep="Restore regcache"`: no fix commit in tree - **[Phase 3]** `git show 2e4bc8422cdee`: same author's analogous pca953x fix backported here with Cc: stable - **[Phase 4]** `b4 dig -m "Restore regcache..."`: no match - **[Phase 4]** WebFetch lore/patch.msgid.link URLs: blocked by Anubis — **UNVERIFIED** review thread content - **[Phase 5]** Read `rockchip_spdif.c`: confirmed regmap users and PM ops registration - **[Phase 5]** Read `sgtl5000.c:1135-1139`: confirmed correct reference pattern - **[Phase 5]** Read `rockchip_sai.c:251-277`: same missing pattern (separate issue) - **[Phase 5]** Read `drivers/base/regmap/regcache.c:551-570`: confirmed cache_only semantics - **[Phase 6]** Read current `rockchip_spdif.c:66-105`: confirmed buggy code without fix - **[Phase 6]** `git log --oneline -20 -- sound/soc/rockchip/rockchip_spdif.c`: no conflicting fix present **YES****Verdict: YES** — backport to this tree (v6.18.44). The Rockchip SPDIF driver leaves `regcache_cache_only` disabled when `regcache_sync()` fails during runtime resume, so later register accesses can hit hardware while the device is still inactive. The fix is a one-line restore of cache-only mode on that error path — same pattern as `sgtl5000` and the author’s backported `pca953x` fix. The bug has been present since 2016 and is still in this checkout; it’s a small, low-risk, maintainer-signed error-path fix. sound/soc/rockchip/rockchip_spdif.c | 1 + 1 file changed, 1 insertion(+) diff --git a/sound/soc/rockchip/rockchip_spdif.c b/sound/soc/rockchip/rockchip_spdif.c index d365168934dc6..7a15f680de2fe 100644 --- a/sound/soc/rockchip/rockchip_spdif.c +++ b/sound/soc/rockchip/rockchip_spdif.c @@ -97,6 +97,7 @@ static int rk_spdif_runtime_resume(struct device *dev) ret = regcache_sync(spdif->regmap); if (ret) { + regcache_cache_only(spdif->regmap, true); clk_disable_unprepare(spdif->mclk); clk_disable_unprepare(spdif->hclk); } -- 2.53.0 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 07681C624A4 for ; Mon, 31 Aug 2026 13:49: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=hy5eiZZORoFbAb7zVrqAFkU3zDHgjCBmppjz53Qgvs0=; b=C6u2gtXc6kyMJ1 Lg/x2VV0ig6Rq9vys61qnRUN3pXskrBCeDm8YcTL6+Y/iR7h9eDAFjHy13oqa8JEgGQAycGw9ipZe FdzAw3tfwXmL7zBDdT89nstxOVLhuxYJ0yuSr04l5DoIysuZpizfyEhl9HSelwiHP5Rdl8nWDSdYF 7+Q9WmhpaxgGVmv6XYLITKPVwjqofLdpoqQqovqXoQ4YKz4PpwXAjVVfd5RJLGNpCUIKjf4x4+PHC 8Ku6OBy49FOqMKU4V4jb14y0kH8hUmswrHY8c0H/PX+kvj+g3r0bWNEshuI/YsSoJRVMxdJU9UFqp WsEGVAveHsdjbmZM//3Q==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.99.1 #2 (Red Hat Linux)) id 1x12OB-00000009XVH-1tB7; Mon, 31 Aug 2026 13:49:31 +0000 Received: from tor.source.kernel.org ([172.105.4.254]) by bombadil.infradead.org with esmtps (Exim 4.99.1 #2 (Red Hat Linux)) id 1x12OA-00000009XUG-1keN; Mon, 31 Aug 2026 13:49:30 +0000 Received: from smtp.kernel.org (quasi.space.kernel.org [100.103.45.18]) by tor.source.kernel.org (Postfix) with ESMTP id B3B806020C; Mon, 31 Aug 2026 13:49:29 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 79D861F00A3D; Mon, 31 Aug 2026 13:49:27 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1788184169; bh=aNzPL9t3Ch3R/81vyFJ8KYM8BGwN9BjbkzaDJlczB9s=; h=From:To:Cc:Subject:Date:In-Reply-To:References; b=Iz8Pt/+mpkLUwne18t+ToVQdXGELRBTYvz3hfQL+/T6qfMb2E8Yo0vIGmeNqbpdqG ntdEoAnDVU7m2wkdoAxWboItzoOETjby2C2B3JbPF1hquVVNH4KTTMCB4p5N+649Ki 0Q21KSw1hzzReD6BeXfo3/4lLlXXdwJzOfkc9qGxKX2+gYlXqvQRLcrkiKj6t+Z/l7 xb3w+Od84Z0J6fXzPJH9iGrbCvkDVaYwgBN8Ceg8fQw+6Gf2B9y2yTDiR6Rojjduv2 Rv1fZ791/RSi47C2jQBpfBJjcQF1H99jqIpvaywjrFg9FCbcrbpBd5GnkoSe4nsmim QB3FOfh/YcPiA== From: Sasha Levin To: patches@lists.linux.dev, stable@vger.kernel.org Cc: bui duc phuc , Sashiko AI Review , Mark Brown , Sasha Levin , lgirdwood@gmail.com, perex@perex.cz, tiwai@suse.com, heiko@sntech.de, linux-sound@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-rockchip@lists.infradead.org, linux-kernel@vger.kernel.org Subject: [PATCH AUTOSEL 6.18-5.10] ASoC: rockchip: spdif: Restore regcache cache-only mode on sync failure Date: Mon, 31 Aug 2026 09:29:20 -0400 Message-ID: <20260831133314.4125787-532-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-rockchip@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: Upstream kernel work for Rockchip platforms List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "Linux-rockchip" Errors-To: linux-rockchip-bounces+linux-rockchip=archiver.kernel.org@lists.infradead.org RnJvbTogYnVpIGR1YyBwaHVjIDxwaHVjZHVjLmJ1aUBnbWFpbC5jb20+CgpbIFVwc3RyZWFtIGNv bW1pdCAzNTQ2ZTlhYTY5MWFjOTgxZTQ3MzRmZWRkMTY0NmQwMTgwNzg0ODkzIF0KCklmIHJlZ2Nh Y2hlX3N5bmMoKSBmYWlscyBkdXJpbmcgcnVudGltZSByZXN1bWUsIHRoZSBkcml2ZXIgZGlzYWJs ZXMgdGhlCmNsb2NrcyBhbmQgcmV0dXJucyBhbiBlcnJvci4gSG93ZXZlciwgdGhlIHJlZ21hcCBj YWNoZS1vbmx5IG1vZGUgaXMgbGVmdApkaXNhYmxlZC4KUmVzdG9yZSBjYWNoZS1vbmx5IG1vZGUg aW4gdGhlIGVycm9yIHBhdGggc28gc3Vic2VxdWVudCByZWdpc3RlciBhY2Nlc3Nlcwpjb250aW51 ZSB0byB1c2UgdGhlIGNhY2hlIHdoaWxlIHRoZSBkZXZpY2UgaXMgaW5hY3RpdmUuCgpSZXBvcnRl ZC1ieTogU2FzaGlrbyBBSSBSZXZpZXcgPHNhc2hpa28tYm90QGtlcm5lbC5vcmc+CkNsb3Nlczog aHR0cHM6Ly9sb3JlLmtlcm5lbC5vcmcvYWxsLzIwMjYwNTIyMTAzNzEzLjZDMDlEMUYwMDBFOUBz bXRwLmtlcm5lbC5vcmcvClNpZ25lZC1vZmYtYnk6IGJ1aSBkdWMgcGh1YyA8cGh1Y2R1Yy5idWlA Z21haWwuY29tPgpMaW5rOiBodHRwczovL3BhdGNoLm1zZ2lkLmxpbmsvMjAyNjA2MDIxMDE2MDgu NDUxMzctNS1waHVjZHVjLmJ1aUBnbWFpbC5jb20KU2lnbmVkLW9mZi1ieTogTWFyayBCcm93biA8 YnJvb25pZUBrZXJuZWwub3JnPgpTaWduZWQtb2ZmLWJ5OiBTYXNoYSBMZXZpbiA8c2FzaGFsQGtl cm5lbC5vcmc+Ci0tLQoKTExNIEdlbmVyYXRlZCBleHBsYW5hdGlvbnMsIG1heSBiZSBjb21wbGV0 ZWx5IGJvZ3VzOgoKIyMgUGhhc2UgMTogQ29tbWl0IE1lc3NhZ2UgRm9yZW5zaWNzCgojIyMgU3Rl cCAxLjE6IFN1YmplY3QgTGluZQoqKlJlY29yZDoqKiBgW0FTb0M6IHJvY2tjaGlwOiBzcGRpZl0g W1Jlc3RvcmVdIFJlc3RvcmUgcmVnY2FjaGUgY2FjaGUtCm9ubHkgbW9kZSBvbiBzeW5jIGZhaWx1 cmUgZHVyaW5nIHJ1bnRpbWUgcmVzdW1lIGVycm9yIHBhdGhgCgojIyMgU3RlcCAxLjI6IENvbW1p dCBUYWdzCioqUmVjb3JkOioqCi0gKipSZXBvcnRlZC1ieToqKiBTYXNoaWtvIEFJIFJldmlldyBg PHNhc2hpa28tYm90QGtlcm5lbC5vcmc+YCDigJQKICBhdXRvbWF0ZWQgcmV2aWV3IGJvdCwgbm90 IGEgdXNlciBjcmFzaCByZXBvcnQKLSAqKkNsb3NlczoqKiBodHRwczovL2xvcmUua2VybmVsLm9y Zy9hbGwvMjAyNjA1MjIxMDM3MTMuNkMwOUQxRjAwMEU5QHNtCiAgdHAua2VybmVsLm9yZy8g4oCU IFNhc2hpa28gcmV2aWV3IHRocmVhZAotICoqU2lnbmVkLW9mZi1ieToqKiBidWkgZHVjIHBodWMg YDxwaHVjZHVjLmJ1aUBnbWFpbC5jb20+YCDigJQgYXV0aG9yCi0gKipMaW5rOioqCiAgaHR0cHM6 Ly9wYXRjaC5tc2dpZC5saW5rLzIwMjYwNjAyMTAxNjA4LjQ1MTM3LTUtcGh1Y2R1Yy5idWlAZ21h aWwuY29tCiAg4oCUIHBhdGNoIDUgb2YgYSBzZXJpZXMgKG1lc3NhZ2UtaWQgc3VmZml4KQotICoq U2lnbmVkLW9mZi1ieToqKiBNYXJrIEJyb3duIGA8YnJvb25pZUBrZXJuZWwub3JnPmAg4oCUIEFT b0Mgc3Vic3lzdGVtCiAgbWFpbnRhaW5lcgotICoqTm8gRml4ZXM6KiogdGFnIChleHBlY3RlZCBm b3IgbWFudWFsIHJldmlldyBwaXBlbGluZSkKLSAqKk5vIENjOiBzdGFibGVAdmdlci5rZXJuZWwu b3JnKiogKGV4cGVjdGVkOyBub3QgYSBuZWdhdGl2ZSBzaWduYWwpCi0gKipObyBUZXN0ZWQtYnkg LyBSZXZpZXdlZC1ieSAvIEFja2VkLWJ5KioKCk5vdGFibGU6IG1haW50YWluZXIgc2lnbi1vZmYg ZnJvbSBNYXJrIEJyb3duOyBzYW1lIGF1dGhvcgooYHBodWNkdWMuYnVpYCkgcmVjZW50bHkgbGFu ZGVkIGFuIGFuYWxvZ291cyBgcmVnY2FjaGVfY2FjaGVfb25seWAKZXJyb3ItcGF0aCBmaXggZm9y IGBncGlvLXBjYTk1M3hgIHdpdGggYENjOiBzdGFibGVAdmdlci5rZXJuZWwub3JnYC4KCiMjIyBT dGVwIDEuMzogQ29tbWl0IEJvZHkgQW5hbHlzaXMKKipSZWNvcmQ6KioKLSAqKkJ1ZzoqKiBPbiBg cmVnY2FjaGVfc3luYygpYCBmYWlsdXJlIGluIGBya19zcGRpZl9ydW50aW1lX3Jlc3VtZSgpYCwK ICBjbG9ja3MgYXJlIGRpc2FibGVkIGFuZCBhbiBlcnJvciBpcyByZXR1cm5lZCwgYnV0CiAgYHJl Z2NhY2hlX2NhY2hlX29ubHkoZmFsc2UpYCBpcyBuZXZlciByZXZlcnRlZC4KLSAqKlN5bXB0b206 KiogQWZ0ZXIgYSBmYWlsZWQgcmVzdW1lLCByZWdtYXAgbGVhdmVzIGNhY2hlLW9ubHkgbW9kZQog IHdoaWxlIHRoZSBkZXZpY2UgaXMgaW5hY3RpdmU7IHN1YnNlcXVlbnQgcmVnaXN0ZXIgYWNjZXNz ZXMgYXR0ZW1wdAogIGhhcmR3YXJlIEkvTyBpbnN0ZWFkIG9mIHVzaW5nIHRoZSBjYWNoZS4KLSAq KlJvb3QgY2F1c2U6KiogSW5jb21wbGV0ZSBlcnJvci1wYXRoIHN0YXRlIHJlc3RvcmF0aW9uIOKA lCBzdXNwZW5kIHNldHMKICBgY2FjaGVfb25seSh0cnVlKWAsIHJlc3VtZSBzZXRzIGBjYWNoZV9v bmx5KGZhbHNlKWAgYmVmb3JlIHN5bmMsIGJ1dAogIHRoZSBzeW5jLWZhaWx1cmUgcGF0aCBvbWl0 cyByZXN0b3JpbmcgYGNhY2hlX29ubHkodHJ1ZSlgLgotICoqVmVyc2lvbiBpbmZvOioqIE5vbmUg c3RhdGVkIGluIHRoZSBjb21taXQgbWVzc2FnZS4KCiMjIyBTdGVwIDEuNDogSGlkZGVuIEJ1ZyBG aXggRGV0ZWN0aW9uCioqUmVjb3JkOioqIE5vdCBkaXNndWlzZWQg4oCUIHRoaXMgaXMgYW4gZXhw bGljaXQgZXJyb3ItcGF0aCBzdGF0ZS1tYWNoaW5lCmJ1ZyBmaXgsIHRob3VnaCB0aGUgc3ViamVj dCB1c2VzICJSZXN0b3JlIiByYXRoZXIgdGhhbiAiZml4Ii4KCi0tLQoKIyMgUGhhc2UgMjogRGlm ZiBBbmFseXNpcwoKIyMjIFN0ZXAgMi4xOiBDaGFuZ2UgSW52ZW50b3J5CioqUmVjb3JkOioqCi0g KipGaWxlczoqKiBgc291bmQvc29jL3JvY2tjaGlwL3JvY2tjaGlwX3NwZGlmLmNgIOKAlCAxIGxp bmUgYWRkZWQgKCsxCiAgbmV0IGluIHRoZSBzaG93biBodW5rKQotICoqRnVuY3Rpb24gbW9kaWZp ZWQ6KiogYHJrX3NwZGlmX3J1bnRpbWVfcmVzdW1lKClgCi0gKipTY29wZToqKiBTaW5nbGUtZmls ZSwgc3VyZ2ljYWwgZml4CgpOb3RlOiB1cHN0cmVhbSBkaWZmIHNob3dzIGBoY2xrYCBlbmFibGVk IGJlZm9yZSBgbWNsa2A7IHRoaXMgdHJlZQplbmFibGVzIGBtY2xrYCB0aGVuIGBoY2xrYC4gVGhl IGFkZGVkIGxpbmUgcGxhY2VtZW50IChpbnNpZGUgdGhlCmByZWdjYWNoZV9zeW5jKClgIGZhaWx1 cmUgYmxvY2ssIGJlZm9yZSBjbG9jayBkaXNhYmxlKSBpcyBpZGVudGljYWwgaW4KaW50ZW50LgoK IyMjIFN0ZXAgMi4yOiBDb2RlIEZsb3cgQ2hhbmdlCioqUmVjb3JkOioqCi0gKipIdW5rIChyZWdj YWNoZV9zeW5jIGVycm9yIHBhdGgpOioqCiAgLSAqKkJlZm9yZToqKiBPbiBzeW5jIGZhaWx1cmUg 4oaSIGRpc2FibGUgY2xvY2tzIOKGkiByZXR1cm4gZXJyb3IsIGxlYXZpbmcKICAgIGBjYWNoZV9v bmx5ID09IGZhbHNlYAogIC0gKipBZnRlcjoqKiBPbiBzeW5jIGZhaWx1cmUg4oaSIGByZWdjYWNo ZV9jYWNoZV9vbmx5KG1hcCwgdHJ1ZSlgIOKGkgogICAgZGlzYWJsZSBjbG9ja3Mg4oaSIHJldHVy biBlcnJvcgotICoqQWZmZWN0ZWQgcGF0aDoqKiBSdW50aW1lIFBNIHJlc3VtZSBlcnJvciBwYXRo IG9ubHkgKG5vdCB0aGUgc3VjY2VzcwogIHBhdGgpCgojIyMgU3RlcCAyLjM6IEJ1ZyBNZWNoYW5p c20KKipSZWNvcmQ6KioKLSAqKkNhdGVnb3J5OioqIEVycm9yLXBhdGggLyBzdGF0ZSBjb25zaXN0 ZW5jeSBidWcgKHJlZ21hcCBjYWNoZS1tb2RlCiAgaW52YXJpYW50IHZpb2xhdGlvbikKLSAqKk1l Y2hhbmlzbToqKiBgcmtfc3BkaWZfcnVudGltZV9zdXNwZW5kKClgIHNldHMgY2FjaGUtb25seTsg cmVzdW1lCiAgY2xlYXJzIGl0IGJlZm9yZSBzeW5jOyBmYWlsZWQgc3luYyBsZWF2ZXMgdGhlIG1h cCBpbiAibGl2ZSBoYXJkd2FyZSIKICBtb2RlIHdoaWxlIGNsb2NrcyBhcmUgb2ZmIGFuZCB0aGUg ZGV2aWNlIGlzIGluYWN0aXZlLiBUaGUgZml4IHJlc3RvcmVzCiAgdGhlIHN1c3BlbmRlZC1zdGF0 ZSBpbnZhcmlhbnQuCgojIyMgU3RlcCAyLjQ6IEZpeCBRdWFsaXR5CioqUmVjb3JkOioqCi0gKipR dWFsaXR5OioqIE9idmlvdXNseSBjb3JyZWN0IOKAlCBtaXJyb3JzIHRoZSBlc3RhYmxpc2hlZCBw YXR0ZXJuIGluCiAgYHNndGw1MDAwLmNgIGFuZCB0aGUgcmVjZW50bHkgYmFja3BvcnRlZCBgcGNh OTUzeGAgZml4IGJ5IHRoZSBzYW1lCiAgYXV0aG9yLgotICoqUmVncmVzc2lvbiByaXNrOioqIFZl cnkgbG93IOKAlCBvbmUgbGluZSBvbiBhbiBhbHJlYWR5LXJhcmUgZXJyb3IKICBwYXRoLgotICoq UmVkIGZsYWdzOioqIE5vbmUuCgotLS0KCiMjIFBoYXNlIDM6IEdpdCBIaXN0b3J5IEludmVzdGln YXRpb24KCiMjIyBTdGVwIDMuMTogQmxhbWUKKipSZWNvcmQ6KioKLSBCdWdneSBgcmVnY2FjaGVf c3luYygpYCBlcnJvciBwYXRoIGludHJvZHVjZWQgYnkgKiozNjI4YzY5ODdmYjQ1KioKICAoMjAx Ni0wOS0wNyk6ICJBU29DOiByb2NrY2hpcDogc3BkaWY6IHJlc3RvcmUgcmVnaXN0ZXIgZHVyaW5n CiAgcnVudGltZV9zdXNwZW5kL3Jlc3VtZSBjeWNsZSIKLSBSZWxhdGVkIHByaW9yIGZpeDogKio2 ZDk0ZDAwOTA1MjdiKiogKDIwMjItMTItMDgpIGFkZGVkIG1pc3NpbmcKICBgY2xrX2Rpc2FibGVf dW5wcmVwYXJlKClgIG9uIGhjbGsgZmFpbHVyZSDigJQgc2FtZSBmdW5jdGlvbiwgc2FtZSBjbGFz cwogIG9mIGluY29tcGxldGUgZXJyb3IgaGFuZGxpbmcKLSBQTSBydW50aW1lIGludGVncmF0aW9u OiAqKmY1MGQ2N2Y5ZWZmNjIqKiAoMjAyMC0wNy0xMykKCiMjIyBTdGVwIDMuMjogRml4ZXM6IFRh ZwoqKlJlY29yZDoqKiBOb3QgYXBwbGljYWJsZSDigJQgbm8gYEZpeGVzOmAgdGFnIGluIHRoZSBj b21taXQgbWVzc2FnZS4KCiMjIyBTdGVwIDMuMzogUmVsYXRlZCBGaWxlIEhpc3RvcnkKKipSZWNv cmQ6KioKLSBSZWNlbnQgY2hhbmdlcyB0byB0aGlzIGZpbGUgYXJlIGNsZWFudXBzIChgUlVOVElN RV9QTV9PUFNgLCByZW1vdmUKICBjYWxsYmFjaywgREFJIG1lcmdlKSDigJQgbm8gb3ZlcmxhcHBp bmcgZml4IGZvciB0aGlzIGJ1Zy4KLSBGaXggY29tbWl0IG1lc3NhZ2Ugbm90IGZvdW5kIGluIHRo aXMgdHJlZSDigJQgKipmaXggaXMgbm90IHlldCBhcHBsaWVkCiAgbG9jYWxseSoqLgotIFBhdGNo IGFwcGVhcnMgc3RhbmRhbG9uZSAoc2luZ2xlIGxpbmUsIG9uZSBmaWxlKTsgbWVzc2FnZS1pZCBg LTVgCiAgc3VnZ2VzdHMgYSBzZXJpZXMsIGJ1dCBubyBzZXJpZXMgZGVwZW5kZW5jeSBpcyBldmlk ZW50IGZyb20gdGhlIGRpZmYuCgojIyMgU3RlcCAzLjQ6IEF1dGhvciBDb250ZXh0CioqUmVjb3Jk OioqCi0gQXV0aG9yIGBwaHVjZHVjLmJ1aWAgaGFzIG5vIG90aGVyIGNvbW1pdHMgdW5kZXIgYHNv dW5kL3NvYy9yb2NrY2hpcC9gCiAgaW4gdGhpcyB0cmVlLgotIFNhbWUgYXV0aG9yIGF1dGhvcmVk ICoqMmU0YmM4NDIyY2RlZSoqIChgZ3BpbzogcGNhOTUzeDogZml4IGNhY2hlX29ubHkKICAuLi4g b24gcmVzdG9yZV9jb250ZXh0KCkgZmFpbHVyZWApLCB3aGljaCB3YXMgYmFja3BvcnRlZCB0byB0 aGlzCiAgc3RhYmxlIHRyZWUgd2l0aCBgQ2M6IHN0YWJsZUB2Z2VyLmtlcm5lbC5vcmdgLgoKIyMj IFN0ZXAgMy41OiBEZXBlbmRlbmNpZXMKKipSZWNvcmQ6KiogTm8gcHJlcmVxdWlzaXRlcyDigJQg c2VsZi1jb250YWluZWQgb25lLWxpbmUgYWRkaXRpb24uIEFwcGxpZXMKY2xlYW5seSB0byB0aGlz IHRyZWUgKGNsb2NrIG9yZGVyIGRpZmZlcnMgY29zbWV0aWNhbGx5LCBodW5rIGxvY2F0aW9uCnVu Y2hhbmdlZCkuCgotLS0KCiMjIFBoYXNlIDQ6IE1haWxpbmcgTGlzdCBhbmQgRXh0ZXJuYWwgUmVz ZWFyY2gKCiMjIyBTdGVwIDQuMTogT3JpZ2luYWwgUGF0Y2ggRGlzY3Vzc2lvbgoqKlJlY29yZDoq KiBgYjQgZGlnIC1tICJSZXN0b3JlIHJlZ2NhY2hlIGNhY2hlLW9ubHkgbW9kZSBvbiBzeW5jCmZh aWx1cmUiYCByZXR1cm5lZCBubyBtYXRjaC4gYGI0IGRpZyAtbQoiMjAyNjA2MDIxMDE2MDguNDUx MzctNS1waHVjZHVjLmJ1aUBnbWFpbC5jb20iYCByZXR1cm5lZCBubyBtYXRjaC4KTG9yZS9wYXRj aC5tc2dpZC5saW5rIFVSTHMgYmxvY2tlZCBieSBBbnViaXMgYm90IHByb3RlY3Rpb24g4oCUICoq Y291bGQKbm90IHJlYWQgcmV2aWV3IHRocmVhZCBjb250ZW50KiouCgojIyMgU3RlcCA0LjI6IFJl dmlld2VycwoqKlJlY29yZDoqKiBgYjQgZGlnIC13YCBub3QgdXNhYmxlIChubyB0aHJlYWQgbWF0 Y2gpLiBNYXJrIEJyb3duCihtYWludGFpbmVyKSBTaWduZWQtb2ZmLWJ5IGNvbmZpcm1zIG1haW50 YWluZXIgYWNjZXB0YW5jZS4KCiMjIyBTdGVwIDQuMzogQnVnIFJlcG9ydAoqKlJlY29yZDoqKiBS ZXBvcnRlZCBieSBTYXNoaWtvIEFJIFJldmlldyAoYXV0b21hdGVkIHN0YXRpYyBhbmFseXNpcyks Cm5vdCBzeXpib3Qgb3IgYSB1c2VyIGNyYXNoIHJlcG9ydC4gVW5kZXJseWluZyBpc3N1ZSBpcyBj b2RlLXJldmlldy0KaWRlbnRpZmllZCBzdGF0ZSBpbmNvbnNpc3RlbmN5LCBub3QgYSBmaWxlZCBv b3BzIHRyYWNlLgoKIyMjIFN0ZXAgNC40OiBSZWxhdGVkIFBhdGNoZXMKKipSZWNvcmQ6KiogU2Ft ZSBhdXRob3IvY2xhc3Mgb2YgZml4IGluIGBncGlvLXBjYTk1M3hgIChhbHJlYWR5IGluIHRoaXMK dHJlZSBhdCBgMmU0YmM4NDIyY2RlZWApLiBgc2d0bDUwMDAuY2AgYWxyZWFkeSBpbXBsZW1lbnRz IHRoZSBjb3JyZWN0CnBhdHRlcm4gYXQgbGluZXMgMTEzNeKAkzExMzkuCgojIyMgU3RlcCA0LjU6 IFN0YWJsZSBMaXN0IEhpc3RvcnkKKipSZWNvcmQ6KiogQ291bGQgbm90IHNlYXJjaCBsb3JlIHN0 YWJsZSBsaXN0IChBbnViaXMgYmxvY2tpbmcpLiBUaGUKYW5hbG9nb3VzIHBjYTk1M3ggZml4IGZy b20gdGhpcyBhdXRob3IgZXhwbGljaXRseSBjYXJyaWVkIGBDYzoKc3RhYmxlQHZnZXIua2VybmVs Lm9yZ2AgYW5kIHdhcyBtZXJnZWQgaGVyZSBieSBHcmVnIEstSC4KCi0tLQoKIyMgUGhhc2UgNTog Q29kZSBTZW1hbnRpYyBBbmFseXNpcwoKIyMjIFN0ZXAgNS4xOiBLZXkgRnVuY3Rpb25zCioqUmVj b3JkOioqIGBya19zcGRpZl9ydW50aW1lX3Jlc3VtZSgpYCBtb2RpZmllZDsgcmVsYXRlZDoKYHJr X3NwZGlmX3J1bnRpbWVfc3VzcGVuZCgpYCwgYHJrX3NwZGlmX2h3X3BhcmFtcygpYCwKYHJrX3Nw ZGlmX3RyaWdnZXIoKWAKCiMjIyBTdGVwIDUuMjogQ2FsbGVycwoqKlJlY29yZDoqKgotIGBya19z cGRpZl9ydW50aW1lX3Jlc3VtZSgpYCByZWdpc3RlcmVkIHZpYSBgUlVOVElNRV9QTV9PUFMoKWAg YXQgbGluZQogIDM3NyDigJQgaW52b2tlZCBieSBQTSBjb3JlIG9uIHJ1bnRpbWUgcmVzdW1lCi0g RGlyZWN0IGNhbGwgZnJvbSBgcmtfc3BkaWZfcHJvYmUoKWAgd2hlbiBQTSBydW50aW1lIGlzIGRp c2FibGVkIChsaW5lcwogIDMzOOKAkzM0MSkKLSBSZWdtYXAgdXNlcnM6IGBya19zcGRpZl9od19w YXJhbXMoKWAsIGBya19zcGRpZl90cmlnZ2VyKClgIOKAlCBBU29DCiAgUENNL0RBSSBwYXRocyBk dXJpbmcgYWN0aXZlIGF1ZGlvCgojIyMgU3RlcCA1LjM6IENhbGxlZXMKKipSZWNvcmQ6KiogYGNs a19wcmVwYXJlX2VuYWJsZSgpYCwgYHJlZ2NhY2hlX2NhY2hlX29ubHkoKWAsCmByZWdjYWNoZV9t YXJrX2RpcnR5KClgLCBgcmVnY2FjaGVfc3luYygpYCwgYGNsa19kaXNhYmxlX3VucHJlcGFyZSgp YAoKIyMjIFN0ZXAgNS40OiBSZWFjaGFiaWxpdHkKKipSZWNvcmQ6KioKLSBSZXN1bWUgcGF0aCBy ZWFjaGFibGUgb24gZXZlcnkgcnVudGltZSBQTSByZXN1bWUgKHN1c3BlbmQvcmVzdW1lCiAgY3lj bGVzLCBhdWRpbyBzdGFydCBvbiBSb2NrY2hpcCBib2FyZHMpCi0gQnVnIHRyaWdnZXJzIG9ubHkg d2hlbiBgcmVnY2FjaGVfc3luYygpYCByZXR1cm5zIGVycm9yICh1bmNvbW1vbiBidXQKICByZWFs IOKAlCBidXMvY2xvY2svaGFyZHdhcmUgZmFpbHVyZSBkdXJpbmcgc3luYykKLSBBZnRlciBidWcg dHJpZ2dlcnMsIGFueSByZWdtYXAgYWNjZXNzIHdoaWxlIGRldmljZSBpcyBpbmFjdGl2ZSBoaXRz CiAgaGFyZHdhcmUgcGF0aCBpbnN0ZWFkIG9mIGNhY2hlIOKAlCByZWFjaGFibGUgZnJvbSBzdWJz ZXF1ZW50IHJlc3VtZQogIHJldHJpZXMgb3IgcmVnbWFwIG9wcyBpZiBQTSBzdGF0ZSBpcyBpbmNv bnNpc3RlbnQKCiMjIyBTdGVwIDUuNTogU2ltaWxhciBQYXR0ZXJucwoqKlJlY29yZDoqKgotICoq Q29ycmVjdCBwYXR0ZXJuOioqIGBzb3VuZC9zb2MvY29kZWNzL3NndGw1MDAwLmM6MTEzNS0xMTM5 YCByZXN0b3JlcwogIGBjYWNoZV9vbmx5KHRydWUpYCBvbiBzeW5jIGZhaWx1cmUKLSAqKlNhbWUg YnVnIGNsYXNzLCBzYW1lIGF1dGhvcjoqKiBgZHJpdmVycy9ncGlvL2dwaW8tcGNhOTUzeC5jYAog IGBwY2E5NTN4X3Jlc3RvcmVfY29udGV4dCgpYCBlcnIgcGF0aAotICoqU2FtZSBidWcgcHJlc2Vu dDoqKiBgc291bmQvc29jL3JvY2tjaGlwL3JvY2tjaGlwX3NhaS5jOjI1MS0yNzdgIOKAlAogIGFs c28gbGFja3MgY2FjaGUtb25seSByZXN0b3JlIG9uIHN5bmMgZmFpbHVyZSAob3V0IG9mIHNjb3Bl IGZvciB0aGlzCiAgY29tbWl0KQoKLS0tCgojIyBQaGFzZSA2OiBDcm9zcy1SZWZlcmVuY2UgQWdh aW5zdCBMb2NhbCBUcmVlCgojIyMgU3RlcCA2LjE6IEJ1Z2d5IENvZGUgUHJlc2VudD8KKipSZWNv cmQ6KiogKipZRVMuKiogTG9jYWwgdHJlZSBpcyAqKnY2LjE4LjQ0KiogKGA2LjE4LjQ0YCkuIEJ1 Z2d5IGNvZGUKYXQ6CgpgYGA5ODoxMDI6c291bmQvc29jL3JvY2tjaGlwL3JvY2tjaGlwX3NwZGlm LmMKICAgICAgICByZXQgPSByZWdjYWNoZV9zeW5jKHNwZGlmLT5yZWdtYXApOwogICAgICAgIGlm IChyZXQpIHsKICAgICAgICAgICAgICAgIGNsa19kaXNhYmxlX3VucHJlcGFyZShzcGRpZi0+bWNs ayk7CiAgICAgICAgICAgICAgICBjbGtfZGlzYWJsZV91bnByZXBhcmUoc3BkaWYtPmhjbGspOwog ICAgICAgIH0KYGBgCgpNaXNzaW5nIGByZWdjYWNoZV9jYWNoZV9vbmx5KHNwZGlmLT5yZWdtYXAs IHRydWUpYC4gQnVnIHByZXNlbnQgc2luY2UKMzYyOGM2OTg3ZmI0NSAoMjAxNikuCgojIyMgU3Rl cCA2LjI6IEJhY2twb3J0IENvbXBsaWNhdGlvbnMKKipSZWNvcmQ6KiogQ2xlYW4gYXBwbHkgZXhw ZWN0ZWQg4oCUIGFkZCBvbmUgbGluZSBpbnNpZGUgZXhpc3RpbmcgYGlmCihyZXQpYCBibG9jay4g Q2xvY2sgZW5hYmxlIG9yZGVyIGRpZmZlcnMgZnJvbSB1cHN0cmVhbSBkaWZmIGJ1dCBodW5rCmxv Y2F0aW9uIGlzIHVuY2hhbmdlZC4KCiMjIyBTdGVwIDYuMzogUmVsYXRlZCBGaXhlcyBBbHJlYWR5 IFByZXNlbnQ/CioqUmVjb3JkOioqIE5vIGVxdWl2YWxlbnQgZml4IGluIHRoaXMgdHJlZS4gUHJp b3IgcmVsYXRlZCBmaXgKNmQ5NGQwMDkwNTI3YiAobWlzc2luZyBjbGsgZGlzYWJsZSkgaXMgcHJl c2VudC4gRml4IGNvbW1pdCBub3QgZm91bmQgdmlhCmdyZXAgb3IgZ2l0IGxvZy4KCi0tLQoKIyMg UGhhc2UgNzogU3Vic3lzdGVtIENvbnRleHQKCiMjIyBTdGVwIDcuMTogU3Vic3lzdGVtIGFuZCBD cml0aWNhbGl0eQoqKlJlY29yZDoqKiAqKkFTb0MgLyBSb2NrY2hpcCBTUERJRiBkcml2ZXIqKiDi gJQgKipQRVJJUEhFUkFMKiogKFJvY2tjaGlwCmVtYmVkZGVkIFNvQyBhdWRpbyBvdXRwdXQpLiBB ZmZlY3RzIGJvYXJkcyB1c2luZyB0aGUgaW4tU29DIFNQRElGCmNvbnRyb2xsZXIgKFJLMzI4OCwg UkszMzk5LCBSSzM1NjgsIGV0Yy4pLgoKIyMjIFN0ZXAgNy4yOiBTdWJzeXN0ZW0gQWN0aXZpdHkK KipSZWNvcmQ6KiogTW9kZXJhdGUgcmVjZW50IGFjdGl2aXR5IChTQUkgZHJpdmVyIGFkZGl0aW9u cywgY2xlYW51cHMpOwpTUERJRiBkcml2ZXIgaXRzZWxmIGlzIG1hdHVyZSB3aXRoIGluZnJlcXVl bnQgY2hhbmdlcy4KCi0tLQoKIyMgUGhhc2UgODogSW1wYWN0IGFuZCBSaXNrIEFzc2Vzc21lbnQK CiMjIyBTdGVwIDguMTogV2hvIElzIEFmZmVjdGVkCioqUmVjb3JkOioqIFVzZXJzIG9mIFJvY2tj aGlwIHBsYXRmb3JtcyB3aXRoCmBDT05GSUdfU05EX1NPQ19ST0NLQ0hJUF9TUERJRmAgYW5kIHRo ZSBidWlsdC1pbiBTUERJRiBEQUkg4oCUCmVtYmVkZGVkL0FSTSBib2FyZHMsIG5vdCB1bml2ZXJz YWwgeDg2IHVzZXJzLgoKIyMjIFN0ZXAgOC4yOiBUcmlnZ2VyIENvbmRpdGlvbnMKKipSZWNvcmQ6 KioKLSAqKlRyaWdnZXI6KiogYHJlZ2NhY2hlX3N5bmMoKWAgZmFpbHVyZSBkdXJpbmcgcnVudGlt ZSByZXN1bWUKLSAqKkxpa2VsaWhvb2Q6KiogVW5jb21tb24gKHJlcXVpcmVzIGhhcmR3YXJlL2J1 cy9jbG9jayBpc3N1ZSBkdXJpbmcKICBzeW5jKQotICoqVW5wcml2aWxlZ2VkIHRyaWdnZXI6Kiog Tm8g4oCUIHJlcXVpcmVzIGRldmljZSBhY2Nlc3MgYW5kIGEgcmVzdW1lCiAgZmFpbHVyZSBjb25k aXRpb24KCiMjIyBTdGVwIDguMzogRmFpbHVyZSBNb2RlIFNldmVyaXR5CioqUmVjb3JkOioqCi0g KipGYWlsdXJlIG1vZGU6KiogUmVnbWFwIGF0dGVtcHRzIGxpdmUgTU1JTwogIChgZGV2bV9yZWdt YXBfaW5pdF9tbWlvX2Nsa2AgdXNlcyBgaGNsa2ApIHdoaWxlIGRyaXZlciBjb25zaWRlcnMKICBk ZXZpY2Ugc3VzcGVuZGVkOyByZWdpc3RlciBzdGF0ZSBtYXkgYmUgaW5jb25zaXN0ZW50OyBzdWJz ZXF1ZW50CiAgcmVzdW1lL2F1ZGlvIG9wZXJhdGlvbnMgbWF5IGZhaWwsIGhhbmcsIG9yIHByb2R1 Y2Ugc2lsZW50IGNvcnJ1cHRpb24KLSAqKlNldmVyaXR5OioqICoqTUVESVVNKiog4oCUIHJlYWwg ZnVuY3Rpb25hbCBidWcgb24gYW4gZXJyb3IgcGF0aCwgbm90IGEKICBjb21tb24gY3Jhc2gsIGJ1 dCBjYW4gbGVhdmUgZHJpdmVyIGluIGFuIHVucmVjb3ZlcmFibGUgaW5jb25zaXN0ZW50CiAgc3Rh dGUgd2l0aG91dCB0aGUgZml4CgojIyMgU3RlcCA4LjQ6IFJpc2stQmVuZWZpdAoqKlJlY29yZDoq KgotICoqQmVuZWZpdDoqKiBSZXN0b3JlcyBjb3JyZWN0IFBNL3JlZ21hcCBzdGF0ZSBpbnZhcmlh bnQ7IHByZXZlbnRzCiAgcG9zdC1mYWlsdXJlIHJlZ21hcC9oYXJkd2FyZSBtaXNtYXRjaCBvbiBS b2NrY2hpcCBTUERJRjsgYWxpZ25zIHdpdGgKICBlc3RhYmxpc2hlZCBrZXJuZWwgcGF0dGVybnMK LSAqKlJpc2s6KiogVmVyeSBsb3cg4oCUIG9uZSBsaW5lLCBlcnJvciBwYXRoIG9ubHkKLSAqKlJh dGlvOioqIEZhdm9yYWJsZSBmb3IgYmFja3BvcnQKCi0tLQoKIyMgUGhhc2UgOTogRmluYWwgU3lu dGhlc2lzCgojIyMgU3RlcCA5LjE6IEV2aWRlbmNlIFN1bW1hcnkKCioqRk9SIGJhY2twb3J0Oioq Ci0gUmVhbCBidWcg4oCUIGluY29tcGxldGUgZXJyb3ItcGF0aCBzdGF0ZSByZXN0b3JhdGlvbiBz aW5jZSAyMDE2Ci0gQnVnIGNvbmZpcm1lZCBwcmVzZW50IGluIHY2LjE4LjQ0IHRyZWUKLSBPbmUt bGluZSwgb2J2aW91c2x5IGNvcnJlY3QgZml4IG1hdGNoaW5nIGBzZ3RsNTAwMGAgYW5kIGJhY2tw b3J0ZWQKICBgcGNhOTUzeGAgcHJlY2VkZW50Ci0gQVNvQyBtYWludGFpbmVyIChNYXJrIEJyb3du KSBTaWduZWQtb2ZmLWJ5Ci0gU2FtZSBhdXRob3Igc3VjY2Vzc2Z1bGx5IGdvdCBhbmFsb2dvdXMg Zml4IGludG8gdGhpcyBzdGFibGUgdHJlZQotIExvdyByZWdyZXNzaW9uIHJpc2sKCioqQUdBSU5T VCBiYWNrcG9ydDoqKgotIFJhcmUgdHJpZ2dlciAoYHJlZ2NhY2hlX3N5bmMoKWAgZmFpbHVyZSkK LSBEcml2ZXItc3BlY2lmaWMsIGVtYmVkZGVkIFJvY2tjaGlwIG9ubHkKLSBObyB1c2VyIGNyYXNo IHJlcG9ydCBvciBzeXpib3Qg4oCUIGZsYWdnZWQgYnkgQUkgcmV2aWV3IGJvdAotIE1lZGl1bSBu b3QgY3JpdGljYWwgc2V2ZXJpdHkKCioqVU5SRVNPTFZFRDoqKgotIEZ1bGwgbG9yZSByZXZpZXcg dGhyZWFkIGNvbnRlbnQgKEFudWJpcyBibG9ja2VkKQotIFdoZXRoZXIgcmV2aWV3ZXJzIGV4cGxp Y2l0bHkgbm9taW5hdGVkIGZvciBzdGFibGUKLSBXaGV0aGVyIHBhdGNoIDUvTiBzZXJpZXMgaGFz IG90aGVyIGRlcGVuZGVuY2llcyAoZGlmZiBhcHBlYXJzCiAgc3RhbmRhbG9uZSkKCiMjIyBTdGVw IDkuMjogU3RhYmxlIFJ1bGVzIENoZWNrbGlzdAoxLiBPYnZpb3VzbHkgY29ycmVjdCBhbmQgdGVz dGVkPyAqKlBBU1MqKiDigJQgcGF0dGVybiBwcm92ZW4gZWxzZXdoZXJlOwogICBtYWludGFpbmVy IFNPQjsgbm8gVGVzdGVkLWJ5CjIuIEZpeGVzIGEgcmVhbCBidWcgYWZmZWN0aW5nIHVzZXJzPyAq KlBBU1MqKiDigJQgc3RhdGUtbWFjaGluZSBidWcgb24KICAgcmVzdW1lIGVycm9yIHBhdGggZm9y IFJvY2tjaGlwIFNQRElGIHVzZXJzCjMuIEltcG9ydGFudCBpc3N1ZT8gKipQQVNTIChNRURJVU0p Kiog4oCUIGNhbiBjYXVzZSBkcml2ZXIKICAgbWFsZnVuY3Rpb24vaGFuZyBvbiBlcnJvciBwYXRo LCBub3Qgc2VjdXJpdHkvZGF0YS1jb3JydXB0aW9uIGluCiAgIGNvbW1vbiBjYXNlCjQuIFNtYWxs IGFuZCBjb250YWluZWQ/ICoqUEFTUyoqIOKAlCAxIGxpbmUsIDEgZmlsZQo1LiBObyBuZXcgZmVh dHVyZXMgb3IgQVBJcz8gKipQQVNTKioKNi4gQ2FuIGFwcGx5IHRvIGxvY2FsIHRyZWU/ICoqUEFT UyoqIOKAlCBidWdneSBjb2RlIHByZXNlbnQsIGNsZWFuIGFwcGx5CgojIyMgU3RlcCA5LjM6IEV4 Y2VwdGlvbiBDYXRlZ29yaWVzCioqUmVjb3JkOioqIE5vdCBhcHBsaWNhYmxlIOKAlCBzdGFuZGFy ZCBidWcgZml4LCBub3QgZGV2aWNlCklEL3F1aXJrL2J1aWxkL2RvYyBleGNlcHRpb24uCgojIyMg U3RlcCA5LjQ6IERlY2lzaW9uIFJhdGlvbmFsZQpUaGlzIGlzIGEgd2VsbC11bmRlcnN0b29kIGVy cm9yLXBhdGggaW52YXJpYW50IGZpeDogd2hlbiBydW50aW1lIHJlc3VtZQpmYWlscyBhZnRlciBk aXNhYmxpbmcgY2FjaGUtb25seSBtb2RlLCB0aGUgZHJpdmVyIG11c3QgcmVzdG9yZSBjYWNoZS0K b25seSBtb2RlIGJlZm9yZSB0dXJuaW5nIGNsb2NrcyBvZmYg4oCUIGV4YWN0bHkgd2hhdCBzdXNw ZW5kIGVzdGFibGlzaGVkLgpUaGUgYnVnIGhhcyBleGlzdGVkIHNpbmNlIHRoZSByZWdjYWNoZSBy ZXN1bWUgbG9naWMgd2FzIGFkZGVkIGluIDIwMTYKYW5kIGlzIHByZXNlbnQgaW4gdGhpcyA2LjE4 LnkgdHJlZS4gV2hpbGUgdGhlIHRyaWdnZXIgaXMgdW5jb21tb24gYW5kCmltcGFjdCBpcyBkcml2 ZXItc3BlY2lmaWMsIHRoZSBmaXggaXMgdHJpdmlhbCwgbG93LXJpc2ssIG1haW50YWluZXItCmFw cHJvdmVkLCBhbmQgZm9sbG93cyBhIHBhdHRlcm4gYWxyZWFkeSBhY2NlcHRlZCBmb3Igc3RhYmxl IChwY2E5NTN4LApzZ3RsNTAwMCkuIENvbnNlcnZhdGl2ZSBzdGFibGUgcG9saWN5IGZhdm9ycyBz dWNoIHN1cmdpY2FsIGVycm9yLXBhdGgKZml4ZXMgdGhhdCBwcmV2ZW50IGxlYXZpbmcgaGFyZHdh cmUgZHJpdmVycyBpbiBpbmNvbnNpc3RlbnQgc3RhdGVzLgoKLS0tCgojIyBWZXJpZmljYXRpb24K Ci0gKipbUGhhc2UgMV0qKiBQYXJzZWQgY29tbWl0IG1lc3NhZ2UgYW5kIGFsbCB0YWdzIGZyb20g dXNlci1wcm92aWRlZAogIGNvbW1pdCB0ZXh0Ci0gKipbUGhhc2UgMl0qKiBEaWZmIGFuYWx5c2lz OiAxIGxpbmUgYWRkZWQgaW4KICBgcmtfc3BkaWZfcnVudGltZV9yZXN1bWUoKWAgZXJyb3IgcGF0 aAotICoqW1BoYXNlIDNdKiogYGdpdCBkZXNjcmliZSBIRUFEYDogdjYuMTguNDQtMS1nMjczNmMz MmRhOThiOSAvIGtlcm5lbAogIDYuMTguNDQKLSAqKltQaGFzZSAzXSoqIGBnaXQgYmxhbWUgLUwg NzcsMTA1YDogcmVnY2FjaGUgZXJyb3IgcGF0aCBmcm9tCiAgMzYyOGM2OTg3ZmI0NSAoMjAxNikK LSAqKltQaGFzZSAzXSoqIGBnaXQgc2hvdyAzNjI4YzY5ODdmYjQ1YDogY29uZmlybWVkIGludHJv ZHVjdGlvbiBvZgogIHJlZ2NhY2hlX3N5bmMgd2l0aG91dCBjYWNoZS1vbmx5IHJlc3RvcmUgb24g ZXJyb3IKLSAqKltQaGFzZSAzXSoqIGBnaXQgc2hvdyA2ZDk0ZDAwOTA1MjdiYDogcmVsYXRlZCBw cmlvciBlcnJvci1wYXRoIGZpeAogIGluIHNhbWUgZnVuY3Rpb24KLSAqKltQaGFzZSAzXSoqIGBn aXQgbG9nIC0tZ3JlcD0iUmVzdG9yZSByZWdjYWNoZSJgOiBubyBmaXggY29tbWl0IGluCiAgdHJl ZQotICoqW1BoYXNlIDNdKiogYGdpdCBzaG93IDJlNGJjODQyMmNkZWVgOiBzYW1lIGF1dGhvcidz IGFuYWxvZ291cwogIHBjYTk1M3ggZml4IGJhY2twb3J0ZWQgaGVyZSB3aXRoIENjOiBzdGFibGUK LSAqKltQaGFzZSA0XSoqIGBiNCBkaWcgLW0gIlJlc3RvcmUgcmVnY2FjaGUuLi4iYDogbm8gbWF0 Y2gKLSAqKltQaGFzZSA0XSoqIFdlYkZldGNoIGxvcmUvcGF0Y2gubXNnaWQubGluayBVUkxzOiBi bG9ja2VkIGJ5IEFudWJpcyDigJQKICAqKlVOVkVSSUZJRUQqKiByZXZpZXcgdGhyZWFkIGNvbnRl bnQKLSAqKltQaGFzZSA1XSoqIFJlYWQgYHJvY2tjaGlwX3NwZGlmLmNgOiBjb25maXJtZWQgcmVn bWFwIHVzZXJzIGFuZCBQTQogIG9wcyByZWdpc3RyYXRpb24KLSAqKltQaGFzZSA1XSoqIFJlYWQg YHNndGw1MDAwLmM6MTEzNS0xMTM5YDogY29uZmlybWVkIGNvcnJlY3QgcmVmZXJlbmNlCiAgcGF0 dGVybgotICoqW1BoYXNlIDVdKiogUmVhZCBgcm9ja2NoaXBfc2FpLmM6MjUxLTI3N2A6IHNhbWUg bWlzc2luZyBwYXR0ZXJuCiAgKHNlcGFyYXRlIGlzc3VlKQotICoqW1BoYXNlIDVdKiogUmVhZCBg ZHJpdmVycy9iYXNlL3JlZ21hcC9yZWdjYWNoZS5jOjU1MS01NzBgOiBjb25maXJtZWQKICBjYWNo ZV9vbmx5IHNlbWFudGljcwotICoqW1BoYXNlIDZdKiogUmVhZCBjdXJyZW50IGByb2NrY2hpcF9z cGRpZi5jOjY2LTEwNWA6IGNvbmZpcm1lZCBidWdneQogIGNvZGUgd2l0aG91dCBmaXgKLSAqKltQ aGFzZSA2XSoqIGBnaXQgbG9nIC0tb25lbGluZSAtMjAgLS0KICBzb3VuZC9zb2Mvcm9ja2NoaXAv cm9ja2NoaXBfc3BkaWYuY2A6IG5vIGNvbmZsaWN0aW5nIGZpeCBwcmVzZW50CgoqKllFUyoqKipW ZXJkaWN0OiBZRVMqKiDigJQgYmFja3BvcnQgdG8gdGhpcyB0cmVlICh2Ni4xOC40NCkuCgpUaGUg Um9ja2NoaXAgU1BESUYgZHJpdmVyIGxlYXZlcyBgcmVnY2FjaGVfY2FjaGVfb25seWAgZGlzYWJs ZWQgd2hlbgpgcmVnY2FjaGVfc3luYygpYCBmYWlscyBkdXJpbmcgcnVudGltZSByZXN1bWUsIHNv IGxhdGVyIHJlZ2lzdGVyCmFjY2Vzc2VzIGNhbiBoaXQgaGFyZHdhcmUgd2hpbGUgdGhlIGRldmlj ZSBpcyBzdGlsbCBpbmFjdGl2ZS4gVGhlIGZpeCBpcwphIG9uZS1saW5lIHJlc3RvcmUgb2YgY2Fj aGUtb25seSBtb2RlIG9uIHRoYXQgZXJyb3IgcGF0aCDigJQgc2FtZSBwYXR0ZXJuCmFzIGBzZ3Rs NTAwMGAgYW5kIHRoZSBhdXRob3LigJlzIGJhY2twb3J0ZWQgYHBjYTk1M3hgIGZpeC4gVGhlIGJ1 ZyBoYXMKYmVlbiBwcmVzZW50IHNpbmNlIDIwMTYgYW5kIGlzIHN0aWxsIGluIHRoaXMgY2hlY2tv dXQ7IGl04oCZcyBhIHNtYWxsLApsb3ctcmlzaywgbWFpbnRhaW5lci1zaWduZWQgZXJyb3ItcGF0 aCBmaXguCgogc291bmQvc29jL3JvY2tjaGlwL3JvY2tjaGlwX3NwZGlmLmMgfCAxICsKIDEgZmls ZSBjaGFuZ2VkLCAxIGluc2VydGlvbigrKQoKZGlmZiAtLWdpdCBhL3NvdW5kL3NvYy9yb2NrY2hp cC9yb2NrY2hpcF9zcGRpZi5jIGIvc291bmQvc29jL3JvY2tjaGlwL3JvY2tjaGlwX3NwZGlmLmMK aW5kZXggZDM2NTE2ODkzNGRjNi4uN2ExNWY2ODBkZTJmZSAxMDA2NDQKLS0tIGEvc291bmQvc29j L3JvY2tjaGlwL3JvY2tjaGlwX3NwZGlmLmMKKysrIGIvc291bmQvc29jL3JvY2tjaGlwL3JvY2tj aGlwX3NwZGlmLmMKQEAgLTk3LDYgKzk3LDcgQEAgc3RhdGljIGludCBya19zcGRpZl9ydW50aW1l X3Jlc3VtZShzdHJ1Y3QgZGV2aWNlICpkZXYpCiAKIAlyZXQgPSByZWdjYWNoZV9zeW5jKHNwZGlm LT5yZWdtYXApOwogCWlmIChyZXQpIHsKKwkJcmVnY2FjaGVfY2FjaGVfb25seShzcGRpZi0+cmVn bWFwLCB0cnVlKTsKIAkJY2xrX2Rpc2FibGVfdW5wcmVwYXJlKHNwZGlmLT5tY2xrKTsKIAkJY2xr X2Rpc2FibGVfdW5wcmVwYXJlKHNwZGlmLT5oY2xrKTsKIAl9Ci0tIAoyLjUzLjAKCgpfX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpMaW51eC1yb2NrY2hpcCBt YWlsaW5nIGxpc3QKTGludXgtcm9ja2NoaXBAbGlzdHMuaW5mcmFkZWFkLm9yZwpodHRwOi8vbGlz dHMuaW5mcmFkZWFkLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xpbnV4LXJvY2tjaGlwCg==