[v3,02/10] clk: Always clamp the rounded rate

Commit Message

Maxime Ripard Jan. 20, 2022, 2:34 p.m. UTC

The current core while setting the min and max rate properly in the
clk_request structure will not make sure that the requested rate is
within these boundaries, leaving it to each and every driver to make
sure it is.

Add a clamp call to make sure it's always done, and add a few unit tests
to make sure we don't have any regression there.

Signed-off-by: Maxime Ripard <[e-mail]>
---
 drivers/clk/clk-rate-test.c | 46 +++++++++++++++++++++++++++++++++++++
 drivers/clk/clk.c           |  2 ++
 2 files changed, 48 insertions(+)

Patch

diff --git a/drivers/clk/clk-rate-test.c b/drivers/clk/clk-rate-test.c
index f2d3df791b5a..a13b02702d20 100644
--- a/drivers/clk/clk-rate-test.c
+++ b/drivers/clk/clk-rate-test.c
@@ -198,6 +198,50 @@  static void clk_rate_range_test_set_range_invalid(struct kunit *test)
 	KUNIT_ASSERT_EQ(test, ret, -EINVAL);
 }
 
+/*
+ * Test that if our clock has some boundaries and we try to round a rate
+ * lower than the minimum, the returned rate will be within range.
+ */
+static void clk_rate_range_test_set_range_round_rate_lower(struct kunit *test)
+{
+	struct clk_dummy_rate_context *ctx = test->priv;
+	struct clk_hw *hw = &ctx->hw;
+	struct clk *clk = hw->clk;
+	long rate;
+	int ret;
+
+	ret = clk_set_rate_range(clk,
+				 DUMMY_CLOCK_RATE_1,
+				 DUMMY_CLOCK_RATE_2);
+	KUNIT_ASSERT_EQ(test, ret, 0);
+
+	rate = clk_round_rate(clk, DUMMY_CLOCK_RATE_1 - 1000);
+	KUNIT_ASSERT_FALSE(test, rate < 0);
+	KUNIT_ASSERT_EQ(test, rate, DUMMY_CLOCK_RATE_1);
+}
+
+/*
+ * Test that if our clock has some boundaries and we try to round a rate
+ * higher than the maximum, the returned rate will be within range.
+ */
+static void clk_rate_range_test_set_range_round_rate_higher(struct kunit *test)
+{
+	struct clk_dummy_rate_context *ctx = test->priv;
+	struct clk_hw *hw = &ctx->hw;
+	struct clk *clk = hw->clk;
+	long rate;
+	int ret;
+
+	ret = clk_set_rate_range(clk,
+				 DUMMY_CLOCK_RATE_1,
+				 DUMMY_CLOCK_RATE_2);
+	KUNIT_ASSERT_EQ(test, ret, 0);
+
+	rate = clk_round_rate(clk, DUMMY_CLOCK_RATE_2 + 1000);
+	KUNIT_ASSERT_FALSE(test, rate < 0);
+	KUNIT_ASSERT_EQ(test, rate, DUMMY_CLOCK_RATE_2);
+}
+
 /*
  * Test that if our clock has a rate lower than the minimum set by a
  * call to clk_set_rate_range(), the rate will be raised to match the
@@ -259,6 +303,8 @@  static void clk_rate_range_test_set_range_get_rate_lowered(struct kunit *test)
 static struct kunit_case clk_rate_range_test_cases[] = {
 	KUNIT_CASE(clk_rate_range_test_set_range),
 	KUNIT_CASE(clk_rate_range_test_set_range_invalid),
+	KUNIT_CASE(clk_rate_range_test_set_range_round_rate_lower),
+	KUNIT_CASE(clk_rate_range_test_set_range_round_rate_higher),
 	KUNIT_CASE(clk_rate_range_test_set_range_get_rate_raised),
 	KUNIT_CASE(clk_rate_range_test_set_range_get_rate_lowered),
 	{}
diff --git a/drivers/clk/clk.c b/drivers/clk/clk.c
index 8de6a22498e7..7bb5ae0fb688 100644
--- a/drivers/clk/clk.c
+++ b/drivers/clk/clk.c
@@ -1330,6 +1330,8 @@  static int clk_core_determine_round_nolock(struct clk_core *core,
 	if (!core)
 		return 0;
 
+	req->rate = clamp(req->rate, req->min_rate, req->max_rate);
+
 	/*
 	 * At this point, core protection will be disabled
 	 * - if the provider is not protected at all