From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1753428AbcHQT4N (ORCPT ); Wed, 17 Aug 2016 15:56:13 -0400 Received: from mx1.redhat.com ([209.132.183.28]:52710 "EHLO mx1.redhat.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1752435AbcHQT4L (ORCPT ); Wed, 17 Aug 2016 15:56:11 -0400 From: Lyude To: intel-gfx@lists.freedesktop.org, =?UTF-8?q?Ville=20Syrj=C3=A4l=C3=A4?= , Maarten Lankhorst , Matt Roper Cc: Lyude , Daniel Vetter , stable@vger.kernel.org, Daniel Vetter , Jani Nikula , David Airlie , dri-devel@lists.freedesktop.org, linux-kernel@vger.kernel.org Subject: [PATCH v12 2/7] drm/i915/skl: Add support for the SAGV, fix underrun hangs Date: Wed, 17 Aug 2016 15:55:54 -0400 Message-Id: <1471463761-26796-3-git-send-email-cpaul@redhat.com> In-Reply-To: <1471463761-26796-1-git-send-email-cpaul@redhat.com> References: <1471463761-26796-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.32]); Wed, 17 Aug 2016 19:56:10 +0000 (UTC) Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Since the watermark calculations for Skylake are still broken, we're apt to hitting underruns very easily under multi-monitor configurations. While it would be lovely if this was fixed, it's not. Another problem that's been coming from this however, is the mysterious issue of underruns causing full system hangs. An easy way to reproduce this with a skylake system: - Get a laptop with a skylake GPU, and hook up two external monitors to it - Move the cursor from the built-in LCD to one of the external displays as quickly as you can - You'll get a few pipe underruns, and eventually the entire system will just freeze. After doing a lot of investigation and reading through the bspec, I found the existence of the SAGV, which is responsible for adjusting the system agent voltage and clock frequencies depending on how much power we need. According to the bspec: "The display engine access to system memory is blocked during the adjustment time. SAGV defaults to enabled. Software must use the GT-driver pcode mailbox to disable SAGV when the display engine is not able to tolerate the blocking time." The rest of the bspec goes on to explain that software can simply leave the SAGV enabled, and disable it when we use interlaced pipes/have more then one pipe active. Sure enough, with this patchset the system hangs resulting from pipe underruns on Skylake have completely vanished on my T460s. Additionally, the bspec mentions turning off the SAGV with more then one pipe enabled as a workaround for display underruns. While this patch doesn't entirely fix that, it looks like it does improve the situation a little bit so it's likely this is going to be required to make watermarks on Skylake fully functional. This will still need additional work in the future: we shouldn't be enabling the SAGV if any of the currently enabled planes can't enable WM levels that introduce latencies >= 30 µs. Changes since v11: - Add skl_can_enable_sagv() - Make sure we don't enable SAGV when not all planes can enable watermarks >= the SAGV engine block time. I was originally going to save this for later, but I recently managed to run into a machine that was having problems with a single pipe configuration + SAGV. - Make comparisons to I915_SKL_SAGV_NOT_CONTROLLED explicit - Change I915_SAGV_DYNAMIC_FREQ to I915_SAGV_ENABLE - Move printks outside of mutexes - Don't print error messages twice Changes since v10: - Apparently sandybridge_pcode_read actually writes values and reads them back, despite it's misleading function name. This means we've been doing this mostly wrong and have been writing garbage to the SAGV control. Because of this, we no longer attempt to read the SAGV status during initialization (since there are no helpers for this). - mlankhorst noticed that this patch was breaking on some very early pre-release Skylake machines, which apparently don't allow you to disable the SAGV. To prevent machines from failing tests due to SAGV errors, if the first time we try to control the SAGV results in the mailbox indicating an invalid command, we just disable future attempts to control the SAGV state by setting dev_priv->skl_sagv_status to I915_SKL_SAGV_NOT_CONTROLLED and make a note of it in dmesg. - Move mutex_unlock() a little higher in skl_enable_sagv(). This doesn't actually fix anything, but lets us release the lock a little sooner since we're finished with it. Changes since v9: - Only enable/disable sagv on Skylake Changes since v8: - Add intel_state->modeset guard to the conditional for skl_enable_sagv() Changes since v7: - Remove GEN9_SAGV_LOW_FREQ, replace with GEN9_SAGV_IS_ENABLED (that's all we use it for anyway) - Use GEN9_SAGV_IS_ENABLED instead of 0x1 for clarification - Fix a styling error that snuck past me Changes since v6: - Protect skl_enable_sagv() with intel_state->modeset conditional in intel_atomic_commit_tail() Changes since v5: - Don't use is_power_of_2. Makes things confusing - Don't use the old state to figure out whether or not to enable/disable the sagv, use the new one - Split the loop in skl_disable_sagv into it's own function - Move skl_sagv_enable/disable() calls into intel_atomic_commit_tail() Changes since v4: - Use is_power_of_2 against active_crtcs to check whether we have > 1 pipe enabled - Fix skl_sagv_get_hw_state(): (temp & 0x1) indicates disabled, 0x0 enabled - Call skl_sagv_enable/disable() from pre/post-plane updates Changes since v3: - Use time_before() to compare timeout to jiffies Changes since v2: - Really apply minor style nitpicks to patch this time Changes since v1: - Added comments about this probably being one of the requirements to fixing Skylake's watermark issues - Minor style nitpicks from Matt Roper - Disable these functions on Broxton, since it doesn't have an SAGV Signed-off-by: Lyude Cc: Matt Roper Cc: Maarten Lankhorst Cc: Daniel Vetter Cc: Ville Syrjälä Cc: stable@vger.kernel.org --- drivers/gpu/drm/i915/i915_drv.h | 7 ++ drivers/gpu/drm/i915/i915_reg.h | 4 + drivers/gpu/drm/i915/intel_display.c | 11 +++ drivers/gpu/drm/i915/intel_drv.h | 3 + drivers/gpu/drm/i915/intel_pm.c | 148 +++++++++++++++++++++++++++++++++++ 5 files changed, 173 insertions(+) diff --git a/drivers/gpu/drm/i915/i915_drv.h b/drivers/gpu/drm/i915/i915_drv.h index 35caa9b..f20530bb 100644 --- a/drivers/gpu/drm/i915/i915_drv.h +++ b/drivers/gpu/drm/i915/i915_drv.h @@ -1949,6 +1949,13 @@ struct drm_i915_private { struct i915_suspend_saved_registers regfile; struct vlv_s0ix_state vlv_s0ix_state; + enum { + I915_SKL_SAGV_UNKNOWN = 0, + I915_SKL_SAGV_DISABLED, + I915_SKL_SAGV_ENABLED, + I915_SKL_SAGV_NOT_CONTROLLED + } skl_sagv_status; + struct { /* * Raw watermark latency values: diff --git a/drivers/gpu/drm/i915/i915_reg.h b/drivers/gpu/drm/i915/i915_reg.h index 7419fbf..be82c49 100644 --- a/drivers/gpu/drm/i915/i915_reg.h +++ b/drivers/gpu/drm/i915/i915_reg.h @@ -7153,6 +7153,10 @@ enum { #define HSW_PCODE_DE_WRITE_FREQ_REQ 0x17 #define DISPLAY_IPS_CONTROL 0x19 #define HSW_PCODE_DYNAMIC_DUTY_CYCLE_CONTROL 0x1A +#define GEN9_PCODE_SAGV_CONTROL 0x21 +#define GEN9_SAGV_DISABLE 0x0 +#define GEN9_SAGV_IS_DISABLED 0x1 +#define GEN9_SAGV_ENABLE 0x3 #define GEN6_PCODE_DATA _MMIO(0x138128) #define GEN6_PCODE_FREQ_IA_RATIO_SHIFT 8 #define GEN6_PCODE_FREQ_RING_RATIO_SHIFT 16 diff --git a/drivers/gpu/drm/i915/intel_display.c b/drivers/gpu/drm/i915/intel_display.c index 781d22e..ca4b83f 100644 --- a/drivers/gpu/drm/i915/intel_display.c +++ b/drivers/gpu/drm/i915/intel_display.c @@ -14156,6 +14156,13 @@ static void intel_atomic_commit_tail(struct drm_atomic_state *state) intel_state->cdclk_pll_vco != dev_priv->cdclk_pll.vco)) dev_priv->display.modeset_commit_cdclk(state); + /* + * SKL workaround: bspec recommends we disable the SAGV when we + * have more then one pipe enabled + */ + if (IS_SKYLAKE(dev_priv) && !skl_can_enable_sagv(state)) + skl_disable_sagv(dev_priv); + intel_modeset_verify_disabled(dev); } @@ -14229,6 +14236,10 @@ static void intel_atomic_commit_tail(struct drm_atomic_state *state) intel_modeset_verify_crtc(crtc, old_crtc_state, crtc->state); } + if (IS_SKYLAKE(dev_priv) && intel_state->modeset && + skl_can_enable_sagv(state)) + skl_enable_sagv(dev_priv); + drm_atomic_helper_commit_hw_done(state); if (intel_state->modeset) diff --git a/drivers/gpu/drm/i915/intel_drv.h b/drivers/gpu/drm/i915/intel_drv.h index 1c700b0..d203c77 100644 --- a/drivers/gpu/drm/i915/intel_drv.h +++ b/drivers/gpu/drm/i915/intel_drv.h @@ -1722,6 +1722,9 @@ void ilk_wm_get_hw_state(struct drm_device *dev); void skl_wm_get_hw_state(struct drm_device *dev); void skl_ddb_get_hw_state(struct drm_i915_private *dev_priv, struct skl_ddb_allocation *ddb /* out */); +bool skl_can_enable_sagv(struct drm_atomic_state *state); +int skl_enable_sagv(struct drm_i915_private *dev_priv); +int skl_disable_sagv(struct drm_i915_private *dev_priv); uint32_t ilk_pipe_pixel_rate(const struct intel_crtc_state *pipe_config); bool ilk_disable_lp_wm(struct drm_device *dev); int sanitize_rc6_option(struct drm_i915_private *dev_priv, int enable_rc6); diff --git a/drivers/gpu/drm/i915/intel_pm.c b/drivers/gpu/drm/i915/intel_pm.c index b4cf988..fed2bae8 100644 --- a/drivers/gpu/drm/i915/intel_pm.c +++ b/drivers/gpu/drm/i915/intel_pm.c @@ -2860,6 +2860,7 @@ bool ilk_disable_lp_wm(struct drm_device *dev) #define SKL_DDB_SIZE 896 /* in blocks */ #define BXT_DDB_SIZE 512 +#define SKL_SAGV_BLOCK_TIME 30 /* µs */ /* * Return the index of a plane in the SKL DDB and wm result arrays. Primary @@ -2883,6 +2884,153 @@ skl_wm_plane_id(const struct intel_plane *plane) } } +/* + * SAGV dynamically adjusts the system agent voltage and clock frequencies + * depending on power and performance requirements. The display engine access + * to system memory is blocked during the adjustment time. Because of the + * blocking time, having this enabled can cause full system hangs and/or pipe + * underruns if we don't meet all of the following requirements: + * + * - <= 1 pipe enabled + * - All planes can enable watermarks for latencies >= SAGV engine block time + * - We're not using an interlaced display configuration + */ +int +skl_enable_sagv(struct drm_i915_private *dev_priv) +{ + int ret; + + if (dev_priv->skl_sagv_status == I915_SKL_SAGV_NOT_CONTROLLED || + dev_priv->skl_sagv_status == I915_SKL_SAGV_ENABLED) + return 0; + + DRM_DEBUG_KMS("Enabling the SAGV\n"); + mutex_lock(&dev_priv->rps.hw_lock); + + ret = sandybridge_pcode_write(dev_priv, GEN9_PCODE_SAGV_CONTROL, + GEN9_SAGV_ENABLE); + + /* We don't need to wait for the SAGV when enabling */ + mutex_unlock(&dev_priv->rps.hw_lock); + + /* + * Some skl systems, pre-release machines in particular, + * don't actually have an SAGV. + */ + if (ret == -ENOSYS) { + DRM_DEBUG_DRIVER("No SAGV found on system, ignoring\n"); + dev_priv->skl_sagv_status = I915_SKL_SAGV_NOT_CONTROLLED; + return 0; + } else if (ret < 0) { + DRM_ERROR("Failed to enable the SAGV\n"); + return ret; + } + + dev_priv->skl_sagv_status = I915_SKL_SAGV_ENABLED; + return 0; +} + +static int +skl_do_sagv_disable(struct drm_i915_private *dev_priv) +{ + int ret; + uint32_t temp = GEN9_SAGV_DISABLE; + + ret = sandybridge_pcode_read(dev_priv, GEN9_PCODE_SAGV_CONTROL, + &temp); + if (ret) + return ret; + else + return temp & GEN9_SAGV_IS_DISABLED; +} + +int +skl_disable_sagv(struct drm_i915_private *dev_priv) +{ + int ret, result; + + if (dev_priv->skl_sagv_status == I915_SKL_SAGV_NOT_CONTROLLED || + dev_priv->skl_sagv_status == I915_SKL_SAGV_DISABLED) + return 0; + + DRM_DEBUG_KMS("Disabling the SAGV\n"); + mutex_lock(&dev_priv->rps.hw_lock); + + /* bspec says to keep retrying for at least 1 ms */ + ret = wait_for(result = skl_do_sagv_disable(dev_priv), 1); + mutex_unlock(&dev_priv->rps.hw_lock); + + if (ret == -ETIMEDOUT) { + DRM_ERROR("Request to disable SAGV timed out\n"); + return -ETIMEDOUT; + } + + /* + * Some skl systems, pre-release machines in particular, + * don't actually have an SAGV. + */ + if (result == -ENOSYS) { + DRM_DEBUG_DRIVER("No SAGV found on system, ignoring\n"); + dev_priv->skl_sagv_status = I915_SKL_SAGV_NOT_CONTROLLED; + return 0; + } else if (result < 0) { + DRM_ERROR("Failed to disable the SAGV\n"); + return result; + } + + dev_priv->skl_sagv_status = I915_SKL_SAGV_DISABLED; + return 0; +} + +bool skl_can_enable_sagv(struct drm_atomic_state *state) +{ + struct drm_device *dev = state->dev; + struct drm_i915_private *dev_priv = to_i915(dev); + struct intel_atomic_state *intel_state = to_intel_atomic_state(state); + struct drm_crtc *crtc; + enum pipe pipe; + int level, plane; + + /* + * SKL workaround: bspec recommends we disable the SAGV when we have + * more then one pipe enabled + * + * If there are no active CRTCs, no additional checks need be performed + */ + if (hweight32(intel_state->active_crtcs) == 0) + return true; + else if (hweight32(intel_state->active_crtcs) > 1) + return false; + + /* Since we're now guaranteed to only have one active CRTC... */ + pipe = ffs(intel_state->active_crtcs) - 1; + crtc = dev_priv->pipe_to_crtc_mapping[pipe]; + + if (crtc->state->mode.flags & DRM_MODE_FLAG_INTERLACE) + return false; + + for_each_plane(dev_priv, pipe, plane) { + /* Skip this plane if it's not enabled */ + if (intel_state->wm_results.plane[pipe][plane][0] == 0) + continue; + + /* Find the highest enabled wm level for this plane */ + for (level = ilk_wm_max_level(dev); + intel_state->wm_results.plane[pipe][plane][level] == 0; + --level); + + /* + * If any of the planes on this pipe don't enable wm levels + * that incur memory latencies higher then 30µs we can't enable + * the SAGV + */ + if (dev_priv->wm.skl_latency[level] < SKL_SAGV_BLOCK_TIME) + return false; + } + + return true; +} + static void skl_ddb_get_pipe_allocation_limits(struct drm_device *dev, const struct intel_crtc_state *cstate, -- 2.7.4 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Lyude Subject: [PATCH v12 2/7] drm/i915/skl: Add support for the SAGV, fix underrun hangs Date: Wed, 17 Aug 2016 15:55:54 -0400 Message-ID: <1471463761-26796-3-git-send-email-cpaul@redhat.com> References: <1471463761-26796-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: <1471463761-26796-1-git-send-email-cpaul@redhat.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" To: intel-gfx@lists.freedesktop.org, =?UTF-8?q?Ville=20Syrj=C3=A4l=C3=A4?= , Maarten Lankhorst , Matt Roper Cc: Daniel Vetter , dri-devel@lists.freedesktop.org, linux-kernel@vger.kernel.org, stable@vger.kernel.org, Daniel Vetter , Lyude List-Id: dri-devel@lists.freedesktop.org U2luY2UgdGhlIHdhdGVybWFyayBjYWxjdWxhdGlvbnMgZm9yIFNreWxha2UgYXJlIHN0aWxsIGJy b2tlbiwgd2UncmUgYXB0CnRvIGhpdHRpbmcgdW5kZXJydW5zIHZlcnkgZWFzaWx5IHVuZGVyIG11 bHRpLW1vbml0b3IgY29uZmlndXJhdGlvbnMuCldoaWxlIGl0IHdvdWxkIGJlIGxvdmVseSBpZiB0 aGlzIHdhcyBmaXhlZCwgaXQncyBub3QuIEFub3RoZXIgcHJvYmxlbQp0aGF0J3MgYmVlbiBjb21p bmcgZnJvbSB0aGlzIGhvd2V2ZXIsIGlzIHRoZSBteXN0ZXJpb3VzIGlzc3VlIG9mCnVuZGVycnVu cyBjYXVzaW5nIGZ1bGwgc3lzdGVtIGhhbmdzLiBBbiBlYXN5IHdheSB0byByZXByb2R1Y2UgdGhp cyB3aXRoCmEgc2t5bGFrZSBzeXN0ZW06CgotIEdldCBhIGxhcHRvcCB3aXRoIGEgc2t5bGFrZSBH UFUsIGFuZCBob29rIHVwIHR3byBleHRlcm5hbCBtb25pdG9ycyB0bwogIGl0Ci0gTW92ZSB0aGUg Y3Vyc29yIGZyb20gdGhlIGJ1aWx0LWluIExDRCB0byBvbmUgb2YgdGhlIGV4dGVybmFsIGRpc3Bs YXlzCiAgYXMgcXVpY2tseSBhcyB5b3UgY2FuCi0gWW91J2xsIGdldCBhIGZldyBwaXBlIHVuZGVy cnVucywgYW5kIGV2ZW50dWFsbHkgdGhlIGVudGlyZSBzeXN0ZW0gd2lsbAogIGp1c3QgZnJlZXpl LgoKQWZ0ZXIgZG9pbmcgYSBsb3Qgb2YgaW52ZXN0aWdhdGlvbiBhbmQgcmVhZGluZyB0aHJvdWdo IHRoZSBic3BlYywgSQpmb3VuZCB0aGUgZXhpc3RlbmNlIG9mIHRoZSBTQUdWLCB3aGljaCBpcyBy ZXNwb25zaWJsZSBmb3IgYWRqdXN0aW5nIHRoZQpzeXN0ZW0gYWdlbnQgdm9sdGFnZSBhbmQgY2xv Y2sgZnJlcXVlbmNpZXMgZGVwZW5kaW5nIG9uIGhvdyBtdWNoIHBvd2VyCndlIG5lZWQuIEFjY29y ZGluZyB0byB0aGUgYnNwZWM6CgoiVGhlIGRpc3BsYXkgZW5naW5lIGFjY2VzcyB0byBzeXN0ZW0g bWVtb3J5IGlzIGJsb2NrZWQgZHVyaW5nIHRoZQogYWRqdXN0bWVudCB0aW1lLiBTQUdWIGRlZmF1 bHRzIHRvIGVuYWJsZWQuIFNvZnR3YXJlIG11c3QgdXNlIHRoZQogR1QtZHJpdmVyIHBjb2RlIG1h aWxib3ggdG8gZGlzYWJsZSBTQUdWIHdoZW4gdGhlIGRpc3BsYXkgZW5naW5lIGlzIG5vdAogYWJs ZSB0byB0b2xlcmF0ZSB0aGUgYmxvY2tpbmcgdGltZS4iCgpUaGUgcmVzdCBvZiB0aGUgYnNwZWMg Z29lcyBvbiB0byBleHBsYWluIHRoYXQgc29mdHdhcmUgY2FuIHNpbXBseSBsZWF2ZQp0aGUgU0FH ViBlbmFibGVkLCBhbmQgZGlzYWJsZSBpdCB3aGVuIHdlIHVzZSBpbnRlcmxhY2VkIHBpcGVzL2hh dmUgbW9yZQp0aGVuIG9uZSBwaXBlIGFjdGl2ZS4KClN1cmUgZW5vdWdoLCB3aXRoIHRoaXMgcGF0 Y2hzZXQgdGhlIHN5c3RlbSBoYW5ncyByZXN1bHRpbmcgZnJvbSBwaXBlCnVuZGVycnVucyBvbiBT a3lsYWtlIGhhdmUgY29tcGxldGVseSB2YW5pc2hlZCBvbiBteSBUNDYwcy4gQWRkaXRpb25hbGx5 LAp0aGUgYnNwZWMgbWVudGlvbnMgdHVybmluZyBvZmYgdGhlIFNBR1YJd2l0aCBtb3JlIHRoZW4g b25lIHBpcGUgZW5hYmxlZAphcyBhIHdvcmthcm91bmQgZm9yIGRpc3BsYXkgdW5kZXJydW5zLiBX aGlsZSB0aGlzIHBhdGNoIGRvZXNuJ3QgZW50aXJlbHkKZml4IHRoYXQsIGl0IGxvb2tzIGxpa2Ug aXQgZG9lcyBpbXByb3ZlIHRoZSBzaXR1YXRpb24gYSBsaXR0bGUgYml0IHNvCml0J3MgbGlrZWx5 IHRoaXMgaXMgZ29pbmcgdG8gYmUgcmVxdWlyZWQgdG8gbWFrZSB3YXRlcm1hcmtzIG9uIFNreWxh a2UKZnVsbHkgZnVuY3Rpb25hbC4KClRoaXMgd2lsbCBzdGlsbCBuZWVkIGFkZGl0aW9uYWwgd29y ayBpbiB0aGUgZnV0dXJlOiB3ZSBzaG91bGRuJ3QgYmUKZW5hYmxpbmcgdGhlIFNBR1YgaWYgYW55 IG9mIHRoZSBjdXJyZW50bHkgZW5hYmxlZCBwbGFuZXMgY2FuJ3QgZW5hYmxlIFdNCmxldmVscyB0 aGF0IGludHJvZHVjZSBsYXRlbmNpZXMgPj0gMzAgwrVzLgoKQ2hhbmdlcyBzaW5jZSB2MTE6CiAt IEFkZCBza2xfY2FuX2VuYWJsZV9zYWd2KCkKIC0gTWFrZSBzdXJlIHdlIGRvbid0IGVuYWJsZSBT QUdWIHdoZW4gbm90IGFsbCBwbGFuZXMgY2FuIGVuYWJsZQogICB3YXRlcm1hcmtzID49IHRoZSBT QUdWIGVuZ2luZSBibG9jayB0aW1lLiBJIHdhcyBvcmlnaW5hbGx5IGdvaW5nIHRvCiAgIHNhdmUg dGhpcyBmb3IgbGF0ZXIsIGJ1dCBJIHJlY2VudGx5IG1hbmFnZWQgdG8gcnVuIGludG8gYSBtYWNo aW5lCiAgIHRoYXQgd2FzIGhhdmluZyBwcm9ibGVtcyB3aXRoIGEgc2luZ2xlIHBpcGUgY29uZmln dXJhdGlvbiArIFNBR1YuCiAtIE1ha2UgY29tcGFyaXNvbnMgdG8gSTkxNV9TS0xfU0FHVl9OT1Rf Q09OVFJPTExFRCBleHBsaWNpdAogLSBDaGFuZ2UgSTkxNV9TQUdWX0RZTkFNSUNfRlJFUSB0byBJ OTE1X1NBR1ZfRU5BQkxFCiAtIE1vdmUgcHJpbnRrcyBvdXRzaWRlIG9mIG11dGV4ZXMKIC0gRG9u J3QgcHJpbnQgZXJyb3IgbWVzc2FnZXMgdHdpY2UKQ2hhbmdlcyBzaW5jZSB2MTA6CiAtIEFwcGFy ZW50bHkgc2FuZHlicmlkZ2VfcGNvZGVfcmVhZCBhY3R1YWxseSB3cml0ZXMgdmFsdWVzIGFuZCBy ZWFkcwogICB0aGVtIGJhY2ssIGRlc3BpdGUgaXQncyBtaXNsZWFkaW5nIGZ1bmN0aW9uIG5hbWUu IFRoaXMgbWVhbnMgd2UndmUKICAgYmVlbiBkb2luZyB0aGlzIG1vc3RseSB3cm9uZyBhbmQgaGF2 ZSBiZWVuIHdyaXRpbmcgZ2FyYmFnZSB0byB0aGUKICAgU0FHViBjb250cm9sLiBCZWNhdXNlIG9m IHRoaXMsIHdlIG5vIGxvbmdlciBhdHRlbXB0IHRvIHJlYWQgdGhlIFNBR1YKICAgc3RhdHVzIGR1 cmluZyBpbml0aWFsaXphdGlvbiAoc2luY2UgdGhlcmUgYXJlIG5vIGhlbHBlcnMgZm9yIHRoaXMp LgogLSBtbGFua2hvcnN0IG5vdGljZWQgdGhhdCB0aGlzIHBhdGNoIHdhcyBicmVha2luZyBvbiBz b21lIHZlcnkgZWFybHkKICAgcHJlLXJlbGVhc2UgU2t5bGFrZSBtYWNoaW5lcywgd2hpY2ggYXBw YXJlbnRseSBkb24ndCBhbGxvdyB5b3UgdG8KICAgZGlzYWJsZSB0aGUgU0FHVi4gVG8gcHJldmVu dCBtYWNoaW5lcyBmcm9tIGZhaWxpbmcgdGVzdHMgZHVlIHRvIFNBR1YKICAgZXJyb3JzLCBpZiB0 aGUgZmlyc3QgdGltZSB3ZSB0cnkgdG8gY29udHJvbCB0aGUgU0FHViByZXN1bHRzIGluIHRoZQog ICBtYWlsYm94IGluZGljYXRpbmcgYW4gaW52YWxpZCBjb21tYW5kLCB3ZSBqdXN0IGRpc2FibGUg ZnV0dXJlIGF0dGVtcHRzCiAgIHRvIGNvbnRyb2wgdGhlIFNBR1Ygc3RhdGUgYnkgc2V0dGluZyBk ZXZfcHJpdi0+c2tsX3NhZ3Zfc3RhdHVzIHRvCiAgIEk5MTVfU0tMX1NBR1ZfTk9UX0NPTlRST0xM RUQgYW5kIG1ha2UgYSBub3RlIG9mIGl0IGluIGRtZXNnLgogLSBNb3ZlIG11dGV4X3VubG9jaygp IGEgbGl0dGxlIGhpZ2hlciBpbiBza2xfZW5hYmxlX3NhZ3YoKS4gVGhpcwogICBkb2Vzbid0IGFj dHVhbGx5IGZpeCBhbnl0aGluZywgYnV0IGxldHMgdXMgcmVsZWFzZSB0aGUgbG9jayBhIGxpdHRs ZQogICBzb29uZXIgc2luY2Ugd2UncmUgZmluaXNoZWQgd2l0aCBpdC4KQ2hhbmdlcyBzaW5jZSB2 OToKIC0gT25seSBlbmFibGUvZGlzYWJsZSBzYWd2IG9uIFNreWxha2UKQ2hhbmdlcyBzaW5jZSB2 ODoKIC0gQWRkIGludGVsX3N0YXRlLT5tb2Rlc2V0IGd1YXJkIHRvIHRoZSBjb25kaXRpb25hbCBm b3IKICAgc2tsX2VuYWJsZV9zYWd2KCkKQ2hhbmdlcyBzaW5jZSB2NzoKIC0gUmVtb3ZlIEdFTjlf U0FHVl9MT1dfRlJFUSwgcmVwbGFjZSB3aXRoIEdFTjlfU0FHVl9JU19FTkFCTEVEICh0aGF0J3MK ICAgYWxsIHdlIHVzZSBpdCBmb3IgYW55d2F5KQogLSBVc2UgR0VOOV9TQUdWX0lTX0VOQUJMRUQg aW5zdGVhZCBvZiAweDEgZm9yIGNsYXJpZmljYXRpb24KIC0gRml4IGEgc3R5bGluZyBlcnJvciB0 aGF0IHNudWNrIHBhc3QgbWUKQ2hhbmdlcyBzaW5jZSB2NjoKIC0gUHJvdGVjdCBza2xfZW5hYmxl X3NhZ3YoKSB3aXRoIGludGVsX3N0YXRlLT5tb2Rlc2V0IGNvbmRpdGlvbmFsIGluCiAgIGludGVs X2F0b21pY19jb21taXRfdGFpbCgpCkNoYW5nZXMgc2luY2UgdjU6CiAtIERvbid0IHVzZSBpc19w b3dlcl9vZl8yLiBNYWtlcyB0aGluZ3MgY29uZnVzaW5nCiAtIERvbid0IHVzZSB0aGUgb2xkIHN0 YXRlIHRvIGZpZ3VyZSBvdXQgd2hldGhlciBvciBub3QgdG8KICAgZW5hYmxlL2Rpc2FibGUgdGhl IHNhZ3YsIHVzZSB0aGUgbmV3IG9uZQogLSBTcGxpdCB0aGUgbG9vcCBpbiBza2xfZGlzYWJsZV9z YWd2IGludG8gaXQncyBvd24gZnVuY3Rpb24KIC0gTW92ZSBza2xfc2Fndl9lbmFibGUvZGlzYWJs ZSgpIGNhbGxzIGludG8gaW50ZWxfYXRvbWljX2NvbW1pdF90YWlsKCkKQ2hhbmdlcyBzaW5jZSB2 NDoKIC0gVXNlIGlzX3Bvd2VyX29mXzIgYWdhaW5zdCBhY3RpdmVfY3J0Y3MgdG8gY2hlY2sgd2hl dGhlciB3ZSBoYXZlID4gMQogICBwaXBlIGVuYWJsZWQKIC0gRml4IHNrbF9zYWd2X2dldF9od19z dGF0ZSgpOiAodGVtcCAmIDB4MSkgaW5kaWNhdGVzIGRpc2FibGVkLCAweDAKICAgZW5hYmxlZAog LSBDYWxsIHNrbF9zYWd2X2VuYWJsZS9kaXNhYmxlKCkgZnJvbSBwcmUvcG9zdC1wbGFuZSB1cGRh dGVzCkNoYW5nZXMgc2luY2UgdjM6CiAtIFVzZSB0aW1lX2JlZm9yZSgpIHRvIGNvbXBhcmUgdGlt ZW91dCB0byBqaWZmaWVzCkNoYW5nZXMgc2luY2UgdjI6CiAtIFJlYWxseSBhcHBseSBtaW5vciBz dHlsZSBuaXRwaWNrcyB0byBwYXRjaCB0aGlzIHRpbWUKQ2hhbmdlcyBzaW5jZSB2MToKIC0gQWRk ZWQgY29tbWVudHMgYWJvdXQgdGhpcyBwcm9iYWJseSBiZWluZyBvbmUgb2YgdGhlIHJlcXVpcmVt ZW50cyB0bwogICBmaXhpbmcgU2t5bGFrZSdzIHdhdGVybWFyayBpc3N1ZXMKIC0gTWlub3Igc3R5 bGUgbml0cGlja3MgZnJvbSBNYXR0IFJvcGVyCiAtIERpc2FibGUgdGhlc2UgZnVuY3Rpb25zIG9u IEJyb3h0b24sIHNpbmNlIGl0IGRvZXNuJ3QgaGF2ZSBhbiBTQUdWCgpTaWduZWQtb2ZmLWJ5OiBM eXVkZSA8Y3BhdWxAcmVkaGF0LmNvbT4KQ2M6IE1hdHQgUm9wZXIgPG1hdHRoZXcuZC5yb3BlckBp bnRlbC5jb20+CkNjOiBNYWFydGVuIExhbmtob3JzdCA8bWFhcnRlbi5sYW5raG9yc3RAbGludXgu aW50ZWwuY29tPgpDYzogRGFuaWVsIFZldHRlciA8ZGFuaWVsLnZldHRlckBmZndsbC5jaD4KQ2M6 IFZpbGxlIFN5cmrDpGzDpCA8dmlsbGUuc3lyamFsYUBsaW51eC5pbnRlbC5jb20+CkNjOiBzdGFi bGVAdmdlci5rZXJuZWwub3JnCi0tLQogZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9kcnYuaCAg ICAgIHwgICA3ICsrCiBkcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1X3JlZy5oICAgICAgfCAgIDQg KwogZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZGlzcGxheS5jIHwgIDExICsrKwogZHJpdmVy cy9ncHUvZHJtL2k5MTUvaW50ZWxfZHJ2LmggICAgIHwgICAzICsKIGRyaXZlcnMvZ3B1L2RybS9p OTE1L2ludGVsX3BtLmMgICAgICB8IDE0OCArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr KysrKwogNSBmaWxlcyBjaGFuZ2VkLCAxNzMgaW5zZXJ0aW9ucygrKQoKZGlmZiAtLWdpdCBhL2Ry aXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZHJ2LmggYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pOTE1 X2Rydi5oCmluZGV4IDM1Y2FhOWIuLmYyMDUzMGJiIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9k cm0vaTkxNS9pOTE1X2Rydi5oCisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfZHJ2LmgK QEAgLTE5NDksNiArMTk0OSwxMyBAQCBzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSB7CiAJc3RydWN0 IGk5MTVfc3VzcGVuZF9zYXZlZF9yZWdpc3RlcnMgcmVnZmlsZTsKIAlzdHJ1Y3Qgdmx2X3MwaXhf c3RhdGUgdmx2X3MwaXhfc3RhdGU7CiAKKwllbnVtIHsKKwkJSTkxNV9TS0xfU0FHVl9VTktOT1dO ID0gMCwKKwkJSTkxNV9TS0xfU0FHVl9ESVNBQkxFRCwKKwkJSTkxNV9TS0xfU0FHVl9FTkFCTEVE LAorCQlJOTE1X1NLTF9TQUdWX05PVF9DT05UUk9MTEVECisJfSBza2xfc2Fndl9zdGF0dXM7CisK IAlzdHJ1Y3QgewogCQkvKgogCQkgKiBSYXcgd2F0ZXJtYXJrIGxhdGVuY3kgdmFsdWVzOgpkaWZm IC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9yZWcuaCBiL2RyaXZlcnMvZ3B1L2Ry bS9pOTE1L2k5MTVfcmVnLmgKaW5kZXggNzQxOWZiZi4uYmU4MmM0OSAxMDA2NDQKLS0tIGEvZHJp dmVycy9ncHUvZHJtL2k5MTUvaTkxNV9yZWcuaAorKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9p OTE1X3JlZy5oCkBAIC03MTUzLDYgKzcxNTMsMTAgQEAgZW51bSB7CiAjZGVmaW5lICAgSFNXX1BD T0RFX0RFX1dSSVRFX0ZSRVFfUkVRCQkweDE3CiAjZGVmaW5lICAgRElTUExBWV9JUFNfQ09OVFJP TAkJCTB4MTkKICNkZWZpbmUJICBIU1dfUENPREVfRFlOQU1JQ19EVVRZX0NZQ0xFX0NPTlRST0wJ MHgxQQorI2RlZmluZSAgIEdFTjlfUENPREVfU0FHVl9DT05UUk9MCQkweDIxCisjZGVmaW5lICAg ICBHRU45X1NBR1ZfRElTQUJMRQkJCTB4MAorI2RlZmluZSAgICAgR0VOOV9TQUdWX0lTX0RJU0FC TEVECQkweDEKKyNkZWZpbmUgICAgIEdFTjlfU0FHVl9FTkFCTEUgCSAgICAgICAgICAgICAweDMK ICNkZWZpbmUgR0VONl9QQ09ERV9EQVRBCQkJCV9NTUlPKDB4MTM4MTI4KQogI2RlZmluZSAgIEdF TjZfUENPREVfRlJFUV9JQV9SQVRJT19TSElGVAk4CiAjZGVmaW5lICAgR0VONl9QQ09ERV9GUkVR X1JJTkdfUkFUSU9fU0hJRlQJMTYKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2lu dGVsX2Rpc3BsYXkuYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX2Rpc3BsYXkuYwppbmRl eCA3ODFkMjJlLi5jYTRiODNmIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRl bF9kaXNwbGF5LmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZGlzcGxheS5jCkBA IC0xNDE1Niw2ICsxNDE1NiwxMyBAQCBzdGF0aWMgdm9pZCBpbnRlbF9hdG9taWNfY29tbWl0X3Rh aWwoc3RydWN0IGRybV9hdG9taWNfc3RhdGUgKnN0YXRlKQogCQkgICAgIGludGVsX3N0YXRlLT5j ZGNsa19wbGxfdmNvICE9IGRldl9wcml2LT5jZGNsa19wbGwudmNvKSkKIAkJCWRldl9wcml2LT5k aXNwbGF5Lm1vZGVzZXRfY29tbWl0X2NkY2xrKHN0YXRlKTsKIAorCQkvKgorCQkgKiBTS0wgd29y a2Fyb3VuZDogYnNwZWMgcmVjb21tZW5kcyB3ZSBkaXNhYmxlIHRoZSBTQUdWIHdoZW4gd2UKKwkJ ICogaGF2ZSBtb3JlIHRoZW4gb25lIHBpcGUgZW5hYmxlZAorCQkgKi8KKwkJaWYgKElTX1NLWUxB S0UoZGV2X3ByaXYpICYmICFza2xfY2FuX2VuYWJsZV9zYWd2KHN0YXRlKSkKKwkJCXNrbF9kaXNh YmxlX3NhZ3YoZGV2X3ByaXYpOworCiAJCWludGVsX21vZGVzZXRfdmVyaWZ5X2Rpc2FibGVkKGRl dik7CiAJfQogCkBAIC0xNDIyOSw2ICsxNDIzNiwxMCBAQCBzdGF0aWMgdm9pZCBpbnRlbF9hdG9t aWNfY29tbWl0X3RhaWwoc3RydWN0IGRybV9hdG9taWNfc3RhdGUgKnN0YXRlKQogCQlpbnRlbF9t b2Rlc2V0X3ZlcmlmeV9jcnRjKGNydGMsIG9sZF9jcnRjX3N0YXRlLCBjcnRjLT5zdGF0ZSk7CiAJ fQogCisJaWYgKElTX1NLWUxBS0UoZGV2X3ByaXYpICYmIGludGVsX3N0YXRlLT5tb2Rlc2V0ICYm CisJICAgIHNrbF9jYW5fZW5hYmxlX3NhZ3Yoc3RhdGUpKQorCQlza2xfZW5hYmxlX3NhZ3YoZGV2 X3ByaXYpOworCiAJZHJtX2F0b21pY19oZWxwZXJfY29tbWl0X2h3X2RvbmUoc3RhdGUpOwogCiAJ aWYgKGludGVsX3N0YXRlLT5tb2Rlc2V0KQpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5 MTUvaW50ZWxfZHJ2LmggYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kcnYuaAppbmRleCAx YzcwMGIwLi5kMjAzYzc3IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9k cnYuaAorKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kcnYuaApAQCAtMTcyMiw2ICsx NzIyLDkgQEAgdm9pZCBpbGtfd21fZ2V0X2h3X3N0YXRlKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYp Owogdm9pZCBza2xfd21fZ2V0X2h3X3N0YXRlKHN0cnVjdCBkcm1fZGV2aWNlICpkZXYpOwogdm9p ZCBza2xfZGRiX2dldF9od19zdGF0ZShzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqZGV2X3ByaXYs CiAJCQkgIHN0cnVjdCBza2xfZGRiX2FsbG9jYXRpb24gKmRkYiAvKiBvdXQgKi8pOworYm9vbCBz a2xfY2FuX2VuYWJsZV9zYWd2KHN0cnVjdCBkcm1fYXRvbWljX3N0YXRlICpzdGF0ZSk7CitpbnQg c2tsX2VuYWJsZV9zYWd2KHN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJpdik7CitpbnQg c2tsX2Rpc2FibGVfc2FndihzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqZGV2X3ByaXYpOwogdWlu dDMyX3QgaWxrX3BpcGVfcGl4ZWxfcmF0ZShjb25zdCBzdHJ1Y3QgaW50ZWxfY3J0Y19zdGF0ZSAq cGlwZV9jb25maWcpOwogYm9vbCBpbGtfZGlzYWJsZV9scF93bShzdHJ1Y3QgZHJtX2RldmljZSAq ZGV2KTsKIGludCBzYW5pdGl6ZV9yYzZfb3B0aW9uKHN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpk ZXZfcHJpdiwgaW50IGVuYWJsZV9yYzYpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5 MTUvaW50ZWxfcG0uYyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX3BtLmMKaW5kZXggYjRj Zjk4OC4uZmVkMmJhZTggMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX3Bt LmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfcG0uYwpAQCAtMjg2MCw2ICsyODYw LDcgQEAgYm9vbCBpbGtfZGlzYWJsZV9scF93bShzdHJ1Y3QgZHJtX2RldmljZSAqZGV2KQogCiAj ZGVmaW5lIFNLTF9EREJfU0laRQkJODk2CS8qIGluIGJsb2NrcyAqLwogI2RlZmluZSBCWFRfRERC X1NJWkUJCTUxMgorI2RlZmluZSBTS0xfU0FHVl9CTE9DS19USU1FIDMwIC8qIMK1cyAqLwogCiAv KgogICogUmV0dXJuIHRoZSBpbmRleCBvZiBhIHBsYW5lIGluIHRoZSBTS0wgRERCIGFuZCB3bSBy ZXN1bHQgYXJyYXlzLiAgUHJpbWFyeQpAQCAtMjg4Myw2ICsyODg0LDE1MyBAQCBza2xfd21fcGxh bmVfaWQoY29uc3Qgc3RydWN0IGludGVsX3BsYW5lICpwbGFuZSkKIAl9CiB9CiAKKy8qCisgKiBT QUdWIGR5bmFtaWNhbGx5IGFkanVzdHMgdGhlIHN5c3RlbSBhZ2VudCB2b2x0YWdlIGFuZCBjbG9j ayBmcmVxdWVuY2llcworICogZGVwZW5kaW5nIG9uIHBvd2VyIGFuZCBwZXJmb3JtYW5jZSByZXF1 aXJlbWVudHMuIFRoZSBkaXNwbGF5IGVuZ2luZSBhY2Nlc3MKKyAqIHRvIHN5c3RlbSBtZW1vcnkg aXMgYmxvY2tlZCBkdXJpbmcgdGhlIGFkanVzdG1lbnQgdGltZS4gQmVjYXVzZSBvZiB0aGUKKyAq IGJsb2NraW5nIHRpbWUsIGhhdmluZyB0aGlzIGVuYWJsZWQgY2FuIGNhdXNlIGZ1bGwgc3lzdGVt IGhhbmdzIGFuZC9vciBwaXBlCisgKiB1bmRlcnJ1bnMgaWYgd2UgZG9uJ3QgbWVldCBhbGwgb2Yg dGhlIGZvbGxvd2luZyByZXF1aXJlbWVudHM6CisgKgorICogIC0gPD0gMSBwaXBlIGVuYWJsZWQK KyAqICAtIEFsbCBwbGFuZXMgY2FuIGVuYWJsZSB3YXRlcm1hcmtzIGZvciBsYXRlbmNpZXMgPj0g U0FHViBlbmdpbmUgYmxvY2sgdGltZQorICogIC0gV2UncmUgbm90IHVzaW5nIGFuIGludGVybGFj ZWQgZGlzcGxheSBjb25maWd1cmF0aW9uCisgKi8KK2ludAorc2tsX2VuYWJsZV9zYWd2KHN0cnVj dCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJpdikKK3sKKwlpbnQgcmV0OworCisJaWYgKGRldl9w cml2LT5za2xfc2Fndl9zdGF0dXMgPT0gSTkxNV9TS0xfU0FHVl9OT1RfQ09OVFJPTExFRCB8fAor CSAgICBkZXZfcHJpdi0+c2tsX3NhZ3Zfc3RhdHVzID09IEk5MTVfU0tMX1NBR1ZfRU5BQkxFRCkK KwkJcmV0dXJuIDA7CisKKwlEUk1fREVCVUdfS01TKCJFbmFibGluZyB0aGUgU0FHVlxuIik7CisJ bXV0ZXhfbG9jaygmZGV2X3ByaXYtPnJwcy5od19sb2NrKTsKKworCXJldCA9IHNhbmR5YnJpZGdl X3Bjb2RlX3dyaXRlKGRldl9wcml2LCBHRU45X1BDT0RFX1NBR1ZfQ09OVFJPTCwKKwkJCQkgICAg ICBHRU45X1NBR1ZfRU5BQkxFKTsKKworCS8qIFdlIGRvbid0IG5lZWQgdG8gd2FpdCBmb3IgdGhl IFNBR1Ygd2hlbiBlbmFibGluZyAqLworCW11dGV4X3VubG9jaygmZGV2X3ByaXYtPnJwcy5od19s b2NrKTsKKworCS8qCisJICogU29tZSBza2wgc3lzdGVtcywgcHJlLXJlbGVhc2UgbWFjaGluZXMg aW4gcGFydGljdWxhciwKKwkgKiBkb24ndCBhY3R1YWxseSBoYXZlIGFuIFNBR1YuCisJICovCisJ aWYgKHJldCA9PSAtRU5PU1lTKSB7CisJCURSTV9ERUJVR19EUklWRVIoIk5vIFNBR1YgZm91bmQg b24gc3lzdGVtLCBpZ25vcmluZ1xuIik7CisJCWRldl9wcml2LT5za2xfc2Fndl9zdGF0dXMgPSBJ OTE1X1NLTF9TQUdWX05PVF9DT05UUk9MTEVEOworCQlyZXR1cm4gMDsKKwl9IGVsc2UgaWYgKHJl dCA8IDApIHsKKwkJRFJNX0VSUk9SKCJGYWlsZWQgdG8gZW5hYmxlIHRoZSBTQUdWXG4iKTsKKwkJ cmV0dXJuIHJldDsKKwl9CisKKwlkZXZfcHJpdi0+c2tsX3NhZ3Zfc3RhdHVzID0gSTkxNV9TS0xf U0FHVl9FTkFCTEVEOworCXJldHVybiAwOworfQorCitzdGF0aWMgaW50Citza2xfZG9fc2Fndl9k aXNhYmxlKHN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJpdikKK3sKKwlpbnQgcmV0Owor CXVpbnQzMl90IHRlbXAgPSBHRU45X1NBR1ZfRElTQUJMRTsKKworCXJldCA9IHNhbmR5YnJpZGdl X3Bjb2RlX3JlYWQoZGV2X3ByaXYsIEdFTjlfUENPREVfU0FHVl9DT05UUk9MLAorCQkJCSAgICAg JnRlbXApOworCWlmIChyZXQpCisJCXJldHVybiByZXQ7CisJZWxzZQorCQlyZXR1cm4gdGVtcCAm IEdFTjlfU0FHVl9JU19ESVNBQkxFRDsKK30KKworaW50Citza2xfZGlzYWJsZV9zYWd2KHN0cnVj dCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJpdikKK3sKKwlpbnQgcmV0LCByZXN1bHQ7CisKKwlp ZiAoZGV2X3ByaXYtPnNrbF9zYWd2X3N0YXR1cyA9PSBJOTE1X1NLTF9TQUdWX05PVF9DT05UUk9M TEVEIHx8CisJICAgIGRldl9wcml2LT5za2xfc2Fndl9zdGF0dXMgPT0gSTkxNV9TS0xfU0FHVl9E SVNBQkxFRCkKKwkJcmV0dXJuIDA7CisKKwlEUk1fREVCVUdfS01TKCJEaXNhYmxpbmcgdGhlIFNB R1ZcbiIpOworCW11dGV4X2xvY2soJmRldl9wcml2LT5ycHMuaHdfbG9jayk7CisKKwkvKiBic3Bl YyBzYXlzIHRvIGtlZXAgcmV0cnlpbmcgZm9yIGF0IGxlYXN0IDEgbXMgKi8KKwlyZXQgPSB3YWl0 X2ZvcihyZXN1bHQgPSBza2xfZG9fc2Fndl9kaXNhYmxlKGRldl9wcml2KSwgMSk7CisJbXV0ZXhf dW5sb2NrKCZkZXZfcHJpdi0+cnBzLmh3X2xvY2spOworCisJaWYgKHJldCA9PSAtRVRJTUVET1VU KSB7CisJCURSTV9FUlJPUigiUmVxdWVzdCB0byBkaXNhYmxlIFNBR1YgdGltZWQgb3V0XG4iKTsK KwkJcmV0dXJuIC1FVElNRURPVVQ7CisJfQorCisJLyoKKwkgKiBTb21lIHNrbCBzeXN0ZW1zLCBw cmUtcmVsZWFzZSBtYWNoaW5lcyBpbiBwYXJ0aWN1bGFyLAorCSAqIGRvbid0IGFjdHVhbGx5IGhh dmUgYW4gU0FHVi4KKwkgKi8KKwlpZiAocmVzdWx0ID09IC1FTk9TWVMpIHsKKwkJRFJNX0RFQlVH X0RSSVZFUigiTm8gU0FHViBmb3VuZCBvbiBzeXN0ZW0sIGlnbm9yaW5nXG4iKTsKKwkJZGV2X3By aXYtPnNrbF9zYWd2X3N0YXR1cyA9IEk5MTVfU0tMX1NBR1ZfTk9UX0NPTlRST0xMRUQ7CisJCXJl dHVybiAwOworCX0gZWxzZSBpZiAocmVzdWx0IDwgMCkgeworCQlEUk1fRVJST1IoIkZhaWxlZCB0 byBkaXNhYmxlIHRoZSBTQUdWXG4iKTsKKwkJcmV0dXJuIHJlc3VsdDsKKwl9CisKKwlkZXZfcHJp di0+c2tsX3NhZ3Zfc3RhdHVzID0gSTkxNV9TS0xfU0FHVl9ESVNBQkxFRDsKKwlyZXR1cm4gMDsK K30KKworYm9vbCBza2xfY2FuX2VuYWJsZV9zYWd2KHN0cnVjdCBkcm1fYXRvbWljX3N0YXRlICpz dGF0ZSkKK3sKKwlzdHJ1Y3QgZHJtX2RldmljZSAqZGV2ID0gc3RhdGUtPmRldjsKKwlzdHJ1Y3Qg ZHJtX2k5MTVfcHJpdmF0ZSAqZGV2X3ByaXYgPSB0b19pOTE1KGRldik7CisJc3RydWN0IGludGVs X2F0b21pY19zdGF0ZSAqaW50ZWxfc3RhdGUgPSB0b19pbnRlbF9hdG9taWNfc3RhdGUoc3RhdGUp OworCXN0cnVjdCBkcm1fY3J0YyAqY3J0YzsKKwllbnVtIHBpcGUgcGlwZTsKKwlpbnQgbGV2ZWws IHBsYW5lOworCisJLyoKKwkgKiBTS0wgd29ya2Fyb3VuZDogYnNwZWMgcmVjb21tZW5kcyB3ZSBk aXNhYmxlIHRoZSBTQUdWIHdoZW4gd2UgaGF2ZQorCSAqIG1vcmUgdGhlbiBvbmUgcGlwZSBlbmFi bGVkCisJICoKKwkgKiBJZiB0aGVyZSBhcmUgbm8gYWN0aXZlIENSVENzLCBubyBhZGRpdGlvbmFs IGNoZWNrcyBuZWVkIGJlIHBlcmZvcm1lZAorCSAqLworCWlmIChod2VpZ2h0MzIoaW50ZWxfc3Rh dGUtPmFjdGl2ZV9jcnRjcykgPT0gMCkKKwkJcmV0dXJuIHRydWU7CisJZWxzZSBpZiAoaHdlaWdo dDMyKGludGVsX3N0YXRlLT5hY3RpdmVfY3J0Y3MpID4gMSkKKwkJcmV0dXJuIGZhbHNlOworCisJ LyogU2luY2Ugd2UncmUgbm93IGd1YXJhbnRlZWQgdG8gb25seSBoYXZlIG9uZSBhY3RpdmUgQ1JU Qy4uLiAqLworCXBpcGUgPSBmZnMoaW50ZWxfc3RhdGUtPmFjdGl2ZV9jcnRjcykgLSAxOworCWNy dGMgPSBkZXZfcHJpdi0+cGlwZV90b19jcnRjX21hcHBpbmdbcGlwZV07CisKKwlpZiAoY3J0Yy0+ c3RhdGUtPm1vZGUuZmxhZ3MgJiBEUk1fTU9ERV9GTEFHX0lOVEVSTEFDRSkKKwkJcmV0dXJuIGZh bHNlOworCisJZm9yX2VhY2hfcGxhbmUoZGV2X3ByaXYsIHBpcGUsIHBsYW5lKSB7CisJCS8qIFNr aXAgdGhpcyBwbGFuZSBpZiBpdCdzIG5vdCBlbmFibGVkICovCisJCWlmIChpbnRlbF9zdGF0ZS0+ d21fcmVzdWx0cy5wbGFuZVtwaXBlXVtwbGFuZV1bMF0gPT0gMCkKKwkJCWNvbnRpbnVlOworCisJ CS8qIEZpbmQgdGhlIGhpZ2hlc3QgZW5hYmxlZCB3bSBsZXZlbCBmb3IgdGhpcyBwbGFuZSAqLwor CQlmb3IgKGxldmVsID0gaWxrX3dtX21heF9sZXZlbChkZXYpOworCQkgICAgIGludGVsX3N0YXRl LT53bV9yZXN1bHRzLnBsYW5lW3BpcGVdW3BsYW5lXVtsZXZlbF0gPT0gMDsKKwkJICAgICAtLWxl dmVsKTsKKworCQkvKgorCQkgKiBJZiBhbnkgb2YgdGhlIHBsYW5lcyBvbiB0aGlzIHBpcGUgZG9u J3QgZW5hYmxlIHdtIGxldmVscworCQkgKiB0aGF0IGluY3VyIG1lbW9yeSBsYXRlbmNpZXMgaGln aGVyIHRoZW4gMzDCtXMgd2UgY2FuJ3QgZW5hYmxlCisJCSAqIHRoZSBTQUdWCisJCSAqLworCQlp ZiAoZGV2X3ByaXYtPndtLnNrbF9sYXRlbmN5W2xldmVsXSA8IFNLTF9TQUdWX0JMT0NLX1RJTUUp CisJCQlyZXR1cm4gZmFsc2U7CisJfQorCisJcmV0dXJuIHRydWU7Cit9CisKIHN0YXRpYyB2b2lk CiBza2xfZGRiX2dldF9waXBlX2FsbG9jYXRpb25fbGltaXRzKHN0cnVjdCBkcm1fZGV2aWNlICpk ZXYsCiAJCQkJICAgY29uc3Qgc3RydWN0IGludGVsX2NydGNfc3RhdGUgKmNzdGF0ZSwKLS0gCjIu Ny40CgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpkcmkt ZGV2ZWwgbWFpbGluZyBsaXN0CmRyaS1kZXZlbEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6 Ly9saXN0cy5mcmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0aW5mby9kcmktZGV2ZWwK