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, 334 insertions, 0 deletions

diff --git a/target/linux/bcm27xx/patches-5.15/950-0846-clk-Set-req_rate-on-reparenting.patch b/target/linux/bcm27xx/patches-5.15/950-0846-clk-Set-req_rate-on-reparenting.patch
new file mode 100644
index 0000000000..32786521a9
--- /dev/null
+++ b/target/linux/bcm27xx/patches-5.15/950-0846-clk-Set-req_rate-on-reparenting.patch
@@ -0,0 +1,334 @@
+From 36595ef49aac284d386e1f9e8ac0910451ef40d6 Mon Sep 17 00:00:00 2001
+From: Maxime Ripard <maxime@cerno.tech>
+Date: Fri, 1 Apr 2022 15:26:46 +0200
+Subject: [PATCH] clk: Set req_rate on reparenting
+
+If a non-rate clock started by default with a parent that never
+registered, core->req_rate will be 0. The expectation is that whenever
+the parent will be registered, req_rate will be updated with the new
+value that has just been computed.
+
+However, if that clock is a mux, clk_set_parent() can also make that
+clock no longer orphan. In this case however, we never update req_rate.
+Let's make sure it's the case for the newly unorphan clock and all its
+children.
+
+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      |  18 ++++
+ drivers/clk/clk_test.c | 231 +++++++++++++++++++++++++++++++++++++++++
+ 2 files changed, 249 insertions(+)
+
+--- a/drivers/clk/clk.c
++++ b/drivers/clk/clk.c
+@@ -1758,6 +1758,23 @@ static void clk_core_update_orphan_statu
+ 		clk_core_update_orphan_status(child, is_orphan);
+ }
+ 
++/*
++ * Update the orphan rate and req_rate of @core and all its children.
++ */
++static void clk_core_update_orphan_child_rates(struct clk_core *core)
++{
++	struct clk_core *child;
++	unsigned long parent_rate = 0;
++
++	if (core->parent)
++		parent_rate = core->parent->rate;
++
++	core->rate = core->req_rate = clk_recalc(core, parent_rate);
++
++	hlist_for_each_entry(child, &core->children, child_node)
++		clk_core_update_orphan_child_rates(child);
++}
++
+ static void clk_reparent(struct clk_core *core, struct clk_core *new_parent)
+ {
+ 	bool was_orphan = core->orphan;
+@@ -1782,6 +1799,7 @@ static void clk_reparent(struct clk_core
+ 	}
+ 
+ 	core->parent = new_parent;
++	clk_core_update_orphan_child_rates(core);
+ }
+ 
+ static struct clk_core *__clk_set_parent_before(struct clk_core *core,
+--- a/drivers/clk/clk_test.c
++++ b/drivers/clk/clk_test.c
+@@ -577,6 +577,39 @@ clk_test_orphan_transparent_multiple_par
+ 
+ /*
+  * Test that, for a mux that started orphan but got switched to a valid
++ * parent, calling clk_drop_range() on the mux won't affect the parent
++ * rate.
++ */
++static void
++clk_test_orphan_transparent_multiple_parent_mux_set_parent_drop_range(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 parent_rate, new_parent_rate;
++	int ret;
++
++	parent = clk_hw_get_clk(&ctx->parents_ctx[1].hw, NULL);
++	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent);
++
++	parent_rate = clk_get_rate(parent);
++	KUNIT_ASSERT_GT(test, parent_rate, 0);
++
++	ret = clk_set_parent(clk, parent);
++	KUNIT_ASSERT_EQ(test, ret, 0);
++
++	ret = clk_drop_range(clk);
++	KUNIT_ASSERT_EQ(test, ret, 0);
++
++	new_parent_rate = clk_get_rate(clk);
++	KUNIT_ASSERT_GT(test, new_parent_rate, 0);
++	KUNIT_EXPECT_EQ(test, parent_rate, new_parent_rate);
++
++	clk_put(parent);
++}
++
++/*
++ * Test that, for a mux that started orphan but got switched to a valid
+  * parent, the rate of the mux and its new parent are consistent.
+  */
+ static void
+@@ -605,6 +638,39 @@ clk_test_orphan_transparent_multiple_par
+ 
+ /*
+  * Test that, for a mux that started orphan but got switched to a valid
++ * parent, calling clk_put() on the mux won't affect the parent rate.
++ */
++static void
++clk_test_orphan_transparent_multiple_parent_mux_set_parent_put(struct kunit *test)
++{
++	struct clk_multiple_parent_ctx *ctx = test->priv;
++	struct clk *clk, *parent;
++	unsigned long parent_rate, new_parent_rate;
++	int ret;
++
++	parent = clk_hw_get_clk(&ctx->parents_ctx[1].hw, NULL);
++	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent);
++
++	clk = clk_hw_get_clk(&ctx->hw, NULL);
++	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, clk);
++
++	parent_rate = clk_get_rate(parent);
++	KUNIT_ASSERT_GT(test, parent_rate, 0);
++
++	ret = clk_set_parent(clk, parent);
++	KUNIT_ASSERT_EQ(test, ret, 0);
++
++	clk_put(clk);
++
++	new_parent_rate = clk_get_rate(parent);
++	KUNIT_ASSERT_GT(test, new_parent_rate, 0);
++	KUNIT_EXPECT_EQ(test, parent_rate, new_parent_rate);
++
++	clk_put(parent);
++}
++
++/*
++ * Test that, for a mux that started orphan but got switched to a valid
+  * parent, calling clk_set_rate_range() will affect the parent state if
+  * its rate is out of range.
+  */
+@@ -635,6 +701,41 @@ clk_test_orphan_transparent_multiple_par
+ }
+ 
+ /*
++ * Test that, for a mux that started orphan but got switched to a valid
++ * parent, calling clk_set_rate_range() won't affect the parent state if
++ * its rate is within range.
++ */
++static void
++clk_test_orphan_transparent_multiple_parent_mux_set_parent_set_range_untouched(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 parent_rate, new_parent_rate;
++	int ret;
++
++	parent = clk_hw_get_clk(&ctx->parents_ctx[1].hw, NULL);
++	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent);
++
++	parent_rate = clk_get_rate(parent);
++	KUNIT_ASSERT_GT(test, parent_rate, 0);
++
++	ret = clk_set_parent(clk, parent);
++	KUNIT_ASSERT_EQ(test, ret, 0);
++
++	ret = clk_set_rate_range(clk,
++				 DUMMY_CLOCK_INIT_RATE - 1000,
++				 DUMMY_CLOCK_INIT_RATE + 1000);
++	KUNIT_ASSERT_EQ(test, ret, 0);
++
++	new_parent_rate = clk_get_rate(parent);
++	KUNIT_ASSERT_GT(test, new_parent_rate, 0);
++	KUNIT_EXPECT_EQ(test, parent_rate, new_parent_rate);
++
++	clk_put(parent);
++}
++
++/*
+  * 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.
+@@ -660,8 +761,11 @@ clk_test_orphan_transparent_multiple_par
+ 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),
++	KUNIT_CASE(clk_test_orphan_transparent_multiple_parent_mux_set_parent_drop_range),
+ 	KUNIT_CASE(clk_test_orphan_transparent_multiple_parent_mux_set_parent_get_rate),
++	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_round_rate),
+ 	{}
+ };
+@@ -946,6 +1050,132 @@ static struct kunit_suite clk_orphan_tra
+ 	.test_cases = clk_orphan_transparent_single_parent_mux_test_cases,
+ };
+ 
++struct clk_single_parent_two_lvl_ctx {
++	struct clk_dummy_context parent_parent_ctx;
++	struct clk_dummy_context parent_ctx;
++	struct clk_hw hw;
++};
++
++static int
++clk_orphan_two_level_root_last_test_init(struct kunit *test)
++{
++	struct clk_single_parent_two_lvl_ctx *ctx;
++	int ret;
++
++	ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
++	if (!ctx)
++		return -ENOMEM;
++	test->priv = ctx;
++
++	ctx->parent_ctx.hw.init =
++		CLK_HW_INIT("intermediate-parent",
++			    "root-parent",
++			    &clk_dummy_single_parent_ops,
++			    CLK_SET_RATE_PARENT);
++	ret = clk_hw_register(NULL, &ctx->parent_ctx.hw);
++	if (ret)
++		return ret;
++
++	ctx->hw.init =
++		CLK_HW_INIT("test-clk", "intermediate-parent",
++			    &clk_dummy_single_parent_ops,
++			    CLK_SET_RATE_PARENT);
++	ret = clk_hw_register(NULL, &ctx->hw);
++	if (ret)
++		return ret;
++
++	ctx->parent_parent_ctx.rate = DUMMY_CLOCK_INIT_RATE;
++	ctx->parent_parent_ctx.hw.init =
++		CLK_HW_INIT_NO_PARENT("root-parent",
++				      &clk_dummy_rate_ops,
++				      0);
++	ret = clk_hw_register(NULL, &ctx->parent_parent_ctx.hw);
++	if (ret)
++		return ret;
++
++	return 0;
++}
++
++static void
++clk_orphan_two_level_root_last_test_exit(struct kunit *test)
++{
++	struct clk_single_parent_two_lvl_ctx *ctx = test->priv;
++
++	clk_hw_unregister(&ctx->hw);
++	clk_hw_unregister(&ctx->parent_ctx.hw);
++	clk_hw_unregister(&ctx->parent_parent_ctx.hw);
++}
++
++/*
++ * Test that, for a clock whose parent used to be orphan, clk_get_rate()
++ * will return the proper rate.
++ */
++static void
++clk_orphan_two_level_root_last_test_get_rate(struct kunit *test)
++{
++	struct clk_single_parent_two_lvl_ctx *ctx = test->priv;
++	struct clk_hw *hw = &ctx->hw;
++	struct clk *clk = hw->clk;
++	unsigned long rate;
++
++	rate = clk_get_rate(clk);
++	KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_INIT_RATE);
++}
++
++/*
++ * Test that, for a clock whose parent used to be orphan,
++ * clk_set_rate_range() won't affect its rate if it is already within
++ * range.
++ *
++ * See (for Exynos 4210):
++ * https://lore.kernel.org/linux-clk/366a0232-bb4a-c357-6aa8-636e398e05eb@samsung.com/
++ */
++static void
++clk_orphan_two_level_root_last_test_set_range(struct kunit *test)
++{
++	struct clk_single_parent_two_lvl_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_INIT_RATE - 1000,
++				 DUMMY_CLOCK_INIT_RATE + 1000);
++	KUNIT_ASSERT_EQ(test, ret, 0);
++
++	rate = clk_get_rate(clk);
++	KUNIT_ASSERT_GT(test, rate, 0);
++	KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_INIT_RATE);
++}
++
++static struct kunit_case
++clk_orphan_two_level_root_last_test_cases[] = {
++	KUNIT_CASE(clk_orphan_two_level_root_last_test_get_rate),
++	KUNIT_CASE(clk_orphan_two_level_root_last_test_set_range),
++	{}
++};
++
++/*
++ * Test suite for a basic, transparent, clock with a parent that is also
++ * such a clock. The parent's parent is registered last, while the
++ * parent and its child are registered in that order. The intermediate
++ * and leaf clocks will thus be orphan when registered, but the leaf
++ * clock itself will always have its parent and will never be
++ * reparented. Indeed, it's only orphan because its parent is.
++ *
++ * These tests are supposed to exercise the behaviour of the consumer
++ * API when dealing with an orphan clock, and how we deal with the
++ * transition to a valid parent.
++ */
++static struct kunit_suite
++clk_orphan_two_level_root_last_test_suite = {
++	.name = "clk-orphan-two-level-root-last-test",
++	.init = clk_orphan_two_level_root_last_test_init,
++	.exit = clk_orphan_two_level_root_last_test_exit,
++	.test_cases = clk_orphan_two_level_root_last_test_cases,
++};
++
+ /*
+  * Test that clk_set_rate_range won't return an error for a valid range
+  * and that it will make sure the rate of the clock is within the
+@@ -1629,6 +1859,7 @@ kunit_test_suites(
+ 	&clk_multiple_parents_mux_test_suite,
+ 	&clk_orphan_transparent_multiple_parent_mux_test_suite,
+ 	&clk_orphan_transparent_single_parent_test_suite,
++	&clk_orphan_two_level_root_last_test_suite,
+ 	&clk_range_test_suite,
+ 	&clk_range_maximize_test_suite,
+ 	&clk_range_minimize_test_suite,