From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1753582AbcHQT4U (ORCPT ); Wed, 17 Aug 2016 15:56:20 -0400 Received: from mx1.redhat.com ([209.132.183.28]:55112 "EHLO mx1.redhat.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1753386AbcHQT4S (ORCPT ); Wed, 17 Aug 2016 15:56:18 -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 , Radhakrishna Sripada , Hans de Goede , Jani Nikula , David Airlie , dri-devel@lists.freedesktop.org, linux-kernel@vger.kernel.org Subject: [PATCH v12 7/7] drm/i915/skl: Update DDB values atomically with wms/plane attrs Date: Wed, 17 Aug 2016 15:55:59 -0400 Message-Id: <1471463761-26796-8-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.27]); Wed, 17 Aug 2016 19:56:18 +0000 (UTC) Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Now that we can hook into update_crtcs and control the order in which we update CRTCs at each modeset, we can finish the final step of fixing Skylake's watermark handling by performing DDB updates at the same time as plane updates and watermark updates. The first major change in this patch is skl_update_crtcs(), which handles ensuring that we order each CRTC update in our atomic commits properly so that they honor the DDB flush order. The second major change in this patch is the order in which we flush the pipes. While the previous order may have worked, it can't be used in this approach since it no longer will do the right thing. For example, using the old ddb flush order: We have pipes A, B, and C enabled, and we're disabling C. Initial ddb allocation looks like this: | A | B |xxxxxxx| Since we're performing the ddb updates after performing any CRTC disablements in intel_atomic_commit_tail(), the space to the right of pipe B is unallocated. 1. Flush pipes with new allocation contained into old space. None apply, so we skip this 2. Flush pipes having their allocation reduced, but overlapping with a previous allocation. None apply, so we also skip this 3. Flush pipes that got more space allocated. This applies to A and B, giving us the following update order: A, B This is wrong, since updating pipe A first will cause it to overlap with B and potentially burst into flames. Our new order (see the code comments for details) would update the pipes in the proper order: B, A. As well, we calculate the order for each DDB update during the check phase, and reference it later in the commit phase when we hit skl_update_crtcs(). This long overdue patch fixes the rest of the underruns on Skylake. Changes since v1: - Add skl_ddb_entry_write() for cursor into skl_write_cursor_wm() Changes since v2: - Use the method for updating CRTCs that Ville suggested - In skl_update_wm(), only copy the watermarks for the crtc that was passed to us Changes since v3: - Small comment fix in skl_ddb_allocation_overlaps() Changes since v4: - Remove the second loop in intel_update_crtcs() and use Ville's suggestion for updating the ddb allocations in the right order - Get rid of the second loop and just use the ddb state as it updates to determine what order to update everything in (thanks for the suggestion Ville) - Simplify skl_ddb_allocation_overlaps() - Split actual overlap checking into it's own helper Fixes: 0e8fb7ba7ca5 ("drm/i915/skl: Flush the WM configuration") Fixes: 8211bd5bdf5e ("drm/i915/skl: Program the DDB allocation") [omitting CC for stable, since this patch will need to be changed for such backports first] Testcase: kms_cursor_legacy Signed-off-by: Lyude Cc: Ville Syrjälä Cc: Daniel Vetter Cc: Radhakrishna Sripada Cc: Hans de Goede Cc: Matt Roper --- drivers/gpu/drm/i915/intel_display.c | 93 +++++++++++++--- drivers/gpu/drm/i915/intel_drv.h | 7 ++ drivers/gpu/drm/i915/intel_pm.c | 200 ++++++++--------------------------- 3 files changed, 132 insertions(+), 168 deletions(-) diff --git a/drivers/gpu/drm/i915/intel_display.c b/drivers/gpu/drm/i915/intel_display.c index 4b078e8..3aa9109 100644 --- a/drivers/gpu/drm/i915/intel_display.c +++ b/drivers/gpu/drm/i915/intel_display.c @@ -13361,16 +13361,23 @@ static void verify_wm_state(struct drm_crtc *crtc, hw_entry->start, hw_entry->end); } - /* cursor */ - hw_entry = &hw_ddb.plane[pipe][PLANE_CURSOR]; - sw_entry = &sw_ddb->plane[pipe][PLANE_CURSOR]; - - if (!skl_ddb_entry_equal(hw_entry, sw_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); + /* + * cursor + * If the cursor plane isn't active, we may not have updated it's ddb + * allocation. In that case since the ddb allocation will be updated + * 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]; + + if (!skl_ddb_entry_equal(hw_entry, sw_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); + } } } @@ -14122,6 +14129,65 @@ static void intel_update_crtcs(struct drm_atomic_state *state, } } +static void skl_update_crtcs(struct drm_atomic_state *state, + unsigned int *crtc_vblank_mask) +{ + 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; + struct drm_crtc_state *old_crtc_state; + struct skl_ddb_allocation *new_ddb = &intel_state->wm_results.ddb; + struct skl_ddb_allocation *cur_ddb = &dev_priv->wm.skl_hw.ddb; + unsigned int updated = 0; + bool progress; + enum pipe pipe; + + /* + * Whenever the number of active pipes changes, we need to make sure we + * update the pipes in the right order so that their ddb allocations + * never overlap with eachother inbetween CRTC updates. Otherwise we'll + * cause pipe underruns and other bad stuff. + */ + do { + int i; + progress = false; + + for_each_crtc_in_state(state, crtc, old_crtc_state, i) { + bool vbl_wait = false; + unsigned int cmask = drm_crtc_mask(crtc); + pipe = to_intel_crtc(crtc)->pipe; + + if (updated & cmask || !crtc->state->active) + continue; + if (skl_ddb_allocation_overlaps(state, cur_ddb, new_ddb, + pipe)) + continue; + + updated |= cmask; + + /* + * If this is an already active pipe, it's DDB changed, + * and this isn't the last pipe that needs updating + * then we need to wait for a vblank to pass for the + * new ddb allocation to take effect. + */ + if (!skl_ddb_allocation_equals(cur_ddb, new_ddb, pipe) && + !crtc->state->active_changed && + intel_state->wm_results.dirty_pipes != updated) + vbl_wait = true; + + intel_update_crtc(crtc, state, old_crtc_state, + crtc_vblank_mask); + + if (vbl_wait) + intel_wait_for_vblank(dev, pipe); + + progress = true; + } + } while (progress); +} + static void intel_atomic_commit_tail(struct drm_atomic_state *state) { struct drm_device *dev = state->dev; @@ -15761,8 +15827,6 @@ void intel_init_display_hooks(struct drm_i915_private *dev_priv) dev_priv->display.crtc_disable = i9xx_crtc_disable; } - dev_priv->display.update_crtcs = intel_update_crtcs; - /* Returns the core display clock speed */ if (IS_SKYLAKE(dev_priv) || IS_KABYLAKE(dev_priv)) dev_priv->display.get_display_clock_speed = @@ -15852,6 +15916,11 @@ void intel_init_display_hooks(struct drm_i915_private *dev_priv) skl_modeset_calc_cdclk; } + if (dev_priv->info.gen >= 9) + dev_priv->display.update_crtcs = skl_update_crtcs; + else + dev_priv->display.update_crtcs = intel_update_crtcs; + switch (INTEL_INFO(dev_priv)->gen) { case 2: dev_priv->display.queue_flip = intel_gen2_queue_flip; diff --git a/drivers/gpu/drm/i915/intel_drv.h b/drivers/gpu/drm/i915/intel_drv.h index 1d31cca..7bf8209 100644 --- a/drivers/gpu/drm/i915/intel_drv.h +++ b/drivers/gpu/drm/i915/intel_drv.h @@ -1725,6 +1725,13 @@ void skl_ddb_get_hw_state(struct drm_i915_private *dev_priv, 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); +bool skl_ddb_allocation_equals(const struct skl_ddb_allocation *old, + const struct skl_ddb_allocation *new, + enum pipe pipe); +bool skl_ddb_allocation_overlaps(struct drm_atomic_state *state, + const struct skl_ddb_allocation *old, + const struct skl_ddb_allocation *new, + enum pipe pipe); void skl_write_cursor_wm(struct intel_crtc *intel_crtc, const struct skl_wm_values *wm); void skl_write_plane_wm(struct intel_crtc *intel_crtc, diff --git a/drivers/gpu/drm/i915/intel_pm.c b/drivers/gpu/drm/i915/intel_pm.c index a3d24cb..54f014c 100644 --- a/drivers/gpu/drm/i915/intel_pm.c +++ b/drivers/gpu/drm/i915/intel_pm.c @@ -3853,6 +3853,11 @@ void skl_write_plane_wm(struct intel_crtc *intel_crtc, wm->plane[pipe][plane][level]); } I915_WRITE(PLANE_WM_TRANS(pipe, plane), wm->plane_trans[pipe][plane]); + + skl_ddb_entry_write(dev_priv, PLANE_BUF_CFG(pipe, plane), + &wm->ddb.plane[pipe][plane]); + skl_ddb_entry_write(dev_priv, PLANE_NV12_BUF_CFG(pipe, plane), + &wm->ddb.y_plane[pipe][plane]); } void skl_write_cursor_wm(struct intel_crtc *intel_crtc, @@ -3869,170 +3874,46 @@ void skl_write_cursor_wm(struct intel_crtc *intel_crtc, wm->plane[pipe][PLANE_CURSOR][level]); } I915_WRITE(CUR_WM_TRANS(pipe), wm->plane_trans[pipe][PLANE_CURSOR]); -} - -static void skl_write_wm_values(struct drm_i915_private *dev_priv, - const struct skl_wm_values *new) -{ - struct drm_device *dev = &dev_priv->drm; - struct intel_crtc *crtc; - - for_each_intel_crtc(dev, crtc) { - int i; - enum pipe pipe = crtc->pipe; - - if ((new->dirty_pipes & drm_crtc_mask(&crtc->base)) == 0) - continue; - if (!crtc->active) - continue; - - for (i = 0; i < intel_num_planes(crtc); i++) { - skl_ddb_entry_write(dev_priv, - PLANE_BUF_CFG(pipe, i), - &new->ddb.plane[pipe][i]); - skl_ddb_entry_write(dev_priv, - PLANE_NV12_BUF_CFG(pipe, i), - &new->ddb.y_plane[pipe][i]); - } - skl_ddb_entry_write(dev_priv, CUR_BUF_CFG(pipe), - &new->ddb.plane[pipe][PLANE_CURSOR]); - } + skl_ddb_entry_write(dev_priv, CUR_BUF_CFG(pipe), + &wm->ddb.plane[pipe][PLANE_CURSOR]); } -/* - * When setting up a new DDB allocation arrangement, we need to correctly - * sequence the times at which the new allocations for the pipes are taken into - * account or we'll have pipes fetching from space previously allocated to - * another pipe. - * - * Roughly the sequence looks like: - * 1. re-allocate the pipe(s) with the allocation being reduced and not - * overlapping with a previous light-up pipe (another way to put it is: - * pipes with their new allocation strickly included into their old ones). - * 2. re-allocate the other pipes that get their allocation reduced - * 3. allocate the pipes having their allocation increased - * - * Steps 1. and 2. are here to take care of the following case: - * - Initially DDB looks like this: - * | B | C | - * - enable pipe A. - * - pipe B has a reduced DDB allocation that overlaps with the old pipe C - * allocation - * | A | B | C | - * - * We need to sequence the re-allocation: C, B, A (and not B, C, A). - */ - -static void -skl_wm_flush_pipe(struct drm_i915_private *dev_priv, enum pipe pipe, int pass) +bool skl_ddb_allocation_equals(const struct skl_ddb_allocation *old, + const struct skl_ddb_allocation *new, + enum pipe pipe) { - int plane; - - DRM_DEBUG_KMS("flush pipe %c (pass %d)\n", pipe_name(pipe), pass); - - for_each_plane(dev_priv, pipe, plane) { - I915_WRITE(PLANE_SURF(pipe, plane), - I915_READ(PLANE_SURF(pipe, plane))); - } - I915_WRITE(CURBASE(pipe), I915_READ(CURBASE(pipe))); + return new->pipe[pipe].start == old->pipe[pipe].start && + new->pipe[pipe].end == old->pipe[pipe].end; } -static bool -skl_ddb_allocation_included(const struct skl_ddb_allocation *old, - const struct skl_ddb_allocation *new, - enum pipe pipe) +static inline bool skl_ddb_entries_overlap(const struct skl_ddb_entry *a, + const struct skl_ddb_entry *b) { - uint16_t old_size, new_size; - - old_size = skl_ddb_entry_size(&old->pipe[pipe]); - new_size = skl_ddb_entry_size(&new->pipe[pipe]); - - return old_size != new_size && - new->pipe[pipe].start >= old->pipe[pipe].start && - new->pipe[pipe].end <= old->pipe[pipe].end; + return a->start < b->end && b->start < a->end; } -static void skl_flush_wm_values(struct drm_i915_private *dev_priv, - struct skl_wm_values *new_values) +bool skl_ddb_allocation_overlaps(struct drm_atomic_state *state, + const struct skl_ddb_allocation *old, + const struct skl_ddb_allocation *new, + enum pipe pipe) { - struct drm_device *dev = &dev_priv->drm; - struct skl_ddb_allocation *cur_ddb, *new_ddb; - bool reallocated[I915_MAX_PIPES] = {}; - struct intel_crtc *crtc; - enum pipe pipe; - - new_ddb = &new_values->ddb; - cur_ddb = &dev_priv->wm.skl_hw.ddb; - - /* - * First pass: flush the pipes with the new allocation contained into - * the old space. - * - * We'll wait for the vblank on those pipes to ensure we can safely - * re-allocate the freed space without this pipe fetching from it. - */ - for_each_intel_crtc(dev, crtc) { - if (!crtc->active) - continue; - - pipe = crtc->pipe; - - if (!skl_ddb_allocation_included(cur_ddb, new_ddb, pipe)) - continue; - - skl_wm_flush_pipe(dev_priv, pipe, 1); - intel_wait_for_vblank(dev, pipe); - - reallocated[pipe] = true; - } - - - /* - * Second pass: flush the pipes that are having their allocation - * reduced, but overlapping with a previous allocation. - * - * Here as well we need to wait for the vblank to make sure the freed - * space is not used anymore. - */ - for_each_intel_crtc(dev, crtc) { - if (!crtc->active) - continue; + struct drm_device *dev = state->dev; + struct intel_crtc *intel_crtc; + enum pipe otherp; - pipe = crtc->pipe; + for_each_intel_crtc(dev, intel_crtc) { + otherp = intel_crtc->pipe; - if (reallocated[pipe]) + if (otherp == pipe) continue; - if (skl_ddb_entry_size(&new_ddb->pipe[pipe]) < - skl_ddb_entry_size(&cur_ddb->pipe[pipe])) { - skl_wm_flush_pipe(dev_priv, pipe, 2); - intel_wait_for_vblank(dev, pipe); - reallocated[pipe] = true; - } + if (skl_ddb_entries_overlap(&new->pipe[pipe], + &old->pipe[otherp])) + return true; } - /* - * Third pass: flush the pipes that got more space allocated. - * - * We don't need to actively wait for the update here, next vblank - * will just get more DDB space with the correct WM values. - */ - for_each_intel_crtc(dev, crtc) { - if (!crtc->active) - continue; - - pipe = crtc->pipe; - - /* - * At this point, only the pipes more space than before are - * left to re-allocate. - */ - if (reallocated[pipe]) - continue; - - skl_wm_flush_pipe(dev_priv, pipe, 3); - } + return false; } static int skl_update_pipe_wm(struct drm_crtc_state *cstate, @@ -4219,7 +4100,7 @@ static void skl_update_wm(struct drm_crtc *crtc) struct skl_wm_values *hw_vals = &dev_priv->wm.skl_hw; struct intel_crtc_state *cstate = to_intel_crtc_state(crtc->state); struct skl_pipe_wm *pipe_wm = &cstate->wm.skl.optimal; - int pipe; + enum pipe pipe = intel_crtc->pipe; if ((results->dirty_pipes & drm_crtc_mask(crtc)) == 0) return; @@ -4228,15 +4109,22 @@ static void skl_update_wm(struct drm_crtc *crtc) mutex_lock(&dev_priv->wm.wm_mutex); - skl_write_wm_values(dev_priv, results); - skl_flush_wm_values(dev_priv, results); - /* - * Store the new configuration (but only for the pipes that have - * changed; the other values weren't recomputed). + * If this pipe isn't active already, we're going to be enabling it + * very soon. Since it's safe to update a pipe's ddb allocation while + * the pipe's shut off, just do so here. Already active pipes will have + * their watermarks updated once we update their planes. */ - for_each_pipe_masked(dev_priv, pipe, results->dirty_pipes) - skl_copy_wm_for_pipe(hw_vals, results, pipe); + if (crtc->state->active_changed) { + int plane; + + for (plane = 0; plane < intel_num_planes(intel_crtc); plane++) + skl_write_plane_wm(intel_crtc, results, plane); + + skl_write_cursor_wm(intel_crtc, results); + } + + skl_copy_wm_for_pipe(hw_vals, results, pipe); mutex_unlock(&dev_priv->wm.wm_mutex); } -- 2.7.4 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Lyude Subject: [PATCH v12 7/7] drm/i915/skl: Update DDB values atomically with wms/plane attrs Date: Wed, 17 Aug 2016 15:55:59 -0400 Message-ID: <1471463761-26796-8-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: Radhakrishna Sripada , linux-kernel@vger.kernel.org, Hans de Goede , dri-devel@lists.freedesktop.org, Daniel Vetter , Lyude List-Id: dri-devel@lists.freedesktop.org Tm93IHRoYXQgd2UgY2FuIGhvb2sgaW50byB1cGRhdGVfY3J0Y3MgYW5kIGNvbnRyb2wgdGhlIG9y ZGVyIGluIHdoaWNoIHdlCnVwZGF0ZSBDUlRDcyBhdCBlYWNoIG1vZGVzZXQsIHdlIGNhbiBmaW5p c2ggdGhlIGZpbmFsIHN0ZXAgb2YgZml4aW5nClNreWxha2UncyB3YXRlcm1hcmsgaGFuZGxpbmcg YnkgcGVyZm9ybWluZyBEREIgdXBkYXRlcyBhdCB0aGUgc2FtZSB0aW1lCmFzIHBsYW5lIHVwZGF0 ZXMgYW5kIHdhdGVybWFyayB1cGRhdGVzLgoKVGhlIGZpcnN0IG1ham9yIGNoYW5nZSBpbiB0aGlz IHBhdGNoIGlzIHNrbF91cGRhdGVfY3J0Y3MoKSwgd2hpY2gKaGFuZGxlcyBlbnN1cmluZyB0aGF0 IHdlIG9yZGVyIGVhY2ggQ1JUQyB1cGRhdGUgaW4gb3VyIGF0b21pYyBjb21taXRzCnByb3Blcmx5 IHNvIHRoYXQgdGhleSBob25vciB0aGUgRERCIGZsdXNoIG9yZGVyLgoKVGhlIHNlY29uZCBtYWpv ciBjaGFuZ2UgaW4gdGhpcyBwYXRjaCBpcyB0aGUgb3JkZXIgaW4gd2hpY2ggd2UgZmx1c2ggdGhl CnBpcGVzLiBXaGlsZSB0aGUgcHJldmlvdXMgb3JkZXIgbWF5IGhhdmUgd29ya2VkLCBpdCBjYW4n dCBiZSB1c2VkIGluCnRoaXMgYXBwcm9hY2ggc2luY2UgaXQgbm8gbG9uZ2VyIHdpbGwgZG8gdGhl IHJpZ2h0IHRoaW5nLiBGb3IgZXhhbXBsZSwKdXNpbmcgdGhlIG9sZCBkZGIgZmx1c2ggb3JkZXI6 CgpXZSBoYXZlIHBpcGVzIEEsIEIsIGFuZCBDIGVuYWJsZWQsIGFuZCB3ZSdyZSBkaXNhYmxpbmcg Qy4gSW5pdGlhbCBkZGIKYWxsb2NhdGlvbiBsb29rcyBsaWtlIHRoaXM6Cgp8ICAgQSAgIHwgICBC ICAgfHh4eHh4eHh8CgpTaW5jZSB3ZSdyZSBwZXJmb3JtaW5nIHRoZSBkZGIgdXBkYXRlcyBhZnRl ciBwZXJmb3JtaW5nIGFueSBDUlRDCmRpc2FibGVtZW50cyBpbiBpbnRlbF9hdG9taWNfY29tbWl0 X3RhaWwoKSwgdGhlIHNwYWNlIHRvIHRoZSByaWdodCBvZgpwaXBlIEIgaXMgdW5hbGxvY2F0ZWQu CgoxLiBGbHVzaCBwaXBlcyB3aXRoIG5ldyBhbGxvY2F0aW9uIGNvbnRhaW5lZCBpbnRvIG9sZCBz cGFjZS4gTm9uZQogICBhcHBseSwgc28gd2Ugc2tpcCB0aGlzCjIuIEZsdXNoIHBpcGVzIGhhdmlu ZyB0aGVpciBhbGxvY2F0aW9uIHJlZHVjZWQsIGJ1dCBvdmVybGFwcGluZyB3aXRoIGEKICAgcHJl dmlvdXMgYWxsb2NhdGlvbi4gTm9uZSBhcHBseSwgc28gd2UgYWxzbyBza2lwIHRoaXMKMy4gRmx1 c2ggcGlwZXMgdGhhdCBnb3QgbW9yZSBzcGFjZSBhbGxvY2F0ZWQuIFRoaXMgYXBwbGllcyB0byBB IGFuZCBCLAogICBnaXZpbmcgdXMgdGhlIGZvbGxvd2luZyB1cGRhdGUgb3JkZXI6IEEsIEIKClRo aXMgaXMgd3JvbmcsIHNpbmNlIHVwZGF0aW5nIHBpcGUgQSBmaXJzdCB3aWxsIGNhdXNlIGl0IHRv IG92ZXJsYXAgd2l0aApCIGFuZCBwb3RlbnRpYWxseSBidXJzdCBpbnRvIGZsYW1lcy4gT3VyIG5l dyBvcmRlciAoc2VlIHRoZSBjb2RlCmNvbW1lbnRzIGZvciBkZXRhaWxzKSB3b3VsZCB1cGRhdGUg dGhlIHBpcGVzIGluIHRoZSBwcm9wZXIgb3JkZXI6IEIsIEEuCgpBcyB3ZWxsLCB3ZSBjYWxjdWxh dGUgdGhlIG9yZGVyIGZvciBlYWNoIEREQiB1cGRhdGUgZHVyaW5nIHRoZSBjaGVjawpwaGFzZSwg YW5kIHJlZmVyZW5jZSBpdCBsYXRlciBpbiB0aGUgY29tbWl0IHBoYXNlIHdoZW4gd2UgaGl0CnNr bF91cGRhdGVfY3J0Y3MoKS4KClRoaXMgbG9uZyBvdmVyZHVlIHBhdGNoIGZpeGVzIHRoZSByZXN0 IG9mIHRoZSB1bmRlcnJ1bnMgb24gU2t5bGFrZS4KCkNoYW5nZXMgc2luY2UgdjE6CiAtIEFkZCBz a2xfZGRiX2VudHJ5X3dyaXRlKCkgZm9yIGN1cnNvciBpbnRvIHNrbF93cml0ZV9jdXJzb3Jfd20o KQpDaGFuZ2VzIHNpbmNlIHYyOgogLSBVc2UgdGhlIG1ldGhvZCBmb3IgdXBkYXRpbmcgQ1JUQ3Mg dGhhdCBWaWxsZSBzdWdnZXN0ZWQKIC0gSW4gc2tsX3VwZGF0ZV93bSgpLCBvbmx5IGNvcHkgdGhl IHdhdGVybWFya3MgZm9yIHRoZSBjcnRjIHRoYXQgd2FzCiAgIHBhc3NlZCB0byB1cwpDaGFuZ2Vz IHNpbmNlIHYzOgogLSBTbWFsbCBjb21tZW50IGZpeCBpbiBza2xfZGRiX2FsbG9jYXRpb25fb3Zl cmxhcHMoKQpDaGFuZ2VzIHNpbmNlIHY0OgogLSBSZW1vdmUgdGhlIHNlY29uZCBsb29wIGluIGlu dGVsX3VwZGF0ZV9jcnRjcygpIGFuZCB1c2UgVmlsbGUncwogICBzdWdnZXN0aW9uIGZvciB1cGRh dGluZyB0aGUgZGRiIGFsbG9jYXRpb25zIGluIHRoZSByaWdodCBvcmRlcgogLSBHZXQgcmlkIG9m IHRoZSBzZWNvbmQgbG9vcCBhbmQganVzdCB1c2UgdGhlIGRkYiBzdGF0ZSBhcyBpdCB1cGRhdGVz CiAgIHRvIGRldGVybWluZSB3aGF0IG9yZGVyIHRvIHVwZGF0ZSBldmVyeXRoaW5nIGluICh0aGFu a3MgZm9yIHRoZQogICBzdWdnZXN0aW9uIFZpbGxlKQogLSBTaW1wbGlmeSBza2xfZGRiX2FsbG9j YXRpb25fb3ZlcmxhcHMoKQogLSBTcGxpdCBhY3R1YWwgb3ZlcmxhcCBjaGVja2luZyBpbnRvIGl0 J3Mgb3duIGhlbHBlcgoKRml4ZXM6IDBlOGZiN2JhN2NhNSAoImRybS9pOTE1L3NrbDogRmx1c2gg dGhlIFdNIGNvbmZpZ3VyYXRpb24iKQpGaXhlczogODIxMWJkNWJkZjVlICgiZHJtL2k5MTUvc2ts OiBQcm9ncmFtIHRoZSBEREIgYWxsb2NhdGlvbiIpCltvbWl0dGluZyBDQyBmb3Igc3RhYmxlLCBz aW5jZSB0aGlzIHBhdGNoIHdpbGwgbmVlZCB0byBiZSBjaGFuZ2VkIGZvcgpzdWNoIGJhY2twb3J0 cyBmaXJzdF0KClRlc3RjYXNlOiBrbXNfY3Vyc29yX2xlZ2FjeQpTaWduZWQtb2ZmLWJ5OiBMeXVk ZSA8Y3BhdWxAcmVkaGF0LmNvbT4KQ2M6IFZpbGxlIFN5cmrDpGzDpCA8dmlsbGUuc3lyamFsYUBs aW51eC5pbnRlbC5jb20+CkNjOiBEYW5pZWwgVmV0dGVyIDxkYW5pZWwudmV0dGVyQGludGVsLmNv bT4KQ2M6IFJhZGhha3Jpc2huYSBTcmlwYWRhIDxyYWRoYWtyaXNobmEuc3JpcGFkYUBpbnRlbC5j b20+CkNjOiBIYW5zIGRlIEdvZWRlIDxoZGVnb2VkZUByZWRoYXQuY29tPgpDYzogTWF0dCBSb3Bl ciA8bWF0dGhldy5kLnJvcGVyQGludGVsLmNvbT4KLS0tCiBkcml2ZXJzL2dwdS9kcm0vaTkxNS9p bnRlbF9kaXNwbGF5LmMgfCAgOTMgKysrKysrKysrKysrKy0tLQogZHJpdmVycy9ncHUvZHJtL2k5 MTUvaW50ZWxfZHJ2LmggICAgIHwgICA3ICsrCiBkcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9w bS5jICAgICAgfCAyMDAgKysrKysrKystLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KIDMgZmls ZXMgY2hhbmdlZCwgMTMyIGluc2VydGlvbnMoKyksIDE2OCBkZWxldGlvbnMoLSkKCmRpZmYgLS1n aXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kaXNwbGF5LmMgYi9kcml2ZXJzL2dwdS9k cm0vaTkxNS9pbnRlbF9kaXNwbGF5LmMKaW5kZXggNGIwNzhlOC4uM2FhOTEwOSAxMDA2NDQKLS0t IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZGlzcGxheS5jCisrKyBiL2RyaXZlcnMvZ3B1 L2RybS9pOTE1L2ludGVsX2Rpc3BsYXkuYwpAQCAtMTMzNjEsMTYgKzEzMzYxLDIzIEBAIHN0YXRp YyB2b2lkIHZlcmlmeV93bV9zdGF0ZShzdHJ1Y3QgZHJtX2NydGMgKmNydGMsCiAJCQkgIGh3X2Vu dHJ5LT5zdGFydCwgaHdfZW50cnktPmVuZCk7CiAJfQogCi0JLyogY3Vyc29yICovCi0JaHdfZW50 cnkgPSAmaHdfZGRiLnBsYW5lW3BpcGVdW1BMQU5FX0NVUlNPUl07Ci0Jc3dfZW50cnkgPSAmc3df ZGRiLT5wbGFuZVtwaXBlXVtQTEFORV9DVVJTT1JdOwotCi0JaWYgKCFza2xfZGRiX2VudHJ5X2Vx dWFsKGh3X2VudHJ5LCBzd19lbnRyeSkpIHsKLQkJRFJNX0VSUk9SKCJtaXNtYXRjaCBpbiBEREIg c3RhdGUgcGlwZSAlYyBjdXJzb3IgIgotCQkJICAiKGV4cGVjdGVkICgldSwldSksIGZvdW5kICgl dSwldSkpXG4iLAotCQkJICBwaXBlX25hbWUocGlwZSksCi0JCQkgIHN3X2VudHJ5LT5zdGFydCwg c3dfZW50cnktPmVuZCwKLQkJCSAgaHdfZW50cnktPnN0YXJ0LCBod19lbnRyeS0+ZW5kKTsKKwkv KgorCSAqIGN1cnNvcgorCSAqIElmIHRoZSBjdXJzb3IgcGxhbmUgaXNuJ3QgYWN0aXZlLCB3ZSBt YXkgbm90IGhhdmUgdXBkYXRlZCBpdCdzIGRkYgorCSAqIGFsbG9jYXRpb24uIEluIHRoYXQgY2Fz ZSBzaW5jZSB0aGUgZGRiIGFsbG9jYXRpb24gd2lsbCBiZSB1cGRhdGVkCisJICogb25jZSB0aGUg cGxhbmUgYmVjb21lcyB2aXNpYmxlLCB3ZSBjYW4gc2tpcCB0aGlzIGNoZWNrCisJICovCisJaWYg KGludGVsX2NydGMtPmN1cnNvcl9hZGRyKSB7CisJCWh3X2VudHJ5ID0gJmh3X2RkYi5wbGFuZVtw aXBlXVtQTEFORV9DVVJTT1JdOworCQlzd19lbnRyeSA9ICZzd19kZGItPnBsYW5lW3BpcGVdW1BM QU5FX0NVUlNPUl07CisKKwkJaWYgKCFza2xfZGRiX2VudHJ5X2VxdWFsKGh3X2VudHJ5LCBzd19l bnRyeSkpIHsKKwkJCURSTV9FUlJPUigibWlzbWF0Y2ggaW4gRERCIHN0YXRlIHBpcGUgJWMgY3Vy c29yICIKKwkJCQkgICIoZXhwZWN0ZWQgKCV1LCV1KSwgZm91bmQgKCV1LCV1KSlcbiIsCisJCQkJ ICBwaXBlX25hbWUocGlwZSksCisJCQkJICBzd19lbnRyeS0+c3RhcnQsIHN3X2VudHJ5LT5lbmQs CisJCQkJICBod19lbnRyeS0+c3RhcnQsIGh3X2VudHJ5LT5lbmQpOworCQl9CiAJfQogfQogCkBA IC0xNDEyMiw2ICsxNDEyOSw2NSBAQCBzdGF0aWMgdm9pZCBpbnRlbF91cGRhdGVfY3J0Y3Moc3Ry dWN0IGRybV9hdG9taWNfc3RhdGUgKnN0YXRlLAogCX0KIH0KIAorc3RhdGljIHZvaWQgc2tsX3Vw ZGF0ZV9jcnRjcyhzdHJ1Y3QgZHJtX2F0b21pY19zdGF0ZSAqc3RhdGUsCisJCQkgICAgIHVuc2ln bmVkIGludCAqY3J0Y192YmxhbmtfbWFzaykKK3sKKwlzdHJ1Y3QgZHJtX2RldmljZSAqZGV2ID0g c3RhdGUtPmRldjsKKwlzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqZGV2X3ByaXYgPSB0b19pOTE1 KGRldik7CisJc3RydWN0IGludGVsX2F0b21pY19zdGF0ZSAqaW50ZWxfc3RhdGUgPSB0b19pbnRl bF9hdG9taWNfc3RhdGUoc3RhdGUpOworCXN0cnVjdCBkcm1fY3J0YyAqY3J0YzsKKwlzdHJ1Y3Qg ZHJtX2NydGNfc3RhdGUgKm9sZF9jcnRjX3N0YXRlOworCXN0cnVjdCBza2xfZGRiX2FsbG9jYXRp b24gKm5ld19kZGIgPSAmaW50ZWxfc3RhdGUtPndtX3Jlc3VsdHMuZGRiOworCXN0cnVjdCBza2xf ZGRiX2FsbG9jYXRpb24gKmN1cl9kZGIgPSAmZGV2X3ByaXYtPndtLnNrbF9ody5kZGI7CisJdW5z aWduZWQgaW50IHVwZGF0ZWQgPSAwOworCWJvb2wgcHJvZ3Jlc3M7CisJZW51bSBwaXBlIHBpcGU7 CisKKwkvKgorCSAqIFdoZW5ldmVyIHRoZSBudW1iZXIgb2YgYWN0aXZlIHBpcGVzIGNoYW5nZXMs IHdlIG5lZWQgdG8gbWFrZSBzdXJlIHdlIAorCSAqIHVwZGF0ZSB0aGUgcGlwZXMgaW4gdGhlIHJp Z2h0IG9yZGVyIHNvIHRoYXQgdGhlaXIgZGRiIGFsbG9jYXRpb25zCisJICogbmV2ZXIgb3Zlcmxh cCB3aXRoIGVhY2hvdGhlciBpbmJldHdlZW4gQ1JUQyB1cGRhdGVzLiBPdGhlcndpc2Ugd2UnbGwK KwkgKiBjYXVzZSBwaXBlIHVuZGVycnVucyBhbmQgb3RoZXIgYmFkIHN0dWZmLgorCSAqLworCWRv IHsKKwkJaW50IGk7CisJCXByb2dyZXNzID0gZmFsc2U7CisKKwkJZm9yX2VhY2hfY3J0Y19pbl9z dGF0ZShzdGF0ZSwgY3J0Yywgb2xkX2NydGNfc3RhdGUsIGkpIHsKKwkJCWJvb2wgdmJsX3dhaXQg PSBmYWxzZTsKKwkJCXVuc2lnbmVkIGludCBjbWFzayA9IGRybV9jcnRjX21hc2soY3J0Yyk7CisJ CQlwaXBlID0gdG9faW50ZWxfY3J0YyhjcnRjKS0+cGlwZTsKKworCQkJaWYgKHVwZGF0ZWQgJiBj bWFzayB8fCAhY3J0Yy0+c3RhdGUtPmFjdGl2ZSkKKwkJCQljb250aW51ZTsKKwkJCWlmIChza2xf ZGRiX2FsbG9jYXRpb25fb3ZlcmxhcHMoc3RhdGUsIGN1cl9kZGIsIG5ld19kZGIsCisJCQkJCQkJ cGlwZSkpCisJCQkJY29udGludWU7CisKKwkJCXVwZGF0ZWQgfD0gY21hc2s7CisKKwkJCS8qCisJ CQkgKiBJZiB0aGlzIGlzIGFuIGFscmVhZHkgYWN0aXZlIHBpcGUsIGl0J3MgRERCIGNoYW5nZWQs CisJCQkgKiBhbmQgdGhpcyBpc24ndCB0aGUgbGFzdCBwaXBlIHRoYXQgbmVlZHMgdXBkYXRpbmcK KwkJCSAqIHRoZW4gd2UgbmVlZCB0byB3YWl0IGZvciBhIHZibGFuayB0byBwYXNzIGZvciB0aGUK KwkJCSAqIG5ldyBkZGIgYWxsb2NhdGlvbiB0byB0YWtlIGVmZmVjdC4KKwkJCSAqLworCQkJaWYg KCFza2xfZGRiX2FsbG9jYXRpb25fZXF1YWxzKGN1cl9kZGIsIG5ld19kZGIsIHBpcGUpICYmCisJ CQkgICAgIWNydGMtPnN0YXRlLT5hY3RpdmVfY2hhbmdlZCAmJgorCQkJICAgIGludGVsX3N0YXRl LT53bV9yZXN1bHRzLmRpcnR5X3BpcGVzICE9IHVwZGF0ZWQpCisJCQkJdmJsX3dhaXQgPSB0cnVl OworCisJCQlpbnRlbF91cGRhdGVfY3J0YyhjcnRjLCBzdGF0ZSwgb2xkX2NydGNfc3RhdGUsCisJ CQkJCSAgY3J0Y192YmxhbmtfbWFzayk7CisKKwkJCWlmICh2Ymxfd2FpdCkKKwkJCQlpbnRlbF93 YWl0X2Zvcl92YmxhbmsoZGV2LCBwaXBlKTsKKworCQkJcHJvZ3Jlc3MgPSB0cnVlOworCQl9CisJ fSB3aGlsZSAocHJvZ3Jlc3MpOworfQorCiBzdGF0aWMgdm9pZCBpbnRlbF9hdG9taWNfY29tbWl0 X3RhaWwoc3RydWN0IGRybV9hdG9taWNfc3RhdGUgKnN0YXRlKQogewogCXN0cnVjdCBkcm1fZGV2 aWNlICpkZXYgPSBzdGF0ZS0+ZGV2OwpAQCAtMTU3NjEsOCArMTU4MjcsNiBAQCB2b2lkIGludGVs X2luaXRfZGlzcGxheV9ob29rcyhzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqZGV2X3ByaXYpCiAJ CWRldl9wcml2LT5kaXNwbGF5LmNydGNfZGlzYWJsZSA9IGk5eHhfY3J0Y19kaXNhYmxlOwogCX0K IAotCWRldl9wcml2LT5kaXNwbGF5LnVwZGF0ZV9jcnRjcyA9IGludGVsX3VwZGF0ZV9jcnRjczsK LQogCS8qIFJldHVybnMgdGhlIGNvcmUgZGlzcGxheSBjbG9jayBzcGVlZCAqLwogCWlmIChJU19T S1lMQUtFKGRldl9wcml2KSB8fCBJU19LQUJZTEFLRShkZXZfcHJpdikpCiAJCWRldl9wcml2LT5k aXNwbGF5LmdldF9kaXNwbGF5X2Nsb2NrX3NwZWVkID0KQEAgLTE1ODUyLDYgKzE1OTE2LDExIEBA IHZvaWQgaW50ZWxfaW5pdF9kaXNwbGF5X2hvb2tzKHN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpk ZXZfcHJpdikKIAkJCXNrbF9tb2Rlc2V0X2NhbGNfY2RjbGs7CiAJfQogCisJaWYgKGRldl9wcml2 LT5pbmZvLmdlbiA+PSA5KQorCQlkZXZfcHJpdi0+ZGlzcGxheS51cGRhdGVfY3J0Y3MgPSBza2xf dXBkYXRlX2NydGNzOworCWVsc2UKKwkJZGV2X3ByaXYtPmRpc3BsYXkudXBkYXRlX2NydGNzID0g aW50ZWxfdXBkYXRlX2NydGNzOworCiAJc3dpdGNoIChJTlRFTF9JTkZPKGRldl9wcml2KS0+Z2Vu KSB7CiAJY2FzZSAyOgogCQlkZXZfcHJpdi0+ZGlzcGxheS5xdWV1ZV9mbGlwID0gaW50ZWxfZ2Vu Ml9xdWV1ZV9mbGlwOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfZHJ2 LmggYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kcnYuaAppbmRleCAxZDMxY2NhLi43YmY4 MjA5IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kcnYuaAorKysgYi9k cml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9kcnYuaApAQCAtMTcyNSw2ICsxNzI1LDEzIEBAIHZv aWQgc2tsX2RkYl9nZXRfaHdfc3RhdGUoc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmRldl9wcml2 LAogYm9vbCBza2xfY2FuX2VuYWJsZV9zYWd2KHN0cnVjdCBkcm1fYXRvbWljX3N0YXRlICpzdGF0 ZSk7CiBpbnQgc2tsX2VuYWJsZV9zYWd2KHN0cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJp dik7CiBpbnQgc2tsX2Rpc2FibGVfc2FndihzdHJ1Y3QgZHJtX2k5MTVfcHJpdmF0ZSAqZGV2X3By aXYpOworYm9vbCBza2xfZGRiX2FsbG9jYXRpb25fZXF1YWxzKGNvbnN0IHN0cnVjdCBza2xfZGRi X2FsbG9jYXRpb24gKm9sZCwKKwkJCSAgICAgICBjb25zdCBzdHJ1Y3Qgc2tsX2RkYl9hbGxvY2F0 aW9uICpuZXcsCisJCQkgICAgICAgZW51bSBwaXBlIHBpcGUpOworYm9vbCBza2xfZGRiX2FsbG9j YXRpb25fb3ZlcmxhcHMoc3RydWN0IGRybV9hdG9taWNfc3RhdGUgKnN0YXRlLAorCQkJCSBjb25z dCBzdHJ1Y3Qgc2tsX2RkYl9hbGxvY2F0aW9uICpvbGQsCisJCQkJIGNvbnN0IHN0cnVjdCBza2xf ZGRiX2FsbG9jYXRpb24gKm5ldywKKwkJCQkgZW51bSBwaXBlIHBpcGUpOwogdm9pZCBza2xfd3Jp dGVfY3Vyc29yX3dtKHN0cnVjdCBpbnRlbF9jcnRjICppbnRlbF9jcnRjLAogCQkJIGNvbnN0IHN0 cnVjdCBza2xfd21fdmFsdWVzICp3bSk7CiB2b2lkIHNrbF93cml0ZV9wbGFuZV93bShzdHJ1Y3Qg aW50ZWxfY3J0YyAqaW50ZWxfY3J0YywKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1 L2ludGVsX3BtLmMgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9pbnRlbF9wbS5jCmluZGV4IGEzZDI0 Y2IuLjU0ZjAxNGMgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2ludGVsX3BtLmMK KysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaW50ZWxfcG0uYwpAQCAtMzg1Myw2ICszODUzLDEx IEBAIHZvaWQgc2tsX3dyaXRlX3BsYW5lX3dtKHN0cnVjdCBpbnRlbF9jcnRjICppbnRlbF9jcnRj LAogCQkJICAgd20tPnBsYW5lW3BpcGVdW3BsYW5lXVtsZXZlbF0pOwogCX0KIAlJOTE1X1dSSVRF KFBMQU5FX1dNX1RSQU5TKHBpcGUsIHBsYW5lKSwgd20tPnBsYW5lX3RyYW5zW3BpcGVdW3BsYW5l XSk7CisKKwlza2xfZGRiX2VudHJ5X3dyaXRlKGRldl9wcml2LCBQTEFORV9CVUZfQ0ZHKHBpcGUs IHBsYW5lKSwKKwkJCSAgICAmd20tPmRkYi5wbGFuZVtwaXBlXVtwbGFuZV0pOworCXNrbF9kZGJf ZW50cnlfd3JpdGUoZGV2X3ByaXYsIFBMQU5FX05WMTJfQlVGX0NGRyhwaXBlLCBwbGFuZSksCisJ CQkgICAgJndtLT5kZGIueV9wbGFuZVtwaXBlXVtwbGFuZV0pOwogfQogCiB2b2lkIHNrbF93cml0 ZV9jdXJzb3Jfd20oc3RydWN0IGludGVsX2NydGMgKmludGVsX2NydGMsCkBAIC0zODY5LDE3MCAr Mzg3NCw0NiBAQCB2b2lkIHNrbF93cml0ZV9jdXJzb3Jfd20oc3RydWN0IGludGVsX2NydGMgKmlu dGVsX2NydGMsCiAJCQkgICB3bS0+cGxhbmVbcGlwZV1bUExBTkVfQ1VSU09SXVtsZXZlbF0pOwog CX0KIAlJOTE1X1dSSVRFKENVUl9XTV9UUkFOUyhwaXBlKSwgd20tPnBsYW5lX3RyYW5zW3BpcGVd W1BMQU5FX0NVUlNPUl0pOwotfQotCi1zdGF0aWMgdm9pZCBza2xfd3JpdGVfd21fdmFsdWVzKHN0 cnVjdCBkcm1faTkxNV9wcml2YXRlICpkZXZfcHJpdiwKLQkJCQljb25zdCBzdHJ1Y3Qgc2tsX3dt X3ZhbHVlcyAqbmV3KQotewotCXN0cnVjdCBkcm1fZGV2aWNlICpkZXYgPSAmZGV2X3ByaXYtPmRy bTsKLQlzdHJ1Y3QgaW50ZWxfY3J0YyAqY3J0YzsKLQotCWZvcl9lYWNoX2ludGVsX2NydGMoZGV2 LCBjcnRjKSB7Ci0JCWludCBpOwotCQllbnVtIHBpcGUgcGlwZSA9IGNydGMtPnBpcGU7Ci0KLQkJ aWYgKChuZXctPmRpcnR5X3BpcGVzICYgZHJtX2NydGNfbWFzaygmY3J0Yy0+YmFzZSkpID09IDAp Ci0JCQljb250aW51ZTsKLQkJaWYgKCFjcnRjLT5hY3RpdmUpCi0JCQljb250aW51ZTsKLQotCQlm b3IgKGkgPSAwOyBpIDwgaW50ZWxfbnVtX3BsYW5lcyhjcnRjKTsgaSsrKSB7Ci0JCQlza2xfZGRi X2VudHJ5X3dyaXRlKGRldl9wcml2LAotCQkJCQkgICAgUExBTkVfQlVGX0NGRyhwaXBlLCBpKSwK LQkJCQkJICAgICZuZXctPmRkYi5wbGFuZVtwaXBlXVtpXSk7Ci0JCQlza2xfZGRiX2VudHJ5X3dy aXRlKGRldl9wcml2LAotCQkJCQkgICAgUExBTkVfTlYxMl9CVUZfQ0ZHKHBpcGUsIGkpLAotCQkJ CQkgICAgJm5ldy0+ZGRiLnlfcGxhbmVbcGlwZV1baV0pOwotCQl9CiAKLQkJc2tsX2RkYl9lbnRy eV93cml0ZShkZXZfcHJpdiwgQ1VSX0JVRl9DRkcocGlwZSksCi0JCQkJICAgICZuZXctPmRkYi5w bGFuZVtwaXBlXVtQTEFORV9DVVJTT1JdKTsKLQl9CisJc2tsX2RkYl9lbnRyeV93cml0ZShkZXZf cHJpdiwgQ1VSX0JVRl9DRkcocGlwZSksCisJCQkgICAgJndtLT5kZGIucGxhbmVbcGlwZV1bUExB TkVfQ1VSU09SXSk7CiB9CiAKLS8qCi0gKiBXaGVuIHNldHRpbmcgdXAgYSBuZXcgRERCIGFsbG9j YXRpb24gYXJyYW5nZW1lbnQsIHdlIG5lZWQgdG8gY29ycmVjdGx5Ci0gKiBzZXF1ZW5jZSB0aGUg dGltZXMgYXQgd2hpY2ggdGhlIG5ldyBhbGxvY2F0aW9ucyBmb3IgdGhlIHBpcGVzIGFyZSB0YWtl biBpbnRvCi0gKiBhY2NvdW50IG9yIHdlJ2xsIGhhdmUgcGlwZXMgZmV0Y2hpbmcgZnJvbSBzcGFj ZSBwcmV2aW91c2x5IGFsbG9jYXRlZCB0bwotICogYW5vdGhlciBwaXBlLgotICoKLSAqIFJvdWdo bHkgdGhlIHNlcXVlbmNlIGxvb2tzIGxpa2U6Ci0gKiAgMS4gcmUtYWxsb2NhdGUgdGhlIHBpcGUo cykgd2l0aCB0aGUgYWxsb2NhdGlvbiBiZWluZyByZWR1Y2VkIGFuZCBub3QKLSAqICAgICBvdmVy bGFwcGluZyB3aXRoIGEgcHJldmlvdXMgbGlnaHQtdXAgcGlwZSAoYW5vdGhlciB3YXkgdG8gcHV0 IGl0IGlzOgotICogICAgIHBpcGVzIHdpdGggdGhlaXIgbmV3IGFsbG9jYXRpb24gc3RyaWNrbHkg aW5jbHVkZWQgaW50byB0aGVpciBvbGQgb25lcykuCi0gKiAgMi4gcmUtYWxsb2NhdGUgdGhlIG90 aGVyIHBpcGVzIHRoYXQgZ2V0IHRoZWlyIGFsbG9jYXRpb24gcmVkdWNlZAotICogIDMuIGFsbG9j YXRlIHRoZSBwaXBlcyBoYXZpbmcgdGhlaXIgYWxsb2NhdGlvbiBpbmNyZWFzZWQKLSAqCi0gKiBT dGVwcyAxLiBhbmQgMi4gYXJlIGhlcmUgdG8gdGFrZSBjYXJlIG9mIHRoZSBmb2xsb3dpbmcgY2Fz ZToKLSAqIC0gSW5pdGlhbGx5IEREQiBsb29rcyBsaWtlIHRoaXM6Ci0gKiAgICAgfCAgIEIgICAg fCAgIEMgICAgfAotICogLSBlbmFibGUgcGlwZSBBLgotICogLSBwaXBlIEIgaGFzIGEgcmVkdWNl ZCBEREIgYWxsb2NhdGlvbiB0aGF0IG92ZXJsYXBzIHdpdGggdGhlIG9sZCBwaXBlIEMKLSAqICAg YWxsb2NhdGlvbgotICogICAgIHwgIEEgIHwgIEIgIHwgIEMgIHwKLSAqCi0gKiBXZSBuZWVkIHRv IHNlcXVlbmNlIHRoZSByZS1hbGxvY2F0aW9uOiBDLCBCLCBBIChhbmQgbm90IEIsIEMsIEEpLgot ICovCi0KLXN0YXRpYyB2b2lkCi1za2xfd21fZmx1c2hfcGlwZShzdHJ1Y3QgZHJtX2k5MTVfcHJp dmF0ZSAqZGV2X3ByaXYsIGVudW0gcGlwZSBwaXBlLCBpbnQgcGFzcykKK2Jvb2wgc2tsX2RkYl9h bGxvY2F0aW9uX2VxdWFscyhjb25zdCBzdHJ1Y3Qgc2tsX2RkYl9hbGxvY2F0aW9uICpvbGQsCisJ CQkgICAgICAgY29uc3Qgc3RydWN0IHNrbF9kZGJfYWxsb2NhdGlvbiAqbmV3LAorCQkJICAgICAg IGVudW0gcGlwZSBwaXBlKQogewotCWludCBwbGFuZTsKLQotCURSTV9ERUJVR19LTVMoImZsdXNo IHBpcGUgJWMgKHBhc3MgJWQpXG4iLCBwaXBlX25hbWUocGlwZSksIHBhc3MpOwotCi0JZm9yX2Vh Y2hfcGxhbmUoZGV2X3ByaXYsIHBpcGUsIHBsYW5lKSB7Ci0JCUk5MTVfV1JJVEUoUExBTkVfU1VS RihwaXBlLCBwbGFuZSksCi0JCQkgICBJOTE1X1JFQUQoUExBTkVfU1VSRihwaXBlLCBwbGFuZSkp KTsKLQl9Ci0JSTkxNV9XUklURShDVVJCQVNFKHBpcGUpLCBJOTE1X1JFQUQoQ1VSQkFTRShwaXBl KSkpOworCXJldHVybiBuZXctPnBpcGVbcGlwZV0uc3RhcnQgPT0gb2xkLT5waXBlW3BpcGVdLnN0 YXJ0ICYmCisJICAgICAgIG5ldy0+cGlwZVtwaXBlXS5lbmQgPT0gb2xkLT5waXBlW3BpcGVdLmVu ZDsKIH0KIAotc3RhdGljIGJvb2wKLXNrbF9kZGJfYWxsb2NhdGlvbl9pbmNsdWRlZChjb25zdCBz dHJ1Y3Qgc2tsX2RkYl9hbGxvY2F0aW9uICpvbGQsCi0JCQkgICAgY29uc3Qgc3RydWN0IHNrbF9k ZGJfYWxsb2NhdGlvbiAqbmV3LAotCQkJICAgIGVudW0gcGlwZSBwaXBlKQorc3RhdGljIGlubGlu ZSBib29sIHNrbF9kZGJfZW50cmllc19vdmVybGFwKGNvbnN0IHN0cnVjdCBza2xfZGRiX2VudHJ5 ICphLAorCQkJCQkgICBjb25zdCBzdHJ1Y3Qgc2tsX2RkYl9lbnRyeSAqYikKIHsKLQl1aW50MTZf dCBvbGRfc2l6ZSwgbmV3X3NpemU7Ci0KLQlvbGRfc2l6ZSA9IHNrbF9kZGJfZW50cnlfc2l6ZSgm b2xkLT5waXBlW3BpcGVdKTsKLQluZXdfc2l6ZSA9IHNrbF9kZGJfZW50cnlfc2l6ZSgmbmV3LT5w aXBlW3BpcGVdKTsKLQotCXJldHVybiBvbGRfc2l6ZSAhPSBuZXdfc2l6ZSAmJgotCSAgICAgICBu ZXctPnBpcGVbcGlwZV0uc3RhcnQgPj0gb2xkLT5waXBlW3BpcGVdLnN0YXJ0ICYmCi0JICAgICAg IG5ldy0+cGlwZVtwaXBlXS5lbmQgPD0gb2xkLT5waXBlW3BpcGVdLmVuZDsKKwlyZXR1cm4gYS0+ c3RhcnQgPCBiLT5lbmQgJiYgYi0+c3RhcnQgPCBhLT5lbmQ7CiB9CiAKLXN0YXRpYyB2b2lkIHNr bF9mbHVzaF93bV92YWx1ZXMoc3RydWN0IGRybV9pOTE1X3ByaXZhdGUgKmRldl9wcml2LAotCQkJ CXN0cnVjdCBza2xfd21fdmFsdWVzICpuZXdfdmFsdWVzKQorYm9vbCBza2xfZGRiX2FsbG9jYXRp b25fb3ZlcmxhcHMoc3RydWN0IGRybV9hdG9taWNfc3RhdGUgKnN0YXRlLAorCQkJCSBjb25zdCBz dHJ1Y3Qgc2tsX2RkYl9hbGxvY2F0aW9uICpvbGQsCisJCQkJIGNvbnN0IHN0cnVjdCBza2xfZGRi X2FsbG9jYXRpb24gKm5ldywKKwkJCQkgZW51bSBwaXBlIHBpcGUpCiB7Ci0Jc3RydWN0IGRybV9k ZXZpY2UgKmRldiA9ICZkZXZfcHJpdi0+ZHJtOwotCXN0cnVjdCBza2xfZGRiX2FsbG9jYXRpb24g KmN1cl9kZGIsICpuZXdfZGRiOwotCWJvb2wgcmVhbGxvY2F0ZWRbSTkxNV9NQVhfUElQRVNdID0g e307Ci0Jc3RydWN0IGludGVsX2NydGMgKmNydGM7Ci0JZW51bSBwaXBlIHBpcGU7Ci0KLQluZXdf ZGRiID0gJm5ld192YWx1ZXMtPmRkYjsKLQljdXJfZGRiID0gJmRldl9wcml2LT53bS5za2xfaHcu ZGRiOwotCi0JLyoKLQkgKiBGaXJzdCBwYXNzOiBmbHVzaCB0aGUgcGlwZXMgd2l0aCB0aGUgbmV3 IGFsbG9jYXRpb24gY29udGFpbmVkIGludG8KLQkgKiB0aGUgb2xkIHNwYWNlLgotCSAqCi0JICog V2UnbGwgd2FpdCBmb3IgdGhlIHZibGFuayBvbiB0aG9zZSBwaXBlcyB0byBlbnN1cmUgd2UgY2Fu IHNhZmVseQotCSAqIHJlLWFsbG9jYXRlIHRoZSBmcmVlZCBzcGFjZSB3aXRob3V0IHRoaXMgcGlw ZSBmZXRjaGluZyBmcm9tIGl0LgotCSAqLwotCWZvcl9lYWNoX2ludGVsX2NydGMoZGV2LCBjcnRj KSB7Ci0JCWlmICghY3J0Yy0+YWN0aXZlKQotCQkJY29udGludWU7Ci0KLQkJcGlwZSA9IGNydGMt PnBpcGU7Ci0KLQkJaWYgKCFza2xfZGRiX2FsbG9jYXRpb25faW5jbHVkZWQoY3VyX2RkYiwgbmV3 X2RkYiwgcGlwZSkpCi0JCQljb250aW51ZTsKLQotCQlza2xfd21fZmx1c2hfcGlwZShkZXZfcHJp diwgcGlwZSwgMSk7Ci0JCWludGVsX3dhaXRfZm9yX3ZibGFuayhkZXYsIHBpcGUpOwotCi0JCXJl YWxsb2NhdGVkW3BpcGVdID0gdHJ1ZTsKLQl9Ci0KLQotCS8qCi0JICogU2Vjb25kIHBhc3M6IGZs dXNoIHRoZSBwaXBlcyB0aGF0IGFyZSBoYXZpbmcgdGhlaXIgYWxsb2NhdGlvbgotCSAqIHJlZHVj ZWQsIGJ1dCBvdmVybGFwcGluZyB3aXRoIGEgcHJldmlvdXMgYWxsb2NhdGlvbi4KLQkgKgotCSAq IEhlcmUgYXMgd2VsbCB3ZSBuZWVkIHRvIHdhaXQgZm9yIHRoZSB2YmxhbmsgdG8gbWFrZSBzdXJl IHRoZSBmcmVlZAotCSAqIHNwYWNlIGlzIG5vdCB1c2VkIGFueW1vcmUuCi0JICovCi0JZm9yX2Vh Y2hfaW50ZWxfY3J0YyhkZXYsIGNydGMpIHsKLQkJaWYgKCFjcnRjLT5hY3RpdmUpCi0JCQljb250 aW51ZTsKKwlzdHJ1Y3QgZHJtX2RldmljZSAqZGV2ID0gc3RhdGUtPmRldjsKKwlzdHJ1Y3QgaW50 ZWxfY3J0YyAqaW50ZWxfY3J0YzsKKwllbnVtIHBpcGUgb3RoZXJwOwogCi0JCXBpcGUgPSBjcnRj LT5waXBlOworCWZvcl9lYWNoX2ludGVsX2NydGMoZGV2LCBpbnRlbF9jcnRjKSB7CisJCW90aGVy cCA9IGludGVsX2NydGMtPnBpcGU7CiAKLQkJaWYgKHJlYWxsb2NhdGVkW3BpcGVdKQorCQlpZiAo b3RoZXJwID09IHBpcGUpCiAJCQljb250aW51ZTsKIAotCQlpZiAoc2tsX2RkYl9lbnRyeV9zaXpl KCZuZXdfZGRiLT5waXBlW3BpcGVdKSA8Ci0JCSAgICBza2xfZGRiX2VudHJ5X3NpemUoJmN1cl9k ZGItPnBpcGVbcGlwZV0pKSB7Ci0JCQlza2xfd21fZmx1c2hfcGlwZShkZXZfcHJpdiwgcGlwZSwg Mik7Ci0JCQlpbnRlbF93YWl0X2Zvcl92YmxhbmsoZGV2LCBwaXBlKTsKLQkJCXJlYWxsb2NhdGVk W3BpcGVdID0gdHJ1ZTsKLQkJfQorCQlpZiAoc2tsX2RkYl9lbnRyaWVzX292ZXJsYXAoJm5ldy0+ cGlwZVtwaXBlXSwKKwkJCQkJICAgICZvbGQtPnBpcGVbb3RoZXJwXSkpCisJCQlyZXR1cm4gdHJ1 ZTsKIAl9CiAKLQkvKgotCSAqIFRoaXJkIHBhc3M6IGZsdXNoIHRoZSBwaXBlcyB0aGF0IGdvdCBt b3JlIHNwYWNlIGFsbG9jYXRlZC4KLQkgKgotCSAqIFdlIGRvbid0IG5lZWQgdG8gYWN0aXZlbHkg d2FpdCBmb3IgdGhlIHVwZGF0ZSBoZXJlLCBuZXh0IHZibGFuawotCSAqIHdpbGwganVzdCBnZXQg bW9yZSBEREIgc3BhY2Ugd2l0aCB0aGUgY29ycmVjdCBXTSB2YWx1ZXMuCi0JICovCi0JZm9yX2Vh Y2hfaW50ZWxfY3J0YyhkZXYsIGNydGMpIHsKLQkJaWYgKCFjcnRjLT5hY3RpdmUpCi0JCQljb250 aW51ZTsKLQotCQlwaXBlID0gY3J0Yy0+cGlwZTsKLQotCQkvKgotCQkgKiBBdCB0aGlzIHBvaW50 LCBvbmx5IHRoZSBwaXBlcyBtb3JlIHNwYWNlIHRoYW4gYmVmb3JlIGFyZQotCQkgKiBsZWZ0IHRv IHJlLWFsbG9jYXRlLgotCQkgKi8KLQkJaWYgKHJlYWxsb2NhdGVkW3BpcGVdKQotCQkJY29udGlu dWU7Ci0KLQkJc2tsX3dtX2ZsdXNoX3BpcGUoZGV2X3ByaXYsIHBpcGUsIDMpOwotCX0KKwlyZXR1 cm4gZmFsc2U7CiB9CiAKIHN0YXRpYyBpbnQgc2tsX3VwZGF0ZV9waXBlX3dtKHN0cnVjdCBkcm1f Y3J0Y19zdGF0ZSAqY3N0YXRlLApAQCAtNDIxOSw3ICs0MTAwLDcgQEAgc3RhdGljIHZvaWQgc2ts X3VwZGF0ZV93bShzdHJ1Y3QgZHJtX2NydGMgKmNydGMpCiAJc3RydWN0IHNrbF93bV92YWx1ZXMg Kmh3X3ZhbHMgPSAmZGV2X3ByaXYtPndtLnNrbF9odzsKIAlzdHJ1Y3QgaW50ZWxfY3J0Y19zdGF0 ZSAqY3N0YXRlID0gdG9faW50ZWxfY3J0Y19zdGF0ZShjcnRjLT5zdGF0ZSk7CiAJc3RydWN0IHNr bF9waXBlX3dtICpwaXBlX3dtID0gJmNzdGF0ZS0+d20uc2tsLm9wdGltYWw7Ci0JaW50IHBpcGU7 CisJZW51bSBwaXBlIHBpcGUgPSBpbnRlbF9jcnRjLT5waXBlOwogCiAJaWYgKChyZXN1bHRzLT5k aXJ0eV9waXBlcyAmIGRybV9jcnRjX21hc2soY3J0YykpID09IDApCiAJCXJldHVybjsKQEAgLTQy MjgsMTUgKzQxMDksMjIgQEAgc3RhdGljIHZvaWQgc2tsX3VwZGF0ZV93bShzdHJ1Y3QgZHJtX2Ny dGMgKmNydGMpCiAKIAltdXRleF9sb2NrKCZkZXZfcHJpdi0+d20ud21fbXV0ZXgpOwogCi0Jc2ts X3dyaXRlX3dtX3ZhbHVlcyhkZXZfcHJpdiwgcmVzdWx0cyk7Ci0Jc2tsX2ZsdXNoX3dtX3ZhbHVl cyhkZXZfcHJpdiwgcmVzdWx0cyk7Ci0KIAkvKgotCSAqIFN0b3JlIHRoZSBuZXcgY29uZmlndXJh dGlvbiAoYnV0IG9ubHkgZm9yIHRoZSBwaXBlcyB0aGF0IGhhdmUKLQkgKiBjaGFuZ2VkOyB0aGUg b3RoZXIgdmFsdWVzIHdlcmVuJ3QgcmVjb21wdXRlZCkuCisJICogSWYgdGhpcyBwaXBlIGlzbid0 IGFjdGl2ZSBhbHJlYWR5LCB3ZSdyZSBnb2luZyB0byBiZSBlbmFibGluZyBpdAorCSAqIHZlcnkg c29vbi4gU2luY2UgaXQncyBzYWZlIHRvIHVwZGF0ZSBhIHBpcGUncyBkZGIgYWxsb2NhdGlvbiB3 aGlsZQorCSAqIHRoZSBwaXBlJ3Mgc2h1dCBvZmYsIGp1c3QgZG8gc28gaGVyZS4gQWxyZWFkeSBh Y3RpdmUgcGlwZXMgd2lsbCBoYXZlCisJICogdGhlaXIgd2F0ZXJtYXJrcyB1cGRhdGVkIG9uY2Ug d2UgdXBkYXRlIHRoZWlyIHBsYW5lcy4KIAkgKi8KLQlmb3JfZWFjaF9waXBlX21hc2tlZChkZXZf cHJpdiwgcGlwZSwgcmVzdWx0cy0+ZGlydHlfcGlwZXMpCi0JCXNrbF9jb3B5X3dtX2Zvcl9waXBl KGh3X3ZhbHMsIHJlc3VsdHMsIHBpcGUpOworCWlmIChjcnRjLT5zdGF0ZS0+YWN0aXZlX2NoYW5n ZWQpIHsKKwkJaW50IHBsYW5lOworCisJCWZvciAocGxhbmUgPSAwOyBwbGFuZSA8IGludGVsX251 bV9wbGFuZXMoaW50ZWxfY3J0Yyk7IHBsYW5lKyspCisJCQlza2xfd3JpdGVfcGxhbmVfd20oaW50 ZWxfY3J0YywgcmVzdWx0cywgcGxhbmUpOworCisJCXNrbF93cml0ZV9jdXJzb3Jfd20oaW50ZWxf Y3J0YywgcmVzdWx0cyk7CisJfQorCisJc2tsX2NvcHlfd21fZm9yX3BpcGUoaHdfdmFscywgcmVz dWx0cywgcGlwZSk7CiAKIAltdXRleF91bmxvY2soJmRldl9wcml2LT53bS53bV9tdXRleCk7CiB9 Ci0tIAoyLjcuNAoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X18KZHJpLWRldmVsIG1haWxpbmcgbGlzdApkcmktZGV2ZWxAbGlzdHMuZnJlZWRlc2t0b3Aub3Jn Cmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGluZm8vZHJpLWRldmVs Cg==