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.0 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_PASS,URIBL_BLOCKED, USER_AGENT_GIT autolearn=ham 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 A695AC282CB for ; Tue, 5 Feb 2019 14:18:51 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 7291120844 for ; Tue, 5 Feb 2019 14:18:51 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727179AbfBEOSu (ORCPT ); Tue, 5 Feb 2019 09:18:50 -0500 Received: from mga06.intel.com ([134.134.136.31]:19716 "EHLO mga06.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726276AbfBEOSu (ORCPT ); Tue, 5 Feb 2019 09:18:50 -0500 X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False Received: from orsmga006.jf.intel.com ([10.7.209.51]) by orsmga104.jf.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 05 Feb 2019 06:18:49 -0800 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.56,564,1539673200"; d="scan'208";a="113858222" Received: from stinkbox.fi.intel.com (HELO stinkbox) ([10.237.72.174]) by orsmga006.jf.intel.com with SMTP; 05 Feb 2019 06:18:47 -0800 Received: by stinkbox (sSMTP sendmail emulation); Tue, 05 Feb 2019 16:18:46 +0200 From: Ville Syrjala To: intel-gfx@lists.freedesktop.org Cc: stable@vger.kernel.org, Daniel Kamil Kozar Subject: [PATCH -fixes] drm/i915: Try to sanitize bogus DPLL state left over by broken SNB BIOSen Date: Tue, 5 Feb 2019 16:18:46 +0200 Message-Id: <20190205141846.6053-1-ville.syrjala@linux.intel.com> X-Mailer: git-send-email 2.19.2 In-Reply-To: <87y36u73o2.fsf@intel.com> References: <87y36u73o2.fsf@intel.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Sender: stable-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: stable@vger.kernel.org From: Ville Syrjälä Certain SNB machines (eg. ASUS K53SV) seem to have a broken BIOS which misprograms the hardware badly when encountering a suitably high resolution display. The programmed pipe timings are somewhat bonkers and the DPLL is totally misprogrammed (P divider == 0). That will result in atomic commit timeouts as apparently the pipe is sufficiently stuck to not signal vblank interrupts. IIRC something like this was also observed on some other SNB machine years ago (might have been a Dell XPS 8300) but a BIOS update cured it. Sadly looks like this was never fixed for the ASUS K53SV as the latest BIOS (K53SV.320 11/11/2011) is still broken. The quickest way to deal with this seems to be to shut down the pipe+ports+DPLL. Unfortunately doing this during the normal sanitization phase isn't quite soon enough as we already spew several WARNs about the bogus hardware state. But it's better than hanging the boot for a few dozen seconds. Since this is limited to a few old machines it doesn't seem entirely worthwile to try and rework the readout+sanitization code to handle it more gracefully. v2: Fix potential NULL deref (kbuild test robot) Constify has_bogus_dpll_config() Cc: stable@vger.kernel.org # v4.20+ Cc: Daniel Kamil Kozar Reported-by: Daniel Kamil Kozar Tested-by: Daniel Kamil Kozar Bugzilla: https://bugs.freedesktop.org/show_bug.cgi?id=109245 Fixes: 516a49cc1946 ("drm/i915: Fix assert_plane() warning on bootup with external display") Signed-off-by: Ville Syrjälä Link: https://patchwork.freedesktop.org/patch/msgid/20190111174950.10681-1-ville.syrjala@linux.intel.com Reviewed-by: Mika Kahola (cherry picked from commit 7bed8adcd9f86231bb69bbc02f88ad89330f99e3) --- drivers/gpu/drm/i915/intel_display.c | 50 ++++++++++++++++++++++++---- 1 file changed, 44 insertions(+), 6 deletions(-) diff --git a/drivers/gpu/drm/i915/intel_display.c b/drivers/gpu/drm/i915/intel_display.c index 3da9c0f9e948..248128126422 100644 --- a/drivers/gpu/drm/i915/intel_display.c +++ b/drivers/gpu/drm/i915/intel_display.c @@ -15415,16 +15415,45 @@ static void intel_sanitize_crtc(struct intel_crtc *crtc, } } +static bool has_bogus_dpll_config(const struct intel_crtc_state *crtc_state) +{ + struct drm_i915_private *dev_priv = to_i915(crtc_state->base.crtc->dev); + + /* + * Some SNB BIOSen (eg. ASUS K53SV) are known to misprogram + * the hardware when a high res displays plugged in. DPLL P + * divider is zero, and the pipe timings are bonkers. We'll + * try to disable everything in that case. + * + * FIXME would be nice to be able to sanitize this state + * without several WARNs, but for now let's take the easy + * road. + */ + return IS_GEN6(dev_priv) && + crtc_state->base.active && + crtc_state->shared_dpll && + crtc_state->port_clock == 0; +} + static void intel_sanitize_encoder(struct intel_encoder *encoder) { struct drm_i915_private *dev_priv = to_i915(encoder->base.dev); struct intel_connector *connector; + struct intel_crtc *crtc = to_intel_crtc(encoder->base.crtc); + struct intel_crtc_state *crtc_state = crtc ? + to_intel_crtc_state(crtc->base.state) : NULL; /* We need to check both for a crtc link (meaning that the * encoder is active and trying to read from a pipe) and the * pipe itself being active. */ - bool has_active_crtc = encoder->base.crtc && - to_intel_crtc(encoder->base.crtc)->active; + bool has_active_crtc = crtc_state && + crtc_state->base.active; + + if (crtc_state && has_bogus_dpll_config(crtc_state)) { + DRM_DEBUG_KMS("BIOS has misprogrammed the hardware. Disabling pipe %c\n", + pipe_name(crtc->pipe)); + has_active_crtc = false; + } connector = intel_encoder_find_connector(encoder); if (connector && !has_active_crtc) { @@ -15435,16 +15464,25 @@ static void intel_sanitize_encoder(struct intel_encoder *encoder) /* Connector is active, but has no active pipe. This is * fallout from our resume register restoring. Disable * the encoder manually again. */ - if (encoder->base.crtc) { - struct drm_crtc_state *crtc_state = encoder->base.crtc->state; + if (crtc_state) { + struct drm_encoder *best_encoder; DRM_DEBUG_KMS("[ENCODER:%d:%s] manually disabled\n", encoder->base.base.id, encoder->base.name); + + /* avoid oopsing in case the hooks consult best_encoder */ + best_encoder = connector->base.state->best_encoder; + connector->base.state->best_encoder = &encoder->base; + if (encoder->disable) - encoder->disable(encoder, to_intel_crtc_state(crtc_state), connector->base.state); + encoder->disable(encoder, crtc_state, + connector->base.state); if (encoder->post_disable) - encoder->post_disable(encoder, to_intel_crtc_state(crtc_state), connector->base.state); + encoder->post_disable(encoder, crtc_state, + connector->base.state); + + connector->base.state->best_encoder = best_encoder; } encoder->base.crtc = NULL; -- 2.19.2 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Ville Syrjala Subject: [PATCH -fixes] drm/i915: Try to sanitize bogus DPLL state left over by broken SNB BIOSen Date: Tue, 5 Feb 2019 16:18:46 +0200 Message-ID: <20190205141846.6053-1-ville.syrjala@linux.intel.com> References: <87y36u73o2.fsf@intel.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mga11.intel.com (mga11.intel.com [192.55.52.93]) by gabe.freedesktop.org (Postfix) with ESMTPS id CECE889CBE for ; Tue, 5 Feb 2019 14:18:50 +0000 (UTC) In-Reply-To: <87y36u73o2.fsf@intel.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: Daniel Kamil Kozar , stable@vger.kernel.org List-Id: intel-gfx@lists.freedesktop.org RnJvbTogVmlsbGUgU3lyasOkbMOkIDx2aWxsZS5zeXJqYWxhQGxpbnV4LmludGVsLmNvbT4KCkNl cnRhaW4gU05CIG1hY2hpbmVzIChlZy4gQVNVUyBLNTNTVikgc2VlbSB0byBoYXZlIGEgYnJva2Vu IEJJT1MKd2hpY2ggbWlzcHJvZ3JhbXMgdGhlIGhhcmR3YXJlIGJhZGx5IHdoZW4gZW5jb3VudGVy aW5nIGEgc3VpdGFibHkKaGlnaCByZXNvbHV0aW9uIGRpc3BsYXkuIFRoZSBwcm9ncmFtbWVkIHBp cGUgdGltaW5ncyBhcmUgc29tZXdoYXQKYm9ua2VycyBhbmQgdGhlIERQTEwgaXMgdG90YWxseSBt aXNwcm9ncmFtbWVkIChQIGRpdmlkZXIgPT0gMCkuClRoYXQgd2lsbCByZXN1bHQgaW4gYXRvbWlj IGNvbW1pdCB0aW1lb3V0cyBhcyBhcHBhcmVudGx5IHRoZSBwaXBlCmlzIHN1ZmZpY2llbnRseSBz dHVjayB0byBub3Qgc2lnbmFsIHZibGFuayBpbnRlcnJ1cHRzLgoKSUlSQyBzb21ldGhpbmcgbGlr ZSB0aGlzIHdhcyBhbHNvIG9ic2VydmVkIG9uIHNvbWUgb3RoZXIgU05CCm1hY2hpbmUgeWVhcnMg YWdvIChtaWdodCBoYXZlIGJlZW4gYSBEZWxsIFhQUyA4MzAwKSBidXQgYSBCSU9TCnVwZGF0ZSBj dXJlZCBpdC4gU2FkbHkgbG9va3MgbGlrZSB0aGlzIHdhcyBuZXZlciBmaXhlZCBmb3IgdGhlCkFT VVMgSzUzU1YgYXMgdGhlIGxhdGVzdCBCSU9TIChLNTNTVi4zMjAgMTEvMTEvMjAxMSkgaXMgc3Rp bGwKYnJva2VuLgoKVGhlIHF1aWNrZXN0IHdheSB0byBkZWFsIHdpdGggdGhpcyBzZWVtcyB0byBi ZSB0byBzaHV0IGRvd24KdGhlIHBpcGUrcG9ydHMrRFBMTC4gVW5mb3J0dW5hdGVseSBkb2luZyB0 aGlzIGR1cmluZyB0aGUKbm9ybWFsIHNhbml0aXphdGlvbiBwaGFzZSBpc24ndCBxdWl0ZSBzb29u IGVub3VnaCBhcyB3ZQphbHJlYWR5IHNwZXcgc2V2ZXJhbCBXQVJOcyBhYm91dCB0aGUgYm9ndXMg aGFyZHdhcmUgc3RhdGUuCkJ1dCBpdCdzIGJldHRlciB0aGFuIGhhbmdpbmcgdGhlIGJvb3QgZm9y IGEgZmV3IGRvemVuIHNlY29uZHMuClNpbmNlIHRoaXMgaXMgbGltaXRlZCB0byBhIGZldyBvbGQg bWFjaGluZXMgaXQgZG9lc24ndCBzZWVtCmVudGlyZWx5IHdvcnRod2lsZSB0byB0cnkgYW5kIHJl d29yayB0aGUgcmVhZG91dCtzYW5pdGl6YXRpb24KY29kZSB0byBoYW5kbGUgaXQgbW9yZSBncmFj ZWZ1bGx5LgoKdjI6IEZpeCBwb3RlbnRpYWwgTlVMTCBkZXJlZiAoa2J1aWxkIHRlc3Qgcm9ib3Qp CiAgICBDb25zdGlmeSBoYXNfYm9ndXNfZHBsbF9jb25maWcoKQoKQ2M6IHN0YWJsZUB2Z2VyLmtl cm5lbC5vcmcgIyB2NC4yMCsKQ2M6IERhbmllbCBLYW1pbCBLb3phciA8ZGtrMDg5QGdtYWlsLmNv bT4KUmVwb3J0ZWQtYnk6IERhbmllbCBLYW1pbCBLb3phciA8ZGtrMDg5QGdtYWlsLmNvbT4KVGVz dGVkLWJ5OiBEYW5pZWwgS2FtaWwgS296YXIgPGRrazA4OUBnbWFpbC5jb20+CkJ1Z3ppbGxhOiBo dHRwczovL2J1Z3MuZnJlZWRlc2t0b3Aub3JnL3Nob3dfYnVnLmNnaT9pZD0xMDkyNDUKRml4ZXM6 IDUxNmE0OWNjMTk0NiAoImRybS9pOTE1OiBGaXggYXNzZXJ0X3BsYW5lKCkgd2FybmluZyBvbiBi b290dXAgd2l0aCBleHRlcm5hbCBkaXNwbGF5IikKU2lnbmVkLW9mZi1ieTogVmlsbGUgU3lyasOk bMOkIDx2aWxsZS5zeXJqYWxhQGxpbnV4LmludGVsLmNvbT4KTGluazogaHR0cHM6Ly9wYXRjaHdv cmsuZnJlZWRlc2t0b3Aub3JnL3BhdGNoL21zZ2lkLzIwMTkwMTExMTc0OTUwLjEwNjgxLTEtdmls bGUuc3lyamFsYUBsaW51eC5pbnRlbC5jb20KUmV2aWV3ZWQtYnk6IE1pa2EgS2Fob2xhIDxtaWth LmthaG9sYUBpbnRlbC5jb20+CihjaGVycnkgcGlja2VkIGZyb20gY29tbWl0IDdiZWQ4YWRjZDlm ODYyMzFiYjY5YmJjMDJmODhhZDg5MzMwZjk5ZTMpCi0tLQogZHJpdmVycy9ncHUvZHJtL2k5MTUv aW50ZWxfZGlzcGxheS5jIHwgNTAgKysrKysrKysrKysrKysrKysrKysrKysrLS0tLQogMSBmaWxl IGNoYW5nZWQsIDQ0IGluc2VydGlvbnMoKyksIDYgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEv ZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZGlzcGxheS5jIGIvZHJpdmVycy9ncHUvZHJtL2k5 MTUvaW50ZWxfZGlzcGxheS5jCmluZGV4IDNkYTljMGY5ZTk0OC4uMjQ4MTI4MTI2NDIyIDEwMDY0 NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kaXNwbGF5LmMKKysrIGIvZHJpdmVy cy9ncHUvZHJtL2k5MTUvaW50ZWxfZGlzcGxheS5jCkBAIC0xNTQxNSwxNiArMTU0MTUsNDUgQEAg c3RhdGljIHZvaWQgaW50ZWxfc2FuaXRpemVfY3J0YyhzdHJ1Y3QgaW50ZWxfY3J0YyAqY3J0YywK IAl9CiB9CiAKK3N0YXRpYyBib29sIGhhc19ib2d1c19kcGxsX2NvbmZpZyhjb25zdCBzdHJ1Y3Qg aW50ZWxfY3J0Y19zdGF0ZSAqY3J0Y19zdGF0ZSkKK3sKKwlzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0 ZSAqZGV2X3ByaXYgPSB0b19pOTE1KGNydGNfc3RhdGUtPmJhc2UuY3J0Yy0+ZGV2KTsKKworCS8q CisJICogU29tZSBTTkIgQklPU2VuIChlZy4gQVNVUyBLNTNTVikgYXJlIGtub3duIHRvIG1pc3By b2dyYW0KKwkgKiB0aGUgaGFyZHdhcmUgd2hlbiBhIGhpZ2ggcmVzIGRpc3BsYXlzIHBsdWdnZWQg aW4uIERQTEwgUAorCSAqIGRpdmlkZXIgaXMgemVybywgYW5kIHRoZSBwaXBlIHRpbWluZ3MgYXJl IGJvbmtlcnMuIFdlJ2xsCisJICogdHJ5IHRvIGRpc2FibGUgZXZlcnl0aGluZyBpbiB0aGF0IGNh c2UuCisJICoKKwkgKiBGSVhNRSB3b3VsZCBiZSBuaWNlIHRvIGJlIGFibGUgdG8gc2FuaXRpemUg dGhpcyBzdGF0ZQorCSAqIHdpdGhvdXQgc2V2ZXJhbCBXQVJOcywgYnV0IGZvciBub3cgbGV0J3Mg dGFrZSB0aGUgZWFzeQorCSAqIHJvYWQuCisJICovCisJcmV0dXJuIElTX0dFTjYoZGV2X3ByaXYp ICYmCisJCWNydGNfc3RhdGUtPmJhc2UuYWN0aXZlICYmCisJCWNydGNfc3RhdGUtPnNoYXJlZF9k cGxsICYmCisJCWNydGNfc3RhdGUtPnBvcnRfY2xvY2sgPT0gMDsKK30KKwogc3RhdGljIHZvaWQg aW50ZWxfc2FuaXRpemVfZW5jb2RlcihzdHJ1Y3QgaW50ZWxfZW5jb2RlciAqZW5jb2RlcikKIHsK IAlzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqZGV2X3ByaXYgPSB0b19pOTE1KGVuY29kZXItPmJh c2UuZGV2KTsKIAlzdHJ1Y3QgaW50ZWxfY29ubmVjdG9yICpjb25uZWN0b3I7CisJc3RydWN0IGlu dGVsX2NydGMgKmNydGMgPSB0b19pbnRlbF9jcnRjKGVuY29kZXItPmJhc2UuY3J0Yyk7CisJc3Ry dWN0IGludGVsX2NydGNfc3RhdGUgKmNydGNfc3RhdGUgPSBjcnRjID8KKwkJdG9faW50ZWxfY3J0 Y19zdGF0ZShjcnRjLT5iYXNlLnN0YXRlKSA6IE5VTEw7CiAKIAkvKiBXZSBuZWVkIHRvIGNoZWNr IGJvdGggZm9yIGEgY3J0YyBsaW5rIChtZWFuaW5nIHRoYXQgdGhlCiAJICogZW5jb2RlciBpcyBh Y3RpdmUgYW5kIHRyeWluZyB0byByZWFkIGZyb20gYSBwaXBlKSBhbmQgdGhlCiAJICogcGlwZSBp dHNlbGYgYmVpbmcgYWN0aXZlLiAqLwotCWJvb2wgaGFzX2FjdGl2ZV9jcnRjID0gZW5jb2Rlci0+ YmFzZS5jcnRjICYmCi0JCXRvX2ludGVsX2NydGMoZW5jb2Rlci0+YmFzZS5jcnRjKS0+YWN0aXZl OworCWJvb2wgaGFzX2FjdGl2ZV9jcnRjID0gY3J0Y19zdGF0ZSAmJgorCQljcnRjX3N0YXRlLT5i YXNlLmFjdGl2ZTsKKworCWlmIChjcnRjX3N0YXRlICYmIGhhc19ib2d1c19kcGxsX2NvbmZpZyhj cnRjX3N0YXRlKSkgeworCQlEUk1fREVCVUdfS01TKCJCSU9TIGhhcyBtaXNwcm9ncmFtbWVkIHRo ZSBoYXJkd2FyZS4gRGlzYWJsaW5nIHBpcGUgJWNcbiIsCisJCQkgICAgICBwaXBlX25hbWUoY3J0 Yy0+cGlwZSkpOworCQloYXNfYWN0aXZlX2NydGMgPSBmYWxzZTsKKwl9CiAKIAljb25uZWN0b3Ig PSBpbnRlbF9lbmNvZGVyX2ZpbmRfY29ubmVjdG9yKGVuY29kZXIpOwogCWlmIChjb25uZWN0b3Ig JiYgIWhhc19hY3RpdmVfY3J0YykgewpAQCAtMTU0MzUsMTYgKzE1NDY0LDI1IEBAIHN0YXRpYyB2 b2lkIGludGVsX3Nhbml0aXplX2VuY29kZXIoc3RydWN0IGludGVsX2VuY29kZXIgKmVuY29kZXIp CiAJCS8qIENvbm5lY3RvciBpcyBhY3RpdmUsIGJ1dCBoYXMgbm8gYWN0aXZlIHBpcGUuIFRoaXMg aXMKIAkJICogZmFsbG91dCBmcm9tIG91ciByZXN1bWUgcmVnaXN0ZXIgcmVzdG9yaW5nLiBEaXNh YmxlCiAJCSAqIHRoZSBlbmNvZGVyIG1hbnVhbGx5IGFnYWluLiAqLwotCQlpZiAoZW5jb2Rlci0+ YmFzZS5jcnRjKSB7Ci0JCQlzdHJ1Y3QgZHJtX2NydGNfc3RhdGUgKmNydGNfc3RhdGUgPSBlbmNv ZGVyLT5iYXNlLmNydGMtPnN0YXRlOworCQlpZiAoY3J0Y19zdGF0ZSkgeworCQkJc3RydWN0IGRy bV9lbmNvZGVyICpiZXN0X2VuY29kZXI7CiAKIAkJCURSTV9ERUJVR19LTVMoIltFTkNPREVSOiVk OiVzXSBtYW51YWxseSBkaXNhYmxlZFxuIiwKIAkJCQkgICAgICBlbmNvZGVyLT5iYXNlLmJhc2Uu aWQsCiAJCQkJICAgICAgZW5jb2Rlci0+YmFzZS5uYW1lKTsKKworCQkJLyogYXZvaWQgb29wc2lu ZyBpbiBjYXNlIHRoZSBob29rcyBjb25zdWx0IGJlc3RfZW5jb2RlciAqLworCQkJYmVzdF9lbmNv ZGVyID0gY29ubmVjdG9yLT5iYXNlLnN0YXRlLT5iZXN0X2VuY29kZXI7CisJCQljb25uZWN0b3It PmJhc2Uuc3RhdGUtPmJlc3RfZW5jb2RlciA9ICZlbmNvZGVyLT5iYXNlOworCiAJCQlpZiAoZW5j b2Rlci0+ZGlzYWJsZSkKLQkJCQllbmNvZGVyLT5kaXNhYmxlKGVuY29kZXIsIHRvX2ludGVsX2Ny dGNfc3RhdGUoY3J0Y19zdGF0ZSksIGNvbm5lY3Rvci0+YmFzZS5zdGF0ZSk7CisJCQkJZW5jb2Rl ci0+ZGlzYWJsZShlbmNvZGVyLCBjcnRjX3N0YXRlLAorCQkJCQkJIGNvbm5lY3Rvci0+YmFzZS5z dGF0ZSk7CiAJCQlpZiAoZW5jb2Rlci0+cG9zdF9kaXNhYmxlKQotCQkJCWVuY29kZXItPnBvc3Rf ZGlzYWJsZShlbmNvZGVyLCB0b19pbnRlbF9jcnRjX3N0YXRlKGNydGNfc3RhdGUpLCBjb25uZWN0 b3ItPmJhc2Uuc3RhdGUpOworCQkJCWVuY29kZXItPnBvc3RfZGlzYWJsZShlbmNvZGVyLCBjcnRj X3N0YXRlLAorCQkJCQkJICAgICAgY29ubmVjdG9yLT5iYXNlLnN0YXRlKTsKKworCQkJY29ubmVj dG9yLT5iYXNlLnN0YXRlLT5iZXN0X2VuY29kZXIgPSBiZXN0X2VuY29kZXI7CiAJCX0KIAkJZW5j b2Rlci0+YmFzZS5jcnRjID0gTlVMTDsKIAotLSAKMi4xOS4yCgpfX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fXwpJbnRlbC1nZnggbWFpbGluZyBsaXN0CkludGVs LWdmeEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcv bWFpbG1hbi9saXN0aW5mby9pbnRlbC1nZngK