bcm27xx: add support for linux v5.15

Build system: x86_64
Build-tested: bcm2708, bcm2709, bcm2710, bcm2711
Run-tested: bcm2708/RPiB+, bcm2709/RPi3B, bcm2710/RPi3B, bcm2711/RPi4B

Signed-off-by: Marty Jones <mj8263788@gmail.com>
Signed-off-by: Álvaro Fernández Rojas <noltari@gmail.com>

1 files changed, 123 insertions, 0 deletions

diff --git a/target/linux/bcm27xx/patches-5.15/950-0847-clk-Skip-set_rate_range-if-our-clock-is-orphan.patch b/target/linux/bcm27xx/patches-5.15/950-0847-clk-Skip-set_rate_range-if-our-clock-is-orphan.patch
new file mode 100644
index 0000000000..4244ad378f
--- /dev/null
+++ b/target/linux/bcm27xx/patches-5.15/950-0847-clk-Skip-set_rate_range-if-our-clock-is-orphan.patch
@@ -0,0 +1,123 @@
+From 655e66b0add0aba16e84587dbb939f8ddce612b0 Mon Sep 17 00:00:00 2001
+From: Maxime Ripard <maxime@cerno.tech>
+Date: Fri, 1 Apr 2022 15:27:09 +0200
+Subject: [PATCH] clk: Skip set_rate_range if our clock is orphan
+
+clk_set_rate_range will now force a clk_set_rate() call to
+core->req_rate. However, if our clock is orphan, req_rate will be 0 and
+we will thus end up calling a set_rate to 0 on potentially all that
+clock subtree.
+
+This can be fairly invasive and result in poor decisions. In such a
+case, let's just store the new range but bail out and skip the set_rate.
+
+When that clock is no longer orphan though, we should be enforcing the
+new range but we don't. Let's add a skipped test to make sure we don't
+forget about that corner case.
+
+Tested-by: Alexander Stein <alexander.stein@ew.tq-group.com> # imx8mp
+Tested-by: Marek Szyprowski <m.szyprowski@samsung.com> # exynos4210, meson g12b
+Signed-off-by: Maxime Ripard <maxime@cerno.tech>
+---
+ drivers/clk/clk.c      |  6 +++++
+ drivers/clk/clk_test.c | 59 ++++++++++++++++++++++++++++++++++++++++++
+ 2 files changed, 65 insertions(+)
+
+--- a/drivers/clk/clk.c
++++ b/drivers/clk/clk.c
+@@ -2388,6 +2388,12 @@ static int clk_set_rate_range_nolock(str
+ 	if (clk->core->flags & CLK_GET_RATE_NOCACHE)
+ 		rate = clk_core_get_rate_recalc(clk->core);
+ 
++	if (clk->core->orphan && !rate) {
++		pr_warn("%s: clk %s: Clock is orphan and doesn't have a rate!\n",
++			__func__, clk->core->name);
++		goto out;
++	}
++
+ 	/*
+ 	 * Since the boundaries have been changed, let's give the
+ 	 * opportunity to the provider to adjust the clock rate based on
+--- a/drivers/clk/clk_test.c
++++ b/drivers/clk/clk_test.c
+@@ -737,6 +737,26 @@ clk_test_orphan_transparent_multiple_par
+ 
+ /*
+  * Test that, for a mux whose current parent hasn't been registered yet,
++ * calling clk_set_rate_range() will succeed but won't affect its rate.
++ */
++static void
++clk_test_orphan_transparent_multiple_parent_mux_set_range_get_rate(struct kunit *test)
++{
++	struct clk_multiple_parent_ctx *ctx = test->priv;
++	struct clk_hw *hw = &ctx->hw;
++	struct clk *clk = hw->clk;
++	unsigned 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_get_rate(clk);
++	KUNIT_EXPECT_EQ(test, rate, 0);
++}
++
++/*
++ * Test that, for a mux whose current parent hasn't been registered yet,
+  * calling clk_set_rate_range() will succeed, and will be taken into
+  * account when rounding a rate.
+  */
+@@ -758,6 +778,43 @@ clk_test_orphan_transparent_multiple_par
+ 	KUNIT_EXPECT_LE(test, rate, DUMMY_CLOCK_RATE_2);
+ }
+ 
++/*
++ * Test that, for a mux that started orphan, was assigned and rate and
++ * then got switched to a valid parent, its rate is eventually within
++ * range.
++ *
++ * FIXME: Even though we update the rate as part of clk_set_parent(), we
++ * don't evaluate whether that new rate is within range and needs to be
++ * adjusted.
++ */
++static void
++clk_test_orphan_transparent_multiple_parent_mux_set_range_set_parent_get_rate(struct kunit *test)
++{
++	struct clk_multiple_parent_ctx *ctx = test->priv;
++	struct clk_hw *hw = &ctx->hw;
++	struct clk *clk = hw->clk, *parent;
++	unsigned long rate;
++	int ret;
++
++	kunit_skip(test, "This needs to be fixed in the core.");
++
++	parent = clk_hw_get_clk(&ctx->parents_ctx[1].hw, NULL);
++	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent);
++
++	ret = clk_set_rate_range(clk, DUMMY_CLOCK_RATE_1, DUMMY_CLOCK_RATE_2);
++	KUNIT_ASSERT_EQ(test, ret, 0);
++
++	ret = clk_set_parent(clk, parent);
++	KUNIT_ASSERT_EQ(test, ret, 0);
++
++	rate = clk_get_rate(clk);
++	KUNIT_ASSERT_GT(test, rate, 0);
++	KUNIT_EXPECT_GE(test, rate, DUMMY_CLOCK_RATE_1);
++	KUNIT_EXPECT_LE(test, rate, DUMMY_CLOCK_RATE_2);
++
++	clk_put(parent);
++}
++
+ static struct kunit_case clk_orphan_transparent_multiple_parent_mux_test_cases[] = {
+ 	KUNIT_CASE(clk_test_orphan_transparent_multiple_parent_mux_get_parent),
+ 	KUNIT_CASE(clk_test_orphan_transparent_multiple_parent_mux_set_parent),
+@@ -766,7 +823,9 @@ static struct kunit_case clk_orphan_tran
+ 	KUNIT_CASE(clk_test_orphan_transparent_multiple_parent_mux_set_parent_put),
+ 	KUNIT_CASE(clk_test_orphan_transparent_multiple_parent_mux_set_parent_set_range_modified),
+ 	KUNIT_CASE(clk_test_orphan_transparent_multiple_parent_mux_set_parent_set_range_untouched),
++	KUNIT_CASE(clk_test_orphan_transparent_multiple_parent_mux_set_range_get_rate),
+ 	KUNIT_CASE(clk_test_orphan_transparent_multiple_parent_mux_set_range_round_rate),
++	KUNIT_CASE(clk_test_orphan_transparent_multiple_parent_mux_set_range_set_parent_get_rate),
+ 	{}
+ };
+