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 X-Spam-Level: X-Spam-Status: No, score=-9.1 required=3.0 tests=DKIM_SIGNED,DKIM_VALID, DKIM_VALID_AU,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_PASS, URIBL_BLOCKED,USER_AGENT_GIT autolearn=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id AF848C43381 for ; Wed, 27 Mar 2019 19:17:37 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 7EBD2206C0 for ; Wed, 27 Mar 2019 19:17:37 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=default; t=1553714257; bh=s97hackakEue2v6mr5/qQjUXUzuAAgS4L41NadkgU9w=; h=From:To:Cc:Subject:Date:In-Reply-To:References:List-ID:From; b=Eruc6amtAmS0sL9oCj/Z90PYnQllhvvqDfUbLIhCr1yocDtE70FQ813n6hyq/smYF 7yGZYouvfiHBE+r23KUEWZrXpiUuGRTRJlSKwHcFJ7TrCMu5S0s10SGkze8UOL3rG4 3al4iFqqtk5nJXwpABLSZdTjWWxTgbqae3ypF56o= Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S2388587AbfC0TRg (ORCPT ); Wed, 27 Mar 2019 15:17:36 -0400 Received: from mail.kernel.org ([198.145.29.99]:50588 "EHLO mail.kernel.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S2388403AbfC0SIt (ORCPT ); Wed, 27 Mar 2019 14:08:49 -0400 Received: from sasha-vm.mshome.net (c-73-47-72-35.hsd1.nh.comcast.net [73.47.72.35]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPSA id 23AE62063F; Wed, 27 Mar 2019 18:08:47 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=default; t=1553710127; bh=s97hackakEue2v6mr5/qQjUXUzuAAgS4L41NadkgU9w=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=UlNCbox5tqZYQvKnwwX97LNbmp0Zo1os8LfizbW/qFuq6+Bqbq+9rk1HY4rYyu1vt r1iyAam9G3wuKT7eUhdZF2Pkndg8VlOGituvqRTWEZyX/YAUIxFLv6l+GNsseF4KNg AeQqSs918QBREXiAZrQGi69RzNswOAyelN4wSnFo= From: Sasha Levin To: linux-kernel@vger.kernel.org, stable@vger.kernel.org Cc: Nicholas Kazlauskas , Alex Deucher , Sasha Levin , amd-gfx@lists.freedesktop.org, dri-devel@lists.freedesktop.org Subject: [PATCH AUTOSEL 5.0 207/262] drm/amd/display: Enable vblank interrupt during CRC capture Date: Wed, 27 Mar 2019 14:01:02 -0400 Message-Id: <20190327180158.10245-207-sashal@kernel.org> X-Mailer: git-send-email 2.19.1 In-Reply-To: <20190327180158.10245-1-sashal@kernel.org> References: <20190327180158.10245-1-sashal@kernel.org> MIME-Version: 1.0 X-Patchwork-Hint: Ignore Content-Transfer-Encoding: 8bit Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org From: Nicholas Kazlauskas [ Upstream commit 428da2bdb05d76c48d0bd8fbfa2e4c102685be08 ] [Why] In order to read CRC events when CRC capture is enabled the vblank interrput handler needs to be running for the CRTC. The handler is enabled while there is an active vblank reference. When running IGT tests there will often be no active vblank reference but the test expects to read a CRC value. This is valid usage (and works on i915 since they have a CRC interrupt handler) so the reference to the vblank should be grabbed while capture is active. This issue was found running: igt@kms_plane_multiple@atomic-pipe-b-tiling-none The pipe-b is the only one in the initial commit and was not previously active so no vblank reference is grabbed. The vblank interrupt is not enabled and the test times out. [How] Keep a reference to the vblank as long as CRC capture is enabled. If userspace never explicitly disables it then the reference is also dropped when removing the CRTC from the context (stream = NULL). Signed-off-by: Nicholas Kazlauskas Reviewed-by: Harry Wentland Reviewed-by: Sun peng Li Acked-by: Leo Li Signed-off-by: Alex Deucher Signed-off-by: Sasha Levin --- .../gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c | 14 ++++++- .../drm/amd/display/amdgpu_dm/amdgpu_dm_crc.c | 42 +++++++++---------- 2 files changed, 34 insertions(+), 22 deletions(-) diff --git a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c index 0040605cace8..83c8a0407537 100644 --- a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c +++ b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm.c @@ -4997,10 +4997,22 @@ static int amdgpu_dm_atomic_commit(struct drm_device *dev, */ for_each_oldnew_crtc_in_state(state, crtc, old_crtc_state, new_crtc_state, i) { struct dm_crtc_state *dm_old_crtc_state = to_dm_crtc_state(old_crtc_state); + struct dm_crtc_state *dm_new_crtc_state = to_dm_crtc_state(new_crtc_state); struct amdgpu_crtc *acrtc = to_amdgpu_crtc(crtc); - if (drm_atomic_crtc_needs_modeset(new_crtc_state) && dm_old_crtc_state->stream) + if (drm_atomic_crtc_needs_modeset(new_crtc_state) + && dm_old_crtc_state->stream) { + /* + * CRC capture was enabled but not disabled. + * Release the vblank reference. + */ + if (dm_new_crtc_state->crc_enabled) { + drm_crtc_vblank_put(crtc); + dm_new_crtc_state->crc_enabled = false; + } + manage_dm_interrupts(adev, acrtc, false); + } } /* * Add check here for SoC's that support hardware cursor plane, to diff --git a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_crc.c b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_crc.c index f088ac585978..26b651148c67 100644 --- a/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_crc.c +++ b/drivers/gpu/drm/amd/display/amdgpu_dm/amdgpu_dm_crc.c @@ -66,6 +66,7 @@ int amdgpu_dm_crtc_set_crc_source(struct drm_crtc *crtc, const char *src_name) { struct dm_crtc_state *crtc_state = to_dm_crtc_state(crtc->state); struct dc_stream_state *stream_state = crtc_state->stream; + bool enable; enum amdgpu_dm_pipe_crc_source source = dm_parse_crc_source(src_name); @@ -80,28 +81,27 @@ int amdgpu_dm_crtc_set_crc_source(struct drm_crtc *crtc, const char *src_name) return -EINVAL; } + enable = (source == AMDGPU_DM_PIPE_CRC_SOURCE_AUTO); + + if (!dc_stream_configure_crc(stream_state->ctx->dc, stream_state, + enable, enable)) + return -EINVAL; + /* When enabling CRC, we should also disable dithering. */ - if (source == AMDGPU_DM_PIPE_CRC_SOURCE_AUTO) { - if (dc_stream_configure_crc(stream_state->ctx->dc, - stream_state, - true, true)) { - crtc_state->crc_enabled = true; - dc_stream_set_dither_option(stream_state, - DITHER_OPTION_TRUN8); - } - else - return -EINVAL; - } else { - if (dc_stream_configure_crc(stream_state->ctx->dc, - stream_state, - false, false)) { - crtc_state->crc_enabled = false; - dc_stream_set_dither_option(stream_state, - DITHER_OPTION_DEFAULT); - } - else - return -EINVAL; - } + dc_stream_set_dither_option(stream_state, + enable ? DITHER_OPTION_TRUN8 + : DITHER_OPTION_DEFAULT); + + /* + * Reading the CRC requires the vblank interrupt handler to be + * enabled. Keep a reference until CRC capture stops. + */ + if (!crtc_state->crc_enabled && enable) + drm_crtc_vblank_get(crtc); + else if (crtc_state->crc_enabled && !enable) + drm_crtc_vblank_put(crtc); + + crtc_state->crc_enabled = enable; /* Reset crc_skipped on dm state */ crtc_state->crc_skip_count = 0; -- 2.19.1 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Sasha Levin Subject: [PATCH AUTOSEL 5.0 207/262] drm/amd/display: Enable vblank interrupt during CRC capture Date: Wed, 27 Mar 2019 14:01:02 -0400 Message-ID: <20190327180158.10245-207-sashal@kernel.org> References: <20190327180158.10245-1-sashal@kernel.org> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20190327180158.10245-1-sashal@kernel.org> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: linux-kernel@vger.kernel.org, stable@vger.kernel.org Cc: Alex Deucher , Sasha Levin , dri-devel@lists.freedesktop.org, Nicholas Kazlauskas , amd-gfx@lists.freedesktop.org List-Id: dri-devel@lists.freedesktop.org RnJvbTogTmljaG9sYXMgS2F6bGF1c2thcyA8bmljaG9sYXMua2F6bGF1c2thc0BhbWQuY29tPgoK WyBVcHN0cmVhbSBjb21taXQgNDI4ZGEyYmRiMDVkNzZjNDhkMGJkOGZiZmEyZTRjMTAyNjg1YmUw OCBdCgpbV2h5XQpJbiBvcmRlciB0byByZWFkIENSQyBldmVudHMgd2hlbiBDUkMgY2FwdHVyZSBp cyBlbmFibGVkIHRoZSB2YmxhbmsKaW50ZXJycHV0IGhhbmRsZXIgbmVlZHMgdG8gYmUgcnVubmlu ZyBmb3IgdGhlIENSVEMuIFRoZSBoYW5kbGVyIGlzCmVuYWJsZWQgd2hpbGUgdGhlcmUgaXMgYW4g YWN0aXZlIHZibGFuayByZWZlcmVuY2UuCgpXaGVuIHJ1bm5pbmcgSUdUIHRlc3RzIHRoZXJlIHdp bGwgb2Z0ZW4gYmUgbm8gYWN0aXZlIHZibGFuayByZWZlcmVuY2UKYnV0IHRoZSB0ZXN0IGV4cGVj dHMgdG8gcmVhZCBhIENSQyB2YWx1ZS4gVGhpcyBpcyB2YWxpZCB1c2FnZSAoYW5kCndvcmtzIG9u IGk5MTUgc2luY2UgdGhleSBoYXZlIGEgQ1JDIGludGVycnVwdCBoYW5kbGVyKSBzbyB0aGUgcmVm ZXJlbmNlCnRvIHRoZSB2Ymxhbmsgc2hvdWxkIGJlIGdyYWJiZWQgd2hpbGUgY2FwdHVyZSBpcyBh Y3RpdmUuCgpUaGlzIGlzc3VlIHdhcyBmb3VuZCBydW5uaW5nOgoKaWd0QGttc19wbGFuZV9tdWx0 aXBsZUBhdG9taWMtcGlwZS1iLXRpbGluZy1ub25lCgpUaGUgcGlwZS1iIGlzIHRoZSBvbmx5IG9u ZSBpbiB0aGUgaW5pdGlhbCBjb21taXQgYW5kIHdhcyBub3QgcHJldmlvdXNseQphY3RpdmUgc28g bm8gdmJsYW5rIHJlZmVyZW5jZSBpcyBncmFiYmVkLiBUaGUgdmJsYW5rIGludGVycnVwdCBpcwpu b3QgZW5hYmxlZCBhbmQgdGhlIHRlc3QgdGltZXMgb3V0LgoKW0hvd10KS2VlcCBhIHJlZmVyZW5j ZSB0byB0aGUgdmJsYW5rIGFzIGxvbmcgYXMgQ1JDIGNhcHR1cmUgaXMgZW5hYmxlZC4KSWYgdXNl cnNwYWNlIG5ldmVyIGV4cGxpY2l0bHkgZGlzYWJsZXMgaXQgdGhlbiB0aGUgcmVmZXJlbmNlIGlz CmFsc28gZHJvcHBlZCB3aGVuIHJlbW92aW5nIHRoZSBDUlRDIGZyb20gdGhlIGNvbnRleHQgKHN0 cmVhbSA9IE5VTEwpLgoKU2lnbmVkLW9mZi1ieTogTmljaG9sYXMgS2F6bGF1c2thcyA8bmljaG9s YXMua2F6bGF1c2thc0BhbWQuY29tPgpSZXZpZXdlZC1ieTogSGFycnkgV2VudGxhbmQgPEhhcnJ5 LldlbnRsYW5kQGFtZC5jb20+ClJldmlld2VkLWJ5OiBTdW4gcGVuZyBMaSA8U3VucGVuZy5MaUBh bWQuY29tPgpBY2tlZC1ieTogTGVvIExpIDxzdW5wZW5nLmxpQGFtZC5jb20+ClNpZ25lZC1vZmYt Ynk6IEFsZXggRGV1Y2hlciA8YWxleGFuZGVyLmRldWNoZXJAYW1kLmNvbT4KU2lnbmVkLW9mZi1i eTogU2FzaGEgTGV2aW4gPHNhc2hhbEBrZXJuZWwub3JnPgotLS0KIC4uLi9ncHUvZHJtL2FtZC9k aXNwbGF5L2FtZGdwdV9kbS9hbWRncHVfZG0uYyB8IDE0ICsrKysrKy0KIC4uLi9kcm0vYW1kL2Rp c3BsYXkvYW1kZ3B1X2RtL2FtZGdwdV9kbV9jcmMuYyB8IDQyICsrKysrKysrKy0tLS0tLS0tLS0K IDIgZmlsZXMgY2hhbmdlZCwgMzQgaW5zZXJ0aW9ucygrKSwgMjIgZGVsZXRpb25zKC0pCgpkaWZm IC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2FtZC9kaXNwbGF5L2FtZGdwdV9kbS9hbWRncHVfZG0u YyBiL2RyaXZlcnMvZ3B1L2RybS9hbWQvZGlzcGxheS9hbWRncHVfZG0vYW1kZ3B1X2RtLmMKaW5k ZXggMDA0MDYwNWNhY2U4Li44M2M4YTA0MDc1MzcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2Ry bS9hbWQvZGlzcGxheS9hbWRncHVfZG0vYW1kZ3B1X2RtLmMKKysrIGIvZHJpdmVycy9ncHUvZHJt L2FtZC9kaXNwbGF5L2FtZGdwdV9kbS9hbWRncHVfZG0uYwpAQCAtNDk5NywxMCArNDk5NywyMiBA QCBzdGF0aWMgaW50IGFtZGdwdV9kbV9hdG9taWNfY29tbWl0KHN0cnVjdCBkcm1fZGV2aWNlICpk ZXYsCiAJICovCiAJZm9yX2VhY2hfb2xkbmV3X2NydGNfaW5fc3RhdGUoc3RhdGUsIGNydGMsIG9s ZF9jcnRjX3N0YXRlLCBuZXdfY3J0Y19zdGF0ZSwgaSkgewogCQlzdHJ1Y3QgZG1fY3J0Y19zdGF0 ZSAqZG1fb2xkX2NydGNfc3RhdGUgPSB0b19kbV9jcnRjX3N0YXRlKG9sZF9jcnRjX3N0YXRlKTsK KwkJc3RydWN0IGRtX2NydGNfc3RhdGUgKmRtX25ld19jcnRjX3N0YXRlID0gdG9fZG1fY3J0Y19z dGF0ZShuZXdfY3J0Y19zdGF0ZSk7CiAJCXN0cnVjdCBhbWRncHVfY3J0YyAqYWNydGMgPSB0b19h bWRncHVfY3J0YyhjcnRjKTsKIAotCQlpZiAoZHJtX2F0b21pY19jcnRjX25lZWRzX21vZGVzZXQo bmV3X2NydGNfc3RhdGUpICYmIGRtX29sZF9jcnRjX3N0YXRlLT5zdHJlYW0pCisJCWlmIChkcm1f YXRvbWljX2NydGNfbmVlZHNfbW9kZXNldChuZXdfY3J0Y19zdGF0ZSkKKwkJICAgICYmIGRtX29s ZF9jcnRjX3N0YXRlLT5zdHJlYW0pIHsKKwkJCS8qCisJCQkgKiBDUkMgY2FwdHVyZSB3YXMgZW5h YmxlZCBidXQgbm90IGRpc2FibGVkLgorCQkJICogUmVsZWFzZSB0aGUgdmJsYW5rIHJlZmVyZW5j ZS4KKwkJCSAqLworCQkJaWYgKGRtX25ld19jcnRjX3N0YXRlLT5jcmNfZW5hYmxlZCkgeworCQkJ CWRybV9jcnRjX3ZibGFua19wdXQoY3J0Yyk7CisJCQkJZG1fbmV3X2NydGNfc3RhdGUtPmNyY19l bmFibGVkID0gZmFsc2U7CisJCQl9CisKIAkJCW1hbmFnZV9kbV9pbnRlcnJ1cHRzKGFkZXYsIGFj cnRjLCBmYWxzZSk7CisJCX0KIAl9CiAJLyoKIAkgKiBBZGQgY2hlY2sgaGVyZSBmb3IgU29DJ3Mg dGhhdCBzdXBwb3J0IGhhcmR3YXJlIGN1cnNvciBwbGFuZSwgdG8KZGlmZiAtLWdpdCBhL2RyaXZl cnMvZ3B1L2RybS9hbWQvZGlzcGxheS9hbWRncHVfZG0vYW1kZ3B1X2RtX2NyYy5jIGIvZHJpdmVy cy9ncHUvZHJtL2FtZC9kaXNwbGF5L2FtZGdwdV9kbS9hbWRncHVfZG1fY3JjLmMKaW5kZXggZjA4 OGFjNTg1OTc4Li4yNmI2NTExNDhjNjcgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9hbWQv ZGlzcGxheS9hbWRncHVfZG0vYW1kZ3B1X2RtX2NyYy5jCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9h bWQvZGlzcGxheS9hbWRncHVfZG0vYW1kZ3B1X2RtX2NyYy5jCkBAIC02Niw2ICs2Niw3IEBAIGlu dCBhbWRncHVfZG1fY3J0Y19zZXRfY3JjX3NvdXJjZShzdHJ1Y3QgZHJtX2NydGMgKmNydGMsIGNv bnN0IGNoYXIgKnNyY19uYW1lKQogewogCXN0cnVjdCBkbV9jcnRjX3N0YXRlICpjcnRjX3N0YXRl ID0gdG9fZG1fY3J0Y19zdGF0ZShjcnRjLT5zdGF0ZSk7CiAJc3RydWN0IGRjX3N0cmVhbV9zdGF0 ZSAqc3RyZWFtX3N0YXRlID0gY3J0Y19zdGF0ZS0+c3RyZWFtOworCWJvb2wgZW5hYmxlOwogCiAJ ZW51bSBhbWRncHVfZG1fcGlwZV9jcmNfc291cmNlIHNvdXJjZSA9IGRtX3BhcnNlX2NyY19zb3Vy Y2Uoc3JjX25hbWUpOwogCkBAIC04MCwyOCArODEsMjcgQEAgaW50IGFtZGdwdV9kbV9jcnRjX3Nl dF9jcmNfc291cmNlKHN0cnVjdCBkcm1fY3J0YyAqY3J0YywgY29uc3QgY2hhciAqc3JjX25hbWUp CiAJCXJldHVybiAtRUlOVkFMOwogCX0KIAorCWVuYWJsZSA9IChzb3VyY2UgPT0gQU1ER1BVX0RN X1BJUEVfQ1JDX1NPVVJDRV9BVVRPKTsKKworCWlmICghZGNfc3RyZWFtX2NvbmZpZ3VyZV9jcmMo c3RyZWFtX3N0YXRlLT5jdHgtPmRjLCBzdHJlYW1fc3RhdGUsCisJCQkJICAgICBlbmFibGUsIGVu YWJsZSkpCisJCXJldHVybiAtRUlOVkFMOworCiAJLyogV2hlbiBlbmFibGluZyBDUkMsIHdlIHNo b3VsZCBhbHNvIGRpc2FibGUgZGl0aGVyaW5nLiAqLwotCWlmIChzb3VyY2UgPT0gQU1ER1BVX0RN X1BJUEVfQ1JDX1NPVVJDRV9BVVRPKSB7Ci0JCWlmIChkY19zdHJlYW1fY29uZmlndXJlX2NyYyhz dHJlYW1fc3RhdGUtPmN0eC0+ZGMsCi0JCQkJCSAgICBzdHJlYW1fc3RhdGUsCi0JCQkJCSAgICB0 cnVlLCB0cnVlKSkgewotCQkJY3J0Y19zdGF0ZS0+Y3JjX2VuYWJsZWQgPSB0cnVlOwotCQkJZGNf c3RyZWFtX3NldF9kaXRoZXJfb3B0aW9uKHN0cmVhbV9zdGF0ZSwKLQkJCQkJCSAgICBESVRIRVJf T1BUSU9OX1RSVU44KTsKLQkJfQotCQllbHNlCi0JCQlyZXR1cm4gLUVJTlZBTDsKLQl9IGVsc2Ug ewotCQlpZiAoZGNfc3RyZWFtX2NvbmZpZ3VyZV9jcmMoc3RyZWFtX3N0YXRlLT5jdHgtPmRjLAot CQkJCQkgICAgc3RyZWFtX3N0YXRlLAotCQkJCQkgICAgZmFsc2UsIGZhbHNlKSkgewotCQkJY3J0 Y19zdGF0ZS0+Y3JjX2VuYWJsZWQgPSBmYWxzZTsKLQkJCWRjX3N0cmVhbV9zZXRfZGl0aGVyX29w dGlvbihzdHJlYW1fc3RhdGUsCi0JCQkJCQkgICAgRElUSEVSX09QVElPTl9ERUZBVUxUKTsKLQkJ fQotCQllbHNlCi0JCQlyZXR1cm4gLUVJTlZBTDsKLQl9CisJZGNfc3RyZWFtX3NldF9kaXRoZXJf b3B0aW9uKHN0cmVhbV9zdGF0ZSwKKwkJCQkgICAgZW5hYmxlID8gRElUSEVSX09QVElPTl9UUlVO OAorCQkJCQkgICA6IERJVEhFUl9PUFRJT05fREVGQVVMVCk7CisKKwkvKgorCSAqIFJlYWRpbmcg dGhlIENSQyByZXF1aXJlcyB0aGUgdmJsYW5rIGludGVycnVwdCBoYW5kbGVyIHRvIGJlCisJICog ZW5hYmxlZC4gS2VlcCBhIHJlZmVyZW5jZSB1bnRpbCBDUkMgY2FwdHVyZSBzdG9wcy4KKwkgKi8K KwlpZiAoIWNydGNfc3RhdGUtPmNyY19lbmFibGVkICYmIGVuYWJsZSkKKwkJZHJtX2NydGNfdmJs YW5rX2dldChjcnRjKTsKKwllbHNlIGlmIChjcnRjX3N0YXRlLT5jcmNfZW5hYmxlZCAmJiAhZW5h YmxlKQorCQlkcm1fY3J0Y192YmxhbmtfcHV0KGNydGMpOworCisJY3J0Y19zdGF0ZS0+Y3JjX2Vu YWJsZWQgPSBlbmFibGU7CiAKIAkvKiBSZXNldCBjcmNfc2tpcHBlZCBvbiBkbSBzdGF0ZSAqLwog CWNydGNfc3RhdGUtPmNyY19za2lwX2NvdW50ID0gMDsKLS0gCjIuMTkuMQoKX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KZHJpLWRldmVsIG1haWxpbmcgbGlz dApkcmktZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0 b3Aub3JnL21haWxtYW4vbGlzdGluZm8vZHJpLWRldmVs