From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-24.0 required=3.0 tests=BAYES_00,DKIMWL_WL_HIGH, DKIM_SIGNED,DKIM_VALID,DKIM_VALID_AU,INCLUDES_CR_TRAILER,INCLUDES_PATCH, MAILING_LIST_MULTI,MENTIONS_GIT_HOSTING,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED, USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 839B1C4332B for ; Mon, 22 Feb 2021 19:43:02 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 5B74064E31 for ; Mon, 22 Feb 2021 19:43:02 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S233119AbhBVTnB (ORCPT ); Mon, 22 Feb 2021 14:43:01 -0500 Received: from mail.kernel.org ([198.145.29.99]:54750 "EHLO mail.kernel.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S232983AbhBVTnA (ORCPT ); Mon, 22 Feb 2021 14:43:00 -0500 Received: by mail.kernel.org (Postfix) with ESMTPSA id AA22B64E02; Mon, 22 Feb 2021 19:42:18 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1614022939; bh=ABuBsMdkyLfGL+k7g+MNLq9V3ierJFRdHgGS1x45AwU=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=JgKjJJjHWloLza27ScGiZXzMizkKHkPE7YQD0NKcyQHlNpRwjdUM0J5MllDZhCF64 bZOpbvMNSHotVzw1oTzglbwoLV6U1bYIpSiDFv4+fZSnjCfT2RfYfRcb3ev+GfJMkh +LenIZlQyWUADO/CRCGdvZvh3no/5G1Mw8jAiROyC+FGXkeMj/7AEFRoGh5/gqCJLr WNuf9NX44CWM0tBM3hMqNTPT8B5g3f9RcbgTQgEAjICqoMLLTF1mU0be+r2CBapPSz VKoSxMCle/DRlabWKUm5bxHNh7R7LN4onRmS++WFCj7fbwsEKCCa5CCI197MKVftN/ MHKZWs5c2MqVg== Received: by pali.im (Postfix) id B724AEB8; Mon, 22 Feb 2021 20:42:16 +0100 (CET) From: =?UTF-8?q?Pali=20Roh=C3=A1r?= To: Gregory Clement , Andrew Lunn , Michael Turquette , Stephen Boyd , linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org, linux-clk@vger.kernel.org Cc: =?UTF-8?q?Marek=20Beh=C3=BAn?= , Miquel Raynal , Tomasz Maciej Nowak , Luka Perkov , Andre Heider , Vladimir Vid , Russell King , =?UTF-8?q?G=C3=A9rald=20Kerma?= , Konstantin Porotchkin Subject: [PATCH mvebu v3 02/10] cpufreq: armada-37xx: Fix setting TBG parent for load levels Date: Mon, 22 Feb 2021 20:41:50 +0100 Message-Id: <20210222194158.12342-3-pali@kernel.org> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20210222194158.12342-1-pali@kernel.org> References: <20210114124032.12765-1-pali@kernel.org> <20210222194158.12342-1-pali@kernel.org> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Precedence: bulk List-ID: X-Mailing-List: linux-clk@vger.kernel.org From: Marek Behún With CPU frequency determining software [1] we have discovered that after this driver does one CPU frequency change, the base frequency of the CPU is set to the frequency of TBG-A-P clock, instead of the TBG that is parent to the CPU. This can be reproduced on EspressoBIN and Turris MOX: cd /sys/devices/system/cpu/cpufreq/policy0 echo powersave >scaling_governor echo performance >scaling_governor Running the mhz tool before this driver is loaded reports 1000 MHz, and after loading the driver and executing commands above the tool reports 800 MHz. The change of TBG clock selector is supposed to happen in function armada37xx_cpufreq_dvfs_setup. Before the function returns, it does this: parent = clk_get_parent(clk); clk_set_parent(clk, parent); The armada-37xx-periph clock driver has the .set_parent method implemented correctly for this, so if the method was actually called, this would work. But since the introduction of the common clock framework in commit b2476490ef11 ("clk: introduce the common clock..."), the clk_set_parent function checks whether the parent is actually changing, and if the requested new parent is same as the old parent (which is obviously the case for the code above), the .set_parent method is not called at all. This patch fixes this issue by filling the correct TBG clock selector directly in the armada37xx_cpufreq_dvfs_setup during the filling of other registers at the same address. But the determination of CPU TBG index cannot be done via the common clock framework, therefore we need to access the North Bridge Peripheral Clock registers directly in this driver. [1] https://github.com/wtarreau/mhz Signed-off-by: Marek Behún Tested-by: Pali Rohár Tested-by: Tomasz Maciej Nowak Tested-by: Anders Trier Olesen Tested-by: Philip Soares Fixes: 92ce45fb875d ("cpufreq: Add DVFS support for Armada 37xx") Cc: stable@vger.kernel.org --- drivers/cpufreq/armada-37xx-cpufreq.c | 35 ++++++++++++++++++--------- 1 file changed, 23 insertions(+), 12 deletions(-) diff --git a/drivers/cpufreq/armada-37xx-cpufreq.c b/drivers/cpufreq/armada-37xx-cpufreq.c index b4af4094309b..b8dc6c849579 100644 --- a/drivers/cpufreq/armada-37xx-cpufreq.c +++ b/drivers/cpufreq/armada-37xx-cpufreq.c @@ -25,6 +25,10 @@ #include "cpufreq-dt.h" +/* Clk register set */ +#define ARMADA_37XX_CLK_TBG_SEL 0 +#define ARMADA_37XX_CLK_TBG_SEL_CPU_OFF 22 + /* Power management in North Bridge register set */ #define ARMADA_37XX_NB_L0L1 0x18 #define ARMADA_37XX_NB_L2L3 0x1C @@ -120,10 +124,15 @@ static struct armada_37xx_dvfs *armada_37xx_cpu_freq_info_get(u32 freq) * will be configured then the DVFS will be enabled. */ static void __init armada37xx_cpufreq_dvfs_setup(struct regmap *base, - struct clk *clk, u8 *divider) + struct regmap *clk_base, u8 *divider) { + u32 cpu_tbg_sel; int load_lvl; - struct clk *parent; + + /* Determine to which TBG clock is CPU connected */ + regmap_read(clk_base, ARMADA_37XX_CLK_TBG_SEL, &cpu_tbg_sel); + cpu_tbg_sel >>= ARMADA_37XX_CLK_TBG_SEL_CPU_OFF; + cpu_tbg_sel &= ARMADA_37XX_NB_TBG_SEL_MASK; for (load_lvl = 0; load_lvl < LOAD_LEVEL_NR; load_lvl++) { unsigned int reg, mask, val, offset = 0; @@ -142,6 +151,11 @@ static void __init armada37xx_cpufreq_dvfs_setup(struct regmap *base, mask = (ARMADA_37XX_NB_CLK_SEL_MASK << ARMADA_37XX_NB_CLK_SEL_OFF); + /* Set TBG index, for all levels we use the same TBG */ + val = cpu_tbg_sel << ARMADA_37XX_NB_TBG_SEL_OFF; + mask = (ARMADA_37XX_NB_TBG_SEL_MASK + << ARMADA_37XX_NB_TBG_SEL_OFF); + /* * Set cpu divider based on the pre-computed array in * order to have balanced step. @@ -160,14 +174,6 @@ static void __init armada37xx_cpufreq_dvfs_setup(struct regmap *base, regmap_update_bits(base, reg, mask, val); } - - /* - * Set cpu clock source, for all the level we keep the same - * clock source that the one already configured. For this one - * we need to use the clock framework - */ - parent = clk_get_parent(clk); - clk_set_parent(clk, parent); } /* @@ -358,11 +364,16 @@ static int __init armada37xx_cpufreq_driver_init(void) struct platform_device *pdev; unsigned long freq; unsigned int cur_frequency, base_frequency; - struct regmap *nb_pm_base, *avs_base; + struct regmap *nb_clk_base, *nb_pm_base, *avs_base; struct device *cpu_dev; int load_lvl, ret; struct clk *clk, *parent; + nb_clk_base = + syscon_regmap_lookup_by_compatible("marvell,armada-3700-periph-clock-nb"); + if (IS_ERR(nb_clk_base)) + return -ENODEV; + nb_pm_base = syscon_regmap_lookup_by_compatible("marvell,armada-3700-nb-pm"); @@ -439,7 +450,7 @@ static int __init armada37xx_cpufreq_driver_init(void) armada37xx_cpufreq_avs_configure(avs_base, dvfs); armada37xx_cpufreq_avs_setup(avs_base, dvfs); - armada37xx_cpufreq_dvfs_setup(nb_pm_base, clk, dvfs->divider); + armada37xx_cpufreq_dvfs_setup(nb_pm_base, nb_clk_base, dvfs->divider); clk_put(clk); for (load_lvl = ARMADA_37XX_DVFS_LOAD_0; load_lvl < LOAD_LEVEL_NR; -- 2.20.1 From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-22.0 required=3.0 tests=BAYES_00,DKIMWL_WL_HIGH, DKIM_SIGNED,DKIM_VALID,INCLUDES_CR_TRAILER,INCLUDES_PATCH,MAILING_LIST_MULTI, MENTIONS_GIT_HOSTING,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 047E5C433DB for ; Mon, 22 Feb 2021 19:44:12 +0000 (UTC) Received: from merlin.infradead.org (merlin.infradead.org [205.233.59.134]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id BC47064E15 for ; Mon, 22 Feb 2021 19:44:11 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org BC47064E15 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=kernel.org Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=merlin.20170209; h=Sender:Content-Transfer-Encoding: Content-Type:Cc:List-Subscribe:List-Help:List-Post:List-Archive: List-Unsubscribe:List-Id:MIME-Version:References:In-Reply-To:Message-Id:Date: Subject:To:From:Reply-To:Content-ID:Content-Description:Resent-Date: Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID:List-Owner; bh=6W7fsFNk2ccPWwXe3ybOuv5XnFN/uDYOzYj7/1gCipE=; b=xTqH7mwVtMSIJZnCdI5BUBUeH fq6L+TKPpEopCxQ56iF/egvWj1MfXusC9tely0xC0/DY3fA5YJ4bUcBya5kmSzdk3UeuR2D6yMeeF 3iT3wLuPg5eH1oZWWd5ssNt/J7P+HsKP9nkP8xVZYpCoNTx4oGXDCV1B8G+pAQSMl2JLDNRCF7Hai o6k2jkC4CVNiZLthUjCq+ClRAeWRuezQMv1WBfQROVx0437rQzs82UdO4sozpF+7/+nkK5HfukDtK mzyxVUBTRlQ07xhhfUGDnyz6J6BCSxDa//S5z6xdp3dvbcN0VKFwsdI73GXBtG25ZnBr7IAMDluph lpUUZPybQ==; Received: from localhost ([::1] helo=merlin.infradead.org) by merlin.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1lEH6L-0002Uu-NG; Mon, 22 Feb 2021 19:42:37 +0000 Received: from mail.kernel.org ([198.145.29.99]) by merlin.infradead.org with esmtps (Exim 4.92.3 #3 (Red Hat Linux)) id 1lEH64-0002Po-Ez for linux-arm-kernel@lists.infradead.org; Mon, 22 Feb 2021 19:42:24 +0000 Received: by mail.kernel.org (Postfix) with ESMTPSA id AA22B64E02; Mon, 22 Feb 2021 19:42:18 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1614022939; bh=ABuBsMdkyLfGL+k7g+MNLq9V3ierJFRdHgGS1x45AwU=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=JgKjJJjHWloLza27ScGiZXzMizkKHkPE7YQD0NKcyQHlNpRwjdUM0J5MllDZhCF64 bZOpbvMNSHotVzw1oTzglbwoLV6U1bYIpSiDFv4+fZSnjCfT2RfYfRcb3ev+GfJMkh +LenIZlQyWUADO/CRCGdvZvh3no/5G1Mw8jAiROyC+FGXkeMj/7AEFRoGh5/gqCJLr WNuf9NX44CWM0tBM3hMqNTPT8B5g3f9RcbgTQgEAjICqoMLLTF1mU0be+r2CBapPSz VKoSxMCle/DRlabWKUm5bxHNh7R7LN4onRmS++WFCj7fbwsEKCCa5CCI197MKVftN/ MHKZWs5c2MqVg== Received: by pali.im (Postfix) id B724AEB8; Mon, 22 Feb 2021 20:42:16 +0100 (CET) From: =?UTF-8?q?Pali=20Roh=C3=A1r?= To: Gregory Clement , Andrew Lunn , Michael Turquette , Stephen Boyd , linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org, linux-clk@vger.kernel.org Subject: [PATCH mvebu v3 02/10] cpufreq: armada-37xx: Fix setting TBG parent for load levels Date: Mon, 22 Feb 2021 20:41:50 +0100 Message-Id: <20210222194158.12342-3-pali@kernel.org> X-Mailer: git-send-email 2.20.1 In-Reply-To: <20210222194158.12342-1-pali@kernel.org> References: <20210114124032.12765-1-pali@kernel.org> <20210222194158.12342-1-pali@kernel.org> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20210222_144220_777068_A68BADCC X-CRM114-Status: GOOD ( 22.64 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: =?UTF-8?q?Marek=20Beh=C3=BAn?= , Tomasz Maciej Nowak , Luka Perkov , Andre Heider , Vladimir Vid , Russell King , =?UTF-8?q?G=C3=A9rald=20Kerma?= , Miquel Raynal , Konstantin Porotchkin Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org RnJvbTogTWFyZWsgQmVow7puIDxrYWJlbEBrZXJuZWwub3JnPgoKV2l0aCBDUFUgZnJlcXVlbmN5 IGRldGVybWluaW5nIHNvZnR3YXJlIFsxXSB3ZSBoYXZlIGRpc2NvdmVyZWQgdGhhdAphZnRlciB0 aGlzIGRyaXZlciBkb2VzIG9uZSBDUFUgZnJlcXVlbmN5IGNoYW5nZSwgdGhlIGJhc2UgZnJlcXVl bmN5IG9mCnRoZSBDUFUgaXMgc2V0IHRvIHRoZSBmcmVxdWVuY3kgb2YgVEJHLUEtUCBjbG9jaywg aW5zdGVhZCBvZiB0aGUgVEJHCnRoYXQgaXMgcGFyZW50IHRvIHRoZSBDUFUuCgpUaGlzIGNhbiBi ZSByZXByb2R1Y2VkIG9uIEVzcHJlc3NvQklOIGFuZCBUdXJyaXMgTU9YOgogIGNkIC9zeXMvZGV2 aWNlcy9zeXN0ZW0vY3B1L2NwdWZyZXEvcG9saWN5MAogIGVjaG8gcG93ZXJzYXZlID5zY2FsaW5n X2dvdmVybm9yCiAgZWNobyBwZXJmb3JtYW5jZSA+c2NhbGluZ19nb3Zlcm5vcgoKUnVubmluZyB0 aGUgbWh6IHRvb2wgYmVmb3JlIHRoaXMgZHJpdmVyIGlzIGxvYWRlZCByZXBvcnRzIDEwMDAgTUh6 LCBhbmQKYWZ0ZXIgbG9hZGluZyB0aGUgZHJpdmVyIGFuZCBleGVjdXRpbmcgY29tbWFuZHMgYWJv dmUgdGhlIHRvb2wgcmVwb3J0cwo4MDAgTUh6LgoKVGhlIGNoYW5nZSBvZiBUQkcgY2xvY2sgc2Vs ZWN0b3IgaXMgc3VwcG9zZWQgdG8gaGFwcGVuIGluIGZ1bmN0aW9uCmFybWFkYTM3eHhfY3B1ZnJl cV9kdmZzX3NldHVwLiBCZWZvcmUgdGhlIGZ1bmN0aW9uIHJldHVybnMsIGl0IGRvZXMKdGhpczoK ICBwYXJlbnQgPSBjbGtfZ2V0X3BhcmVudChjbGspOwogIGNsa19zZXRfcGFyZW50KGNsaywgcGFy ZW50KTsKClRoZSBhcm1hZGEtMzd4eC1wZXJpcGggY2xvY2sgZHJpdmVyIGhhcyB0aGUgLnNldF9w YXJlbnQgbWV0aG9kCmltcGxlbWVudGVkIGNvcnJlY3RseSBmb3IgdGhpcywgc28gaWYgdGhlIG1l dGhvZCB3YXMgYWN0dWFsbHkgY2FsbGVkLAp0aGlzIHdvdWxkIHdvcmsuIEJ1dCBzaW5jZSB0aGUg aW50cm9kdWN0aW9uIG9mIHRoZSBjb21tb24gY2xvY2sKZnJhbWV3b3JrIGluIGNvbW1pdCBiMjQ3 NjQ5MGVmMTEgKCJjbGs6IGludHJvZHVjZSB0aGUgY29tbW9uIGNsb2NrLi4uIiksCnRoZSBjbGtf c2V0X3BhcmVudCBmdW5jdGlvbiBjaGVja3Mgd2hldGhlciB0aGUgcGFyZW50IGlzIGFjdHVhbGx5 CmNoYW5naW5nLCBhbmQgaWYgdGhlIHJlcXVlc3RlZCBuZXcgcGFyZW50IGlzIHNhbWUgYXMgdGhl IG9sZCBwYXJlbnQKKHdoaWNoIGlzIG9idmlvdXNseSB0aGUgY2FzZSBmb3IgdGhlIGNvZGUgYWJv dmUpLCB0aGUgLnNldF9wYXJlbnQgbWV0aG9kCmlzIG5vdCBjYWxsZWQgYXQgYWxsLgoKVGhpcyBw YXRjaCBmaXhlcyB0aGlzIGlzc3VlIGJ5IGZpbGxpbmcgdGhlIGNvcnJlY3QgVEJHIGNsb2NrIHNl bGVjdG9yCmRpcmVjdGx5IGluIHRoZSBhcm1hZGEzN3h4X2NwdWZyZXFfZHZmc19zZXR1cCBkdXJp bmcgdGhlIGZpbGxpbmcgb2YKb3RoZXIgcmVnaXN0ZXJzIGF0IHRoZSBzYW1lIGFkZHJlc3MuIEJ1 dCB0aGUgZGV0ZXJtaW5hdGlvbiBvZiBDUFUgVEJHCmluZGV4IGNhbm5vdCBiZSBkb25lIHZpYSB0 aGUgY29tbW9uIGNsb2NrIGZyYW1ld29yaywgdGhlcmVmb3JlIHdlIG5lZWQKdG8gYWNjZXNzIHRo ZSBOb3J0aCBCcmlkZ2UgUGVyaXBoZXJhbCBDbG9jayByZWdpc3RlcnMgZGlyZWN0bHkgaW4gdGhp cwpkcml2ZXIuCgpbMV0gaHR0cHM6Ly9naXRodWIuY29tL3d0YXJyZWF1L21oegoKU2lnbmVkLW9m Zi1ieTogTWFyZWsgQmVow7puIDxrYWJlbEBrZXJuZWwub3JnPgpUZXN0ZWQtYnk6IFBhbGkgUm9o w6FyIDxwYWxpQGtlcm5lbC5vcmc+ClRlc3RlZC1ieTogVG9tYXN6IE1hY2llaiBOb3dhayA8dG1u NTA1QGdtYWlsLmNvbT4KVGVzdGVkLWJ5OiBBbmRlcnMgVHJpZXIgT2xlc2VuIDxhbmRlcnMudHJp ZXIub2xlc2VuQGdtYWlsLmNvbT4KVGVzdGVkLWJ5OiBQaGlsaXAgU29hcmVzIDxwaGlsaXBzQG5l dGlzZW5zZS5jb20+CkZpeGVzOiA5MmNlNDVmYjg3NWQgKCJjcHVmcmVxOiBBZGQgRFZGUyBzdXBw b3J0IGZvciBBcm1hZGEgMzd4eCIpCkNjOiBzdGFibGVAdmdlci5rZXJuZWwub3JnCi0tLQogZHJp dmVycy9jcHVmcmVxL2FybWFkYS0zN3h4LWNwdWZyZXEuYyB8IDM1ICsrKysrKysrKysrKysrKysr Ky0tLS0tLS0tLQogMSBmaWxlIGNoYW5nZWQsIDIzIGluc2VydGlvbnMoKyksIDEyIGRlbGV0aW9u cygtKQoKZGlmZiAtLWdpdCBhL2RyaXZlcnMvY3B1ZnJlcS9hcm1hZGEtMzd4eC1jcHVmcmVxLmMg Yi9kcml2ZXJzL2NwdWZyZXEvYXJtYWRhLTM3eHgtY3B1ZnJlcS5jCmluZGV4IGI0YWY0MDk0MzA5 Yi4uYjhkYzZjODQ5NTc5IDEwMDY0NAotLS0gYS9kcml2ZXJzL2NwdWZyZXEvYXJtYWRhLTM3eHgt Y3B1ZnJlcS5jCisrKyBiL2RyaXZlcnMvY3B1ZnJlcS9hcm1hZGEtMzd4eC1jcHVmcmVxLmMKQEAg LTI1LDYgKzI1LDEwIEBACiAKICNpbmNsdWRlICJjcHVmcmVxLWR0LmgiCiAKKy8qIENsayByZWdp c3RlciBzZXQgKi8KKyNkZWZpbmUgQVJNQURBXzM3WFhfQ0xLX1RCR19TRUwJCTAKKyNkZWZpbmUg QVJNQURBXzM3WFhfQ0xLX1RCR19TRUxfQ1BVX09GRgkyMgorCiAvKiBQb3dlciBtYW5hZ2VtZW50 IGluIE5vcnRoIEJyaWRnZSByZWdpc3RlciBzZXQgKi8KICNkZWZpbmUgQVJNQURBXzM3WFhfTkJf TDBMMQkweDE4CiAjZGVmaW5lIEFSTUFEQV8zN1hYX05CX0wyTDMJMHgxQwpAQCAtMTIwLDEwICsx MjQsMTUgQEAgc3RhdGljIHN0cnVjdCBhcm1hZGFfMzd4eF9kdmZzICphcm1hZGFfMzd4eF9jcHVf ZnJlcV9pbmZvX2dldCh1MzIgZnJlcSkKICAqIHdpbGwgYmUgY29uZmlndXJlZCB0aGVuIHRoZSBE VkZTIHdpbGwgYmUgZW5hYmxlZC4KICAqLwogc3RhdGljIHZvaWQgX19pbml0IGFybWFkYTM3eHhf Y3B1ZnJlcV9kdmZzX3NldHVwKHN0cnVjdCByZWdtYXAgKmJhc2UsCi0JCQkJCQkgc3RydWN0IGNs ayAqY2xrLCB1OCAqZGl2aWRlcikKKwkJCQkJCSBzdHJ1Y3QgcmVnbWFwICpjbGtfYmFzZSwgdTgg KmRpdmlkZXIpCiB7CisJdTMyIGNwdV90Ymdfc2VsOwogCWludCBsb2FkX2x2bDsKLQlzdHJ1Y3Qg Y2xrICpwYXJlbnQ7CisKKwkvKiBEZXRlcm1pbmUgdG8gd2hpY2ggVEJHIGNsb2NrIGlzIENQVSBj b25uZWN0ZWQgKi8KKwlyZWdtYXBfcmVhZChjbGtfYmFzZSwgQVJNQURBXzM3WFhfQ0xLX1RCR19T RUwsICZjcHVfdGJnX3NlbCk7CisJY3B1X3RiZ19zZWwgPj49IEFSTUFEQV8zN1hYX0NMS19UQkdf U0VMX0NQVV9PRkY7CisJY3B1X3RiZ19zZWwgJj0gQVJNQURBXzM3WFhfTkJfVEJHX1NFTF9NQVNL OwogCiAJZm9yIChsb2FkX2x2bCA9IDA7IGxvYWRfbHZsIDwgTE9BRF9MRVZFTF9OUjsgbG9hZF9s dmwrKykgewogCQl1bnNpZ25lZCBpbnQgcmVnLCBtYXNrLCB2YWwsIG9mZnNldCA9IDA7CkBAIC0x NDIsNiArMTUxLDExIEBAIHN0YXRpYyB2b2lkIF9faW5pdCBhcm1hZGEzN3h4X2NwdWZyZXFfZHZm c19zZXR1cChzdHJ1Y3QgcmVnbWFwICpiYXNlLAogCQltYXNrID0gKEFSTUFEQV8zN1hYX05CX0NM S19TRUxfTUFTSwogCQkJPDwgQVJNQURBXzM3WFhfTkJfQ0xLX1NFTF9PRkYpOwogCisJCS8qIFNl dCBUQkcgaW5kZXgsIGZvciBhbGwgbGV2ZWxzIHdlIHVzZSB0aGUgc2FtZSBUQkcgKi8KKwkJdmFs ID0gY3B1X3RiZ19zZWwgPDwgQVJNQURBXzM3WFhfTkJfVEJHX1NFTF9PRkY7CisJCW1hc2sgPSAo QVJNQURBXzM3WFhfTkJfVEJHX1NFTF9NQVNLCisJCQk8PCBBUk1BREFfMzdYWF9OQl9UQkdfU0VM X09GRik7CisKIAkJLyoKIAkJICogU2V0IGNwdSBkaXZpZGVyIGJhc2VkIG9uIHRoZSBwcmUtY29t cHV0ZWQgYXJyYXkgaW4KIAkJICogb3JkZXIgdG8gaGF2ZSBiYWxhbmNlZCBzdGVwLgpAQCAtMTYw LDE0ICsxNzQsNiBAQCBzdGF0aWMgdm9pZCBfX2luaXQgYXJtYWRhMzd4eF9jcHVmcmVxX2R2ZnNf c2V0dXAoc3RydWN0IHJlZ21hcCAqYmFzZSwKIAogCQlyZWdtYXBfdXBkYXRlX2JpdHMoYmFzZSwg cmVnLCBtYXNrLCB2YWwpOwogCX0KLQotCS8qCi0JICogU2V0IGNwdSBjbG9jayBzb3VyY2UsIGZv ciBhbGwgdGhlIGxldmVsIHdlIGtlZXAgdGhlIHNhbWUKLQkgKiBjbG9jayBzb3VyY2UgdGhhdCB0 aGUgb25lIGFscmVhZHkgY29uZmlndXJlZC4gRm9yIHRoaXMgb25lCi0JICogd2UgbmVlZCB0byB1 c2UgdGhlIGNsb2NrIGZyYW1ld29yawotCSAqLwotCXBhcmVudCA9IGNsa19nZXRfcGFyZW50KGNs ayk7Ci0JY2xrX3NldF9wYXJlbnQoY2xrLCBwYXJlbnQpOwogfQogCiAvKgpAQCAtMzU4LDExICsz NjQsMTYgQEAgc3RhdGljIGludCBfX2luaXQgYXJtYWRhMzd4eF9jcHVmcmVxX2RyaXZlcl9pbml0 KHZvaWQpCiAJc3RydWN0IHBsYXRmb3JtX2RldmljZSAqcGRldjsKIAl1bnNpZ25lZCBsb25nIGZy ZXE7CiAJdW5zaWduZWQgaW50IGN1cl9mcmVxdWVuY3ksIGJhc2VfZnJlcXVlbmN5OwotCXN0cnVj dCByZWdtYXAgKm5iX3BtX2Jhc2UsICphdnNfYmFzZTsKKwlzdHJ1Y3QgcmVnbWFwICpuYl9jbGtf YmFzZSwgKm5iX3BtX2Jhc2UsICphdnNfYmFzZTsKIAlzdHJ1Y3QgZGV2aWNlICpjcHVfZGV2Owog CWludCBsb2FkX2x2bCwgcmV0OwogCXN0cnVjdCBjbGsgKmNsaywgKnBhcmVudDsKIAorCW5iX2Ns a19iYXNlID0KKwkJc3lzY29uX3JlZ21hcF9sb29rdXBfYnlfY29tcGF0aWJsZSgibWFydmVsbCxh cm1hZGEtMzcwMC1wZXJpcGgtY2xvY2stbmIiKTsKKwlpZiAoSVNfRVJSKG5iX2Nsa19iYXNlKSkK KwkJcmV0dXJuIC1FTk9ERVY7CisKIAluYl9wbV9iYXNlID0KIAkJc3lzY29uX3JlZ21hcF9sb29r dXBfYnlfY29tcGF0aWJsZSgibWFydmVsbCxhcm1hZGEtMzcwMC1uYi1wbSIpOwogCkBAIC00Mzks NyArNDUwLDcgQEAgc3RhdGljIGludCBfX2luaXQgYXJtYWRhMzd4eF9jcHVmcmVxX2RyaXZlcl9p bml0KHZvaWQpCiAJYXJtYWRhMzd4eF9jcHVmcmVxX2F2c19jb25maWd1cmUoYXZzX2Jhc2UsIGR2 ZnMpOwogCWFybWFkYTM3eHhfY3B1ZnJlcV9hdnNfc2V0dXAoYXZzX2Jhc2UsIGR2ZnMpOwogCi0J YXJtYWRhMzd4eF9jcHVmcmVxX2R2ZnNfc2V0dXAobmJfcG1fYmFzZSwgY2xrLCBkdmZzLT5kaXZp ZGVyKTsKKwlhcm1hZGEzN3h4X2NwdWZyZXFfZHZmc19zZXR1cChuYl9wbV9iYXNlLCBuYl9jbGtf YmFzZSwgZHZmcy0+ZGl2aWRlcik7CiAJY2xrX3B1dChjbGspOwogCiAJZm9yIChsb2FkX2x2bCA9 IEFSTUFEQV8zN1hYX0RWRlNfTE9BRF8wOyBsb2FkX2x2bCA8IExPQURfTEVWRUxfTlI7Ci0tIAoy LjIwLjEKCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwps aW51eC1hcm0ta2VybmVsIG1haWxpbmcgbGlzdApsaW51eC1hcm0ta2VybmVsQGxpc3RzLmluZnJh ZGVhZC5vcmcKaHR0cDovL2xpc3RzLmluZnJhZGVhZC5vcmcvbWFpbG1hbi9saXN0aW5mby9saW51 eC1hcm0ta2VybmVsCg==