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 gabe.freedesktop.org (gabe.freedesktop.org [131.252.210.177]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 73DD7C77B75 for ; Fri, 5 May 2023 11:26:02 +0000 (UTC) Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id 9805410E5D5; Fri, 5 May 2023 11:26:01 +0000 (UTC) Received: from wnew2-smtp.messagingengine.com (wnew2-smtp.messagingengine.com [64.147.123.27]) by gabe.freedesktop.org (Postfix) with ESMTPS id CDE8D10E5D5 for ; Fri, 5 May 2023 11:25:58 +0000 (UTC) Received: from compute6.internal (compute6.nyi.internal [10.202.2.47]) by mailnew.west.internal (Postfix) with ESMTP id CF5502B066B8; Fri, 5 May 2023 07:25:53 -0400 (EDT) Received: from mailfrontend1 ([10.202.2.162]) by compute6.internal (MEProxy); Fri, 05 May 2023 07:25:58 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=cerno.tech; h=cc :cc:content-transfer-encoding:content-type:content-type:date :date:from:from:in-reply-to:in-reply-to:message-id:mime-version :references:reply-to:sender:subject:subject:to:to; s=fm2; t= 1683285953; x=1683293153; bh=WU20FpUx77EC9SQ4SvyGsBOJEHNPQAGkitA hRG2bZ+8=; b=cgeM5GXMn3UxomTuwWA6AkOxgVn1PUeJmY+HSkE1TZA752i4fMf QlYTaJ3UBsrM+xmXXoB8aMPoNfu33v/+uNcOH6qdiut5C/giuLiiL+5xpPL9JQ3q KBZI2kK8gg4c7gD5R7CpKcY87dEyeTl7s1nF18OyeKxj9B28kPMuyI7bzaLQuG7F jUCWx54c1O0WZ7iMU4OguTOmfgUWmsnRtWbzh20WYFo3Z2hV6z0lK9Rpe9SA8+gk xun/BjXaV1djzqXT5STJvMBm9KjZTBCAJ3fnpgoAoMk4b34q1MzQLNEwCiR0sj6I Yfq0t+Rzah7rVMv1mCoZhd7NmbmoteVaanw== DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d= messagingengine.com; h=cc:cc:content-transfer-encoding :content-type:content-type:date:date:feedback-id:feedback-id :from:from:in-reply-to:in-reply-to:message-id:mime-version :references:reply-to:sender:subject:subject:to:to:x-me-proxy :x-me-proxy:x-me-sender:x-me-sender:x-sasl-enc; s=fm3; t= 1683285953; x=1683293153; bh=WU20FpUx77EC9SQ4SvyGsBOJEHNPQAGkitA hRG2bZ+8=; b=jr8lN2ghqcDZ5kqJHWWrVG+JVKxrGxFjiL2Fo6F+tO6khTu9uNC 3Vzfo/OsYMLD3RLfc+/5PSx3qtINZwp/2/Qs+vt62FUAIp8X+tN87wRyDj5pE/9y PJokTD1FNIRNQR0hzIJGElMJPY0E/L8AV0eT2rJj7nhin7Vj/nnbY7UhIGMzeYDx iZDx76QA1IsHnrUbb92BFyco9yHVZY5Uwf7/Tkjsuw9gRBiv+1/xFABEQxh5Q0cS HziRpz9berfkuczUH/qZ7+c14O98hfnbgHBn//enLqYX0/76S0yKkBeLnX8FTGaH oEkXYF8N3c35dQD5wyXVdIoY4aiurQAwgcA== X-ME-Sender: X-ME-Received: X-ME-Proxy-Cause: gggruggvucftvghtrhhoucdtuddrgedvhedrfeefvddggedtucetufdoteggodetrfdotf fvucfrrhhofhhilhgvmecuhfgrshhtofgrihhlpdfqfgfvpdfurfetoffkrfgpnffqhgen uceurghilhhouhhtmecufedttdenucesvcftvggtihhpihgvnhhtshculddquddttddmne cujfgurhephfffufggtgfgkfhfjgfvvefosehtkeertdertdejnecuhfhrohhmpeforgig ihhmvgcutfhiphgrrhguuceomhgrgihimhgvsegtvghrnhhordhtvggthheqnecuggftrf grthhtvghrnhepudduudfhveejteefgedvffdvvedvjedugedukeejhedtlefhffevtefh jeeltdevnecuvehluhhsthgvrhfuihiivgeptdenucfrrghrrghmpehmrghilhhfrhhomh epmhgrgihimhgvsegtvghrnhhordhtvggthh X-ME-Proxy: Feedback-ID: i8771445c:Fastmail Received: by mail.messagingengine.com (Postfix) with ESMTPA; Fri, 5 May 2023 07:25:51 -0400 (EDT) From: Maxime Ripard Date: Fri, 05 May 2023 13:25:06 +0200 Subject: [PATCH v4 04/68] clk: Introduce clk_hw_determine_rate_no_reparent() MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: 8bit Message-Id: <20221018-clk-range-checks-fixes-v4-4-971d5077e7d2@cerno.tech> References: <20221018-clk-range-checks-fixes-v4-0-971d5077e7d2@cerno.tech> In-Reply-To: <20221018-clk-range-checks-fixes-v4-0-971d5077e7d2@cerno.tech> To: Michael Turquette , Stephen Boyd X-Mailer: b4 0.12.2 X-Developer-Signature: v=1; a=openpgp-sha256; l=10829; i=maxime@cerno.tech; h=from:subject:message-id; bh=YBkKiWSHU6AfKueAcHZCOzbYZiY/0bHTLTOJ1X0UewY=; b=owGbwMvMwCX2+D1vfrpE4FHG02pJDCkhzxedUy9mc+d6kvbti+3SFwfvMnndXJS6hu1k/TrpDJGw on1pHaUsDGJcDLJiiiwxwuZL4k7Net3JxjcPZg4rE8gQBi5OAZjIMUdGhrc1IfwXRIW2N4U5T025te 74MuZT1+3CXxzLnmrrU8G66gwjw9XfZ8pdlhx7KvVmQf4Moc++3jnXPGXyivk3x50qOet1hBMA X-Developer-Key: i=maxime@cerno.tech; a=openpgp; fpr=BE5675C37E818C8B5764241C254BCFC56BF6CE8D X-BeenThere: dri-devel@lists.freedesktop.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Direct Rendering Infrastructure - Development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Alexandre Belloni , Peng Fan , Geert Uytterhoeven , Sekhar Nori , Alexandre Torgue , dri-devel@lists.freedesktop.org, Jaroslav Kysela , Paul Cercueil , Max Filippov , Prashant Gaikwad , linux-phy@lists.infradead.org, linux-clk@vger.kernel.org, Abel Vesa , Kishon Vijay Abraham I , Samuel Holland , Chunyan Zhang , Takashi Iwai , Vinod Koul , Jernej Skrabec , Jonathan Hunter , Chen-Yu Tsai , NXP Linux Team , Chen-Yu Tsai , Orson Zhai , Ulf Hansson , linux-mips@vger.kernel.org, Luca Ceresoli , linux-sunxi@lists.linux.dev, Maxime Coquelin , linux-rtc@vger.kernel.org, Charles Keepax , David Lechner , Manivannan Sadhasivam , Sascha Hauer , Nicolas Ferre , linux-actions@lists.infradead.org, Markus Schneider-Pargmann , Richard Fitzgerald , Mark Brown , Maxime Ripard , Baolin Wang , linux-tegra@vger.kernel.org, Mikko Perttunen , Pengutronix Kernel Team , linux-arm-kernel@lists.infradead.org, AngeloGioacchino Del Regno , Alessandro Zummo , patches@opensource.cirrus.com, Peter De Schrijver , linux-stm32@st-md-mailman.stormreply.com, Liam Girdwood , Claudiu Beznea , linux-renesas-soc@vger.kernel.org, Dinh Nguyen , Miles Chen , Thierry Reding , Shawn Guo , =?utf-8?q?Andreas_F=C3=A4rber?= Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" From: Stephen Boyd Some clock drivers do not want to allow any reparenting on a given clock, but usually do so by not providing any determine_rate implementation. Whenever we call clk_round_rate() or clk_set_rate(), this leads to clk_core_can_round() returning false and thus the rest of the function either forwarding the rate request to its current parent if CLK_SET_RATE_PARENT is set, or just returning the current clock rate. This behaviour happens implicitly, and as we move forward to making a determine_rate implementation required for muxes, we need some way to explicitly opt-in for that behaviour. Fortunately, this is exactly what the clk_core_determine_rate_no_reparent() function is doing, so we can simply make it available to drivers. Cc: Abel Vesa Cc: Alessandro Zummo Cc: Alexandre Belloni Cc: Alexandre Torgue Cc: "Andreas Färber" Cc: AngeloGioacchino Del Regno Cc: Baolin Wang Cc: Charles Keepax Cc: Chen-Yu Tsai Cc: Chen-Yu Tsai Cc: Chunyan Zhang Cc: Claudiu Beznea Cc: Daniel Vetter Cc: David Airlie Cc: David Lechner Cc: Dinh Nguyen Cc: Fabio Estevam Cc: Geert Uytterhoeven Cc: Jaroslav Kysela Cc: Jernej Skrabec Cc: Jonathan Hunter Cc: Kishon Vijay Abraham I Cc: Liam Girdwood Cc: Linus Walleij Cc: Luca Ceresoli Cc: Manivannan Sadhasivam Cc: Mark Brown Cc: Markus Schneider-Pargmann Cc: Max Filippov Cc: Maxime Coquelin Cc: Mikko Perttunen Cc: Miles Chen Cc: Nicolas Ferre Cc: Orson Zhai Cc: Paul Cercueil Cc: Peng Fan Cc: Peter De Schrijver Cc: Prashant Gaikwad Cc: Richard Fitzgerald Cc: Samuel Holland Cc: Sascha Hauer Cc: Sekhar Nori Cc: Shawn Guo Cc: Takashi Iwai Cc: Thierry Reding Cc: Ulf Hansson Cc: Vinod Koul Cc: dri-devel@lists.freedesktop.org Cc: linux-actions@lists.infradead.org Cc: linux-arm-kernel@lists.infradead.org Cc: linux-mips@vger.kernel.org Cc: linux-phy@lists.infradead.org Cc: linux-renesas-soc@vger.kernel.org Cc: linux-rtc@vger.kernel.org Cc: linux-stm32@st-md-mailman.stormreply.com Cc: linux-sunxi@lists.linux.dev Cc: linux-tegra@vger.kernel.org Cc: NXP Linux Team Cc: patches@opensource.cirrus.com Cc: Pengutronix Kernel Team Signed-off-by: Stephen Boyd Signed-off-by: Maxime Ripard --- drivers/clk/clk.c | 18 +++++ drivers/clk/clk_test.c | 152 +++++++++++++++++++++++++++++++++++++++++++ include/linux/clk-provider.h | 2 + 3 files changed, 172 insertions(+) diff --git a/drivers/clk/clk.c b/drivers/clk/clk.c index f57f821a5e5a..5365595433c8 100644 --- a/drivers/clk/clk.c +++ b/drivers/clk/clk.c @@ -783,6 +783,24 @@ int __clk_mux_determine_rate_closest(struct clk_hw *hw, } EXPORT_SYMBOL_GPL(__clk_mux_determine_rate_closest); +/* + * clk_hw_determine_rate_no_reparent - clk_ops::determine_rate implementation for a clk that doesn't reparent + * @hw: mux type clk to determine rate on + * @req: rate request, also used to return preferred frequency + * + * Helper for finding best parent rate to provide a given frequency. + * This can be used directly as a determine_rate callback (e.g. for a + * mux), or from a more complex clock that may combine a mux with other + * operations. + * + * Returns: 0 on success, -EERROR value on error + */ +int clk_hw_determine_rate_no_reparent(struct clk_hw *hw, + struct clk_rate_request *req) +{ + return clk_core_determine_rate_no_reparent(hw, req); +} + /*** clk api ***/ static void clk_core_rate_unprotect(struct clk_core *core) diff --git a/drivers/clk/clk_test.c b/drivers/clk/clk_test.c index 2cb51153750d..b3ed3b0e4c31 100644 --- a/drivers/clk/clk_test.c +++ b/drivers/clk/clk_test.c @@ -141,6 +141,12 @@ static const struct clk_ops clk_multiple_parents_mux_ops = { .determine_rate = __clk_mux_determine_rate_closest, }; +static const struct clk_ops clk_multiple_parents_no_reparent_mux_ops = { + .determine_rate = clk_hw_determine_rate_no_reparent, + .get_parent = clk_multiple_parents_mux_get_parent, + .set_parent = clk_multiple_parents_mux_set_parent, +}; + static int clk_test_init_with_ops(struct kunit *test, const struct clk_ops *ops) { struct clk_dummy_context *ctx; @@ -2395,10 +2401,156 @@ static struct kunit_suite clk_mux_notifier_test_suite = { .test_cases = clk_mux_notifier_test_cases, }; +static int +clk_mux_no_reparent_test_init(struct kunit *test) +{ + struct clk_multiple_parent_ctx *ctx; + const char *parents[2] = { "parent-0", "parent-1"}; + int ret; + + ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL); + if (!ctx) + return -ENOMEM; + test->priv = ctx; + + ctx->parents_ctx[0].hw.init = CLK_HW_INIT_NO_PARENT("parent-0", + &clk_dummy_rate_ops, + 0); + ctx->parents_ctx[0].rate = DUMMY_CLOCK_RATE_1; + ret = clk_hw_register(NULL, &ctx->parents_ctx[0].hw); + if (ret) + return ret; + + ctx->parents_ctx[1].hw.init = CLK_HW_INIT_NO_PARENT("parent-1", + &clk_dummy_rate_ops, + 0); + ctx->parents_ctx[1].rate = DUMMY_CLOCK_RATE_2; + ret = clk_hw_register(NULL, &ctx->parents_ctx[1].hw); + if (ret) + return ret; + + ctx->current_parent = 0; + ctx->hw.init = CLK_HW_INIT_PARENTS("test-mux", parents, + &clk_multiple_parents_no_reparent_mux_ops, + 0); + ret = clk_hw_register(NULL, &ctx->hw); + if (ret) + return ret; + + return 0; +} + +static void +clk_mux_no_reparent_test_exit(struct kunit *test) +{ + struct clk_multiple_parent_ctx *ctx = test->priv; + + clk_hw_unregister(&ctx->hw); + clk_hw_unregister(&ctx->parents_ctx[0].hw); + clk_hw_unregister(&ctx->parents_ctx[1].hw); +} + +/* + * Test that if the we have a mux that cannot change parent and we call + * clk_round_rate() on it with a rate that should cause it to change + * parent, it won't. + */ +static void clk_mux_no_reparent_round_rate(struct kunit *test) +{ + struct clk_multiple_parent_ctx *ctx = test->priv; + struct clk_hw *hw = &ctx->hw; + struct clk *clk = clk_hw_get_clk(hw, NULL); + struct clk *other_parent, *parent; + unsigned long other_parent_rate; + unsigned long parent_rate; + long rounded_rate; + + parent = clk_get_parent(clk); + KUNIT_ASSERT_PTR_NE(test, parent, NULL); + + parent_rate = clk_get_rate(parent); + KUNIT_ASSERT_GT(test, parent_rate, 0); + + other_parent = clk_hw_get_clk(&ctx->parents_ctx[1].hw, NULL); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, other_parent); + KUNIT_ASSERT_FALSE(test, clk_is_match(parent, other_parent)); + + other_parent_rate = clk_get_rate(other_parent); + KUNIT_ASSERT_GT(test, other_parent_rate, 0); + clk_put(other_parent); + + rounded_rate = clk_round_rate(clk, other_parent_rate); + KUNIT_ASSERT_GT(test, rounded_rate, 0); + KUNIT_EXPECT_EQ(test, rounded_rate, parent_rate); + + clk_put(clk); +} + +/* + * Test that if the we have a mux that cannot change parent and we call + * clk_set_rate() on it with a rate that should cause it to change + * parent, it won't. + */ +static void clk_mux_no_reparent_set_rate(struct kunit *test) +{ + struct clk_multiple_parent_ctx *ctx = test->priv; + struct clk_hw *hw = &ctx->hw; + struct clk *clk = clk_hw_get_clk(hw, NULL); + struct clk *other_parent, *parent; + unsigned long other_parent_rate; + unsigned long parent_rate; + unsigned long rate; + int ret; + + parent = clk_get_parent(clk); + KUNIT_ASSERT_PTR_NE(test, parent, NULL); + + parent_rate = clk_get_rate(parent); + KUNIT_ASSERT_GT(test, parent_rate, 0); + + other_parent = clk_hw_get_clk(&ctx->parents_ctx[1].hw, NULL); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, other_parent); + KUNIT_ASSERT_FALSE(test, clk_is_match(parent, other_parent)); + + other_parent_rate = clk_get_rate(other_parent); + KUNIT_ASSERT_GT(test, other_parent_rate, 0); + clk_put(other_parent); + + ret = clk_set_rate(clk, other_parent_rate); + KUNIT_ASSERT_EQ(test, ret, 0); + + rate = clk_get_rate(clk); + KUNIT_ASSERT_GT(test, rate, 0); + KUNIT_EXPECT_EQ(test, rate, parent_rate); + + clk_put(clk); +} + +static struct kunit_case clk_mux_no_reparent_test_cases[] = { + KUNIT_CASE(clk_mux_no_reparent_round_rate), + KUNIT_CASE(clk_mux_no_reparent_set_rate), + {} +}; + +/* + * Test suite for a clock mux that isn't allowed to change parent, using + * the clk_hw_determine_rate_no_reparent() helper. + * + * These tests exercise that helper, and the proper selection of + * rates and parents. + */ +static struct kunit_suite clk_mux_no_reparent_test_suite = { + .name = "clk-mux-no-reparent", + .init = clk_mux_no_reparent_test_init, + .exit = clk_mux_no_reparent_test_exit, + .test_cases = clk_mux_no_reparent_test_cases, +}; + kunit_test_suites( &clk_leaf_mux_set_rate_parent_test_suite, &clk_test_suite, &clk_multiple_parents_mux_test_suite, + &clk_mux_no_reparent_test_suite, &clk_mux_notifier_test_suite, &clk_orphan_transparent_multiple_parent_mux_test_suite, &clk_orphan_transparent_single_parent_test_suite, diff --git a/include/linux/clk-provider.h b/include/linux/clk-provider.h index 28ff6f1a6ada..f8f220fb5dab 100644 --- a/include/linux/clk-provider.h +++ b/include/linux/clk-provider.h @@ -1333,6 +1333,8 @@ int __clk_mux_determine_rate_closest(struct clk_hw *hw, int clk_mux_determine_rate_flags(struct clk_hw *hw, struct clk_rate_request *req, unsigned long flags); +int clk_hw_determine_rate_no_reparent(struct clk_hw *hw, + struct clk_rate_request *req); void clk_hw_reparent(struct clk_hw *hw, struct clk_hw *new_parent); void clk_hw_get_rate_range(struct clk_hw *hw, unsigned long *min_rate, unsigned long *max_rate); -- 2.40.0 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 1C408C77B7F for ; Fri, 5 May 2023 11:26:04 +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:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:Cc:To:In-Reply-To:References:Message-Id :MIME-Version:Subject:Date:From:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=MClnhPXh1RVoWxujtDAhreaqz1/+eessX17QaAsKQYY=; b=ORbhtiwDiT522G dGfv3YmNIKtFmL6IbkYvFp+Uh+XM17ksMwdTXixy2dAZyoX0oErJr+ek1LFQThg/OcEGuurfr5CL5 IBPl6yJrygJNv2Q3eDFdZALLjo4knJfGLYX2C2Ey7uLyx/5MfRcEUjxj7rAOG/4E/q9+dIzHWu6X+ GBZ3jGRmmo5YVpGbjur1a4D6wyoEnB3fY23l77euNOPOzx4/xXAAp5tK7aDfGCyDGsmLOyTYcq6wC 1ahy9QnyWF3IpxFgICtoIoul/UUiLO0fcIuz1OMudT8nuEHwrXZaNEqFGdQtSlFHH6m6WWLh8VXVr GzgZfrRA5EoSSQppxBnw==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.96 #2 (Red Hat Linux)) id 1putZb-00Af8M-2O; Fri, 05 May 2023 11:26:03 +0000 Received: from wnew2-smtp.messagingengine.com ([64.147.123.27]) by bombadil.infradead.org with esmtps (Exim 4.96 #2 (Red Hat Linux)) id 1putZW-00Af74-2b; Fri, 05 May 2023 11:26:00 +0000 Received: from compute6.internal (compute6.nyi.internal [10.202.2.47]) by mailnew.west.internal (Postfix) with ESMTP id CF5502B066B8; Fri, 5 May 2023 07:25:53 -0400 (EDT) Received: from mailfrontend1 ([10.202.2.162]) by compute6.internal (MEProxy); Fri, 05 May 2023 07:25:58 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=cerno.tech; h=cc :cc:content-transfer-encoding:content-type:content-type:date :date:from:from:in-reply-to:in-reply-to:message-id:mime-version :references:reply-to:sender:subject:subject:to:to; s=fm2; t= 1683285953; x=1683293153; bh=WU20FpUx77EC9SQ4SvyGsBOJEHNPQAGkitA hRG2bZ+8=; b=cgeM5GXMn3UxomTuwWA6AkOxgVn1PUeJmY+HSkE1TZA752i4fMf QlYTaJ3UBsrM+xmXXoB8aMPoNfu33v/+uNcOH6qdiut5C/giuLiiL+5xpPL9JQ3q KBZI2kK8gg4c7gD5R7CpKcY87dEyeTl7s1nF18OyeKxj9B28kPMuyI7bzaLQuG7F jUCWx54c1O0WZ7iMU4OguTOmfgUWmsnRtWbzh20WYFo3Z2hV6z0lK9Rpe9SA8+gk xun/BjXaV1djzqXT5STJvMBm9KjZTBCAJ3fnpgoAoMk4b34q1MzQLNEwCiR0sj6I Yfq0t+Rzah7rVMv1mCoZhd7NmbmoteVaanw== DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d= messagingengine.com; h=cc:cc:content-transfer-encoding :content-type:content-type:date:date:feedback-id:feedback-id :from:from:in-reply-to:in-reply-to:message-id:mime-version :references:reply-to:sender:subject:subject:to:to:x-me-proxy :x-me-proxy:x-me-sender:x-me-sender:x-sasl-enc; s=fm3; t= 1683285953; x=1683293153; bh=WU20FpUx77EC9SQ4SvyGsBOJEHNPQAGkitA hRG2bZ+8=; b=jr8lN2ghqcDZ5kqJHWWrVG+JVKxrGxFjiL2Fo6F+tO6khTu9uNC 3Vzfo/OsYMLD3RLfc+/5PSx3qtINZwp/2/Qs+vt62FUAIp8X+tN87wRyDj5pE/9y PJokTD1FNIRNQR0hzIJGElMJPY0E/L8AV0eT2rJj7nhin7Vj/nnbY7UhIGMzeYDx iZDx76QA1IsHnrUbb92BFyco9yHVZY5Uwf7/Tkjsuw9gRBiv+1/xFABEQxh5Q0cS HziRpz9berfkuczUH/qZ7+c14O98hfnbgHBn//enLqYX0/76S0yKkBeLnX8FTGaH oEkXYF8N3c35dQD5wyXVdIoY4aiurQAwgcA== X-ME-Sender: X-ME-Received: X-ME-Proxy-Cause: gggruggvucftvghtrhhoucdtuddrgedvhedrfeefvddggedtucetufdoteggodetrfdotf fvucfrrhhofhhilhgvmecuhfgrshhtofgrihhlpdfqfgfvpdfurfetoffkrfgpnffqhgen uceurghilhhouhhtmecufedttdenucesvcftvggtihhpihgvnhhtshculddquddttddmne cujfgurhephfffufggtgfgkfhfjgfvvefosehtkeertdertdejnecuhfhrohhmpeforgig ihhmvgcutfhiphgrrhguuceomhgrgihimhgvsegtvghrnhhordhtvggthheqnecuggftrf grthhtvghrnhepudduudfhveejteefgedvffdvvedvjedugedukeejhedtlefhffevtefh jeeltdevnecuvehluhhsthgvrhfuihiivgeptdenucfrrghrrghmpehmrghilhhfrhhomh epmhgrgihimhgvsegtvghrnhhordhtvggthh X-ME-Proxy: Feedback-ID: i8771445c:Fastmail Received: by mail.messagingengine.com (Postfix) with ESMTPA; Fri, 5 May 2023 07:25:51 -0400 (EDT) From: Maxime Ripard Date: Fri, 05 May 2023 13:25:06 +0200 Subject: [PATCH v4 04/68] clk: Introduce clk_hw_determine_rate_no_reparent() MIME-Version: 1.0 Message-Id: <20221018-clk-range-checks-fixes-v4-4-971d5077e7d2@cerno.tech> References: <20221018-clk-range-checks-fixes-v4-0-971d5077e7d2@cerno.tech> In-Reply-To: <20221018-clk-range-checks-fixes-v4-0-971d5077e7d2@cerno.tech> To: Michael Turquette , Stephen Boyd Cc: linux-clk@vger.kernel.org, Maxime Ripard , Abel Vesa , Alessandro Zummo , Alexandre Belloni , Alexandre Torgue , =?utf-8?q?Andreas_F=C3=A4rber?= , AngeloGioacchino Del Regno , Baolin Wang , Charles Keepax , Chen-Yu Tsai , Chen-Yu Tsai , Chunyan Zhang , Claudiu Beznea , Daniel Vetter , David Airlie , David Lechner , Dinh Nguyen , Fabio Estevam , Geert Uytterhoeven , Jaroslav Kysela , Jernej Skrabec , Jonathan Hunter , Kishon Vijay Abraham I , Liam Girdwood , Linus Walleij , Luca Ceresoli , Manivannan Sadhasivam , Mark Brown , Markus Schneider-Pargmann , Max Filippov , Maxime Coquelin , Mikko Perttunen , Miles Chen , Nicolas Ferre , Orson Zhai , Paul Cercueil , Peng Fan , Peter De Schrijver , Prashant Gaikwad , Richard Fitzgerald , Samuel Holland , Sascha Hauer , Sekhar Nori , Shawn Guo , Takashi Iwai , Thierry Reding , Ulf Hansson , Vinod Koul , dri-devel@lists.freedesktop.org, linux-actions@lists.infradead.org, linux-arm-kernel@lists.infradead.org, linux-mips@vger.kernel.org, linux-phy@lists.infradead.org, linux-renesas-soc@vger.kernel.org, linux-rtc@vger.kernel.org, linux-stm32@st-md-mailman.stormreply.com, linux-sunxi@lists.linux.dev, linux-tegra@vger.kernel.org, NXP Linux Team , patches@opensource.cirrus.com, Pengutronix Kernel Team X-Mailer: b4 0.12.2 X-Developer-Signature: v=1; a=openpgp-sha256; l=10829; i=maxime@cerno.tech; h=from:subject:message-id; bh=YBkKiWSHU6AfKueAcHZCOzbYZiY/0bHTLTOJ1X0UewY=; b=owGbwMvMwCX2+D1vfrpE4FHG02pJDCkhzxedUy9mc+d6kvbti+3SFwfvMnndXJS6hu1k/TrpDJGw on1pHaUsDGJcDLJiiiwxwuZL4k7Net3JxjcPZg4rE8gQBi5OAZjIMUdGhrc1IfwXRIW2N4U5T025te 74MuZT1+3CXxzLnmrrU8G66gwjw9XfZ8pdlhx7KvVmQf4Moc++3jnXPGXyivk3x50qOet1hBMA X-Developer-Key: i=maxime@cerno.tech; a=openpgp; fpr=BE5675C37E818C8B5764241C254BCFC56BF6CE8D X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20230505_042558_901886_82F2FA71 X-CRM114-Status: GOOD ( 23.31 ) 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: , 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 RnJvbTogU3RlcGhlbiBCb3lkIDxzYm95ZEBrZXJuZWwub3JnPgoKU29tZSBjbG9jayBkcml2ZXJz IGRvIG5vdCB3YW50IHRvIGFsbG93IGFueSByZXBhcmVudGluZyBvbiBhIGdpdmVuCmNsb2NrLCBi dXQgdXN1YWxseSBkbyBzbyBieSBub3QgcHJvdmlkaW5nIGFueSBkZXRlcm1pbmVfcmF0ZQppbXBs ZW1lbnRhdGlvbi4KCldoZW5ldmVyIHdlIGNhbGwgY2xrX3JvdW5kX3JhdGUoKSBvciBjbGtfc2V0 X3JhdGUoKSwgdGhpcyBsZWFkcyB0bwpjbGtfY29yZV9jYW5fcm91bmQoKSByZXR1cm5pbmcgZmFs c2UgYW5kIHRodXMgdGhlIHJlc3Qgb2YgdGhlIGZ1bmN0aW9uCmVpdGhlciBmb3J3YXJkaW5nIHRo ZSByYXRlIHJlcXVlc3QgdG8gaXRzIGN1cnJlbnQgcGFyZW50IGlmCkNMS19TRVRfUkFURV9QQVJF TlQgaXMgc2V0LCBvciBqdXN0IHJldHVybmluZyB0aGUgY3VycmVudCBjbG9jayByYXRlLgoKVGhp cyBiZWhhdmlvdXIgaGFwcGVucyBpbXBsaWNpdGx5LCBhbmQgYXMgd2UgbW92ZSBmb3J3YXJkIHRv IG1ha2luZyBhCmRldGVybWluZV9yYXRlIGltcGxlbWVudGF0aW9uIHJlcXVpcmVkIGZvciBtdXhl cywgd2UgbmVlZCBzb21lIHdheSB0bwpleHBsaWNpdGx5IG9wdC1pbiBmb3IgdGhhdCBiZWhhdmlv dXIuCgpGb3J0dW5hdGVseSwgdGhpcyBpcyBleGFjdGx5IHdoYXQgdGhlIGNsa19jb3JlX2RldGVy bWluZV9yYXRlX25vX3JlcGFyZW50KCkKZnVuY3Rpb24gaXMgZG9pbmcsIHNvIHdlIGNhbiBzaW1w bHkgbWFrZSBpdCBhdmFpbGFibGUgdG8gZHJpdmVycy4KCkNjOiBBYmVsIFZlc2EgPGFiZWx2ZXNh QGtlcm5lbC5vcmc+CkNjOiBBbGVzc2FuZHJvIFp1bW1vIDxhLnp1bW1vQHRvd2VydGVjaC5pdD4K Q2M6IEFsZXhhbmRyZSBCZWxsb25pIDxhbGV4YW5kcmUuYmVsbG9uaUBib290bGluLmNvbT4KQ2M6 IEFsZXhhbmRyZSBUb3JndWUgPGFsZXhhbmRyZS50b3JndWVAZm9zcy5zdC5jb20+CkNjOiAiQW5k cmVhcyBGw6RyYmVyIiA8YWZhZXJiZXJAc3VzZS5kZT4KQ2M6IEFuZ2Vsb0dpb2FjY2hpbm8gRGVs IFJlZ25vIDxhbmdlbG9naW9hY2NoaW5vLmRlbHJlZ25vQGNvbGxhYm9yYS5jb20+CkNjOiBCYW9s aW4gV2FuZyA8YmFvbGluLndhbmdAbGludXguYWxpYmFiYS5jb20+CkNjOiBDaGFybGVzIEtlZXBh eCA8Y2tlZXBheEBvcGVuc291cmNlLmNpcnJ1cy5jb20+CkNjOiBDaGVuLVl1IFRzYWkgPHdlbnNA Y3NpZS5vcmc+CkNjOiBDaGVuLVl1IFRzYWkgPHdlbnN0QGNocm9taXVtLm9yZz4KQ2M6IENodW55 YW4gWmhhbmcgPHpoYW5nLmx5cmFAZ21haWwuY29tPgpDYzogQ2xhdWRpdSBCZXpuZWEgPGNsYXVk aXUuYmV6bmVhQG1pY3JvY2hpcC5jb20+CkNjOiBEYW5pZWwgVmV0dGVyIDxkYW5pZWxAZmZ3bGwu Y2g+CkNjOiBEYXZpZCBBaXJsaWUgPGFpcmxpZWRAZ21haWwuY29tPgpDYzogRGF2aWQgTGVjaG5l ciA8ZGF2aWRAbGVjaG5vbG9neS5jb20+CkNjOiBEaW5oIE5ndXllbiA8ZGluZ3V5ZW5Aa2VybmVs Lm9yZz4KQ2M6IEZhYmlvIEVzdGV2YW0gPGZlc3RldmFtQGdtYWlsLmNvbT4KQ2M6IEdlZXJ0IFV5 dHRlcmhvZXZlbiA8Z2VlcnQrcmVuZXNhc0BnbGlkZXIuYmU+CkNjOiBKYXJvc2xhdiBLeXNlbGEg PHBlcmV4QHBlcmV4LmN6PgpDYzogSmVybmVqIFNrcmFiZWMgPGplcm5lai5za3JhYmVjQGdtYWls LmNvbT4KQ2M6IEpvbmF0aGFuIEh1bnRlciA8am9uYXRoYW5oQG52aWRpYS5jb20+CkNjOiBLaXNo b24gVmlqYXkgQWJyYWhhbSBJIDxraXNob25Aa2VybmVsLm9yZz4KQ2M6IExpYW0gR2lyZHdvb2Qg PGxnaXJkd29vZEBnbWFpbC5jb20+CkNjOiBMaW51cyBXYWxsZWlqIDxsaW51cy53YWxsZWlqQGxp bmFyby5vcmc+CkNjOiBMdWNhIENlcmVzb2xpIDxsdWNhLmNlcmVzb2xpQGJvb3RsaW4uY29tPgpD YzogTWFuaXZhbm5hbiBTYWRoYXNpdmFtIDxtYW5pQGtlcm5lbC5vcmc+CkNjOiBNYXJrIEJyb3du IDxicm9vbmllQGtlcm5lbC5vcmc+CkNjOiBNYXJrdXMgU2NobmVpZGVyLVBhcmdtYW5uIDxtc3BA YmF5bGlicmUuY29tPgpDYzogTWF4IEZpbGlwcG92IDxqY212YmtiY0BnbWFpbC5jb20+CkNjOiBN YXhpbWUgQ29xdWVsaW4gPG1jb3F1ZWxpbi5zdG0zMkBnbWFpbC5jb20+CkNjOiBNaWtrbyBQZXJ0 dHVuZW4gPG1wZXJ0dHVuZW5AbnZpZGlhLmNvbT4KQ2M6IE1pbGVzIENoZW4gPG1pbGVzLmNoZW5A bWVkaWF0ZWsuY29tPgpDYzogTmljb2xhcyBGZXJyZSA8bmljb2xhcy5mZXJyZUBtaWNyb2NoaXAu Y29tPgpDYzogT3Jzb24gWmhhaSA8b3Jzb256aGFpQGdtYWlsLmNvbT4KQ2M6IFBhdWwgQ2VyY3Vl aWwgPHBhdWxAY3JhcG91aWxsb3UubmV0PgpDYzogUGVuZyBGYW4gPHBlbmcuZmFuQG54cC5jb20+ CkNjOiBQZXRlciBEZSBTY2hyaWp2ZXIgPHBkZXNjaHJpanZlckBudmlkaWEuY29tPgpDYzogUHJh c2hhbnQgR2Fpa3dhZCA8cGdhaWt3YWRAbnZpZGlhLmNvbT4KQ2M6IFJpY2hhcmQgRml0emdlcmFs ZCA8cmZAb3BlbnNvdXJjZS5jaXJydXMuY29tPgpDYzogU2FtdWVsIEhvbGxhbmQgPHNhbXVlbEBz aG9sbGFuZC5vcmc+CkNjOiBTYXNjaGEgSGF1ZXIgPHMuaGF1ZXJAcGVuZ3V0cm9uaXguZGU+CkNj OiBTZWtoYXIgTm9yaSA8bnNla2hhckB0aS5jb20+CkNjOiBTaGF3biBHdW8gPHNoYXduZ3VvQGtl cm5lbC5vcmc+CkNjOiBUYWthc2hpIEl3YWkgPHRpd2FpQHN1c2UuY29tPgpDYzogVGhpZXJyeSBS ZWRpbmcgPHRoaWVycnkucmVkaW5nQGdtYWlsLmNvbT4KQ2M6IFVsZiBIYW5zc29uIDx1bGYuaGFu c3NvbkBsaW5hcm8ub3JnPgpDYzogVmlub2QgS291bCA8dmtvdWxAa2VybmVsLm9yZz4KQ2M6IGRy aS1kZXZlbEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKQ2M6IGxpbnV4LWFjdGlvbnNAbGlzdHMuaW5m cmFkZWFkLm9yZwpDYzogbGludXgtYXJtLWtlcm5lbEBsaXN0cy5pbmZyYWRlYWQub3JnCkNjOiBs aW51eC1taXBzQHZnZXIua2VybmVsLm9yZwpDYzogbGludXgtcGh5QGxpc3RzLmluZnJhZGVhZC5v cmcKQ2M6IGxpbnV4LXJlbmVzYXMtc29jQHZnZXIua2VybmVsLm9yZwpDYzogbGludXgtcnRjQHZn ZXIua2VybmVsLm9yZwpDYzogbGludXgtc3RtMzJAc3QtbWQtbWFpbG1hbi5zdG9ybXJlcGx5LmNv bQpDYzogbGludXgtc3VueGlAbGlzdHMubGludXguZGV2CkNjOiBsaW51eC10ZWdyYUB2Z2VyLmtl cm5lbC5vcmcKQ2M6IE5YUCBMaW51eCBUZWFtIDxsaW51eC1pbXhAbnhwLmNvbT4KQ2M6IHBhdGNo ZXNAb3BlbnNvdXJjZS5jaXJydXMuY29tCkNjOiBQZW5ndXRyb25peCBLZXJuZWwgVGVhbSA8a2Vy bmVsQHBlbmd1dHJvbml4LmRlPgpTaWduZWQtb2ZmLWJ5OiBTdGVwaGVuIEJveWQgPHNib3lkQGtl cm5lbC5vcmc+ClNpZ25lZC1vZmYtYnk6IE1heGltZSBSaXBhcmQgPG1heGltZUBjZXJuby50ZWNo PgotLS0KIGRyaXZlcnMvY2xrL2Nsay5jICAgICAgICAgICAgfCAgMTggKysrKysKIGRyaXZlcnMv Y2xrL2Nsa190ZXN0LmMgICAgICAgfCAxNTIgKysrKysrKysrKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKwogaW5jbHVkZS9saW51eC9jbGstcHJvdmlkZXIuaCB8ICAgMiArCiAzIGZp bGVzIGNoYW5nZWQsIDE3MiBpbnNlcnRpb25zKCspCgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9jbGsv Y2xrLmMgYi9kcml2ZXJzL2Nsay9jbGsuYwppbmRleCBmNTdmODIxYTVlNWEuLjUzNjU1OTU0MzNj OCAxMDA2NDQKLS0tIGEvZHJpdmVycy9jbGsvY2xrLmMKKysrIGIvZHJpdmVycy9jbGsvY2xrLmMK QEAgLTc4Myw2ICs3ODMsMjQgQEAgaW50IF9fY2xrX211eF9kZXRlcm1pbmVfcmF0ZV9jbG9zZXN0 KHN0cnVjdCBjbGtfaHcgKmh3LAogfQogRVhQT1JUX1NZTUJPTF9HUEwoX19jbGtfbXV4X2RldGVy bWluZV9yYXRlX2Nsb3Nlc3QpOwogCisvKgorICogY2xrX2h3X2RldGVybWluZV9yYXRlX25vX3Jl cGFyZW50IC0gY2xrX29wczo6ZGV0ZXJtaW5lX3JhdGUgaW1wbGVtZW50YXRpb24gZm9yIGEgY2xr IHRoYXQgZG9lc24ndCByZXBhcmVudAorICogQGh3OiBtdXggdHlwZSBjbGsgdG8gZGV0ZXJtaW5l IHJhdGUgb24KKyAqIEByZXE6IHJhdGUgcmVxdWVzdCwgYWxzbyB1c2VkIHRvIHJldHVybiBwcmVm ZXJyZWQgZnJlcXVlbmN5CisgKgorICogSGVscGVyIGZvciBmaW5kaW5nIGJlc3QgcGFyZW50IHJh dGUgdG8gcHJvdmlkZSBhIGdpdmVuIGZyZXF1ZW5jeS4KKyAqIFRoaXMgY2FuIGJlIHVzZWQgZGly ZWN0bHkgYXMgYSBkZXRlcm1pbmVfcmF0ZSBjYWxsYmFjayAoZS5nLiBmb3IgYQorICogbXV4KSwg b3IgZnJvbSBhIG1vcmUgY29tcGxleCBjbG9jayB0aGF0IG1heSBjb21iaW5lIGEgbXV4IHdpdGgg b3RoZXIKKyAqIG9wZXJhdGlvbnMuCisgKgorICogUmV0dXJuczogMCBvbiBzdWNjZXNzLCAtRUVS Uk9SIHZhbHVlIG9uIGVycm9yCisgKi8KK2ludCBjbGtfaHdfZGV0ZXJtaW5lX3JhdGVfbm9fcmVw YXJlbnQoc3RydWN0IGNsa19odyAqaHcsCisJCQkJICAgICAgc3RydWN0IGNsa19yYXRlX3JlcXVl c3QgKnJlcSkKK3sKKwlyZXR1cm4gY2xrX2NvcmVfZGV0ZXJtaW5lX3JhdGVfbm9fcmVwYXJlbnQo aHcsIHJlcSk7Cit9CisKIC8qKiogICAgICAgIGNsayBhcGkgICAgICAgICoqKi8KIAogc3RhdGlj IHZvaWQgY2xrX2NvcmVfcmF0ZV91bnByb3RlY3Qoc3RydWN0IGNsa19jb3JlICpjb3JlKQpkaWZm IC0tZ2l0IGEvZHJpdmVycy9jbGsvY2xrX3Rlc3QuYyBiL2RyaXZlcnMvY2xrL2Nsa190ZXN0LmMK aW5kZXggMmNiNTExNTM3NTBkLi5iM2VkM2IwZTRjMzEgMTAwNjQ0Ci0tLSBhL2RyaXZlcnMvY2xr L2Nsa190ZXN0LmMKKysrIGIvZHJpdmVycy9jbGsvY2xrX3Rlc3QuYwpAQCAtMTQxLDYgKzE0MSwx MiBAQCBzdGF0aWMgY29uc3Qgc3RydWN0IGNsa19vcHMgY2xrX211bHRpcGxlX3BhcmVudHNfbXV4 X29wcyA9IHsKIAkuZGV0ZXJtaW5lX3JhdGUgPSBfX2Nsa19tdXhfZGV0ZXJtaW5lX3JhdGVfY2xv c2VzdCwKIH07CiAKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgY2xrX29wcyBjbGtfbXVsdGlwbGVfcGFy ZW50c19ub19yZXBhcmVudF9tdXhfb3BzID0geworCS5kZXRlcm1pbmVfcmF0ZSA9IGNsa19od19k ZXRlcm1pbmVfcmF0ZV9ub19yZXBhcmVudCwKKwkuZ2V0X3BhcmVudCA9IGNsa19tdWx0aXBsZV9w YXJlbnRzX211eF9nZXRfcGFyZW50LAorCS5zZXRfcGFyZW50ID0gY2xrX211bHRpcGxlX3BhcmVu dHNfbXV4X3NldF9wYXJlbnQsCit9OworCiBzdGF0aWMgaW50IGNsa190ZXN0X2luaXRfd2l0aF9v cHMoc3RydWN0IGt1bml0ICp0ZXN0LCBjb25zdCBzdHJ1Y3QgY2xrX29wcyAqb3BzKQogewogCXN0 cnVjdCBjbGtfZHVtbXlfY29udGV4dCAqY3R4OwpAQCAtMjM5NSwxMCArMjQwMSwxNTYgQEAgc3Rh dGljIHN0cnVjdCBrdW5pdF9zdWl0ZSBjbGtfbXV4X25vdGlmaWVyX3Rlc3Rfc3VpdGUgPSB7CiAJ LnRlc3RfY2FzZXMgPSBjbGtfbXV4X25vdGlmaWVyX3Rlc3RfY2FzZXMsCiB9OwogCitzdGF0aWMg aW50CitjbGtfbXV4X25vX3JlcGFyZW50X3Rlc3RfaW5pdChzdHJ1Y3Qga3VuaXQgKnRlc3QpCit7 CisJc3RydWN0IGNsa19tdWx0aXBsZV9wYXJlbnRfY3R4ICpjdHg7CisJY29uc3QgY2hhciAqcGFy ZW50c1syXSA9IHsgInBhcmVudC0wIiwgInBhcmVudC0xIn07CisJaW50IHJldDsKKworCWN0eCA9 IGt1bml0X2t6YWxsb2ModGVzdCwgc2l6ZW9mKCpjdHgpLCBHRlBfS0VSTkVMKTsKKwlpZiAoIWN0 eCkKKwkJcmV0dXJuIC1FTk9NRU07CisJdGVzdC0+cHJpdiA9IGN0eDsKKworCWN0eC0+cGFyZW50 c19jdHhbMF0uaHcuaW5pdCA9IENMS19IV19JTklUX05PX1BBUkVOVCgicGFyZW50LTAiLAorCQkJ CQkJCSAgICAmY2xrX2R1bW15X3JhdGVfb3BzLAorCQkJCQkJCSAgICAwKTsKKwljdHgtPnBhcmVu dHNfY3R4WzBdLnJhdGUgPSBEVU1NWV9DTE9DS19SQVRFXzE7CisJcmV0ID0gY2xrX2h3X3JlZ2lz dGVyKE5VTEwsICZjdHgtPnBhcmVudHNfY3R4WzBdLmh3KTsKKwlpZiAocmV0KQorCQlyZXR1cm4g cmV0OworCisJY3R4LT5wYXJlbnRzX2N0eFsxXS5ody5pbml0ID0gQ0xLX0hXX0lOSVRfTk9fUEFS RU5UKCJwYXJlbnQtMSIsCisJCQkJCQkJICAgICZjbGtfZHVtbXlfcmF0ZV9vcHMsCisJCQkJCQkJ ICAgIDApOworCWN0eC0+cGFyZW50c19jdHhbMV0ucmF0ZSA9IERVTU1ZX0NMT0NLX1JBVEVfMjsK KwlyZXQgPSBjbGtfaHdfcmVnaXN0ZXIoTlVMTCwgJmN0eC0+cGFyZW50c19jdHhbMV0uaHcpOwor CWlmIChyZXQpCisJCXJldHVybiByZXQ7CisKKwljdHgtPmN1cnJlbnRfcGFyZW50ID0gMDsKKwlj dHgtPmh3LmluaXQgPSBDTEtfSFdfSU5JVF9QQVJFTlRTKCJ0ZXN0LW11eCIsIHBhcmVudHMsCisJ CQkJCSAgICZjbGtfbXVsdGlwbGVfcGFyZW50c19ub19yZXBhcmVudF9tdXhfb3BzLAorCQkJCQkg ICAwKTsKKwlyZXQgPSBjbGtfaHdfcmVnaXN0ZXIoTlVMTCwgJmN0eC0+aHcpOworCWlmIChyZXQp CisJCXJldHVybiByZXQ7CisKKwlyZXR1cm4gMDsKK30KKworc3RhdGljIHZvaWQKK2Nsa19tdXhf bm9fcmVwYXJlbnRfdGVzdF9leGl0KHN0cnVjdCBrdW5pdCAqdGVzdCkKK3sKKwlzdHJ1Y3QgY2xr X211bHRpcGxlX3BhcmVudF9jdHggKmN0eCA9IHRlc3QtPnByaXY7CisKKwljbGtfaHdfdW5yZWdp c3RlcigmY3R4LT5odyk7CisJY2xrX2h3X3VucmVnaXN0ZXIoJmN0eC0+cGFyZW50c19jdHhbMF0u aHcpOworCWNsa19od191bnJlZ2lzdGVyKCZjdHgtPnBhcmVudHNfY3R4WzFdLmh3KTsKK30KKwor LyoKKyAqIFRlc3QgdGhhdCBpZiB0aGUgd2UgaGF2ZSBhIG11eCB0aGF0IGNhbm5vdCBjaGFuZ2Ug cGFyZW50IGFuZCB3ZSBjYWxsCisgKiBjbGtfcm91bmRfcmF0ZSgpIG9uIGl0IHdpdGggYSByYXRl IHRoYXQgc2hvdWxkIGNhdXNlIGl0IHRvIGNoYW5nZQorICogcGFyZW50LCBpdCB3b24ndC4KKyAq Lworc3RhdGljIHZvaWQgY2xrX211eF9ub19yZXBhcmVudF9yb3VuZF9yYXRlKHN0cnVjdCBrdW5p dCAqdGVzdCkKK3sKKwlzdHJ1Y3QgY2xrX211bHRpcGxlX3BhcmVudF9jdHggKmN0eCA9IHRlc3Qt PnByaXY7CisJc3RydWN0IGNsa19odyAqaHcgPSAmY3R4LT5odzsKKwlzdHJ1Y3QgY2xrICpjbGsg PSBjbGtfaHdfZ2V0X2NsayhodywgTlVMTCk7CisJc3RydWN0IGNsayAqb3RoZXJfcGFyZW50LCAq cGFyZW50OworCXVuc2lnbmVkIGxvbmcgb3RoZXJfcGFyZW50X3JhdGU7CisJdW5zaWduZWQgbG9u ZyBwYXJlbnRfcmF0ZTsKKwlsb25nIHJvdW5kZWRfcmF0ZTsKKworCXBhcmVudCA9IGNsa19nZXRf cGFyZW50KGNsayk7CisJS1VOSVRfQVNTRVJUX1BUUl9ORSh0ZXN0LCBwYXJlbnQsIE5VTEwpOwor CisJcGFyZW50X3JhdGUgPSBjbGtfZ2V0X3JhdGUocGFyZW50KTsKKwlLVU5JVF9BU1NFUlRfR1Qo dGVzdCwgcGFyZW50X3JhdGUsIDApOworCisJb3RoZXJfcGFyZW50ID0gY2xrX2h3X2dldF9jbGso JmN0eC0+cGFyZW50c19jdHhbMV0uaHcsIE5VTEwpOworCUtVTklUX0FTU0VSVF9OT1RfRVJSX09S X05VTEwodGVzdCwgb3RoZXJfcGFyZW50KTsKKwlLVU5JVF9BU1NFUlRfRkFMU0UodGVzdCwgY2xr X2lzX21hdGNoKHBhcmVudCwgb3RoZXJfcGFyZW50KSk7CisKKwlvdGhlcl9wYXJlbnRfcmF0ZSA9 IGNsa19nZXRfcmF0ZShvdGhlcl9wYXJlbnQpOworCUtVTklUX0FTU0VSVF9HVCh0ZXN0LCBvdGhl cl9wYXJlbnRfcmF0ZSwgMCk7CisJY2xrX3B1dChvdGhlcl9wYXJlbnQpOworCisJcm91bmRlZF9y YXRlID0gY2xrX3JvdW5kX3JhdGUoY2xrLCBvdGhlcl9wYXJlbnRfcmF0ZSk7CisJS1VOSVRfQVNT RVJUX0dUKHRlc3QsIHJvdW5kZWRfcmF0ZSwgMCk7CisJS1VOSVRfRVhQRUNUX0VRKHRlc3QsIHJv dW5kZWRfcmF0ZSwgcGFyZW50X3JhdGUpOworCisJY2xrX3B1dChjbGspOworfQorCisvKgorICog VGVzdCB0aGF0IGlmIHRoZSB3ZSBoYXZlIGEgbXV4IHRoYXQgY2Fubm90IGNoYW5nZSBwYXJlbnQg YW5kIHdlIGNhbGwKKyAqIGNsa19zZXRfcmF0ZSgpIG9uIGl0IHdpdGggYSByYXRlIHRoYXQgc2hv dWxkIGNhdXNlIGl0IHRvIGNoYW5nZQorICogcGFyZW50LCBpdCB3b24ndC4KKyAqLworc3RhdGlj IHZvaWQgY2xrX211eF9ub19yZXBhcmVudF9zZXRfcmF0ZShzdHJ1Y3Qga3VuaXQgKnRlc3QpCit7 CisJc3RydWN0IGNsa19tdWx0aXBsZV9wYXJlbnRfY3R4ICpjdHggPSB0ZXN0LT5wcml2OworCXN0 cnVjdCBjbGtfaHcgKmh3ID0gJmN0eC0+aHc7CisJc3RydWN0IGNsayAqY2xrID0gY2xrX2h3X2dl dF9jbGsoaHcsIE5VTEwpOworCXN0cnVjdCBjbGsgKm90aGVyX3BhcmVudCwgKnBhcmVudDsKKwl1 bnNpZ25lZCBsb25nIG90aGVyX3BhcmVudF9yYXRlOworCXVuc2lnbmVkIGxvbmcgcGFyZW50X3Jh dGU7CisJdW5zaWduZWQgbG9uZyByYXRlOworCWludCByZXQ7CisKKwlwYXJlbnQgPSBjbGtfZ2V0 X3BhcmVudChjbGspOworCUtVTklUX0FTU0VSVF9QVFJfTkUodGVzdCwgcGFyZW50LCBOVUxMKTsK KworCXBhcmVudF9yYXRlID0gY2xrX2dldF9yYXRlKHBhcmVudCk7CisJS1VOSVRfQVNTRVJUX0dU KHRlc3QsIHBhcmVudF9yYXRlLCAwKTsKKworCW90aGVyX3BhcmVudCA9IGNsa19od19nZXRfY2xr KCZjdHgtPnBhcmVudHNfY3R4WzFdLmh3LCBOVUxMKTsKKwlLVU5JVF9BU1NFUlRfTk9UX0VSUl9P Ul9OVUxMKHRlc3QsIG90aGVyX3BhcmVudCk7CisJS1VOSVRfQVNTRVJUX0ZBTFNFKHRlc3QsIGNs a19pc19tYXRjaChwYXJlbnQsIG90aGVyX3BhcmVudCkpOworCisJb3RoZXJfcGFyZW50X3JhdGUg PSBjbGtfZ2V0X3JhdGUob3RoZXJfcGFyZW50KTsKKwlLVU5JVF9BU1NFUlRfR1QodGVzdCwgb3Ro ZXJfcGFyZW50X3JhdGUsIDApOworCWNsa19wdXQob3RoZXJfcGFyZW50KTsKKworCXJldCA9IGNs a19zZXRfcmF0ZShjbGssIG90aGVyX3BhcmVudF9yYXRlKTsKKwlLVU5JVF9BU1NFUlRfRVEodGVz dCwgcmV0LCAwKTsKKworCXJhdGUgPSBjbGtfZ2V0X3JhdGUoY2xrKTsKKwlLVU5JVF9BU1NFUlRf R1QodGVzdCwgcmF0ZSwgMCk7CisJS1VOSVRfRVhQRUNUX0VRKHRlc3QsIHJhdGUsIHBhcmVudF9y YXRlKTsKKworCWNsa19wdXQoY2xrKTsKK30KKworc3RhdGljIHN0cnVjdCBrdW5pdF9jYXNlIGNs a19tdXhfbm9fcmVwYXJlbnRfdGVzdF9jYXNlc1tdID0geworCUtVTklUX0NBU0UoY2xrX211eF9u b19yZXBhcmVudF9yb3VuZF9yYXRlKSwKKwlLVU5JVF9DQVNFKGNsa19tdXhfbm9fcmVwYXJlbnRf c2V0X3JhdGUpLAorCXt9Cit9OworCisvKgorICogVGVzdCBzdWl0ZSBmb3IgYSBjbG9jayBtdXgg dGhhdCBpc24ndCBhbGxvd2VkIHRvIGNoYW5nZSBwYXJlbnQsIHVzaW5nCisgKiB0aGUgY2xrX2h3 X2RldGVybWluZV9yYXRlX25vX3JlcGFyZW50KCkgaGVscGVyLgorICoKKyAqIFRoZXNlIHRlc3Rz IGV4ZXJjaXNlIHRoYXQgaGVscGVyLCBhbmQgdGhlIHByb3BlciBzZWxlY3Rpb24gb2YKKyAqIHJh dGVzIGFuZCBwYXJlbnRzLgorICovCitzdGF0aWMgc3RydWN0IGt1bml0X3N1aXRlIGNsa19tdXhf bm9fcmVwYXJlbnRfdGVzdF9zdWl0ZSA9IHsKKwkubmFtZSA9ICJjbGstbXV4LW5vLXJlcGFyZW50 IiwKKwkuaW5pdCA9IGNsa19tdXhfbm9fcmVwYXJlbnRfdGVzdF9pbml0LAorCS5leGl0ID0gY2xr X211eF9ub19yZXBhcmVudF90ZXN0X2V4aXQsCisJLnRlc3RfY2FzZXMgPSBjbGtfbXV4X25vX3Jl cGFyZW50X3Rlc3RfY2FzZXMsCit9OworCiBrdW5pdF90ZXN0X3N1aXRlcygKIAkmY2xrX2xlYWZf bXV4X3NldF9yYXRlX3BhcmVudF90ZXN0X3N1aXRlLAogCSZjbGtfdGVzdF9zdWl0ZSwKIAkmY2xr X211bHRpcGxlX3BhcmVudHNfbXV4X3Rlc3Rfc3VpdGUsCisJJmNsa19tdXhfbm9fcmVwYXJlbnRf dGVzdF9zdWl0ZSwKIAkmY2xrX211eF9ub3RpZmllcl90ZXN0X3N1aXRlLAogCSZjbGtfb3JwaGFu X3RyYW5zcGFyZW50X211bHRpcGxlX3BhcmVudF9tdXhfdGVzdF9zdWl0ZSwKIAkmY2xrX29ycGhh bl90cmFuc3BhcmVudF9zaW5nbGVfcGFyZW50X3Rlc3Rfc3VpdGUsCmRpZmYgLS1naXQgYS9pbmNs dWRlL2xpbnV4L2Nsay1wcm92aWRlci5oIGIvaW5jbHVkZS9saW51eC9jbGstcHJvdmlkZXIuaApp bmRleCAyOGZmNmYxYTZhZGEuLmY4ZjIyMGZiNWRhYiAxMDA2NDQKLS0tIGEvaW5jbHVkZS9saW51 eC9jbGstcHJvdmlkZXIuaAorKysgYi9pbmNsdWRlL2xpbnV4L2Nsay1wcm92aWRlci5oCkBAIC0x MzMzLDYgKzEzMzMsOCBAQCBpbnQgX19jbGtfbXV4X2RldGVybWluZV9yYXRlX2Nsb3Nlc3Qoc3Ry dWN0IGNsa19odyAqaHcsCiBpbnQgY2xrX211eF9kZXRlcm1pbmVfcmF0ZV9mbGFncyhzdHJ1Y3Qg Y2xrX2h3ICpodywKIAkJCQkgc3RydWN0IGNsa19yYXRlX3JlcXVlc3QgKnJlcSwKIAkJCQkgdW5z aWduZWQgbG9uZyBmbGFncyk7CitpbnQgY2xrX2h3X2RldGVybWluZV9yYXRlX25vX3JlcGFyZW50 KHN0cnVjdCBjbGtfaHcgKmh3LAorCQkJCSAgICAgIHN0cnVjdCBjbGtfcmF0ZV9yZXF1ZXN0ICpy ZXEpOwogdm9pZCBjbGtfaHdfcmVwYXJlbnQoc3RydWN0IGNsa19odyAqaHcsIHN0cnVjdCBjbGtf aHcgKm5ld19wYXJlbnQpOwogdm9pZCBjbGtfaHdfZ2V0X3JhdGVfcmFuZ2Uoc3RydWN0IGNsa19o dyAqaHcsIHVuc2lnbmVkIGxvbmcgKm1pbl9yYXRlLAogCQkJICAgdW5zaWduZWQgbG9uZyAqbWF4 X3JhdGUpOwoKLS0gCjIuNDAuMAoKCi0tIApsaW51eC1waHkgbWFpbGluZyBsaXN0CmxpbnV4LXBo eUBsaXN0cy5pbmZyYWRlYWQub3JnCmh0dHBzOi8vbGlzdHMuaW5mcmFkZWFkLm9yZy9tYWlsbWFu L2xpc3RpbmZvL2xpbnV4LXBoeQo= From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from wnew2-smtp.messagingengine.com (wnew2-smtp.messagingengine.com [64.147.123.27]) (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 DB20C156C6 for ; Fri, 5 May 2023 11:25:58 +0000 (UTC) Received: from compute6.internal (compute6.nyi.internal [10.202.2.47]) by mailnew.west.internal (Postfix) with ESMTP id CF5502B066B8; Fri, 5 May 2023 07:25:53 -0400 (EDT) Received: from mailfrontend1 ([10.202.2.162]) by compute6.internal (MEProxy); Fri, 05 May 2023 07:25:58 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=cerno.tech; h=cc :cc:content-transfer-encoding:content-type:content-type:date :date:from:from:in-reply-to:in-reply-to:message-id:mime-version :references:reply-to:sender:subject:subject:to:to; s=fm2; t= 1683285953; x=1683293153; bh=WU20FpUx77EC9SQ4SvyGsBOJEHNPQAGkitA hRG2bZ+8=; b=cgeM5GXMn3UxomTuwWA6AkOxgVn1PUeJmY+HSkE1TZA752i4fMf QlYTaJ3UBsrM+xmXXoB8aMPoNfu33v/+uNcOH6qdiut5C/giuLiiL+5xpPL9JQ3q KBZI2kK8gg4c7gD5R7CpKcY87dEyeTl7s1nF18OyeKxj9B28kPMuyI7bzaLQuG7F jUCWx54c1O0WZ7iMU4OguTOmfgUWmsnRtWbzh20WYFo3Z2hV6z0lK9Rpe9SA8+gk xun/BjXaV1djzqXT5STJvMBm9KjZTBCAJ3fnpgoAoMk4b34q1MzQLNEwCiR0sj6I Yfq0t+Rzah7rVMv1mCoZhd7NmbmoteVaanw== DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d= messagingengine.com; h=cc:cc:content-transfer-encoding :content-type:content-type:date:date:feedback-id:feedback-id :from:from:in-reply-to:in-reply-to:message-id:mime-version :references:reply-to:sender:subject:subject:to:to:x-me-proxy :x-me-proxy:x-me-sender:x-me-sender:x-sasl-enc; s=fm3; t= 1683285953; x=1683293153; bh=WU20FpUx77EC9SQ4SvyGsBOJEHNPQAGkitA hRG2bZ+8=; b=jr8lN2ghqcDZ5kqJHWWrVG+JVKxrGxFjiL2Fo6F+tO6khTu9uNC 3Vzfo/OsYMLD3RLfc+/5PSx3qtINZwp/2/Qs+vt62FUAIp8X+tN87wRyDj5pE/9y PJokTD1FNIRNQR0hzIJGElMJPY0E/L8AV0eT2rJj7nhin7Vj/nnbY7UhIGMzeYDx iZDx76QA1IsHnrUbb92BFyco9yHVZY5Uwf7/Tkjsuw9gRBiv+1/xFABEQxh5Q0cS HziRpz9berfkuczUH/qZ7+c14O98hfnbgHBn//enLqYX0/76S0yKkBeLnX8FTGaH oEkXYF8N3c35dQD5wyXVdIoY4aiurQAwgcA== X-ME-Sender: X-ME-Received: X-ME-Proxy-Cause: gggruggvucftvghtrhhoucdtuddrgedvhedrfeefvddggedtucetufdoteggodetrfdotf fvucfrrhhofhhilhgvmecuhfgrshhtofgrihhlpdfqfgfvpdfurfetoffkrfgpnffqhgen uceurghilhhouhhtmecufedttdenucesvcftvggtihhpihgvnhhtshculddquddttddmne cujfgurhephfffufggtgfgkfhfjgfvvefosehtkeertdertdejnecuhfhrohhmpeforgig ihhmvgcutfhiphgrrhguuceomhgrgihimhgvsegtvghrnhhordhtvggthheqnecuggftrf grthhtvghrnhepudduudfhveejteefgedvffdvvedvjedugedukeejhedtlefhffevtefh jeeltdevnecuvehluhhsthgvrhfuihiivgeptdenucfrrghrrghmpehmrghilhhfrhhomh epmhgrgihimhgvsegtvghrnhhordhtvggthh X-ME-Proxy: Feedback-ID: i8771445c:Fastmail Received: by mail.messagingengine.com (Postfix) with ESMTPA; Fri, 5 May 2023 07:25:51 -0400 (EDT) From: Maxime Ripard Date: Fri, 05 May 2023 13:25:06 +0200 Subject: [PATCH v4 04/68] clk: Introduce clk_hw_determine_rate_no_reparent() Precedence: bulk X-Mailing-List: linux-sunxi@lists.linux.dev List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: 8bit Message-Id: <20221018-clk-range-checks-fixes-v4-4-971d5077e7d2@cerno.tech> References: <20221018-clk-range-checks-fixes-v4-0-971d5077e7d2@cerno.tech> In-Reply-To: <20221018-clk-range-checks-fixes-v4-0-971d5077e7d2@cerno.tech> To: Michael Turquette , Stephen Boyd Cc: linux-clk@vger.kernel.org, Maxime Ripard , Abel Vesa , Alessandro Zummo , Alexandre Belloni , Alexandre Torgue , =?utf-8?q?Andreas_F=C3=A4rber?= , AngeloGioacchino Del Regno , Baolin Wang , Charles Keepax , Chen-Yu Tsai , Chen-Yu Tsai , Chunyan Zhang , Claudiu Beznea , Daniel Vetter , David Airlie , David Lechner , Dinh Nguyen , Fabio Estevam , Geert Uytterhoeven , Jaroslav Kysela , Jernej Skrabec , Jonathan Hunter , Kishon Vijay Abraham I , Liam Girdwood , Linus Walleij , Luca Ceresoli , Manivannan Sadhasivam , Mark Brown , Markus Schneider-Pargmann , Max Filippov , Maxime Coquelin , Mikko Perttunen , Miles Chen , Nicolas Ferre , Orson Zhai , Paul Cercueil , Peng Fan , Peter De Schrijver , Prashant Gaikwad , Richard Fitzgerald , Samuel Holland , Sascha Hauer , Sekhar Nori , Shawn Guo , Takashi Iwai , Thierry Reding , Ulf Hansson , Vinod Koul , dri-devel@lists.freedesktop.org, linux-actions@lists.infradead.org, linux-arm-kernel@lists.infradead.org, linux-mips@vger.kernel.org, linux-phy@lists.infradead.org, linux-renesas-soc@vger.kernel.org, linux-rtc@vger.kernel.org, linux-stm32@st-md-mailman.stormreply.com, linux-sunxi@lists.linux.dev, linux-tegra@vger.kernel.org, NXP Linux Team , patches@opensource.cirrus.com, Pengutronix Kernel Team X-Mailer: b4 0.12.2 X-Developer-Signature: v=1; a=openpgp-sha256; l=10829; i=maxime@cerno.tech; h=from:subject:message-id; bh=YBkKiWSHU6AfKueAcHZCOzbYZiY/0bHTLTOJ1X0UewY=; b=owGbwMvMwCX2+D1vfrpE4FHG02pJDCkhzxedUy9mc+d6kvbti+3SFwfvMnndXJS6hu1k/TrpDJGw on1pHaUsDGJcDLJiiiwxwuZL4k7Net3JxjcPZg4rE8gQBi5OAZjIMUdGhrc1IfwXRIW2N4U5T025te 74MuZT1+3CXxzLnmrrU8G66gwjw9XfZ8pdlhx7KvVmQf4Moc++3jnXPGXyivk3x50qOet1hBMA X-Developer-Key: i=maxime@cerno.tech; a=openpgp; fpr=BE5675C37E818C8B5764241C254BCFC56BF6CE8D From: Stephen Boyd Some clock drivers do not want to allow any reparenting on a given clock, but usually do so by not providing any determine_rate implementation. Whenever we call clk_round_rate() or clk_set_rate(), this leads to clk_core_can_round() returning false and thus the rest of the function either forwarding the rate request to its current parent if CLK_SET_RATE_PARENT is set, or just returning the current clock rate. This behaviour happens implicitly, and as we move forward to making a determine_rate implementation required for muxes, we need some way to explicitly opt-in for that behaviour. Fortunately, this is exactly what the clk_core_determine_rate_no_reparent() function is doing, so we can simply make it available to drivers. Cc: Abel Vesa Cc: Alessandro Zummo Cc: Alexandre Belloni Cc: Alexandre Torgue Cc: "Andreas Färber" Cc: AngeloGioacchino Del Regno Cc: Baolin Wang Cc: Charles Keepax Cc: Chen-Yu Tsai Cc: Chen-Yu Tsai Cc: Chunyan Zhang Cc: Claudiu Beznea Cc: Daniel Vetter Cc: David Airlie Cc: David Lechner Cc: Dinh Nguyen Cc: Fabio Estevam Cc: Geert Uytterhoeven Cc: Jaroslav Kysela Cc: Jernej Skrabec Cc: Jonathan Hunter Cc: Kishon Vijay Abraham I Cc: Liam Girdwood Cc: Linus Walleij Cc: Luca Ceresoli Cc: Manivannan Sadhasivam Cc: Mark Brown Cc: Markus Schneider-Pargmann Cc: Max Filippov Cc: Maxime Coquelin Cc: Mikko Perttunen Cc: Miles Chen Cc: Nicolas Ferre Cc: Orson Zhai Cc: Paul Cercueil Cc: Peng Fan Cc: Peter De Schrijver Cc: Prashant Gaikwad Cc: Richard Fitzgerald Cc: Samuel Holland Cc: Sascha Hauer Cc: Sekhar Nori Cc: Shawn Guo Cc: Takashi Iwai Cc: Thierry Reding Cc: Ulf Hansson Cc: Vinod Koul Cc: dri-devel@lists.freedesktop.org Cc: linux-actions@lists.infradead.org Cc: linux-arm-kernel@lists.infradead.org Cc: linux-mips@vger.kernel.org Cc: linux-phy@lists.infradead.org Cc: linux-renesas-soc@vger.kernel.org Cc: linux-rtc@vger.kernel.org Cc: linux-stm32@st-md-mailman.stormreply.com Cc: linux-sunxi@lists.linux.dev Cc: linux-tegra@vger.kernel.org Cc: NXP Linux Team Cc: patches@opensource.cirrus.com Cc: Pengutronix Kernel Team Signed-off-by: Stephen Boyd Signed-off-by: Maxime Ripard --- drivers/clk/clk.c | 18 +++++ drivers/clk/clk_test.c | 152 +++++++++++++++++++++++++++++++++++++++++++ include/linux/clk-provider.h | 2 + 3 files changed, 172 insertions(+) diff --git a/drivers/clk/clk.c b/drivers/clk/clk.c index f57f821a5e5a..5365595433c8 100644 --- a/drivers/clk/clk.c +++ b/drivers/clk/clk.c @@ -783,6 +783,24 @@ int __clk_mux_determine_rate_closest(struct clk_hw *hw, } EXPORT_SYMBOL_GPL(__clk_mux_determine_rate_closest); +/* + * clk_hw_determine_rate_no_reparent - clk_ops::determine_rate implementation for a clk that doesn't reparent + * @hw: mux type clk to determine rate on + * @req: rate request, also used to return preferred frequency + * + * Helper for finding best parent rate to provide a given frequency. + * This can be used directly as a determine_rate callback (e.g. for a + * mux), or from a more complex clock that may combine a mux with other + * operations. + * + * Returns: 0 on success, -EERROR value on error + */ +int clk_hw_determine_rate_no_reparent(struct clk_hw *hw, + struct clk_rate_request *req) +{ + return clk_core_determine_rate_no_reparent(hw, req); +} + /*** clk api ***/ static void clk_core_rate_unprotect(struct clk_core *core) diff --git a/drivers/clk/clk_test.c b/drivers/clk/clk_test.c index 2cb51153750d..b3ed3b0e4c31 100644 --- a/drivers/clk/clk_test.c +++ b/drivers/clk/clk_test.c @@ -141,6 +141,12 @@ static const struct clk_ops clk_multiple_parents_mux_ops = { .determine_rate = __clk_mux_determine_rate_closest, }; +static const struct clk_ops clk_multiple_parents_no_reparent_mux_ops = { + .determine_rate = clk_hw_determine_rate_no_reparent, + .get_parent = clk_multiple_parents_mux_get_parent, + .set_parent = clk_multiple_parents_mux_set_parent, +}; + static int clk_test_init_with_ops(struct kunit *test, const struct clk_ops *ops) { struct clk_dummy_context *ctx; @@ -2395,10 +2401,156 @@ static struct kunit_suite clk_mux_notifier_test_suite = { .test_cases = clk_mux_notifier_test_cases, }; +static int +clk_mux_no_reparent_test_init(struct kunit *test) +{ + struct clk_multiple_parent_ctx *ctx; + const char *parents[2] = { "parent-0", "parent-1"}; + int ret; + + ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL); + if (!ctx) + return -ENOMEM; + test->priv = ctx; + + ctx->parents_ctx[0].hw.init = CLK_HW_INIT_NO_PARENT("parent-0", + &clk_dummy_rate_ops, + 0); + ctx->parents_ctx[0].rate = DUMMY_CLOCK_RATE_1; + ret = clk_hw_register(NULL, &ctx->parents_ctx[0].hw); + if (ret) + return ret; + + ctx->parents_ctx[1].hw.init = CLK_HW_INIT_NO_PARENT("parent-1", + &clk_dummy_rate_ops, + 0); + ctx->parents_ctx[1].rate = DUMMY_CLOCK_RATE_2; + ret = clk_hw_register(NULL, &ctx->parents_ctx[1].hw); + if (ret) + return ret; + + ctx->current_parent = 0; + ctx->hw.init = CLK_HW_INIT_PARENTS("test-mux", parents, + &clk_multiple_parents_no_reparent_mux_ops, + 0); + ret = clk_hw_register(NULL, &ctx->hw); + if (ret) + return ret; + + return 0; +} + +static void +clk_mux_no_reparent_test_exit(struct kunit *test) +{ + struct clk_multiple_parent_ctx *ctx = test->priv; + + clk_hw_unregister(&ctx->hw); + clk_hw_unregister(&ctx->parents_ctx[0].hw); + clk_hw_unregister(&ctx->parents_ctx[1].hw); +} + +/* + * Test that if the we have a mux that cannot change parent and we call + * clk_round_rate() on it with a rate that should cause it to change + * parent, it won't. + */ +static void clk_mux_no_reparent_round_rate(struct kunit *test) +{ + struct clk_multiple_parent_ctx *ctx = test->priv; + struct clk_hw *hw = &ctx->hw; + struct clk *clk = clk_hw_get_clk(hw, NULL); + struct clk *other_parent, *parent; + unsigned long other_parent_rate; + unsigned long parent_rate; + long rounded_rate; + + parent = clk_get_parent(clk); + KUNIT_ASSERT_PTR_NE(test, parent, NULL); + + parent_rate = clk_get_rate(parent); + KUNIT_ASSERT_GT(test, parent_rate, 0); + + other_parent = clk_hw_get_clk(&ctx->parents_ctx[1].hw, NULL); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, other_parent); + KUNIT_ASSERT_FALSE(test, clk_is_match(parent, other_parent)); + + other_parent_rate = clk_get_rate(other_parent); + KUNIT_ASSERT_GT(test, other_parent_rate, 0); + clk_put(other_parent); + + rounded_rate = clk_round_rate(clk, other_parent_rate); + KUNIT_ASSERT_GT(test, rounded_rate, 0); + KUNIT_EXPECT_EQ(test, rounded_rate, parent_rate); + + clk_put(clk); +} + +/* + * Test that if the we have a mux that cannot change parent and we call + * clk_set_rate() on it with a rate that should cause it to change + * parent, it won't. + */ +static void clk_mux_no_reparent_set_rate(struct kunit *test) +{ + struct clk_multiple_parent_ctx *ctx = test->priv; + struct clk_hw *hw = &ctx->hw; + struct clk *clk = clk_hw_get_clk(hw, NULL); + struct clk *other_parent, *parent; + unsigned long other_parent_rate; + unsigned long parent_rate; + unsigned long rate; + int ret; + + parent = clk_get_parent(clk); + KUNIT_ASSERT_PTR_NE(test, parent, NULL); + + parent_rate = clk_get_rate(parent); + KUNIT_ASSERT_GT(test, parent_rate, 0); + + other_parent = clk_hw_get_clk(&ctx->parents_ctx[1].hw, NULL); + KUNIT_ASSERT_NOT_ERR_OR_NULL(test, other_parent); + KUNIT_ASSERT_FALSE(test, clk_is_match(parent, other_parent)); + + other_parent_rate = clk_get_rate(other_parent); + KUNIT_ASSERT_GT(test, other_parent_rate, 0); + clk_put(other_parent); + + ret = clk_set_rate(clk, other_parent_rate); + KUNIT_ASSERT_EQ(test, ret, 0); + + rate = clk_get_rate(clk); + KUNIT_ASSERT_GT(test, rate, 0); + KUNIT_EXPECT_EQ(test, rate, parent_rate); + + clk_put(clk); +} + +static struct kunit_case clk_mux_no_reparent_test_cases[] = { + KUNIT_CASE(clk_mux_no_reparent_round_rate), + KUNIT_CASE(clk_mux_no_reparent_set_rate), + {} +}; + +/* + * Test suite for a clock mux that isn't allowed to change parent, using + * the clk_hw_determine_rate_no_reparent() helper. + * + * These tests exercise that helper, and the proper selection of + * rates and parents. + */ +static struct kunit_suite clk_mux_no_reparent_test_suite = { + .name = "clk-mux-no-reparent", + .init = clk_mux_no_reparent_test_init, + .exit = clk_mux_no_reparent_test_exit, + .test_cases = clk_mux_no_reparent_test_cases, +}; + kunit_test_suites( &clk_leaf_mux_set_rate_parent_test_suite, &clk_test_suite, &clk_multiple_parents_mux_test_suite, + &clk_mux_no_reparent_test_suite, &clk_mux_notifier_test_suite, &clk_orphan_transparent_multiple_parent_mux_test_suite, &clk_orphan_transparent_single_parent_test_suite, diff --git a/include/linux/clk-provider.h b/include/linux/clk-provider.h index 28ff6f1a6ada..f8f220fb5dab 100644 --- a/include/linux/clk-provider.h +++ b/include/linux/clk-provider.h @@ -1333,6 +1333,8 @@ int __clk_mux_determine_rate_closest(struct clk_hw *hw, int clk_mux_determine_rate_flags(struct clk_hw *hw, struct clk_rate_request *req, unsigned long flags); +int clk_hw_determine_rate_no_reparent(struct clk_hw *hw, + struct clk_rate_request *req); void clk_hw_reparent(struct clk_hw *hw, struct clk_hw *new_parent); void clk_hw_get_rate_range(struct clk_hw *hw, unsigned long *min_rate, unsigned long *max_rate); -- 2.40.0