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=1793878029; b=VC/Wtyae+ysti5yOa17U47AZMVIK/AwyRXfiiP7baReHUAGXNEjbHytcACOcXA8GyYAI urR78eva4P60VzPScM0LNe8r1OFZeFW9gHOoXPVE4S86WUvb3uqV+cu6JiH/46kKNT5n0 CAR1zltE77V/p0jA7QmSZQPB60HNWV7WHBOF3Re73oyNeCi2RCk+1xbkZXXA/8jkm8qxX DafFUONaCRFkeFqeVP7mCzhlrh/2gcKOgIhPEVkqEFVuB1AMOhas/O+gjiIRkIrqf5wnm 4ZFBLCJxswtwMcmp4tZ3kjwhoGOjacy2a0QEDMtdkamjr49H7BINoPqeUccL5ilKf0Q== ARC-Message-Signature: i=1; d=subspace.kernel.org; s=arc20261015; a=rsa-sha256; c=relaxed/relaxed; t=1793878029; h=Received:DKIM-Signature:Message-ID:From:Subject:Reply-To:To:Cc: In-Reply-To:References:Content-Type:Content-Transfer-Encoding:Date; bh=iAcrTZYGj9Z0xe0WP+0BvkJC+jqTsdSUr73f5NR4cAg=; b=KQUYg6C/SpItdyhDNamYwoA4j1lVNNNoWd5uMtw1O5N6qqxHcZOvZRfZUDBqAEutMYh8 gTbzJ7o4TC/94WVVCTORIEZeowH48eRzRA1+UCKNr9ondJTXwH/8yz6I2K5soMIuugqnB NgKmF4GwJeqxTTxCDMmxmH6170OIivgZlSAK4uzzrq5zfPtOOTYRsEmYpe0lq2gO4yOiS mr3R4RvmjCL1w2BK3Z3iBhm2f38LK0bFkD+5LcucNVWOeQ4IDHLKEvCDWXpPutp6Nz3y5 nEOSTRTimFgTpRSH5FKY7gKCLl2448jO8r9zERpDB8Uvr0a1YZAABHqlfLMDaPpHtGw== 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=To2f6wKp; 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 F2DD1606A326 for ; Thu, 5 Nov 2026 11:27:08 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key, unprotected) header.d=kernel.org header.i=@kernel.org header.a=rsa-sha256 header.s=k20260515 header.b=To2f6wKp Received: by smtp.kernel.org (Postfix) with ESMTPSA id CE99F1F000C1; Thu, 5 Nov 2026 11:27:07 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1793878028; bh=iAcrTZYGj9Z0xe0WP+0BvkJC+jqTsdSUr73f5NR4cAg=; h=From:Subject:Reply-To:To:Cc:In-Reply-To:References:Date; b=To2f6wKpT0BiQQ9H48SBmk7Lw8kQG9ue2XtHLU1N4jVJAJskr4NC9m/btEgGYiVAs VDWsAuDKPdQjXnrfkQtHvkF04ATLT2dAVWCAGvcKjaQcr9ErN88tGDH5pcaUCVGlBU zXetgVyJsm+dRZBhHM9sVnMN9D4LUyhoSvhK7P++1776rq8Na+SGGiNhhHUM0fi045 rBjhIVOfqlzW3VWgeIXm4t5XFt1K0pSPjI5j34bHCpu0FAkoQ173PIpTvrVjxZvP6J 88Hdmr5NVZDgVVrQntajl796UJ4dyWC9IbaMFmcAs3sX6fBYRyZ/2TKyPP1eDnYfGW U3vaLlXYX//pw== Message-ID: From: sashiko-bot@kernel.org Subject: Re: [PATCH v11 11/19] spi: cadence-quadspi: enable PHY for direct reads Reply-To: sashiko-reviews@lists.linux.dev To: "Santhosh Kumar K" , broonie@kernel.org, robh@kernel.org, krzk+dt@kernel.org, conor+dt@kernel.org, miquel.raynal@bootlin.com, richard@nod.at, vigneshr@ti.com, pratyush@kernel.org, mwalle@kernel.org, takahiro.kuwano@infineon.com Cc: devicetree@vger.kernel.org, linux-mtd@lists.infradead.org, praneeth@ti.com, sebin.francis@ti.com, u-kumar1@ti.com, srikanth.boyapally@amd.com, m-shah@ti.com In-Reply-To: <20261105105832.2134313-12-s-k6@ti.com> References: <20261105105832.2134313-1-s-k6@ti.com> <20261105105832.2134313-12-s-k6@ti.com> Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: quoted-printable Date: Thu, 05 Nov 2026 11:27:07 +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 3 potential issue(= s) to consider: - [High] spi: cadence-quadspi: state leak on disable timeout in cqspi_tune_= phy_read() - [High] spi: cadence-quadspi: silent base-clock fallback during PHY tuning= in cqspi_read() - [High] spi: cadence-quadspi: missing READCAPTURE_EDGE bit in cqspi_tune_p= hy_read() -- commit feb139507791ba27ec4dfd5612d622bfad619500 Author: Santhosh Kumar K spi: cadence-quadspi: enable PHY for direct reads This commit enables PHY mode around direct-mode DMA reads when PHY tuning h= as succeeded and the operation requests the post-config clock rate. It also ad= ds fallback logic to drop the clock to the base rate when a read cannot use the tuned PHY. > diff --git a/drivers/spi/spi-cadence-quadspi.c b/drivers/spi/spi-cadence-= quadspi.c > index c324451a9a285..55c446f4245af 100644 > --- a/drivers/spi/spi-cadence-quadspi.c > +++ b/drivers/spi/spi-cadence-quadspi.c [ ... ] > @@ -1075,6 +1076,105 @@ static int cqspi_resync_dll(struct cqspi_st *cqsp= i) [ ... ] > +static int cqspi_tune_phy_read(struct cqspi_flash_pdata *f_pdata, bool e= nable) > +{ > + struct cqspi_st *cqspi =3D f_pdata->cqspi; > + void __iomem *reg_base =3D cqspi->iobase; > + u32 reg; > + u8 dummy; > + int ret; > + > + /* Wait for idle before touching CONFIG/RD_INSTR either direction. */ > + ret =3D cqspi_wait_idle(cqspi); > + if (ret) > + return ret; > + > + if (!enable) { > + cqspi_phy_restore_read_config(f_pdata); > + return 0; > + } [Severity: High] As reported by Sashiko on v10 [1], when cqspi_direct_read_execute() calls cqspi_tune_phy_read(f_pdata, false) after cqspi_direct_read_dma() and cqspi_wait_idle() times out, returning early before the !enable check skips cqspi_phy_restore_read_config(). Doesn't this leave CQSPI_REG_CONFIG_PHY_EN and CQSPI_REG_CONFIG_PHY_PIPELINE asserted in CQSPI_REG_CONFIG, CQSPI_REG_READCAPTURE programmed with the PHY capture settings, and the decremented dummy cycle count in CQSPI_REG_RD_INS= TR for subsequent untuned transfers? > + > + ret =3D cqspi_phy_reprogram_dll(f_pdata); > + if (ret) > + return ret; > + > + cqspi_readdata_capture(cqspi, !f_pdata->use_dqs, f_pdata->use_dqs, > + f_pdata->phy_setting.read_delay); [Severity: High] During PHY calibration, cqspi_phy_apply_setting() sets BIT(CQSPI_REG_READCAPTURE_EDGE_LSB) in CQSPI_REG_READCAPTURE before each pattern read: drivers/spi/spi-cadence-quadspi.c:cqspi_phy_apply_setting() { reg =3D readl(cqspi->iobase + CQSPI_REG_READCAPTURE); reg |=3D BIT(CQSPI_REG_READCAPTURE_EDGE_LSB); writel(reg, cqspi->iobase + CQSPI_REG_READCAPTURE); ... } When calibration finishes, cqspi_phy_post_config() clears that bit to resto= re the non-PHY state: drivers/spi/spi-cadence-quadspi.c:cqspi_phy_post_config() { ... reg =3D readl(reg_base + CQSPI_REG_READCAPTURE); reg &=3D ~BIT(CQSPI_REG_READCAPTURE_EDGE_LSB); writel(reg, reg_base + CQSPI_REG_READCAPTURE); ... } However, cqspi_tune_phy_read() and cqspi_readdata_capture() never set or restore BIT(CQSPI_REG_READCAPTURE_EDGE_LSB). Won't all runtime PHY direct reads execute with CQSPI_REG_READCAPTURE_EDGE_LSB cleared, even though the PHY delay settings were calibrated with that bit set? [ ... ] > @@ -1622,26 +1730,66 @@ static void cqspi_memcpy_fromio(const struct spi_= mem_op *op, void *to, > memcpy_fromio(to, from, count); > } > =20 > +static int cqspi_direct_read_fallback(struct cqspi_flash_pdata *f_pdata, > + const struct spi_mem_op *op, > + unsigned long max_speed_hz, > + u32 post_config_max_speed_hz) > +{ > + struct cqspi_st *cqspi =3D f_pdata->cqspi; > + loff_t from =3D op->addr.val; > + size_t len =3D op->data.nbytes; > + u_char *buf =3D op->data.buf.in; > + unsigned long configured_sclk =3D cqspi->sclk; > + bool reclock =3D op->max_freq =3D=3D post_config_max_speed_hz && > + configured_sclk !=3D max_speed_hz; > + int ret =3D 0; > + > + /* Drop to the safe rate for this untuned transfer; PHY isn't used. */ > + if (reclock) > + cqspi_configure(f_pdata, max_speed_hz); > + > + if (!cqspi->rx_chan || !virt_addr_valid(buf) || > + len < CQSPI_PHY_MIN_DIRECT_READ_LEN) > + cqspi_memcpy_fromio(op, buf, cqspi->ahb_base + from, len); > + else > + ret =3D cqspi_direct_read_dma(f_pdata, buf, from, len); > + > + if (reclock) > + cqspi_configure(f_pdata, configured_sclk); > + > + return ret; > +} > + > static int cqspi_direct_read_execute(struct cqspi_flash_pdata *f_pdata, > const struct spi_mem_op *op, > + unsigned long max_speed_hz, > u32 post_config_max_speed_hz) > { > struct cqspi_st *cqspi =3D f_pdata->cqspi; > loff_t from =3D op->addr.val; > size_t len =3D op->data.nbytes; > u_char *buf =3D op->data.buf.in; > + int ret; > =20 > - if (!cqspi->rx_chan || !virt_addr_valid(buf) || > - len < CQSPI_PHY_MIN_DIRECT_READ_LEN) { > - cqspi_memcpy_fromio(op, buf, cqspi->ahb_base + from, len); > - return 0; > - } > + if (!cqspi_use_tuned_phy(f_pdata, op, post_config_max_speed_hz) || > + !cqspi->rx_chan || !virt_addr_valid(buf) || > + len < CQSPI_PHY_MIN_DIRECT_READ_LEN || > + !IS_ALIGNED(from, 16) || !IS_ALIGNED(from + len, 16)) > + return cqspi_direct_read_fallback(f_pdata, op, max_speed_hz, > + post_config_max_speed_hz); [Severity: High] During PHY calibration via cqspi_am654_ospi_execute_tuning(), pattern verification reads go through cqspi_phy_check_pattern() -> cqspi_exec_mem_o= p() -> cqspi_mem_process() -> cqspi_read() -> cqspi_direct_read_execute(). If DMA is not available (!cqspi->rx_chan), direct mode is disabled (!cqspi->use_direct_mode), or f_pdata->phy_read_op.addr.val is not 16-byte aligned or exceeds cqspi->ahb_size, won't every calibration read silently f= all back to cqspi_direct_read_fallback() (or the indirect read path in cqspi_read()) and drop the clock from post_config_max_speed_hz to max_speed_hz without running cqspi_tune_phy_read()? That would evaluate the entire PHY delay sweep at the slow base clock rate, falsely report tuning success, and promote read_op->max_freq and write_op->max_freq to post_config_max_speed_hz with uncalibrated tap settin= gs. Should cqspi_am654_ospi_execute_tuning() verify that direct DMA reads can be used for the calibration pattern before starting tuning, or should fallback reads be rejected while cqspi->phy_tuning_active is set? [1] https://lore.kernel.org/r/20260929063529.1235417-12-s-k6@ti.com --=20 Sashiko AI review =C2=B7 https://sashiko.dev/#/patchset/20261105105832.2134= 313-1-s-k6@ti.com?part=3D11 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 87593606A31B for ; Thu, 5 Nov 2026 11:27:14 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key, unprotected) header.d=lists.infradead.org header.i=@lists.infradead.org header.a=rsa-sha256 header.s=bombadil.20210309 header.b=xJw6qvEg; dkim=fail reason="signature verification failed" (2048-bit key, unprotected) header.d=kernel.org header.i=@kernel.org header.a=rsa-sha256 header.s=k20260515 header.b=To2f6wKp 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=EeLg+B9Aea1goHoiReWNfOJTzg0uIqsy4QqzrqJ4Q8A=; b=xJw6qvEgsm4KYRWzG+bli0Aa8t Wz8BSpnSSeNiLOEIkIFXeK6DlA1f1iggpBYZWu33p/eEKJDqbuW7iC8ocYJat6kpoev/XR+qByZ6q JS3jBuz4NVHadpjw884H/AXz+6D28cFEE55EW8sWLtsfUYpVzjxjjzXDTsh63AaEcgI4Lttrcetcs PX9qxc0cz6RNgZ+Xvl3TWJofl+AXwr9UjHw1yYW2jhmg7F9twkJKBM3yG8WUlyXu4ouatGBSlH45C cOT7Jj+om8OQcmyyYNLSOO+jUgGxfyBU4BFueT5megrrh0jyV0Ds5+hux/8ZzIyzPqt4OkXJVd4sp y6OwA8rA==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.100.1 #2 (Red Hat Linux)) id 1xOvcf-00000008dxg-3xwF; Thu, 05 Nov 2026 11:27:13 +0000 Received: from sea.source.kernel.org ([172.234.252.31]) by bombadil.infradead.org with esmtps (Exim 4.100.1 #2 (Red Hat Linux)) id 1xOvcb-00000008dxG-04e9 for linux-mtd@lists.infradead.org; Thu, 05 Nov 2026 11:27:12 +0000 Received: from smtp.kernel.org (quasi.space.kernel.org [100.103.45.18]) by sea.source.kernel.org (Postfix) with ESMTP id B026C40F7A; Thu, 5 Nov 2026 11:27:08 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id CE99F1F000C1; Thu, 5 Nov 2026 11:27:07 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kernel.org; s=k20260515; t=1793878028; bh=iAcrTZYGj9Z0xe0WP+0BvkJC+jqTsdSUr73f5NR4cAg=; h=From:Subject:Reply-To:To:Cc:In-Reply-To:References:Date; b=To2f6wKpT0BiQQ9H48SBmk7Lw8kQG9ue2XtHLU1N4jVJAJskr4NC9m/btEgGYiVAs VDWsAuDKPdQjXnrfkQtHvkF04ATLT2dAVWCAGvcKjaQcr9ErN88tGDH5pcaUCVGlBU zXetgVyJsm+dRZBhHM9sVnMN9D4LUyhoSvhK7P++1776rq8Na+SGGiNhhHUM0fi045 rBjhIVOfqlzW3VWgeIXm4t5XFt1K0pSPjI5j34bHCpu0FAkoQ173PIpTvrVjxZvP6J 88Hdmr5NVZDgVVrQntajl796UJ4dyWC9IbaMFmcAs3sX6fBYRyZ/2TKyPP1eDnYfGW U3vaLlXYX//pw== Message-ID: From: sashiko-bot@kernel.org Subject: Re: [PATCH v11 11/19] spi: cadence-quadspi: enable PHY for direct reads To: "Santhosh Kumar K" , broonie@kernel.org, robh@kernel.org, krzk+dt@kernel.org, conor+dt@kernel.org, miquel.raynal@bootlin.com, richard@nod.at, vigneshr@ti.com, pratyush@kernel.org, mwalle@kernel.org, takahiro.kuwano@infineon.com Cc: devicetree@vger.kernel.org, linux-mtd@lists.infradead.org, praneeth@ti.com, sebin.francis@ti.com, u-kumar1@ti.com, srikanth.boyapally@amd.com, m-shah@ti.com In-Reply-To: <20261105105832.2134313-12-s-k6@ti.com> References: <20261105105832.2134313-1-s-k6@ti.com> <20261105105832.2134313-12-s-k6@ti.com> Date: Thu, 05 Nov 2026 11:27:07 +0000 X-BeenThere: linux-mtd@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: Linux MTD discussion 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-mtd" 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 MyBwb3RlbnRpYWwgaXNzdWUocykgdG8gY29uc2lkZXI6Ci0gW0hpZ2hdIHNwaTogY2FkZW5jZS1x dWFkc3BpOiBzdGF0ZSBsZWFrIG9uIGRpc2FibGUgdGltZW91dCBpbiBjcXNwaV90dW5lX3BoeV9y ZWFkKCkKLSBbSGlnaF0gc3BpOiBjYWRlbmNlLXF1YWRzcGk6IHNpbGVudCBiYXNlLWNsb2NrIGZh bGxiYWNrIGR1cmluZyBQSFkgdHVuaW5nIGluIGNxc3BpX3JlYWQoKQotIFtIaWdoXSBzcGk6IGNh ZGVuY2UtcXVhZHNwaTogbWlzc2luZyBSRUFEQ0FQVFVSRV9FREdFIGJpdCBpbiBjcXNwaV90dW5l X3BoeV9yZWFkKCkKLS0KCmNvbW1pdCBmZWIxMzk1MDc3OTFiYTI3ZWM0ZGZkNTYxMmQ2MjJiZmFk NjE5NTAwCkF1dGhvcjogU2FudGhvc2ggS3VtYXIgSyA8cy1rNkB0aS5jb20+CgpzcGk6IGNhZGVu Y2UtcXVhZHNwaTogZW5hYmxlIFBIWSBmb3IgZGlyZWN0IHJlYWRzCgpUaGlzIGNvbW1pdCBlbmFi bGVzIFBIWSBtb2RlIGFyb3VuZCBkaXJlY3QtbW9kZSBETUEgcmVhZHMgd2hlbiBQSFkgdHVuaW5n IGhhcwpzdWNjZWVkZWQgYW5kIHRoZSBvcGVyYXRpb24gcmVxdWVzdHMgdGhlIHBvc3QtY29uZmln IGNsb2NrIHJhdGUuIEl0IGFsc28gYWRkcwpmYWxsYmFjayBsb2dpYyB0byBkcm9wIHRoZSBjbG9j ayB0byB0aGUgYmFzZSByYXRlIHdoZW4gYSByZWFkIGNhbm5vdCB1c2UgdGhlCnR1bmVkIFBIWS4K Cj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvc3BpL3NwaS1jYWRlbmNlLXF1YWRzcGkuYyBiL2RyaXZl cnMvc3BpL3NwaS1jYWRlbmNlLXF1YWRzcGkuYwo+IGluZGV4IGMzMjQ0NTFhOWEyODUuLjU1YzQ0 NmY0MjQ1YWYgMTAwNjQ0Cj4gLS0tIGEvZHJpdmVycy9zcGkvc3BpLWNhZGVuY2UtcXVhZHNwaS5j Cj4gKysrIGIvZHJpdmVycy9zcGkvc3BpLWNhZGVuY2UtcXVhZHNwaS5jCgpbIC4uLiBdCgo+IEBA IC0xMDc1LDYgKzEwNzYsMTA1IEBAIHN0YXRpYyBpbnQgY3FzcGlfcmVzeW5jX2RsbChzdHJ1Y3Qg Y3FzcGlfc3QgKmNxc3BpKQoKWyAuLi4gXQoKPiArc3RhdGljIGludCBjcXNwaV90dW5lX3BoeV9y ZWFkKHN0cnVjdCBjcXNwaV9mbGFzaF9wZGF0YSAqZl9wZGF0YSwgYm9vbCBlbmFibGUpCj4gK3sK PiArCXN0cnVjdCBjcXNwaV9zdCAqY3FzcGkgPSBmX3BkYXRhLT5jcXNwaTsKPiArCXZvaWQgX19p b21lbSAqcmVnX2Jhc2UgPSBjcXNwaS0+aW9iYXNlOwo+ICsJdTMyIHJlZzsKPiArCXU4IGR1bW15 Owo+ICsJaW50IHJldDsKPiArCj4gKwkvKiBXYWl0IGZvciBpZGxlIGJlZm9yZSB0b3VjaGluZyBD T05GSUcvUkRfSU5TVFIgZWl0aGVyIGRpcmVjdGlvbi4gKi8KPiArCXJldCA9IGNxc3BpX3dhaXRf aWRsZShjcXNwaSk7Cj4gKwlpZiAocmV0KQo+ICsJCXJldHVybiByZXQ7Cj4gKwo+ICsJaWYgKCFl bmFibGUpIHsKPiArCQljcXNwaV9waHlfcmVzdG9yZV9yZWFkX2NvbmZpZyhmX3BkYXRhKTsKPiAr CQlyZXR1cm4gMDsKPiArCX0KCltTZXZlcml0eTogSGlnaF0KQXMgcmVwb3J0ZWQgYnkgU2FzaGlr byBvbiB2MTAgWzFdLCB3aGVuIGNxc3BpX2RpcmVjdF9yZWFkX2V4ZWN1dGUoKSBjYWxscwpjcXNw aV90dW5lX3BoeV9yZWFkKGZfcGRhdGEsIGZhbHNlKSBhZnRlciBjcXNwaV9kaXJlY3RfcmVhZF9k bWEoKSBhbmQKY3FzcGlfd2FpdF9pZGxlKCkgdGltZXMgb3V0LCByZXR1cm5pbmcgZWFybHkgYmVm b3JlIHRoZSAhZW5hYmxlIGNoZWNrIHNraXBzCmNxc3BpX3BoeV9yZXN0b3JlX3JlYWRfY29uZmln KCkuCgpEb2Vzbid0IHRoaXMgbGVhdmUgQ1FTUElfUkVHX0NPTkZJR19QSFlfRU4gYW5kIENRU1BJ X1JFR19DT05GSUdfUEhZX1BJUEVMSU5FCmFzc2VydGVkIGluIENRU1BJX1JFR19DT05GSUcsIENR U1BJX1JFR19SRUFEQ0FQVFVSRSBwcm9ncmFtbWVkIHdpdGggdGhlIFBIWQpjYXB0dXJlIHNldHRp bmdzLCBhbmQgdGhlIGRlY3JlbWVudGVkIGR1bW15IGN5Y2xlIGNvdW50IGluIENRU1BJX1JFR19S RF9JTlNUUgpmb3Igc3Vic2VxdWVudCB1bnR1bmVkIHRyYW5zZmVycz8KCj4gKwo+ICsJcmV0ID0g Y3FzcGlfcGh5X3JlcHJvZ3JhbV9kbGwoZl9wZGF0YSk7Cj4gKwlpZiAocmV0KQo+ICsJCXJldHVy biByZXQ7Cj4gKwo+ICsJY3FzcGlfcmVhZGRhdGFfY2FwdHVyZShjcXNwaSwgIWZfcGRhdGEtPnVz ZV9kcXMsIGZfcGRhdGEtPnVzZV9kcXMsCj4gKwkJCSAgICAgICBmX3BkYXRhLT5waHlfc2V0dGlu Zy5yZWFkX2RlbGF5KTsKCltTZXZlcml0eTogSGlnaF0KRHVyaW5nIFBIWSBjYWxpYnJhdGlvbiwg Y3FzcGlfcGh5X2FwcGx5X3NldHRpbmcoKSBzZXRzCkJJVChDUVNQSV9SRUdfUkVBRENBUFRVUkVf RURHRV9MU0IpIGluIENRU1BJX1JFR19SRUFEQ0FQVFVSRSBiZWZvcmUgZWFjaApwYXR0ZXJuIHJl YWQ6Cgpkcml2ZXJzL3NwaS9zcGktY2FkZW5jZS1xdWFkc3BpLmM6Y3FzcGlfcGh5X2FwcGx5X3Nl dHRpbmcoKSB7CglyZWcgPSByZWFkbChjcXNwaS0+aW9iYXNlICsgQ1FTUElfUkVHX1JFQURDQVBU VVJFKTsKCXJlZyB8PSBCSVQoQ1FTUElfUkVHX1JFQURDQVBUVVJFX0VER0VfTFNCKTsKCXdyaXRl bChyZWcsIGNxc3BpLT5pb2Jhc2UgKyBDUVNQSV9SRUdfUkVBRENBUFRVUkUpOwoJLi4uCn0KCldo ZW4gY2FsaWJyYXRpb24gZmluaXNoZXMsIGNxc3BpX3BoeV9wb3N0X2NvbmZpZygpIGNsZWFycyB0 aGF0IGJpdCB0byByZXN0b3JlCnRoZSBub24tUEhZIHN0YXRlOgoKZHJpdmVycy9zcGkvc3BpLWNh ZGVuY2UtcXVhZHNwaS5jOmNxc3BpX3BoeV9wb3N0X2NvbmZpZygpIHsKCS4uLgoJcmVnID0gcmVh ZGwocmVnX2Jhc2UgKyBDUVNQSV9SRUdfUkVBRENBUFRVUkUpOwoJcmVnICY9IH5CSVQoQ1FTUElf UkVHX1JFQURDQVBUVVJFX0VER0VfTFNCKTsKCXdyaXRlbChyZWcsIHJlZ19iYXNlICsgQ1FTUElf UkVHX1JFQURDQVBUVVJFKTsKCS4uLgp9CgpIb3dldmVyLCBjcXNwaV90dW5lX3BoeV9yZWFkKCkg YW5kIGNxc3BpX3JlYWRkYXRhX2NhcHR1cmUoKSBuZXZlciBzZXQgb3IKcmVzdG9yZSBCSVQoQ1FT UElfUkVHX1JFQURDQVBUVVJFX0VER0VfTFNCKS4gV29uJ3QgYWxsIHJ1bnRpbWUgUEhZIGRpcmVj dApyZWFkcyBleGVjdXRlIHdpdGggQ1FTUElfUkVHX1JFQURDQVBUVVJFX0VER0VfTFNCIGNsZWFy ZWQsIGV2ZW4gdGhvdWdoIHRoZQpQSFkgZGVsYXkgc2V0dGluZ3Mgd2VyZSBjYWxpYnJhdGVkIHdp dGggdGhhdCBiaXQgc2V0PwoKWyAuLi4gXQoKPiBAQCAtMTYyMiwyNiArMTczMCw2NiBAQCBzdGF0 aWMgdm9pZCBjcXNwaV9tZW1jcHlfZnJvbWlvKGNvbnN0IHN0cnVjdCBzcGlfbWVtX29wICpvcCwg dm9pZCAqdG8sCj4gIAltZW1jcHlfZnJvbWlvKHRvLCBmcm9tLCBjb3VudCk7Cj4gIH0KPiAgCj4g K3N0YXRpYyBpbnQgY3FzcGlfZGlyZWN0X3JlYWRfZmFsbGJhY2soc3RydWN0IGNxc3BpX2ZsYXNo X3BkYXRhICpmX3BkYXRhLAo+ICsJCQkJICAgICAgY29uc3Qgc3RydWN0IHNwaV9tZW1fb3AgKm9w LAo+ICsJCQkJICAgICAgdW5zaWduZWQgbG9uZyBtYXhfc3BlZWRfaHosCj4gKwkJCQkgICAgICB1 MzIgcG9zdF9jb25maWdfbWF4X3NwZWVkX2h6KQo+ICt7Cj4gKwlzdHJ1Y3QgY3FzcGlfc3QgKmNx c3BpID0gZl9wZGF0YS0+Y3FzcGk7Cj4gKwlsb2ZmX3QgZnJvbSA9IG9wLT5hZGRyLnZhbDsKPiAr CXNpemVfdCBsZW4gPSBvcC0+ZGF0YS5uYnl0ZXM7Cj4gKwl1X2NoYXIgKmJ1ZiA9IG9wLT5kYXRh LmJ1Zi5pbjsKPiArCXVuc2lnbmVkIGxvbmcgY29uZmlndXJlZF9zY2xrID0gY3FzcGktPnNjbGs7 Cj4gKwlib29sIHJlY2xvY2sgPSBvcC0+bWF4X2ZyZXEgPT0gcG9zdF9jb25maWdfbWF4X3NwZWVk X2h6ICYmCj4gKwkJICAgICAgIGNvbmZpZ3VyZWRfc2NsayAhPSBtYXhfc3BlZWRfaHo7Cj4gKwlp bnQgcmV0ID0gMDsKPiArCj4gKwkvKiBEcm9wIHRvIHRoZSBzYWZlIHJhdGUgZm9yIHRoaXMgdW50 dW5lZCB0cmFuc2ZlcjsgUEhZIGlzbid0IHVzZWQuICovCj4gKwlpZiAocmVjbG9jaykKPiArCQlj cXNwaV9jb25maWd1cmUoZl9wZGF0YSwgbWF4X3NwZWVkX2h6KTsKPiArCj4gKwlpZiAoIWNxc3Bp LT5yeF9jaGFuIHx8ICF2aXJ0X2FkZHJfdmFsaWQoYnVmKSB8fAo+ICsJICAgIGxlbiA8IENRU1BJ X1BIWV9NSU5fRElSRUNUX1JFQURfTEVOKQo+ICsJCWNxc3BpX21lbWNweV9mcm9taW8ob3AsIGJ1 ZiwgY3FzcGktPmFoYl9iYXNlICsgZnJvbSwgbGVuKTsKPiArCWVsc2UKPiArCQlyZXQgPSBjcXNw aV9kaXJlY3RfcmVhZF9kbWEoZl9wZGF0YSwgYnVmLCBmcm9tLCBsZW4pOwo+ICsKPiArCWlmIChy ZWNsb2NrKQo+ICsJCWNxc3BpX2NvbmZpZ3VyZShmX3BkYXRhLCBjb25maWd1cmVkX3NjbGspOwo+ ICsKPiArCXJldHVybiByZXQ7Cj4gK30KPiArCj4gIHN0YXRpYyBpbnQgY3FzcGlfZGlyZWN0X3Jl YWRfZXhlY3V0ZShzdHJ1Y3QgY3FzcGlfZmxhc2hfcGRhdGEgKmZfcGRhdGEsCj4gIAkJCQkgICAg IGNvbnN0IHN0cnVjdCBzcGlfbWVtX29wICpvcCwKPiArCQkJCSAgICAgdW5zaWduZWQgbG9uZyBt YXhfc3BlZWRfaHosCj4gIAkJCQkgICAgIHUzMiBwb3N0X2NvbmZpZ19tYXhfc3BlZWRfaHopCj4g IHsKPiAgCXN0cnVjdCBjcXNwaV9zdCAqY3FzcGkgPSBmX3BkYXRhLT5jcXNwaTsKPiAgCWxvZmZf dCBmcm9tID0gb3AtPmFkZHIudmFsOwo+ICAJc2l6ZV90IGxlbiA9IG9wLT5kYXRhLm5ieXRlczsK PiAgCXVfY2hhciAqYnVmID0gb3AtPmRhdGEuYnVmLmluOwo+ICsJaW50IHJldDsKPiAgCj4gLQlp ZiAoIWNxc3BpLT5yeF9jaGFuIHx8ICF2aXJ0X2FkZHJfdmFsaWQoYnVmKSB8fAo+IC0JICAgIGxl biA8IENRU1BJX1BIWV9NSU5fRElSRUNUX1JFQURfTEVOKSB7Cj4gLQkJY3FzcGlfbWVtY3B5X2Zy b21pbyhvcCwgYnVmLCBjcXNwaS0+YWhiX2Jhc2UgKyBmcm9tLCBsZW4pOwo+IC0JCXJldHVybiAw Owo+IC0JfQo+ICsJaWYgKCFjcXNwaV91c2VfdHVuZWRfcGh5KGZfcGRhdGEsIG9wLCBwb3N0X2Nv bmZpZ19tYXhfc3BlZWRfaHopIHx8Cj4gKwkgICAgIWNxc3BpLT5yeF9jaGFuIHx8ICF2aXJ0X2Fk ZHJfdmFsaWQoYnVmKSB8fAo+ICsJICAgIGxlbiA8IENRU1BJX1BIWV9NSU5fRElSRUNUX1JFQURf TEVOIHx8Cj4gKwkgICAgIUlTX0FMSUdORUQoZnJvbSwgMTYpIHx8ICFJU19BTElHTkVEKGZyb20g KyBsZW4sIDE2KSkKPiArCQlyZXR1cm4gY3FzcGlfZGlyZWN0X3JlYWRfZmFsbGJhY2soZl9wZGF0 YSwgb3AsIG1heF9zcGVlZF9oeiwKPiArCQkJCQkJICBwb3N0X2NvbmZpZ19tYXhfc3BlZWRfaHop OwoKW1NldmVyaXR5OiBIaWdoXQpEdXJpbmcgUEhZIGNhbGlicmF0aW9uIHZpYSBjcXNwaV9hbTY1 NF9vc3BpX2V4ZWN1dGVfdHVuaW5nKCksIHBhdHRlcm4KdmVyaWZpY2F0aW9uIHJlYWRzIGdvIHRo cm91Z2ggY3FzcGlfcGh5X2NoZWNrX3BhdHRlcm4oKSAtPiBjcXNwaV9leGVjX21lbV9vcCgpCi0+ IGNxc3BpX21lbV9wcm9jZXNzKCkgLT4gY3FzcGlfcmVhZCgpIC0+IGNxc3BpX2RpcmVjdF9yZWFk X2V4ZWN1dGUoKS4KCklmIERNQSBpcyBub3QgYXZhaWxhYmxlICghY3FzcGktPnJ4X2NoYW4pLCBk aXJlY3QgbW9kZSBpcyBkaXNhYmxlZAooIWNxc3BpLT51c2VfZGlyZWN0X21vZGUpLCBvciBmX3Bk YXRhLT5waHlfcmVhZF9vcC5hZGRyLnZhbCBpcyBub3QgMTYtYnl0ZQphbGlnbmVkIG9yIGV4Y2Vl ZHMgY3FzcGktPmFoYl9zaXplLCB3b24ndCBldmVyeSBjYWxpYnJhdGlvbiByZWFkIHNpbGVudGx5 IGZhbGwKYmFjayB0byBjcXNwaV9kaXJlY3RfcmVhZF9mYWxsYmFjaygpIChvciB0aGUgaW5kaXJl Y3QgcmVhZCBwYXRoIGluCmNxc3BpX3JlYWQoKSkgYW5kIGRyb3AgdGhlIGNsb2NrIGZyb20gcG9z dF9jb25maWdfbWF4X3NwZWVkX2h6IHRvCm1heF9zcGVlZF9oeiB3aXRob3V0IHJ1bm5pbmcgY3Fz cGlfdHVuZV9waHlfcmVhZCgpPwoKVGhhdCB3b3VsZCBldmFsdWF0ZSB0aGUgZW50aXJlIFBIWSBk ZWxheSBzd2VlcCBhdCB0aGUgc2xvdyBiYXNlIGNsb2NrIHJhdGUsCmZhbHNlbHkgcmVwb3J0IHR1 bmluZyBzdWNjZXNzLCBhbmQgcHJvbW90ZSByZWFkX29wLT5tYXhfZnJlcSBhbmQKd3JpdGVfb3At Pm1heF9mcmVxIHRvIHBvc3RfY29uZmlnX21heF9zcGVlZF9oeiB3aXRoIHVuY2FsaWJyYXRlZCB0 YXAgc2V0dGluZ3MuClNob3VsZCBjcXNwaV9hbTY1NF9vc3BpX2V4ZWN1dGVfdHVuaW5nKCkgdmVy aWZ5IHRoYXQgZGlyZWN0IERNQSByZWFkcyBjYW4gYmUKdXNlZCBmb3IgdGhlIGNhbGlicmF0aW9u IHBhdHRlcm4gYmVmb3JlIHN0YXJ0aW5nIHR1bmluZywgb3Igc2hvdWxkIGZhbGxiYWNrCnJlYWRz IGJlIHJlamVjdGVkIHdoaWxlIGNxc3BpLT5waHlfdHVuaW5nX2FjdGl2ZSBpcyBzZXQ/CgpbMV0g aHR0cHM6Ly9sb3JlLmtlcm5lbC5vcmcvci8yMDI2MDkyOTA2MzUyOS4xMjM1NDE3LTEyLXMtazZA dGkuY29tCgotLSAKU2FzaGlrbyBBSSByZXZpZXcgwrcgaHR0cHM6Ly9zYXNoaWtvLmRldi8jL3Bh dGNoc2V0LzIwMjYxMTA1MTA1ODMyLjIxMzQzMTMtMS1zLWs2QHRpLmNvbT9wYXJ0PTExCgpfX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KTGludXgg TVREIGRpc2N1c3Npb24gbWFpbGluZyBsaXN0Cmh0dHA6Ly9saXN0cy5pbmZyYWRlYWQub3JnL21h aWxtYW4vbGlzdGluZm8vbGludXgtbXRkLwo=