From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-alma10-1.taild15c8.ts.net [100.103.45.18]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 73543239E7E for ; Sat, 25 Jul 2026 05:02:55 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=100.103.45.18 ARC-Seal:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1784955776; cv=none; b=IdoA+k+7JeV5dxu9DGhqECC+OKfLTDi3FOJjIlkpcpGGhw6/+/4nnL0H3wyChn/a4npvDvBRruFC7yj0oOHKIyoFLwCBuI2+VDmHY3i0VeldbebqZhuUVA8fOGic5sK0yAnQad2yyjjcMC9VaqGaaP7WdFjQlaNCXkJX8pGuaio= ARC-Message-Signature:i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1784955776; c=relaxed/simple; bh=xqAjdrgYUenINinenKdJVekEJowAKS0UNkxZrlWLIYU=; h=From:Subject:To:Cc:In-Reply-To:References:Content-Type:Date: Message-Id; b=KDV4Sz6qZknHpBTF3D5rYSAjA9Z+beg5uoz241qIUi31YqeReW4S6FFOWDgOLdqUpu/m0c0C+Dxe2j7VuXIeJKWI3su30zvAC2elT9yYRbdH3XeTcLNCdG4r678429f6OyXJUJ6vwiWib48Hmkhp2H9l01ru0BeLioIOgnWt7uQ= ARC-Authentication-Results:i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=LF0mP8Xg; arc=none smtp.client-ip=100.103.45.18 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="LF0mP8Xg" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 9F7091F000E9; Sat, 25 Jul 2026 05:02:54 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1784955775; bh=j1l9WKvO3rqihB+U+ZgLEcKN9WSynhxIvhL+TFeCEdI=; h=From:Subject:Reply-To:To:Cc:In-Reply-To:References:Date; b=LF0mP8XgbF6W80UoI8X3N3ws4Sx2ZtpY8lDg5kjT9ZfxFyxShSVl0EC1Ory6GoYjQ Y8S/E59plDih7/SvQ2u7A0URV3AfCvK8oQGECTPxaHopEKKpXzyXaZ1VunlMfPkeDj t1bT/EvIE4kJwNFbYubzMe3CdYNDlTdDnyEIQ2qGiATUZQXYXzlzb9tt41sTkZkHbn rIPhn9fSghVYvXZNQ+zbj+6EB7MTs015F7sLSM5UqYrSwufJApy6hYZd49SjT/LDcn EVa2w9rUhSWSlVgBNK0eBQRDA4HwjL7ifn8Fzi+PThpv/1xEDxteksJMqoSnKq65+2 RzHpjtcl7UA/g== From: sashiko-bot@kernel.org Subject: Re: [PATCH RESEND 05/17] phy: spacemit: add Innosilicon DP TX PHY driver Reply-To: sashiko-reviews@lists.linux.dev To: "Cody Kang" Cc: dri-devel@lists.freedesktop.org, vkoul@kernel.org, linux-phy@lists.infradead.org, neil.armstrong@linaro.org, robh@kernel.org, devicetree@vger.kernel.org, olteanv@gmail.com, conor+dt@kernel.org In-Reply-To: <20260725-k3-display-v1-5-6de34d80e86c@gmail.com> References: <20260725-k3-display-v1-0-6de34d80e86c@gmail.com> <20260725-k3-display-v1-5-6de34d80e86c@gmail.com> Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: quoted-printable Date: Sat, 25 Jul 2026 05:02:54 +0000 Message-Id: <20260725050254.9F7091F000E9@smtp.kernel.org> Precedence: bulk X-Mailing-List: devicetree@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: Thank you for your contribution! Sashiko AI review found 6 potential issue(= s) to consider: - [High] PHY provider is registered before probe finishes, exposing it to e= arly concurrent access and potential Use-After-Free (UAF) on probe failure. - [High] Lack of driver-level synchronization between CCF and PHY framework= s leads to concurrent hardware state corruption. - [Medium] The MPLL (main link PLL) is powered on during PHY initialization= but is never powered off in the power down sequence. - [Medium] Missing hardware state cleanup on error paths in `k3_inno_dp_phy= _power_on` leaves the PHY powered on. - [Medium] Rate configuration functions unconditionally power on the PLLs, = overriding the logical PHY power state. - [Medium] PLL programming functions do not poll for hardware lock before p= roceeding. -- --- Patch [5]: [PATCH RESEND 05/17] phy: spacemit: add Innosilicon DP TX PH= Y driver --- commit 31db74eae7dc59ddc61373dbe3e2c6c1e6966ccd Author: Cody Kang Subject: phy: spacemit: add Innosilicon DP TX PHY driver This commit introduces the SpacemiT K3 Innosilicon DisplayPort PHY driver. It integrates the PHY as a child of the DP controller, registering a PHY provider and exposing the pixel PLL as a clock provider. > diff --git a/drivers/phy/spacemit/phy-k3-inno-dp.c b/drivers/phy/spacemit= /phy-k3-inno-dp.c > new file mode 100644 > index 0000000000000..9dd62edb7a5af > --- /dev/null > +++ b/drivers/phy/spacemit/phy-k3-inno-dp.c > @@ -0,0 +1,948 @@ [ ... ] > +static int k3_inno_dp_phy_power_on(struct phy *phy) > +{ > + struct k3_inno_dp_phy *p =3D phy_get_drvdata(phy); > + u32 lane_en; > + u32 val; > + int ret; [ ... ] > + ret =3D regmap_read_poll_timeout(p->regmap, DPTX_ANA_MPLL, val, > + val & DPTX_ANA_MPLL_LOCKED, > + 2000, 10 * 1000); > + if (ret) { > + dev_err(p->dev, "DP PHY core PLL lock timed out\n"); > + return ret; > + } [Severity: Medium] If the MPLL or PREPLL fails to lock within 10ms, this immediately returns an error without restoring the power down bits or XMIT_EN. Since the generic PHY framework does not automatically call phy_power_off() when phy_power_on() fails, could this leave the hardware running in an inconsistent state and leak power? > + > + ret =3D regmap_read_poll_timeout(p->regmap, DPTX_ANA_PREPLL, val, > + val & DPTX_ANA_PREPLL_LOCKED, > + 2000, 10 * 1000); > + if (ret) > + dev_err(p->dev, "DP PHY pixel PLL lock timed out\n"); > + > + return ret; > +} > + > +static int k3_inno_dp_phy_power_off(struct phy *phy) > +{ > + struct k3_inno_dp_phy *p =3D phy_get_drvdata(phy); > + > + regmap_write_bits(p->regmap, DPTX_PHY_CTRL, DPTX_PHY_CTRL_XMIT_EN, 0); > + usleep_range(2000, 4000); > + > + regmap_write_bits(p->regmap, DPTX_ANA_PREPLL, DPTX_ANA_PREPLL_PD, > + DPTX_ANA_PREPLL_PD); > + usleep_range(2000, 4000); > + > + return 0; > +} [Severity: Medium] Does this power down sequence omit the MPLL? The k3_inno_dp_phy_power_on() function powers up the MPLL by clearing DPTX_ANA_MPLL_PD, but this power_off function does not appear to re-assert it. Could this leave the main link PLL running indefinitely when the DP controller is suspended or torn down? [ ... ] > +static void k3_inno_dp_phy_program_mpll(struct k3_inno_dp_phy *p, > + const struct k3_inno_dp_mpll_cfg *cfg) > +{ > + struct regmap *rm =3D p->regmap; [ ... ] > + regmap_write_bits(rm, DPTX_ANA_PREPLL_CTRL, DPTX_ANA_PREPLL_LOCK_BYPEN, > + FIELD_PREP(DPTX_ANA_PREPLL_LOCK_BYPEN, 1)); > + > + regmap_write_bits(rm, DPTX_ANA_MPLL, DPTX_ANA_MPLL_PD, > + FIELD_PREP(DPTX_ANA_MPLL_PD, 0)); [Severity: Medium] Does unconditionally writing 0 to DPTX_ANA_MPLL_PD override the logical power state of the PHY? If a DRM driver configures the link rate (calling phy_configure()) while the PHY is logically powered off, this will force the PLL to run and desynchronize the hardware from the PHY framework's power state. > + usleep_range(2000, 4000); > +} [Severity: Medium] Is it safe to rely on a fixed 2-4ms sleep here instead of polling DPTX_ANA_MPLL_LOCKED? The power_on() function polls the locked bit for up to 10ms. A fixed delay here might proceed with an unstable clock if the hardware takes longer to lock, potentially causing display failures or link training issues. [ ... ] > +static void k3_inno_dp_program_prepll(struct k3_inno_dp_phy *p, > + const struct k3_inno_dp_prepll_cfg *cfg) > +{ > + regmap_write_bits(p->regmap, DPTX_ANA_PREPLL, DPTX_ANA_PREPLL_PD, > + FIELD_PREP(DPTX_ANA_PREPLL_PD, 1)); > + usleep_range(2000, 4000); [Severity: High] Is a driver-level lock needed to synchronize access to the PHY registers between the CCF and PHY frameworks? Since this driver exposes both a clock (via CCF) and a PHY that share the same hardware registers, concurrent calls to clk_set_rate() and phy_power_on() can interleave. If clk_set_rate() begins this multi-step programming sequence, a concurrent phy_power_on() could clear the PD bit while the clock is still being configured, corrupting the hardware state. [ ... ] > + regmap_write_bits(p->regmap, DPTX_ANA_PREPLL, > + DPTX_ANA_PREPLL_PCLK_NORMAL, > + FIELD_PREP(DPTX_ANA_PREPLL_PCLK_NORMAL, 1)); > + usleep_range(2000, 4000); > + > + regmap_write_bits(p->regmap, DPTX_ANA_PREPLL, DPTX_ANA_PREPLL_PD, > + FIELD_PREP(DPTX_ANA_PREPLL_PD, 0)); [Severity: Medium] Similar to the MPLL configuration, does unconditionally clearing DPTX_ANA_PREPLL_PD here override the PHY power state if the clock rate is set while the PHY is logically off? > + usleep_range(2000, 4000); > +} [Severity: Medium] Is it safe to rely on a fixed delay here instead of polling the DPTX_ANA_PREPLL_LOCKED bit, which could lead to proceeding with an unstable pixel clock? [ ... ] > +static int k3_inno_dp_phy_probe(struct platform_device *pdev) > +{ > + struct device *dev =3D &pdev->dev; > + struct k3_inno_dp_phy *p; > + struct phy_provider *provider; > + struct clk_init_data init =3D {}; > + int ret; [ ... ] > + provider =3D devm_of_phy_provider_register(dev, of_phy_simple_xlate); > + if (IS_ERR(provider)) > + return dev_err_probe(dev, PTR_ERR(provider), > + "failed to register PHY provider\n"); > + > + /* PHY takes a 24 MHz reference clock */ > + p->ref_clk_khz =3D 24000; > + > + /* The APMU pixel-clock mux references this clock by name. */ > + of_property_read_string(dev->of_node, "clock-output-names", &init.name); > + if (!init.name) > + init.name =3D dev_name(dev); > + init.ops =3D &k3_inno_dp_pxclk_ops; > + init.parent_names =3D NULL; > + init.num_parents =3D 0; > + init.flags =3D 0; > + p->pxclk_hw.init =3D &init; > + > + ret =3D devm_clk_hw_register(dev, &p->pxclk_hw); > + if (ret) > + return dev_err_probe(dev, ret, > + "failed to register pixel clock\n"); [Severity: High] Can the PHY provider be accessed by consumers before probe completes successfully? The PHY provider is registered via devm_of_phy_provider_register() before the pixel clock is registered. If devm_clk_hw_register() fails, probe will return an error and devres will free the driver context struct. If a consumer driver acquires a reference to the PHY during this race window, it could retain the reference after probe fails, leading to a use-after-free when it attempts PHY operations on the freed pointer. --=20 Sashiko AI review =C2=B7 https://sashiko.dev/#/patchset/20260725-k3-display= -v1-0-6de34d80e86c@gmail.com?part=3D5 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 Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id CA63BC531D0 for ; Sat, 25 Jul 2026 05:02:57 +0000 (UTC) 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:Message-Id:Date: References:In-Reply-To:Cc:To:Subject:From:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=4hbP5N2drQvUnOIi+rcKkodpaEZ89hQ+Agf8jrpHFVU=; b=onBPTzxAbnPjvd wTpG4jFqB4eLxOsk1Qp9djbDDQLDsGWf5zKDQ/c5JZWklFMSKP0X/6f71/s4ju+pUs1MGcBZuFEv+ +Z3MoN0X/KSOL/ooJIGCqMkfMo/w4+xG0oj5zbmBgz3nSPXJuuphX8pUZHSSfY9YY29fvOVAHgEJ6 A9A/nhxx85bIhJC3cePJihRXcSUQOaGgIMeeRBDQ0dD1AnGhKYush567iGNrlpUEld1MBdbeSCl2k ZEPaM+hL3jdhEfOoU5ZRDAekFEdWMPgVH6/cQUI6ELurUC1V+q/vHIprH/4buxQdrD/Pgaq/9EoTf 3Jx3JWUw6zHPRStJhMgg==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.99.1 #2 (Red Hat Linux)) id 1wnUXJ-000000002mG-1aTb; Sat, 25 Jul 2026 05:02:57 +0000 Received: from sea.source.kernel.org ([172.234.252.31]) by bombadil.infradead.org with esmtps (Exim 4.99.1 #2 (Red Hat Linux)) id 1wnUXH-000000002lz-2gjR for linux-phy@lists.infradead.org; Sat, 25 Jul 2026 05:02:55 +0000 Received: from smtp.kernel.org (quasi.space.kernel.org [100.103.45.18]) by sea.source.kernel.org (Postfix) with ESMTP id 36E6744E52; Sat, 25 Jul 2026 05:02:55 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 9F7091F000E9; Sat, 25 Jul 2026 05:02:54 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1784955775; bh=j1l9WKvO3rqihB+U+ZgLEcKN9WSynhxIvhL+TFeCEdI=; h=From:Subject:Reply-To:To:Cc:In-Reply-To:References:Date; b=LF0mP8XgbF6W80UoI8X3N3ws4Sx2ZtpY8lDg5kjT9ZfxFyxShSVl0EC1Ory6GoYjQ Y8S/E59plDih7/SvQ2u7A0URV3AfCvK8oQGECTPxaHopEKKpXzyXaZ1VunlMfPkeDj t1bT/EvIE4kJwNFbYubzMe3CdYNDlTdDnyEIQ2qGiATUZQXYXzlzb9tt41sTkZkHbn rIPhn9fSghVYvXZNQ+zbj+6EB7MTs015F7sLSM5UqYrSwufJApy6hYZd49SjT/LDcn EVa2w9rUhSWSlVgBNK0eBQRDA4HwjL7ifn8Fzi+PThpv/1xEDxteksJMqoSnKq65+2 RzHpjtcl7UA/g== From: sashiko-bot@kernel.org Subject: Re: [PATCH RESEND 05/17] phy: spacemit: add Innosilicon DP TX PHY driver To: "Cody Kang" Cc: dri-devel@lists.freedesktop.org, vkoul@kernel.org, linux-phy@lists.infradead.org, neil.armstrong@linaro.org, robh@kernel.org, devicetree@vger.kernel.org, olteanv@gmail.com, conor+dt@kernel.org In-Reply-To: <20260725-k3-display-v1-5-6de34d80e86c@gmail.com> References: <20260725-k3-display-v1-0-6de34d80e86c@gmail.com> <20260725-k3-display-v1-5-6de34d80e86c@gmail.com> Date: Sat, 25 Jul 2026 05:02:54 +0000 Message-Id: <20260725050254.9F7091F000E9@smtp.kernel.org> X-BeenThere: linux-phy@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: Linux Phy Mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Reply-To: sashiko-reviews@lists.linux.dev MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-phy" Errors-To: linux-phy-bounces+linux-phy=archiver.kernel.org@lists.infradead.org VGhhbmsgeW91IGZvciB5b3VyIGNvbnRyaWJ1dGlvbiEgU2FzaGlrbyBBSSByZXZpZXcgZm91bmQg NiBwb3RlbnRpYWwgaXNzdWUocykgdG8gY29uc2lkZXI6Ci0gW0hpZ2hdIFBIWSBwcm92aWRlciBp cyByZWdpc3RlcmVkIGJlZm9yZSBwcm9iZSBmaW5pc2hlcywgZXhwb3NpbmcgaXQgdG8gZWFybHkg Y29uY3VycmVudCBhY2Nlc3MgYW5kIHBvdGVudGlhbCBVc2UtQWZ0ZXItRnJlZSAoVUFGKSBvbiBw cm9iZSBmYWlsdXJlLgotIFtIaWdoXSBMYWNrIG9mIGRyaXZlci1sZXZlbCBzeW5jaHJvbml6YXRp b24gYmV0d2VlbiBDQ0YgYW5kIFBIWSBmcmFtZXdvcmtzIGxlYWRzIHRvIGNvbmN1cnJlbnQgaGFy ZHdhcmUgc3RhdGUgY29ycnVwdGlvbi4KLSBbTWVkaXVtXSBUaGUgTVBMTCAobWFpbiBsaW5rIFBM TCkgaXMgcG93ZXJlZCBvbiBkdXJpbmcgUEhZIGluaXRpYWxpemF0aW9uIGJ1dCBpcyBuZXZlciBw b3dlcmVkIG9mZiBpbiB0aGUgcG93ZXIgZG93biBzZXF1ZW5jZS4KLSBbTWVkaXVtXSBNaXNzaW5n IGhhcmR3YXJlIHN0YXRlIGNsZWFudXAgb24gZXJyb3IgcGF0aHMgaW4gYGszX2lubm9fZHBfcGh5 X3Bvd2VyX29uYCBsZWF2ZXMgdGhlIFBIWSBwb3dlcmVkIG9uLgotIFtNZWRpdW1dIFJhdGUgY29u ZmlndXJhdGlvbiBmdW5jdGlvbnMgdW5jb25kaXRpb25hbGx5IHBvd2VyIG9uIHRoZSBQTExzLCBv dmVycmlkaW5nIHRoZSBsb2dpY2FsIFBIWSBwb3dlciBzdGF0ZS4KLSBbTWVkaXVtXSBQTEwgcHJv Z3JhbW1pbmcgZnVuY3Rpb25zIGRvIG5vdCBwb2xsIGZvciBoYXJkd2FyZSBsb2NrIGJlZm9yZSBw cm9jZWVkaW5nLgotLQoKLS0tIFBhdGNoIFs1XTogW1BBVENIIFJFU0VORCAwNS8xN10gcGh5OiBz cGFjZW1pdDogYWRkIElubm9zaWxpY29uIERQIFRYIFBIWSBkcml2ZXIgLS0tCmNvbW1pdCAzMWRi NzRlYWU3ZGM1OWRkYzYxMzczZGJlM2UyYzZjMWU2OTY2Y2NkCkF1dGhvcjogQ29keSBLYW5nIDxj b2R5a2FuZy5oa0BnbWFpbC5jb20+ClN1YmplY3Q6IHBoeTogc3BhY2VtaXQ6IGFkZCBJbm5vc2ls aWNvbiBEUCBUWCBQSFkgZHJpdmVyCgpUaGlzIGNvbW1pdCBpbnRyb2R1Y2VzIHRoZSBTcGFjZW1p VCBLMyBJbm5vc2lsaWNvbiBEaXNwbGF5UG9ydCBQSFkgZHJpdmVyLgpJdCBpbnRlZ3JhdGVzIHRo ZSBQSFkgYXMgYSBjaGlsZCBvZiB0aGUgRFAgY29udHJvbGxlciwgcmVnaXN0ZXJpbmcgYSBQSFkK cHJvdmlkZXIgYW5kIGV4cG9zaW5nIHRoZSBwaXhlbCBQTEwgYXMgYSBjbG9jayBwcm92aWRlci4K Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvcGh5L3NwYWNlbWl0L3BoeS1rMy1pbm5vLWRwLmMgYi9k cml2ZXJzL3BoeS9zcGFjZW1pdC9waHktazMtaW5uby1kcC5jCj4gbmV3IGZpbGUgbW9kZSAxMDA2 NDQKPiBpbmRleCAwMDAwMDAwMDAwMDAwLi45ZGQ2MmVkYjdhNWFmCj4gLS0tIC9kZXYvbnVsbAo+ ICsrKyBiL2RyaXZlcnMvcGh5L3NwYWNlbWl0L3BoeS1rMy1pbm5vLWRwLmMKPiBAQCAtMCwwICsx LDk0OCBAQAoKWyAuLi4gXQoKPiArc3RhdGljIGludCBrM19pbm5vX2RwX3BoeV9wb3dlcl9vbihz dHJ1Y3QgcGh5ICpwaHkpCj4gK3sKPiArCXN0cnVjdCBrM19pbm5vX2RwX3BoeSAqcCA9IHBoeV9n ZXRfZHJ2ZGF0YShwaHkpOwo+ICsJdTMyIGxhbmVfZW47Cj4gKwl1MzIgdmFsOwo+ICsJaW50IHJl dDsKClsgLi4uIF0KCj4gKwlyZXQgPSByZWdtYXBfcmVhZF9wb2xsX3RpbWVvdXQocC0+cmVnbWFw LCBEUFRYX0FOQV9NUExMLCB2YWwsCj4gKwkJCQkgICAgICAgdmFsICYgRFBUWF9BTkFfTVBMTF9M T0NLRUQsCj4gKwkJCQkgICAgICAgMjAwMCwgMTAgKiAxMDAwKTsKPiArCWlmIChyZXQpIHsKPiAr CQlkZXZfZXJyKHAtPmRldiwgIkRQIFBIWSBjb3JlIFBMTCBsb2NrIHRpbWVkIG91dFxuIik7Cj4g KwkJcmV0dXJuIHJldDsKPiArCX0KCltTZXZlcml0eTogTWVkaXVtXQpJZiB0aGUgTVBMTCBvciBQ UkVQTEwgZmFpbHMgdG8gbG9jayB3aXRoaW4gMTBtcywgdGhpcyBpbW1lZGlhdGVseSByZXR1cm5z IGFuCmVycm9yIHdpdGhvdXQgcmVzdG9yaW5nIHRoZSBwb3dlciBkb3duIGJpdHMgb3IgWE1JVF9F Ti4KClNpbmNlIHRoZSBnZW5lcmljIFBIWSBmcmFtZXdvcmsgZG9lcyBub3QgYXV0b21hdGljYWxs eSBjYWxsIHBoeV9wb3dlcl9vZmYoKQp3aGVuIHBoeV9wb3dlcl9vbigpIGZhaWxzLCBjb3VsZCB0 aGlzIGxlYXZlIHRoZSBoYXJkd2FyZSBydW5uaW5nIGluIGFuCmluY29uc2lzdGVudCBzdGF0ZSBh bmQgbGVhayBwb3dlcj8KCj4gKwo+ICsJcmV0ID0gcmVnbWFwX3JlYWRfcG9sbF90aW1lb3V0KHAt PnJlZ21hcCwgRFBUWF9BTkFfUFJFUExMLCB2YWwsCj4gKwkJCQkgICAgICAgdmFsICYgRFBUWF9B TkFfUFJFUExMX0xPQ0tFRCwKPiArCQkJCSAgICAgICAyMDAwLCAxMCAqIDEwMDApOwo+ICsJaWYg KHJldCkKPiArCQlkZXZfZXJyKHAtPmRldiwgIkRQIFBIWSBwaXhlbCBQTEwgbG9jayB0aW1lZCBv dXRcbiIpOwo+ICsKPiArCXJldHVybiByZXQ7Cj4gK30KPiArCj4gK3N0YXRpYyBpbnQgazNfaW5u b19kcF9waHlfcG93ZXJfb2ZmKHN0cnVjdCBwaHkgKnBoeSkKPiArewo+ICsJc3RydWN0IGszX2lu bm9fZHBfcGh5ICpwID0gcGh5X2dldF9kcnZkYXRhKHBoeSk7Cj4gKwo+ICsJcmVnbWFwX3dyaXRl X2JpdHMocC0+cmVnbWFwLCBEUFRYX1BIWV9DVFJMLCBEUFRYX1BIWV9DVFJMX1hNSVRfRU4sIDAp Owo+ICsJdXNsZWVwX3JhbmdlKDIwMDAsIDQwMDApOwo+ICsKPiArCXJlZ21hcF93cml0ZV9iaXRz KHAtPnJlZ21hcCwgRFBUWF9BTkFfUFJFUExMLCBEUFRYX0FOQV9QUkVQTExfUEQsCj4gKwkJCSAg RFBUWF9BTkFfUFJFUExMX1BEKTsKPiArCXVzbGVlcF9yYW5nZSgyMDAwLCA0MDAwKTsKPiArCj4g KwlyZXR1cm4gMDsKPiArfQoKW1NldmVyaXR5OiBNZWRpdW1dCkRvZXMgdGhpcyBwb3dlciBkb3du IHNlcXVlbmNlIG9taXQgdGhlIE1QTEw/CgpUaGUgazNfaW5ub19kcF9waHlfcG93ZXJfb24oKSBm dW5jdGlvbiBwb3dlcnMgdXAgdGhlIE1QTEwgYnkgY2xlYXJpbmcKRFBUWF9BTkFfTVBMTF9QRCwg YnV0IHRoaXMgcG93ZXJfb2ZmIGZ1bmN0aW9uIGRvZXMgbm90IGFwcGVhciB0byByZS1hc3NlcnQK aXQuIENvdWxkIHRoaXMgbGVhdmUgdGhlIG1haW4gbGluayBQTEwgcnVubmluZyBpbmRlZmluaXRl bHkgd2hlbiB0aGUgRFAKY29udHJvbGxlciBpcyBzdXNwZW5kZWQgb3IgdG9ybiBkb3duPwoKWyAu Li4gXQoKPiArc3RhdGljIHZvaWQgazNfaW5ub19kcF9waHlfcHJvZ3JhbV9tcGxsKHN0cnVjdCBr M19pbm5vX2RwX3BoeSAqcCwKPiArCQkJCQljb25zdCBzdHJ1Y3QgazNfaW5ub19kcF9tcGxsX2Nm ZyAqY2ZnKQo+ICt7Cj4gKwlzdHJ1Y3QgcmVnbWFwICpybSA9IHAtPnJlZ21hcDsKClsgLi4uIF0K Cj4gKwlyZWdtYXBfd3JpdGVfYml0cyhybSwgRFBUWF9BTkFfUFJFUExMX0NUUkwsIERQVFhfQU5B X1BSRVBMTF9MT0NLX0JZUEVOLAo+ICsJCUZJRUxEX1BSRVAoRFBUWF9BTkFfUFJFUExMX0xPQ0tf QllQRU4sIDEpKTsKPiArCj4gKwlyZWdtYXBfd3JpdGVfYml0cyhybSwgRFBUWF9BTkFfTVBMTCwg RFBUWF9BTkFfTVBMTF9QRCwKPiArCQlGSUVMRF9QUkVQKERQVFhfQU5BX01QTExfUEQsIDApKTsK CltTZXZlcml0eTogTWVkaXVtXQpEb2VzIHVuY29uZGl0aW9uYWxseSB3cml0aW5nIDAgdG8gRFBU WF9BTkFfTVBMTF9QRCBvdmVycmlkZSB0aGUgbG9naWNhbApwb3dlciBzdGF0ZSBvZiB0aGUgUEhZ PwoKSWYgYSBEUk0gZHJpdmVyIGNvbmZpZ3VyZXMgdGhlIGxpbmsgcmF0ZSAoY2FsbGluZyBwaHlf Y29uZmlndXJlKCkpIHdoaWxlIHRoZQpQSFkgaXMgbG9naWNhbGx5IHBvd2VyZWQgb2ZmLCB0aGlz IHdpbGwgZm9yY2UgdGhlIFBMTCB0byBydW4gYW5kCmRlc3luY2hyb25pemUgdGhlIGhhcmR3YXJl IGZyb20gdGhlIFBIWSBmcmFtZXdvcmsncyBwb3dlciBzdGF0ZS4KCj4gKwl1c2xlZXBfcmFuZ2Uo MjAwMCwgNDAwMCk7Cj4gK30KCltTZXZlcml0eTogTWVkaXVtXQpJcyBpdCBzYWZlIHRvIHJlbHkg b24gYSBmaXhlZCAyLTRtcyBzbGVlcCBoZXJlIGluc3RlYWQgb2YgcG9sbGluZwpEUFRYX0FOQV9N UExMX0xPQ0tFRD8KClRoZSBwb3dlcl9vbigpIGZ1bmN0aW9uIHBvbGxzIHRoZSBsb2NrZWQgYml0 IGZvciB1cCB0byAxMG1zLiBBIGZpeGVkIGRlbGF5CmhlcmUgbWlnaHQgcHJvY2VlZCB3aXRoIGFu IHVuc3RhYmxlIGNsb2NrIGlmIHRoZSBoYXJkd2FyZSB0YWtlcyBsb25nZXIgdG8KbG9jaywgcG90 ZW50aWFsbHkgY2F1c2luZyBkaXNwbGF5IGZhaWx1cmVzIG9yIGxpbmsgdHJhaW5pbmcgaXNzdWVz LgoKWyAuLi4gXQoKPiArc3RhdGljIHZvaWQgazNfaW5ub19kcF9wcm9ncmFtX3ByZXBsbChzdHJ1 Y3QgazNfaW5ub19kcF9waHkgKnAsCj4gKwkJCQkgICAgICBjb25zdCBzdHJ1Y3QgazNfaW5ub19k cF9wcmVwbGxfY2ZnICpjZmcpCj4gK3sKPiArCXJlZ21hcF93cml0ZV9iaXRzKHAtPnJlZ21hcCwg RFBUWF9BTkFfUFJFUExMLCBEUFRYX0FOQV9QUkVQTExfUEQsCj4gKwkJRklFTERfUFJFUChEUFRY X0FOQV9QUkVQTExfUEQsIDEpKTsKPiArCXVzbGVlcF9yYW5nZSgyMDAwLCA0MDAwKTsKCltTZXZl cml0eTogSGlnaF0KSXMgYSBkcml2ZXItbGV2ZWwgbG9jayBuZWVkZWQgdG8gc3luY2hyb25pemUg YWNjZXNzIHRvIHRoZSBQSFkgcmVnaXN0ZXJzCmJldHdlZW4gdGhlIENDRiBhbmQgUEhZIGZyYW1l d29ya3M/CgpTaW5jZSB0aGlzIGRyaXZlciBleHBvc2VzIGJvdGggYSBjbG9jayAodmlhIENDRikg YW5kIGEgUEhZIHRoYXQgc2hhcmUgdGhlCnNhbWUgaGFyZHdhcmUgcmVnaXN0ZXJzLCBjb25jdXJy ZW50IGNhbGxzIHRvIGNsa19zZXRfcmF0ZSgpIGFuZApwaHlfcG93ZXJfb24oKSBjYW4gaW50ZXJs ZWF2ZS4KCklmIGNsa19zZXRfcmF0ZSgpIGJlZ2lucyB0aGlzIG11bHRpLXN0ZXAgcHJvZ3JhbW1p bmcgc2VxdWVuY2UsIGEgY29uY3VycmVudApwaHlfcG93ZXJfb24oKSBjb3VsZCBjbGVhciB0aGUg UEQgYml0IHdoaWxlIHRoZSBjbG9jayBpcyBzdGlsbCBiZWluZwpjb25maWd1cmVkLCBjb3JydXB0 aW5nIHRoZSBoYXJkd2FyZSBzdGF0ZS4KClsgLi4uIF0KCj4gKwlyZWdtYXBfd3JpdGVfYml0cyhw LT5yZWdtYXAsIERQVFhfQU5BX1BSRVBMTCwKPiArCQlEUFRYX0FOQV9QUkVQTExfUENMS19OT1JN QUwsCj4gKwkJRklFTERfUFJFUChEUFRYX0FOQV9QUkVQTExfUENMS19OT1JNQUwsIDEpKTsKPiAr CXVzbGVlcF9yYW5nZSgyMDAwLCA0MDAwKTsKPiArCj4gKwlyZWdtYXBfd3JpdGVfYml0cyhwLT5y ZWdtYXAsIERQVFhfQU5BX1BSRVBMTCwgRFBUWF9BTkFfUFJFUExMX1BELAo+ICsJCUZJRUxEX1BS RVAoRFBUWF9BTkFfUFJFUExMX1BELCAwKSk7CgpbU2V2ZXJpdHk6IE1lZGl1bV0KU2ltaWxhciB0 byB0aGUgTVBMTCBjb25maWd1cmF0aW9uLCBkb2VzIHVuY29uZGl0aW9uYWxseSBjbGVhcmluZwpE UFRYX0FOQV9QUkVQTExfUEQgaGVyZSBvdmVycmlkZSB0aGUgUEhZIHBvd2VyIHN0YXRlIGlmIHRo ZSBjbG9jayByYXRlIGlzCnNldCB3aGlsZSB0aGUgUEhZIGlzIGxvZ2ljYWxseSBvZmY/Cgo+ICsJ dXNsZWVwX3JhbmdlKDIwMDAsIDQwMDApOwo+ICt9CgpbU2V2ZXJpdHk6IE1lZGl1bV0KSXMgaXQg c2FmZSB0byByZWx5IG9uIGEgZml4ZWQgZGVsYXkgaGVyZSBpbnN0ZWFkIG9mIHBvbGxpbmcgdGhl CkRQVFhfQU5BX1BSRVBMTF9MT0NLRUQgYml0LCB3aGljaCBjb3VsZCBsZWFkIHRvIHByb2NlZWRp bmcgd2l0aCBhbiB1bnN0YWJsZQpwaXhlbCBjbG9jaz8KClsgLi4uIF0KCj4gK3N0YXRpYyBpbnQg azNfaW5ub19kcF9waHlfcHJvYmUoc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldikKPiArewo+ ICsJc3RydWN0IGRldmljZSAqZGV2ID0gJnBkZXYtPmRldjsKPiArCXN0cnVjdCBrM19pbm5vX2Rw X3BoeSAqcDsKPiArCXN0cnVjdCBwaHlfcHJvdmlkZXIgKnByb3ZpZGVyOwo+ICsJc3RydWN0IGNs a19pbml0X2RhdGEgaW5pdCA9IHt9Owo+ICsJaW50IHJldDsKClsgLi4uIF0KCj4gKwlwcm92aWRl ciA9IGRldm1fb2ZfcGh5X3Byb3ZpZGVyX3JlZ2lzdGVyKGRldiwgb2ZfcGh5X3NpbXBsZV94bGF0 ZSk7Cj4gKwlpZiAoSVNfRVJSKHByb3ZpZGVyKSkKPiArCQlyZXR1cm4gZGV2X2Vycl9wcm9iZShk ZXYsIFBUUl9FUlIocHJvdmlkZXIpLAo+ICsJCQkJICAgICAiZmFpbGVkIHRvIHJlZ2lzdGVyIFBI WSBwcm92aWRlclxuIik7Cj4gKwo+ICsJLyogUEhZIHRha2VzIGEgMjQgTUh6IHJlZmVyZW5jZSBj bG9jayAqLwo+ICsJcC0+cmVmX2Nsa19raHogPSAyNDAwMDsKPiArCj4gKwkvKiBUaGUgQVBNVSBw aXhlbC1jbG9jayBtdXggcmVmZXJlbmNlcyB0aGlzIGNsb2NrIGJ5IG5hbWUuICovCj4gKwlvZl9w cm9wZXJ0eV9yZWFkX3N0cmluZyhkZXYtPm9mX25vZGUsICJjbG9jay1vdXRwdXQtbmFtZXMiLCAm aW5pdC5uYW1lKTsKPiArCWlmICghaW5pdC5uYW1lKQo+ICsJCWluaXQubmFtZSA9IGRldl9uYW1l KGRldik7Cj4gKwlpbml0Lm9wcyA9ICZrM19pbm5vX2RwX3B4Y2xrX29wczsKPiArCWluaXQucGFy ZW50X25hbWVzID0gTlVMTDsKPiArCWluaXQubnVtX3BhcmVudHMgPSAwOwo+ICsJaW5pdC5mbGFn cyA9IDA7Cj4gKwlwLT5weGNsa19ody5pbml0ID0gJmluaXQ7Cj4gKwo+ICsJcmV0ID0gZGV2bV9j bGtfaHdfcmVnaXN0ZXIoZGV2LCAmcC0+cHhjbGtfaHcpOwo+ICsJaWYgKHJldCkKPiArCQlyZXR1 cm4gZGV2X2Vycl9wcm9iZShkZXYsIHJldCwKPiArCQkJCSAgICAgImZhaWxlZCB0byByZWdpc3Rl ciBwaXhlbCBjbG9ja1xuIik7CgpbU2V2ZXJpdHk6IEhpZ2hdCkNhbiB0aGUgUEhZIHByb3ZpZGVy IGJlIGFjY2Vzc2VkIGJ5IGNvbnN1bWVycyBiZWZvcmUgcHJvYmUgY29tcGxldGVzCnN1Y2Nlc3Nm dWxseT8KClRoZSBQSFkgcHJvdmlkZXIgaXMgcmVnaXN0ZXJlZCB2aWEgZGV2bV9vZl9waHlfcHJv dmlkZXJfcmVnaXN0ZXIoKSBiZWZvcmUKdGhlIHBpeGVsIGNsb2NrIGlzIHJlZ2lzdGVyZWQuIElm IGRldm1fY2xrX2h3X3JlZ2lzdGVyKCkgZmFpbHMsIHByb2JlIHdpbGwKcmV0dXJuIGFuIGVycm9y IGFuZCBkZXZyZXMgd2lsbCBmcmVlIHRoZSBkcml2ZXIgY29udGV4dCBzdHJ1Y3QuCgpJZiBhIGNv bnN1bWVyIGRyaXZlciBhY3F1aXJlcyBhIHJlZmVyZW5jZSB0byB0aGUgUEhZIGR1cmluZyB0aGlz IHJhY2UKd2luZG93LCBpdCBjb3VsZCByZXRhaW4gdGhlIHJlZmVyZW5jZSBhZnRlciBwcm9iZSBm YWlscywgbGVhZGluZyB0byBhCnVzZS1hZnRlci1mcmVlIHdoZW4gaXQgYXR0ZW1wdHMgUEhZIG9w ZXJhdGlvbnMgb24gdGhlIGZyZWVkIHBvaW50ZXIuCgotLSAKU2FzaGlrbyBBSSByZXZpZXcgwrcg aHR0cHM6Ly9zYXNoaWtvLmRldi8jL3BhdGNoc2V0LzIwMjYwNzI1LWszLWRpc3BsYXktdjEtMC02 ZGUzNGQ4MGU4NmNAZ21haWwuY29tP3BhcnQ9NQoKLS0gCmxpbnV4LXBoeSBtYWlsaW5nIGxpc3QK bGludXgtcGh5QGxpc3RzLmluZnJhZGVhZC5vcmcKaHR0cHM6Ly9saXN0cy5pbmZyYWRlYWQub3Jn L21haWxtYW4vbGlzdGluZm8vbGludXgtcGh5Cg==