From mboxrd@z Thu Jan 1 00:00:00 1970 Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.remote-ip=100.103.45.18 ARC-Seal: i=1; d=subspace.kernel.org; s=arc20261015; a=rsa-sha256; cv=none; t=1795181599; b=SgpIRDWS6t+JKquaqqKImcy0JSblCu95T3o0xhoPugGE/jb/zGljvoQiuHUdghHnGh8e +yj8gVMzmkA5NX69BEFoMGW+m2dTnrsL9vrjQ+7JlswYxpg1Ph1Numpr+CNaGWHHo49bf 9YQHApFvL8guAci9AlgWtSNVpPOHCX6F3KtHZ7rchJgfMiuf39gUC34qMk24AhvM17QJO wEJCPFtux37fJwuGxnqaI6/9s9BGlOJJPEp/LIv93KO+DrTHrF0hYUT7hZFE7Hxdi4Gb/ yFomgBvW2TvEjXHiHySS1NtLGnBYQjc6qEmKxdBOGUGSZyxpyBPexNTfu8YiwMGPJzQ== ARC-Message-Signature: i=1; d=subspace.kernel.org; s=arc20261015; a=rsa-sha256; c=relaxed/relaxed; t=1795181599; h=Received:DKIM-Signature:Message-ID:From:Subject:Reply-To:To:Cc: In-Reply-To:References:Content-Type:Content-Transfer-Encoding:Date; bh=rmF3PBjYjmcGICpHqzXZYxMwQUARFEhP12AnfntWJAY=; b=bBpwrj5v4aYVTHBaL/WthSBxR/XTzBoHn6yPm1A32+66r1yPdMtTqAv1UWJkS/3dqVr2 zr3v81oj1mjffXYIgr1NqOCWwxlNRXKiUv9BIRFN5MZ94HZI2oePAR1hbwFAn56qd69DM 6Hr5KmtRaAv5xdmlHkbU7U9peTd9huvYXTCXHLphBJrpo96HcF137rtBrhcKsTN+cUsfP iDbJZKNMuI2Sl80hYlFdZ+Y9CgDe+bbu3FwHxCVix5dymGbxYZvKrNPHmE02r2thajrOL mSqDwDwbmxpIX9bwYGY5tuVzpLl+gEwUGcRUiekrlNMMm8xIPaOa973ElAp1SSEIKSQ== ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass header.d=kernel.org header.i=@kernel.org header.a=rsa-sha256 header.s=k20260515 header.b=bvyARTtQ; arc=none smtp.remote-ip=100.103.45.18 Received: from smtp.kernel.org (quasi.space.kernel.org [100.103.45.18]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature ECDSA (prime256v1)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 3C5A4606A320 for ; Fri, 20 Nov 2026 13:33:18 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.a=rsa-sha256 header.s=k20260515 header.b=bvyARTtQ Received: by smtp.kernel.org (Postfix) with ESMTPSA id 706581F000C6; Fri, 20 Nov 2026 13:33:18 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1795181598; bh=rmF3PBjYjmcGICpHqzXZYxMwQUARFEhP12AnfntWJAY=; h=From:Subject:Reply-To:To:Cc:In-Reply-To:References:Date; b=bvyARTtQhbzLq+MzZPFBrXNYM/dhsXH38aoGvZWBteEOfRfH7Ogzsm1//OWvDwdxG rWDewpnO8Y/OiOrzZo2X5Nc1wIQawnxh5LLR26uyDtLAZRuGTptI7w6KjMTWAts8Zh cGwZaYV+jwioNHH7dgw6KGQDMuotFI7FjLXK/LZBdYr9U+xjHuaXfA7L5NXaVwxhpX ukHFHNAYItMtpit7rmtfdGWOkVY0IZSyrWfjHB/4BP6u4EiX6w8GCe9bp9Rgl8HypF qbz8+D7OFu0LI4TW/OmZFJSo5Ho29UGpApIf74GinWj2GlFfEybrCOc7excTApGUnq yIW+tbV7Ttybw== Message-ID: From: sashiko-bot@kernel.org Subject: Re: [PATCH 4/4] phy: cadence-torrent: rewrite Torrent PHY driver Reply-To: sashiko-reviews@lists.linux.dev To: "Benjamin Robin" Cc: devicetree@vger.kernel.org, linux-phy@lists.infradead.org, robh@kernel.org, conor+dt@kernel.org, vkoul@kernel.org, neil.armstrong@linaro.org, olteanv@gmail.com In-Reply-To: <20261120-phy-cadence-torrent-ng-v1-4-da2db7125cd7@bootlin.com> References: <20261120-phy-cadence-torrent-ng-v1-0-da2db7125cd7@bootlin.com> <20261120-phy-cadence-torrent-ng-v1-4-da2db7125cd7@bootlin.com> Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: quoted-printable Date: Fri, 20 Nov 2026 13:33:18 +0000 X-Mailing-List: devicetree@vger.kernel.org List-Id: List-Post: List-Help: List-Subscribe: List-Unsubscribe: List-Owner: Precedence: list Thank you for your contribution! Sashiko AI review found 14 potential issues to consider: - [High] phy: cadence-torrent: 32-bit shift overflow in tp_write_pll_regs() - [High] phy: cadence-torrent: CDB register access before apb_rst deassertion - [High] phy: cadence-torrent: DP init and configure break cdns-mhdp8546 consumer - [High] phy: cadence-torrent: missing mlane shift in tp_dptx_set_pll_en() and lanes - [High] phy: cadence-torrent: nb_phy_on underflow in tp_phy_off() when preconfigured - [High] phy: cadence-torrent: tp_resume_noirq() leaves active links held in reset - [Medium] phy: cadence-torrent: REV_R110 enum typo in tp_write_pll_cp_padj() - [Medium] phy: cadence-torrent: unreachable FBR mode in tp_calc_pcie_pll_fb_div_mode() - [Medium] phy: cadence-torrent: stale SSC and divider regs in tp_write_pll_regs() - [Medium] phy: cadence-torrent: unbalanced clk disable in tp_phy_cleanup() - [Medium] phy: cadence-torrent: skipped refclk check in tp_ref_clks_init() - [Medium] phy: cadence-torrent: missed PCIe ML flag in tp_check_multiple_pcie_links() - [Medium] phy: cadence-torrent: rejected standard swap with clk1 in tp_find_link_cfg() - [Medium] phy: cadence-torrent: unchecked tp_dp_run() and missing reset rollback -- commit 3480ec972d0cd2d542d547f1d45d7f4f38415bc8 Author: Benjamin Robin phy: cadence-torrent: rewrite Torrent PHY driver This commit rewrites the Cadence Torrent PHY driver to compute clock and PLL register values at runtime and look up remaining protocol, revision, and process-node register settings per register instead of using static register tables. > diff --git a/drivers/phy/cadence/phy-cadence-torrent.c b/drivers/phy/cade= nce/phy-cadence-torrent.c > index 1e178aa2ffd76..74a65f0f4b242 100644 > --- a/drivers/phy/cadence/phy-cadence-torrent.c > +++ b/drivers/phy/cadence/phy-cadence-torrent.c [ ... ] > @@ -394,5453 +515,4629 @@ enum phy_powerstate { > POWERSTATE_A3 =3D 3, > }; > =20 > +static const struct tp_link_cfg tp_link_cfgs[] =3D { > + { > + /* PLL 0 M0: PCIe, PLL 0 M1: PCIe, PLL 1: None */ > + .std0 =3D STD0_PCIE_SL, .std1 =3D STD1_NONE, > + .pll_freq =3D { PLL_10_00_GHZ, PLL_8_00_GHZ, PLL_8_00_GHZ }, > + .phy_pll_cfg =3D 0x0001, > + .pll_clk_sel =3D { 0x0601, 0x0400, 0x0400 }, > + .xcvr_diag_plldrc_ctrl =3D { 0x0012, 0x0012 }, > + .xcvr_diag_hsclk_sel =3D { 0x0000, 0x0000 }, > + .xcvr_diag_hsclk_div =3D { 0x0001, 0x0001 }, > + }, [ ... ] > +static enum tp_pll_fb_div_mode tp_calc_pcie_pll_fb_div_mode(const struct= tp_phy *tp_phy) > +{ > + u32 tech_tag =3D tp_phy->tech_tag; > + enum tp_revision rev =3D tp_phy->rev; > + enum tp_pll_fb_div_mode div_mode; > + > + if (tech_tag & (TECH_TSMC_16 | TECH_TSMC_12)) { > + if (rev =3D=3D REV_R100) { > + if (tp_phy->plls[PLL1_MODE0].freq_khz =3D=3D 0) > + div_mode =3D PLL_FB_DIV_MODE_FBR; > + else > + div_mode =3D PLL_FB_DIV_MODE_D32; > + } else { [Severity: Medium] Can tp_phy->plls[PLL1_MODE0].freq_khz ever be 0 here? Every entry in tp_link_cfgs[], including single-link PCIe (STD0_PCIE_SL with STD1_NONE), sets pll_freq[PLL1_MODE0] to a non-zero frequency (PLL_8_00_GHZ) rather than PLL_UNUSED. Because tp_init_plls_data() populates plls[PLL1_MODE0].freq_khz from pll_freq[PLL1_MODE0] before calling tp_calc_pll_fb_div_modes(), single-link PCIe on TSMC 16nm/12nm REV_R100 hardware always selects PLL_FB_DIV_MODE_D32 instead of PLL_FB_DIV_MODE_FBR, misprogramming the PLL control, VCO calibration, and lock registers. [ ... ] > +static void tp_write_pll_cp_padj(const struct tp_phy *tp_phy, enum tp_pl= l_id pll_id) > +{ > + u32 tech_tag =3D tp_phy->tech_tag; > + u32 rev_msk =3D BIT(tp_phy->rev); > + const struct tp_pll_data *pll =3D &tp_phy->plls[pll_id]; > + u16 val; > + > + /* PLL charge pump proportional path adjust register */ > + if (pll->freq_khz < 8000000) { > + val =3D 0x0B17; > + } else if (pll->fractional_mode) { > + if (tech_tag & TECH_TSMC_7) > + val =3D 0x0B17; > + else if (tech_tag & (TECH_SS_5 | TECH_SS_7)) > + val =3D 0x0309; > + else > + val =3D 0x0509; /* TSMC_5, TSMC_12, TSMC_16, TSMC_16_0805 */ > + } else if (pll->freq_khz >=3D 10000000) { > + if (tech_tag & TECH_TSMC_7) > + val =3D (rev_msk & (REV_MSK_R100 | REV_MSK_R110)) ? 0x0023 : 0x0035; > + else if (tech_tag & TECH_TSMC_5) > + val =3D (pll_id =3D=3D PLL0_MODE0) ? 0x002D : 0x0035; > + else if (tech_tag & (TECH_SS_5 | TECH_SS_7)) > + val =3D 0x013E; > + else > + val =3D 0x0028; /* TSMC_12, TSMC_16, TSMC_16_0805 */ > + } else { > + if (tech_tag & TECH_TSMC_16) > + val =3D (rev_msk & REV_MSK_R100) ? 0x0028 : 0x0128; > + else if (tech_tag & TECH_TSMC_16_0805) > + val =3D 0x0128; > + else if (tech_tag & TECH_TSMC_12) > + val =3D 0x0028; > + else if (tech_tag & TECH_TSMC_7) > + val =3D (rev_msk & (REV_MSK_R100 | REV_R110)) ? 0x001D : 0x0031; [Severity: Medium] Should REV_R110 be REV_MSK_R110 in the TECH_TSMC_7 check? REV_R110 is the enum value 1 (equal to REV_MSK_R100) rather than BIT(REV_R110), so R110 hardware (rev_msk =3D=3D 0x2) never matches and programs CMN_PDIAG_PLLx_CP_PADJ_Mx with 0x0031 instead of 0x001D for 8 GHz integer-mode PLLs. [ ... ] > +static void tp_write_pll_fd_div_regs(const struct tp_phy *tp_phy, enum t= p_pll_id pll_id, > + u32 div_ratio) > +{ > + const struct tp_reg_base *base =3D &tp_phy->reg_common_cdb; > + const struct tp_pll_data *pll =3D &tp_phy->plls[pll_id]; > + u32 tech_tag =3D tp_phy->tech_tag; > + u16 high_div; > + u16 low_div; > + > + /* In fractional mode, we use default/reset value */ > + if (pll->fractional_mode) > + return; > + > + if (pll_id =3D=3D PLL0_MODE0 && pll->ref_clk_khz =3D=3D 100000 && pll->= freq_khz =3D=3D 10000000) { > + /* 100 MHz refclk, 10 GHz PLL */ > + if (tech_tag & (TECH_TSMC_12 | TECH_TSMC_16 | TECH_TSMC_16_0805)) { > + high_div =3D 30; > + low_div =3D 12; > + } else { > + high_div =3D 36; > + low_div =3D 6; > + } > + } else if (pll->ref_clk_khz =3D=3D 100000 && pll->freq_khz =3D=3D 80000= 00) { > + /* 100 MHz refclk, 8 GHz PLL */ > + if (tech_tag & (TECH_TSMC_12 | TECH_TSMC_16 | TECH_TSMC_16_0805)) { > + high_div =3D 16; > + low_div =3D 16; > + } else { > + high_div =3D 28; > + low_div =3D 4; > + } > + } else { > + /* Generic calculations */ > + > + /* PLL high integer divider val: EVEN(div_ratio_2 * 67/100) - 4 */ > + high_div =3D DIV_ROUND_UP((div_ratio >> 1) * 67U, 100U); > + high_div -=3D (high_div & 1U) ? 3U : 4U; > + > + /* PLL low integer divider val: div_ratio_2 - 8 - high_div */ > + low_div =3D (div_ratio >> 1) - 8 - high_div; > + } > + > + tp_reg_write(base, CMN_PLLx_DSM_FBH_OVRD_Mx(pll_id), high_div); > + tp_reg_write(base, CMN_PLLx_DSM_FBL_OVRD_Mx(pll_id), low_div); > +} > + > +static void tp_write_pll_itrim_reg(const struct tp_phy *tp_phy, enum tp_= pll_id pll_id) > +{ > + const struct tp_reg_base *base =3D &tp_phy->reg_common_cdb; > + const struct tp_pll_data *pll =3D &tp_phy->plls[pll_id]; > + > + if (tp_phy->tech_tag & TECH_TSMC_ALL) { > + u16 val =3D (pll->freq_khz >=3D 10000000) ? 0x003F : 0x007F; > + > + tp_reg_write(base, CMN_PDIAG_PLLx_ITRIM_Mx(pll_id), val); > + } > +} > + > +static void tp_write_pll_regs(const struct tp_phy *tp_phy, enum tp_pll_i= d pll_id) > +{ > + const struct tp_reg_base *base =3D &tp_phy->reg_common_cdb; > + const struct tp_pll_data *pll =3D &tp_phy->plls[pll_id]; > + u32 fd_div_prescale; > + u32 div_ratio; > + u16 fracdivl; > + u16 val; > + > + if (pll_id !=3D PLL0_MODE1) > + tp_write_pll_vco_regs(tp_phy, pll_id); > + > + /* Divide ratio */ > + div_ratio =3D pll->freq_khz / pll->ref_clk_khz; > + > + /* PLL feedback divider prescale */ > + fd_div_prescale =3D ((!pll->fractional_mode) || (div_ratio > 512)) ? 1 = : 0; > + > + /* PLL integer divider value */ > + val =3D (pll->fractional_mode) ? (div_ratio >> fd_div_prescale) : 0; > + tp_reg_write(base, CMN_PLLx_INTDIV_Mx(pll_id), val); > + > + /* PLL fractional divider value */ > + if (pll->fractional_mode) { > + u32 den =3D pll->ref_clk_khz << fd_div_prescale; > + u32 rem =3D pll->freq_khz % den; > + > + fracdivl =3D DIV_ROUND_CLOSEST(rem << 16, den); > + } else { > + fracdivl =3D 0; > + } > + > + tp_reg_write(base, CMN_PLLx_FRACDIVL_Mx(pll_id), fracdivl); > + tp_reg_write(base, CMN_PLLx_FRACDIVH_Mx(pll_id), pll->fractional_mode ?= 2 : 0); > + > + /* PLL high threshold value */ > + if (pll->fractional_mode) { > + /* EVEN(CEIL((fracdivl/65536 + (div_ratio >> fd_div_prescale)) * 2 / 3= )) */ > + u32 num =3D fracdivl + (div_ratio << (16 - fd_div_prescale)); [Severity: High] Can rem << 16 overflow 32-bit u32 when computing fracdivl in tp_write_pll_regs()? When rem >=3D 65535 (for example, DisplayPort at the default 8100 Mbps rate with a supported 156.25 MHz reference clock, where den =3D 156250 and rem =3D 131250), rem << 16 overflows u32 and corrupts both CMN_PLLx_FRACDIVL_Mx and CMN_PLLx_HIGH_THR_Mx (producing fracdivl =3D 0x004B instead of 0xD70A). Also, when fd_div_prescale =3D=3D 1 and div_ratio is o= dd (e.g. 20 MHz refclk with 10.3125 GHz USXGMII where div_ratio =3D 515), div_ratio << (16 - fd_div_prescale) retains bit 0 of div_ratio instead of using (div_ratio >> fd_div_prescale) << 16, double-counting the odd remainder already included in fracdivl. > + > + val =3D DIV_ROUND_UP(num, 3 << 15); > + if (val & 1) > + val++; > + } else { > + val =3D 0; > + } > + > + tp_reg_write(base, CMN_PLLx_HIGH_THR_Mx(pll_id), val); > + > + /* PLL delta sigma modulator diagnostics register */ > + tp_reg_write(base, CMN_PLLx_DSM_DIAG_Mx(pll_id), > + pll->fractional_mode ? 0x0004 : 0x4004); > + > + /* PLL high and low integer divider value */ > + tp_write_pll_fd_div_regs(tp_phy, pll_id, div_ratio); > + > + if (pll->ssc) > + tp_write_ssc_ctrl(tp_phy, pll_id, fd_div_prescale); [Severity: Medium] Does dynamic DisplayPort rate reconfiguration leave stale values in CMN_PLLx_SS_CTRL1_Mx..CTRL4_Mx and CMN_PLLx_DSM_FBH/FBL_OVRD_Mx? When tp_dp_update_pll_freq() -> tp_write_pll_regs() reconfigures a DP link from SSC enabled to SSC disabled, skipping tp_write_ssc_ctrl() leaves CMN_PLLx_SS_CTRL1_Mx..CTRL4_Mx enabled in hardware while VCO and lock counters are programmed for non-SSC operation. Similarly, if a DP PLL switches from integer mode (e.g. 2.7/5.4 Gbps with 100 MHz refclk and no SSC) to fractional mode, returning early in tp_write_pll_fd_div_regs() leaves the previous integer divider overrides in CMN_PLLx_DSM_FBH_OVRD_Mx and CMN_PLLx_DSM_FBL_OVRD_Mx instead of restoring their reset values. [ ... ] > +static int tp_dptx_set_pll_en(const struct tp_phy *tp_phy, u32 num_lanes= , bool enable) > +{ > + void __iomem *addr; > + u32 pll_ack_val; > + u32 rd_val; > + int ret; > + > + /* Used to determine which bits to check for or enable in PHY_PMA_XCVR_= PLLCLK_EN reg */ > + u32 pll_bits; > + /* Used to enable or disable lanes. */ > + u32 pll_val; > + > + /* Select reg value and mask, depending on enabled lane count. */ > + pll_val =3D tp_reg_dptx_read(tp_phy, PHY_PMA_XCVR_PLLCLK_EN); > + > + if (enable) { > + pll_bits =3D ((1 << num_lanes) - 1); > + pll_val |=3D pll_bits; > + pll_ack_val =3D pll_bits; > + } else { > + pll_bits =3D ((1 << num_lanes) - 1); > + pll_val &=3D (~pll_bits); > + pll_ack_val =3D 0; > + } [ ... ] > +static void tp_dp_set_lanes(const struct tp_phy *tp_phy, struct tp_link = *link, u32 num_lanes) > +{ > + u32 pma_tx_elec_idle_mask; > + u8 used_lane_mask; > + u8 all_lane_mask; > + u32 pll_clk_en; > + u32 pwr_state; > + u32 value; > + u32 mlane =3D link->mlane; > + > + used_lane_mask =3D ((1U << num_lanes) - 1) << mlane; > + all_lane_mask =3D ((1U << link->max_lanes) - 1) << mlane; [ ... ] > + /* Clear requested power state set PLL clock enable to 0 on all used la= nes. */ > + pwr_state =3D tp_reg_dptx_read(tp_phy, PHY_PMA_XCVR_POWER_STATE_REQ); > + pll_clk_en =3D tp_reg_dptx_read(tp_phy, PHY_PMA_XCVR_PLLCLK_EN); > + > + for (u32 i =3D 0; i < num_lanes; ++i) > + pwr_state &=3D ~(PMA_XCVR_POWER_STATE_REQ_LN_MASK << PHY_POWER_STATE_L= N(mlane + i)); > + > + pll_clk_en &=3D ~used_lane_mask; > + > + tp_reg_dptx_write(tp_phy, PHY_PMA_XCVR_POWER_STATE_REQ, pwr_state); > + tp_reg_dptx_write(tp_phy, PHY_PMA_XCVR_PLLCLK_EN, pll_clk_en); > + > + /* release master lane reset */ > + value |=3D 1 << mlane; > + tp_reg_dptx_write(tp_phy, PHY_RESET, value); > + > + /* update the number of used lanes */\n+ link->num_lanes =3D num_lanes; > +} [Severity: High] Should pll_bits in tp_dptx_set_pll_en() be shifted by link->mlane? Unlike tp_dp_set_lanes() and tp_dptx_set_power_state(), tp_dptx_set_pll_en() computes pll_bits =3D ((1 << num_lanes) - 1) without shifting by link->mlan= e, so any DisplayPort link with mlane > 0 modifies PHY_PMA_XCVR_PLLCLK_EN for lane 0 and times out polling PHY_PMA_XCVR_PLLCLK_EN_ACK. In addition, tp_dp_set_lanes() only clears PHY_PMA_XCVR_POWER_STATE_REQ and PHY_PMA_XCVR_PLLCLK_EN across used_lane_mask instead of all_lane_mask, leaving disabled lanes' PLLCLK_EN bits set when reducing the lane count. And when both set_lanes and set_rate are requested in tp_phy_configure(), running tp_dp_set_lanes() before tp_dp_set_rate() resets the lanes, clears PLLCLK_EN, and updates link->num_lanes before tp_dp_set_rate() transitions the previously active lanes to POWERSTATE_A3 (while tp_write_lanes_reg() also only programs link->num_lanes instead of link->max_lanes). [ ... ] > +static int tp_phy_configure(struct phy *phy, union phy_configure_opts *o= pts) > +{ > + struct tp_phy *tp_phy =3D dev_get_drvdata(phy->dev.parent); > + struct tp_link *link =3D phy_get_drvdata(phy); > + bool run_needed =3D false; > + int ret; > + > + guard(mutex)(&tp_phy->lock); > + > + if (tp_phy->already_configured) > + return 0; > + > + if (link->type !=3D STD_TYPE_DP) > + return -EINVAL; > + > + ret =3D tp_dp_verify_config(link, &opts->dp); > + if (ret) { > + dev_err(&phy->dev, "invalid params for phy configure\n"); > + return ret; > + } > + > + if (opts->dp.set_lanes && opts->dp.lanes !=3D link->num_lanes) { > + tp_dp_set_lanes(tp_phy, link, opts->dp.lanes); > + run_needed =3D true; > + } > + > + if (opts->dp.set_rate) { > + ret =3D tp_dp_set_rate(tp_phy, link, &opts->dp); > + if (ret) { > + dev_err(&phy->dev, "Set rate failed\n"); > + return ret; > + } > + run_needed =3D true; > + } > + > + if (opts->dp.set_voltages) > + tp_dp_set_voltages(tp_phy, link, &opts->dp); > + > + if (phy->power_count && run_needed) > + ret =3D tp_dp_run(tp_phy, link); > + > + return ret; > +} [Severity: High] Does moving DisplayPort reset deassertion and tp_dp_run() out of tp_phy_init() and gating tp_dp_run() on phy->power_count break cdns-mhdp8546? The in-tree DisplayPort bridge consumer (drivers/gpu/drm/bridge/cadence/cdns-mhdp8546-core.c) calls phy_init() in cdns_mhdp_probe() and phy_configure() in cdns_mhdp_link_training_init(), but never calls phy_power_on(). Because tp_dp_phy_init() no longer deasserts phy_rst/lnk_rst or starts the DP PLL and lanes, and tp_phy_configure() skips tp_dp_run() when phy->power_count is 0, the PHY remains held in reset and tp_dp_set_rate() polls PHY_PMA_CMN_CTRL2 on an unstarted PHY. > + > +static int tp_phy_on(struct phy *phy) > +{ > + struct tp_link *link =3D phy_get_drvdata(phy); > + struct tp_phy *tp_phy =3D dev_get_drvdata(phy->dev.parent); > + u16 val; > + int ret; > + > + guard(mutex)(&tp_phy->lock); > + > + if (tp_phy->already_configured) { > + /* Give 5ms to 10ms delay for the PIPE clock to be stable */ > + usleep_range(5000, 10000); > + return 0; > + } > + > + if (tp_phy->nb_phy_on =3D=3D 0) { > + /* Take the PHY out of reset */ > + ret =3D reset_control_deassert(tp_phy->phy_rst); > + if (ret) > + return ret; > + } > + > + /* Take the PHY lane group out of reset */ > + ret =3D reset_control_deassert(link->lnk_rst); > + if (ret) > + return ret; > + > + /* > + * Wait for cmn_ready assertion > + * PHY_PMA_CMN_CTRL1[0] =3D=3D 1 > + */ > + ret =3D read_poll_timeout(tp_reg_read, val, val & 1, 1000, PLL_LOCK_TIM= EOUT, false, > + &tp_phy->reg_phy_pma_common_cdb, PHY_PMA_CMN_CTRL1); > + if (ret) { > + dev_err(tp_phy->dev, "Timeout waiting for CMN ready\n"); > + return ret; > + } > + > + if (link->type =3D=3D STD_TYPE_DP) { > + tp_dp_run(tp_phy, link); > + } else if (link->type =3D=3D STD_TYPE_PCIE || link->type =3D=3D STD_TYP= E_USB_TXRX) { > + struct tp_reg_base *reg_base; > + > + reg_base =3D &tp_phy->reg_phy_pcs_lane_cdb[link->mlane]; > + ret =3D read_poll_timeout(tp_reg_read, val, (val & 2) =3D=3D 0, 1000, > + PLL_LOCK_TIMEOUT, false, reg_base, > + PHY_PCS_ISO_LINK_CTRL); > + if (ret < 0) { > + dev_err(tp_phy->dev, "Timeout waiting for PHY status ready\n"); > + return ret; > + } > + } > + > + tp_phy->nb_phy_on++; > + return 0; > +} [Severity: Medium] Should tp_phy_on() check the return value of tp_dp_run() and re-assert link->lnk_rst and tp_phy->phy_rst on error? Right now a timeout in tp_dp_run() is ignored and tp_phy_on() increments nb_phy_on and returns 0. Conversely, if deasserting link->lnk_rst or polling PHY_PMA_CMN_CTRL1 or PHY_PCS_ISO_LINK_CTRL fails, tp_phy_on() returns an error without re-asserting the resets it deasserted and without incrementing phy->power_count, so tp_phy_off() will not be called to clean them up. > + > +static int tp_phy_off(struct phy *phy) > +{ > + struct tp_link *inst =3D phy_get_drvdata(phy); > + struct tp_phy *tp_phy =3D dev_get_drvdata(phy->dev.parent); > + int ret; > + > + guard(mutex)(&tp_phy->lock); > + > + ret =3D reset_control_assert(inst->lnk_rst); > + if (ret) > + return ret; > + > + if (tp_phy->nb_phy_on =3D=3D 1) { > + ret =3D reset_control_assert(tp_phy->phy_rst); > + if (ret) > + return ret; > + } > + > + tp_phy->nb_phy_on--; > + return 0; > +} [Severity: High] Can tp_phy_off() underflow tp_phy->nb_phy_on when tp_phy->already_configured is true? When tp_phy->already_configured is true, tp_phy_on() returns early without incrementing nb_phy_on (leaving it at 0), but tp_phy_off() has no already_configured check: it asserts inst->lnk_rst and decrements the u8 nb_phy_on counter from 0 to 255. A subsequent phy_power_on() then either returns early with inst->lnk_rst still asserted, or after system suspend clears already_configured, sees nb_phy_on !=3D 0, skips deasserting tp_phy->phy_rst, and times out waiting for CMN ready. [ ... ] > +static int tp_ref_clk_init(const struct tp_phy *tp_phy, struct clk *clk,= const char *name, > + u32 *p_ref_clk_khz) > +{ > + struct device *dev =3D tp_phy->dev; > + u32 ref_clk_rate; > + int ret; > + > + ret =3D clk_prepare_enable(clk); > + if (ret) { > + dev_err(dev, "Failed to prepare %s ref clock: %d\n", name, ret); > + return ret; > + } > + > + ref_clk_rate =3D clk_get_rate(clk); > + if (!ref_clk_rate) { > + dev_err(dev, "Failed to get %s ref clock rate\n", name); > + ret =3D -EINVAL; > + goto disable_clk; > + } > + > + for (u8 i =3D 0; i < tp_phy->nb_links; ++i) { > + if (!tp_is_ref_freq_supported(tp_phy->links[i].type, ref_clk_rate)) { > + dev_err(dev, "Invalid ref clock rate: %u Hz\n", ref_clk_rate); > + ret =3D -EINVAL; > + goto disable_clk; > + } > + } [Severity: Medium] Does this loop skip reference clock validation during probe and reject valid dual-refclk configurations during resume? In cdns_torrent_phy_probe(), tp_ref_clks_init() is called before the child subnodes are parsed, so tp_phy->nb_links is 0 and this loop does not run at probe time (allowing unsupported clock rates, or rates < 1000 Hz that set ref_clk_khz to 0 and divide by zero in tp_write_pll_regs()). Then in tp_resume_noirq(), where nb_links > 0, tp_ref_clk_init() checks every link against both tp_phy->clk and tp_phy->clk1 instead of only the links using that PLL, failing resume with -EINVAL when PLL0 and PLL1 use different protocol-specific reference frequencies. [ ... ] > +static void tp_check_multiple_pcie_links(struct tp_phy *tp_phy) > +{ > + struct tp_standard *std0 =3D &tp_phy->standards[0]; > + u32 num_pcie_links =3D 0; > + > + /* First check if the first standard is PCIe */ > + if (std0->type !=3D STD_TYPE_PCIE) > + return; > + > + /* Count the number of links with PCIe protocol. */ > + for (u8 i =3D 0; i < tp_phy->nb_links; ++i) { > + if (tp_phy->links[i].type =3D=3D STD_TYPE_PCIE) > + num_pcie_links++; > + } > + > + /* PCIe Multilink configuration can be supported along with a non-PCIe = protocol. > + * Such configurations are handled by adding a flag named STD_FLAG_PCIE= _ML > + */ > + if (num_pcie_links > 1) > + std0->flags |=3D STD_FLAG_PCIE_ML; > +} [Severity: Medium] Does tp_check_multiple_pcie_links() miss multi-link PCIe when a non-PCIe subnode appears first in Device Tree? tp_add_phy_from_of_subnode() populates tp_phy->standards[] in DT subnode order, so if phy@0 is USB or SGMII and phy@1 and phy@2 are PCIe, PCIe is in standards[1] when tp_check_multiple_pcie_links() runs. Because tp_check_multiple_pcie_links() only checks standards[0], it returns without setting STD_FLAG_PCIE_ML, and when tp_find_link_cfg() subsequently swaps standards[0] and standards[1], the driver matches single-link PCIe (STD0_PCIE_SL) instead of multi-link PCIe (STD0_PCIE_ML). [ ... ] > +static int tp_find_link_cfg(struct tp_phy *tp_phy) > +{ > + const struct tp_link_cfg *link_cfg; > + struct device *dev =3D tp_phy->dev; > + struct tp_standard *std0 =3D &tp_phy->standards[0]; > + struct tp_standard *std1 =3D &tp_phy->standards[1]; > + > + /* Verify the validity of standard index in links */ > + for (u8 i =3D 0; i < tp_phy->nb_links; ++i) { > + const struct tp_link *link =3D &tp_phy->links[i]; > + > + if (WARN_ON(link->std_idx >=3D MAX_NUM_STANDARDS)) > + return -EINVAL; > + } > + > + link_cfg =3D tp_find_link_cfg_from_standards(std0, std1); > + > + /* Only swap the two standards if PLL1 has no dedicated reference clock= */ > + if (!link_cfg && !tp_phy->clk1) { > + link_cfg =3D tp_find_link_cfg_from_standards(std1, std0); > + if (link_cfg) { > + /* Swap the 2 standards */ > + swap(tp_phy->standards[0], tp_phy->standards[1]); > + > + for (u8 i =3D 0; i < tp_phy->nb_links; ++i) > + tp_phy->links[i].std_idx ^=3D 1; > + } > + } [Severity: Medium] Why is swapping standards[0] and standards[1] disallowed when tp_phy->clk1 is present? standards[0] and standards[1] are populated in DT child subnode order (lane order), whereas tp_link_cfgs[] orders entries by PLL assignment (std0 on PLL0 clocked by refclk, std1 on PLL1 clocked by pll1_refclk). When pll1_refclk is provided and the protocol on lower lanes (phy@0) uses PLL1 (for example, USXGMII on phy@0 with PLL1 at 156.25 MHz and PCIe on phy@2 with PLL0 at 100 MHz), refusing to swap standards[0] and standards[1] causes tp_find_link_cfg() to fail probe with -EINVAL. [ ... ] > +static void tp_phy_cleanup(const struct tp_phy *tp_phy) > +{ > + reset_control_assert(tp_phy->phy_rst); > + reset_control_assert(tp_phy->apb_rst); > + > + for (u8 i =3D 0; i < tp_phy->nb_links; ++i) { > + reset_control_assert(tp_phy->links[i].lnk_rst); > + reset_control_put(tp_phy->links[i].lnk_rst); > + } > + > + clk_disable_unprepare(tp_phy->clk1); > + clk_disable_unprepare(tp_phy->clk); > + tp_clk_cleanup(tp_phy); > +} [Severity: Medium] Can tp_phy_cleanup() call clk_disable_unprepare() on clocks that were never enabled or were already disabled? In cdns_torrent_phy_probe(), jumping to cleanup when tp_of_get_clk() fails on pll1_refclk after acquiring tp_phy->clk, when tp_ref_clks_init() fails (after already disabling any clock it enabled), or when tp_phy->already_con= figured is true (where tp_ref_clks_init() is skipped, which also affects cdns_torrent_phy_remove()) unconditionally calls clk_disable_unprepare() on tp_phy->clk1 and tp_phy->clk, triggering clock enable/prepare count underflow warnings. [ ... ] > +static int tp_suspend_noirq(struct device *dev) > +{ > + struct tp_phy *tp_phy =3D dev_get_drvdata(dev); > + > + tp_refclk_driver_suspend(tp_phy); > + > + for (u8 i =3D 0; i < tp_phy->nb_links; ++i) > + reset_control_assert(tp_phy->links[i].lnk_rst); > + > + reset_control_assert(tp_phy->phy_rst); > + reset_control_assert(tp_phy->apb_rst); > + > + if (tp_phy->already_configured) { > + tp_phy->already_configured =3D false; > + } else { > + clk_disable_unprepare(tp_phy->clk1); > + clk_disable_unprepare(tp_phy->clk); > + } > + > + return 0; > +} > + > +static int tp_resume_noirq(struct device *dev) > +{ > + int ret; > + struct tp_phy *tp_phy =3D dev_get_drvdata(dev); > + > + ret =3D tp_refclk_driver_resume(tp_phy); > + if (ret) > + return ret; > + > + ret =3D tp_ref_clks_init(tp_phy); > + if (ret) > + return ret; > + > + /* Enable APB */ > + reset_control_deassert(tp_phy->apb_rst); > + > + ret =3D tp_configure_links(tp_phy); > + if (ret) > + goto put_lnk_rst; > + > + return 0; [Severity: High] Does tp_resume_noirq() leave active links held in reset after suspend? tp_suspend_noirq() asserts lnk_rst for every link and asserts phy_rst without changing tp_phy->nb_phy_on, but tp_resume_noirq() only deasserts apb_rst and calls tp_configure_links() without deasserting phy_rst or lnk_rst. Consumers that keep their PHY powered on across suspend (such as am65-cpsw-nuss for SGMII/QSGMII/USXGMII) are left held in reset after resume, and sibling consumers on the same SERDES that call phy_power_off()/phy_power_on() across suspend/resume (such as pci-j721e) see tp_phy->nb_phy_on !=3D 0 in tp_phy_on(), skip deasserting phy_rst, and time out waiting for CMN ready. > + > +put_lnk_rst: > + > + for (u8 i =3D 0; i < tp_phy->nb_links; ++i) > + reset_control_assert(tp_phy->links[i].lnk_rst); > + > + reset_control_assert(tp_phy->apb_rst); > + reset_control_assert(tp_phy->phy_rst); > + > + clk_disable_unprepare(tp_phy->clk1); > + clk_disable_unprepare(tp_phy->clk); > + > + return ret; > +} > + > +static DEFINE_NOIRQ_DEV_PM_OPS(tp_pm_ops, tp_suspend_noirq, tp_resume_no= irq); > + > +static int cdns_torrent_phy_probe(struct platform_device *pdev) > +{ [ ... ] > + tp_reg_bases_init(tp_phy); > + tp_reg_fields_init(tp_phy); > + > + ret =3D tp_read_techno_revision(tp_phy); > + if (ret) > + return ret; > + > + ret =3D tp_clk_register(tp_phy); > + if (ret) > + return ret; > + > + ret =3D tp_of_get_reset(tp_phy); > + if (ret) > + goto cleanup; > + > + ret =3D tp_of_get_clk(tp_phy); > + if (ret) > + goto cleanup; > + > + tp_phy->already_configured =3D tp_is_already_configured(tp_phy); > + if (!tp_phy->already_configured) { > + ret =3D tp_ref_clks_init(tp_phy); > + if (ret) > + goto cleanup; > + > + /* Enable APB */ > + reset_control_deassert(tp_phy->apb_rst); > + } [Severity: High] Are CDB registers accessed here and in tp_resume_noirq() while tp_phy->apb_rst is still asserted? cdns_torrent_phy_probe() reads the PHY ID registers in tp_read_techno_revision(), writes CMN_CDIAG_REFCLK_DRV0_CTRL in tp_clk_register(), and reads PHY_PMA_CMN_CTRL1 in tp_is_already_configured() before tp_of_get_reset() and reset_control_deassert(tp_phy->apb_rst) run. Similarly, tp_resume_noirq() calls tp_refclk_driver_resume() (reading and writing CMN_CDIAG_REFCLK_DRV0_CTRL) before deasserting tp_phy->apb_rst, which was asserted in tp_suspend_noirq(). On platforms using the torrent_apb reset (or when re-probing after driver removal, which asserts apb_rst), accessing CDB registers while APB is in reset can fail probe with -ENODEV, lose register writes, or fault. --=20 Sashiko AI review =C2=B7 https://sashiko.dev/#/patchset/20261120-phy-cadenc= e-torrent-ng-v1-0-da2db7125cd7@bootlin.com?part=3D4 From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature ECDSA (prime256v1) server-digest SHA256) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 2A4FD606A320 for ; Fri, 20 Nov 2026 13:33:21 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.a=rsa-sha256 header.s=bombadil.20210309 header.b=vnNPgKQ5; dkim=fail reason="signature verification failed" (2048-bit key) header.d=kernel.org header.i=@kernel.org header.a=rsa-sha256 header.s=k20260515 header.b=bvyARTtQ DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender: Content-Transfer-Encoding:Content-Type:MIME-Version:Reply-To:List-Subscribe: List-Help:List-Post:List-Archive:List-Unsubscribe:List-Id:Date:References: In-Reply-To:Cc:To:Subject:From:Message-ID:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Unsubscribe-Post:List-Owner; bh=DF/t+oUdg0Nxx03K9K8eNL/9mM/UlVVVmtqBUsSmGLw=; b=vnNPgKQ5VfAOcyZywAQGLPDRZd iHd6rO0/Od/hr5PbIasON2OBjuTV09VJevcfZpq3jomlgi+DP1mOZtPEjog5pvTfs0MgBaaYdM8hJ 0DWssqRNtSxIhxo5c6wTZCCk4aWtXHjGKEADCRkeLB0cd3NTEkIO5KFiptrhcbZhGxizLa1yyqEPt exQEAcLWV0utLp5R7P6yJ3hE+gT5Gp2bBbc8Xmt2xBuz6YeRPAiqSzDFgfye44+OPxObZH/nzdY/N R1Kvv/XxQ4vJ9ieoW/6gRWY0lpv37h8sS6VEvW5MVRKqn5EsMtXQepCDHzbHVc9+F75UUjpmfTVat IVUN1PDQ==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.100.1 #2 (Red Hat Linux)) id 1xUOjw-0000000F6Vg-2sFG; Fri, 20 Nov 2026 13:33:20 +0000 Received: from tor.source.kernel.org ([172.105.4.254]) by bombadil.infradead.org with esmtps (Exim 4.100.1 #2 (Red Hat Linux)) id 1xUOjw-0000000F6VW-0IGj for linux-phy@lists.infradead.org; Fri, 20 Nov 2026 13:33:20 +0000 Received: from smtp.kernel.org (quasi.space.kernel.org [100.103.45.18]) by tor.source.kernel.org (Postfix) with ESMTP id 2314460F89; Fri, 20 Nov 2026 13:33:19 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 706581F000C6; Fri, 20 Nov 2026 13:33:18 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1795181598; bh=rmF3PBjYjmcGICpHqzXZYxMwQUARFEhP12AnfntWJAY=; h=From:Subject:Reply-To:To:Cc:In-Reply-To:References:Date; b=bvyARTtQhbzLq+MzZPFBrXNYM/dhsXH38aoGvZWBteEOfRfH7Ogzsm1//OWvDwdxG rWDewpnO8Y/OiOrzZo2X5Nc1wIQawnxh5LLR26uyDtLAZRuGTptI7w6KjMTWAts8Zh cGwZaYV+jwioNHH7dgw6KGQDMuotFI7FjLXK/LZBdYr9U+xjHuaXfA7L5NXaVwxhpX ukHFHNAYItMtpit7rmtfdGWOkVY0IZSyrWfjHB/4BP6u4EiX6w8GCe9bp9Rgl8HypF qbz8+D7OFu0LI4TW/OmZFJSo5Ho29UGpApIf74GinWj2GlFfEybrCOc7excTApGUnq yIW+tbV7Ttybw== Message-ID: From: sashiko-bot@kernel.org Subject: Re: [PATCH 4/4] phy: cadence-torrent: rewrite Torrent PHY driver To: "Benjamin Robin" Cc: devicetree@vger.kernel.org, linux-phy@lists.infradead.org, robh@kernel.org, conor+dt@kernel.org, vkoul@kernel.org, neil.armstrong@linaro.org, olteanv@gmail.com In-Reply-To: <20261120-phy-cadence-torrent-ng-v1-4-da2db7125cd7@bootlin.com> References: <20261120-phy-cadence-torrent-ng-v1-0-da2db7125cd7@bootlin.com> <20261120-phy-cadence-torrent-ng-v1-4-da2db7125cd7@bootlin.com> Date: Fri, 20 Nov 2026 13:33:18 +0000 X-BeenThere: linux-phy@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: Linux Phy Mailing list List-Archive: List-Post: List-Help: List-Subscribe: , Reply-To: sashiko-reviews@lists.linux.dev X-Archived-By: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-phy" X-Spam-Status: No, score=-8.9 required=3.0 tests=BAYES_00,DKIMWL_WL_HIGH, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_EF,HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS autolearn=ham autolearn_force=no version=4.0.1 X-Spam-Checker-Version: SpamAssassin 4.0.1 (2024-03-26) on aws-us-west-2-korg-listserv-alma10-1 VGhhbmsgeW91IGZvciB5b3VyIGNvbnRyaWJ1dGlvbiEgU2FzaGlrbyBBSSByZXZpZXcgZm91bmQg MTQgcG90ZW50aWFsCmlzc3VlcyB0byBjb25zaWRlcjoKLSBbSGlnaF0gcGh5OiBjYWRlbmNlLXRv cnJlbnQ6IDMyLWJpdCBzaGlmdCBvdmVyZmxvdyBpbgogIHRwX3dyaXRlX3BsbF9yZWdzKCkKLSBb SGlnaF0gcGh5OiBjYWRlbmNlLXRvcnJlbnQ6IENEQiByZWdpc3RlciBhY2Nlc3MgYmVmb3JlIGFw Yl9yc3QKICBkZWFzc2VydGlvbgotIFtIaWdoXSBwaHk6IGNhZGVuY2UtdG9ycmVudDogRFAgaW5p dCBhbmQgY29uZmlndXJlIGJyZWFrIGNkbnMtbWhkcDg1NDYKICBjb25zdW1lcgotIFtIaWdoXSBw aHk6IGNhZGVuY2UtdG9ycmVudDogbWlzc2luZyBtbGFuZSBzaGlmdCBpbgogIHRwX2RwdHhfc2V0 X3BsbF9lbigpIGFuZCBsYW5lcwotIFtIaWdoXSBwaHk6IGNhZGVuY2UtdG9ycmVudDogbmJfcGh5 X29uIHVuZGVyZmxvdyBpbiB0cF9waHlfb2ZmKCkgd2hlbgogIHByZWNvbmZpZ3VyZWQKLSBbSGln aF0gcGh5OiBjYWRlbmNlLXRvcnJlbnQ6IHRwX3Jlc3VtZV9ub2lycSgpIGxlYXZlcyBhY3RpdmUg bGlua3MKICBoZWxkIGluIHJlc2V0Ci0gW01lZGl1bV0gcGh5OiBjYWRlbmNlLXRvcnJlbnQ6IFJF Vl9SMTEwIGVudW0gdHlwbyBpbgogIHRwX3dyaXRlX3BsbF9jcF9wYWRqKCkKLSBbTWVkaXVtXSBw aHk6IGNhZGVuY2UtdG9ycmVudDogdW5yZWFjaGFibGUgRkJSIG1vZGUgaW4KICB0cF9jYWxjX3Bj aWVfcGxsX2ZiX2Rpdl9tb2RlKCkKLSBbTWVkaXVtXSBwaHk6IGNhZGVuY2UtdG9ycmVudDogc3Rh bGUgU1NDIGFuZCBkaXZpZGVyIHJlZ3MgaW4KICB0cF93cml0ZV9wbGxfcmVncygpCi0gW01lZGl1 bV0gcGh5OiBjYWRlbmNlLXRvcnJlbnQ6IHVuYmFsYW5jZWQgY2xrIGRpc2FibGUgaW4KICB0cF9w aHlfY2xlYW51cCgpCi0gW01lZGl1bV0gcGh5OiBjYWRlbmNlLXRvcnJlbnQ6IHNraXBwZWQgcmVm Y2xrIGNoZWNrIGluCiAgdHBfcmVmX2Nsa3NfaW5pdCgpCi0gW01lZGl1bV0gcGh5OiBjYWRlbmNl LXRvcnJlbnQ6IG1pc3NlZCBQQ0llIE1MIGZsYWcgaW4KICB0cF9jaGVja19tdWx0aXBsZV9wY2ll X2xpbmtzKCkKLSBbTWVkaXVtXSBwaHk6IGNhZGVuY2UtdG9ycmVudDogcmVqZWN0ZWQgc3RhbmRh cmQgc3dhcCB3aXRoIGNsazEgaW4KICB0cF9maW5kX2xpbmtfY2ZnKCkKLSBbTWVkaXVtXSBwaHk6 IGNhZGVuY2UtdG9ycmVudDogdW5jaGVja2VkIHRwX2RwX3J1bigpIGFuZCBtaXNzaW5nIHJlc2V0 CiAgcm9sbGJhY2sKLS0KCmNvbW1pdCAzNDgwZWM5NzJkMGNkMmQ1NDJkNTQ3ZjFkNDVkN2Y0ZjM4 NDE1YmM4CkF1dGhvcjogQmVuamFtaW4gUm9iaW4gPGJlbmphbWluLnJvYmluQGJvb3RsaW4uY29t PgoKcGh5OiBjYWRlbmNlLXRvcnJlbnQ6IHJld3JpdGUgVG9ycmVudCBQSFkgZHJpdmVyCgpUaGlz IGNvbW1pdCByZXdyaXRlcyB0aGUgQ2FkZW5jZSBUb3JyZW50IFBIWSBkcml2ZXIgdG8gY29tcHV0 ZSBjbG9jayBhbmQKUExMIHJlZ2lzdGVyIHZhbHVlcyBhdCBydW50aW1lIGFuZCBsb29rIHVwIHJl bWFpbmluZyBwcm90b2NvbCwgcmV2aXNpb24sCmFuZCBwcm9jZXNzLW5vZGUgcmVnaXN0ZXIgc2V0 dGluZ3MgcGVyIHJlZ2lzdGVyIGluc3RlYWQgb2YgdXNpbmcgc3RhdGljCnJlZ2lzdGVyIHRhYmxl cy4KCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvcGh5L2NhZGVuY2UvcGh5LWNhZGVuY2UtdG9ycmVu dC5jIGIvZHJpdmVycy9waHkvY2FkZW5jZS9waHktY2FkZW5jZS10b3JyZW50LmMKPiBpbmRleCAx ZTE3OGFhMmZmZDc2Li43NGE2NWYwZjRiMjQyIDEwMDY0NAo+IC0tLSBhL2RyaXZlcnMvcGh5L2Nh ZGVuY2UvcGh5LWNhZGVuY2UtdG9ycmVudC5jCj4gKysrIGIvZHJpdmVycy9waHkvY2FkZW5jZS9w aHktY2FkZW5jZS10b3JyZW50LmMKClsgLi4uIF0KCj4gQEAgLTM5NCw1NDUzICs1MTUsNDYyOSBA QCBlbnVtIHBoeV9wb3dlcnN0YXRlIHsKPiAgCVBPV0VSU1RBVEVfQTMgPSAzLAo+ICB9Owo+ICAK PiArc3RhdGljIGNvbnN0IHN0cnVjdCB0cF9saW5rX2NmZyB0cF9saW5rX2NmZ3NbXSA9IHsKPiAr CXsKPiArCQkvKiBQTEwgMCBNMDogUENJZSwgUExMIDAgTTE6IFBDSWUsIFBMTCAxOiBOb25lICov Cj4gKwkJLnN0ZDAgPSBTVEQwX1BDSUVfU0wsCS5zdGQxID0gU1REMV9OT05FLAo+ICsJCS5wbGxf ZnJlcSA9IHsgUExMXzEwXzAwX0dIWiwgUExMXzhfMDBfR0haLCBQTExfOF8wMF9HSFogfSwKPiAr CQkucGh5X3BsbF9jZmcgPSAweDAwMDEsCj4gKwkJLnBsbF9jbGtfc2VsID0geyAweDA2MDEsIDB4 MDQwMCwgMHgwNDAwIH0sCj4gKwkJLnhjdnJfZGlhZ19wbGxkcmNfY3RybCA9IHsgMHgwMDEyLCAw eDAwMTIgfSwKPiArCQkueGN2cl9kaWFnX2hzY2xrX3NlbCA9IHsgMHgwMDAwLCAweDAwMDAgfSwK PiArCQkueGN2cl9kaWFnX2hzY2xrX2RpdiA9IHsgMHgwMDAxLCAweDAwMDEgfSwKPiArCX0sCgpb IC4uLiBdCgo+ICtzdGF0aWMgZW51bSB0cF9wbGxfZmJfZGl2X21vZGUgdHBfY2FsY19wY2llX3Bs bF9mYl9kaXZfbW9kZShjb25zdCBzdHJ1Y3QgdHBfcGh5ICp0cF9waHkpCj4gK3sKPiArCXUzMiB0 ZWNoX3RhZyA9IHRwX3BoeS0+dGVjaF90YWc7Cj4gKwllbnVtIHRwX3JldmlzaW9uIHJldiA9IHRw X3BoeS0+cmV2Owo+ICsJZW51bSB0cF9wbGxfZmJfZGl2X21vZGUgZGl2X21vZGU7Cj4gKwo+ICsJ aWYgKHRlY2hfdGFnICYgKFRFQ0hfVFNNQ18xNiB8IFRFQ0hfVFNNQ18xMikpIHsKPiArCQlpZiAo cmV2ID09IFJFVl9SMTAwKSB7Cj4gKwkJCWlmICh0cF9waHktPnBsbHNbUExMMV9NT0RFMF0uZnJl cV9raHogPT0gMCkKPiArCQkJCWRpdl9tb2RlID0gUExMX0ZCX0RJVl9NT0RFX0ZCUjsKPiArCQkJ ZWxzZQo+ICsJCQkJZGl2X21vZGUgPSBQTExfRkJfRElWX01PREVfRDMyOwo+ICsJCX0gZWxzZSB7 CgpbU2V2ZXJpdHk6IE1lZGl1bV0KQ2FuIHRwX3BoeS0+cGxsc1tQTEwxX01PREUwXS5mcmVxX2to eiBldmVyIGJlIDAgaGVyZT8KCkV2ZXJ5IGVudHJ5IGluIHRwX2xpbmtfY2Znc1tdLCBpbmNsdWRp bmcgc2luZ2xlLWxpbmsgUENJZSAoU1REMF9QQ0lFX1NMCndpdGggU1REMV9OT05FKSwgc2V0cyBw bGxfZnJlcVtQTEwxX01PREUwXSB0byBhIG5vbi16ZXJvIGZyZXF1ZW5jeQooUExMXzhfMDBfR0ha KSByYXRoZXIgdGhhbiBQTExfVU5VU0VELiAgQmVjYXVzZSB0cF9pbml0X3BsbHNfZGF0YSgpCnBv cHVsYXRlcyBwbGxzW1BMTDFfTU9ERTBdLmZyZXFfa2h6IGZyb20gcGxsX2ZyZXFbUExMMV9NT0RF MF0gYmVmb3JlCmNhbGxpbmcgdHBfY2FsY19wbGxfZmJfZGl2X21vZGVzKCksIHNpbmdsZS1saW5r IFBDSWUgb24gVFNNQyAxNm5tLzEybm0KUkVWX1IxMDAgaGFyZHdhcmUgYWx3YXlzIHNlbGVjdHMg UExMX0ZCX0RJVl9NT0RFX0QzMiBpbnN0ZWFkIG9mClBMTF9GQl9ESVZfTU9ERV9GQlIsIG1pc3By b2dyYW1taW5nIHRoZSBQTEwgY29udHJvbCwgVkNPIGNhbGlicmF0aW9uLCBhbmQKbG9jayByZWdp c3RlcnMuCgpbIC4uLiBdCgo+ICtzdGF0aWMgdm9pZCB0cF93cml0ZV9wbGxfY3BfcGFkaihjb25z dCBzdHJ1Y3QgdHBfcGh5ICp0cF9waHksIGVudW0gdHBfcGxsX2lkIHBsbF9pZCkKPiArewo+ICsJ dTMyIHRlY2hfdGFnID0gdHBfcGh5LT50ZWNoX3RhZzsKPiArCXUzMiByZXZfbXNrID0gQklUKHRw X3BoeS0+cmV2KTsKPiArCWNvbnN0IHN0cnVjdCB0cF9wbGxfZGF0YSAqcGxsID0gJnRwX3BoeS0+ cGxsc1twbGxfaWRdOwo+ICsJdTE2IHZhbDsKPiArCj4gKwkvKiBQTEwgY2hhcmdlIHB1bXAgcHJv cG9ydGlvbmFsIHBhdGggYWRqdXN0IHJlZ2lzdGVyICovCj4gKwlpZiAocGxsLT5mcmVxX2toeiA8 IDgwMDAwMDApIHsKPiArCQl2YWwgPSAweDBCMTc7Cj4gKwl9IGVsc2UgaWYgKHBsbC0+ZnJhY3Rp b25hbF9tb2RlKSB7Cj4gKwkJaWYgKHRlY2hfdGFnICYgVEVDSF9UU01DXzcpCj4gKwkJCXZhbCA9 IDB4MEIxNzsKPiArCQllbHNlIGlmICh0ZWNoX3RhZyAmIChURUNIX1NTXzUgfCBURUNIX1NTXzcp KQo+ICsJCQl2YWwgPSAweDAzMDk7Cj4gKwkJZWxzZQo+ICsJCQl2YWwgPSAweDA1MDk7IC8qIFRT TUNfNSwgVFNNQ18xMiwgVFNNQ18xNiwgVFNNQ18xNl8wODA1ICovCj4gKwl9IGVsc2UgaWYgKHBs bC0+ZnJlcV9raHogPj0gMTAwMDAwMDApIHsKPiArCQlpZiAodGVjaF90YWcgJiBURUNIX1RTTUNf NykKPiArCQkJdmFsID0gKHJldl9tc2sgJiAoUkVWX01TS19SMTAwIHwgUkVWX01TS19SMTEwKSkg PyAweDAwMjMgOiAweDAwMzU7Cj4gKwkJZWxzZSBpZiAodGVjaF90YWcgJiBURUNIX1RTTUNfNSkK PiArCQkJdmFsID0gKHBsbF9pZCA9PSBQTEwwX01PREUwKSA/IDB4MDAyRCA6IDB4MDAzNTsKPiAr CQllbHNlIGlmICh0ZWNoX3RhZyAmIChURUNIX1NTXzUgfCBURUNIX1NTXzcpKQo+ICsJCQl2YWwg PSAweDAxM0U7Cj4gKwkJZWxzZQo+ICsJCQl2YWwgPSAweDAwMjg7IC8qIFRTTUNfMTIsIFRTTUNf MTYsIFRTTUNfMTZfMDgwNSAqLwo+ICsJfSBlbHNlIHsKPiArCQlpZiAodGVjaF90YWcgJiBURUNI X1RTTUNfMTYpCj4gKwkJCXZhbCA9IChyZXZfbXNrICYgUkVWX01TS19SMTAwKSA/IDB4MDAyOCA6 IDB4MDEyODsKPiArCQllbHNlIGlmICh0ZWNoX3RhZyAmIFRFQ0hfVFNNQ18xNl8wODA1KQo+ICsJ CQl2YWwgPSAweDAxMjg7Cj4gKwkJZWxzZSBpZiAodGVjaF90YWcgJiBURUNIX1RTTUNfMTIpCj4g KwkJCXZhbCA9IDB4MDAyODsKPiArCQllbHNlIGlmICh0ZWNoX3RhZyAmIFRFQ0hfVFNNQ183KQo+ ICsJCQl2YWwgPSAocmV2X21zayAmIChSRVZfTVNLX1IxMDAgfCBSRVZfUjExMCkpID8gMHgwMDFE IDogMHgwMDMxOwoKW1NldmVyaXR5OiBNZWRpdW1dClNob3VsZCBSRVZfUjExMCBiZSBSRVZfTVNL X1IxMTAgaW4gdGhlIFRFQ0hfVFNNQ183IGNoZWNrPyAgUkVWX1IxMTAgaXMKdGhlIGVudW0gdmFs dWUgMSAoZXF1YWwgdG8gUkVWX01TS19SMTAwKSByYXRoZXIgdGhhbiBCSVQoUkVWX1IxMTApLCBz byBSMTEwCmhhcmR3YXJlIChyZXZfbXNrID09IDB4MikgbmV2ZXIgbWF0Y2hlcyBhbmQgcHJvZ3Jh bXMKQ01OX1BESUFHX1BMTHhfQ1BfUEFESl9NeCB3aXRoIDB4MDAzMSBpbnN0ZWFkIG9mIDB4MDAx RCBmb3IgOCBHSHoKaW50ZWdlci1tb2RlIFBMTHMuCgpbIC4uLiBdCgo+ICtzdGF0aWMgdm9pZCB0 cF93cml0ZV9wbGxfZmRfZGl2X3JlZ3MoY29uc3Qgc3RydWN0IHRwX3BoeSAqdHBfcGh5LCBlbnVt IHRwX3BsbF9pZCBwbGxfaWQsCj4gKwkJCQkgICAgIHUzMiBkaXZfcmF0aW8pCj4gK3sKPiArCWNv bnN0IHN0cnVjdCB0cF9yZWdfYmFzZSAqYmFzZSA9ICZ0cF9waHktPnJlZ19jb21tb25fY2RiOwo+ ICsJY29uc3Qgc3RydWN0IHRwX3BsbF9kYXRhICpwbGwgPSAmdHBfcGh5LT5wbGxzW3BsbF9pZF07 Cj4gKwl1MzIgdGVjaF90YWcgPSB0cF9waHktPnRlY2hfdGFnOwo+ICsJdTE2IGhpZ2hfZGl2Owo+ ICsJdTE2IGxvd19kaXY7Cj4gKwo+ICsJLyogSW4gZnJhY3Rpb25hbCBtb2RlLCB3ZSB1c2UgZGVm YXVsdC9yZXNldCB2YWx1ZSAqLwo+ICsJaWYgKHBsbC0+ZnJhY3Rpb25hbF9tb2RlKQo+ICsJCXJl dHVybjsKPiArCj4gKwlpZiAocGxsX2lkID09IFBMTDBfTU9ERTAgJiYgcGxsLT5yZWZfY2xrX2to eiA9PSAxMDAwMDAgJiYgcGxsLT5mcmVxX2toeiA9PSAxMDAwMDAwMCkgewo+ICsJCS8qIDEwMCBN SHogcmVmY2xrLCAxMCBHSHogUExMICovCj4gKwkJaWYgKHRlY2hfdGFnICYgKFRFQ0hfVFNNQ18x MiB8IFRFQ0hfVFNNQ18xNiB8IFRFQ0hfVFNNQ18xNl8wODA1KSkgewo+ICsJCQloaWdoX2RpdiA9 IDMwOwo+ICsJCQlsb3dfZGl2ID0gMTI7Cj4gKwkJfSBlbHNlIHsKPiArCQkJaGlnaF9kaXYgPSAz NjsKPiArCQkJbG93X2RpdiA9IDY7Cj4gKwkJfQo+ICsJfSBlbHNlIGlmIChwbGwtPnJlZl9jbGtf a2h6ID09IDEwMDAwMCAmJiBwbGwtPmZyZXFfa2h6ID09IDgwMDAwMDApIHsKPiArCQkvKiAxMDAg TUh6IHJlZmNsaywgOCBHSHogUExMICovCj4gKwkJaWYgKHRlY2hfdGFnICYgKFRFQ0hfVFNNQ18x MiB8IFRFQ0hfVFNNQ18xNiB8IFRFQ0hfVFNNQ18xNl8wODA1KSkgewo+ICsJCQloaWdoX2RpdiA9 IDE2Owo+ICsJCQlsb3dfZGl2ID0gMTY7Cj4gKwkJfSBlbHNlIHsKPiArCQkJaGlnaF9kaXYgPSAy ODsKPiArCQkJbG93X2RpdiA9IDQ7Cj4gKwkJfQo+ICsJfSBlbHNlIHsKPiArCQkvKiBHZW5lcmlj IGNhbGN1bGF0aW9ucyAqLwo+ICsKPiArCQkvKiBQTEwgaGlnaCBpbnRlZ2VyIGRpdmlkZXIgdmFs OiBFVkVOKGRpdl9yYXRpb18yICogNjcvMTAwKSAtIDQgKi8KPiArCQloaWdoX2RpdiA9IERJVl9S T1VORF9VUCgoZGl2X3JhdGlvID4+IDEpICogNjdVLCAxMDBVKTsKPiArCQloaWdoX2RpdiAtPSAo aGlnaF9kaXYgJiAxVSkgPyAzVSA6IDRVOwo+ICsKPiArCQkvKiBQTEwgbG93IGludGVnZXIgZGl2 aWRlciB2YWw6IGRpdl9yYXRpb18yIC0gOCAtIGhpZ2hfZGl2ICovCj4gKwkJbG93X2RpdiA9IChk aXZfcmF0aW8gPj4gMSkgLSA4IC0gaGlnaF9kaXY7Cj4gKwl9Cj4gKwo+ICsJdHBfcmVnX3dyaXRl KGJhc2UsIENNTl9QTEx4X0RTTV9GQkhfT1ZSRF9NeChwbGxfaWQpLCBoaWdoX2Rpdik7Cj4gKwl0 cF9yZWdfd3JpdGUoYmFzZSwgQ01OX1BMTHhfRFNNX0ZCTF9PVlJEX014KHBsbF9pZCksIGxvd19k aXYpOwo+ICt9Cj4gKwo+ICtzdGF0aWMgdm9pZCB0cF93cml0ZV9wbGxfaXRyaW1fcmVnKGNvbnN0 IHN0cnVjdCB0cF9waHkgKnRwX3BoeSwgZW51bSB0cF9wbGxfaWQgcGxsX2lkKQo+ICt7Cj4gKwlj b25zdCBzdHJ1Y3QgdHBfcmVnX2Jhc2UgKmJhc2UgPSAmdHBfcGh5LT5yZWdfY29tbW9uX2NkYjsK PiArCWNvbnN0IHN0cnVjdCB0cF9wbGxfZGF0YSAqcGxsID0gJnRwX3BoeS0+cGxsc1twbGxfaWRd Owo+ICsKPiArCWlmICh0cF9waHktPnRlY2hfdGFnICYgVEVDSF9UU01DX0FMTCkgewo+ICsJCXUx NiB2YWwgPSAocGxsLT5mcmVxX2toeiA+PSAxMDAwMDAwMCkgPyAweDAwM0YgOiAweDAwN0Y7Cj4g Kwo+ICsJCXRwX3JlZ193cml0ZShiYXNlLCBDTU5fUERJQUdfUExMeF9JVFJJTV9NeChwbGxfaWQp LCB2YWwpOwo+ICsJfQo+ICt9Cj4gKwo+ICtzdGF0aWMgdm9pZCB0cF93cml0ZV9wbGxfcmVncyhj b25zdCBzdHJ1Y3QgdHBfcGh5ICp0cF9waHksIGVudW0gdHBfcGxsX2lkIHBsbF9pZCkKPiArewo+ ICsJY29uc3Qgc3RydWN0IHRwX3JlZ19iYXNlICpiYXNlID0gJnRwX3BoeS0+cmVnX2NvbW1vbl9j ZGI7Cj4gKwljb25zdCBzdHJ1Y3QgdHBfcGxsX2RhdGEgKnBsbCA9ICZ0cF9waHktPnBsbHNbcGxs X2lkXTsKPiArCXUzMiBmZF9kaXZfcHJlc2NhbGU7Cj4gKwl1MzIgZGl2X3JhdGlvOwo+ICsJdTE2 IGZyYWNkaXZsOwo+ICsJdTE2IHZhbDsKPiArCj4gKwlpZiAocGxsX2lkICE9IFBMTDBfTU9ERTEp Cj4gKwkJdHBfd3JpdGVfcGxsX3Zjb19yZWdzKHRwX3BoeSwgcGxsX2lkKTsKPiArCj4gKwkvKiBE aXZpZGUgcmF0aW8gKi8KPiArCWRpdl9yYXRpbyA9IHBsbC0+ZnJlcV9raHogLyBwbGwtPnJlZl9j bGtfa2h6Owo+ICsKPiArCS8qIFBMTCBmZWVkYmFjayBkaXZpZGVyIHByZXNjYWxlICovCj4gKwlm ZF9kaXZfcHJlc2NhbGUgPSAoKCFwbGwtPmZyYWN0aW9uYWxfbW9kZSkgfHwgKGRpdl9yYXRpbyA+ IDUxMikpID8gMSA6IDA7Cj4gKwo+ICsJLyogUExMIGludGVnZXIgZGl2aWRlciB2YWx1ZSAqLwo+ ICsJdmFsID0gKHBsbC0+ZnJhY3Rpb25hbF9tb2RlKSA/IChkaXZfcmF0aW8gPj4gZmRfZGl2X3By ZXNjYWxlKSA6IDA7Cj4gKwl0cF9yZWdfd3JpdGUoYmFzZSwgQ01OX1BMTHhfSU5URElWX014KHBs bF9pZCksIHZhbCk7Cj4gKwo+ICsJLyogUExMIGZyYWN0aW9uYWwgZGl2aWRlciB2YWx1ZSAqLwo+ ICsJaWYgKHBsbC0+ZnJhY3Rpb25hbF9tb2RlKSB7Cj4gKwkJdTMyIGRlbiA9IHBsbC0+cmVmX2Ns a19raHogPDwgZmRfZGl2X3ByZXNjYWxlOwo+ICsJCXUzMiByZW0gPSBwbGwtPmZyZXFfa2h6ICUg ZGVuOwo+ICsKPiArCQlmcmFjZGl2bCA9IERJVl9ST1VORF9DTE9TRVNUKHJlbSA8PCAxNiwgZGVu KTsKPiArCX0gZWxzZSB7Cj4gKwkJZnJhY2RpdmwgPSAwOwo+ICsJfQo+ICsKPiArCXRwX3JlZ193 cml0ZShiYXNlLCBDTU5fUExMeF9GUkFDRElWTF9NeChwbGxfaWQpLCBmcmFjZGl2bCk7Cj4gKwl0 cF9yZWdfd3JpdGUoYmFzZSwgQ01OX1BMTHhfRlJBQ0RJVkhfTXgocGxsX2lkKSwgcGxsLT5mcmFj dGlvbmFsX21vZGUgPyAyIDogMCk7Cj4gKwo+ICsJLyogUExMIGhpZ2ggdGhyZXNob2xkIHZhbHVl ICovCj4gKwlpZiAocGxsLT5mcmFjdGlvbmFsX21vZGUpIHsKPiArCQkvKiBFVkVOKENFSUwoKGZy YWNkaXZsLzY1NTM2ICsgKGRpdl9yYXRpbyA+PiBmZF9kaXZfcHJlc2NhbGUpKSAqIDIgLyAzKSkg Ki8KPiArCQl1MzIgbnVtID0gZnJhY2RpdmwgKyAoZGl2X3JhdGlvIDw8ICgxNiAtIGZkX2Rpdl9w cmVzY2FsZSkpOwoKW1NldmVyaXR5OiBIaWdoXQpDYW4gcmVtIDw8IDE2IG92ZXJmbG93IDMyLWJp dCB1MzIgd2hlbiBjb21wdXRpbmcgZnJhY2RpdmwgaW4KdHBfd3JpdGVfcGxsX3JlZ3MoKT8KCldo ZW4gcmVtID49IDY1NTM1IChmb3IgZXhhbXBsZSwgRGlzcGxheVBvcnQgYXQgdGhlIGRlZmF1bHQg ODEwMCBNYnBzIHJhdGUKd2l0aCBhIHN1cHBvcnRlZCAxNTYuMjUgTUh6IHJlZmVyZW5jZSBjbG9j aywgd2hlcmUgZGVuID0gMTU2MjUwIGFuZApyZW0gPSAxMzEyNTApLCByZW0gPDwgMTYgb3ZlcmZs b3dzIHUzMiBhbmQgY29ycnVwdHMgYm90aApDTU5fUExMeF9GUkFDRElWTF9NeCBhbmQgQ01OX1BM THhfSElHSF9USFJfTXggKHByb2R1Y2luZyBmcmFjZGl2bCA9IDB4MDA0QgppbnN0ZWFkIG9mIDB4 RDcwQSkuICBBbHNvLCB3aGVuIGZkX2Rpdl9wcmVzY2FsZSA9PSAxIGFuZCBkaXZfcmF0aW8gaXMg b2RkCihlLmcuIDIwIE1IeiByZWZjbGsgd2l0aCAxMC4zMTI1IEdIeiBVU1hHTUlJIHdoZXJlIGRp dl9yYXRpbyA9IDUxNSksCmRpdl9yYXRpbyA8PCAoMTYgLSBmZF9kaXZfcHJlc2NhbGUpIHJldGFp bnMgYml0IDAgb2YgZGl2X3JhdGlvIGluc3RlYWQgb2YKdXNpbmcgKGRpdl9yYXRpbyA+PiBmZF9k aXZfcHJlc2NhbGUpIDw8IDE2LCBkb3VibGUtY291bnRpbmcgdGhlIG9kZApyZW1haW5kZXIgYWxy ZWFkeSBpbmNsdWRlZCBpbiBmcmFjZGl2bC4KCj4gKwo+ICsJCXZhbCA9IERJVl9ST1VORF9VUChu dW0sIDMgPDwgMTUpOwo+ICsJCWlmICh2YWwgJiAxKQo+ICsJCQl2YWwrKzsKPiArCX0gZWxzZSB7 Cj4gKwkJdmFsID0gMDsKPiArCX0KPiArCj4gKwl0cF9yZWdfd3JpdGUoYmFzZSwgQ01OX1BMTHhf SElHSF9USFJfTXgocGxsX2lkKSwgdmFsKTsKPiArCj4gKwkvKiBQTEwgZGVsdGEgc2lnbWEgbW9k dWxhdG9yIGRpYWdub3N0aWNzIHJlZ2lzdGVyICovCj4gKwl0cF9yZWdfd3JpdGUoYmFzZSwgQ01O X1BMTHhfRFNNX0RJQUdfTXgocGxsX2lkKSwKPiArCQkgICAgIHBsbC0+ZnJhY3Rpb25hbF9tb2Rl ID8gMHgwMDA0IDogMHg0MDA0KTsKPiArCj4gKwkvKiBQTEwgaGlnaCBhbmQgbG93IGludGVnZXIg ZGl2aWRlciB2YWx1ZSAqLwo+ICsJdHBfd3JpdGVfcGxsX2ZkX2Rpdl9yZWdzKHRwX3BoeSwgcGxs X2lkLCBkaXZfcmF0aW8pOwo+ICsKPiArCWlmIChwbGwtPnNzYykKPiArCQl0cF93cml0ZV9zc2Nf Y3RybCh0cF9waHksIHBsbF9pZCwgZmRfZGl2X3ByZXNjYWxlKTsKCltTZXZlcml0eTogTWVkaXVt XQpEb2VzIGR5bmFtaWMgRGlzcGxheVBvcnQgcmF0ZSByZWNvbmZpZ3VyYXRpb24gbGVhdmUgc3Rh bGUgdmFsdWVzIGluCkNNTl9QTEx4X1NTX0NUUkwxX014Li5DVFJMNF9NeCBhbmQgQ01OX1BMTHhf RFNNX0ZCSC9GQkxfT1ZSRF9NeD8KCldoZW4gdHBfZHBfdXBkYXRlX3BsbF9mcmVxKCkgLT4gdHBf d3JpdGVfcGxsX3JlZ3MoKSByZWNvbmZpZ3VyZXMgYSBEUCBsaW5rCmZyb20gU1NDIGVuYWJsZWQg dG8gU1NDIGRpc2FibGVkLCBza2lwcGluZyB0cF93cml0ZV9zc2NfY3RybCgpIGxlYXZlcwpDTU5f UExMeF9TU19DVFJMMV9NeC4uQ1RSTDRfTXggZW5hYmxlZCBpbiBoYXJkd2FyZSB3aGlsZSBWQ08g YW5kIGxvY2sKY291bnRlcnMgYXJlIHByb2dyYW1tZWQgZm9yIG5vbi1TU0Mgb3BlcmF0aW9uLiAg U2ltaWxhcmx5LCBpZiBhIERQIFBMTApzd2l0Y2hlcyBmcm9tIGludGVnZXIgbW9kZSAoZS5nLiAy LjcvNS40IEdicHMgd2l0aCAxMDAgTUh6IHJlZmNsayBhbmQgbm8KU1NDKSB0byBmcmFjdGlvbmFs IG1vZGUsIHJldHVybmluZyBlYXJseSBpbiB0cF93cml0ZV9wbGxfZmRfZGl2X3JlZ3MoKQpsZWF2 ZXMgdGhlIHByZXZpb3VzIGludGVnZXIgZGl2aWRlciBvdmVycmlkZXMgaW4gQ01OX1BMTHhfRFNN X0ZCSF9PVlJEX014CmFuZCBDTU5fUExMeF9EU01fRkJMX09WUkRfTXggaW5zdGVhZCBvZiByZXN0 b3JpbmcgdGhlaXIgcmVzZXQgdmFsdWVzLgoKWyAuLi4gXQoKPiArc3RhdGljIGludCB0cF9kcHR4 X3NldF9wbGxfZW4oY29uc3Qgc3RydWN0IHRwX3BoeSAqdHBfcGh5LCB1MzIgbnVtX2xhbmVzLCBi b29sIGVuYWJsZSkKPiArewo+ICsJdm9pZCBfX2lvbWVtICphZGRyOwo+ICsJdTMyIHBsbF9hY2tf dmFsOwo+ICsJdTMyIHJkX3ZhbDsKPiArCWludCByZXQ7Cj4gKwo+ICsJLyogVXNlZCB0byBkZXRl cm1pbmUgd2hpY2ggYml0cyB0byBjaGVjayBmb3Igb3IgZW5hYmxlIGluIFBIWV9QTUFfWENWUl9Q TExDTEtfRU4gcmVnICovCj4gKwl1MzIgcGxsX2JpdHM7Cj4gKwkvKiBVc2VkIHRvIGVuYWJsZSBv ciBkaXNhYmxlIGxhbmVzLiAqLwo+ICsJdTMyIHBsbF92YWw7Cj4gKwo+ICsJLyogU2VsZWN0IHJl ZyB2YWx1ZSBhbmQgbWFzaywgZGVwZW5kaW5nIG9uIGVuYWJsZWQgbGFuZSBjb3VudC4gKi8KPiAr CXBsbF92YWwgPSB0cF9yZWdfZHB0eF9yZWFkKHRwX3BoeSwgUEhZX1BNQV9YQ1ZSX1BMTENMS19F Tik7Cj4gKwo+ICsJaWYgKGVuYWJsZSkgewo+ICsJCXBsbF9iaXRzID0gKCgxIDw8IG51bV9sYW5l cykgLSAxKTsKPiArCQlwbGxfdmFsIHw9IHBsbF9iaXRzOwo+ICsJCXBsbF9hY2tfdmFsID0gcGxs X2JpdHM7Cj4gKwl9IGVsc2Ugewo+ICsJCXBsbF9iaXRzID0gKCgxIDw8IG51bV9sYW5lcykgLSAx KTsKPiArCQlwbGxfdmFsICY9ICh+cGxsX2JpdHMpOwo+ICsJCXBsbF9hY2tfdmFsID0gMDsKPiAr CX0KClsgLi4uIF0KCj4gK3N0YXRpYyB2b2lkIHRwX2RwX3NldF9sYW5lcyhjb25zdCBzdHJ1Y3Qg dHBfcGh5ICp0cF9waHksIHN0cnVjdCB0cF9saW5rICpsaW5rLCB1MzIgbnVtX2xhbmVzKQo+ICt7 Cj4gKwl1MzIgcG1hX3R4X2VsZWNfaWRsZV9tYXNrOwo+ICsJdTggdXNlZF9sYW5lX21hc2s7Cj4g Kwl1OCBhbGxfbGFuZV9tYXNrOwo+ICsJdTMyIHBsbF9jbGtfZW47Cj4gKwl1MzIgcHdyX3N0YXRl Owo+ICsJdTMyIHZhbHVlOwo+ICsJdTMyIG1sYW5lID0gbGluay0+bWxhbmU7Cj4gKwo+ICsJdXNl ZF9sYW5lX21hc2sgPSAoKDFVIDw8IG51bV9sYW5lcykgLSAxKSA8PCBtbGFuZTsKPiArCWFsbF9s YW5lX21hc2sgPSAoKDFVIDw8IGxpbmstPm1heF9sYW5lcykgLSAxKSA8PCBtbGFuZTsKClsgLi4u IF0KCj4gKwkvKiBDbGVhciByZXF1ZXN0ZWQgcG93ZXIgc3RhdGUgc2V0IFBMTCBjbG9jayBlbmFi bGUgdG8gMCBvbiBhbGwgdXNlZCBsYW5lcy4gKi8KPiArCXB3cl9zdGF0ZSA9IHRwX3JlZ19kcHR4 X3JlYWQodHBfcGh5LCBQSFlfUE1BX1hDVlJfUE9XRVJfU1RBVEVfUkVRKTsKPiArCXBsbF9jbGtf ZW4gPSB0cF9yZWdfZHB0eF9yZWFkKHRwX3BoeSwgUEhZX1BNQV9YQ1ZSX1BMTENMS19FTik7Cj4g Kwo+ICsJZm9yICh1MzIgaSA9IDA7IGkgPCBudW1fbGFuZXM7ICsraSkKPiArCQlwd3Jfc3RhdGUg Jj0gfihQTUFfWENWUl9QT1dFUl9TVEFURV9SRVFfTE5fTUFTSyA8PCBQSFlfUE9XRVJfU1RBVEVf TE4obWxhbmUgKyBpKSk7Cj4gKwo+ICsJcGxsX2Nsa19lbiAmPSB+dXNlZF9sYW5lX21hc2s7Cj4g Kwo+ICsJdHBfcmVnX2RwdHhfd3JpdGUodHBfcGh5LCBQSFlfUE1BX1hDVlJfUE9XRVJfU1RBVEVf UkVRLCBwd3Jfc3RhdGUpOwo+ICsJdHBfcmVnX2RwdHhfd3JpdGUodHBfcGh5LCBQSFlfUE1BX1hD VlJfUExMQ0xLX0VOLCBwbGxfY2xrX2VuKTsKPiArCj4gKwkvKiByZWxlYXNlIG1hc3RlciBsYW5l IHJlc2V0ICovCj4gKwl2YWx1ZSB8PSAxIDw8IG1sYW5lOwo+ICsJdHBfcmVnX2RwdHhfd3JpdGUo dHBfcGh5LCBQSFlfUkVTRVQsIHZhbHVlKTsKPiArCj4gKwkvKiB1cGRhdGUgdGhlIG51bWJlciBv ZiB1c2VkIGxhbmVzICovXG4rCWxpbmstPm51bV9sYW5lcyA9IG51bV9sYW5lczsKPiArfQoKW1Nl dmVyaXR5OiBIaWdoXQpTaG91bGQgcGxsX2JpdHMgaW4gdHBfZHB0eF9zZXRfcGxsX2VuKCkgYmUg c2hpZnRlZCBieSBsaW5rLT5tbGFuZT8KClVubGlrZSB0cF9kcF9zZXRfbGFuZXMoKSBhbmQgdHBf ZHB0eF9zZXRfcG93ZXJfc3RhdGUoKSwgdHBfZHB0eF9zZXRfcGxsX2VuKCkKY29tcHV0ZXMgcGxs X2JpdHMgPSAoKDEgPDwgbnVtX2xhbmVzKSAtIDEpIHdpdGhvdXQgc2hpZnRpbmcgYnkgbGluay0+ bWxhbmUsCnNvIGFueSBEaXNwbGF5UG9ydCBsaW5rIHdpdGggbWxhbmUgPiAwIG1vZGlmaWVzIFBI WV9QTUFfWENWUl9QTExDTEtfRU4gZm9yCmxhbmUgMCBhbmQgdGltZXMgb3V0IHBvbGxpbmcgUEhZ X1BNQV9YQ1ZSX1BMTENMS19FTl9BQ0suCgpJbiBhZGRpdGlvbiwgdHBfZHBfc2V0X2xhbmVzKCkg b25seSBjbGVhcnMgUEhZX1BNQV9YQ1ZSX1BPV0VSX1NUQVRFX1JFUSBhbmQKUEhZX1BNQV9YQ1ZS X1BMTENMS19FTiBhY3Jvc3MgdXNlZF9sYW5lX21hc2sgaW5zdGVhZCBvZiBhbGxfbGFuZV9tYXNr LApsZWF2aW5nIGRpc2FibGVkIGxhbmVzJyBQTExDTEtfRU4gYml0cyBzZXQgd2hlbiByZWR1Y2lu ZyB0aGUgbGFuZSBjb3VudC4KQW5kIHdoZW4gYm90aCBzZXRfbGFuZXMgYW5kIHNldF9yYXRlIGFy ZSByZXF1ZXN0ZWQgaW4gdHBfcGh5X2NvbmZpZ3VyZSgpLApydW5uaW5nIHRwX2RwX3NldF9sYW5l cygpIGJlZm9yZSB0cF9kcF9zZXRfcmF0ZSgpIHJlc2V0cyB0aGUgbGFuZXMsIGNsZWFycwpQTExD TEtfRU4sIGFuZCB1cGRhdGVzIGxpbmstPm51bV9sYW5lcyBiZWZvcmUgdHBfZHBfc2V0X3JhdGUo KSB0cmFuc2l0aW9ucwp0aGUgcHJldmlvdXNseSBhY3RpdmUgbGFuZXMgdG8gUE9XRVJTVEFURV9B MyAod2hpbGUgdHBfd3JpdGVfbGFuZXNfcmVnKCkKYWxzbyBvbmx5IHByb2dyYW1zIGxpbmstPm51 bV9sYW5lcyBpbnN0ZWFkIG9mIGxpbmstPm1heF9sYW5lcykuCgpbIC4uLiBdCgo+ICtzdGF0aWMg aW50IHRwX3BoeV9jb25maWd1cmUoc3RydWN0IHBoeSAqcGh5LCB1bmlvbiBwaHlfY29uZmlndXJl X29wdHMgKm9wdHMpCj4gK3sKPiArCXN0cnVjdCB0cF9waHkgKnRwX3BoeSA9IGRldl9nZXRfZHJ2 ZGF0YShwaHktPmRldi5wYXJlbnQpOwo+ICsJc3RydWN0IHRwX2xpbmsgKmxpbmsgPSBwaHlfZ2V0 X2RydmRhdGEocGh5KTsKPiArCWJvb2wgcnVuX25lZWRlZCA9IGZhbHNlOwo+ICsJaW50IHJldDsK PiArCj4gKwlndWFyZChtdXRleCkoJnRwX3BoeS0+bG9jayk7Cj4gKwo+ICsJaWYgKHRwX3BoeS0+ YWxyZWFkeV9jb25maWd1cmVkKQo+ICsJCXJldHVybiAwOwo+ICsKPiArCWlmIChsaW5rLT50eXBl ICE9IFNURF9UWVBFX0RQKQo+ICsJCXJldHVybiAtRUlOVkFMOwo+ICsKPiArCXJldCA9IHRwX2Rw X3ZlcmlmeV9jb25maWcobGluaywgJm9wdHMtPmRwKTsKPiArCWlmIChyZXQpIHsKPiArCQlkZXZf ZXJyKCZwaHktPmRldiwgImludmFsaWQgcGFyYW1zIGZvciBwaHkgY29uZmlndXJlXG4iKTsKPiAr CQlyZXR1cm4gcmV0Owo+ICsJfQo+ICsKPiArCWlmIChvcHRzLT5kcC5zZXRfbGFuZXMgJiYgb3B0 cy0+ZHAubGFuZXMgIT0gbGluay0+bnVtX2xhbmVzKSB7Cj4gKwkJdHBfZHBfc2V0X2xhbmVzKHRw X3BoeSwgbGluaywgb3B0cy0+ZHAubGFuZXMpOwo+ICsJCXJ1bl9uZWVkZWQgPSB0cnVlOwo+ICsJ fQo+ICsKPiArCWlmIChvcHRzLT5kcC5zZXRfcmF0ZSkgewo+ICsJCXJldCA9IHRwX2RwX3NldF9y YXRlKHRwX3BoeSwgbGluaywgJm9wdHMtPmRwKTsKPiArCQlpZiAocmV0KSB7Cj4gKwkJCWRldl9l cnIoJnBoeS0+ZGV2LCAiU2V0IHJhdGUgZmFpbGVkXG4iKTsKPiArCQkJcmV0dXJuIHJldDsKPiAr CQl9Cj4gKwkJcnVuX25lZWRlZCA9IHRydWU7Cj4gKwl9Cj4gKwo+ICsJaWYgKG9wdHMtPmRwLnNl dF92b2x0YWdlcykKPiArCQl0cF9kcF9zZXRfdm9sdGFnZXModHBfcGh5LCBsaW5rLCAmb3B0cy0+ ZHApOwo+ICsKPiArCWlmIChwaHktPnBvd2VyX2NvdW50ICYmIHJ1bl9uZWVkZWQpCj4gKwkJcmV0 ID0gdHBfZHBfcnVuKHRwX3BoeSwgbGluayk7Cj4gKwo+ICsJcmV0dXJuIHJldDsKPiArfQoKW1Nl dmVyaXR5OiBIaWdoXQpEb2VzIG1vdmluZyBEaXNwbGF5UG9ydCByZXNldCBkZWFzc2VydGlvbiBh bmQgdHBfZHBfcnVuKCkgb3V0IG9mCnRwX3BoeV9pbml0KCkgYW5kIGdhdGluZyB0cF9kcF9ydW4o KSBvbiBwaHktPnBvd2VyX2NvdW50IGJyZWFrCmNkbnMtbWhkcDg1NDY/CgpUaGUgaW4tdHJlZSBE aXNwbGF5UG9ydCBicmlkZ2UgY29uc3VtZXIKKGRyaXZlcnMvZ3B1L2RybS9icmlkZ2UvY2FkZW5j ZS9jZG5zLW1oZHA4NTQ2LWNvcmUuYykgY2FsbHMgcGh5X2luaXQoKSBpbgpjZG5zX21oZHBfcHJv YmUoKSBhbmQgcGh5X2NvbmZpZ3VyZSgpIGluIGNkbnNfbWhkcF9saW5rX3RyYWluaW5nX2luaXQo KSwKYnV0IG5ldmVyIGNhbGxzIHBoeV9wb3dlcl9vbigpLiAgQmVjYXVzZSB0cF9kcF9waHlfaW5p dCgpIG5vIGxvbmdlcgpkZWFzc2VydHMgcGh5X3JzdC9sbmtfcnN0IG9yIHN0YXJ0cyB0aGUgRFAg UExMIGFuZCBsYW5lcywgYW5kCnRwX3BoeV9jb25maWd1cmUoKSBza2lwcyB0cF9kcF9ydW4oKSB3 aGVuIHBoeS0+cG93ZXJfY291bnQgaXMgMCwgdGhlIFBIWQpyZW1haW5zIGhlbGQgaW4gcmVzZXQg YW5kIHRwX2RwX3NldF9yYXRlKCkgcG9sbHMgUEhZX1BNQV9DTU5fQ1RSTDIgb24gYW4KdW5zdGFy dGVkIFBIWS4KCj4gKwo+ICtzdGF0aWMgaW50IHRwX3BoeV9vbihzdHJ1Y3QgcGh5ICpwaHkpCj4g K3sKPiArCXN0cnVjdCB0cF9saW5rICpsaW5rID0gcGh5X2dldF9kcnZkYXRhKHBoeSk7Cj4gKwlz dHJ1Y3QgdHBfcGh5ICp0cF9waHkgPSBkZXZfZ2V0X2RydmRhdGEocGh5LT5kZXYucGFyZW50KTsK PiArCXUxNiB2YWw7Cj4gKwlpbnQgcmV0Owo+ICsKPiArCWd1YXJkKG11dGV4KSgmdHBfcGh5LT5s b2NrKTsKPiArCj4gKwlpZiAodHBfcGh5LT5hbHJlYWR5X2NvbmZpZ3VyZWQpIHsKPiArCQkvKiBH aXZlIDVtcyB0byAxMG1zIGRlbGF5IGZvciB0aGUgUElQRSBjbG9jayB0byBiZSBzdGFibGUgKi8K PiArCQl1c2xlZXBfcmFuZ2UoNTAwMCwgMTAwMDApOwo+ICsJCXJldHVybiAwOwo+ICsJfQo+ICsK PiArCWlmICh0cF9waHktPm5iX3BoeV9vbiA9PSAwKSB7Cj4gKwkJLyogVGFrZSB0aGUgUEhZIG91 dCBvZiByZXNldCAqLwo+ICsJCXJldCA9IHJlc2V0X2NvbnRyb2xfZGVhc3NlcnQodHBfcGh5LT5w aHlfcnN0KTsKPiArCQlpZiAocmV0KQo+ICsJCQlyZXR1cm4gcmV0Owo+ICsJfQo+ICsKPiArCS8q IFRha2UgdGhlIFBIWSBsYW5lIGdyb3VwIG91dCBvZiByZXNldCAqLwo+ICsJcmV0ID0gcmVzZXRf Y29udHJvbF9kZWFzc2VydChsaW5rLT5sbmtfcnN0KTsKPiArCWlmIChyZXQpCj4gKwkJcmV0dXJu IHJldDsKPiArCj4gKwkvKgo+ICsJICogV2FpdCBmb3IgY21uX3JlYWR5IGFzc2VydGlvbgo+ICsJ ICogUEhZX1BNQV9DTU5fQ1RSTDFbMF0gPT0gMQo+ICsJICovCj4gKwlyZXQgPSByZWFkX3BvbGxf dGltZW91dCh0cF9yZWdfcmVhZCwgdmFsLCB2YWwgJiAxLCAxMDAwLCBQTExfTE9DS19USU1FT1VU LCBmYWxzZSwKPiArCQkJCSZ0cF9waHktPnJlZ19waHlfcG1hX2NvbW1vbl9jZGIsIFBIWV9QTUFf Q01OX0NUUkwxKTsKPiArCWlmIChyZXQpIHsKPiArCQlkZXZfZXJyKHRwX3BoeS0+ZGV2LCAiVGlt ZW91dCB3YWl0aW5nIGZvciBDTU4gcmVhZHlcbiIpOwo+ICsJCXJldHVybiByZXQ7Cj4gKwl9Cj4g Kwo+ICsJaWYgKGxpbmstPnR5cGUgPT0gU1REX1RZUEVfRFApIHsKPiArCQl0cF9kcF9ydW4odHBf cGh5LCBsaW5rKTsKPiArCX0gZWxzZSBpZiAobGluay0+dHlwZSA9PSBTVERfVFlQRV9QQ0lFIHx8 IGxpbmstPnR5cGUgPT0gU1REX1RZUEVfVVNCX1RYUlgpIHsKPiArCQlzdHJ1Y3QgdHBfcmVnX2Jh c2UgKnJlZ19iYXNlOwo+ICsKPiArCQlyZWdfYmFzZSA9ICZ0cF9waHktPnJlZ19waHlfcGNzX2xh bmVfY2RiW2xpbmstPm1sYW5lXTsKPiArCQlyZXQgPSByZWFkX3BvbGxfdGltZW91dCh0cF9yZWdf cmVhZCwgdmFsLCAodmFsICYgMikgPT0gMCwgMTAwMCwKPiArCQkJCQlQTExfTE9DS19USU1FT1VU LCBmYWxzZSwgcmVnX2Jhc2UsCj4gKwkJCQkJUEhZX1BDU19JU09fTElOS19DVFJMKTsKPiArCQlp ZiAocmV0IDwgMCkgewo+ICsJCQlkZXZfZXJyKHRwX3BoeS0+ZGV2LCAiVGltZW91dCB3YWl0aW5n IGZvciBQSFkgc3RhdHVzIHJlYWR5XG4iKTsKPiArCQkJcmV0dXJuIHJldDsKPiArCQl9Cj4gKwl9 Cj4gKwo+ICsJdHBfcGh5LT5uYl9waHlfb24rKzsKPiArCXJldHVybiAwOwo+ICt9CgpbU2V2ZXJp dHk6IE1lZGl1bV0KU2hvdWxkIHRwX3BoeV9vbigpIGNoZWNrIHRoZSByZXR1cm4gdmFsdWUgb2Yg dHBfZHBfcnVuKCkgYW5kIHJlLWFzc2VydApsaW5rLT5sbmtfcnN0IGFuZCB0cF9waHktPnBoeV9y c3Qgb24gZXJyb3I/CgpSaWdodCBub3cgYSB0aW1lb3V0IGluIHRwX2RwX3J1bigpIGlzIGlnbm9y ZWQgYW5kIHRwX3BoeV9vbigpIGluY3JlbWVudHMKbmJfcGh5X29uIGFuZCByZXR1cm5zIDAuICBD b252ZXJzZWx5LCBpZiBkZWFzc2VydGluZyBsaW5rLT5sbmtfcnN0IG9yCnBvbGxpbmcgUEhZX1BN QV9DTU5fQ1RSTDEgb3IgUEhZX1BDU19JU09fTElOS19DVFJMIGZhaWxzLCB0cF9waHlfb24oKQpy ZXR1cm5zIGFuIGVycm9yIHdpdGhvdXQgcmUtYXNzZXJ0aW5nIHRoZSByZXNldHMgaXQgZGVhc3Nl cnRlZCBhbmQgd2l0aG91dAppbmNyZW1lbnRpbmcgcGh5LT5wb3dlcl9jb3VudCwgc28gdHBfcGh5 X29mZigpIHdpbGwgbm90IGJlIGNhbGxlZCB0byBjbGVhbgp0aGVtIHVwLgoKPiArCj4gK3N0YXRp YyBpbnQgdHBfcGh5X29mZihzdHJ1Y3QgcGh5ICpwaHkpCj4gK3sKPiArCXN0cnVjdCB0cF9saW5r ICppbnN0ID0gcGh5X2dldF9kcnZkYXRhKHBoeSk7Cj4gKwlzdHJ1Y3QgdHBfcGh5ICp0cF9waHkg PSBkZXZfZ2V0X2RydmRhdGEocGh5LT5kZXYucGFyZW50KTsKPiArCWludCByZXQ7Cj4gKwo+ICsJ Z3VhcmQobXV0ZXgpKCZ0cF9waHktPmxvY2spOwo+ICsKPiArCXJldCA9IHJlc2V0X2NvbnRyb2xf YXNzZXJ0KGluc3QtPmxua19yc3QpOwo+ICsJaWYgKHJldCkKPiArCQlyZXR1cm4gcmV0Owo+ICsK PiArCWlmICh0cF9waHktPm5iX3BoeV9vbiA9PSAxKSB7Cj4gKwkJcmV0ID0gcmVzZXRfY29udHJv bF9hc3NlcnQodHBfcGh5LT5waHlfcnN0KTsKPiArCQlpZiAocmV0KQo+ICsJCQlyZXR1cm4gcmV0 Owo+ICsJfQo+ICsKPiArCXRwX3BoeS0+bmJfcGh5X29uLS07Cj4gKwlyZXR1cm4gMDsKPiArfQoK W1NldmVyaXR5OiBIaWdoXQpDYW4gdHBfcGh5X29mZigpIHVuZGVyZmxvdyB0cF9waHktPm5iX3Bo eV9vbiB3aGVuIHRwX3BoeS0+YWxyZWFkeV9jb25maWd1cmVkCmlzIHRydWU/CgpXaGVuIHRwX3Bo eS0+YWxyZWFkeV9jb25maWd1cmVkIGlzIHRydWUsIHRwX3BoeV9vbigpIHJldHVybnMgZWFybHkg d2l0aG91dAppbmNyZW1lbnRpbmcgbmJfcGh5X29uIChsZWF2aW5nIGl0IGF0IDApLCBidXQgdHBf cGh5X29mZigpIGhhcyBubwphbHJlYWR5X2NvbmZpZ3VyZWQgY2hlY2s6IGl0IGFzc2VydHMgaW5z dC0+bG5rX3JzdCBhbmQgZGVjcmVtZW50cyB0aGUgdTgKbmJfcGh5X29uIGNvdW50ZXIgZnJvbSAw IHRvIDI1NS4gIEEgc3Vic2VxdWVudCBwaHlfcG93ZXJfb24oKSB0aGVuIGVpdGhlcgpyZXR1cm5z IGVhcmx5IHdpdGggaW5zdC0+bG5rX3JzdCBzdGlsbCBhc3NlcnRlZCwgb3IgYWZ0ZXIgc3lzdGVt IHN1c3BlbmQKY2xlYXJzIGFscmVhZHlfY29uZmlndXJlZCwgc2VlcyBuYl9waHlfb24gIT0gMCwg c2tpcHMgZGVhc3NlcnRpbmcKdHBfcGh5LT5waHlfcnN0LCBhbmQgdGltZXMgb3V0IHdhaXRpbmcg Zm9yIENNTiByZWFkeS4KClsgLi4uIF0KCj4gK3N0YXRpYyBpbnQgdHBfcmVmX2Nsa19pbml0KGNv bnN0IHN0cnVjdCB0cF9waHkgKnRwX3BoeSwgc3RydWN0IGNsayAqY2xrLCBjb25zdCBjaGFyICpu YW1lLAo+ICsJCQkgICB1MzIgKnBfcmVmX2Nsa19raHopCj4gK3sKPiArCXN0cnVjdCBkZXZpY2Ug KmRldiA9IHRwX3BoeS0+ZGV2Owo+ICsJdTMyIHJlZl9jbGtfcmF0ZTsKPiArCWludCByZXQ7Cj4g Kwo+ICsJcmV0ID0gY2xrX3ByZXBhcmVfZW5hYmxlKGNsayk7Cj4gKwlpZiAocmV0KSB7Cj4gKwkJ ZGV2X2VycihkZXYsICJGYWlsZWQgdG8gcHJlcGFyZSAlcyByZWYgY2xvY2s6ICVkXG4iLCBuYW1l LCByZXQpOwo+ICsJCXJldHVybiByZXQ7Cj4gKwl9Cj4gKwo+ICsJcmVmX2Nsa19yYXRlID0gY2xr X2dldF9yYXRlKGNsayk7Cj4gKwlpZiAoIXJlZl9jbGtfcmF0ZSkgewo+ICsJCWRldl9lcnIoZGV2 LCAiRmFpbGVkIHRvIGdldCAlcyByZWYgY2xvY2sgcmF0ZVxuIiwgbmFtZSk7Cj4gKwkJcmV0ID0g LUVJTlZBTDsKPiArCQlnb3RvIGRpc2FibGVfY2xrOwo+ICsJfQo+ICsKPiArCWZvciAodTggaSA9 IDA7IGkgPCB0cF9waHktPm5iX2xpbmtzOyArK2kpIHsKPiArCQlpZiAoIXRwX2lzX3JlZl9mcmVx X3N1cHBvcnRlZCh0cF9waHktPmxpbmtzW2ldLnR5cGUsIHJlZl9jbGtfcmF0ZSkpIHsKPiArCQkJ ZGV2X2VycihkZXYsICJJbnZhbGlkIHJlZiBjbG9jayByYXRlOiAldSBIelxuIiwgcmVmX2Nsa19y YXRlKTsKPiArCQkJcmV0ID0gLUVJTlZBTDsKPiArCQkJZ290byBkaXNhYmxlX2NsazsKPiArCQl9 Cj4gKwl9CgpbU2V2ZXJpdHk6IE1lZGl1bV0KRG9lcyB0aGlzIGxvb3Agc2tpcCByZWZlcmVuY2Ug Y2xvY2sgdmFsaWRhdGlvbiBkdXJpbmcgcHJvYmUgYW5kIHJlamVjdAp2YWxpZCBkdWFsLXJlZmNs ayBjb25maWd1cmF0aW9ucyBkdXJpbmcgcmVzdW1lPwoKSW4gY2Ruc190b3JyZW50X3BoeV9wcm9i ZSgpLCB0cF9yZWZfY2xrc19pbml0KCkgaXMgY2FsbGVkIGJlZm9yZSB0aGUgY2hpbGQKc3Vibm9k ZXMgYXJlIHBhcnNlZCwgc28gdHBfcGh5LT5uYl9saW5rcyBpcyAwIGFuZCB0aGlzIGxvb3AgZG9l cyBub3QgcnVuCmF0IHByb2JlIHRpbWUgKGFsbG93aW5nIHVuc3VwcG9ydGVkIGNsb2NrIHJhdGVz LCBvciByYXRlcyA8IDEwMDAgSHogdGhhdApzZXQgcmVmX2Nsa19raHogdG8gMCBhbmQgZGl2aWRl IGJ5IHplcm8gaW4gdHBfd3JpdGVfcGxsX3JlZ3MoKSkuICBUaGVuIGluCnRwX3Jlc3VtZV9ub2ly cSgpLCB3aGVyZSBuYl9saW5rcyA+IDAsIHRwX3JlZl9jbGtfaW5pdCgpIGNoZWNrcyBldmVyeSBs aW5rCmFnYWluc3QgYm90aCB0cF9waHktPmNsayBhbmQgdHBfcGh5LT5jbGsxIGluc3RlYWQgb2Yg b25seSB0aGUgbGlua3MgdXNpbmcKdGhhdCBQTEwsIGZhaWxpbmcgcmVzdW1lIHdpdGggLUVJTlZB TCB3aGVuIFBMTDAgYW5kIFBMTDEgdXNlIGRpZmZlcmVudApwcm90b2NvbC1zcGVjaWZpYyByZWZl cmVuY2UgZnJlcXVlbmNpZXMuCgpbIC4uLiBdCgo+ICtzdGF0aWMgdm9pZCB0cF9jaGVja19tdWx0 aXBsZV9wY2llX2xpbmtzKHN0cnVjdCB0cF9waHkgKnRwX3BoeSkKPiArewo+ICsJc3RydWN0IHRw X3N0YW5kYXJkICpzdGQwID0gJnRwX3BoeS0+c3RhbmRhcmRzWzBdOwo+ICsJdTMyIG51bV9wY2ll X2xpbmtzID0gMDsKPiArCj4gKwkvKiBGaXJzdCBjaGVjayBpZiB0aGUgZmlyc3Qgc3RhbmRhcmQg aXMgUENJZSAqLwo+ICsJaWYgKHN0ZDAtPnR5cGUgIT0gU1REX1RZUEVfUENJRSkKPiArCQlyZXR1 cm47Cj4gKwo+ICsJLyogQ291bnQgdGhlIG51bWJlciBvZiBsaW5rcyB3aXRoIFBDSWUgcHJvdG9j b2wuICovCj4gKwlmb3IgKHU4IGkgPSAwOyBpIDwgdHBfcGh5LT5uYl9saW5rczsgKytpKSB7Cj4g KwkJaWYgKHRwX3BoeS0+bGlua3NbaV0udHlwZSA9PSBTVERfVFlQRV9QQ0lFKQo+ICsJCQludW1f cGNpZV9saW5rcysrOwo+ICsJfQo+ICsKPiArCS8qIFBDSWUgTXVsdGlsaW5rIGNvbmZpZ3VyYXRp b24gY2FuIGJlIHN1cHBvcnRlZCBhbG9uZyB3aXRoIGEgbm9uLVBDSWUgcHJvdG9jb2wuCj4gKwkg KiBTdWNoIGNvbmZpZ3VyYXRpb25zIGFyZSBoYW5kbGVkIGJ5IGFkZGluZyBhIGZsYWcgbmFtZWQg U1REX0ZMQUdfUENJRV9NTAo+ICsJICovCj4gKwlpZiAobnVtX3BjaWVfbGlua3MgPiAxKQo+ICsJ CXN0ZDAtPmZsYWdzIHw9IFNURF9GTEFHX1BDSUVfTUw7Cj4gK30KCltTZXZlcml0eTogTWVkaXVt XQpEb2VzIHRwX2NoZWNrX211bHRpcGxlX3BjaWVfbGlua3MoKSBtaXNzIG11bHRpLWxpbmsgUENJ ZSB3aGVuIGEgbm9uLVBDSWUKc3Vibm9kZSBhcHBlYXJzIGZpcnN0IGluIERldmljZSBUcmVlPwoK dHBfYWRkX3BoeV9mcm9tX29mX3N1Ym5vZGUoKSBwb3B1bGF0ZXMgdHBfcGh5LT5zdGFuZGFyZHNb XSBpbiBEVCBzdWJub2RlCm9yZGVyLCBzbyBpZiBwaHlAMCBpcyBVU0Igb3IgU0dNSUkgYW5kIHBo eUAxIGFuZCBwaHlAMiBhcmUgUENJZSwgUENJZSBpcyBpbgpzdGFuZGFyZHNbMV0gd2hlbiB0cF9j aGVja19tdWx0aXBsZV9wY2llX2xpbmtzKCkgcnVucy4gIEJlY2F1c2UKdHBfY2hlY2tfbXVsdGlw bGVfcGNpZV9saW5rcygpIG9ubHkgY2hlY2tzIHN0YW5kYXJkc1swXSwgaXQgcmV0dXJucyB3aXRo b3V0CnNldHRpbmcgU1REX0ZMQUdfUENJRV9NTCwgYW5kIHdoZW4gdHBfZmluZF9saW5rX2NmZygp IHN1YnNlcXVlbnRseSBzd2FwcwpzdGFuZGFyZHNbMF0gYW5kIHN0YW5kYXJkc1sxXSwgdGhlIGRy aXZlciBtYXRjaGVzIHNpbmdsZS1saW5rIFBDSWUKKFNURDBfUENJRV9TTCkgaW5zdGVhZCBvZiBt dWx0aS1saW5rIFBDSWUgKFNURDBfUENJRV9NTCkuCgpbIC4uLiBdCgo+ICtzdGF0aWMgaW50IHRw X2ZpbmRfbGlua19jZmcoc3RydWN0IHRwX3BoeSAqdHBfcGh5KQo+ICt7Cj4gKwljb25zdCBzdHJ1 Y3QgdHBfbGlua19jZmcgKmxpbmtfY2ZnOwo+ICsJc3RydWN0IGRldmljZSAqZGV2ID0gdHBfcGh5 LT5kZXY7Cj4gKwlzdHJ1Y3QgdHBfc3RhbmRhcmQgKnN0ZDAgPSAmdHBfcGh5LT5zdGFuZGFyZHNb MF07Cj4gKwlzdHJ1Y3QgdHBfc3RhbmRhcmQgKnN0ZDEgPSAmdHBfcGh5LT5zdGFuZGFyZHNbMV07 Cj4gKwo+ICsJLyogVmVyaWZ5IHRoZSB2YWxpZGl0eSBvZiBzdGFuZGFyZCBpbmRleCBpbiBsaW5r cyAqLwo+ICsJZm9yICh1OCBpID0gMDsgaSA8IHRwX3BoeS0+bmJfbGlua3M7ICsraSkgewo+ICsJ CWNvbnN0IHN0cnVjdCB0cF9saW5rICpsaW5rID0gJnRwX3BoeS0+bGlua3NbaV07Cj4gKwo+ICsJ CWlmIChXQVJOX09OKGxpbmstPnN0ZF9pZHggPj0gTUFYX05VTV9TVEFOREFSRFMpKQo+ICsJCQly ZXR1cm4gLUVJTlZBTDsKPiArCX0KPiArCj4gKwlsaW5rX2NmZyA9IHRwX2ZpbmRfbGlua19jZmdf ZnJvbV9zdGFuZGFyZHMoc3RkMCwgc3RkMSk7Cj4gKwo+ICsJLyogT25seSBzd2FwIHRoZSB0d28g c3RhbmRhcmRzIGlmIFBMTDEgaGFzIG5vIGRlZGljYXRlZCByZWZlcmVuY2UgY2xvY2sgKi8KPiAr CWlmICghbGlua19jZmcgJiYgIXRwX3BoeS0+Y2xrMSkgewo+ICsJCWxpbmtfY2ZnID0gdHBfZmlu ZF9saW5rX2NmZ19mcm9tX3N0YW5kYXJkcyhzdGQxLCBzdGQwKTsKPiArCQlpZiAobGlua19jZmcp IHsKPiArCQkJLyogU3dhcCB0aGUgMiBzdGFuZGFyZHMgKi8KPiArCQkJc3dhcCh0cF9waHktPnN0 YW5kYXJkc1swXSwgdHBfcGh5LT5zdGFuZGFyZHNbMV0pOwo+ICsKPiArCQkJZm9yICh1OCBpID0g MDsgaSA8IHRwX3BoeS0+bmJfbGlua3M7ICsraSkKPiArCQkJCXRwX3BoeS0+bGlua3NbaV0uc3Rk X2lkeCBePSAxOwo+ICsJCX0KPiArCX0KCltTZXZlcml0eTogTWVkaXVtXQpXaHkgaXMgc3dhcHBp bmcgc3RhbmRhcmRzWzBdIGFuZCBzdGFuZGFyZHNbMV0gZGlzYWxsb3dlZCB3aGVuIHRwX3BoeS0+ Y2xrMQppcyBwcmVzZW50PwoKc3RhbmRhcmRzWzBdIGFuZCBzdGFuZGFyZHNbMV0gYXJlIHBvcHVs YXRlZCBpbiBEVCBjaGlsZCBzdWJub2RlIG9yZGVyIChsYW5lCm9yZGVyKSwgd2hlcmVhcyB0cF9s aW5rX2NmZ3NbXSBvcmRlcnMgZW50cmllcyBieSBQTEwgYXNzaWdubWVudCAoc3RkMCBvbgpQTEww IGNsb2NrZWQgYnkgcmVmY2xrLCBzdGQxIG9uIFBMTDEgY2xvY2tlZCBieSBwbGwxX3JlZmNsayku ICBXaGVuCnBsbDFfcmVmY2xrIGlzIHByb3ZpZGVkIGFuZCB0aGUgcHJvdG9jb2wgb24gbG93ZXIg bGFuZXMgKHBoeUAwKSB1c2VzIFBMTDEKKGZvciBleGFtcGxlLCBVU1hHTUlJIG9uIHBoeUAwIHdp dGggUExMMSBhdCAxNTYuMjUgTUh6IGFuZCBQQ0llIG9uIHBoeUAyCndpdGggUExMMCBhdCAxMDAg TUh6KSwgcmVmdXNpbmcgdG8gc3dhcCBzdGFuZGFyZHNbMF0gYW5kIHN0YW5kYXJkc1sxXQpjYXVz ZXMgdHBfZmluZF9saW5rX2NmZygpIHRvIGZhaWwgcHJvYmUgd2l0aCAtRUlOVkFMLgoKWyAuLi4g XQoKPiArc3RhdGljIHZvaWQgdHBfcGh5X2NsZWFudXAoY29uc3Qgc3RydWN0IHRwX3BoeSAqdHBf cGh5KQo+ICt7Cj4gKwlyZXNldF9jb250cm9sX2Fzc2VydCh0cF9waHktPnBoeV9yc3QpOwo+ICsJ cmVzZXRfY29udHJvbF9hc3NlcnQodHBfcGh5LT5hcGJfcnN0KTsKPiArCj4gKwlmb3IgKHU4IGkg PSAwOyBpIDwgdHBfcGh5LT5uYl9saW5rczsgKytpKSB7Cj4gKwkJcmVzZXRfY29udHJvbF9hc3Nl cnQodHBfcGh5LT5saW5rc1tpXS5sbmtfcnN0KTsKPiArCQlyZXNldF9jb250cm9sX3B1dCh0cF9w aHktPmxpbmtzW2ldLmxua19yc3QpOwo+ICsJfQo+ICsKPiArCWNsa19kaXNhYmxlX3VucHJlcGFy ZSh0cF9waHktPmNsazEpOwo+ICsJY2xrX2Rpc2FibGVfdW5wcmVwYXJlKHRwX3BoeS0+Y2xrKTsK PiArCXRwX2Nsa19jbGVhbnVwKHRwX3BoeSk7Cj4gK30KCltTZXZlcml0eTogTWVkaXVtXQpDYW4g dHBfcGh5X2NsZWFudXAoKSBjYWxsIGNsa19kaXNhYmxlX3VucHJlcGFyZSgpIG9uIGNsb2NrcyB0 aGF0IHdlcmUgbmV2ZXIKZW5hYmxlZCBvciB3ZXJlIGFscmVhZHkgZGlzYWJsZWQ/CgpJbiBjZG5z X3RvcnJlbnRfcGh5X3Byb2JlKCksIGp1bXBpbmcgdG8gY2xlYW51cCB3aGVuIHRwX29mX2dldF9j bGsoKSBmYWlscwpvbiBwbGwxX3JlZmNsayBhZnRlciBhY3F1aXJpbmcgdHBfcGh5LT5jbGssIHdo ZW4gdHBfcmVmX2Nsa3NfaW5pdCgpIGZhaWxzCihhZnRlciBhbHJlYWR5IGRpc2FibGluZyBhbnkg Y2xvY2sgaXQgZW5hYmxlZCksIG9yIHdoZW4gdHBfcGh5LT5hbHJlYWR5X2NvbmZpZ3VyZWQKaXMg dHJ1ZSAod2hlcmUgdHBfcmVmX2Nsa3NfaW5pdCgpIGlzIHNraXBwZWQsIHdoaWNoIGFsc28gYWZm ZWN0cwpjZG5zX3RvcnJlbnRfcGh5X3JlbW92ZSgpKSB1bmNvbmRpdGlvbmFsbHkgY2FsbHMgY2xr X2Rpc2FibGVfdW5wcmVwYXJlKCkgb24KdHBfcGh5LT5jbGsxIGFuZCB0cF9waHktPmNsaywgdHJp Z2dlcmluZyBjbG9jayBlbmFibGUvcHJlcGFyZSBjb3VudAp1bmRlcmZsb3cgd2FybmluZ3MuCgpb IC4uLiBdCgo+ICtzdGF0aWMgaW50IHRwX3N1c3BlbmRfbm9pcnEoc3RydWN0IGRldmljZSAqZGV2 KQo+ICt7Cj4gKwlzdHJ1Y3QgdHBfcGh5ICp0cF9waHkgPSBkZXZfZ2V0X2RydmRhdGEoZGV2KTsK PiArCj4gKwl0cF9yZWZjbGtfZHJpdmVyX3N1c3BlbmQodHBfcGh5KTsKPiArCj4gKwlmb3IgKHU4 IGkgPSAwOyBpIDwgdHBfcGh5LT5uYl9saW5rczsgKytpKQo+ICsJCXJlc2V0X2NvbnRyb2xfYXNz ZXJ0KHRwX3BoeS0+bGlua3NbaV0ubG5rX3JzdCk7Cj4gKwo+ICsJcmVzZXRfY29udHJvbF9hc3Nl cnQodHBfcGh5LT5waHlfcnN0KTsKPiArCXJlc2V0X2NvbnRyb2xfYXNzZXJ0KHRwX3BoeS0+YXBi X3JzdCk7Cj4gKwo+ICsJaWYgKHRwX3BoeS0+YWxyZWFkeV9jb25maWd1cmVkKSB7Cj4gKwkJdHBf cGh5LT5hbHJlYWR5X2NvbmZpZ3VyZWQgPSBmYWxzZTsKPiArCX0gZWxzZSB7Cj4gKwkJY2xrX2Rp c2FibGVfdW5wcmVwYXJlKHRwX3BoeS0+Y2xrMSk7Cj4gKwkJY2xrX2Rpc2FibGVfdW5wcmVwYXJl KHRwX3BoeS0+Y2xrKTsKPiArCX0KPiArCj4gKwlyZXR1cm4gMDsKPiArfQo+ICsKPiArc3RhdGlj IGludCB0cF9yZXN1bWVfbm9pcnEoc3RydWN0IGRldmljZSAqZGV2KQo+ICt7Cj4gKwlpbnQgcmV0 Owo+ICsJc3RydWN0IHRwX3BoeSAqdHBfcGh5ID0gZGV2X2dldF9kcnZkYXRhKGRldik7Cj4gKwo+ ICsJcmV0ID0gdHBfcmVmY2xrX2RyaXZlcl9yZXN1bWUodHBfcGh5KTsKPiArCWlmIChyZXQpCj4g KwkJcmV0dXJuIHJldDsKPiArCj4gKwlyZXQgPSB0cF9yZWZfY2xrc19pbml0KHRwX3BoeSk7Cj4g KwlpZiAocmV0KQo+ICsJCXJldHVybiByZXQ7Cj4gKwo+ICsJLyogRW5hYmxlIEFQQiAqLwo+ICsJ cmVzZXRfY29udHJvbF9kZWFzc2VydCh0cF9waHktPmFwYl9yc3QpOwo+ICsKPiArCXJldCA9IHRw X2NvbmZpZ3VyZV9saW5rcyh0cF9waHkpOwo+ICsJaWYgKHJldCkKPiArCQlnb3RvIHB1dF9sbmtf cnN0Owo+ICsKPiArCXJldHVybiAwOwoKW1NldmVyaXR5OiBIaWdoXQpEb2VzIHRwX3Jlc3VtZV9u b2lycSgpIGxlYXZlIGFjdGl2ZSBsaW5rcyBoZWxkIGluIHJlc2V0IGFmdGVyIHN1c3BlbmQ/Cgp0 cF9zdXNwZW5kX25vaXJxKCkgYXNzZXJ0cyBsbmtfcnN0IGZvciBldmVyeSBsaW5rIGFuZCBhc3Nl cnRzIHBoeV9yc3QKd2l0aG91dCBjaGFuZ2luZyB0cF9waHktPm5iX3BoeV9vbiwgYnV0IHRwX3Jl c3VtZV9ub2lycSgpIG9ubHkgZGVhc3NlcnRzCmFwYl9yc3QgYW5kIGNhbGxzIHRwX2NvbmZpZ3Vy ZV9saW5rcygpIHdpdGhvdXQgZGVhc3NlcnRpbmcgcGh5X3JzdCBvcgpsbmtfcnN0LiAgQ29uc3Vt ZXJzIHRoYXQga2VlcCB0aGVpciBQSFkgcG93ZXJlZCBvbiBhY3Jvc3Mgc3VzcGVuZCAoc3VjaCBh cwphbTY1LWNwc3ctbnVzcyBmb3IgU0dNSUkvUVNHTUlJL1VTWEdNSUkpIGFyZSBsZWZ0IGhlbGQg aW4gcmVzZXQgYWZ0ZXIKcmVzdW1lLCBhbmQgc2libGluZyBjb25zdW1lcnMgb24gdGhlIHNhbWUg U0VSREVTIHRoYXQgY2FsbApwaHlfcG93ZXJfb2ZmKCkvcGh5X3Bvd2VyX29uKCkgYWNyb3NzIHN1 c3BlbmQvcmVzdW1lIChzdWNoIGFzIHBjaS1qNzIxZSkKc2VlIHRwX3BoeS0+bmJfcGh5X29uICE9 IDAgaW4gdHBfcGh5X29uKCksIHNraXAgZGVhc3NlcnRpbmcgcGh5X3JzdCwgYW5kCnRpbWUgb3V0 IHdhaXRpbmcgZm9yIENNTiByZWFkeS4KCj4gKwo+ICtwdXRfbG5rX3JzdDoKPiArCj4gKwlmb3Ig KHU4IGkgPSAwOyBpIDwgdHBfcGh5LT5uYl9saW5rczsgKytpKQo+ICsJCXJlc2V0X2NvbnRyb2xf YXNzZXJ0KHRwX3BoeS0+bGlua3NbaV0ubG5rX3JzdCk7Cj4gKwo+ICsJcmVzZXRfY29udHJvbF9h c3NlcnQodHBfcGh5LT5hcGJfcnN0KTsKPiArCXJlc2V0X2NvbnRyb2xfYXNzZXJ0KHRwX3BoeS0+ cGh5X3JzdCk7Cj4gKwo+ICsJY2xrX2Rpc2FibGVfdW5wcmVwYXJlKHRwX3BoeS0+Y2xrMSk7Cj4g KwljbGtfZGlzYWJsZV91bnByZXBhcmUodHBfcGh5LT5jbGspOwo+ICsKPiArCXJldHVybiByZXQ7 Cj4gK30KPiArCj4gK3N0YXRpYyBERUZJTkVfTk9JUlFfREVWX1BNX09QUyh0cF9wbV9vcHMsIHRw X3N1c3BlbmRfbm9pcnEsIHRwX3Jlc3VtZV9ub2lycSk7Cj4gKwo+ICtzdGF0aWMgaW50IGNkbnNf dG9ycmVudF9waHlfcHJvYmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKPiArewoKWyAu Li4gXQoKPiArCXRwX3JlZ19iYXNlc19pbml0KHRwX3BoeSk7Cj4gKwl0cF9yZWdfZmllbGRzX2lu aXQodHBfcGh5KTsKPiArCj4gKwlyZXQgPSB0cF9yZWFkX3RlY2hub19yZXZpc2lvbih0cF9waHkp Owo+ICsJaWYgKHJldCkKPiArCQlyZXR1cm4gcmV0Owo+ICsKPiArCXJldCA9IHRwX2Nsa19yZWdp c3Rlcih0cF9waHkpOwo+ICsJaWYgKHJldCkKPiArCQlyZXR1cm4gcmV0Owo+ICsKPiArCXJldCA9 IHRwX29mX2dldF9yZXNldCh0cF9waHkpOwo+ICsJaWYgKHJldCkKPiArCQlnb3RvIGNsZWFudXA7 Cj4gKwo+ICsJcmV0ID0gdHBfb2ZfZ2V0X2Nsayh0cF9waHkpOwo+ICsJaWYgKHJldCkKPiArCQln b3RvIGNsZWFudXA7Cj4gKwo+ICsJdHBfcGh5LT5hbHJlYWR5X2NvbmZpZ3VyZWQgPSB0cF9pc19h bHJlYWR5X2NvbmZpZ3VyZWQodHBfcGh5KTsKPiArCWlmICghdHBfcGh5LT5hbHJlYWR5X2NvbmZp Z3VyZWQpIHsKPiArCQlyZXQgPSB0cF9yZWZfY2xrc19pbml0KHRwX3BoeSk7Cj4gKwkJaWYgKHJl dCkKPiArCQkJZ290byBjbGVhbnVwOwo+ICsKPiArCQkvKiBFbmFibGUgQVBCICovCj4gKwkJcmVz ZXRfY29udHJvbF9kZWFzc2VydCh0cF9waHktPmFwYl9yc3QpOwo+ICsJfQoKW1NldmVyaXR5OiBI aWdoXQpBcmUgQ0RCIHJlZ2lzdGVycyBhY2Nlc3NlZCBoZXJlIGFuZCBpbiB0cF9yZXN1bWVfbm9p cnEoKSB3aGlsZQp0cF9waHktPmFwYl9yc3QgaXMgc3RpbGwgYXNzZXJ0ZWQ/CgpjZG5zX3RvcnJl bnRfcGh5X3Byb2JlKCkgcmVhZHMgdGhlIFBIWSBJRCByZWdpc3RlcnMgaW4KdHBfcmVhZF90ZWNo bm9fcmV2aXNpb24oKSwgd3JpdGVzIENNTl9DRElBR19SRUZDTEtfRFJWMF9DVFJMIGluCnRwX2Ns a19yZWdpc3RlcigpLCBhbmQgcmVhZHMgUEhZX1BNQV9DTU5fQ1RSTDEgaW4KdHBfaXNfYWxyZWFk eV9jb25maWd1cmVkKCkgYmVmb3JlIHRwX29mX2dldF9yZXNldCgpIGFuZApyZXNldF9jb250cm9s X2RlYXNzZXJ0KHRwX3BoeS0+YXBiX3JzdCkgcnVuLiAgU2ltaWxhcmx5LCB0cF9yZXN1bWVfbm9p cnEoKQpjYWxscyB0cF9yZWZjbGtfZHJpdmVyX3Jlc3VtZSgpIChyZWFkaW5nIGFuZCB3cml0aW5n CkNNTl9DRElBR19SRUZDTEtfRFJWMF9DVFJMKSBiZWZvcmUgZGVhc3NlcnRpbmcgdHBfcGh5LT5h cGJfcnN0LCB3aGljaCB3YXMKYXNzZXJ0ZWQgaW4gdHBfc3VzcGVuZF9ub2lycSgpLiAgT24gcGxh dGZvcm1zIHVzaW5nIHRoZSB0b3JyZW50X2FwYiByZXNldAoob3Igd2hlbiByZS1wcm9iaW5nIGFm dGVyIGRyaXZlciByZW1vdmFsLCB3aGljaCBhc3NlcnRzIGFwYl9yc3QpLCBhY2Nlc3NpbmcKQ0RC IHJlZ2lzdGVycyB3aGlsZSBBUEIgaXMgaW4gcmVzZXQgY2FuIGZhaWwgcHJvYmUgd2l0aCAtRU5P REVWLCBsb3NlCnJlZ2lzdGVyIHdyaXRlcywgb3IgZmF1bHQuCgotLSAKU2FzaGlrbyBBSSByZXZp ZXcgwrcgaHR0cHM6Ly9zYXNoaWtvLmRldi8jL3BhdGNoc2V0LzIwMjYxMTIwLXBoeS1jYWRlbmNl LXRvcnJlbnQtbmctdjEtMC1kYTJkYjcxMjVjZDdAYm9vdGxpbi5jb20/cGFydD00CgotLSAKbGlu dXgtcGh5IG1haWxpbmcgbGlzdApsaW51eC1waHlAbGlzdHMuaW5mcmFkZWFkLm9yZwpodHRwczov L2xpc3RzLmluZnJhZGVhZC5vcmcvbWFpbG1hbi9saXN0aW5mby9saW51eC1waHkK