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=-16.8 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,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 EE66AC11F72 for ; Thu, 1 Jul 2021 20:26:54 +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 C36E3613F4 for ; Thu, 1 Jul 2021 20:26:54 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org C36E3613F4 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=intel.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 661586EC44; Thu, 1 Jul 2021 20:25:43 +0000 (UTC) Received: from mga17.intel.com (mga17.intel.com [192.55.52.151]) by gabe.freedesktop.org (Postfix) with ESMTPS id EEAD76EC06; Thu, 1 Jul 2021 20:25:23 +0000 (UTC) X-IronPort-AV: E=McAfee;i="6200,9189,10032"; a="188998669" X-IronPort-AV: E=Sophos;i="5.83,315,1616482800"; d="scan'208";a="188998669" Received: from fmsmga005.fm.intel.com ([10.253.24.32]) by fmsmga107.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 01 Jul 2021 13:25:21 -0700 X-IronPort-AV: E=Sophos;i="5.83,315,1616482800"; d="scan'208";a="644564533" Received: from mdroper-desk1.fm.intel.com ([10.1.27.134]) by fmsmga005-auth.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 01 Jul 2021 13:25:20 -0700 From: Matt Roper To: intel-gfx@lists.freedesktop.org Subject: [PATCH 43/53] drm/i915/dg2: Add MPLLB programming for HDMI Date: Thu, 1 Jul 2021 13:24:17 -0700 Message-Id: <20210701202427.1547543-44-matthew.d.roper@intel.com> X-Mailer: git-send-email 2.25.4 In-Reply-To: <20210701202427.1547543-1-matthew.d.roper@intel.com> References: <20210701202427.1547543-1-matthew.d.roper@intel.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit X-BeenThere: dri-devel@lists.freedesktop.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Direct Rendering Infrastructure - Development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Matt Atwood , dri-devel@lists.freedesktop.org, Vandita Kulkarni Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" At the moment we don't have a proper algorithm that can be used to calculate PHY settings for arbitrary HDMI link rates. The PHY tables here should support the regular modes of real-world HDMI monitors. Bspec: 54032 Cc: Matt Atwood Signed-off-by: Matt Roper Signed-off-by: Vandita Kulkarni --- drivers/gpu/drm/i915/display/intel_ddi.c | 14 +- drivers/gpu/drm/i915/display/intel_display.c | 47 +++ drivers/gpu/drm/i915/display/intel_hdmi.c | 11 + drivers/gpu/drm/i915/display/intel_snps_phy.c | 286 +++++++++++++++++- drivers/gpu/drm/i915/display/intel_snps_phy.h | 7 + drivers/gpu/drm/i915/i915_reg.h | 3 + 6 files changed, 355 insertions(+), 13 deletions(-) diff --git a/drivers/gpu/drm/i915/display/intel_ddi.c b/drivers/gpu/drm/i915/display/intel_ddi.c index 26a3aa73fcc4..929a95ddb316 100644 --- a/drivers/gpu/drm/i915/display/intel_ddi.c +++ b/drivers/gpu/drm/i915/display/intel_ddi.c @@ -51,6 +51,7 @@ #include "intel_panel.h" #include "intel_pps.h" #include "intel_psr.h" +#include "intel_snps_phy.h" #include "intel_sprite.h" #include "intel_tc.h" #include "intel_vdsc.h" @@ -3745,6 +3746,15 @@ void intel_ddi_get_clock(struct intel_encoder *encoder, &crtc_state->dpll_hw_state); } +static void dg2_ddi_get_config(struct intel_encoder *encoder, + struct intel_crtc_state *crtc_state) +{ + intel_mpllb_readout_hw_state(encoder, &crtc_state->mpllb_state); + crtc_state->port_clock = intel_mpllb_calc_port_clock(encoder, &crtc_state->mpllb_state); + + intel_ddi_get_config(encoder, crtc_state); +} + static void adls_ddi_get_config(struct intel_encoder *encoder, struct intel_crtc_state *crtc_state) { @@ -4606,7 +4616,9 @@ void intel_ddi_init(struct drm_i915_private *dev_priv, enum port port) encoder->cloneable = 0; encoder->pipe_mask = ~0; - if (IS_ALDERLAKE_S(dev_priv)) { + if (IS_DG2(dev_priv)) { + encoder->get_config = dg2_ddi_get_config; + } else if (IS_ALDERLAKE_S(dev_priv)) { encoder->enable_clock = adls_ddi_enable_clock; encoder->disable_clock = adls_ddi_disable_clock; encoder->is_clock_enabled = adls_ddi_is_clock_enabled; diff --git a/drivers/gpu/drm/i915/display/intel_display.c b/drivers/gpu/drm/i915/display/intel_display.c index 91f6964ec406..cce520b6dfcf 100644 --- a/drivers/gpu/drm/i915/display/intel_display.c +++ b/drivers/gpu/drm/i915/display/intel_display.c @@ -9113,6 +9113,52 @@ verify_shared_dpll_state(struct intel_crtc *crtc, } } +static void +verify_mpllb_state(struct intel_atomic_state *state, + struct intel_crtc_state *new_crtc_state) +{ + struct drm_i915_private *i915 = to_i915(state->base.dev); + struct intel_mpllb_state mpllb_hw_state = { 0 }; + struct intel_mpllb_state *mpllb_sw_state = &new_crtc_state->mpllb_state; + struct intel_crtc *crtc = to_intel_crtc(new_crtc_state->uapi.crtc); + struct intel_encoder *encoder; + + if (!IS_DG2(i915)) + return; + + if (!new_crtc_state->hw.active) + return; + + encoder = intel_get_crtc_new_encoder(state, new_crtc_state); + intel_mpllb_readout_hw_state(encoder, &mpllb_hw_state); + +#define MPLLB_CHECK(name) do { \ + if (mpllb_sw_state->name != mpllb_hw_state.name) { \ + pipe_config_mismatch(false, crtc, "MPLLB:" __stringify(name), \ + "(expected 0x%08x, found 0x%08x)", \ + mpllb_sw_state->name, \ + mpllb_hw_state.name); \ + } \ +} while (0) + + MPLLB_CHECK(mpllb_cp); + MPLLB_CHECK(mpllb_div); + MPLLB_CHECK(mpllb_div2); + MPLLB_CHECK(mpllb_fracn1); + MPLLB_CHECK(mpllb_fracn2); + MPLLB_CHECK(mpllb_sscen); + MPLLB_CHECK(mpllb_sscstep); + + /* + * ref_control is handled by the hardware/firemware and never + * programmed by the software, but the proper values are supplied + * in the bspec for verification purposes. + */ + MPLLB_CHECK(ref_control); + +#undef MPLLB_CHECK +} + static void intel_modeset_verify_crtc(struct intel_crtc *crtc, struct intel_atomic_state *state, @@ -9126,6 +9172,7 @@ intel_modeset_verify_crtc(struct intel_crtc *crtc, verify_connector_state(state, crtc); verify_crtc_state(crtc, old_crtc_state, new_crtc_state); verify_shared_dpll_state(crtc, old_crtc_state, new_crtc_state); + verify_mpllb_state(state, new_crtc_state); } static void diff --git a/drivers/gpu/drm/i915/display/intel_hdmi.c b/drivers/gpu/drm/i915/display/intel_hdmi.c index 852af2b23540..b04685bb6439 100644 --- a/drivers/gpu/drm/i915/display/intel_hdmi.c +++ b/drivers/gpu/drm/i915/display/intel_hdmi.c @@ -51,6 +51,7 @@ #include "intel_hdmi.h" #include "intel_lspcon.h" #include "intel_panel.h" +#include "intel_snps_phy.h" static struct drm_device *intel_hdmi_to_dev(struct intel_hdmi *intel_hdmi) { @@ -1850,6 +1851,16 @@ hdmi_port_clock_valid(struct intel_hdmi *hdmi, if (IS_CHERRYVIEW(dev_priv) && clock > 216000 && clock < 240000) return MODE_CLOCK_RANGE; + /* + * SNPS PHYs' MPLLB table-based programming can only handle a fixed + * set of link rates. + * + * FIXME: We will hopefully get an algorithmic way of programming + * the MPLLB for HDMI in the future. + */ + if (IS_DG2(dev_priv)) + return intel_snps_phy_check_hdmi_link_rate(clock); + return MODE_OK; } diff --git a/drivers/gpu/drm/i915/display/intel_snps_phy.c b/drivers/gpu/drm/i915/display/intel_snps_phy.c index 6d9205906595..1317b4e94b50 100644 --- a/drivers/gpu/drm/i915/display/intel_snps_phy.c +++ b/drivers/gpu/drm/i915/display/intel_snps_phy.c @@ -3,6 +3,8 @@ * Copyright © 2019 Intel Corporation */ +#include + #include "intel_de.h" #include "intel_display_types.h" #include "intel_snps_phy.h" @@ -375,14 +377,172 @@ static const struct intel_mpllb_state *dg2_edp_tables[] = { NULL, }; -int intel_mpllb_calc_state(struct intel_crtc_state *crtc_state, - struct intel_encoder *encoder) -{ - const struct intel_mpllb_state **tables; - int i; +/* + * HDMI link rates with 100 MHz reference clock. + */ + +static const struct intel_mpllb_state dg2_hdmi_25_175 = { + .clock = 25175, + .ref_control = + REG_FIELD_PREP(SNPS_PHY_REF_CONTROL_REF_RANGE, 3), + .mpllb_cp = + REG_FIELD_PREP(SNPS_PHY_MPLLB_CP_INT, 5) | + REG_FIELD_PREP(SNPS_PHY_MPLLB_CP_PROP, 15) | + REG_FIELD_PREP(SNPS_PHY_MPLLB_CP_INT_GS, 64) | + REG_FIELD_PREP(SNPS_PHY_MPLLB_CP_PROP_GS, 124), + .mpllb_div = + REG_FIELD_PREP(SNPS_PHY_MPLLB_DIV5_CLK_EN, 1) | + REG_FIELD_PREP(SNPS_PHY_MPLLB_TX_CLK_DIV, 5) | + REG_FIELD_PREP(SNPS_PHY_MPLLB_PMIX_EN, 1) | + REG_FIELD_PREP(SNPS_PHY_MPLLB_V2I, 2), + .mpllb_div2 = + REG_FIELD_PREP(SNPS_PHY_MPLLB_REF_CLK_DIV, 1) | + REG_FIELD_PREP(SNPS_PHY_MPLLB_MULTIPLIER, 128) | + REG_FIELD_PREP(SNPS_PHY_MPLLB_HDMI_DIV, 1), + .mpllb_fracn1 = + REG_FIELD_PREP(SNPS_PHY_MPLLB_FRACN_CGG_UPDATE_EN, 1) | + REG_FIELD_PREP(SNPS_PHY_MPLLB_FRACN_EN, 1) | + REG_FIELD_PREP(SNPS_PHY_MPLLB_FRACN_DEN, 143), + .mpllb_fracn2 = + REG_FIELD_PREP(SNPS_PHY_MPLLB_FRACN_QUOT, 36663) | + REG_FIELD_PREP(SNPS_PHY_MPLLB_FRACN_REM, 71), + .mpllb_sscen = + REG_FIELD_PREP(SNPS_PHY_MPLLB_SSC_UP_SPREAD, 1), +}; + +static const struct intel_mpllb_state dg2_hdmi_27_0 = { + .clock = 27000, + .ref_control = + REG_FIELD_PREP(SNPS_PHY_REF_CONTROL_REF_RANGE, 3), + .mpllb_cp = + REG_FIELD_PREP(SNPS_PHY_MPLLB_CP_INT, 5) | + REG_FIELD_PREP(SNPS_PHY_MPLLB_CP_PROP, 15) | + REG_FIELD_PREP(SNPS_PHY_MPLLB_CP_INT_GS, 64) | + REG_FIELD_PREP(SNPS_PHY_MPLLB_CP_PROP_GS, 124), + .mpllb_div = + REG_FIELD_PREP(SNPS_PHY_MPLLB_DIV5_CLK_EN, 1) | + REG_FIELD_PREP(SNPS_PHY_MPLLB_TX_CLK_DIV, 5) | + REG_FIELD_PREP(SNPS_PHY_MPLLB_PMIX_EN, 1) | + REG_FIELD_PREP(SNPS_PHY_MPLLB_V2I, 2), + .mpllb_div2 = + REG_FIELD_PREP(SNPS_PHY_MPLLB_REF_CLK_DIV, 1) | + REG_FIELD_PREP(SNPS_PHY_MPLLB_MULTIPLIER, 140) | + REG_FIELD_PREP(SNPS_PHY_MPLLB_HDMI_DIV, 1), + .mpllb_fracn1 = + REG_FIELD_PREP(SNPS_PHY_MPLLB_FRACN_CGG_UPDATE_EN, 1) | + REG_FIELD_PREP(SNPS_PHY_MPLLB_FRACN_EN, 1) | + REG_FIELD_PREP(SNPS_PHY_MPLLB_FRACN_DEN, 5), + .mpllb_fracn2 = + REG_FIELD_PREP(SNPS_PHY_MPLLB_FRACN_QUOT, 26214) | + REG_FIELD_PREP(SNPS_PHY_MPLLB_FRACN_REM, 2), + .mpllb_sscen = + REG_FIELD_PREP(SNPS_PHY_MPLLB_SSC_UP_SPREAD, 1), +}; + +static const struct intel_mpllb_state dg2_hdmi_74_25 = { + .clock = 74250, + .ref_control = + REG_FIELD_PREP(SNPS_PHY_REF_CONTROL_REF_RANGE, 3), + .mpllb_cp = + REG_FIELD_PREP(SNPS_PHY_MPLLB_CP_INT, 4) | + REG_FIELD_PREP(SNPS_PHY_MPLLB_CP_PROP, 15) | + REG_FIELD_PREP(SNPS_PHY_MPLLB_CP_INT_GS, 64) | + REG_FIELD_PREP(SNPS_PHY_MPLLB_CP_PROP_GS, 124), + .mpllb_div = + REG_FIELD_PREP(SNPS_PHY_MPLLB_DIV5_CLK_EN, 1) | + REG_FIELD_PREP(SNPS_PHY_MPLLB_TX_CLK_DIV, 3) | + REG_FIELD_PREP(SNPS_PHY_MPLLB_PMIX_EN, 1) | + REG_FIELD_PREP(SNPS_PHY_MPLLB_V2I, 2) | + REG_FIELD_PREP(SNPS_PHY_MPLLB_FREQ_VCO, 3), + .mpllb_div2 = + REG_FIELD_PREP(SNPS_PHY_MPLLB_REF_CLK_DIV, 1) | + REG_FIELD_PREP(SNPS_PHY_MPLLB_MULTIPLIER, 86) | + REG_FIELD_PREP(SNPS_PHY_MPLLB_HDMI_DIV, 1), + .mpllb_fracn1 = + REG_FIELD_PREP(SNPS_PHY_MPLLB_FRACN_CGG_UPDATE_EN, 1) | + REG_FIELD_PREP(SNPS_PHY_MPLLB_FRACN_EN, 1) | + REG_FIELD_PREP(SNPS_PHY_MPLLB_FRACN_DEN, 5), + .mpllb_fracn2 = + REG_FIELD_PREP(SNPS_PHY_MPLLB_FRACN_QUOT, 26214) | + REG_FIELD_PREP(SNPS_PHY_MPLLB_FRACN_REM, 2), + .mpllb_sscen = + REG_FIELD_PREP(SNPS_PHY_MPLLB_SSC_UP_SPREAD, 1), +}; + +static const struct intel_mpllb_state dg2_hdmi_148_5 = { + .clock = 148500, + .ref_control = + REG_FIELD_PREP(SNPS_PHY_REF_CONTROL_REF_RANGE, 3), + .mpllb_cp = + REG_FIELD_PREP(SNPS_PHY_MPLLB_CP_INT, 4) | + REG_FIELD_PREP(SNPS_PHY_MPLLB_CP_PROP, 15) | + REG_FIELD_PREP(SNPS_PHY_MPLLB_CP_INT_GS, 64) | + REG_FIELD_PREP(SNPS_PHY_MPLLB_CP_PROP_GS, 124), + .mpllb_div = + REG_FIELD_PREP(SNPS_PHY_MPLLB_DIV5_CLK_EN, 1) | + REG_FIELD_PREP(SNPS_PHY_MPLLB_TX_CLK_DIV, 2) | + REG_FIELD_PREP(SNPS_PHY_MPLLB_PMIX_EN, 1) | + REG_FIELD_PREP(SNPS_PHY_MPLLB_V2I, 2) | + REG_FIELD_PREP(SNPS_PHY_MPLLB_FREQ_VCO, 3), + .mpllb_div2 = + REG_FIELD_PREP(SNPS_PHY_MPLLB_REF_CLK_DIV, 1) | + REG_FIELD_PREP(SNPS_PHY_MPLLB_MULTIPLIER, 86) | + REG_FIELD_PREP(SNPS_PHY_MPLLB_HDMI_DIV, 1), + .mpllb_fracn1 = + REG_FIELD_PREP(SNPS_PHY_MPLLB_FRACN_CGG_UPDATE_EN, 1) | + REG_FIELD_PREP(SNPS_PHY_MPLLB_FRACN_EN, 1) | + REG_FIELD_PREP(SNPS_PHY_MPLLB_FRACN_DEN, 5), + .mpllb_fracn2 = + REG_FIELD_PREP(SNPS_PHY_MPLLB_FRACN_QUOT, 26214) | + REG_FIELD_PREP(SNPS_PHY_MPLLB_FRACN_REM, 2), + .mpllb_sscen = + REG_FIELD_PREP(SNPS_PHY_MPLLB_SSC_UP_SPREAD, 1), +}; + +static const struct intel_mpllb_state dg2_hdmi_594 = { + .clock = 594000, + .ref_control = + REG_FIELD_PREP(SNPS_PHY_REF_CONTROL_REF_RANGE, 3), + .mpllb_cp = + REG_FIELD_PREP(SNPS_PHY_MPLLB_CP_INT, 4) | + REG_FIELD_PREP(SNPS_PHY_MPLLB_CP_PROP, 15) | + REG_FIELD_PREP(SNPS_PHY_MPLLB_CP_INT_GS, 64) | + REG_FIELD_PREP(SNPS_PHY_MPLLB_CP_PROP_GS, 124), + .mpllb_div = + REG_FIELD_PREP(SNPS_PHY_MPLLB_DIV5_CLK_EN, 1) | + REG_FIELD_PREP(SNPS_PHY_MPLLB_PMIX_EN, 1) | + REG_FIELD_PREP(SNPS_PHY_MPLLB_V2I, 2) | + REG_FIELD_PREP(SNPS_PHY_MPLLB_FREQ_VCO, 3), + .mpllb_div2 = + REG_FIELD_PREP(SNPS_PHY_MPLLB_REF_CLK_DIV, 1) | + REG_FIELD_PREP(SNPS_PHY_MPLLB_MULTIPLIER, 86) | + REG_FIELD_PREP(SNPS_PHY_MPLLB_HDMI_DIV, 1), + .mpllb_fracn1 = + REG_FIELD_PREP(SNPS_PHY_MPLLB_FRACN_CGG_UPDATE_EN, 1) | + REG_FIELD_PREP(SNPS_PHY_MPLLB_FRACN_EN, 1) | + REG_FIELD_PREP(SNPS_PHY_MPLLB_FRACN_DEN, 5), + .mpllb_fracn2 = + REG_FIELD_PREP(SNPS_PHY_MPLLB_FRACN_QUOT, 26214) | + REG_FIELD_PREP(SNPS_PHY_MPLLB_FRACN_REM, 2), + .mpllb_sscen = + REG_FIELD_PREP(SNPS_PHY_MPLLB_SSC_UP_SPREAD, 1), +}; +static const struct intel_mpllb_state *dg2_hdmi_tables[] = { + &dg2_hdmi_25_175, + &dg2_hdmi_27_0, + &dg2_hdmi_74_25, + &dg2_hdmi_148_5, + &dg2_hdmi_594, + NULL, +}; + +static const struct intel_mpllb_state ** +intel_mpllb_tables_get(struct intel_crtc_state *crtc_state, + struct intel_encoder *encoder) +{ if (intel_crtc_has_type(crtc_state, INTEL_OUTPUT_EDP)) { - tables = dg2_edp_tables; + return dg2_edp_tables; } else if (intel_crtc_has_dp_encoder(crtc_state)) { /* * FIXME: Initially we're just enabling the "combo" outputs on @@ -397,15 +557,41 @@ int intel_mpllb_calc_state(struct intel_crtc_state *crtc_state, * that to determine which table to use. */ if (0) - tables = dg2_dp_38_4_tables; + return dg2_dp_38_4_tables; else - tables = dg2_dp_100_tables; - } else { - /* TODO: Add HDMI support */ - MISSING_CASE(encoder->type); - return -EINVAL; + return dg2_dp_100_tables; + } else if (intel_crtc_has_type(crtc_state, INTEL_OUTPUT_HDMI)) { + return dg2_hdmi_tables; } + MISSING_CASE(encoder->type); + return NULL; +} + +int intel_mpllb_calc_state(struct intel_crtc_state *crtc_state, + struct intel_encoder *encoder) +{ + const struct intel_mpllb_state **tables; + int i; + + if (intel_crtc_has_type(crtc_state, INTEL_OUTPUT_HDMI)) { + if (intel_snps_phy_check_hdmi_link_rate(crtc_state->port_clock) + != MODE_OK) { + /* + * FIXME: Can only support fixed HDMI frequencies + * until we have a proper algorithm under a valid + * license. + */ + DRM_DEBUG_KMS("Can't support HDMI link rate %d\n", + crtc_state->port_clock); + return -EINVAL; + } + } + + tables = intel_mpllb_tables_get(crtc_state, encoder); + if (!tables) + return -EINVAL; + for (i = 0; tables[i]; i++) { if (crtc_state->port_clock <= tables[i]->clock) { crtc_state->mpllb_state = *tables[i]; @@ -515,3 +701,79 @@ void intel_mpllb_disable(struct intel_encoder *encoder) * We handle this step in bxt_set_cdclk(). */ } + +int intel_mpllb_calc_port_clock(struct intel_encoder *encoder, + const struct intel_mpllb_state *pll_state) +{ + unsigned int frac_quot = 0, frac_rem = 0, frac_den = 1; + unsigned int multiplier, tx_clk_div, refclk; + bool frac_en; + + if (0) + refclk = 38400; + else + refclk = 100000; + + refclk >>= REG_FIELD_GET(SNPS_PHY_MPLLB_REF_CLK_DIV, pll_state->mpllb_div2) - 1; + + frac_en = REG_FIELD_GET(SNPS_PHY_MPLLB_FRACN_EN, pll_state->mpllb_fracn1); + + if (frac_en) { + frac_quot = REG_FIELD_GET(SNPS_PHY_MPLLB_FRACN_QUOT, pll_state->mpllb_fracn2); + frac_rem = REG_FIELD_GET(SNPS_PHY_MPLLB_FRACN_REM, pll_state->mpllb_fracn2); + frac_den = REG_FIELD_GET(SNPS_PHY_MPLLB_FRACN_DEN, pll_state->mpllb_fracn1); + } + + multiplier = REG_FIELD_GET(SNPS_PHY_MPLLB_MULTIPLIER, pll_state->mpllb_div2) / 2 + 16; + + tx_clk_div = REG_FIELD_GET(SNPS_PHY_MPLLB_TX_CLK_DIV, pll_state->mpllb_div); + + return DIV_ROUND_CLOSEST_ULL(mul_u32_u32(refclk, (multiplier << 16) + frac_quot) + + DIV_ROUND_CLOSEST(refclk * frac_rem, frac_den), + 10 << (tx_clk_div + 16)); +} + +void intel_mpllb_readout_hw_state(struct intel_encoder *encoder, + struct intel_mpllb_state *pll_state) +{ + struct drm_i915_private *dev_priv = to_i915(encoder->base.dev); + enum phy phy = intel_port_to_phy(dev_priv, encoder->port); + + pll_state->mpllb_cp = intel_de_read(dev_priv, SNPS_PHY_MPLLB_CP(phy)); + pll_state->mpllb_div = intel_de_read(dev_priv, SNPS_PHY_MPLLB_DIV(phy)); + pll_state->mpllb_div2 = intel_de_read(dev_priv, SNPS_PHY_MPLLB_DIV2(phy)); + pll_state->mpllb_sscen = intel_de_read(dev_priv, SNPS_PHY_MPLLB_SSCEN(phy)); + pll_state->mpllb_sscstep = intel_de_read(dev_priv, SNPS_PHY_MPLLB_SSCSTEP(phy)); + pll_state->mpllb_fracn1 = intel_de_read(dev_priv, SNPS_PHY_MPLLB_FRACN1(phy)); + pll_state->mpllb_fracn2 = intel_de_read(dev_priv, SNPS_PHY_MPLLB_FRACN2(phy)); + + /* + * REF_CONTROL is under firmware control and never programmed by the + * driver; we read it only for sanity checking purposes. The bspec + * only tells us the expected value for one field in this register, + * so we'll only read out those specific bits here. + */ + pll_state->ref_control = intel_de_read(dev_priv, SNPS_PHY_REF_CONTROL(phy)) & + SNPS_PHY_REF_CONTROL_REF_RANGE; + + /* + * MPLLB_DIV is programmed twice, once with the software-computed + * state, then again with the MPLLB_FORCE_EN bit added. Drop that + * extra bit during readout so that we return the actual expected + * software state. + */ + pll_state->mpllb_div &= ~SNPS_PHY_MPLLB_FORCE_EN; +} + +int intel_snps_phy_check_hdmi_link_rate(int clock) +{ + const struct intel_mpllb_state **tables = dg2_hdmi_tables; + int i; + + for (i = 0; tables[i]; i++) { + if (clock == tables[i]->clock) + return MODE_OK; + } + + return MODE_CLOCK_RANGE; +} diff --git a/drivers/gpu/drm/i915/display/intel_snps_phy.h b/drivers/gpu/drm/i915/display/intel_snps_phy.h index 205ab46f0b67..ca4c2a25182b 100644 --- a/drivers/gpu/drm/i915/display/intel_snps_phy.h +++ b/drivers/gpu/drm/i915/display/intel_snps_phy.h @@ -8,11 +8,18 @@ struct intel_encoder; struct intel_crtc_state; +struct intel_mpllb_state; int intel_mpllb_calc_state(struct intel_crtc_state *crtc_state, struct intel_encoder *encoder); void intel_mpllb_enable(struct intel_encoder *encoder, const struct intel_crtc_state *crtc_state); void intel_mpllb_disable(struct intel_encoder *encoder); +void intel_mpllb_readout_hw_state(struct intel_encoder *encoder, + struct intel_mpllb_state *pll_state); +int intel_mpllb_calc_port_clock(struct intel_encoder *encoder, + const struct intel_mpllb_state *pll_state); + +int intel_snps_phy_check_hdmi_link_rate(int clock); #endif /* __INTEL_SNPS_PHY_H__ */ diff --git a/drivers/gpu/drm/i915/i915_reg.h b/drivers/gpu/drm/i915/i915_reg.h index c0417c994b97..15465f9cf9ab 100644 --- a/drivers/gpu/drm/i915/i915_reg.h +++ b/drivers/gpu/drm/i915/i915_reg.h @@ -2325,12 +2325,15 @@ static inline bool i915_mmio_reg_valid(i915_reg_t reg) #define SNPS_PHY_MPLLB_SSCEN(phy) _MMIO_SNPS(phy, 0x168014) #define SNPS_PHY_MPLLB_SSC_EN REG_BIT(31) +#define SNPS_PHY_MPLLB_SSC_UP_SPREAD REG_BIT(30) #define SNPS_PHY_MPLLB_SSC_PEAK REG_GENMASK(29, 10) #define SNPS_PHY_MPLLB_SSCSTEP(phy) _MMIO_SNPS(phy, 0x168018) #define SNPS_PHY_MPLLB_SSC_STEPSIZE REG_GENMASK(31, 11) #define SNPS_PHY_MPLLB_DIV2(phy) _MMIO_SNPS(phy, 0x16801C) +#define SNPS_PHY_MPLLB_HDMI_PIXEL_CLK_DIV REG_GENMASK(19, 18) +#define SNPS_PHY_MPLLB_HDMI_DIV REG_GENMASK(17, 15) #define SNPS_PHY_MPLLB_REF_CLK_DIV REG_GENMASK(14, 12) #define SNPS_PHY_MPLLB_MULTIPLIER REG_GENMASK(11, 0) -- 2.25.4 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=-16.8 required=3.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,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 2A4CAC11F78 for ; Thu, 1 Jul 2021 20:26:48 +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 E1704613F3 for ; Thu, 1 Jul 2021 20:26:47 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org E1704613F3 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=intel.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=intel-gfx-bounces@lists.freedesktop.org Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id 4E57B6EC0F; Thu, 1 Jul 2021 20:25:43 +0000 (UTC) Received: from mga17.intel.com (mga17.intel.com [192.55.52.151]) by gabe.freedesktop.org (Postfix) with ESMTPS id EEAD76EC06; Thu, 1 Jul 2021 20:25:23 +0000 (UTC) X-IronPort-AV: E=McAfee;i="6200,9189,10032"; a="188998669" X-IronPort-AV: E=Sophos;i="5.83,315,1616482800"; d="scan'208";a="188998669" Received: from fmsmga005.fm.intel.com ([10.253.24.32]) by fmsmga107.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 01 Jul 2021 13:25:21 -0700 X-IronPort-AV: E=Sophos;i="5.83,315,1616482800"; d="scan'208";a="644564533" Received: from mdroper-desk1.fm.intel.com ([10.1.27.134]) by fmsmga005-auth.fm.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 01 Jul 2021 13:25:20 -0700 From: Matt Roper To: intel-gfx@lists.freedesktop.org Date: Thu, 1 Jul 2021 13:24:17 -0700 Message-Id: <20210701202427.1547543-44-matthew.d.roper@intel.com> X-Mailer: git-send-email 2.25.4 In-Reply-To: <20210701202427.1547543-1-matthew.d.roper@intel.com> References: <20210701202427.1547543-1-matthew.d.roper@intel.com> MIME-Version: 1.0 Subject: [Intel-gfx] [PATCH 43/53] drm/i915/dg2: Add MPLLB programming for HDMI X-BeenThere: intel-gfx@lists.freedesktop.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Intel graphics driver community testing & development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: dri-devel@lists.freedesktop.org Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" QXQgdGhlIG1vbWVudCB3ZSBkb24ndCBoYXZlIGEgcHJvcGVyIGFsZ29yaXRobSB0aGF0IGNhbiBi ZSB1c2VkIHRvCmNhbGN1bGF0ZSBQSFkgc2V0dGluZ3MgZm9yIGFyYml0cmFyeSBIRE1JIGxpbmsg cmF0ZXMuICBUaGUgUEhZIHRhYmxlcwpoZXJlIHNob3VsZCBzdXBwb3J0IHRoZSByZWd1bGFyIG1v ZGVzIG9mIHJlYWwtd29ybGQgSERNSSBtb25pdG9ycy4KCkJzcGVjOiA1NDAzMgpDYzogTWF0dCBB dHdvb2QgPG1hdHRoZXcucy5hdHdvb2RAaW50ZWwuY29tPgpTaWduZWQtb2ZmLWJ5OiBNYXR0IFJv cGVyIDxtYXR0aGV3LmQucm9wZXJAaW50ZWwuY29tPgpTaWduZWQtb2ZmLWJ5OiBWYW5kaXRhIEt1 bGthcm5pIDx2YW5kaXRhLmt1bGthcm5pQGludGVsLmNvbT4KLS0tCiBkcml2ZXJzL2dwdS9kcm0v aTkxNS9kaXNwbGF5L2ludGVsX2RkaS5jICAgICAgfCAgMTQgKy0KIGRyaXZlcnMvZ3B1L2RybS9p OTE1L2Rpc3BsYXkvaW50ZWxfZGlzcGxheS5jICB8ICA0NyArKysKIGRyaXZlcnMvZ3B1L2RybS9p OTE1L2Rpc3BsYXkvaW50ZWxfaGRtaS5jICAgICB8ICAxMSArCiBkcml2ZXJzL2dwdS9kcm0vaTkx NS9kaXNwbGF5L2ludGVsX3NucHNfcGh5LmMgfCAyODYgKysrKysrKysrKysrKysrKystCiBkcml2 ZXJzL2dwdS9kcm0vaTkxNS9kaXNwbGF5L2ludGVsX3NucHNfcGh5LmggfCAgIDcgKwogZHJpdmVy cy9ncHUvZHJtL2k5MTUvaTkxNV9yZWcuaCAgICAgICAgICAgICAgIHwgICAzICsKIDYgZmlsZXMg Y2hhbmdlZCwgMzU1IGluc2VydGlvbnMoKyksIDEzIGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBh L2RyaXZlcnMvZ3B1L2RybS9pOTE1L2Rpc3BsYXkvaW50ZWxfZGRpLmMgYi9kcml2ZXJzL2dwdS9k cm0vaTkxNS9kaXNwbGF5L2ludGVsX2RkaS5jCmluZGV4IDI2YTNhYTczZmNjNC4uOTI5YTk1ZGRi MzE2IDEwMDY0NAotLS0gYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9kaXNwbGF5L2ludGVsX2RkaS5j CisrKyBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2Rpc3BsYXkvaW50ZWxfZGRpLmMKQEAgLTUxLDYg KzUxLDcgQEAKICNpbmNsdWRlICJpbnRlbF9wYW5lbC5oIgogI2luY2x1ZGUgImludGVsX3Bwcy5o IgogI2luY2x1ZGUgImludGVsX3Bzci5oIgorI2luY2x1ZGUgImludGVsX3NucHNfcGh5LmgiCiAj aW5jbHVkZSAiaW50ZWxfc3ByaXRlLmgiCiAjaW5jbHVkZSAiaW50ZWxfdGMuaCIKICNpbmNsdWRl ICJpbnRlbF92ZHNjLmgiCkBAIC0zNzQ1LDYgKzM3NDYsMTUgQEAgdm9pZCBpbnRlbF9kZGlfZ2V0 X2Nsb2NrKHN0cnVjdCBpbnRlbF9lbmNvZGVyICplbmNvZGVyLAogCQkJCQkJICAgICAmY3J0Y19z dGF0ZS0+ZHBsbF9od19zdGF0ZSk7CiB9CiAKK3N0YXRpYyB2b2lkIGRnMl9kZGlfZ2V0X2NvbmZp ZyhzdHJ1Y3QgaW50ZWxfZW5jb2RlciAqZW5jb2RlciwKKwkJCQlzdHJ1Y3QgaW50ZWxfY3J0Y19z dGF0ZSAqY3J0Y19zdGF0ZSkKK3sKKwlpbnRlbF9tcGxsYl9yZWFkb3V0X2h3X3N0YXRlKGVuY29k ZXIsICZjcnRjX3N0YXRlLT5tcGxsYl9zdGF0ZSk7CisJY3J0Y19zdGF0ZS0+cG9ydF9jbG9jayA9 IGludGVsX21wbGxiX2NhbGNfcG9ydF9jbG9jayhlbmNvZGVyLCAmY3J0Y19zdGF0ZS0+bXBsbGJf c3RhdGUpOworCisJaW50ZWxfZGRpX2dldF9jb25maWcoZW5jb2RlciwgY3J0Y19zdGF0ZSk7Cit9 CisKIHN0YXRpYyB2b2lkIGFkbHNfZGRpX2dldF9jb25maWcoc3RydWN0IGludGVsX2VuY29kZXIg KmVuY29kZXIsCiAJCQkJc3RydWN0IGludGVsX2NydGNfc3RhdGUgKmNydGNfc3RhdGUpCiB7CkBA IC00NjA2LDcgKzQ2MTYsOSBAQCB2b2lkIGludGVsX2RkaV9pbml0KHN0cnVjdCBkcm1faTkxNV9w cml2YXRlICpkZXZfcHJpdiwgZW51bSBwb3J0IHBvcnQpCiAJZW5jb2Rlci0+Y2xvbmVhYmxlID0g MDsKIAllbmNvZGVyLT5waXBlX21hc2sgPSB+MDsKIAotCWlmIChJU19BTERFUkxBS0VfUyhkZXZf cHJpdikpIHsKKwlpZiAoSVNfREcyKGRldl9wcml2KSkgeworCQllbmNvZGVyLT5nZXRfY29uZmln ID0gZGcyX2RkaV9nZXRfY29uZmlnOworCX0gZWxzZSBpZiAoSVNfQUxERVJMQUtFX1MoZGV2X3By aXYpKSB7CiAJCWVuY29kZXItPmVuYWJsZV9jbG9jayA9IGFkbHNfZGRpX2VuYWJsZV9jbG9jazsK IAkJZW5jb2Rlci0+ZGlzYWJsZV9jbG9jayA9IGFkbHNfZGRpX2Rpc2FibGVfY2xvY2s7CiAJCWVu Y29kZXItPmlzX2Nsb2NrX2VuYWJsZWQgPSBhZGxzX2RkaV9pc19jbG9ja19lbmFibGVkOwpkaWZm IC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZGlzcGxheS9pbnRlbF9kaXNwbGF5LmMgYi9k cml2ZXJzL2dwdS9kcm0vaTkxNS9kaXNwbGF5L2ludGVsX2Rpc3BsYXkuYwppbmRleCA5MWY2OTY0 ZWM0MDYuLmNjZTUyMGI2ZGZjZiAxMDA2NDQKLS0tIGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvZGlz cGxheS9pbnRlbF9kaXNwbGF5LmMKKysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZGlzcGxheS9p bnRlbF9kaXNwbGF5LmMKQEAgLTkxMTMsNiArOTExMyw1MiBAQCB2ZXJpZnlfc2hhcmVkX2RwbGxf c3RhdGUoc3RydWN0IGludGVsX2NydGMgKmNydGMsCiAJfQogfQogCitzdGF0aWMgdm9pZAordmVy aWZ5X21wbGxiX3N0YXRlKHN0cnVjdCBpbnRlbF9hdG9taWNfc3RhdGUgKnN0YXRlLAorCQkgICBz dHJ1Y3QgaW50ZWxfY3J0Y19zdGF0ZSAqbmV3X2NydGNfc3RhdGUpCit7CisJc3RydWN0IGRybV9p OTE1X3ByaXZhdGUgKmk5MTUgPSB0b19pOTE1KHN0YXRlLT5iYXNlLmRldik7CisJc3RydWN0IGlu dGVsX21wbGxiX3N0YXRlIG1wbGxiX2h3X3N0YXRlID0geyAwIH07CisJc3RydWN0IGludGVsX21w bGxiX3N0YXRlICptcGxsYl9zd19zdGF0ZSA9ICZuZXdfY3J0Y19zdGF0ZS0+bXBsbGJfc3RhdGU7 CisJc3RydWN0IGludGVsX2NydGMgKmNydGMgPSB0b19pbnRlbF9jcnRjKG5ld19jcnRjX3N0YXRl LT51YXBpLmNydGMpOworCXN0cnVjdCBpbnRlbF9lbmNvZGVyICplbmNvZGVyOworCisJaWYgKCFJ U19ERzIoaTkxNSkpCisJCXJldHVybjsKKworCWlmICghbmV3X2NydGNfc3RhdGUtPmh3LmFjdGl2 ZSkKKwkJcmV0dXJuOworCisJZW5jb2RlciA9IGludGVsX2dldF9jcnRjX25ld19lbmNvZGVyKHN0 YXRlLCBuZXdfY3J0Y19zdGF0ZSk7CisJaW50ZWxfbXBsbGJfcmVhZG91dF9od19zdGF0ZShlbmNv ZGVyLCAmbXBsbGJfaHdfc3RhdGUpOworCisjZGVmaW5lIE1QTExCX0NIRUNLKG5hbWUpIGRvIHsg XAorCWlmIChtcGxsYl9zd19zdGF0ZS0+bmFtZSAhPSBtcGxsYl9od19zdGF0ZS5uYW1lKSB7IFwK KwkJcGlwZV9jb25maWdfbWlzbWF0Y2goZmFsc2UsIGNydGMsICJNUExMQjoiIF9fc3RyaW5naWZ5 KG5hbWUpLCBcCisJCQkJICAgICAiKGV4cGVjdGVkIDB4JTA4eCwgZm91bmQgMHglMDh4KSIsIFwK KwkJCQkgICAgIG1wbGxiX3N3X3N0YXRlLT5uYW1lLCBcCisJCQkJICAgICBtcGxsYl9od19zdGF0 ZS5uYW1lKTsgXAorCX0gXAorfSB3aGlsZSAoMCkKKworCU1QTExCX0NIRUNLKG1wbGxiX2NwKTsK KwlNUExMQl9DSEVDSyhtcGxsYl9kaXYpOworCU1QTExCX0NIRUNLKG1wbGxiX2RpdjIpOworCU1Q TExCX0NIRUNLKG1wbGxiX2ZyYWNuMSk7CisJTVBMTEJfQ0hFQ0sobXBsbGJfZnJhY24yKTsKKwlN UExMQl9DSEVDSyhtcGxsYl9zc2Nlbik7CisJTVBMTEJfQ0hFQ0sobXBsbGJfc3Njc3RlcCk7CisK KwkvKgorCSAqIHJlZl9jb250cm9sIGlzIGhhbmRsZWQgYnkgdGhlIGhhcmR3YXJlL2ZpcmVtd2Fy ZSBhbmQgbmV2ZXIKKwkgKiBwcm9ncmFtbWVkIGJ5IHRoZSBzb2Z0d2FyZSwgYnV0IHRoZSBwcm9w ZXIgdmFsdWVzIGFyZSBzdXBwbGllZAorCSAqIGluIHRoZSBic3BlYyBmb3IgdmVyaWZpY2F0aW9u IHB1cnBvc2VzLgorCSAqLworCU1QTExCX0NIRUNLKHJlZl9jb250cm9sKTsKKworI3VuZGVmIE1Q TExCX0NIRUNLCit9CisKIHN0YXRpYyB2b2lkCiBpbnRlbF9tb2Rlc2V0X3ZlcmlmeV9jcnRjKHN0 cnVjdCBpbnRlbF9jcnRjICpjcnRjLAogCQkJICBzdHJ1Y3QgaW50ZWxfYXRvbWljX3N0YXRlICpz dGF0ZSwKQEAgLTkxMjYsNiArOTE3Miw3IEBAIGludGVsX21vZGVzZXRfdmVyaWZ5X2NydGMoc3Ry dWN0IGludGVsX2NydGMgKmNydGMsCiAJdmVyaWZ5X2Nvbm5lY3Rvcl9zdGF0ZShzdGF0ZSwgY3J0 Yyk7CiAJdmVyaWZ5X2NydGNfc3RhdGUoY3J0Yywgb2xkX2NydGNfc3RhdGUsIG5ld19jcnRjX3N0 YXRlKTsKIAl2ZXJpZnlfc2hhcmVkX2RwbGxfc3RhdGUoY3J0Yywgb2xkX2NydGNfc3RhdGUsIG5l d19jcnRjX3N0YXRlKTsKKwl2ZXJpZnlfbXBsbGJfc3RhdGUoc3RhdGUsIG5ld19jcnRjX3N0YXRl KTsKIH0KIAogc3RhdGljIHZvaWQKZGlmZiAtLWdpdCBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2Rp c3BsYXkvaW50ZWxfaGRtaS5jIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvZGlzcGxheS9pbnRlbF9o ZG1pLmMKaW5kZXggODUyYWYyYjIzNTQwLi5iMDQ2ODViYjY0MzkgMTAwNjQ0Ci0tLSBhL2RyaXZl cnMvZ3B1L2RybS9pOTE1L2Rpc3BsYXkvaW50ZWxfaGRtaS5jCisrKyBiL2RyaXZlcnMvZ3B1L2Ry bS9pOTE1L2Rpc3BsYXkvaW50ZWxfaGRtaS5jCkBAIC01MSw2ICs1MSw3IEBACiAjaW5jbHVkZSAi aW50ZWxfaGRtaS5oIgogI2luY2x1ZGUgImludGVsX2xzcGNvbi5oIgogI2luY2x1ZGUgImludGVs X3BhbmVsLmgiCisjaW5jbHVkZSAiaW50ZWxfc25wc19waHkuaCIKIAogc3RhdGljIHN0cnVjdCBk cm1fZGV2aWNlICppbnRlbF9oZG1pX3RvX2RldihzdHJ1Y3QgaW50ZWxfaGRtaSAqaW50ZWxfaGRt aSkKIHsKQEAgLTE4NTAsNiArMTg1MSwxNiBAQCBoZG1pX3BvcnRfY2xvY2tfdmFsaWQoc3RydWN0 IGludGVsX2hkbWkgKmhkbWksCiAJaWYgKElTX0NIRVJSWVZJRVcoZGV2X3ByaXYpICYmIGNsb2Nr ID4gMjE2MDAwICYmIGNsb2NrIDwgMjQwMDAwKQogCQlyZXR1cm4gTU9ERV9DTE9DS19SQU5HRTsK IAorCS8qCisJICogU05QUyBQSFlzJyBNUExMQiB0YWJsZS1iYXNlZCBwcm9ncmFtbWluZyBjYW4g b25seSBoYW5kbGUgYSBmaXhlZAorCSAqIHNldCBvZiBsaW5rIHJhdGVzLgorCSAqCisJICogRklY TUU6IFdlIHdpbGwgaG9wZWZ1bGx5IGdldCBhbiBhbGdvcml0aG1pYyB3YXkgb2YgcHJvZ3JhbW1p bmcKKwkgKiB0aGUgTVBMTEIgZm9yIEhETUkgaW4gdGhlIGZ1dHVyZS4KKwkgKi8KKwlpZiAoSVNf REcyKGRldl9wcml2KSkKKwkJcmV0dXJuIGludGVsX3NucHNfcGh5X2NoZWNrX2hkbWlfbGlua19y YXRlKGNsb2NrKTsKKwogCXJldHVybiBNT0RFX09LOwogfQogCmRpZmYgLS1naXQgYS9kcml2ZXJz L2dwdS9kcm0vaTkxNS9kaXNwbGF5L2ludGVsX3NucHNfcGh5LmMgYi9kcml2ZXJzL2dwdS9kcm0v aTkxNS9kaXNwbGF5L2ludGVsX3NucHNfcGh5LmMKaW5kZXggNmQ5MjA1OTA2NTk1Li4xMzE3YjRl OTRiNTAgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2Rpc3BsYXkvaW50ZWxfc25w c19waHkuYworKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9kaXNwbGF5L2ludGVsX3NucHNfcGh5 LmMKQEAgLTMsNiArMyw4IEBACiAgKiBDb3B5cmlnaHQgwqkgMjAxOSBJbnRlbCBDb3Jwb3JhdGlv bgogICovCiAKKyNpbmNsdWRlIDxsaW51eC91dGlsX21hY3Jvcy5oPgorCiAjaW5jbHVkZSAiaW50 ZWxfZGUuaCIKICNpbmNsdWRlICJpbnRlbF9kaXNwbGF5X3R5cGVzLmgiCiAjaW5jbHVkZSAiaW50 ZWxfc25wc19waHkuaCIKQEAgLTM3NSwxNCArMzc3LDE3MiBAQCBzdGF0aWMgY29uc3Qgc3RydWN0 IGludGVsX21wbGxiX3N0YXRlICpkZzJfZWRwX3RhYmxlc1tdID0gewogCU5VTEwsCiB9OwogCi1p bnQgaW50ZWxfbXBsbGJfY2FsY19zdGF0ZShzdHJ1Y3QgaW50ZWxfY3J0Y19zdGF0ZSAqY3J0Y19z dGF0ZSwKLQkJCSAgIHN0cnVjdCBpbnRlbF9lbmNvZGVyICplbmNvZGVyKQotewotCWNvbnN0IHN0 cnVjdCBpbnRlbF9tcGxsYl9zdGF0ZSAqKnRhYmxlczsKLQlpbnQgaTsKKy8qCisgKiBIRE1JIGxp bmsgcmF0ZXMgd2l0aCAxMDAgTUh6IHJlZmVyZW5jZSBjbG9jay4KKyAqLworCitzdGF0aWMgY29u c3Qgc3RydWN0IGludGVsX21wbGxiX3N0YXRlIGRnMl9oZG1pXzI1XzE3NSA9IHsKKwkuY2xvY2sg PSAyNTE3NSwKKwkucmVmX2NvbnRyb2wgPQorCQlSRUdfRklFTERfUFJFUChTTlBTX1BIWV9SRUZf Q09OVFJPTF9SRUZfUkFOR0UsIDMpLAorCS5tcGxsYl9jcCA9CisJCVJFR19GSUVMRF9QUkVQKFNO UFNfUEhZX01QTExCX0NQX0lOVCwgNSkgfAorCQlSRUdfRklFTERfUFJFUChTTlBTX1BIWV9NUExM Ql9DUF9QUk9QLCAxNSkgfAorCQlSRUdfRklFTERfUFJFUChTTlBTX1BIWV9NUExMQl9DUF9JTlRf R1MsIDY0KSB8CisJCVJFR19GSUVMRF9QUkVQKFNOUFNfUEhZX01QTExCX0NQX1BST1BfR1MsIDEy NCksCisJLm1wbGxiX2RpdiA9CisJCVJFR19GSUVMRF9QUkVQKFNOUFNfUEhZX01QTExCX0RJVjVf Q0xLX0VOLCAxKSB8CisJCVJFR19GSUVMRF9QUkVQKFNOUFNfUEhZX01QTExCX1RYX0NMS19ESVYs IDUpIHwKKwkJUkVHX0ZJRUxEX1BSRVAoU05QU19QSFlfTVBMTEJfUE1JWF9FTiwgMSkgfAorCQlS RUdfRklFTERfUFJFUChTTlBTX1BIWV9NUExMQl9WMkksIDIpLAorCS5tcGxsYl9kaXYyID0KKwkJ UkVHX0ZJRUxEX1BSRVAoU05QU19QSFlfTVBMTEJfUkVGX0NMS19ESVYsIDEpIHwKKwkJUkVHX0ZJ RUxEX1BSRVAoU05QU19QSFlfTVBMTEJfTVVMVElQTElFUiwgMTI4KSB8CisJCVJFR19GSUVMRF9Q UkVQKFNOUFNfUEhZX01QTExCX0hETUlfRElWLCAxKSwKKwkubXBsbGJfZnJhY24xID0KKwkJUkVH X0ZJRUxEX1BSRVAoU05QU19QSFlfTVBMTEJfRlJBQ05fQ0dHX1VQREFURV9FTiwgMSkgfAorCQlS RUdfRklFTERfUFJFUChTTlBTX1BIWV9NUExMQl9GUkFDTl9FTiwgMSkgfAorCQlSRUdfRklFTERf UFJFUChTTlBTX1BIWV9NUExMQl9GUkFDTl9ERU4sIDE0MyksCisJLm1wbGxiX2ZyYWNuMiA9CisJ CVJFR19GSUVMRF9QUkVQKFNOUFNfUEhZX01QTExCX0ZSQUNOX1FVT1QsIDM2NjYzKSB8CisJCVJF R19GSUVMRF9QUkVQKFNOUFNfUEhZX01QTExCX0ZSQUNOX1JFTSwgNzEpLAorCS5tcGxsYl9zc2Nl biA9CisJCVJFR19GSUVMRF9QUkVQKFNOUFNfUEhZX01QTExCX1NTQ19VUF9TUFJFQUQsIDEpLAor fTsKKworc3RhdGljIGNvbnN0IHN0cnVjdCBpbnRlbF9tcGxsYl9zdGF0ZSBkZzJfaGRtaV8yN18w ID0geworCS5jbG9jayA9IDI3MDAwLAorCS5yZWZfY29udHJvbCA9CisJCVJFR19GSUVMRF9QUkVQ KFNOUFNfUEhZX1JFRl9DT05UUk9MX1JFRl9SQU5HRSwgMyksCisJLm1wbGxiX2NwID0KKwkJUkVH X0ZJRUxEX1BSRVAoU05QU19QSFlfTVBMTEJfQ1BfSU5ULCA1KSB8CisJCVJFR19GSUVMRF9QUkVQ KFNOUFNfUEhZX01QTExCX0NQX1BST1AsIDE1KSB8CisJCVJFR19GSUVMRF9QUkVQKFNOUFNfUEhZ X01QTExCX0NQX0lOVF9HUywgNjQpIHwKKwkJUkVHX0ZJRUxEX1BSRVAoU05QU19QSFlfTVBMTEJf Q1BfUFJPUF9HUywgMTI0KSwKKwkubXBsbGJfZGl2ID0KKwkJUkVHX0ZJRUxEX1BSRVAoU05QU19Q SFlfTVBMTEJfRElWNV9DTEtfRU4sIDEpIHwKKwkJUkVHX0ZJRUxEX1BSRVAoU05QU19QSFlfTVBM TEJfVFhfQ0xLX0RJViwgNSkgfAorCQlSRUdfRklFTERfUFJFUChTTlBTX1BIWV9NUExMQl9QTUlY X0VOLCAxKSB8CisJCVJFR19GSUVMRF9QUkVQKFNOUFNfUEhZX01QTExCX1YySSwgMiksCisJLm1w bGxiX2RpdjIgPQorCQlSRUdfRklFTERfUFJFUChTTlBTX1BIWV9NUExMQl9SRUZfQ0xLX0RJViwg MSkgfAorCQlSRUdfRklFTERfUFJFUChTTlBTX1BIWV9NUExMQl9NVUxUSVBMSUVSLCAxNDApIHwK KwkJUkVHX0ZJRUxEX1BSRVAoU05QU19QSFlfTVBMTEJfSERNSV9ESVYsIDEpLAorCS5tcGxsYl9m cmFjbjEgPQorCQlSRUdfRklFTERfUFJFUChTTlBTX1BIWV9NUExMQl9GUkFDTl9DR0dfVVBEQVRF X0VOLCAxKSB8CisJCVJFR19GSUVMRF9QUkVQKFNOUFNfUEhZX01QTExCX0ZSQUNOX0VOLCAxKSB8 CisJCVJFR19GSUVMRF9QUkVQKFNOUFNfUEhZX01QTExCX0ZSQUNOX0RFTiwgNSksCisJLm1wbGxi X2ZyYWNuMiA9CisJCVJFR19GSUVMRF9QUkVQKFNOUFNfUEhZX01QTExCX0ZSQUNOX1FVT1QsIDI2 MjE0KSB8CisJCVJFR19GSUVMRF9QUkVQKFNOUFNfUEhZX01QTExCX0ZSQUNOX1JFTSwgMiksCisJ Lm1wbGxiX3NzY2VuID0KKwkJUkVHX0ZJRUxEX1BSRVAoU05QU19QSFlfTVBMTEJfU1NDX1VQX1NQ UkVBRCwgMSksCit9OworCitzdGF0aWMgY29uc3Qgc3RydWN0IGludGVsX21wbGxiX3N0YXRlIGRn Ml9oZG1pXzc0XzI1ID0geworCS5jbG9jayA9IDc0MjUwLAorCS5yZWZfY29udHJvbCA9CisJCVJF R19GSUVMRF9QUkVQKFNOUFNfUEhZX1JFRl9DT05UUk9MX1JFRl9SQU5HRSwgMyksCisJLm1wbGxi X2NwID0KKwkJUkVHX0ZJRUxEX1BSRVAoU05QU19QSFlfTVBMTEJfQ1BfSU5ULCA0KSB8CisJCVJF R19GSUVMRF9QUkVQKFNOUFNfUEhZX01QTExCX0NQX1BST1AsIDE1KSB8CisJCVJFR19GSUVMRF9Q UkVQKFNOUFNfUEhZX01QTExCX0NQX0lOVF9HUywgNjQpIHwKKwkJUkVHX0ZJRUxEX1BSRVAoU05Q U19QSFlfTVBMTEJfQ1BfUFJPUF9HUywgMTI0KSwKKwkubXBsbGJfZGl2ID0KKwkJUkVHX0ZJRUxE X1BSRVAoU05QU19QSFlfTVBMTEJfRElWNV9DTEtfRU4sIDEpIHwKKwkJUkVHX0ZJRUxEX1BSRVAo U05QU19QSFlfTVBMTEJfVFhfQ0xLX0RJViwgMykgfAorCQlSRUdfRklFTERfUFJFUChTTlBTX1BI WV9NUExMQl9QTUlYX0VOLCAxKSB8CisJCVJFR19GSUVMRF9QUkVQKFNOUFNfUEhZX01QTExCX1Yy SSwgMikgfAorCQlSRUdfRklFTERfUFJFUChTTlBTX1BIWV9NUExMQl9GUkVRX1ZDTywgMyksCisJ Lm1wbGxiX2RpdjIgPQorCQlSRUdfRklFTERfUFJFUChTTlBTX1BIWV9NUExMQl9SRUZfQ0xLX0RJ ViwgMSkgfAorCQlSRUdfRklFTERfUFJFUChTTlBTX1BIWV9NUExMQl9NVUxUSVBMSUVSLCA4Nikg fAorCQlSRUdfRklFTERfUFJFUChTTlBTX1BIWV9NUExMQl9IRE1JX0RJViwgMSksCisJLm1wbGxi X2ZyYWNuMSA9CisJCVJFR19GSUVMRF9QUkVQKFNOUFNfUEhZX01QTExCX0ZSQUNOX0NHR19VUERB VEVfRU4sIDEpIHwKKwkJUkVHX0ZJRUxEX1BSRVAoU05QU19QSFlfTVBMTEJfRlJBQ05fRU4sIDEp IHwKKwkJUkVHX0ZJRUxEX1BSRVAoU05QU19QSFlfTVBMTEJfRlJBQ05fREVOLCA1KSwKKwkubXBs bGJfZnJhY24yID0KKwkJUkVHX0ZJRUxEX1BSRVAoU05QU19QSFlfTVBMTEJfRlJBQ05fUVVPVCwg MjYyMTQpIHwKKwkJUkVHX0ZJRUxEX1BSRVAoU05QU19QSFlfTVBMTEJfRlJBQ05fUkVNLCAyKSwK KwkubXBsbGJfc3NjZW4gPQorCQlSRUdfRklFTERfUFJFUChTTlBTX1BIWV9NUExMQl9TU0NfVVBf U1BSRUFELCAxKSwKK307CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgaW50ZWxfbXBsbGJfc3RhdGUg ZGcyX2hkbWlfMTQ4XzUgPSB7CisJLmNsb2NrID0gMTQ4NTAwLAorCS5yZWZfY29udHJvbCA9CisJ CVJFR19GSUVMRF9QUkVQKFNOUFNfUEhZX1JFRl9DT05UUk9MX1JFRl9SQU5HRSwgMyksCisJLm1w bGxiX2NwID0KKwkJUkVHX0ZJRUxEX1BSRVAoU05QU19QSFlfTVBMTEJfQ1BfSU5ULCA0KSB8CisJ CVJFR19GSUVMRF9QUkVQKFNOUFNfUEhZX01QTExCX0NQX1BST1AsIDE1KSB8CisJCVJFR19GSUVM RF9QUkVQKFNOUFNfUEhZX01QTExCX0NQX0lOVF9HUywgNjQpIHwKKwkJUkVHX0ZJRUxEX1BSRVAo U05QU19QSFlfTVBMTEJfQ1BfUFJPUF9HUywgMTI0KSwKKwkubXBsbGJfZGl2ID0KKwkJUkVHX0ZJ RUxEX1BSRVAoU05QU19QSFlfTVBMTEJfRElWNV9DTEtfRU4sIDEpIHwKKwkJUkVHX0ZJRUxEX1BS RVAoU05QU19QSFlfTVBMTEJfVFhfQ0xLX0RJViwgMikgfAorCQlSRUdfRklFTERfUFJFUChTTlBT X1BIWV9NUExMQl9QTUlYX0VOLCAxKSB8CisJCVJFR19GSUVMRF9QUkVQKFNOUFNfUEhZX01QTExC X1YySSwgMikgfAorCQlSRUdfRklFTERfUFJFUChTTlBTX1BIWV9NUExMQl9GUkVRX1ZDTywgMyks CisJLm1wbGxiX2RpdjIgPQorCQlSRUdfRklFTERfUFJFUChTTlBTX1BIWV9NUExMQl9SRUZfQ0xL X0RJViwgMSkgfAorCQlSRUdfRklFTERfUFJFUChTTlBTX1BIWV9NUExMQl9NVUxUSVBMSUVSLCA4 NikgfAorCQlSRUdfRklFTERfUFJFUChTTlBTX1BIWV9NUExMQl9IRE1JX0RJViwgMSksCisJLm1w bGxiX2ZyYWNuMSA9CisJCVJFR19GSUVMRF9QUkVQKFNOUFNfUEhZX01QTExCX0ZSQUNOX0NHR19V UERBVEVfRU4sIDEpIHwKKwkJUkVHX0ZJRUxEX1BSRVAoU05QU19QSFlfTVBMTEJfRlJBQ05fRU4s IDEpIHwKKwkJUkVHX0ZJRUxEX1BSRVAoU05QU19QSFlfTVBMTEJfRlJBQ05fREVOLCA1KSwKKwku bXBsbGJfZnJhY24yID0KKwkJUkVHX0ZJRUxEX1BSRVAoU05QU19QSFlfTVBMTEJfRlJBQ05fUVVP VCwgMjYyMTQpIHwKKwkJUkVHX0ZJRUxEX1BSRVAoU05QU19QSFlfTVBMTEJfRlJBQ05fUkVNLCAy KSwKKwkubXBsbGJfc3NjZW4gPQorCQlSRUdfRklFTERfUFJFUChTTlBTX1BIWV9NUExMQl9TU0Nf VVBfU1BSRUFELCAxKSwKK307CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgaW50ZWxfbXBsbGJfc3Rh dGUgZGcyX2hkbWlfNTk0ID0geworCS5jbG9jayA9IDU5NDAwMCwKKwkucmVmX2NvbnRyb2wgPQor CQlSRUdfRklFTERfUFJFUChTTlBTX1BIWV9SRUZfQ09OVFJPTF9SRUZfUkFOR0UsIDMpLAorCS5t cGxsYl9jcCA9CisJCVJFR19GSUVMRF9QUkVQKFNOUFNfUEhZX01QTExCX0NQX0lOVCwgNCkgfAor CQlSRUdfRklFTERfUFJFUChTTlBTX1BIWV9NUExMQl9DUF9QUk9QLCAxNSkgfAorCQlSRUdfRklF TERfUFJFUChTTlBTX1BIWV9NUExMQl9DUF9JTlRfR1MsIDY0KSB8CisJCVJFR19GSUVMRF9QUkVQ KFNOUFNfUEhZX01QTExCX0NQX1BST1BfR1MsIDEyNCksCisJLm1wbGxiX2RpdiA9CisJCVJFR19G SUVMRF9QUkVQKFNOUFNfUEhZX01QTExCX0RJVjVfQ0xLX0VOLCAxKSB8CisJCVJFR19GSUVMRF9Q UkVQKFNOUFNfUEhZX01QTExCX1BNSVhfRU4sIDEpIHwKKwkJUkVHX0ZJRUxEX1BSRVAoU05QU19Q SFlfTVBMTEJfVjJJLCAyKSB8CisJCVJFR19GSUVMRF9QUkVQKFNOUFNfUEhZX01QTExCX0ZSRVFf VkNPLCAzKSwKKwkubXBsbGJfZGl2MiA9CisJCVJFR19GSUVMRF9QUkVQKFNOUFNfUEhZX01QTExC X1JFRl9DTEtfRElWLCAxKSB8CisJCVJFR19GSUVMRF9QUkVQKFNOUFNfUEhZX01QTExCX01VTFRJ UExJRVIsIDg2KSB8CisJCVJFR19GSUVMRF9QUkVQKFNOUFNfUEhZX01QTExCX0hETUlfRElWLCAx KSwKKwkubXBsbGJfZnJhY24xID0KKwkJUkVHX0ZJRUxEX1BSRVAoU05QU19QSFlfTVBMTEJfRlJB Q05fQ0dHX1VQREFURV9FTiwgMSkgfAorCQlSRUdfRklFTERfUFJFUChTTlBTX1BIWV9NUExMQl9G UkFDTl9FTiwgMSkgfAorCQlSRUdfRklFTERfUFJFUChTTlBTX1BIWV9NUExMQl9GUkFDTl9ERU4s IDUpLAorCS5tcGxsYl9mcmFjbjIgPQorCQlSRUdfRklFTERfUFJFUChTTlBTX1BIWV9NUExMQl9G UkFDTl9RVU9ULCAyNjIxNCkgfAorCQlSRUdfRklFTERfUFJFUChTTlBTX1BIWV9NUExMQl9GUkFD Tl9SRU0sIDIpLAorCS5tcGxsYl9zc2NlbiA9CisJCVJFR19GSUVMRF9QUkVQKFNOUFNfUEhZX01Q TExCX1NTQ19VUF9TUFJFQUQsIDEpLAorfTsKIAorc3RhdGljIGNvbnN0IHN0cnVjdCBpbnRlbF9t cGxsYl9zdGF0ZSAqZGcyX2hkbWlfdGFibGVzW10gPSB7CisJJmRnMl9oZG1pXzI1XzE3NSwKKwkm ZGcyX2hkbWlfMjdfMCwKKwkmZGcyX2hkbWlfNzRfMjUsCisJJmRnMl9oZG1pXzE0OF81LAorCSZk ZzJfaGRtaV81OTQsCisJTlVMTCwKK307CisKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgaW50ZWxfbXBs bGJfc3RhdGUgKioKK2ludGVsX21wbGxiX3RhYmxlc19nZXQoc3RydWN0IGludGVsX2NydGNfc3Rh dGUgKmNydGNfc3RhdGUsCisJCSAgICAgICBzdHJ1Y3QgaW50ZWxfZW5jb2RlciAqZW5jb2RlcikK K3sKIAlpZiAoaW50ZWxfY3J0Y19oYXNfdHlwZShjcnRjX3N0YXRlLCBJTlRFTF9PVVRQVVRfRURQ KSkgewotCQl0YWJsZXMgPSBkZzJfZWRwX3RhYmxlczsKKwkJcmV0dXJuIGRnMl9lZHBfdGFibGVz OwogCX0gZWxzZSBpZiAoaW50ZWxfY3J0Y19oYXNfZHBfZW5jb2RlcihjcnRjX3N0YXRlKSkgewog CQkvKgogCQkgKiBGSVhNRTogSW5pdGlhbGx5IHdlJ3JlIGp1c3QgZW5hYmxpbmcgdGhlICJjb21i byIgb3V0cHV0cyBvbgpAQCAtMzk3LDE1ICs1NTcsNDEgQEAgaW50IGludGVsX21wbGxiX2NhbGNf c3RhdGUoc3RydWN0IGludGVsX2NydGNfc3RhdGUgKmNydGNfc3RhdGUsCiAJCSAqIHRoYXQgdG8g ZGV0ZXJtaW5lIHdoaWNoIHRhYmxlIHRvIHVzZS4KIAkJICovCiAJCWlmICgwKQotCQkJdGFibGVz ID0gZGcyX2RwXzM4XzRfdGFibGVzOworCQkJcmV0dXJuIGRnMl9kcF8zOF80X3RhYmxlczsKIAkJ ZWxzZQotCQkJdGFibGVzID0gZGcyX2RwXzEwMF90YWJsZXM7Ci0JfSBlbHNlIHsKLQkJLyogVE9E TzogQWRkIEhETUkgc3VwcG9ydCAqLwotCQlNSVNTSU5HX0NBU0UoZW5jb2Rlci0+dHlwZSk7Ci0J CXJldHVybiAtRUlOVkFMOworCQkJcmV0dXJuIGRnMl9kcF8xMDBfdGFibGVzOworCX0gZWxzZSBp ZiAoaW50ZWxfY3J0Y19oYXNfdHlwZShjcnRjX3N0YXRlLCBJTlRFTF9PVVRQVVRfSERNSSkpIHsK KwkJcmV0dXJuIGRnMl9oZG1pX3RhYmxlczsKIAl9CiAKKwlNSVNTSU5HX0NBU0UoZW5jb2Rlci0+ dHlwZSk7CisJcmV0dXJuIE5VTEw7Cit9CisKK2ludCBpbnRlbF9tcGxsYl9jYWxjX3N0YXRlKHN0 cnVjdCBpbnRlbF9jcnRjX3N0YXRlICpjcnRjX3N0YXRlLAorCQkJICAgc3RydWN0IGludGVsX2Vu Y29kZXIgKmVuY29kZXIpCit7CisJY29uc3Qgc3RydWN0IGludGVsX21wbGxiX3N0YXRlICoqdGFi bGVzOworCWludCBpOworCisJaWYgKGludGVsX2NydGNfaGFzX3R5cGUoY3J0Y19zdGF0ZSwgSU5U RUxfT1VUUFVUX0hETUkpKSB7CisJCWlmIChpbnRlbF9zbnBzX3BoeV9jaGVja19oZG1pX2xpbmtf cmF0ZShjcnRjX3N0YXRlLT5wb3J0X2Nsb2NrKQorCQkgICAgIT0gTU9ERV9PSykgeworCQkJLyoK KwkJCSAqIEZJWE1FOiBDYW4gb25seSBzdXBwb3J0IGZpeGVkIEhETUkgZnJlcXVlbmNpZXMKKwkJ CSAqIHVudGlsIHdlIGhhdmUgYSBwcm9wZXIgYWxnb3JpdGhtIHVuZGVyIGEgdmFsaWQKKwkJCSAq IGxpY2Vuc2UuCisJCQkgKi8KKwkJCURSTV9ERUJVR19LTVMoIkNhbid0IHN1cHBvcnQgSERNSSBs aW5rIHJhdGUgJWRcbiIsCisJCQkJICAgICAgY3J0Y19zdGF0ZS0+cG9ydF9jbG9jayk7CisJCQly ZXR1cm4gLUVJTlZBTDsKKwkJfQorCX0KKworCXRhYmxlcyA9IGludGVsX21wbGxiX3RhYmxlc19n ZXQoY3J0Y19zdGF0ZSwgZW5jb2Rlcik7CisJaWYgKCF0YWJsZXMpCisJCXJldHVybiAtRUlOVkFM OworCiAJZm9yIChpID0gMDsgdGFibGVzW2ldOyBpKyspIHsKIAkJaWYgKGNydGNfc3RhdGUtPnBv cnRfY2xvY2sgPD0gdGFibGVzW2ldLT5jbG9jaykgewogCQkJY3J0Y19zdGF0ZS0+bXBsbGJfc3Rh dGUgPSAqdGFibGVzW2ldOwpAQCAtNTE1LDMgKzcwMSw3OSBAQCB2b2lkIGludGVsX21wbGxiX2Rp c2FibGUoc3RydWN0IGludGVsX2VuY29kZXIgKmVuY29kZXIpCiAJICogV2UgaGFuZGxlIHRoaXMg c3RlcCBpbiBieHRfc2V0X2NkY2xrKCkuCiAJICovCiB9CisKK2ludCBpbnRlbF9tcGxsYl9jYWxj X3BvcnRfY2xvY2soc3RydWN0IGludGVsX2VuY29kZXIgKmVuY29kZXIsCisJCQkJY29uc3Qgc3Ry dWN0IGludGVsX21wbGxiX3N0YXRlICpwbGxfc3RhdGUpCit7CisJdW5zaWduZWQgaW50IGZyYWNf cXVvdCA9IDAsIGZyYWNfcmVtID0gMCwgZnJhY19kZW4gPSAxOworCXVuc2lnbmVkIGludCBtdWx0 aXBsaWVyLCB0eF9jbGtfZGl2LCByZWZjbGs7CisJYm9vbCBmcmFjX2VuOworCisJaWYgKDApCisJ CXJlZmNsayA9IDM4NDAwOworCWVsc2UKKwkJcmVmY2xrID0gMTAwMDAwOworCisJcmVmY2xrID4+ PSBSRUdfRklFTERfR0VUKFNOUFNfUEhZX01QTExCX1JFRl9DTEtfRElWLCBwbGxfc3RhdGUtPm1w bGxiX2RpdjIpIC0gMTsKKworCWZyYWNfZW4gPSBSRUdfRklFTERfR0VUKFNOUFNfUEhZX01QTExC X0ZSQUNOX0VOLCBwbGxfc3RhdGUtPm1wbGxiX2ZyYWNuMSk7CisKKwlpZiAoZnJhY19lbikgewor CQlmcmFjX3F1b3QgPSBSRUdfRklFTERfR0VUKFNOUFNfUEhZX01QTExCX0ZSQUNOX1FVT1QsIHBs bF9zdGF0ZS0+bXBsbGJfZnJhY24yKTsKKwkJZnJhY19yZW0gPSBSRUdfRklFTERfR0VUKFNOUFNf UEhZX01QTExCX0ZSQUNOX1JFTSwgcGxsX3N0YXRlLT5tcGxsYl9mcmFjbjIpOworCQlmcmFjX2Rl biA9IFJFR19GSUVMRF9HRVQoU05QU19QSFlfTVBMTEJfRlJBQ05fREVOLCBwbGxfc3RhdGUtPm1w bGxiX2ZyYWNuMSk7CisJfQorCisJbXVsdGlwbGllciA9IFJFR19GSUVMRF9HRVQoU05QU19QSFlf TVBMTEJfTVVMVElQTElFUiwgcGxsX3N0YXRlLT5tcGxsYl9kaXYyKSAvIDIgKyAxNjsKKworCXR4 X2Nsa19kaXYgPSBSRUdfRklFTERfR0VUKFNOUFNfUEhZX01QTExCX1RYX0NMS19ESVYsIHBsbF9z dGF0ZS0+bXBsbGJfZGl2KTsKKworCXJldHVybiBESVZfUk9VTkRfQ0xPU0VTVF9VTEwobXVsX3Uz Ml91MzIocmVmY2xrLCAobXVsdGlwbGllciA8PCAxNikgKyBmcmFjX3F1b3QpICsKKwkJCQkgICAg IERJVl9ST1VORF9DTE9TRVNUKHJlZmNsayAqIGZyYWNfcmVtLCBmcmFjX2RlbiksCisJCQkJICAg ICAxMCA8PCAodHhfY2xrX2RpdiArIDE2KSk7Cit9CisKK3ZvaWQgaW50ZWxfbXBsbGJfcmVhZG91 dF9od19zdGF0ZShzdHJ1Y3QgaW50ZWxfZW5jb2RlciAqZW5jb2RlciwKKwkJCQkgIHN0cnVjdCBp bnRlbF9tcGxsYl9zdGF0ZSAqcGxsX3N0YXRlKQoreworCXN0cnVjdCBkcm1faTkxNV9wcml2YXRl ICpkZXZfcHJpdiA9IHRvX2k5MTUoZW5jb2Rlci0+YmFzZS5kZXYpOworCWVudW0gcGh5IHBoeSA9 IGludGVsX3BvcnRfdG9fcGh5KGRldl9wcml2LCBlbmNvZGVyLT5wb3J0KTsKKworCXBsbF9zdGF0 ZS0+bXBsbGJfY3AgPSBpbnRlbF9kZV9yZWFkKGRldl9wcml2LCBTTlBTX1BIWV9NUExMQl9DUChw aHkpKTsKKwlwbGxfc3RhdGUtPm1wbGxiX2RpdiA9IGludGVsX2RlX3JlYWQoZGV2X3ByaXYsIFNO UFNfUEhZX01QTExCX0RJVihwaHkpKTsKKwlwbGxfc3RhdGUtPm1wbGxiX2RpdjIgPSBpbnRlbF9k ZV9yZWFkKGRldl9wcml2LCBTTlBTX1BIWV9NUExMQl9ESVYyKHBoeSkpOworCXBsbF9zdGF0ZS0+ bXBsbGJfc3NjZW4gPSBpbnRlbF9kZV9yZWFkKGRldl9wcml2LCBTTlBTX1BIWV9NUExMQl9TU0NF TihwaHkpKTsKKwlwbGxfc3RhdGUtPm1wbGxiX3NzY3N0ZXAgPSBpbnRlbF9kZV9yZWFkKGRldl9w cml2LCBTTlBTX1BIWV9NUExMQl9TU0NTVEVQKHBoeSkpOworCXBsbF9zdGF0ZS0+bXBsbGJfZnJh Y24xID0gaW50ZWxfZGVfcmVhZChkZXZfcHJpdiwgU05QU19QSFlfTVBMTEJfRlJBQ04xKHBoeSkp OworCXBsbF9zdGF0ZS0+bXBsbGJfZnJhY24yID0gaW50ZWxfZGVfcmVhZChkZXZfcHJpdiwgU05Q U19QSFlfTVBMTEJfRlJBQ04yKHBoeSkpOworCisJLyoKKwkgKiBSRUZfQ09OVFJPTCBpcyB1bmRl ciBmaXJtd2FyZSBjb250cm9sIGFuZCBuZXZlciBwcm9ncmFtbWVkIGJ5IHRoZQorCSAqIGRyaXZl cjsgd2UgcmVhZCBpdCBvbmx5IGZvciBzYW5pdHkgY2hlY2tpbmcgcHVycG9zZXMuICBUaGUgYnNw ZWMKKwkgKiBvbmx5IHRlbGxzIHVzIHRoZSBleHBlY3RlZCB2YWx1ZSBmb3Igb25lIGZpZWxkIGlu IHRoaXMgcmVnaXN0ZXIsCisJICogc28gd2UnbGwgb25seSByZWFkIG91dCB0aG9zZSBzcGVjaWZp YyBiaXRzIGhlcmUuCisJICovCisJcGxsX3N0YXRlLT5yZWZfY29udHJvbCA9IGludGVsX2RlX3Jl YWQoZGV2X3ByaXYsIFNOUFNfUEhZX1JFRl9DT05UUk9MKHBoeSkpICYKKwkJU05QU19QSFlfUkVG X0NPTlRST0xfUkVGX1JBTkdFOworCisJLyoKKwkgKiBNUExMQl9ESVYgaXMgcHJvZ3JhbW1lZCB0 d2ljZSwgb25jZSB3aXRoIHRoZSBzb2Z0d2FyZS1jb21wdXRlZAorCSAqIHN0YXRlLCB0aGVuIGFn YWluIHdpdGggdGhlIE1QTExCX0ZPUkNFX0VOIGJpdCBhZGRlZC4gIERyb3AgdGhhdAorCSAqIGV4 dHJhIGJpdCBkdXJpbmcgcmVhZG91dCBzbyB0aGF0IHdlIHJldHVybiB0aGUgYWN0dWFsIGV4cGVj dGVkCisJICogc29mdHdhcmUgc3RhdGUuCisJICovCisJcGxsX3N0YXRlLT5tcGxsYl9kaXYgJj0g flNOUFNfUEhZX01QTExCX0ZPUkNFX0VOOworfQorCitpbnQgaW50ZWxfc25wc19waHlfY2hlY2tf aGRtaV9saW5rX3JhdGUoaW50IGNsb2NrKQoreworCWNvbnN0IHN0cnVjdCBpbnRlbF9tcGxsYl9z dGF0ZSAqKnRhYmxlcyA9IGRnMl9oZG1pX3RhYmxlczsKKwlpbnQgaTsKKworCWZvciAoaSA9IDA7 IHRhYmxlc1tpXTsgaSsrKSB7CisJCWlmIChjbG9jayA9PSB0YWJsZXNbaV0tPmNsb2NrKQorCQkJ cmV0dXJuIE1PREVfT0s7CisJfQorCisJcmV0dXJuIE1PREVfQ0xPQ0tfUkFOR0U7Cit9CmRpZmYg LS1naXQgYS9kcml2ZXJzL2dwdS9kcm0vaTkxNS9kaXNwbGF5L2ludGVsX3NucHNfcGh5LmggYi9k cml2ZXJzL2dwdS9kcm0vaTkxNS9kaXNwbGF5L2ludGVsX3NucHNfcGh5LmgKaW5kZXggMjA1YWI0 NmYwYjY3Li5jYTRjMmEyNTE4MmIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2Rp c3BsYXkvaW50ZWxfc25wc19waHkuaAorKysgYi9kcml2ZXJzL2dwdS9kcm0vaTkxNS9kaXNwbGF5 L2ludGVsX3NucHNfcGh5LmgKQEAgLTgsMTEgKzgsMTggQEAKIAogc3RydWN0IGludGVsX2VuY29k ZXI7CiBzdHJ1Y3QgaW50ZWxfY3J0Y19zdGF0ZTsKK3N0cnVjdCBpbnRlbF9tcGxsYl9zdGF0ZTsK IAogaW50IGludGVsX21wbGxiX2NhbGNfc3RhdGUoc3RydWN0IGludGVsX2NydGNfc3RhdGUgKmNy dGNfc3RhdGUsCiAJCQkgICBzdHJ1Y3QgaW50ZWxfZW5jb2RlciAqZW5jb2Rlcik7CiB2b2lkIGlu dGVsX21wbGxiX2VuYWJsZShzdHJ1Y3QgaW50ZWxfZW5jb2RlciAqZW5jb2RlciwKIAkJCWNvbnN0 IHN0cnVjdCBpbnRlbF9jcnRjX3N0YXRlICpjcnRjX3N0YXRlKTsKIHZvaWQgaW50ZWxfbXBsbGJf ZGlzYWJsZShzdHJ1Y3QgaW50ZWxfZW5jb2RlciAqZW5jb2Rlcik7Cit2b2lkIGludGVsX21wbGxi X3JlYWRvdXRfaHdfc3RhdGUoc3RydWN0IGludGVsX2VuY29kZXIgKmVuY29kZXIsCisJCQkJICBz dHJ1Y3QgaW50ZWxfbXBsbGJfc3RhdGUgKnBsbF9zdGF0ZSk7CitpbnQgaW50ZWxfbXBsbGJfY2Fs Y19wb3J0X2Nsb2NrKHN0cnVjdCBpbnRlbF9lbmNvZGVyICplbmNvZGVyLAorCQkJCWNvbnN0IHN0 cnVjdCBpbnRlbF9tcGxsYl9zdGF0ZSAqcGxsX3N0YXRlKTsKKworaW50IGludGVsX3NucHNfcGh5 X2NoZWNrX2hkbWlfbGlua19yYXRlKGludCBjbG9jayk7CiAKICNlbmRpZiAvKiBfX0lOVEVMX1NO UFNfUEhZX0hfXyAqLwpkaWZmIC0tZ2l0IGEvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9yZWcu aCBiL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfcmVnLmgKaW5kZXggYzA0MTdjOTk0Yjk3Li4x NTQ2NWY5Y2Y5YWIgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvZ3B1L2RybS9pOTE1L2k5MTVfcmVnLmgK KysrIGIvZHJpdmVycy9ncHUvZHJtL2k5MTUvaTkxNV9yZWcuaApAQCAtMjMyNSwxMiArMjMyNSwx NSBAQCBzdGF0aWMgaW5saW5lIGJvb2wgaTkxNV9tbWlvX3JlZ192YWxpZChpOTE1X3JlZ190IHJl ZykKIAogI2RlZmluZSBTTlBTX1BIWV9NUExMQl9TU0NFTihwaHkpCQlfTU1JT19TTlBTKHBoeSwg MHgxNjgwMTQpCiAjZGVmaW5lICAgU05QU19QSFlfTVBMTEJfU1NDX0VOCQkJUkVHX0JJVCgzMSkK KyNkZWZpbmUgICBTTlBTX1BIWV9NUExMQl9TU0NfVVBfU1BSRUFECQlSRUdfQklUKDMwKQogI2Rl ZmluZSAgIFNOUFNfUEhZX01QTExCX1NTQ19QRUFLCQlSRUdfR0VOTUFTSygyOSwgMTApCiAKICNk ZWZpbmUgU05QU19QSFlfTVBMTEJfU1NDU1RFUChwaHkpCQlfTU1JT19TTlBTKHBoeSwgMHgxNjgw MTgpCiAjZGVmaW5lICAgU05QU19QSFlfTVBMTEJfU1NDX1NURVBTSVpFCQlSRUdfR0VOTUFTSygz MSwgMTEpCiAKICNkZWZpbmUgU05QU19QSFlfTVBMTEJfRElWMihwaHkpCQlfTU1JT19TTlBTKHBo eSwgMHgxNjgwMUMpCisjZGVmaW5lICAgU05QU19QSFlfTVBMTEJfSERNSV9QSVhFTF9DTEtfRElW CVJFR19HRU5NQVNLKDE5LCAxOCkKKyNkZWZpbmUgICBTTlBTX1BIWV9NUExMQl9IRE1JX0RJVgkJ UkVHX0dFTk1BU0soMTcsIDE1KQogI2RlZmluZSAgIFNOUFNfUEhZX01QTExCX1JFRl9DTEtfRElW CQlSRUdfR0VOTUFTSygxNCwgMTIpCiAjZGVmaW5lICAgU05QU19QSFlfTVBMTEJfTVVMVElQTElF UgkJUkVHX0dFTk1BU0soMTEsIDApCiAKLS0gCjIuMjUuNAoKX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX18KSW50ZWwtZ2Z4IG1haWxpbmcgbGlzdApJbnRlbC1n ZnhAbGlzdHMuZnJlZWRlc2t0b3Aub3JnCmh0dHBzOi8vbGlzdHMuZnJlZWRlc2t0b3Aub3JnL21h aWxtYW4vbGlzdGluZm8vaW50ZWwtZ2Z4Cg==