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.7 required=3.0 tests=DKIM_SIGNED,DKIM_VALID, DKIM_VALID_AU,FREEMAIL_FORGED_FROMDOMAIN,FREEMAIL_FROM, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY, SPF_HELO_NONE,SPF_PASS,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 7737BC43215 for ; Mon, 18 Nov 2019 20:06:04 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id 37B192230F for ; Mon, 18 Nov 2019 20:06:04 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="uh1visuS" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727435AbfKRUGC (ORCPT ); Mon, 18 Nov 2019 15:06:02 -0500 Received: from mail-lj1-f196.google.com ([209.85.208.196]:44391 "EHLO mail-lj1-f196.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727395AbfKRUGB (ORCPT ); Mon, 18 Nov 2019 15:06:01 -0500 Received: by mail-lj1-f196.google.com with SMTP id g3so20410755ljl.11; Mon, 18 Nov 2019 12:05:57 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=nuz1BcEYsck8xXvuAx6no465QzG7OGwvJ3sC9jHo7/Y=; b=uh1visuScvodNh0T8pHBqf2GB2+HNTFTQhIPhDeLDok+7qBEvrWAAtnI/A1CAaLpl9 5FFdbEfyBubZFVgpmhJmFAtN5ZLyl1/jLAplsfXd3TxVyvwtrkbZ7aOl5iOKk70S1qZH L6t8faaBy+8iBwgHyQ+JXhs0q5PH+1qU9sA3dk4IP1yhF2pPxv7UMkdqprSh2TH+eFED EAwMXoziIq6fPfpJfJBvoDA5Xa3JQFdS6/ZfBjYf3mAwz73qHRIs5DtxNfo1Ippb5ZEZ qKOD1urA2W0hEjrH6kgemlQLkm1z50WScTg4p49NVoNUfZ7Lx1UbdOLTCy1/N3lgzPvM 770A== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=nuz1BcEYsck8xXvuAx6no465QzG7OGwvJ3sC9jHo7/Y=; b=NBP/KPFjcOwEQdlNntcZ0ClqtVUl0StxNnSZDi8sVFgKAmURKzpAhG3f6tf0BF3kl0 zOEVjf4ltyhWFdl6X1GeY8vyvbKr2eGanGwzO29vNhQhgsQD3zOJX8HgkCIb58GHrU1I 9tga6iWxNCrvn0PnV78kNcDee7wJ2QUxZbVP+az2vFQOmYvWsJZMY2VgyZynLp9P6kiJ cBMgi7zRaskKQNQ2XkML9slhKxZTYw5W/58S6yk/ZD2bxPLFV1TDPS9X9+BV+mZYXTga ZDfbTWbX4YM3pnbhcqQgh+h0kgqYpsepIcYvyey1mfgTHJmTNeo4Oh70WFWm3LAHcKZJ aPVg== X-Gm-Message-State: APjAAAU77xxtZPignZsYKMvH5zhO0nw2T9iAlKYpqtnGGa0JLkLTTphk eNZstnPAnI3GGYUD2CM7k8M= X-Google-Smtp-Source: APXvYqyhYhJ7ztyMovZ1MiQtwkAscCbe0gkfGOrZ6XqzJMvebaMVZfQSkKVE5yVPpf0nfopJV71yWw== X-Received: by 2002:a2e:9256:: with SMTP id v22mr898223ljg.124.1574107556687; Mon, 18 Nov 2019 12:05:56 -0800 (PST) Received: from localhost.localdomain (79-139-233-37.dynamic.spd-mgts.ru. [79.139.233.37]) by smtp.gmail.com with ESMTPSA id j23sm9166942lji.41.2019.11.18.12.05.55 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 18 Nov 2019 12:05:56 -0800 (PST) From: Dmitry Osipenko To: Thierry Reding , Jonathan Hunter , Peter De Schrijver , Mikko Perttunen , Georgi Djakov , Rob Herring Cc: linux-tegra@vger.kernel.org, linux-pm@vger.kernel.org, linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, devicetree@vger.kernel.org Subject: [PATCH v1 26/29] drm/tegra: dc: Support memory bandwidth management Date: Mon, 18 Nov 2019 23:02:44 +0300 Message-Id: <20191118200247.3567-27-digetx@gmail.com> X-Mailer: git-send-email 2.23.0 In-Reply-To: <20191118200247.3567-1-digetx@gmail.com> References: <20191118200247.3567-1-digetx@gmail.com> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit Sender: linux-pm-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-pm@vger.kernel.org Display controller (DC) performs isochronous memory transfers and thus has a requirement for a minimum memory bandwidth that shall be fulfilled, otherwise framebuffer data can't be fetched fast enough and this results in a DC's data-FIFO underflow that follows by a visual corruption. The External Memory Controller drivers provide facility for memory bandwidth management via interconnect API. This patch wires up the interconnect API support to the DC driver. Signed-off-by: Dmitry Osipenko --- drivers/gpu/drm/tegra/dc.c | 240 +++++++++++++++++++++++++++++++++- drivers/gpu/drm/tegra/dc.h | 8 ++ drivers/gpu/drm/tegra/drm.c | 18 +++ drivers/gpu/drm/tegra/plane.c | 1 + drivers/gpu/drm/tegra/plane.h | 4 +- 5 files changed, 269 insertions(+), 2 deletions(-) diff --git a/drivers/gpu/drm/tegra/dc.c b/drivers/gpu/drm/tegra/dc.c index c2c61156cdcf..c60a0c00d95f 100644 --- a/drivers/gpu/drm/tegra/dc.c +++ b/drivers/gpu/drm/tegra/dc.c @@ -519,6 +519,122 @@ static void tegra_dc_setup_window(struct tegra_plane *plane, tegra_plane_setup_blending(plane, window); } +static unsigned long +tegra_plane_memory_bandwidth(struct drm_plane_state *state, + struct tegra_dc_window *window) +{ + struct tegra_plane_state *tegra_state; + struct drm_crtc_state *crtc_state; + const struct drm_format_info *fmt; + struct tegra_dc_window win; + unsigned int bpp_plane; + unsigned int bpp; + unsigned int mul; + unsigned int i; + + if (!state->fb || !state->visible) + return 0; + + crtc_state = drm_atomic_get_new_crtc_state(state->state, state->crtc); + tegra_state = to_tegra_plane_state(state); + + if (!window) + window = &win; + + window->src.w = drm_rect_width(&state->src) >> 16; + window->src.h = drm_rect_height(&state->src) >> 16; + window->dst.w = drm_rect_width(&state->dst); + window->dst.h = drm_rect_height(&state->dst); + window->tiling = tegra_state->tiling; + + fmt = state->fb->format; + + /* + * Note that real memory bandwidth vary depending on format and + * memory layout, we are not taking that into account because small + * estimation error isn't important since bandwidth is rounded up + * anyway. + */ + for (i = 0, bpp = 0; i < fmt->num_planes; i++) { + bpp_plane = fmt->cpp[i] * 8; + + /* + * Sub-sampling is relevant for chroma planes only and vertical + * readouts are not cached, hence only horizontal sub-sampling + * matters. + */ + if (i > 0) + bpp_plane /= fmt->hsub; + + bpp += bpp_plane; + } + + /* + * Horizontal downscale takes extra bandwidth which roughly depends + * on the scaled width. + */ + if (window->src.w > window->dst.w) + mul = (window->src.w - window->dst.w) * bpp / 2048 + 1; + else + mul = 1; + + /* + * Ignore window if its width is small enough such that data-prefetch + * FIFO will easily help to overcome temporal memory pressure. This is + * a typical case for the cursor's plane. + */ + if (mul == 1 && window->src.w * bpp <= 2048) + return 0; + + /* mode.clock in kHz, bandwidth in kbit/s */ + return kbps_to_icc(crtc_state->mode.clock * bpp * mul); +} + +static unsigned long +tegra20_plane_memory_bandwidth(struct drm_plane_state *state) +{ + /* ~35% efficiency */ + return tegra_plane_memory_bandwidth(state, NULL) * 29 / 10; +} + +static unsigned long +tegra30_plane_memory_bandwidth(struct drm_plane_state *state) +{ + struct tegra_dc_window window; + unsigned long bandwidth; + + bandwidth = tegra_plane_memory_bandwidth(state, &window); + + /* x2: memory overfetch for tiled framebuffer and DDR3 */ + if (window.tiling.mode == TEGRA_BO_TILING_MODE_TILED) + bandwidth *= 2; + + /* ~35% efficiency */ + return bandwidth * 29 / 10; +} + +static unsigned long +tegra114_plane_memory_bandwidth(struct drm_plane_state *state) +{ + struct tegra_dc_window window; + unsigned long bandwidth; + + bandwidth = tegra_plane_memory_bandwidth(state, &window); + + /* x2: memory overfetch for tiled framebuffer and DDR3 */ + if (window.tiling.mode == TEGRA_BO_TILING_MODE_TILED) + bandwidth *= 2; + + return bandwidth; +} + +static unsigned long +tegra124_plane_memory_bandwidth(struct drm_plane_state *state) +{ + /* 64bit memory bus */ + return tegra_plane_memory_bandwidth(state, NULL); +} + static const u32 tegra20_primary_formats[] = { DRM_FORMAT_ARGB4444, DRM_FORMAT_ARGB1555, @@ -608,8 +724,10 @@ static int tegra_plane_atomic_check(struct drm_plane *plane, int err; /* no need for further checks if the plane is being disabled */ - if (!state->crtc) + if (!state->crtc) { + plane_state->memory_bandwidth = 0; return 0; + } err = tegra_plane_format(state->fb->format->format, &plane_state->format, @@ -662,6 +780,8 @@ static int tegra_plane_atomic_check(struct drm_plane *plane, if (err < 0) return err; + plane_state->memory_bandwidth = dc->soc->plane_memory_bandwidth(state); + return 0; } @@ -1186,6 +1306,7 @@ tegra_crtc_atomic_duplicate_state(struct drm_crtc *crtc) copy->pclk = state->pclk; copy->div = state->div; copy->planes = state->planes; + copy->memory_bandwidth = state->memory_bandwidth; return ©->base; } @@ -1774,6 +1895,8 @@ static void tegra_crtc_atomic_disable(struct drm_crtc *crtc, spin_unlock_irq(&crtc->dev->event_lock); pm_runtime_put_sync(dc->dev); + + icc_set_bw(dc->icc, 0, 0); } static void tegra_crtc_atomic_enable(struct drm_crtc *crtc, @@ -1784,6 +1907,8 @@ static void tegra_crtc_atomic_enable(struct drm_crtc *crtc, struct tegra_dc *dc = to_tegra_dc(crtc); u32 value; + icc_set_bw(dc->icc, state->memory_bandwidth, state->memory_bandwidth); + pm_runtime_get_sync(dc->dev); /* initialize display controller */ @@ -1893,6 +2018,9 @@ static void tegra_crtc_atomic_enable(struct drm_crtc *crtc, static void tegra_crtc_atomic_begin(struct drm_crtc *crtc, struct drm_crtc_state *old_crtc_state) { + struct tegra_dc_state *dc_old_state = to_dc_state(old_crtc_state); + struct tegra_dc_state *dc_state = to_dc_state(crtc->state); + struct tegra_dc *dc = to_tegra_dc(crtc); unsigned long flags; if (crtc->state->event) { @@ -1907,6 +2035,25 @@ static void tegra_crtc_atomic_begin(struct drm_crtc *crtc, crtc->state->event = NULL; } + + if (old_crtc_state && old_crtc_state->active) { + /* + * Raise memory bandwidth before changes take effect if it + * goes from low to high. + */ + if (dc_old_state->memory_bandwidth < dc_state->memory_bandwidth) + icc_set_bw(dc->icc, + dc_state->memory_bandwidth, + dc_state->memory_bandwidth); + } else { + /* + * Raise memory bandwidth before changes take effect if + * CRTC is turning on. + */ + icc_set_bw(dc->icc, + dc_state->memory_bandwidth, + dc_state->memory_bandwidth); + } } static void tegra_crtc_atomic_flush(struct drm_crtc *crtc, @@ -1925,7 +2072,79 @@ static void tegra_crtc_atomic_flush(struct drm_crtc *crtc, value = tegra_dc_readl(dc, DC_CMD_STATE_CONTROL); } +static bool +tegra_plane_intersects_with_other_plane(struct drm_crtc_state *state, + const struct drm_plane_state *plane_state) +{ + const struct drm_plane_state *other_state; + struct drm_plane *plane; + struct drm_rect rect; + + drm_atomic_crtc_state_for_each_plane_state(plane, other_state, state) { + rect = plane_state->dst; + + if (other_state == plane_state) + continue; + + if (!other_state->visible || !other_state->fb) + continue; + + if (drm_rect_intersect(&rect, &other_state->dst)) + return true; + } + + return false; +} + +static int tegra_crtc_atomic_check(struct drm_crtc *crtc, + struct drm_crtc_state *state) +{ + struct tegra_dc_state *dc_state = to_dc_state(state); + const struct drm_plane_state *plane_state; + const struct tegra_plane_state *tegra; + unsigned long long bandwidth = 0; + struct drm_plane *plane; + + /* + * For overlapping planes pixel's data is fetched for each plane at + * the same time, hence bandwidth is accumulated in this case. + */ + drm_atomic_crtc_state_for_each_plane_state(plane, plane_state, state) { + tegra = to_tegra_plane_state(plane_state); + + if (tegra_plane_intersects_with_other_plane(state, plane_state)) + bandwidth += tegra->memory_bandwidth; + else + bandwidth = max(bandwidth, (u64)tegra->memory_bandwidth); + } + + dc_state->memory_bandwidth = min(bandwidth, (u64)U32_MAX); + + return 0; +} + +void tegra_crtc_atomic_post_commit(struct drm_crtc *crtc, + struct drm_crtc_state *old_crtc_state) +{ + struct tegra_dc_state *dc_old_state = to_dc_state(old_crtc_state); + struct tegra_dc_state *dc_state = to_dc_state(crtc->state); + struct tegra_dc *dc = to_tegra_dc(crtc); + + if (!dc_old_state) + return; + + /* + * Drop memory bandwidth after changes take effect if it goes from + * high to low. + */ + if (dc_old_state->memory_bandwidth > dc_state->memory_bandwidth) + icc_set_bw(dc->icc, + dc_state->memory_bandwidth, + dc_state->memory_bandwidth); +} + static const struct drm_crtc_helper_funcs tegra_crtc_helper_funcs = { + .atomic_check = tegra_crtc_atomic_check, .atomic_begin = tegra_crtc_atomic_begin, .atomic_flush = tegra_crtc_atomic_flush, .atomic_enable = tegra_crtc_atomic_enable, @@ -2143,6 +2362,7 @@ static const struct tegra_dc_soc_info tegra20_dc_soc_info = { .modifiers = tegra20_modifiers, .has_win_a_without_filters = true, .has_win_c_without_vert_filter = true, + .plane_memory_bandwidth = tegra20_plane_memory_bandwidth, }; static const struct tegra_dc_soc_info tegra30_dc_soc_info = { @@ -2162,6 +2382,7 @@ static const struct tegra_dc_soc_info tegra30_dc_soc_info = { .modifiers = tegra20_modifiers, .has_win_a_without_filters = false, .has_win_c_without_vert_filter = false, + .plane_memory_bandwidth = tegra30_plane_memory_bandwidth, }; static const struct tegra_dc_soc_info tegra114_dc_soc_info = { @@ -2181,6 +2402,7 @@ static const struct tegra_dc_soc_info tegra114_dc_soc_info = { .modifiers = tegra20_modifiers, .has_win_a_without_filters = false, .has_win_c_without_vert_filter = false, + .plane_memory_bandwidth = tegra114_plane_memory_bandwidth, }; static const struct tegra_dc_soc_info tegra124_dc_soc_info = { @@ -2200,6 +2422,7 @@ static const struct tegra_dc_soc_info tegra124_dc_soc_info = { .modifiers = tegra124_modifiers, .has_win_a_without_filters = false, .has_win_c_without_vert_filter = false, + .plane_memory_bandwidth = tegra124_plane_memory_bandwidth, }; static const struct tegra_dc_soc_info tegra210_dc_soc_info = { @@ -2219,6 +2442,7 @@ static const struct tegra_dc_soc_info tegra210_dc_soc_info = { .modifiers = tegra124_modifiers, .has_win_a_without_filters = false, .has_win_c_without_vert_filter = false, + .plane_memory_bandwidth = tegra124_plane_memory_bandwidth, }; static const struct tegra_windowgroup_soc tegra186_dc_wgrps[] = { @@ -2267,6 +2491,7 @@ static const struct tegra_dc_soc_info tegra186_dc_soc_info = { .has_nvdisplay = true, .wgrps = tegra186_dc_wgrps, .num_wgrps = ARRAY_SIZE(tegra186_dc_wgrps), + .plane_memory_bandwidth = tegra124_plane_memory_bandwidth, }; static const struct tegra_windowgroup_soc tegra194_dc_wgrps[] = { @@ -2315,6 +2540,7 @@ static const struct tegra_dc_soc_info tegra194_dc_soc_info = { .has_nvdisplay = true, .wgrps = tegra194_dc_wgrps, .num_wgrps = ARRAY_SIZE(tegra194_dc_wgrps), + .plane_memory_bandwidth = tegra124_plane_memory_bandwidth, }; static const struct of_device_id tegra_dc_of_match[] = { @@ -2493,6 +2719,13 @@ static int tegra_dc_probe(struct platform_device *pdev) return err; } + dc->icc = of_icc_get(dc->dev, "dma-mem"); + err = PTR_ERR_OR_ZERO(dc->icc); + if (err) { + dev_err(dc->dev, "failed to get interconnect: %d\n", err); + goto remove_rgb; + } + platform_set_drvdata(pdev, dc); pm_runtime_enable(&pdev->dev); @@ -2511,6 +2744,9 @@ static int tegra_dc_probe(struct platform_device *pdev) disable_pm: pm_runtime_disable(&pdev->dev); + icc_put(dc->icc); + +remove_rgb: tegra_dc_rgb_remove(dc); return err; @@ -2528,6 +2764,8 @@ static int tegra_dc_remove(struct platform_device *pdev) return err; } + icc_put(dc->icc); + err = tegra_dc_rgb_remove(dc); if (err < 0) { dev_err(&pdev->dev, "failed to remove RGB output: %d\n", err); diff --git a/drivers/gpu/drm/tegra/dc.h b/drivers/gpu/drm/tegra/dc.h index 3d8ddccd758f..629b379a8207 100644 --- a/drivers/gpu/drm/tegra/dc.h +++ b/drivers/gpu/drm/tegra/dc.h @@ -8,6 +8,7 @@ #define TEGRA_DC_H 1 #include +#include #include @@ -23,6 +24,8 @@ struct tegra_dc_state { unsigned int div; u32 planes; + + unsigned long memory_bandwidth; }; static inline struct tegra_dc_state *to_dc_state(struct drm_crtc_state *state) @@ -66,6 +69,7 @@ struct tegra_dc_soc_info { const u64 *modifiers; bool has_win_a_without_filters; bool has_win_c_without_vert_filter; + unsigned long (*plane_memory_bandwidth)(struct drm_plane_state *state); }; struct tegra_dc { @@ -90,6 +94,8 @@ struct tegra_dc { struct drm_info_list *debugfs_files; const struct tegra_dc_soc_info *soc; + + struct icc_path *icc; }; static inline struct tegra_dc * @@ -150,6 +156,8 @@ int tegra_dc_state_setup_clock(struct tegra_dc *dc, struct drm_crtc_state *crtc_state, struct clk *clk, unsigned long pclk, unsigned int div); +void tegra_crtc_atomic_post_commit(struct drm_crtc *crtc, + struct drm_crtc_state *old_crtc_state); /* from rgb.c */ int tegra_dc_rgb_probe(struct tegra_dc *dc); diff --git a/drivers/gpu/drm/tegra/drm.c b/drivers/gpu/drm/tegra/drm.c index 56e5e7a5c108..ccce91ea7180 100644 --- a/drivers/gpu/drm/tegra/drm.c +++ b/drivers/gpu/drm/tegra/drm.c @@ -20,6 +20,7 @@ #include #include +#include "dc.h" #include "drm.h" #include "gem.h" @@ -59,6 +60,21 @@ static const struct drm_mode_config_funcs tegra_drm_mode_config_funcs = { .atomic_commit = drm_atomic_helper_commit, }; +static void tegra_atomic_post_commit(struct drm_device *drm, + struct drm_atomic_state *old_state) +{ + struct drm_crtc_state *old_crtc_state, *new_crtc_state; + struct drm_crtc *crtc; + int i; + + for_each_oldnew_crtc_in_state(old_state, crtc, old_crtc_state, new_crtc_state, i) { + if (!new_crtc_state->active) + continue; + + tegra_crtc_atomic_post_commit(crtc, old_crtc_state); + } +} + static void tegra_atomic_commit_tail(struct drm_atomic_state *old_state) { struct drm_device *drm = old_state->dev; @@ -75,6 +91,8 @@ static void tegra_atomic_commit_tail(struct drm_atomic_state *old_state) } else { drm_atomic_helper_commit_tail_rpm(old_state); } + + tegra_atomic_post_commit(drm, old_state); } static const struct drm_mode_config_helper_funcs diff --git a/drivers/gpu/drm/tegra/plane.c b/drivers/gpu/drm/tegra/plane.c index 163b590be224..1f482e594dc9 100644 --- a/drivers/gpu/drm/tegra/plane.c +++ b/drivers/gpu/drm/tegra/plane.c @@ -61,6 +61,7 @@ tegra_plane_atomic_duplicate_state(struct drm_plane *plane) copy->swap = state->swap; copy->bottom_up = state->bottom_up; copy->opaque = state->opaque; + copy->memory_bandwidth = state->memory_bandwidth; for (i = 0; i < 2; i++) copy->blending[i] = state->blending[i]; diff --git a/drivers/gpu/drm/tegra/plane.h b/drivers/gpu/drm/tegra/plane.h index a158a915109a..5227c7a9ad8b 100644 --- a/drivers/gpu/drm/tegra/plane.h +++ b/drivers/gpu/drm/tegra/plane.h @@ -51,10 +51,12 @@ struct tegra_plane_state { /* used for legacy blending support only */ struct tegra_plane_legacy_blending_state blending[2]; bool opaque; + + unsigned long memory_bandwidth; }; static inline struct tegra_plane_state * -to_tegra_plane_state(struct drm_plane_state *state) +to_tegra_plane_state(const struct drm_plane_state *state) { if (state) return container_of(state, struct tegra_plane_state, base); -- 2.23.0 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.5 required=3.0 tests=DKIM_ADSP_CUSTOM_MED, FREEMAIL_FORGED_FROMDOMAIN,FREEMAIL_FROM,HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS, 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 94FF4C432C0 for ; Tue, 19 Nov 2019 08:06:13 +0000 (UTC) Received: from gabe.freedesktop.org (gabe.freedesktop.org [131.252.210.177]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 70FB9222EF for ; Tue, 19 Nov 2019 08:06:13 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 70FB9222EF Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=gmail.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=dri-devel-bounces@lists.freedesktop.org Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id 887916EBF2; Tue, 19 Nov 2019 08:04:39 +0000 (UTC) Received: from mail-lj1-x244.google.com (mail-lj1-x244.google.com [IPv6:2a00:1450:4864:20::244]) by gabe.freedesktop.org (Postfix) with ESMTPS id 68FB16E829 for ; Mon, 18 Nov 2019 20:05:58 +0000 (UTC) Received: by mail-lj1-x244.google.com with SMTP id m4so15495035ljj.8 for ; Mon, 18 Nov 2019 12:05:58 -0800 (PST) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=nuz1BcEYsck8xXvuAx6no465QzG7OGwvJ3sC9jHo7/Y=; b=O9e2rfNZsM+EqrgXOkNnAmAaVRV+u9aQx31pqROK/VZXd60MDps/6fn8s7qYxeqQ3z 5pFFoMl1u6uZ/mNwJ+dgCzNINtTQNQZgC4z5WW49M9QiI9vugHiO2gJi32hyRMpNsvMZ 3sH7tBCB5CMS1c+prsyOdb3/X7hQ/VtjqYzoVBOU9+5UntbTD4oV9RAYmn8n0NpIV9Zp BHSqxNxS7nELcb83IeXBZckUZNQXFS7sHsKU8ACadf94B/ye1eJqVciHRxsABYvhKmmW leuBDQ16VPhS0qM5kVpXW1fGuU0QCA3Phc6u9XUp+eYmf7d1AmShmArHwFSMMSqPYtXw HOnw== X-Gm-Message-State: APjAAAUIhYjC8Ym4VYAWK2mLaQI9bHQZu420s8yhTB5hr9wYrwH2SQ12 g8z16TKuKMwGOv8gPuu+bow= X-Google-Smtp-Source: APXvYqyhYhJ7ztyMovZ1MiQtwkAscCbe0gkfGOrZ6XqzJMvebaMVZfQSkKVE5yVPpf0nfopJV71yWw== X-Received: by 2002:a2e:9256:: with SMTP id v22mr898223ljg.124.1574107556687; Mon, 18 Nov 2019 12:05:56 -0800 (PST) Received: from localhost.localdomain (79-139-233-37.dynamic.spd-mgts.ru. [79.139.233.37]) by smtp.gmail.com with ESMTPSA id j23sm9166942lji.41.2019.11.18.12.05.55 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 18 Nov 2019 12:05:56 -0800 (PST) From: Dmitry Osipenko To: Thierry Reding , Jonathan Hunter , Peter De Schrijver , Mikko Perttunen , Georgi Djakov , Rob Herring Subject: [PATCH v1 26/29] drm/tegra: dc: Support memory bandwidth management Date: Mon, 18 Nov 2019 23:02:44 +0300 Message-Id: <20191118200247.3567-27-digetx@gmail.com> X-Mailer: git-send-email 2.23.0 In-Reply-To: <20191118200247.3567-1-digetx@gmail.com> References: <20191118200247.3567-1-digetx@gmail.com> MIME-Version: 1.0 X-Mailman-Approved-At: Tue, 19 Nov 2019 08:04:07 +0000 X-Mailman-Original-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=nuz1BcEYsck8xXvuAx6no465QzG7OGwvJ3sC9jHo7/Y=; b=uh1visuScvodNh0T8pHBqf2GB2+HNTFTQhIPhDeLDok+7qBEvrWAAtnI/A1CAaLpl9 5FFdbEfyBubZFVgpmhJmFAtN5ZLyl1/jLAplsfXd3TxVyvwtrkbZ7aOl5iOKk70S1qZH L6t8faaBy+8iBwgHyQ+JXhs0q5PH+1qU9sA3dk4IP1yhF2pPxv7UMkdqprSh2TH+eFED EAwMXoziIq6fPfpJfJBvoDA5Xa3JQFdS6/ZfBjYf3mAwz73qHRIs5DtxNfo1Ippb5ZEZ qKOD1urA2W0hEjrH6kgemlQLkm1z50WScTg4p49NVoNUfZ7Lx1UbdOLTCy1/N3lgzPvM 770A== X-BeenThere: dri-devel@lists.freedesktop.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: Direct Rendering Infrastructure - Development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: linux-tegra@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, dri-devel@lists.freedesktop.org, linux-pm@vger.kernel.org Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" Message-ID: <20191118200244.bg_tuFG5F560LLNbhIdHIlRL8EFJKOpudoNDPuXMOvM@z> RGlzcGxheSBjb250cm9sbGVyIChEQykgcGVyZm9ybXMgaXNvY2hyb25vdXMgbWVtb3J5IHRyYW5z ZmVycyBhbmQgdGh1cwpoYXMgYSByZXF1aXJlbWVudCBmb3IgYSBtaW5pbXVtIG1lbW9yeSBiYW5k d2lkdGggdGhhdCBzaGFsbCBiZSBmdWxmaWxsZWQsCm90aGVyd2lzZSBmcmFtZWJ1ZmZlciBkYXRh IGNhbid0IGJlIGZldGNoZWQgZmFzdCBlbm91Z2ggYW5kIHRoaXMgcmVzdWx0cwppbiBhIERDJ3Mg ZGF0YS1GSUZPIHVuZGVyZmxvdyB0aGF0IGZvbGxvd3MgYnkgYSB2aXN1YWwgY29ycnVwdGlvbi4K ClRoZSBFeHRlcm5hbCBNZW1vcnkgQ29udHJvbGxlciBkcml2ZXJzIHByb3ZpZGUgZmFjaWxpdHkg Zm9yIG1lbW9yeQpiYW5kd2lkdGggbWFuYWdlbWVudCB2aWEgaW50ZXJjb25uZWN0IEFQSS4gVGhp cyBwYXRjaCB3aXJlcyB1cCB0aGUKaW50ZXJjb25uZWN0IEFQSSBzdXBwb3J0IHRvIHRoZSBEQyBk cml2ZXIuCgpTaWduZWQtb2ZmLWJ5OiBEbWl0cnkgT3NpcGVua28gPGRpZ2V0eEBnbWFpbC5jb20+ Ci0tLQogZHJpdmVycy9ncHUvZHJtL3RlZ3JhL2RjLmMgICAgfCAyNDAgKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrLQogZHJpdmVycy9ncHUvZHJtL3RlZ3JhL2RjLmggICAgfCAgIDgg KysKIGRyaXZlcnMvZ3B1L2RybS90ZWdyYS9kcm0uYyAgIHwgIDE4ICsrKwogZHJpdmVycy9ncHUv ZHJtL3RlZ3JhL3BsYW5lLmMgfCAgIDEgKwogZHJpdmVycy9ncHUvZHJtL3RlZ3JhL3BsYW5lLmgg fCAgIDQgKy0KIDUgZmlsZXMgY2hhbmdlZCwgMjY5IGluc2VydGlvbnMoKyksIDIgZGVsZXRpb25z KC0pCgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3RlZ3JhL2RjLmMgYi9kcml2ZXJzL2dw dS9kcm0vdGVncmEvZGMuYwppbmRleCBjMmM2MTE1NmNkY2YuLmM2MGEwYzAwZDk1ZiAxMDA2NDQK LS0tIGEvZHJpdmVycy9ncHUvZHJtL3RlZ3JhL2RjLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL3Rl Z3JhL2RjLmMKQEAgLTUxOSw2ICs1MTksMTIyIEBAIHN0YXRpYyB2b2lkIHRlZ3JhX2RjX3NldHVw X3dpbmRvdyhzdHJ1Y3QgdGVncmFfcGxhbmUgKnBsYW5lLAogCQl0ZWdyYV9wbGFuZV9zZXR1cF9i bGVuZGluZyhwbGFuZSwgd2luZG93KTsKIH0KIAorc3RhdGljIHVuc2lnbmVkIGxvbmcKK3RlZ3Jh X3BsYW5lX21lbW9yeV9iYW5kd2lkdGgoc3RydWN0IGRybV9wbGFuZV9zdGF0ZSAqc3RhdGUsCisJ CQkgICAgIHN0cnVjdCB0ZWdyYV9kY193aW5kb3cgKndpbmRvdykKK3sKKwlzdHJ1Y3QgdGVncmFf cGxhbmVfc3RhdGUgKnRlZ3JhX3N0YXRlOworCXN0cnVjdCBkcm1fY3J0Y19zdGF0ZSAqY3J0Y19z dGF0ZTsKKwljb25zdCBzdHJ1Y3QgZHJtX2Zvcm1hdF9pbmZvICpmbXQ7CisJc3RydWN0IHRlZ3Jh X2RjX3dpbmRvdyB3aW47CisJdW5zaWduZWQgaW50IGJwcF9wbGFuZTsKKwl1bnNpZ25lZCBpbnQg YnBwOworCXVuc2lnbmVkIGludCBtdWw7CisJdW5zaWduZWQgaW50IGk7CisKKwlpZiAoIXN0YXRl LT5mYiB8fCAhc3RhdGUtPnZpc2libGUpCisJCXJldHVybiAwOworCisJY3J0Y19zdGF0ZSA9IGRy bV9hdG9taWNfZ2V0X25ld19jcnRjX3N0YXRlKHN0YXRlLT5zdGF0ZSwgc3RhdGUtPmNydGMpOwor CXRlZ3JhX3N0YXRlID0gdG9fdGVncmFfcGxhbmVfc3RhdGUoc3RhdGUpOworCisJaWYgKCF3aW5k b3cpCisJCXdpbmRvdyA9ICZ3aW47CisKKwl3aW5kb3ctPnNyYy53ID0gZHJtX3JlY3Rfd2lkdGgo JnN0YXRlLT5zcmMpID4+IDE2OworCXdpbmRvdy0+c3JjLmggPSBkcm1fcmVjdF9oZWlnaHQoJnN0 YXRlLT5zcmMpID4+IDE2OworCXdpbmRvdy0+ZHN0LncgPSBkcm1fcmVjdF93aWR0aCgmc3RhdGUt PmRzdCk7CisJd2luZG93LT5kc3QuaCA9IGRybV9yZWN0X2hlaWdodCgmc3RhdGUtPmRzdCk7CisJ d2luZG93LT50aWxpbmcgPSB0ZWdyYV9zdGF0ZS0+dGlsaW5nOworCisJZm10ID0gc3RhdGUtPmZi LT5mb3JtYXQ7CisKKwkvKgorCSAqIE5vdGUgdGhhdCByZWFsIG1lbW9yeSBiYW5kd2lkdGggdmFy eSBkZXBlbmRpbmcgb24gZm9ybWF0IGFuZAorCSAqIG1lbW9yeSBsYXlvdXQsIHdlIGFyZSBub3Qg dGFraW5nIHRoYXQgaW50byBhY2NvdW50IGJlY2F1c2Ugc21hbGwKKwkgKiBlc3RpbWF0aW9uIGVy cm9yIGlzbid0IGltcG9ydGFudCBzaW5jZSBiYW5kd2lkdGggaXMgcm91bmRlZCB1cAorCSAqIGFu eXdheS4KKwkgKi8KKwlmb3IgKGkgPSAwLCBicHAgPSAwOyBpIDwgZm10LT5udW1fcGxhbmVzOyBp KyspIHsKKwkJYnBwX3BsYW5lID0gZm10LT5jcHBbaV0gKiA4OworCisJCS8qCisJCSAqIFN1Yi1z YW1wbGluZyBpcyByZWxldmFudCBmb3IgY2hyb21hIHBsYW5lcyBvbmx5IGFuZCB2ZXJ0aWNhbAor CQkgKiByZWFkb3V0cyBhcmUgbm90IGNhY2hlZCwgaGVuY2Ugb25seSBob3Jpem9udGFsIHN1Yi1z YW1wbGluZworCQkgKiBtYXR0ZXJzLgorCQkgKi8KKwkJaWYgKGkgPiAwKQorCQkJYnBwX3BsYW5l IC89IGZtdC0+aHN1YjsKKworCQlicHAgKz0gYnBwX3BsYW5lOworCX0KKworCS8qCisJICogSG9y aXpvbnRhbCBkb3duc2NhbGUgdGFrZXMgZXh0cmEgYmFuZHdpZHRoIHdoaWNoIHJvdWdobHkgZGVw ZW5kcworCSAqIG9uIHRoZSBzY2FsZWQgd2lkdGguCisJICovCisJaWYgKHdpbmRvdy0+c3JjLncg PiB3aW5kb3ctPmRzdC53KQorCQltdWwgPSAod2luZG93LT5zcmMudyAtIHdpbmRvdy0+ZHN0Lncp ICogYnBwIC8gMjA0OCArIDE7CisJZWxzZQorCQltdWwgPSAxOworCisJLyoKKwkgKiBJZ25vcmUg d2luZG93IGlmIGl0cyB3aWR0aCBpcyBzbWFsbCBlbm91Z2ggc3VjaCB0aGF0IGRhdGEtcHJlZmV0 Y2gKKwkgKiBGSUZPIHdpbGwgZWFzaWx5IGhlbHAgdG8gb3ZlcmNvbWUgdGVtcG9yYWwgbWVtb3J5 IHByZXNzdXJlLiBUaGlzIGlzCisJICogYSB0eXBpY2FsIGNhc2UgZm9yIHRoZSBjdXJzb3IncyBw bGFuZS4KKwkgKi8KKwlpZiAobXVsID09IDEgJiYgd2luZG93LT5zcmMudyAqIGJwcCA8PSAyMDQ4 KQorCQlyZXR1cm4gMDsKKworCS8qIG1vZGUuY2xvY2sgaW4ga0h6LCBiYW5kd2lkdGggaW4ga2Jp dC9zICovCisJcmV0dXJuIGticHNfdG9faWNjKGNydGNfc3RhdGUtPm1vZGUuY2xvY2sgKiBicHAg KiBtdWwpOworfQorCitzdGF0aWMgdW5zaWduZWQgbG9uZwordGVncmEyMF9wbGFuZV9tZW1vcnlf YmFuZHdpZHRoKHN0cnVjdCBkcm1fcGxhbmVfc3RhdGUgKnN0YXRlKQoreworCS8qIH4zNSUgZWZm aWNpZW5jeSAqLworCXJldHVybiB0ZWdyYV9wbGFuZV9tZW1vcnlfYmFuZHdpZHRoKHN0YXRlLCBO VUxMKSAqIDI5IC8gMTA7Cit9CisKK3N0YXRpYyB1bnNpZ25lZCBsb25nCit0ZWdyYTMwX3BsYW5l X21lbW9yeV9iYW5kd2lkdGgoc3RydWN0IGRybV9wbGFuZV9zdGF0ZSAqc3RhdGUpCit7CisJc3Ry dWN0IHRlZ3JhX2RjX3dpbmRvdyB3aW5kb3c7CisJdW5zaWduZWQgbG9uZyBiYW5kd2lkdGg7CisK KwliYW5kd2lkdGggPSB0ZWdyYV9wbGFuZV9tZW1vcnlfYmFuZHdpZHRoKHN0YXRlLCAmd2luZG93 KTsKKworCS8qIHgyOiBtZW1vcnkgb3ZlcmZldGNoIGZvciB0aWxlZCBmcmFtZWJ1ZmZlciBhbmQg RERSMyAqLworCWlmICh3aW5kb3cudGlsaW5nLm1vZGUgPT0gVEVHUkFfQk9fVElMSU5HX01PREVf VElMRUQpCisJCWJhbmR3aWR0aCAqPSAyOworCisJLyogfjM1JSBlZmZpY2llbmN5ICovCisJcmV0 dXJuIGJhbmR3aWR0aCAqIDI5IC8gMTA7Cit9CisKK3N0YXRpYyB1bnNpZ25lZCBsb25nCit0ZWdy YTExNF9wbGFuZV9tZW1vcnlfYmFuZHdpZHRoKHN0cnVjdCBkcm1fcGxhbmVfc3RhdGUgKnN0YXRl KQoreworCXN0cnVjdCB0ZWdyYV9kY193aW5kb3cgd2luZG93OworCXVuc2lnbmVkIGxvbmcgYmFu ZHdpZHRoOworCisJYmFuZHdpZHRoID0gdGVncmFfcGxhbmVfbWVtb3J5X2JhbmR3aWR0aChzdGF0 ZSwgJndpbmRvdyk7CisKKwkvKiB4MjogbWVtb3J5IG92ZXJmZXRjaCBmb3IgdGlsZWQgZnJhbWVi dWZmZXIgYW5kIEREUjMgKi8KKwlpZiAod2luZG93LnRpbGluZy5tb2RlID09IFRFR1JBX0JPX1RJ TElOR19NT0RFX1RJTEVEKQorCQliYW5kd2lkdGggKj0gMjsKKworCXJldHVybiBiYW5kd2lkdGg7 Cit9CisKK3N0YXRpYyB1bnNpZ25lZCBsb25nCit0ZWdyYTEyNF9wbGFuZV9tZW1vcnlfYmFuZHdp ZHRoKHN0cnVjdCBkcm1fcGxhbmVfc3RhdGUgKnN0YXRlKQoreworCS8qIDY0Yml0IG1lbW9yeSBi dXMgKi8KKwlyZXR1cm4gdGVncmFfcGxhbmVfbWVtb3J5X2JhbmR3aWR0aChzdGF0ZSwgTlVMTCk7 Cit9CisKIHN0YXRpYyBjb25zdCB1MzIgdGVncmEyMF9wcmltYXJ5X2Zvcm1hdHNbXSA9IHsKIAlE Uk1fRk9STUFUX0FSR0I0NDQ0LAogCURSTV9GT1JNQVRfQVJHQjE1NTUsCkBAIC02MDgsOCArNzI0 LDEwIEBAIHN0YXRpYyBpbnQgdGVncmFfcGxhbmVfYXRvbWljX2NoZWNrKHN0cnVjdCBkcm1fcGxh bmUgKnBsYW5lLAogCWludCBlcnI7CiAKIAkvKiBubyBuZWVkIGZvciBmdXJ0aGVyIGNoZWNrcyBp ZiB0aGUgcGxhbmUgaXMgYmVpbmcgZGlzYWJsZWQgKi8KLQlpZiAoIXN0YXRlLT5jcnRjKQorCWlm ICghc3RhdGUtPmNydGMpIHsKKwkJcGxhbmVfc3RhdGUtPm1lbW9yeV9iYW5kd2lkdGggPSAwOwog CQlyZXR1cm4gMDsKKwl9CiAKIAllcnIgPSB0ZWdyYV9wbGFuZV9mb3JtYXQoc3RhdGUtPmZiLT5m b3JtYXQtPmZvcm1hdCwKIAkJCQkgJnBsYW5lX3N0YXRlLT5mb3JtYXQsCkBAIC02NjIsNiArNzgw LDggQEAgc3RhdGljIGludCB0ZWdyYV9wbGFuZV9hdG9taWNfY2hlY2soc3RydWN0IGRybV9wbGFu ZSAqcGxhbmUsCiAJaWYgKGVyciA8IDApCiAJCXJldHVybiBlcnI7CiAKKwlwbGFuZV9zdGF0ZS0+ bWVtb3J5X2JhbmR3aWR0aCA9IGRjLT5zb2MtPnBsYW5lX21lbW9yeV9iYW5kd2lkdGgoc3RhdGUp OworCiAJcmV0dXJuIDA7CiB9CiAKQEAgLTExODYsNiArMTMwNiw3IEBAIHRlZ3JhX2NydGNfYXRv bWljX2R1cGxpY2F0ZV9zdGF0ZShzdHJ1Y3QgZHJtX2NydGMgKmNydGMpCiAJY29weS0+cGNsayA9 IHN0YXRlLT5wY2xrOwogCWNvcHktPmRpdiA9IHN0YXRlLT5kaXY7CiAJY29weS0+cGxhbmVzID0g c3RhdGUtPnBsYW5lczsKKwljb3B5LT5tZW1vcnlfYmFuZHdpZHRoID0gc3RhdGUtPm1lbW9yeV9i YW5kd2lkdGg7CiAKIAlyZXR1cm4gJmNvcHktPmJhc2U7CiB9CkBAIC0xNzc0LDYgKzE4OTUsOCBA QCBzdGF0aWMgdm9pZCB0ZWdyYV9jcnRjX2F0b21pY19kaXNhYmxlKHN0cnVjdCBkcm1fY3J0YyAq Y3J0YywKIAlzcGluX3VubG9ja19pcnEoJmNydGMtPmRldi0+ZXZlbnRfbG9jayk7CiAKIAlwbV9y dW50aW1lX3B1dF9zeW5jKGRjLT5kZXYpOworCisJaWNjX3NldF9idyhkYy0+aWNjLCAwLCAwKTsK IH0KIAogc3RhdGljIHZvaWQgdGVncmFfY3J0Y19hdG9taWNfZW5hYmxlKHN0cnVjdCBkcm1fY3J0 YyAqY3J0YywKQEAgLTE3ODQsNiArMTkwNyw4IEBAIHN0YXRpYyB2b2lkIHRlZ3JhX2NydGNfYXRv bWljX2VuYWJsZShzdHJ1Y3QgZHJtX2NydGMgKmNydGMsCiAJc3RydWN0IHRlZ3JhX2RjICpkYyA9 IHRvX3RlZ3JhX2RjKGNydGMpOwogCXUzMiB2YWx1ZTsKIAorCWljY19zZXRfYncoZGMtPmljYywg c3RhdGUtPm1lbW9yeV9iYW5kd2lkdGgsIHN0YXRlLT5tZW1vcnlfYmFuZHdpZHRoKTsKKwogCXBt X3J1bnRpbWVfZ2V0X3N5bmMoZGMtPmRldik7CiAKIAkvKiBpbml0aWFsaXplIGRpc3BsYXkgY29u dHJvbGxlciAqLwpAQCAtMTg5Myw2ICsyMDE4LDkgQEAgc3RhdGljIHZvaWQgdGVncmFfY3J0Y19h dG9taWNfZW5hYmxlKHN0cnVjdCBkcm1fY3J0YyAqY3J0YywKIHN0YXRpYyB2b2lkIHRlZ3JhX2Ny dGNfYXRvbWljX2JlZ2luKHN0cnVjdCBkcm1fY3J0YyAqY3J0YywKIAkJCQkgICAgc3RydWN0IGRy bV9jcnRjX3N0YXRlICpvbGRfY3J0Y19zdGF0ZSkKIHsKKwlzdHJ1Y3QgdGVncmFfZGNfc3RhdGUg KmRjX29sZF9zdGF0ZSA9IHRvX2RjX3N0YXRlKG9sZF9jcnRjX3N0YXRlKTsKKwlzdHJ1Y3QgdGVn cmFfZGNfc3RhdGUgKmRjX3N0YXRlID0gdG9fZGNfc3RhdGUoY3J0Yy0+c3RhdGUpOworCXN0cnVj dCB0ZWdyYV9kYyAqZGMgPSB0b190ZWdyYV9kYyhjcnRjKTsKIAl1bnNpZ25lZCBsb25nIGZsYWdz OwogCiAJaWYgKGNydGMtPnN0YXRlLT5ldmVudCkgewpAQCAtMTkwNyw2ICsyMDM1LDI1IEBAIHN0 YXRpYyB2b2lkIHRlZ3JhX2NydGNfYXRvbWljX2JlZ2luKHN0cnVjdCBkcm1fY3J0YyAqY3J0YywK IAogCQljcnRjLT5zdGF0ZS0+ZXZlbnQgPSBOVUxMOwogCX0KKworCWlmIChvbGRfY3J0Y19zdGF0 ZSAmJiBvbGRfY3J0Y19zdGF0ZS0+YWN0aXZlKSB7CisJCS8qCisJCSAqIFJhaXNlIG1lbW9yeSBi YW5kd2lkdGggYmVmb3JlIGNoYW5nZXMgdGFrZSBlZmZlY3QgaWYgaXQKKwkJICogZ29lcyBmcm9t IGxvdyB0byBoaWdoLgorCQkgKi8KKwkJaWYgKGRjX29sZF9zdGF0ZS0+bWVtb3J5X2JhbmR3aWR0 aCA8IGRjX3N0YXRlLT5tZW1vcnlfYmFuZHdpZHRoKQorCQkJaWNjX3NldF9idyhkYy0+aWNjLAor CQkJCSAgIGRjX3N0YXRlLT5tZW1vcnlfYmFuZHdpZHRoLAorCQkJCSAgIGRjX3N0YXRlLT5tZW1v cnlfYmFuZHdpZHRoKTsKKwl9IGVsc2UgeworCQkvKgorCQkgKiBSYWlzZSBtZW1vcnkgYmFuZHdp ZHRoIGJlZm9yZSBjaGFuZ2VzIHRha2UgZWZmZWN0IGlmCisJCSAqIENSVEMgaXMgdHVybmluZyBv bi4KKwkJICovCisJCWljY19zZXRfYncoZGMtPmljYywKKwkJCSAgIGRjX3N0YXRlLT5tZW1vcnlf YmFuZHdpZHRoLAorCQkJICAgZGNfc3RhdGUtPm1lbW9yeV9iYW5kd2lkdGgpOworCX0KIH0KIAog c3RhdGljIHZvaWQgdGVncmFfY3J0Y19hdG9taWNfZmx1c2goc3RydWN0IGRybV9jcnRjICpjcnRj LApAQCAtMTkyNSw3ICsyMDcyLDc5IEBAIHN0YXRpYyB2b2lkIHRlZ3JhX2NydGNfYXRvbWljX2Zs dXNoKHN0cnVjdCBkcm1fY3J0YyAqY3J0YywKIAl2YWx1ZSA9IHRlZ3JhX2RjX3JlYWRsKGRjLCBE Q19DTURfU1RBVEVfQ09OVFJPTCk7CiB9CiAKK3N0YXRpYyBib29sCit0ZWdyYV9wbGFuZV9pbnRl cnNlY3RzX3dpdGhfb3RoZXJfcGxhbmUoc3RydWN0IGRybV9jcnRjX3N0YXRlICpzdGF0ZSwKKwkJ CQkJY29uc3Qgc3RydWN0IGRybV9wbGFuZV9zdGF0ZSAqcGxhbmVfc3RhdGUpCit7CisJY29uc3Qg c3RydWN0IGRybV9wbGFuZV9zdGF0ZSAqb3RoZXJfc3RhdGU7CisJc3RydWN0IGRybV9wbGFuZSAq cGxhbmU7CisJc3RydWN0IGRybV9yZWN0IHJlY3Q7CisKKwlkcm1fYXRvbWljX2NydGNfc3RhdGVf Zm9yX2VhY2hfcGxhbmVfc3RhdGUocGxhbmUsIG90aGVyX3N0YXRlLCBzdGF0ZSkgeworCQlyZWN0 ID0gcGxhbmVfc3RhdGUtPmRzdDsKKworCQlpZiAob3RoZXJfc3RhdGUgPT0gcGxhbmVfc3RhdGUp CisJCQljb250aW51ZTsKKworCQlpZiAoIW90aGVyX3N0YXRlLT52aXNpYmxlIHx8ICFvdGhlcl9z dGF0ZS0+ZmIpCisJCQljb250aW51ZTsKKworCQlpZiAoZHJtX3JlY3RfaW50ZXJzZWN0KCZyZWN0 LCAmb3RoZXJfc3RhdGUtPmRzdCkpCisJCQlyZXR1cm4gdHJ1ZTsKKwl9CisKKwlyZXR1cm4gZmFs c2U7Cit9CisKK3N0YXRpYyBpbnQgdGVncmFfY3J0Y19hdG9taWNfY2hlY2soc3RydWN0IGRybV9j cnRjICpjcnRjLAorCQkJCSAgIHN0cnVjdCBkcm1fY3J0Y19zdGF0ZSAqc3RhdGUpCit7CisJc3Ry dWN0IHRlZ3JhX2RjX3N0YXRlICpkY19zdGF0ZSA9IHRvX2RjX3N0YXRlKHN0YXRlKTsKKwljb25z dCBzdHJ1Y3QgZHJtX3BsYW5lX3N0YXRlICpwbGFuZV9zdGF0ZTsKKwljb25zdCBzdHJ1Y3QgdGVn cmFfcGxhbmVfc3RhdGUgKnRlZ3JhOworCXVuc2lnbmVkIGxvbmcgbG9uZyBiYW5kd2lkdGggPSAw OworCXN0cnVjdCBkcm1fcGxhbmUgKnBsYW5lOworCisJLyoKKwkgKiBGb3Igb3ZlcmxhcHBpbmcg cGxhbmVzIHBpeGVsJ3MgZGF0YSBpcyBmZXRjaGVkIGZvciBlYWNoIHBsYW5lIGF0CisJICogdGhl IHNhbWUgdGltZSwgaGVuY2UgYmFuZHdpZHRoIGlzIGFjY3VtdWxhdGVkIGluIHRoaXMgY2FzZS4K KwkgKi8KKwlkcm1fYXRvbWljX2NydGNfc3RhdGVfZm9yX2VhY2hfcGxhbmVfc3RhdGUocGxhbmUs IHBsYW5lX3N0YXRlLCBzdGF0ZSkgeworCQl0ZWdyYSA9IHRvX3RlZ3JhX3BsYW5lX3N0YXRlKHBs YW5lX3N0YXRlKTsKKworCQlpZiAodGVncmFfcGxhbmVfaW50ZXJzZWN0c193aXRoX290aGVyX3Bs YW5lKHN0YXRlLCBwbGFuZV9zdGF0ZSkpCisJCQliYW5kd2lkdGggKz0gdGVncmEtPm1lbW9yeV9i YW5kd2lkdGg7CisJCWVsc2UKKwkJCWJhbmR3aWR0aCA9IG1heChiYW5kd2lkdGgsICh1NjQpdGVn cmEtPm1lbW9yeV9iYW5kd2lkdGgpOworCX0KKworCWRjX3N0YXRlLT5tZW1vcnlfYmFuZHdpZHRo ID0gbWluKGJhbmR3aWR0aCwgKHU2NClVMzJfTUFYKTsKKworCXJldHVybiAwOworfQorCit2b2lk IHRlZ3JhX2NydGNfYXRvbWljX3Bvc3RfY29tbWl0KHN0cnVjdCBkcm1fY3J0YyAqY3J0YywKKwkJ CQkgICBzdHJ1Y3QgZHJtX2NydGNfc3RhdGUgKm9sZF9jcnRjX3N0YXRlKQoreworCXN0cnVjdCB0 ZWdyYV9kY19zdGF0ZSAqZGNfb2xkX3N0YXRlID0gdG9fZGNfc3RhdGUob2xkX2NydGNfc3RhdGUp OworCXN0cnVjdCB0ZWdyYV9kY19zdGF0ZSAqZGNfc3RhdGUgPSB0b19kY19zdGF0ZShjcnRjLT5z dGF0ZSk7CisJc3RydWN0IHRlZ3JhX2RjICpkYyA9IHRvX3RlZ3JhX2RjKGNydGMpOworCisJaWYg KCFkY19vbGRfc3RhdGUpCisJCXJldHVybjsKKworCS8qCisJICogRHJvcCBtZW1vcnkgYmFuZHdp ZHRoIGFmdGVyIGNoYW5nZXMgdGFrZSBlZmZlY3QgaWYgaXQgZ29lcyBmcm9tCisJICogaGlnaCB0 byBsb3cuCisJICovCisJaWYgKGRjX29sZF9zdGF0ZS0+bWVtb3J5X2JhbmR3aWR0aCA+IGRjX3N0 YXRlLT5tZW1vcnlfYmFuZHdpZHRoKQorCQlpY2Nfc2V0X2J3KGRjLT5pY2MsCisJCQkgICBkY19z dGF0ZS0+bWVtb3J5X2JhbmR3aWR0aCwKKwkJCSAgIGRjX3N0YXRlLT5tZW1vcnlfYmFuZHdpZHRo KTsKK30KKwogc3RhdGljIGNvbnN0IHN0cnVjdCBkcm1fY3J0Y19oZWxwZXJfZnVuY3MgdGVncmFf Y3J0Y19oZWxwZXJfZnVuY3MgPSB7CisJLmF0b21pY19jaGVjayA9IHRlZ3JhX2NydGNfYXRvbWlj X2NoZWNrLAogCS5hdG9taWNfYmVnaW4gPSB0ZWdyYV9jcnRjX2F0b21pY19iZWdpbiwKIAkuYXRv bWljX2ZsdXNoID0gdGVncmFfY3J0Y19hdG9taWNfZmx1c2gsCiAJLmF0b21pY19lbmFibGUgPSB0 ZWdyYV9jcnRjX2F0b21pY19lbmFibGUsCkBAIC0yMTQzLDYgKzIzNjIsNyBAQCBzdGF0aWMgY29u c3Qgc3RydWN0IHRlZ3JhX2RjX3NvY19pbmZvIHRlZ3JhMjBfZGNfc29jX2luZm8gPSB7CiAJLm1v ZGlmaWVycyA9IHRlZ3JhMjBfbW9kaWZpZXJzLAogCS5oYXNfd2luX2Ffd2l0aG91dF9maWx0ZXJz ID0gdHJ1ZSwKIAkuaGFzX3dpbl9jX3dpdGhvdXRfdmVydF9maWx0ZXIgPSB0cnVlLAorCS5wbGFu ZV9tZW1vcnlfYmFuZHdpZHRoID0gdGVncmEyMF9wbGFuZV9tZW1vcnlfYmFuZHdpZHRoLAogfTsK IAogc3RhdGljIGNvbnN0IHN0cnVjdCB0ZWdyYV9kY19zb2NfaW5mbyB0ZWdyYTMwX2RjX3NvY19p bmZvID0gewpAQCAtMjE2Miw2ICsyMzgyLDcgQEAgc3RhdGljIGNvbnN0IHN0cnVjdCB0ZWdyYV9k Y19zb2NfaW5mbyB0ZWdyYTMwX2RjX3NvY19pbmZvID0gewogCS5tb2RpZmllcnMgPSB0ZWdyYTIw X21vZGlmaWVycywKIAkuaGFzX3dpbl9hX3dpdGhvdXRfZmlsdGVycyA9IGZhbHNlLAogCS5oYXNf d2luX2Nfd2l0aG91dF92ZXJ0X2ZpbHRlciA9IGZhbHNlLAorCS5wbGFuZV9tZW1vcnlfYmFuZHdp ZHRoID0gdGVncmEzMF9wbGFuZV9tZW1vcnlfYmFuZHdpZHRoLAogfTsKIAogc3RhdGljIGNvbnN0 IHN0cnVjdCB0ZWdyYV9kY19zb2NfaW5mbyB0ZWdyYTExNF9kY19zb2NfaW5mbyA9IHsKQEAgLTIx ODEsNiArMjQwMiw3IEBAIHN0YXRpYyBjb25zdCBzdHJ1Y3QgdGVncmFfZGNfc29jX2luZm8gdGVn cmExMTRfZGNfc29jX2luZm8gPSB7CiAJLm1vZGlmaWVycyA9IHRlZ3JhMjBfbW9kaWZpZXJzLAog CS5oYXNfd2luX2Ffd2l0aG91dF9maWx0ZXJzID0gZmFsc2UsCiAJLmhhc193aW5fY193aXRob3V0 X3ZlcnRfZmlsdGVyID0gZmFsc2UsCisJLnBsYW5lX21lbW9yeV9iYW5kd2lkdGggPSB0ZWdyYTEx NF9wbGFuZV9tZW1vcnlfYmFuZHdpZHRoLAogfTsKIAogc3RhdGljIGNvbnN0IHN0cnVjdCB0ZWdy YV9kY19zb2NfaW5mbyB0ZWdyYTEyNF9kY19zb2NfaW5mbyA9IHsKQEAgLTIyMDAsNiArMjQyMiw3 IEBAIHN0YXRpYyBjb25zdCBzdHJ1Y3QgdGVncmFfZGNfc29jX2luZm8gdGVncmExMjRfZGNfc29j X2luZm8gPSB7CiAJLm1vZGlmaWVycyA9IHRlZ3JhMTI0X21vZGlmaWVycywKIAkuaGFzX3dpbl9h X3dpdGhvdXRfZmlsdGVycyA9IGZhbHNlLAogCS5oYXNfd2luX2Nfd2l0aG91dF92ZXJ0X2ZpbHRl ciA9IGZhbHNlLAorCS5wbGFuZV9tZW1vcnlfYmFuZHdpZHRoID0gdGVncmExMjRfcGxhbmVfbWVt b3J5X2JhbmR3aWR0aCwKIH07CiAKIHN0YXRpYyBjb25zdCBzdHJ1Y3QgdGVncmFfZGNfc29jX2lu Zm8gdGVncmEyMTBfZGNfc29jX2luZm8gPSB7CkBAIC0yMjE5LDYgKzI0NDIsNyBAQCBzdGF0aWMg Y29uc3Qgc3RydWN0IHRlZ3JhX2RjX3NvY19pbmZvIHRlZ3JhMjEwX2RjX3NvY19pbmZvID0gewog CS5tb2RpZmllcnMgPSB0ZWdyYTEyNF9tb2RpZmllcnMsCiAJLmhhc193aW5fYV93aXRob3V0X2Zp bHRlcnMgPSBmYWxzZSwKIAkuaGFzX3dpbl9jX3dpdGhvdXRfdmVydF9maWx0ZXIgPSBmYWxzZSwK KwkucGxhbmVfbWVtb3J5X2JhbmR3aWR0aCA9IHRlZ3JhMTI0X3BsYW5lX21lbW9yeV9iYW5kd2lk dGgsCiB9OwogCiBzdGF0aWMgY29uc3Qgc3RydWN0IHRlZ3JhX3dpbmRvd2dyb3VwX3NvYyB0ZWdy YTE4Nl9kY193Z3Jwc1tdID0gewpAQCAtMjI2Nyw2ICsyNDkxLDcgQEAgc3RhdGljIGNvbnN0IHN0 cnVjdCB0ZWdyYV9kY19zb2NfaW5mbyB0ZWdyYTE4Nl9kY19zb2NfaW5mbyA9IHsKIAkuaGFzX252 ZGlzcGxheSA9IHRydWUsCiAJLndncnBzID0gdGVncmExODZfZGNfd2dycHMsCiAJLm51bV93Z3Jw cyA9IEFSUkFZX1NJWkUodGVncmExODZfZGNfd2dycHMpLAorCS5wbGFuZV9tZW1vcnlfYmFuZHdp ZHRoID0gdGVncmExMjRfcGxhbmVfbWVtb3J5X2JhbmR3aWR0aCwKIH07CiAKIHN0YXRpYyBjb25z dCBzdHJ1Y3QgdGVncmFfd2luZG93Z3JvdXBfc29jIHRlZ3JhMTk0X2RjX3dncnBzW10gPSB7CkBA IC0yMzE1LDYgKzI1NDAsNyBAQCBzdGF0aWMgY29uc3Qgc3RydWN0IHRlZ3JhX2RjX3NvY19pbmZv IHRlZ3JhMTk0X2RjX3NvY19pbmZvID0gewogCS5oYXNfbnZkaXNwbGF5ID0gdHJ1ZSwKIAkud2dy cHMgPSB0ZWdyYTE5NF9kY193Z3JwcywKIAkubnVtX3dncnBzID0gQVJSQVlfU0laRSh0ZWdyYTE5 NF9kY193Z3JwcyksCisJLnBsYW5lX21lbW9yeV9iYW5kd2lkdGggPSB0ZWdyYTEyNF9wbGFuZV9t ZW1vcnlfYmFuZHdpZHRoLAogfTsKIAogc3RhdGljIGNvbnN0IHN0cnVjdCBvZl9kZXZpY2VfaWQg dGVncmFfZGNfb2ZfbWF0Y2hbXSA9IHsKQEAgLTI0OTMsNiArMjcxOSwxMyBAQCBzdGF0aWMgaW50 IHRlZ3JhX2RjX3Byb2JlKHN0cnVjdCBwbGF0Zm9ybV9kZXZpY2UgKnBkZXYpCiAJCXJldHVybiBl cnI7CiAJfQogCisJZGMtPmljYyA9IG9mX2ljY19nZXQoZGMtPmRldiwgImRtYS1tZW0iKTsKKwll cnIgPSBQVFJfRVJSX09SX1pFUk8oZGMtPmljYyk7CisJaWYgKGVycikgeworCQlkZXZfZXJyKGRj LT5kZXYsICJmYWlsZWQgdG8gZ2V0IGludGVyY29ubmVjdDogJWRcbiIsIGVycik7CisJCWdvdG8g cmVtb3ZlX3JnYjsKKwl9CisKIAlwbGF0Zm9ybV9zZXRfZHJ2ZGF0YShwZGV2LCBkYyk7CiAJcG1f cnVudGltZV9lbmFibGUoJnBkZXYtPmRldik7CiAKQEAgLTI1MTEsNiArMjc0NCw5IEBAIHN0YXRp YyBpbnQgdGVncmFfZGNfcHJvYmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKIAogZGlz YWJsZV9wbToKIAlwbV9ydW50aW1lX2Rpc2FibGUoJnBkZXYtPmRldik7CisJaWNjX3B1dChkYy0+ aWNjKTsKKworcmVtb3ZlX3JnYjoKIAl0ZWdyYV9kY19yZ2JfcmVtb3ZlKGRjKTsKIAogCXJldHVy biBlcnI7CkBAIC0yNTI4LDYgKzI3NjQsOCBAQCBzdGF0aWMgaW50IHRlZ3JhX2RjX3JlbW92ZShz dHJ1Y3QgcGxhdGZvcm1fZGV2aWNlICpwZGV2KQogCQlyZXR1cm4gZXJyOwogCX0KIAorCWljY19w dXQoZGMtPmljYyk7CisKIAllcnIgPSB0ZWdyYV9kY19yZ2JfcmVtb3ZlKGRjKTsKIAlpZiAoZXJy IDwgMCkgewogCQlkZXZfZXJyKCZwZGV2LT5kZXYsICJmYWlsZWQgdG8gcmVtb3ZlIFJHQiBvdXRw dXQ6ICVkXG4iLCBlcnIpOwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3RlZ3JhL2RjLmgg Yi9kcml2ZXJzL2dwdS9kcm0vdGVncmEvZGMuaAppbmRleCAzZDhkZGNjZDc1OGYuLjYyOWIzNzlh ODIwNyAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL3RlZ3JhL2RjLmgKKysrIGIvZHJpdmVy cy9ncHUvZHJtL3RlZ3JhL2RjLmgKQEAgLTgsNiArOCw3IEBACiAjZGVmaW5lIFRFR1JBX0RDX0gg MQogCiAjaW5jbHVkZSA8bGludXgvaG9zdDF4Lmg+CisjaW5jbHVkZSA8bGludXgvaW50ZXJjb25u ZWN0Lmg+CiAKICNpbmNsdWRlIDxkcm0vZHJtX2NydGMuaD4KIApAQCAtMjMsNiArMjQsOCBAQCBz dHJ1Y3QgdGVncmFfZGNfc3RhdGUgewogCXVuc2lnbmVkIGludCBkaXY7CiAKIAl1MzIgcGxhbmVz OworCisJdW5zaWduZWQgbG9uZyBtZW1vcnlfYmFuZHdpZHRoOwogfTsKIAogc3RhdGljIGlubGlu ZSBzdHJ1Y3QgdGVncmFfZGNfc3RhdGUgKnRvX2RjX3N0YXRlKHN0cnVjdCBkcm1fY3J0Y19zdGF0 ZSAqc3RhdGUpCkBAIC02Niw2ICs2OSw3IEBAIHN0cnVjdCB0ZWdyYV9kY19zb2NfaW5mbyB7CiAJ Y29uc3QgdTY0ICptb2RpZmllcnM7CiAJYm9vbCBoYXNfd2luX2Ffd2l0aG91dF9maWx0ZXJzOwog CWJvb2wgaGFzX3dpbl9jX3dpdGhvdXRfdmVydF9maWx0ZXI7CisJdW5zaWduZWQgbG9uZyAoKnBs YW5lX21lbW9yeV9iYW5kd2lkdGgpKHN0cnVjdCBkcm1fcGxhbmVfc3RhdGUgKnN0YXRlKTsKIH07 CiAKIHN0cnVjdCB0ZWdyYV9kYyB7CkBAIC05MCw2ICs5NCw4IEBAIHN0cnVjdCB0ZWdyYV9kYyB7 CiAJc3RydWN0IGRybV9pbmZvX2xpc3QgKmRlYnVnZnNfZmlsZXM7CiAKIAljb25zdCBzdHJ1Y3Qg dGVncmFfZGNfc29jX2luZm8gKnNvYzsKKworCXN0cnVjdCBpY2NfcGF0aCAqaWNjOwogfTsKIAog c3RhdGljIGlubGluZSBzdHJ1Y3QgdGVncmFfZGMgKgpAQCAtMTUwLDYgKzE1Niw4IEBAIGludCB0 ZWdyYV9kY19zdGF0ZV9zZXR1cF9jbG9jayhzdHJ1Y3QgdGVncmFfZGMgKmRjLAogCQkJICAgICAg IHN0cnVjdCBkcm1fY3J0Y19zdGF0ZSAqY3J0Y19zdGF0ZSwKIAkJCSAgICAgICBzdHJ1Y3QgY2xr ICpjbGssIHVuc2lnbmVkIGxvbmcgcGNsaywKIAkJCSAgICAgICB1bnNpZ25lZCBpbnQgZGl2KTsK K3ZvaWQgdGVncmFfY3J0Y19hdG9taWNfcG9zdF9jb21taXQoc3RydWN0IGRybV9jcnRjICpjcnRj LAorCQkJCSAgIHN0cnVjdCBkcm1fY3J0Y19zdGF0ZSAqb2xkX2NydGNfc3RhdGUpOwogCiAvKiBm cm9tIHJnYi5jICovCiBpbnQgdGVncmFfZGNfcmdiX3Byb2JlKHN0cnVjdCB0ZWdyYV9kYyAqZGMp OwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL3RlZ3JhL2RybS5jIGIvZHJpdmVycy9ncHUv ZHJtL3RlZ3JhL2RybS5jCmluZGV4IDU2ZTVlN2E1YzEwOC4uY2NjZTkxZWE3MTgwIDEwMDY0NAot LS0gYS9kcml2ZXJzL2dwdS9kcm0vdGVncmEvZHJtLmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL3Rl Z3JhL2RybS5jCkBAIC0yMCw2ICsyMCw3IEBACiAjaW5jbHVkZSA8ZHJtL2RybV9wcmltZS5oPgog I2luY2x1ZGUgPGRybS9kcm1fdmJsYW5rLmg+CiAKKyNpbmNsdWRlICJkYy5oIgogI2luY2x1ZGUg ImRybS5oIgogI2luY2x1ZGUgImdlbS5oIgogCkBAIC01OSw2ICs2MCwyMSBAQCBzdGF0aWMgY29u c3Qgc3RydWN0IGRybV9tb2RlX2NvbmZpZ19mdW5jcyB0ZWdyYV9kcm1fbW9kZV9jb25maWdfZnVu Y3MgPSB7CiAJLmF0b21pY19jb21taXQgPSBkcm1fYXRvbWljX2hlbHBlcl9jb21taXQsCiB9Owog CitzdGF0aWMgdm9pZCB0ZWdyYV9hdG9taWNfcG9zdF9jb21taXQoc3RydWN0IGRybV9kZXZpY2Ug KmRybSwKKwkJCQkgICAgIHN0cnVjdCBkcm1fYXRvbWljX3N0YXRlICpvbGRfc3RhdGUpCit7CisJ c3RydWN0IGRybV9jcnRjX3N0YXRlICpvbGRfY3J0Y19zdGF0ZSwgKm5ld19jcnRjX3N0YXRlOwor CXN0cnVjdCBkcm1fY3J0YyAqY3J0YzsKKwlpbnQgaTsKKworCWZvcl9lYWNoX29sZG5ld19jcnRj X2luX3N0YXRlKG9sZF9zdGF0ZSwgY3J0Yywgb2xkX2NydGNfc3RhdGUsIG5ld19jcnRjX3N0YXRl LCBpKSB7CisJCWlmICghbmV3X2NydGNfc3RhdGUtPmFjdGl2ZSkKKwkJCWNvbnRpbnVlOworCisJ CXRlZ3JhX2NydGNfYXRvbWljX3Bvc3RfY29tbWl0KGNydGMsIG9sZF9jcnRjX3N0YXRlKTsKKwl9 Cit9CisKIHN0YXRpYyB2b2lkIHRlZ3JhX2F0b21pY19jb21taXRfdGFpbChzdHJ1Y3QgZHJtX2F0 b21pY19zdGF0ZSAqb2xkX3N0YXRlKQogewogCXN0cnVjdCBkcm1fZGV2aWNlICpkcm0gPSBvbGRf c3RhdGUtPmRldjsKQEAgLTc1LDYgKzkxLDggQEAgc3RhdGljIHZvaWQgdGVncmFfYXRvbWljX2Nv bW1pdF90YWlsKHN0cnVjdCBkcm1fYXRvbWljX3N0YXRlICpvbGRfc3RhdGUpCiAJfSBlbHNlIHsK IAkJZHJtX2F0b21pY19oZWxwZXJfY29tbWl0X3RhaWxfcnBtKG9sZF9zdGF0ZSk7CiAJfQorCisJ dGVncmFfYXRvbWljX3Bvc3RfY29tbWl0KGRybSwgb2xkX3N0YXRlKTsKIH0KIAogc3RhdGljIGNv bnN0IHN0cnVjdCBkcm1fbW9kZV9jb25maWdfaGVscGVyX2Z1bmNzCmRpZmYgLS1naXQgYS9kcml2 ZXJzL2dwdS9kcm0vdGVncmEvcGxhbmUuYyBiL2RyaXZlcnMvZ3B1L2RybS90ZWdyYS9wbGFuZS5j CmluZGV4IDE2M2I1OTBiZTIyNC4uMWY0ODJlNTk0ZGM5IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dw dS9kcm0vdGVncmEvcGxhbmUuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vdGVncmEvcGxhbmUuYwpA QCAtNjEsNiArNjEsNyBAQCB0ZWdyYV9wbGFuZV9hdG9taWNfZHVwbGljYXRlX3N0YXRlKHN0cnVj dCBkcm1fcGxhbmUgKnBsYW5lKQogCWNvcHktPnN3YXAgPSBzdGF0ZS0+c3dhcDsKIAljb3B5LT5i b3R0b21fdXAgPSBzdGF0ZS0+Ym90dG9tX3VwOwogCWNvcHktPm9wYXF1ZSA9IHN0YXRlLT5vcGFx dWU7CisJY29weS0+bWVtb3J5X2JhbmR3aWR0aCA9IHN0YXRlLT5tZW1vcnlfYmFuZHdpZHRoOwog CiAJZm9yIChpID0gMDsgaSA8IDI7IGkrKykKIAkJY29weS0+YmxlbmRpbmdbaV0gPSBzdGF0ZS0+ YmxlbmRpbmdbaV07CmRpZmYgLS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vdGVncmEvcGxhbmUuaCBi L2RyaXZlcnMvZ3B1L2RybS90ZWdyYS9wbGFuZS5oCmluZGV4IGExNThhOTE1MTA5YS4uNTIyN2M3 YTlhZDhiIDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vdGVncmEvcGxhbmUuaAorKysgYi9k cml2ZXJzL2dwdS9kcm0vdGVncmEvcGxhbmUuaApAQCAtNTEsMTAgKzUxLDEyIEBAIHN0cnVjdCB0 ZWdyYV9wbGFuZV9zdGF0ZSB7CiAJLyogdXNlZCBmb3IgbGVnYWN5IGJsZW5kaW5nIHN1cHBvcnQg b25seSAqLwogCXN0cnVjdCB0ZWdyYV9wbGFuZV9sZWdhY3lfYmxlbmRpbmdfc3RhdGUgYmxlbmRp bmdbMl07CiAJYm9vbCBvcGFxdWU7CisKKwl1bnNpZ25lZCBsb25nIG1lbW9yeV9iYW5kd2lkdGg7 CiB9OwogCiBzdGF0aWMgaW5saW5lIHN0cnVjdCB0ZWdyYV9wbGFuZV9zdGF0ZSAqCi10b190ZWdy YV9wbGFuZV9zdGF0ZShzdHJ1Y3QgZHJtX3BsYW5lX3N0YXRlICpzdGF0ZSkKK3RvX3RlZ3JhX3Bs YW5lX3N0YXRlKGNvbnN0IHN0cnVjdCBkcm1fcGxhbmVfc3RhdGUgKnN0YXRlKQogewogCWlmIChz dGF0ZSkKIAkJcmV0dXJuIGNvbnRhaW5lcl9vZihzdGF0ZSwgc3RydWN0IHRlZ3JhX3BsYW5lX3N0 YXRlLCBiYXNlKTsKLS0gCjIuMjMuMAoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX18KZHJpLWRldmVsIG1haWxpbmcgbGlzdApkcmktZGV2ZWxAbGlzdHMuZnJl ZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21haWxtYW4vbGlzdGlu Zm8vZHJpLWRldmVs