From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S932974AbcJHAMt (ORCPT ); Fri, 7 Oct 2016 20:12:49 -0400 Received: from mx1.redhat.com ([209.132.183.28]:32988 "EHLO mx1.redhat.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S932941AbcJHAMe (ORCPT ); Fri, 7 Oct 2016 20:12:34 -0400 From: Lyude To: intel-gfx@lists.freedesktop.org Cc: Lyude , Maarten Lankhorst , =?UTF-8?q?Ville=20Syrj=C3=A4l=C3=A4?= , Paulo Zanoni , Daniel Vetter , Jani Nikula , David Airlie , dri-devel@lists.freedesktop.org, linux-kernel@vger.kernel.org Subject: [PATCH 09/10] drm/i915/gen9: Actually verify WM levels in verify_wm_state() Date: Fri, 7 Oct 2016 20:11:33 -0400 Message-Id: <1475885497-6094-10-git-send-email-cpaul@redhat.com> In-Reply-To: <1475885497-6094-1-git-send-email-cpaul@redhat.com> References: <1475885497-6094-1-git-send-email-cpaul@redhat.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit X-Greylist: Sender IP whitelisted, not delayed by milter-greylist-4.5.16 (mx1.redhat.com [10.5.110.39]); Sat, 08 Oct 2016 00:12:33 +0000 (UTC) Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Thanks to Paulo Zanoni for indirectly pointing this out. Looks like we never actually added any code for checking whether or not we actually wrote watermark levels properly. Let's fix that. Signed-off-by: Lyude Cc: Maarten Lankhorst Cc: Ville Syrjälä Cc: Paulo Zanoni --- drivers/gpu/drm/i915/intel_display.c | 100 +++++++++++++++++++++++++++++------ 1 file changed, 84 insertions(+), 16 deletions(-) diff --git a/drivers/gpu/drm/i915/intel_display.c b/drivers/gpu/drm/i915/intel_display.c index 39400a0..2c682bc 100644 --- a/drivers/gpu/drm/i915/intel_display.c +++ b/drivers/gpu/drm/i915/intel_display.c @@ -13444,30 +13444,66 @@ static void verify_wm_state(struct drm_crtc *crtc, struct drm_device *dev = crtc->dev; struct drm_i915_private *dev_priv = to_i915(dev); struct skl_ddb_allocation hw_ddb, *sw_ddb; - struct skl_ddb_entry *hw_entry, *sw_entry; + struct skl_pipe_wm hw_wm, *sw_wm; + struct skl_plane_wm *hw_plane_wm, *sw_plane_wm; + struct skl_ddb_entry *hw_ddb_entry, *sw_ddb_entry; struct intel_crtc *intel_crtc = to_intel_crtc(crtc); const enum pipe pipe = intel_crtc->pipe; - int plane; + int plane, level, max_level = ilk_wm_max_level(dev); if (INTEL_INFO(dev)->gen < 9 || !new_state->active) return; + skl_pipe_wm_get_hw_state(crtc, &hw_wm); + sw_wm = &intel_crtc->wm.active.skl; + skl_ddb_get_hw_state(dev_priv, &hw_ddb); sw_ddb = &dev_priv->wm.skl_hw.ddb; /* planes */ for_each_plane(dev_priv, pipe, plane) { - hw_entry = &hw_ddb.plane[pipe][plane]; - sw_entry = &sw_ddb->plane[pipe][plane]; + hw_plane_wm = &hw_wm.planes[plane]; + sw_plane_wm = &sw_wm->planes[plane]; - if (skl_ddb_entry_equal(hw_entry, sw_entry)) - continue; + /* Watermarks */ + for (level = 0; level <= max_level; level++) { + if (skl_wm_level_equals(&hw_plane_wm->wm[level], + &sw_plane_wm->wm[level])) + continue; + + DRM_ERROR("mismatch in WM pipe %c plane %d level %d (expected e=%d b=%d l=%d, got e=%d b=%d l=%d)\n", + pipe_name(pipe), plane + 1, level, + sw_plane_wm->wm[level].plane_en, + sw_plane_wm->wm[level].plane_res_b, + sw_plane_wm->wm[level].plane_res_l, + hw_plane_wm->wm[level].plane_en, + hw_plane_wm->wm[level].plane_res_b, + hw_plane_wm->wm[level].plane_res_l); + } - DRM_ERROR("mismatch in DDB state pipe %c plane %d " - "(expected (%u,%u), found (%u,%u))\n", - pipe_name(pipe), plane + 1, - sw_entry->start, sw_entry->end, - hw_entry->start, hw_entry->end); + if (!skl_wm_level_equals(&hw_plane_wm->trans_wm, + &sw_plane_wm->trans_wm)) { + DRM_ERROR("mismatch in trans WM pipe %c plane %d (expected e=%d b=%d l=%d, got e=%d b=%d l=%d)\n", + pipe_name(pipe), plane + 1, + sw_plane_wm->trans_wm.plane_en, + sw_plane_wm->trans_wm.plane_res_b, + sw_plane_wm->trans_wm.plane_res_l, + hw_plane_wm->trans_wm.plane_en, + hw_plane_wm->trans_wm.plane_res_b, + hw_plane_wm->trans_wm.plane_res_l); + } + + /* DDB */ + hw_ddb_entry = &hw_ddb.plane[pipe][plane]; + sw_ddb_entry = &sw_ddb->plane[pipe][plane]; + + if (!skl_ddb_entry_equal(hw_ddb_entry, sw_ddb_entry)) { + DRM_ERROR("mismatch in DDB state pipe %c plane %d " + "(expected (%u,%u), found (%u,%u))\n", + pipe_name(pipe), plane + 1, + sw_ddb_entry->start, sw_ddb_entry->end, + hw_ddb_entry->start, hw_ddb_entry->end); + } } /* @@ -13477,15 +13513,47 @@ static void verify_wm_state(struct drm_crtc *crtc, * once the plane becomes visible, we can skip this check */ if (intel_crtc->cursor_addr) { - hw_entry = &hw_ddb.plane[pipe][PLANE_CURSOR]; - sw_entry = &sw_ddb->plane[pipe][PLANE_CURSOR]; + hw_plane_wm = &hw_wm.planes[PLANE_CURSOR]; + sw_plane_wm = &sw_wm->planes[PLANE_CURSOR]; + + /* Watermarks */ + for (level = 0; level <= max_level; level++) { + if (skl_wm_level_equals(&hw_plane_wm->wm[level], + &sw_plane_wm->wm[level])) + continue; + + DRM_ERROR("mismatch in WM pipe %c cursor level %d (expected e=%d b=%d l=%d, got e=%d b=%d l=%d)\n", + pipe_name(pipe), level, + sw_plane_wm->wm[level].plane_en, + sw_plane_wm->wm[level].plane_res_b, + sw_plane_wm->wm[level].plane_res_l, + hw_plane_wm->wm[level].plane_en, + hw_plane_wm->wm[level].plane_res_b, + hw_plane_wm->wm[level].plane_res_l); + } + + if (!skl_wm_level_equals(&hw_plane_wm->trans_wm, + &sw_plane_wm->trans_wm)) { + DRM_ERROR("mismatch in trans WM pipe %c cursor (expected e=%d b=%d l=%d, got e=%d b=%d l=%d)\n", + pipe_name(pipe), + sw_plane_wm->trans_wm.plane_en, + sw_plane_wm->trans_wm.plane_res_b, + sw_plane_wm->trans_wm.plane_res_l, + hw_plane_wm->trans_wm.plane_en, + hw_plane_wm->trans_wm.plane_res_b, + hw_plane_wm->trans_wm.plane_res_l); + } + + /* DDB */ + hw_ddb_entry = &hw_ddb.plane[pipe][PLANE_CURSOR]; + sw_ddb_entry = &sw_ddb->plane[pipe][PLANE_CURSOR]; - if (!skl_ddb_entry_equal(hw_entry, sw_entry)) { + if (!skl_ddb_entry_equal(hw_ddb_entry, sw_ddb_entry)) { DRM_ERROR("mismatch in DDB state pipe %c cursor " "(expected (%u,%u), found (%u,%u))\n", pipe_name(pipe), - sw_entry->start, sw_entry->end, - hw_entry->start, hw_entry->end); + sw_ddb_entry->start, sw_ddb_entry->end, + hw_ddb_entry->start, hw_ddb_entry->end); } } } -- 2.7.4 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Lyude Subject: [PATCH 09/10] drm/i915/gen9: Actually verify WM levels in verify_wm_state() Date: Fri, 7 Oct 2016 20:11:33 -0400 Message-ID: <1475885497-6094-10-git-send-email-cpaul@redhat.com> References: <1475885497-6094-1-git-send-email-cpaul@redhat.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <1475885497-6094-1-git-send-email-cpaul@redhat.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" To: intel-gfx@lists.freedesktop.org Cc: Paulo Zanoni , David Airlie , linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, Daniel Vetter List-Id: dri-devel@lists.freedesktop.org VGhhbmtzIHRvIFBhdWxvIFphbm9uaSBmb3IgaW5kaXJlY3RseSBwb2ludGluZyB0aGlzIG91dC4K Ckxvb2tzIGxpa2Ugd2UgbmV2ZXIgYWN0dWFsbHkgYWRkZWQgYW55IGNvZGUgZm9yIGNoZWNraW5n IHdoZXRoZXIgb3Igbm90CndlIGFjdHVhbGx5IHdyb3RlIHdhdGVybWFyayBsZXZlbHMgcHJvcGVy bHkuIExldCdzIGZpeCB0aGF0LgoKU2lnbmVkLW9mZi1ieTogTHl1ZGUgPGNwYXVsQHJlZGhhdC5j b20+CkNjOiBNYWFydGVuIExhbmtob3JzdCA8bWFhcnRlbi5sYW5raG9yc3RAbGludXguaW50ZWwu Y29tPgpDYzogVmlsbGUgU3lyasOkbMOkIDx2aWxsZS5zeXJqYWxhQGxpbnV4LmludGVsLmNvbT4K Q2M6IFBhdWxvIFphbm9uaSA8cGF1bG8uci56YW5vbmlAaW50ZWwuY29tPgotLS0KIGRyaXZlcnMv Z3B1L2RybS9pOTE1L2ludGVsX2Rpc3BsYXkuYyB8IDEwMCArKysrKysrKysrKysrKysrKysrKysr KysrKysrKy0tLS0tLQogMSBmaWxlIGNoYW5nZWQsIDg0IGluc2VydGlvbnMoKyksIDE2IGRlbGV0 aW9ucygtKQoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2Rpc3BsYXku YyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2Rpc3BsYXkuYwppbmRleCAzOTQwMGEwLi4y YzY4MmJjIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kaXNwbGF5LmMK KysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZGlzcGxheS5jCkBAIC0xMzQ0NCwzMCAr MTM0NDQsNjYgQEAgc3RhdGljIHZvaWQgdmVyaWZ5X3dtX3N0YXRlKHN0cnVjdCBkcm1fY3J0YyAq Y3J0YywKIAlzdHJ1Y3QgZHJtX2RldmljZSAqZGV2ID0gY3J0Yy0+ZGV2OwogCXN0cnVjdCBkcm1f aTkxNV9wcml2YXRlICpkZXZfcHJpdiA9IHRvX2k5MTUoZGV2KTsKIAlzdHJ1Y3Qgc2tsX2RkYl9h bGxvY2F0aW9uIGh3X2RkYiwgKnN3X2RkYjsKLQlzdHJ1Y3Qgc2tsX2RkYl9lbnRyeSAqaHdfZW50 cnksICpzd19lbnRyeTsKKwlzdHJ1Y3Qgc2tsX3BpcGVfd20gaHdfd20sICpzd193bTsKKwlzdHJ1 Y3Qgc2tsX3BsYW5lX3dtICpod19wbGFuZV93bSwgKnN3X3BsYW5lX3dtOworCXN0cnVjdCBza2xf ZGRiX2VudHJ5ICpod19kZGJfZW50cnksICpzd19kZGJfZW50cnk7CiAJc3RydWN0IGludGVsX2Ny dGMgKmludGVsX2NydGMgPSB0b19pbnRlbF9jcnRjKGNydGMpOwogCWNvbnN0IGVudW0gcGlwZSBw aXBlID0gaW50ZWxfY3J0Yy0+cGlwZTsKLQlpbnQgcGxhbmU7CisJaW50IHBsYW5lLCBsZXZlbCwg bWF4X2xldmVsID0gaWxrX3dtX21heF9sZXZlbChkZXYpOwogCiAJaWYgKElOVEVMX0lORk8oZGV2 KS0+Z2VuIDwgOSB8fCAhbmV3X3N0YXRlLT5hY3RpdmUpCiAJCXJldHVybjsKIAorCXNrbF9waXBl X3dtX2dldF9od19zdGF0ZShjcnRjLCAmaHdfd20pOworCXN3X3dtID0gJmludGVsX2NydGMtPndt LmFjdGl2ZS5za2w7CisKIAlza2xfZGRiX2dldF9od19zdGF0ZShkZXZfcHJpdiwgJmh3X2RkYik7 CiAJc3dfZGRiID0gJmRldl9wcml2LT53bS5za2xfaHcuZGRiOwogCiAJLyogcGxhbmVzICovCiAJ Zm9yX2VhY2hfcGxhbmUoZGV2X3ByaXYsIHBpcGUsIHBsYW5lKSB7Ci0JCWh3X2VudHJ5ID0gJmh3 X2RkYi5wbGFuZVtwaXBlXVtwbGFuZV07Ci0JCXN3X2VudHJ5ID0gJnN3X2RkYi0+cGxhbmVbcGlw ZV1bcGxhbmVdOworCQlod19wbGFuZV93bSA9ICZod193bS5wbGFuZXNbcGxhbmVdOworCQlzd19w bGFuZV93bSA9ICZzd193bS0+cGxhbmVzW3BsYW5lXTsKIAotCQlpZiAoc2tsX2RkYl9lbnRyeV9l cXVhbChod19lbnRyeSwgc3dfZW50cnkpKQotCQkJY29udGludWU7CisJCS8qIFdhdGVybWFya3Mg Ki8KKwkJZm9yIChsZXZlbCA9IDA7IGxldmVsIDw9IG1heF9sZXZlbDsgbGV2ZWwrKykgeworCQkJ aWYgKHNrbF93bV9sZXZlbF9lcXVhbHMoJmh3X3BsYW5lX3dtLT53bVtsZXZlbF0sCisJCQkJCQkm c3dfcGxhbmVfd20tPndtW2xldmVsXSkpCisJCQkJY29udGludWU7CisKKwkJCURSTV9FUlJPUigi bWlzbWF0Y2ggaW4gV00gcGlwZSAlYyBwbGFuZSAlZCBsZXZlbCAlZCAoZXhwZWN0ZWQgZT0lZCBi PSVkIGw9JWQsIGdvdCBlPSVkIGI9JWQgbD0lZClcbiIsCisJCQkJICBwaXBlX25hbWUocGlwZSks IHBsYW5lICsgMSwgbGV2ZWwsCisJCQkJICBzd19wbGFuZV93bS0+d21bbGV2ZWxdLnBsYW5lX2Vu LAorCQkJCSAgc3dfcGxhbmVfd20tPndtW2xldmVsXS5wbGFuZV9yZXNfYiwKKwkJCQkgIHN3X3Bs YW5lX3dtLT53bVtsZXZlbF0ucGxhbmVfcmVzX2wsCisJCQkJICBod19wbGFuZV93bS0+d21bbGV2 ZWxdLnBsYW5lX2VuLAorCQkJCSAgaHdfcGxhbmVfd20tPndtW2xldmVsXS5wbGFuZV9yZXNfYiwK KwkJCQkgIGh3X3BsYW5lX3dtLT53bVtsZXZlbF0ucGxhbmVfcmVzX2wpOworCQl9CiAKLQkJRFJN X0VSUk9SKCJtaXNtYXRjaCBpbiBEREIgc3RhdGUgcGlwZSAlYyBwbGFuZSAlZCAiCi0JCQkgICIo ZXhwZWN0ZWQgKCV1LCV1KSwgZm91bmQgKCV1LCV1KSlcbiIsCi0JCQkgIHBpcGVfbmFtZShwaXBl KSwgcGxhbmUgKyAxLAotCQkJICBzd19lbnRyeS0+c3RhcnQsIHN3X2VudHJ5LT5lbmQsCi0JCQkg IGh3X2VudHJ5LT5zdGFydCwgaHdfZW50cnktPmVuZCk7CisJCWlmICghc2tsX3dtX2xldmVsX2Vx dWFscygmaHdfcGxhbmVfd20tPnRyYW5zX3dtLAorCQkJCQkgJnN3X3BsYW5lX3dtLT50cmFuc193 bSkpIHsKKwkJCURSTV9FUlJPUigibWlzbWF0Y2ggaW4gdHJhbnMgV00gcGlwZSAlYyBwbGFuZSAl ZCAoZXhwZWN0ZWQgZT0lZCBiPSVkIGw9JWQsIGdvdCBlPSVkIGI9JWQgbD0lZClcbiIsCisJCQkJ ICBwaXBlX25hbWUocGlwZSksIHBsYW5lICsgMSwKKwkJCQkgIHN3X3BsYW5lX3dtLT50cmFuc193 bS5wbGFuZV9lbiwKKwkJCQkgIHN3X3BsYW5lX3dtLT50cmFuc193bS5wbGFuZV9yZXNfYiwKKwkJ CQkgIHN3X3BsYW5lX3dtLT50cmFuc193bS5wbGFuZV9yZXNfbCwKKwkJCQkgIGh3X3BsYW5lX3dt LT50cmFuc193bS5wbGFuZV9lbiwKKwkJCQkgIGh3X3BsYW5lX3dtLT50cmFuc193bS5wbGFuZV9y ZXNfYiwKKwkJCQkgIGh3X3BsYW5lX3dtLT50cmFuc193bS5wbGFuZV9yZXNfbCk7CisJCX0KKwor CQkvKiBEREIgKi8KKwkJaHdfZGRiX2VudHJ5ID0gJmh3X2RkYi5wbGFuZVtwaXBlXVtwbGFuZV07 CisJCXN3X2RkYl9lbnRyeSA9ICZzd19kZGItPnBsYW5lW3BpcGVdW3BsYW5lXTsKKworCQlpZiAo IXNrbF9kZGJfZW50cnlfZXF1YWwoaHdfZGRiX2VudHJ5LCBzd19kZGJfZW50cnkpKSB7CisJCQlE Uk1fRVJST1IoIm1pc21hdGNoIGluIEREQiBzdGF0ZSBwaXBlICVjIHBsYW5lICVkICIKKwkJCQkg ICIoZXhwZWN0ZWQgKCV1LCV1KSwgZm91bmQgKCV1LCV1KSlcbiIsCisJCQkJICBwaXBlX25hbWUo cGlwZSksIHBsYW5lICsgMSwKKwkJCQkgIHN3X2RkYl9lbnRyeS0+c3RhcnQsIHN3X2RkYl9lbnRy eS0+ZW5kLAorCQkJCSAgaHdfZGRiX2VudHJ5LT5zdGFydCwgaHdfZGRiX2VudHJ5LT5lbmQpOwor CQl9CiAJfQogCiAJLyoKQEAgLTEzNDc3LDE1ICsxMzUxMyw0NyBAQCBzdGF0aWMgdm9pZCB2ZXJp Znlfd21fc3RhdGUoc3RydWN0IGRybV9jcnRjICpjcnRjLAogCSAqIG9uY2UgdGhlIHBsYW5lIGJl Y29tZXMgdmlzaWJsZSwgd2UgY2FuIHNraXAgdGhpcyBjaGVjawogCSAqLwogCWlmIChpbnRlbF9j cnRjLT5jdXJzb3JfYWRkcikgewotCQlod19lbnRyeSA9ICZod19kZGIucGxhbmVbcGlwZV1bUExB TkVfQ1VSU09SXTsKLQkJc3dfZW50cnkgPSAmc3dfZGRiLT5wbGFuZVtwaXBlXVtQTEFORV9DVVJT T1JdOworCQlod19wbGFuZV93bSA9ICZod193bS5wbGFuZXNbUExBTkVfQ1VSU09SXTsKKwkJc3df cGxhbmVfd20gPSAmc3dfd20tPnBsYW5lc1tQTEFORV9DVVJTT1JdOworCisJCS8qIFdhdGVybWFy a3MgKi8KKwkJZm9yIChsZXZlbCA9IDA7IGxldmVsIDw9IG1heF9sZXZlbDsgbGV2ZWwrKykgewor CQkJaWYgKHNrbF93bV9sZXZlbF9lcXVhbHMoJmh3X3BsYW5lX3dtLT53bVtsZXZlbF0sCisJCQkJ CQkmc3dfcGxhbmVfd20tPndtW2xldmVsXSkpCisJCQkJY29udGludWU7CisKKwkJCURSTV9FUlJP UigibWlzbWF0Y2ggaW4gV00gcGlwZSAlYyBjdXJzb3IgbGV2ZWwgJWQgKGV4cGVjdGVkIGU9JWQg Yj0lZCBsPSVkLCBnb3QgZT0lZCBiPSVkIGw9JWQpXG4iLAorCQkJCSAgcGlwZV9uYW1lKHBpcGUp LCBsZXZlbCwKKwkJCQkgIHN3X3BsYW5lX3dtLT53bVtsZXZlbF0ucGxhbmVfZW4sCisJCQkJICBz d19wbGFuZV93bS0+d21bbGV2ZWxdLnBsYW5lX3Jlc19iLAorCQkJCSAgc3dfcGxhbmVfd20tPndt W2xldmVsXS5wbGFuZV9yZXNfbCwKKwkJCQkgIGh3X3BsYW5lX3dtLT53bVtsZXZlbF0ucGxhbmVf ZW4sCisJCQkJICBod19wbGFuZV93bS0+d21bbGV2ZWxdLnBsYW5lX3Jlc19iLAorCQkJCSAgaHdf cGxhbmVfd20tPndtW2xldmVsXS5wbGFuZV9yZXNfbCk7CisJCX0KKworCQlpZiAoIXNrbF93bV9s ZXZlbF9lcXVhbHMoJmh3X3BsYW5lX3dtLT50cmFuc193bSwKKwkJCQkJICZzd19wbGFuZV93bS0+ dHJhbnNfd20pKSB7CisJCQlEUk1fRVJST1IoIm1pc21hdGNoIGluIHRyYW5zIFdNIHBpcGUgJWMg Y3Vyc29yIChleHBlY3RlZCBlPSVkIGI9JWQgbD0lZCwgZ290IGU9JWQgYj0lZCBsPSVkKVxuIiwK KwkJCQkgIHBpcGVfbmFtZShwaXBlKSwKKwkJCQkgIHN3X3BsYW5lX3dtLT50cmFuc193bS5wbGFu ZV9lbiwKKwkJCQkgIHN3X3BsYW5lX3dtLT50cmFuc193bS5wbGFuZV9yZXNfYiwKKwkJCQkgIHN3 X3BsYW5lX3dtLT50cmFuc193bS5wbGFuZV9yZXNfbCwKKwkJCQkgIGh3X3BsYW5lX3dtLT50cmFu c193bS5wbGFuZV9lbiwKKwkJCQkgIGh3X3BsYW5lX3dtLT50cmFuc193bS5wbGFuZV9yZXNfYiwK KwkJCQkgIGh3X3BsYW5lX3dtLT50cmFuc193bS5wbGFuZV9yZXNfbCk7CisJCX0KKworCQkvKiBE REIgKi8KKwkJaHdfZGRiX2VudHJ5ID0gJmh3X2RkYi5wbGFuZVtwaXBlXVtQTEFORV9DVVJTT1Jd OworCQlzd19kZGJfZW50cnkgPSAmc3dfZGRiLT5wbGFuZVtwaXBlXVtQTEFORV9DVVJTT1JdOwog Ci0JCWlmICghc2tsX2RkYl9lbnRyeV9lcXVhbChod19lbnRyeSwgc3dfZW50cnkpKSB7CisJCWlm ICghc2tsX2RkYl9lbnRyeV9lcXVhbChod19kZGJfZW50cnksIHN3X2RkYl9lbnRyeSkpIHsKIAkJ CURSTV9FUlJPUigibWlzbWF0Y2ggaW4gRERCIHN0YXRlIHBpcGUgJWMgY3Vyc29yICIKIAkJCQkg ICIoZXhwZWN0ZWQgKCV1LCV1KSwgZm91bmQgKCV1LCV1KSlcbiIsCiAJCQkJICBwaXBlX25hbWUo cGlwZSksCi0JCQkJICBzd19lbnRyeS0+c3RhcnQsIHN3X2VudHJ5LT5lbmQsCi0JCQkJICBod19l bnRyeS0+c3RhcnQsIGh3X2VudHJ5LT5lbmQpOworCQkJCSAgc3dfZGRiX2VudHJ5LT5zdGFydCwg c3dfZGRiX2VudHJ5LT5lbmQsCisJCQkJICBod19kZGJfZW50cnktPnN0YXJ0LCBod19kZGJfZW50 cnktPmVuZCk7CiAJCX0KIAl9CiB9Ci0tIAoyLjcuNAoKX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX18KSW50ZWwtZ2Z4IG1haWxpbmcgbGlzdApJbnRlbC1nZnhA bGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxt YW4vbGlzdGluZm8vaW50ZWwtZ2Z4Cg==