1	// SPDX-License-Identifier: GPL-2.0
2	/*
3	* Kunit test for clk rate management
4	*/
5	#include <linux/clk.h>
6	#include <linux/clk-provider.h>
7
8	/* Needed for clk_hw_get_clk() */
9	#include "clk.h"
10
11	#include <kunit/test.h>
12
13	static const struct clk_ops empty_clk_ops = { };
14
15	#define DUMMY_CLOCK_INIT_RATE (42 * 1000 * 1000)
16	#define DUMMY_CLOCK_RATE_1 (142 * 1000 * 1000)
17	#define DUMMY_CLOCK_RATE_2 (242 * 1000 * 1000)
18
19	struct clk_dummy_context {
20	struct clk_hw hw;
21	unsigned long rate;
22	};
23
24	static unsigned long clk_dummy_recalc_rate(struct clk_hw *hw,
25	unsigned long parent_rate)
26	{
27	struct clk_dummy_context *ctx =
28	container_of(hw, struct clk_dummy_context, hw);
29
30	return ctx->rate;
31	}
32
33	static int clk_dummy_determine_rate(struct clk_hw *hw,
34	struct clk_rate_request *req)
35	{
36	/* Just return the same rate without modifying it */
37	return 0;
38	}
39
40	static int clk_dummy_maximize_rate(struct clk_hw *hw,
41	struct clk_rate_request *req)
42	{
43	/*
44	* If there's a maximum set, always run the clock at the maximum
45	* allowed.
46	*/
47	if (req->max_rate < ULONG_MAX)
48	req->rate = req->max_rate;
49
50	return 0;
51	}
52
53	static int clk_dummy_minimize_rate(struct clk_hw *hw,
54	struct clk_rate_request *req)
55	{
56	/*
57	* If there's a minimum set, always run the clock at the minimum
58	* allowed.
59	*/
60	if (req->min_rate > 0)
61	req->rate = req->min_rate;
62
63	return 0;
64	}
65
66	static int clk_dummy_set_rate(struct clk_hw *hw,
67	unsigned long rate,
68	unsigned long parent_rate)
69	{
70	struct clk_dummy_context *ctx =
71	container_of(hw, struct clk_dummy_context, hw);
72
73	ctx->rate = rate;
74	return 0;
75	}
76
77	static int clk_dummy_single_set_parent(struct clk_hw *hw, u8 index)
78	{
79	if (index >= clk_hw_get_num_parents(hw))
80	return -EINVAL;
81
82	return 0;
83	}
84
85	static u8 clk_dummy_single_get_parent(struct clk_hw *hw)
86	{
87	return 0;
88	}
89
90	static const struct clk_ops clk_dummy_rate_ops = {
91	.recalc_rate = clk_dummy_recalc_rate,
92	.determine_rate = clk_dummy_determine_rate,
93	.set_rate = clk_dummy_set_rate,
94	};
95
96	static const struct clk_ops clk_dummy_maximize_rate_ops = {
97	.recalc_rate = clk_dummy_recalc_rate,
98	.determine_rate = clk_dummy_maximize_rate,
99	.set_rate = clk_dummy_set_rate,
100	};
101
102	static const struct clk_ops clk_dummy_minimize_rate_ops = {
103	.recalc_rate = clk_dummy_recalc_rate,
104	.determine_rate = clk_dummy_minimize_rate,
105	.set_rate = clk_dummy_set_rate,
106	};
107
108	static const struct clk_ops clk_dummy_single_parent_ops = {
109	/*
110	* FIXME: Even though we should probably be able to use
111	* __clk_mux_determine_rate() here, if we use it and call
112	* clk_round_rate() or clk_set_rate() with a rate lower than
113	* what all the parents can provide, it will return -EINVAL.
114	*
115	* This is due to the fact that it has the undocumented
116	* behaviour to always pick up the closest rate higher than the
117	* requested rate. If we get something lower, it thus considers
118	* that it's not acceptable and will return an error.
119	*
120	* It's somewhat inconsistent and creates a weird threshold
121	* between rates above the parent rate which would be rounded to
122	* what the parent can provide, but rates below will simply
123	* return an error.
124	*/
125	.determine_rate = __clk_mux_determine_rate_closest,
126	.set_parent = clk_dummy_single_set_parent,
127	.get_parent = clk_dummy_single_get_parent,
128	};
129
130	struct clk_multiple_parent_ctx {
131	struct clk_dummy_context parents_ctx[2];
132	struct clk_hw hw;
133	u8 current_parent;
134	};
135
136	static int clk_multiple_parents_mux_set_parent(struct clk_hw *hw, u8 index)
137	{
138	struct clk_multiple_parent_ctx *ctx =
139	container_of(hw, struct clk_multiple_parent_ctx, hw);
140
141	if (index >= clk_hw_get_num_parents(hw))
142	return -EINVAL;
143
144	ctx->current_parent = index;
145
146	return 0;
147	}
148
149	static u8 clk_multiple_parents_mux_get_parent(struct clk_hw *hw)
150	{
151	struct clk_multiple_parent_ctx *ctx =
152	container_of(hw, struct clk_multiple_parent_ctx, hw);
153
154	return ctx->current_parent;
155	}
156
157	static const struct clk_ops clk_multiple_parents_mux_ops = {
158	.get_parent = clk_multiple_parents_mux_get_parent,
159	.set_parent = clk_multiple_parents_mux_set_parent,
160	.determine_rate = __clk_mux_determine_rate_closest,
161	};
162
163	static const struct clk_ops clk_multiple_parents_no_reparent_mux_ops = {
164	.determine_rate = clk_hw_determine_rate_no_reparent,
165	.get_parent = clk_multiple_parents_mux_get_parent,
166	.set_parent = clk_multiple_parents_mux_set_parent,
167	};
168
169	static int clk_test_init_with_ops(struct kunit *test, const struct clk_ops *ops)
170	{
171	struct clk_dummy_context *ctx;
172	struct clk_init_data init = { };
173	int ret;
174
175	ctx = kunit_kzalloc(test, size: sizeof(*ctx), GFP_KERNEL);
176	if (!ctx)
177	return -ENOMEM;
178	ctx->rate = DUMMY_CLOCK_INIT_RATE;
179	test->priv = ctx;
180
181	init.name = "test_dummy_rate";
182	init.ops = ops;
183	ctx->hw.init = &init;
184
185	ret = clk_hw_register(NULL, hw: &ctx->hw);
186	if (ret)
187	return ret;
188
189	return 0;
190	}
191
192	static int clk_test_init(struct kunit *test)
193	{
194	return clk_test_init_with_ops(test, ops: &clk_dummy_rate_ops);
195	}
196
197	static int clk_maximize_test_init(struct kunit *test)
198	{
199	return clk_test_init_with_ops(test, ops: &clk_dummy_maximize_rate_ops);
200	}
201
202	static int clk_minimize_test_init(struct kunit *test)
203	{
204	return clk_test_init_with_ops(test, ops: &clk_dummy_minimize_rate_ops);
205	}
206
207	static void clk_test_exit(struct kunit *test)
208	{
209	struct clk_dummy_context *ctx = test->priv;
210
211	clk_hw_unregister(hw: &ctx->hw);
212	}
213
214	/*
215	* Test that the actual rate matches what is returned by clk_get_rate()
216	*/
217	static void clk_test_get_rate(struct kunit *test)
218	{
219	struct clk_dummy_context *ctx = test->priv;
220	struct clk_hw *hw = &ctx->hw;
221	struct clk *clk = clk_hw_get_clk(hw, NULL);
222	unsigned long rate;
223
224	rate = clk_get_rate(clk);
225	KUNIT_ASSERT_GT(test, rate, 0);
226	KUNIT_EXPECT_EQ(test, rate, ctx->rate);
227
228	clk_put(clk);
229	}
230
231	/*
232	* Test that, after a call to clk_set_rate(), the rate returned by
233	* clk_get_rate() matches.
234	*
235	* This assumes that clk_ops.determine_rate or clk_ops.round_rate won't
236	* modify the requested rate, which is our case in clk_dummy_rate_ops.
237	*/
238	static void clk_test_set_get_rate(struct kunit *test)
239	{
240	struct clk_dummy_context *ctx = test->priv;
241	struct clk_hw *hw = &ctx->hw;
242	struct clk *clk = clk_hw_get_clk(hw, NULL);
243	unsigned long rate;
244
245	KUNIT_ASSERT_EQ(test,
246	clk_set_rate(clk, DUMMY_CLOCK_RATE_1),
247	0);
248
249	rate = clk_get_rate(clk);
250	KUNIT_ASSERT_GT(test, rate, 0);
251	KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_1);
252
253	clk_put(clk);
254	}
255
256	/*
257	* Test that, after several calls to clk_set_rate(), the rate returned
258	* by clk_get_rate() matches the last one.
259	*
260	* This assumes that clk_ops.determine_rate or clk_ops.round_rate won't
261	* modify the requested rate, which is our case in clk_dummy_rate_ops.
262	*/
263	static void clk_test_set_set_get_rate(struct kunit *test)
264	{
265	struct clk_dummy_context *ctx = test->priv;
266	struct clk_hw *hw = &ctx->hw;
267	struct clk *clk = clk_hw_get_clk(hw, NULL);
268	unsigned long rate;
269
270	KUNIT_ASSERT_EQ(test,
271	clk_set_rate(clk, DUMMY_CLOCK_RATE_1),
272	0);
273
274	KUNIT_ASSERT_EQ(test,
275	clk_set_rate(clk, DUMMY_CLOCK_RATE_2),
276	0);
277
278	rate = clk_get_rate(clk);
279	KUNIT_ASSERT_GT(test, rate, 0);
280	KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_2);
281
282	clk_put(clk);
283	}
284
285	/*
286	* Test that clk_round_rate and clk_set_rate are consitent and will
287	* return the same frequency.
288	*/
289	static void clk_test_round_set_get_rate(struct kunit *test)
290	{
291	struct clk_dummy_context *ctx = test->priv;
292	struct clk_hw *hw = &ctx->hw;
293	struct clk *clk = clk_hw_get_clk(hw, NULL);
294	unsigned long set_rate;
295	long rounded_rate;
296
297	rounded_rate = clk_round_rate(clk, DUMMY_CLOCK_RATE_1);
298	KUNIT_ASSERT_GT(test, rounded_rate, 0);
299	KUNIT_EXPECT_EQ(test, rounded_rate, DUMMY_CLOCK_RATE_1);
300
301	KUNIT_ASSERT_EQ(test,
302	clk_set_rate(clk, DUMMY_CLOCK_RATE_1),
303	0);
304
305	set_rate = clk_get_rate(clk);
306	KUNIT_ASSERT_GT(test, set_rate, 0);
307	KUNIT_EXPECT_EQ(test, rounded_rate, set_rate);
308
309	clk_put(clk);
310	}
311
312	static struct kunit_case clk_test_cases[] = {
313	KUNIT_CASE(clk_test_get_rate),
314	KUNIT_CASE(clk_test_set_get_rate),
315	KUNIT_CASE(clk_test_set_set_get_rate),
316	KUNIT_CASE(clk_test_round_set_get_rate),
317	{}
318	};
319
320	/*
321	* Test suite for a basic rate clock, without any parent.
322	*
323	* These tests exercise the rate API with simple scenarios
324	*/
325	static struct kunit_suite clk_test_suite = {
326	.name = "clk-test",
327	.init = clk_test_init,
328	.exit = clk_test_exit,
329	.test_cases = clk_test_cases,
330	};
331
332	static int clk_uncached_test_init(struct kunit *test)
333	{
334	struct clk_dummy_context *ctx;
335	int ret;
336
337	ctx = kunit_kzalloc(test, size: sizeof(*ctx), GFP_KERNEL);
338	if (!ctx)
339	return -ENOMEM;
340	test->priv = ctx;
341
342	ctx->rate = DUMMY_CLOCK_INIT_RATE;
343	ctx->hw.init = CLK_HW_INIT_NO_PARENT("test-clk",
344	&clk_dummy_rate_ops,
345	CLK_GET_RATE_NOCACHE);
346
347	ret = clk_hw_register(NULL, hw: &ctx->hw);
348	if (ret)
349	return ret;
350
351	return 0;
352	}
353
354	/*
355	* Test that for an uncached clock, the clock framework doesn't cache
356	* the rate and clk_get_rate() will return the underlying clock rate
357	* even if it changed.
358	*/
359	static void clk_test_uncached_get_rate(struct kunit *test)
360	{
361	struct clk_dummy_context *ctx = test->priv;
362	struct clk_hw *hw = &ctx->hw;
363	struct clk *clk = clk_hw_get_clk(hw, NULL);
364	unsigned long rate;
365
366	rate = clk_get_rate(clk);
367	KUNIT_ASSERT_GT(test, rate, 0);
368	KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_INIT_RATE);
369
370	/* We change the rate behind the clock framework's back */
371	ctx->rate = DUMMY_CLOCK_RATE_1;
372	rate = clk_get_rate(clk);
373	KUNIT_ASSERT_GT(test, rate, 0);
374	KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_1);
375
376	clk_put(clk);
377	}
378
379	/*
380	* Test that for an uncached clock, clk_set_rate_range() will work
381	* properly if the rate hasn't changed.
382	*/
383	static void clk_test_uncached_set_range(struct kunit *test)
384	{
385	struct clk_dummy_context *ctx = test->priv;
386	struct clk_hw *hw = &ctx->hw;
387	struct clk *clk = clk_hw_get_clk(hw, NULL);
388	unsigned long rate;
389
390	KUNIT_ASSERT_EQ(test,
391	clk_set_rate_range(clk,
392	DUMMY_CLOCK_RATE_1,
393	DUMMY_CLOCK_RATE_2),
394	0);
395
396	rate = clk_get_rate(clk);
397	KUNIT_ASSERT_GT(test, rate, 0);
398	KUNIT_EXPECT_GE(test, rate, DUMMY_CLOCK_RATE_1);
399	KUNIT_EXPECT_LE(test, rate, DUMMY_CLOCK_RATE_2);
400
401	clk_put(clk);
402	}
403
404	/*
405	* Test that for an uncached clock, clk_set_rate_range() will work
406	* properly if the rate has changed in hardware.
407	*
408	* In this case, it means that if the rate wasn't initially in the range
409	* we're trying to set, but got changed at some point into the range
410	* without the kernel knowing about it, its rate shouldn't be affected.
411	*/
412	static void clk_test_uncached_updated_rate_set_range(struct kunit *test)
413	{
414	struct clk_dummy_context *ctx = test->priv;
415	struct clk_hw *hw = &ctx->hw;
416	struct clk *clk = clk_hw_get_clk(hw, NULL);
417	unsigned long rate;
418
419	/* We change the rate behind the clock framework's back */
420	ctx->rate = DUMMY_CLOCK_RATE_1 + 1000;
421	KUNIT_ASSERT_EQ(test,
422	clk_set_rate_range(clk,
423	DUMMY_CLOCK_RATE_1,
424	DUMMY_CLOCK_RATE_2),
425	0);
426
427	rate = clk_get_rate(clk);
428	KUNIT_ASSERT_GT(test, rate, 0);
429	KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_1 + 1000);
430
431	clk_put(clk);
432	}
433
434	static struct kunit_case clk_uncached_test_cases[] = {
435	KUNIT_CASE(clk_test_uncached_get_rate),
436	KUNIT_CASE(clk_test_uncached_set_range),
437	KUNIT_CASE(clk_test_uncached_updated_rate_set_range),
438	{}
439	};
440
441	/*
442	* Test suite for a basic, uncached, rate clock, without any parent.
443	*
444	* These tests exercise the rate API with simple scenarios
445	*/
446	static struct kunit_suite clk_uncached_test_suite = {
447	.name = "clk-uncached-test",
448	.init = clk_uncached_test_init,
449	.exit = clk_test_exit,
450	.test_cases = clk_uncached_test_cases,
451	};
452
453	static int
454	clk_multiple_parents_mux_test_init(struct kunit *test)
455	{
456	struct clk_multiple_parent_ctx *ctx;
457	const char *parents[2] = { "parent-0", "parent-1"};
458	int ret;
459
460	ctx = kunit_kzalloc(test, size: sizeof(*ctx), GFP_KERNEL);
461	if (!ctx)
462	return -ENOMEM;
463	test->priv = ctx;
464
465	ctx->parents_ctx[0].hw.init = CLK_HW_INIT_NO_PARENT("parent-0",
466	&clk_dummy_rate_ops,
467	0);
468	ctx->parents_ctx[0].rate = DUMMY_CLOCK_RATE_1;
469	ret = clk_hw_register(NULL, hw: &ctx->parents_ctx[0].hw);
470	if (ret)
471	return ret;
472
473	ctx->parents_ctx[1].hw.init = CLK_HW_INIT_NO_PARENT("parent-1",
474	&clk_dummy_rate_ops,
475	0);
476	ctx->parents_ctx[1].rate = DUMMY_CLOCK_RATE_2;
477	ret = clk_hw_register(NULL, hw: &ctx->parents_ctx[1].hw);
478	if (ret)
479	return ret;
480
481	ctx->current_parent = 0;
482	ctx->hw.init = CLK_HW_INIT_PARENTS("test-mux", parents,
483	&clk_multiple_parents_mux_ops,
484	CLK_SET_RATE_PARENT);
485	ret = clk_hw_register(NULL, hw: &ctx->hw);
486	if (ret)
487	return ret;
488
489	return 0;
490	}
491
492	static void
493	clk_multiple_parents_mux_test_exit(struct kunit *test)
494	{
495	struct clk_multiple_parent_ctx *ctx = test->priv;
496
497	clk_hw_unregister(hw: &ctx->hw);
498	clk_hw_unregister(hw: &ctx->parents_ctx[0].hw);
499	clk_hw_unregister(hw: &ctx->parents_ctx[1].hw);
500	}
501
502	/*
503	* Test that for a clock with multiple parents, clk_get_parent()
504	* actually returns the current one.
505	*/
506	static void
507	clk_test_multiple_parents_mux_get_parent(struct kunit *test)
508	{
509	struct clk_multiple_parent_ctx *ctx = test->priv;
510	struct clk_hw *hw = &ctx->hw;
511	struct clk *clk = clk_hw_get_clk(hw, NULL);
512	struct clk *parent = clk_hw_get_clk(hw: &ctx->parents_ctx[0].hw, NULL);
513
514	KUNIT_EXPECT_TRUE(test, clk_is_match(clk_get_parent(clk), parent));
515
516	clk_put(clk: parent);
517	clk_put(clk);
518	}
519
520	/*
521	* Test that for a clock with a multiple parents, clk_has_parent()
522	* actually reports all of them as parents.
523	*/
524	static void
525	clk_test_multiple_parents_mux_has_parent(struct kunit *test)
526	{
527	struct clk_multiple_parent_ctx *ctx = test->priv;
528	struct clk_hw *hw = &ctx->hw;
529	struct clk *clk = clk_hw_get_clk(hw, NULL);
530	struct clk *parent;
531
532	parent = clk_hw_get_clk(hw: &ctx->parents_ctx[0].hw, NULL);
533	KUNIT_EXPECT_TRUE(test, clk_has_parent(clk, parent));
534	clk_put(clk: parent);
535
536	parent = clk_hw_get_clk(hw: &ctx->parents_ctx[1].hw, NULL);
537	KUNIT_EXPECT_TRUE(test, clk_has_parent(clk, parent));
538	clk_put(clk: parent);
539
540	clk_put(clk);
541	}
542
543	/*
544	* Test that for a clock with a multiple parents, if we set a range on
545	* that clock and the parent is changed, its rate after the reparenting
546	* is still within the range we asked for.
547	*
548	* FIXME: clk_set_parent() only does the reparenting but doesn't
549	* reevaluate whether the new clock rate is within its boundaries or
550	* not.
551	*/
552	static void
553	clk_test_multiple_parents_mux_set_range_set_parent_get_rate(struct kunit *test)
554	{
555	struct clk_multiple_parent_ctx *ctx = test->priv;
556	struct clk_hw *hw = &ctx->hw;
557	struct clk *clk = clk_hw_get_clk(hw, NULL);
558	struct clk *parent1, *parent2;
559	unsigned long rate;
560	int ret;
561
562	kunit_skip(test, "This needs to be fixed in the core.");
563
564	parent1 = clk_hw_get_clk(hw: &ctx->parents_ctx[0].hw, NULL);
565	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent1);
566	KUNIT_ASSERT_TRUE(test, clk_is_match(clk_get_parent(clk), parent1));
567
568	parent2 = clk_hw_get_clk(hw: &ctx->parents_ctx[1].hw, NULL);
569	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent2);
570
571	ret = clk_set_rate(clk: parent1, DUMMY_CLOCK_RATE_1);
572	KUNIT_ASSERT_EQ(test, ret, 0);
573
574	ret = clk_set_rate(clk: parent2, DUMMY_CLOCK_RATE_2);
575	KUNIT_ASSERT_EQ(test, ret, 0);
576
577	ret = clk_set_rate_range(clk,
578	DUMMY_CLOCK_RATE_1 - 1000,
579	DUMMY_CLOCK_RATE_1 + 1000);
580	KUNIT_ASSERT_EQ(test, ret, 0);
581
582	ret = clk_set_parent(clk, parent: parent2);
583	KUNIT_ASSERT_EQ(test, ret, 0);
584
585	rate = clk_get_rate(clk);
586	KUNIT_ASSERT_GT(test, rate, 0);
587	KUNIT_EXPECT_GE(test, rate, DUMMY_CLOCK_RATE_1 - 1000);
588	KUNIT_EXPECT_LE(test, rate, DUMMY_CLOCK_RATE_1 + 1000);
589
590	clk_put(clk: parent2);
591	clk_put(clk: parent1);
592	clk_put(clk);
593	}
594
595	static struct kunit_case clk_multiple_parents_mux_test_cases[] = {
596	KUNIT_CASE(clk_test_multiple_parents_mux_get_parent),
597	KUNIT_CASE(clk_test_multiple_parents_mux_has_parent),
598	KUNIT_CASE(clk_test_multiple_parents_mux_set_range_set_parent_get_rate),
599	{}
600	};
601
602	/*
603	* Test suite for a basic mux clock with two parents, with
604	* CLK_SET_RATE_PARENT on the child.
605	*
606	* These tests exercise the consumer API and check that the state of the
607	* child and parents are sane and consistent.
608	*/
609	static struct kunit_suite
610	clk_multiple_parents_mux_test_suite = {
611	.name = "clk-multiple-parents-mux-test",
612	.init = clk_multiple_parents_mux_test_init,
613	.exit = clk_multiple_parents_mux_test_exit,
614	.test_cases = clk_multiple_parents_mux_test_cases,
615	};
616
617	static int
618	clk_orphan_transparent_multiple_parent_mux_test_init(struct kunit *test)
619	{
620	struct clk_multiple_parent_ctx *ctx;
621	const char *parents[2] = { "missing-parent", "proper-parent"};
622	int ret;
623
624	ctx = kunit_kzalloc(test, size: sizeof(*ctx), GFP_KERNEL);
625	if (!ctx)
626	return -ENOMEM;
627	test->priv = ctx;
628
629	ctx->parents_ctx[1].hw.init = CLK_HW_INIT_NO_PARENT("proper-parent",
630	&clk_dummy_rate_ops,
631	0);
632	ctx->parents_ctx[1].rate = DUMMY_CLOCK_INIT_RATE;
633	ret = clk_hw_register(NULL, hw: &ctx->parents_ctx[1].hw);
634	if (ret)
635	return ret;
636
637	ctx->hw.init = CLK_HW_INIT_PARENTS("test-orphan-mux", parents,
638	&clk_multiple_parents_mux_ops,
639	CLK_SET_RATE_PARENT);
640	ret = clk_hw_register(NULL, hw: &ctx->hw);
641	if (ret)
642	return ret;
643
644	return 0;
645	}
646
647	static void
648	clk_orphan_transparent_multiple_parent_mux_test_exit(struct kunit *test)
649	{
650	struct clk_multiple_parent_ctx *ctx = test->priv;
651
652	clk_hw_unregister(hw: &ctx->hw);
653	clk_hw_unregister(hw: &ctx->parents_ctx[1].hw);
654	}
655
656	/*
657	* Test that, for a mux whose current parent hasn't been registered yet and is
658	* thus orphan, clk_get_parent() will return NULL.
659	*/
660	static void
661	clk_test_orphan_transparent_multiple_parent_mux_get_parent(struct kunit *test)
662	{
663	struct clk_multiple_parent_ctx *ctx = test->priv;
664	struct clk_hw *hw = &ctx->hw;
665	struct clk *clk = clk_hw_get_clk(hw, NULL);
666
667	KUNIT_EXPECT_PTR_EQ(test, clk_get_parent(clk), NULL);
668
669	clk_put(clk);
670	}
671
672	/*
673	* Test that, for a mux whose current parent hasn't been registered yet,
674	* calling clk_set_parent() to a valid parent will properly update the
675	* mux parent and its orphan status.
676	*/
677	static void
678	clk_test_orphan_transparent_multiple_parent_mux_set_parent(struct kunit *test)
679	{
680	struct clk_multiple_parent_ctx *ctx = test->priv;
681	struct clk_hw *hw = &ctx->hw;
682	struct clk *clk = clk_hw_get_clk(hw, NULL);
683	struct clk *parent, *new_parent;
684	int ret;
685
686	parent = clk_hw_get_clk(hw: &ctx->parents_ctx[1].hw, NULL);
687	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent);
688
689	ret = clk_set_parent(clk, parent);
690	KUNIT_ASSERT_EQ(test, ret, 0);
691
692	new_parent = clk_get_parent(clk);
693	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent);
694	KUNIT_EXPECT_TRUE(test, clk_is_match(parent, new_parent));
695
696	clk_put(clk: parent);
697	clk_put(clk);
698	}
699
700	/*
701	* Test that, for a mux that started orphan but got switched to a valid
702	* parent, calling clk_drop_range() on the mux won't affect the parent
703	* rate.
704	*/
705	static void
706	clk_test_orphan_transparent_multiple_parent_mux_set_parent_drop_range(struct kunit *test)
707	{
708	struct clk_multiple_parent_ctx *ctx = test->priv;
709	struct clk_hw *hw = &ctx->hw;
710	struct clk *clk = clk_hw_get_clk(hw, NULL);
711	struct clk *parent;
712	unsigned long parent_rate, new_parent_rate;
713	int ret;
714
715	parent = clk_hw_get_clk(hw: &ctx->parents_ctx[1].hw, NULL);
716	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent);
717
718	parent_rate = clk_get_rate(clk: parent);
719	KUNIT_ASSERT_GT(test, parent_rate, 0);
720
721	ret = clk_set_parent(clk, parent);
722	KUNIT_ASSERT_EQ(test, ret, 0);
723
724	ret = clk_drop_range(clk);
725	KUNIT_ASSERT_EQ(test, ret, 0);
726
727	new_parent_rate = clk_get_rate(clk);
728	KUNIT_ASSERT_GT(test, new_parent_rate, 0);
729	KUNIT_EXPECT_EQ(test, parent_rate, new_parent_rate);
730
731	clk_put(clk: parent);
732	clk_put(clk);
733	}
734
735	/*
736	* Test that, for a mux that started orphan but got switched to a valid
737	* parent, the rate of the mux and its new parent are consistent.
738	*/
739	static void
740	clk_test_orphan_transparent_multiple_parent_mux_set_parent_get_rate(struct kunit *test)
741	{
742	struct clk_multiple_parent_ctx *ctx = test->priv;
743	struct clk_hw *hw = &ctx->hw;
744	struct clk *clk = clk_hw_get_clk(hw, NULL);
745	struct clk *parent;
746	unsigned long parent_rate, rate;
747	int ret;
748
749	parent = clk_hw_get_clk(hw: &ctx->parents_ctx[1].hw, NULL);
750	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent);
751
752	parent_rate = clk_get_rate(clk: parent);
753	KUNIT_ASSERT_GT(test, parent_rate, 0);
754
755	ret = clk_set_parent(clk, parent);
756	KUNIT_ASSERT_EQ(test, ret, 0);
757
758	rate = clk_get_rate(clk);
759	KUNIT_ASSERT_GT(test, rate, 0);
760	KUNIT_EXPECT_EQ(test, parent_rate, rate);
761
762	clk_put(clk: parent);
763	clk_put(clk);
764	}
765
766	/*
767	* Test that, for a mux that started orphan but got switched to a valid
768	* parent, calling clk_put() on the mux won't affect the parent rate.
769	*/
770	static void
771	clk_test_orphan_transparent_multiple_parent_mux_set_parent_put(struct kunit *test)
772	{
773	struct clk_multiple_parent_ctx *ctx = test->priv;
774	struct clk *clk, *parent;
775	unsigned long parent_rate, new_parent_rate;
776	int ret;
777
778	parent = clk_hw_get_clk(hw: &ctx->parents_ctx[1].hw, NULL);
779	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent);
780
781	clk = clk_hw_get_clk(hw: &ctx->hw, NULL);
782	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, clk);
783
784	parent_rate = clk_get_rate(clk: parent);
785	KUNIT_ASSERT_GT(test, parent_rate, 0);
786
787	ret = clk_set_parent(clk, parent);
788	KUNIT_ASSERT_EQ(test, ret, 0);
789
790	clk_put(clk);
791
792	new_parent_rate = clk_get_rate(clk: parent);
793	KUNIT_ASSERT_GT(test, new_parent_rate, 0);
794	KUNIT_EXPECT_EQ(test, parent_rate, new_parent_rate);
795
796	clk_put(clk: parent);
797	}
798
799	/*
800	* Test that, for a mux that started orphan but got switched to a valid
801	* parent, calling clk_set_rate_range() will affect the parent state if
802	* its rate is out of range.
803	*/
804	static void
805	clk_test_orphan_transparent_multiple_parent_mux_set_parent_set_range_modified(struct kunit *test)
806	{
807	struct clk_multiple_parent_ctx *ctx = test->priv;
808	struct clk_hw *hw = &ctx->hw;
809	struct clk *clk = clk_hw_get_clk(hw, NULL);
810	struct clk *parent;
811	unsigned long rate;
812	int ret;
813
814	parent = clk_hw_get_clk(hw: &ctx->parents_ctx[1].hw, NULL);
815	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent);
816
817	ret = clk_set_parent(clk, parent);
818	KUNIT_ASSERT_EQ(test, ret, 0);
819
820	ret = clk_set_rate_range(clk, DUMMY_CLOCK_RATE_1, DUMMY_CLOCK_RATE_2);
821	KUNIT_ASSERT_EQ(test, ret, 0);
822
823	rate = clk_get_rate(clk);
824	KUNIT_ASSERT_GT(test, rate, 0);
825	KUNIT_EXPECT_GE(test, rate, DUMMY_CLOCK_RATE_1);
826	KUNIT_EXPECT_LE(test, rate, DUMMY_CLOCK_RATE_2);
827
828	clk_put(clk: parent);
829	clk_put(clk);
830	}
831
832	/*
833	* Test that, for a mux that started orphan but got switched to a valid
834	* parent, calling clk_set_rate_range() won't affect the parent state if
835	* its rate is within range.
836	*/
837	static void
838	clk_test_orphan_transparent_multiple_parent_mux_set_parent_set_range_untouched(struct kunit *test)
839	{
840	struct clk_multiple_parent_ctx *ctx = test->priv;
841	struct clk_hw *hw = &ctx->hw;
842	struct clk *clk = clk_hw_get_clk(hw, NULL);
843	struct clk *parent;
844	unsigned long parent_rate, new_parent_rate;
845	int ret;
846
847	parent = clk_hw_get_clk(hw: &ctx->parents_ctx[1].hw, NULL);
848	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent);
849
850	parent_rate = clk_get_rate(clk: parent);
851	KUNIT_ASSERT_GT(test, parent_rate, 0);
852
853	ret = clk_set_parent(clk, parent);
854	KUNIT_ASSERT_EQ(test, ret, 0);
855
856	ret = clk_set_rate_range(clk,
857	DUMMY_CLOCK_INIT_RATE - 1000,
858	DUMMY_CLOCK_INIT_RATE + 1000);
859	KUNIT_ASSERT_EQ(test, ret, 0);
860
861	new_parent_rate = clk_get_rate(clk: parent);
862	KUNIT_ASSERT_GT(test, new_parent_rate, 0);
863	KUNIT_EXPECT_EQ(test, parent_rate, new_parent_rate);
864
865	clk_put(clk: parent);
866	clk_put(clk);
867	}
868
869	/*
870	* Test that, for a mux whose current parent hasn't been registered yet,
871	* calling clk_set_rate_range() will succeed, and will be taken into
872	* account when rounding a rate.
873	*/
874	static void
875	clk_test_orphan_transparent_multiple_parent_mux_set_range_round_rate(struct kunit *test)
876	{
877	struct clk_multiple_parent_ctx *ctx = test->priv;
878	struct clk_hw *hw = &ctx->hw;
879	struct clk *clk = clk_hw_get_clk(hw, NULL);
880	long rate;
881	int ret;
882
883	ret = clk_set_rate_range(clk, DUMMY_CLOCK_RATE_1, DUMMY_CLOCK_RATE_2);
884	KUNIT_ASSERT_EQ(test, ret, 0);
885
886	rate = clk_round_rate(clk, DUMMY_CLOCK_RATE_1 - 1000);
887	KUNIT_ASSERT_GT(test, rate, 0);
888	KUNIT_EXPECT_GE(test, rate, DUMMY_CLOCK_RATE_1);
889	KUNIT_EXPECT_LE(test, rate, DUMMY_CLOCK_RATE_2);
890
891	clk_put(clk);
892	}
893
894	/*
895	* Test that, for a mux that started orphan, was assigned and rate and
896	* then got switched to a valid parent, its rate is eventually within
897	* range.
898	*
899	* FIXME: Even though we update the rate as part of clk_set_parent(), we
900	* don't evaluate whether that new rate is within range and needs to be
901	* adjusted.
902	*/
903	static void
904	clk_test_orphan_transparent_multiple_parent_mux_set_range_set_parent_get_rate(struct kunit *test)
905	{
906	struct clk_multiple_parent_ctx *ctx = test->priv;
907	struct clk_hw *hw = &ctx->hw;
908	struct clk *clk = clk_hw_get_clk(hw, NULL);
909	struct clk *parent;
910	unsigned long rate;
911	int ret;
912
913	kunit_skip(test, "This needs to be fixed in the core.");
914
915	clk_hw_set_rate_range(hw, DUMMY_CLOCK_RATE_1, DUMMY_CLOCK_RATE_2);
916
917	parent = clk_hw_get_clk(hw: &ctx->parents_ctx[1].hw, NULL);
918	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent);
919
920	ret = clk_set_parent(clk, parent);
921	KUNIT_ASSERT_EQ(test, ret, 0);
922
923	rate = clk_get_rate(clk);
924	KUNIT_ASSERT_GT(test, rate, 0);
925	KUNIT_EXPECT_GE(test, rate, DUMMY_CLOCK_RATE_1);
926	KUNIT_EXPECT_LE(test, rate, DUMMY_CLOCK_RATE_2);
927
928	clk_put(clk: parent);
929	clk_put(clk);
930	}
931
932	static struct kunit_case clk_orphan_transparent_multiple_parent_mux_test_cases[] = {
933	KUNIT_CASE(clk_test_orphan_transparent_multiple_parent_mux_get_parent),
934	KUNIT_CASE(clk_test_orphan_transparent_multiple_parent_mux_set_parent),
935	KUNIT_CASE(clk_test_orphan_transparent_multiple_parent_mux_set_parent_drop_range),
936	KUNIT_CASE(clk_test_orphan_transparent_multiple_parent_mux_set_parent_get_rate),
937	KUNIT_CASE(clk_test_orphan_transparent_multiple_parent_mux_set_parent_put),
938	KUNIT_CASE(clk_test_orphan_transparent_multiple_parent_mux_set_parent_set_range_modified),
939	KUNIT_CASE(clk_test_orphan_transparent_multiple_parent_mux_set_parent_set_range_untouched),
940	KUNIT_CASE(clk_test_orphan_transparent_multiple_parent_mux_set_range_round_rate),
941	KUNIT_CASE(clk_test_orphan_transparent_multiple_parent_mux_set_range_set_parent_get_rate),
942	{}
943	};
944
945	/*
946	* Test suite for a basic mux clock with two parents. The default parent
947	* isn't registered, only the second parent is. By default, the clock
948	* will thus be orphan.
949	*
950	* These tests exercise the behaviour of the consumer API when dealing
951	* with an orphan clock, and how we deal with the transition to a valid
952	* parent.
953	*/
954	static struct kunit_suite clk_orphan_transparent_multiple_parent_mux_test_suite = {
955	.name = "clk-orphan-transparent-multiple-parent-mux-test",
956	.init = clk_orphan_transparent_multiple_parent_mux_test_init,
957	.exit = clk_orphan_transparent_multiple_parent_mux_test_exit,
958	.test_cases = clk_orphan_transparent_multiple_parent_mux_test_cases,
959	};
960
961	struct clk_single_parent_ctx {
962	struct clk_dummy_context parent_ctx;
963	struct clk_hw hw;
964	};
965
966	static int clk_single_parent_mux_test_init(struct kunit *test)
967	{
968	struct clk_single_parent_ctx *ctx;
969	int ret;
970
971	ctx = kunit_kzalloc(test, size: sizeof(*ctx), GFP_KERNEL);
972	if (!ctx)
973	return -ENOMEM;
974	test->priv = ctx;
975
976	ctx->parent_ctx.rate = DUMMY_CLOCK_INIT_RATE;
977	ctx->parent_ctx.hw.init =
978	CLK_HW_INIT_NO_PARENT("parent-clk",
979	&clk_dummy_rate_ops,
980	0);
981
982	ret = clk_hw_register(NULL, hw: &ctx->parent_ctx.hw);
983	if (ret)
984	return ret;
985
986	ctx->hw.init = CLK_HW_INIT("test-clk", "parent-clk",
987	&clk_dummy_single_parent_ops,
988	CLK_SET_RATE_PARENT);
989
990	ret = clk_hw_register(NULL, hw: &ctx->hw);
991	if (ret)
992	return ret;
993
994	return 0;
995	}
996
997	static void
998	clk_single_parent_mux_test_exit(struct kunit *test)
999	{
1000	struct clk_single_parent_ctx *ctx = test->priv;
1001
1002	clk_hw_unregister(hw: &ctx->hw);
1003	clk_hw_unregister(hw: &ctx->parent_ctx.hw);
1004	}
1005
1006	/*
1007	* Test that for a clock with a single parent, clk_get_parent() actually
1008	* returns the parent.
1009	*/
1010	static void
1011	clk_test_single_parent_mux_get_parent(struct kunit *test)
1012	{
1013	struct clk_single_parent_ctx *ctx = test->priv;
1014	struct clk_hw *hw = &ctx->hw;
1015	struct clk *clk = clk_hw_get_clk(hw, NULL);
1016	struct clk *parent = clk_hw_get_clk(hw: &ctx->parent_ctx.hw, NULL);
1017
1018	KUNIT_EXPECT_TRUE(test, clk_is_match(clk_get_parent(clk), parent));
1019
1020	clk_put(clk: parent);
1021	clk_put(clk);
1022	}
1023
1024	/*
1025	* Test that for a clock with a single parent, clk_has_parent() actually
1026	* reports it as a parent.
1027	*/
1028	static void
1029	clk_test_single_parent_mux_has_parent(struct kunit *test)
1030	{
1031	struct clk_single_parent_ctx *ctx = test->priv;
1032	struct clk_hw *hw = &ctx->hw;
1033	struct clk *clk = clk_hw_get_clk(hw, NULL);
1034	struct clk *parent = clk_hw_get_clk(hw: &ctx->parent_ctx.hw, NULL);
1035
1036	KUNIT_EXPECT_TRUE(test, clk_has_parent(clk, parent));
1037
1038	clk_put(clk: parent);
1039	clk_put(clk);
1040	}
1041
1042	/*
1043	* Test that for a clock that can't modify its rate and with a single
1044	* parent, if we set disjoints range on the parent and then the child,
1045	* the second will return an error.
1046	*
1047	* FIXME: clk_set_rate_range() only considers the current clock when
1048	* evaluating whether ranges are disjoints and not the upstream clocks
1049	* ranges.
1050	*/
1051	static void
1052	clk_test_single_parent_mux_set_range_disjoint_child_last(struct kunit *test)
1053	{
1054	struct clk_single_parent_ctx *ctx = test->priv;
1055	struct clk_hw *hw = &ctx->hw;
1056	struct clk *clk = clk_hw_get_clk(hw, NULL);
1057	struct clk *parent;
1058	int ret;
1059
1060	kunit_skip(test, "This needs to be fixed in the core.");
1061
1062	parent = clk_get_parent(clk);
1063	KUNIT_ASSERT_PTR_NE(test, parent, NULL);
1064
1065	ret = clk_set_rate_range(clk: parent, min: 1000, max: 2000);
1066	KUNIT_ASSERT_EQ(test, ret, 0);
1067
1068	ret = clk_set_rate_range(clk, min: 3000, max: 4000);
1069	KUNIT_EXPECT_LT(test, ret, 0);
1070
1071	clk_put(clk);
1072	}
1073
1074	/*
1075	* Test that for a clock that can't modify its rate and with a single
1076	* parent, if we set disjoints range on the child and then the parent,
1077	* the second will return an error.
1078	*
1079	* FIXME: clk_set_rate_range() only considers the current clock when
1080	* evaluating whether ranges are disjoints and not the downstream clocks
1081	* ranges.
1082	*/
1083	static void
1084	clk_test_single_parent_mux_set_range_disjoint_parent_last(struct kunit *test)
1085	{
1086	struct clk_single_parent_ctx *ctx = test->priv;
1087	struct clk_hw *hw = &ctx->hw;
1088	struct clk *clk = clk_hw_get_clk(hw, NULL);
1089	struct clk *parent;
1090	int ret;
1091
1092	kunit_skip(test, "This needs to be fixed in the core.");
1093
1094	parent = clk_get_parent(clk);
1095	KUNIT_ASSERT_PTR_NE(test, parent, NULL);
1096
1097	ret = clk_set_rate_range(clk, min: 1000, max: 2000);
1098	KUNIT_ASSERT_EQ(test, ret, 0);
1099
1100	ret = clk_set_rate_range(clk: parent, min: 3000, max: 4000);
1101	KUNIT_EXPECT_LT(test, ret, 0);
1102
1103	clk_put(clk);
1104	}
1105
1106	/*
1107	* Test that for a clock that can't modify its rate and with a single
1108	* parent, if we set a range on the parent and then call
1109	* clk_round_rate(), the boundaries of the parent are taken into
1110	* account.
1111	*/
1112	static void
1113	clk_test_single_parent_mux_set_range_round_rate_parent_only(struct kunit *test)
1114	{
1115	struct clk_single_parent_ctx *ctx = test->priv;
1116	struct clk_hw *hw = &ctx->hw;
1117	struct clk *clk = clk_hw_get_clk(hw, NULL);
1118	struct clk *parent;
1119	long rate;
1120	int ret;
1121
1122	parent = clk_get_parent(clk);
1123	KUNIT_ASSERT_PTR_NE(test, parent, NULL);
1124
1125	ret = clk_set_rate_range(clk: parent, DUMMY_CLOCK_RATE_1, DUMMY_CLOCK_RATE_2);
1126	KUNIT_ASSERT_EQ(test, ret, 0);
1127
1128	rate = clk_round_rate(clk, DUMMY_CLOCK_RATE_1 - 1000);
1129	KUNIT_ASSERT_GT(test, rate, 0);
1130	KUNIT_EXPECT_GE(test, rate, DUMMY_CLOCK_RATE_1);
1131	KUNIT_EXPECT_LE(test, rate, DUMMY_CLOCK_RATE_2);
1132
1133	clk_put(clk);
1134	}
1135
1136	/*
1137	* Test that for a clock that can't modify its rate and with a single
1138	* parent, if we set a range on the parent and a more restrictive one on
1139	* the child, and then call clk_round_rate(), the boundaries of the
1140	* two clocks are taken into account.
1141	*/
1142	static void
1143	clk_test_single_parent_mux_set_range_round_rate_child_smaller(struct kunit *test)
1144	{
1145	struct clk_single_parent_ctx *ctx = test->priv;
1146	struct clk_hw *hw = &ctx->hw;
1147	struct clk *clk = clk_hw_get_clk(hw, NULL);
1148	struct clk *parent;
1149	long rate;
1150	int ret;
1151
1152	parent = clk_get_parent(clk);
1153	KUNIT_ASSERT_PTR_NE(test, parent, NULL);
1154
1155	ret = clk_set_rate_range(clk: parent, DUMMY_CLOCK_RATE_1, DUMMY_CLOCK_RATE_2);
1156	KUNIT_ASSERT_EQ(test, ret, 0);
1157
1158	ret = clk_set_rate_range(clk, DUMMY_CLOCK_RATE_1 + 1000, DUMMY_CLOCK_RATE_2 - 1000);
1159	KUNIT_ASSERT_EQ(test, ret, 0);
1160
1161	rate = clk_round_rate(clk, DUMMY_CLOCK_RATE_1 - 1000);
1162	KUNIT_ASSERT_GT(test, rate, 0);
1163	KUNIT_EXPECT_GE(test, rate, DUMMY_CLOCK_RATE_1 + 1000);
1164	KUNIT_EXPECT_LE(test, rate, DUMMY_CLOCK_RATE_2 - 1000);
1165
1166	rate = clk_round_rate(clk, DUMMY_CLOCK_RATE_2 + 1000);
1167	KUNIT_ASSERT_GT(test, rate, 0);
1168	KUNIT_EXPECT_GE(test, rate, DUMMY_CLOCK_RATE_1 + 1000);
1169	KUNIT_EXPECT_LE(test, rate, DUMMY_CLOCK_RATE_2 - 1000);
1170
1171	clk_put(clk);
1172	}
1173
1174	/*
1175	* Test that for a clock that can't modify its rate and with a single
1176	* parent, if we set a range on the child and a more restrictive one on
1177	* the parent, and then call clk_round_rate(), the boundaries of the
1178	* two clocks are taken into account.
1179	*/
1180	static void
1181	clk_test_single_parent_mux_set_range_round_rate_parent_smaller(struct kunit *test)
1182	{
1183	struct clk_single_parent_ctx *ctx = test->priv;
1184	struct clk_hw *hw = &ctx->hw;
1185	struct clk *clk = clk_hw_get_clk(hw, NULL);
1186	struct clk *parent;
1187	long rate;
1188	int ret;
1189
1190	parent = clk_get_parent(clk);
1191	KUNIT_ASSERT_PTR_NE(test, parent, NULL);
1192
1193	ret = clk_set_rate_range(clk: parent, DUMMY_CLOCK_RATE_1 + 1000, DUMMY_CLOCK_RATE_2 - 1000);
1194	KUNIT_ASSERT_EQ(test, ret, 0);
1195
1196	ret = clk_set_rate_range(clk, DUMMY_CLOCK_RATE_1, DUMMY_CLOCK_RATE_2);
1197	KUNIT_ASSERT_EQ(test, ret, 0);
1198
1199	rate = clk_round_rate(clk, DUMMY_CLOCK_RATE_1 - 1000);
1200	KUNIT_ASSERT_GT(test, rate, 0);
1201	KUNIT_EXPECT_GE(test, rate, DUMMY_CLOCK_RATE_1 + 1000);
1202	KUNIT_EXPECT_LE(test, rate, DUMMY_CLOCK_RATE_2 - 1000);
1203
1204	rate = clk_round_rate(clk, DUMMY_CLOCK_RATE_2 + 1000);
1205	KUNIT_ASSERT_GT(test, rate, 0);
1206	KUNIT_EXPECT_GE(test, rate, DUMMY_CLOCK_RATE_1 + 1000);
1207	KUNIT_EXPECT_LE(test, rate, DUMMY_CLOCK_RATE_2 - 1000);
1208
1209	clk_put(clk);
1210	}
1211
1212	static struct kunit_case clk_single_parent_mux_test_cases[] = {
1213	KUNIT_CASE(clk_test_single_parent_mux_get_parent),
1214	KUNIT_CASE(clk_test_single_parent_mux_has_parent),
1215	KUNIT_CASE(clk_test_single_parent_mux_set_range_disjoint_child_last),
1216	KUNIT_CASE(clk_test_single_parent_mux_set_range_disjoint_parent_last),
1217	KUNIT_CASE(clk_test_single_parent_mux_set_range_round_rate_child_smaller),
1218	KUNIT_CASE(clk_test_single_parent_mux_set_range_round_rate_parent_only),
1219	KUNIT_CASE(clk_test_single_parent_mux_set_range_round_rate_parent_smaller),
1220	{}
1221	};
1222
1223	/*
1224	* Test suite for a basic mux clock with one parent, with
1225	* CLK_SET_RATE_PARENT on the child.
1226	*
1227	* These tests exercise the consumer API and check that the state of the
1228	* child and parent are sane and consistent.
1229	*/
1230	static struct kunit_suite
1231	clk_single_parent_mux_test_suite = {
1232	.name = "clk-single-parent-mux-test",
1233	.init = clk_single_parent_mux_test_init,
1234	.exit = clk_single_parent_mux_test_exit,
1235	.test_cases = clk_single_parent_mux_test_cases,
1236	};
1237
1238	static int clk_orphan_transparent_single_parent_mux_test_init(struct kunit *test)
1239	{
1240	struct clk_single_parent_ctx *ctx;
1241	struct clk_init_data init = { };
1242	const char * const parents[] = { "orphan_parent" };
1243	int ret;
1244
1245	ctx = kunit_kzalloc(test, size: sizeof(*ctx), GFP_KERNEL);
1246	if (!ctx)
1247	return -ENOMEM;
1248	test->priv = ctx;
1249
1250	init.name = "test_orphan_dummy_parent";
1251	init.ops = &clk_dummy_single_parent_ops;
1252	init.parent_names = parents;
1253	init.num_parents = ARRAY_SIZE(parents);
1254	init.flags = CLK_SET_RATE_PARENT;
1255	ctx->hw.init = &init;
1256
1257	ret = clk_hw_register(NULL, hw: &ctx->hw);
1258	if (ret)
1259	return ret;
1260
1261	memset(&init, 0, sizeof(init));
1262	init.name = "orphan_parent";
1263	init.ops = &clk_dummy_rate_ops;
1264	ctx->parent_ctx.hw.init = &init;
1265	ctx->parent_ctx.rate = DUMMY_CLOCK_INIT_RATE;
1266
1267	ret = clk_hw_register(NULL, hw: &ctx->parent_ctx.hw);
1268	if (ret)
1269	return ret;
1270
1271	return 0;
1272	}
1273
1274	/*
1275	* Test that a mux-only clock, with an initial rate within a range,
1276	* will still have the same rate after the range has been enforced.
1277	*
1278	* See:
1279	* https://lore.kernel.org/linux-clk/7720158d-10a7-a17b-73a4-a8615c9c6d5c@collabora.com/
1280	*/
1281	static void clk_test_orphan_transparent_parent_mux_set_range(struct kunit *test)
1282	{
1283	struct clk_single_parent_ctx *ctx = test->priv;
1284	struct clk_hw *hw = &ctx->hw;
1285	struct clk *clk = clk_hw_get_clk(hw, NULL);
1286	unsigned long rate, new_rate;
1287
1288	rate = clk_get_rate(clk);
1289	KUNIT_ASSERT_GT(test, rate, 0);
1290
1291	KUNIT_ASSERT_EQ(test,
1292	clk_set_rate_range(clk,
1293	ctx->parent_ctx.rate - 1000,
1294	ctx->parent_ctx.rate + 1000),
1295	0);
1296
1297	new_rate = clk_get_rate(clk);
1298	KUNIT_ASSERT_GT(test, new_rate, 0);
1299	KUNIT_EXPECT_EQ(test, rate, new_rate);
1300
1301	clk_put(clk);
1302	}
1303
1304	static struct kunit_case clk_orphan_transparent_single_parent_mux_test_cases[] = {
1305	KUNIT_CASE(clk_test_orphan_transparent_parent_mux_set_range),
1306	{}
1307	};
1308
1309	/*
1310	* Test suite for a basic mux clock with one parent. The parent is
1311	* registered after its child. The clock will thus be an orphan when
1312	* registered, but will no longer be when the tests run.
1313	*
1314	* These tests make sure a clock that used to be orphan has a sane,
1315	* consistent, behaviour.
1316	*/
1317	static struct kunit_suite clk_orphan_transparent_single_parent_test_suite = {
1318	.name = "clk-orphan-transparent-single-parent-test",
1319	.init = clk_orphan_transparent_single_parent_mux_test_init,
1320	.exit = clk_single_parent_mux_test_exit,
1321	.test_cases = clk_orphan_transparent_single_parent_mux_test_cases,
1322	};
1323
1324	struct clk_single_parent_two_lvl_ctx {
1325	struct clk_dummy_context parent_parent_ctx;
1326	struct clk_dummy_context parent_ctx;
1327	struct clk_hw hw;
1328	};
1329
1330	static int
1331	clk_orphan_two_level_root_last_test_init(struct kunit *test)
1332	{
1333	struct clk_single_parent_two_lvl_ctx *ctx;
1334	int ret;
1335
1336	ctx = kunit_kzalloc(test, size: sizeof(*ctx), GFP_KERNEL);
1337	if (!ctx)
1338	return -ENOMEM;
1339	test->priv = ctx;
1340
1341	ctx->parent_ctx.hw.init =
1342	CLK_HW_INIT("intermediate-parent",
1343	"root-parent",
1344	&clk_dummy_single_parent_ops,
1345	CLK_SET_RATE_PARENT);
1346	ret = clk_hw_register(NULL, hw: &ctx->parent_ctx.hw);
1347	if (ret)
1348	return ret;
1349
1350	ctx->hw.init =
1351	CLK_HW_INIT("test-clk", "intermediate-parent",
1352	&clk_dummy_single_parent_ops,
1353	CLK_SET_RATE_PARENT);
1354	ret = clk_hw_register(NULL, hw: &ctx->hw);
1355	if (ret)
1356	return ret;
1357
1358	ctx->parent_parent_ctx.rate = DUMMY_CLOCK_INIT_RATE;
1359	ctx->parent_parent_ctx.hw.init =
1360	CLK_HW_INIT_NO_PARENT("root-parent",
1361	&clk_dummy_rate_ops,
1362	0);
1363	ret = clk_hw_register(NULL, hw: &ctx->parent_parent_ctx.hw);
1364	if (ret)
1365	return ret;
1366
1367	return 0;
1368	}
1369
1370	static void
1371	clk_orphan_two_level_root_last_test_exit(struct kunit *test)
1372	{
1373	struct clk_single_parent_two_lvl_ctx *ctx = test->priv;
1374
1375	clk_hw_unregister(hw: &ctx->hw);
1376	clk_hw_unregister(hw: &ctx->parent_ctx.hw);
1377	clk_hw_unregister(hw: &ctx->parent_parent_ctx.hw);
1378	}
1379
1380	/*
1381	* Test that, for a clock whose parent used to be orphan, clk_get_rate()
1382	* will return the proper rate.
1383	*/
1384	static void
1385	clk_orphan_two_level_root_last_test_get_rate(struct kunit *test)
1386	{
1387	struct clk_single_parent_two_lvl_ctx *ctx = test->priv;
1388	struct clk_hw *hw = &ctx->hw;
1389	struct clk *clk = clk_hw_get_clk(hw, NULL);
1390	unsigned long rate;
1391
1392	rate = clk_get_rate(clk);
1393	KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_INIT_RATE);
1394
1395	clk_put(clk);
1396	}
1397
1398	/*
1399	* Test that, for a clock whose parent used to be orphan,
1400	* clk_set_rate_range() won't affect its rate if it is already within
1401	* range.
1402	*
1403	* See (for Exynos 4210):
1404	* https://lore.kernel.org/linux-clk/366a0232-bb4a-c357-6aa8-636e398e05eb@samsung.com/
1405	*/
1406	static void
1407	clk_orphan_two_level_root_last_test_set_range(struct kunit *test)
1408	{
1409	struct clk_single_parent_two_lvl_ctx *ctx = test->priv;
1410	struct clk_hw *hw = &ctx->hw;
1411	struct clk *clk = clk_hw_get_clk(hw, NULL);
1412	unsigned long rate;
1413	int ret;
1414
1415	ret = clk_set_rate_range(clk,
1416	DUMMY_CLOCK_INIT_RATE - 1000,
1417	DUMMY_CLOCK_INIT_RATE + 1000);
1418	KUNIT_ASSERT_EQ(test, ret, 0);
1419
1420	rate = clk_get_rate(clk);
1421	KUNIT_ASSERT_GT(test, rate, 0);
1422	KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_INIT_RATE);
1423
1424	clk_put(clk);
1425	}
1426
1427	static struct kunit_case
1428	clk_orphan_two_level_root_last_test_cases[] = {
1429	KUNIT_CASE(clk_orphan_two_level_root_last_test_get_rate),
1430	KUNIT_CASE(clk_orphan_two_level_root_last_test_set_range),
1431	{}
1432	};
1433
1434	/*
1435	* Test suite for a basic, transparent, clock with a parent that is also
1436	* such a clock. The parent's parent is registered last, while the
1437	* parent and its child are registered in that order. The intermediate
1438	* and leaf clocks will thus be orphan when registered, but the leaf
1439	* clock itself will always have its parent and will never be
1440	* reparented. Indeed, it's only orphan because its parent is.
1441	*
1442	* These tests exercise the behaviour of the consumer API when dealing
1443	* with an orphan clock, and how we deal with the transition to a valid
1444	* parent.
1445	*/
1446	static struct kunit_suite
1447	clk_orphan_two_level_root_last_test_suite = {
1448	.name = "clk-orphan-two-level-root-last-test",
1449	.init = clk_orphan_two_level_root_last_test_init,
1450	.exit = clk_orphan_two_level_root_last_test_exit,
1451	.test_cases = clk_orphan_two_level_root_last_test_cases,
1452	};
1453
1454	/*
1455	* Test that clk_set_rate_range won't return an error for a valid range
1456	* and that it will make sure the rate of the clock is within the
1457	* boundaries.
1458	*/
1459	static void clk_range_test_set_range(struct kunit *test)
1460	{
1461	struct clk_dummy_context *ctx = test->priv;
1462	struct clk_hw *hw = &ctx->hw;
1463	struct clk *clk = clk_hw_get_clk(hw, NULL);
1464	unsigned long rate;
1465
1466	KUNIT_ASSERT_EQ(test,
1467	clk_set_rate_range(clk,
1468	DUMMY_CLOCK_RATE_1,
1469	DUMMY_CLOCK_RATE_2),
1470	0);
1471
1472	rate = clk_get_rate(clk);
1473	KUNIT_ASSERT_GT(test, rate, 0);
1474	KUNIT_EXPECT_GE(test, rate, DUMMY_CLOCK_RATE_1);
1475	KUNIT_EXPECT_LE(test, rate, DUMMY_CLOCK_RATE_2);
1476
1477	clk_put(clk);
1478	}
1479
1480	/*
1481	* Test that calling clk_set_rate_range with a minimum rate higher than
1482	* the maximum rate returns an error.
1483	*/
1484	static void clk_range_test_set_range_invalid(struct kunit *test)
1485	{
1486	struct clk_dummy_context *ctx = test->priv;
1487	struct clk_hw *hw = &ctx->hw;
1488	struct clk *clk = clk_hw_get_clk(hw, NULL);
1489
1490	KUNIT_EXPECT_LT(test,
1491	clk_set_rate_range(clk,
1492	DUMMY_CLOCK_RATE_1 + 1000,
1493	DUMMY_CLOCK_RATE_1),
1494	0);
1495
1496	clk_put(clk);
1497	}
1498
1499	/*
1500	* Test that users can't set multiple, disjoints, range that would be
1501	* impossible to meet.
1502	*/
1503	static void clk_range_test_multiple_disjoints_range(struct kunit *test)
1504	{
1505	struct clk_dummy_context *ctx = test->priv;
1506	struct clk_hw *hw = &ctx->hw;
1507	struct clk *user1, *user2;
1508
1509	user1 = clk_hw_get_clk(hw, NULL);
1510	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, user1);
1511
1512	user2 = clk_hw_get_clk(hw, NULL);
1513	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, user2);
1514
1515	KUNIT_ASSERT_EQ(test,
1516	clk_set_rate_range(user1, 1000, 2000),
1517	0);
1518
1519	KUNIT_EXPECT_LT(test,
1520	clk_set_rate_range(user2, 3000, 4000),
1521	0);
1522
1523	clk_put(clk: user2);
1524	clk_put(clk: user1);
1525	}
1526
1527	/*
1528	* Test that if our clock has some boundaries and we try to round a rate
1529	* lower than the minimum, the returned rate will be within range.
1530	*/
1531	static void clk_range_test_set_range_round_rate_lower(struct kunit *test)
1532	{
1533	struct clk_dummy_context *ctx = test->priv;
1534	struct clk_hw *hw = &ctx->hw;
1535	struct clk *clk = clk_hw_get_clk(hw, NULL);
1536	long rate;
1537
1538	KUNIT_ASSERT_EQ(test,
1539	clk_set_rate_range(clk,
1540	DUMMY_CLOCK_RATE_1,
1541	DUMMY_CLOCK_RATE_2),
1542	0);
1543
1544	rate = clk_round_rate(clk, DUMMY_CLOCK_RATE_1 - 1000);
1545	KUNIT_ASSERT_GT(test, rate, 0);
1546	KUNIT_EXPECT_GE(test, rate, DUMMY_CLOCK_RATE_1);
1547	KUNIT_EXPECT_LE(test, rate, DUMMY_CLOCK_RATE_2);
1548
1549	clk_put(clk);
1550	}
1551
1552	/*
1553	* Test that if our clock has some boundaries and we try to set a rate
1554	* higher than the maximum, the new rate will be within range.
1555	*/
1556	static void clk_range_test_set_range_set_rate_lower(struct kunit *test)
1557	{
1558	struct clk_dummy_context *ctx = test->priv;
1559	struct clk_hw *hw = &ctx->hw;
1560	struct clk *clk = clk_hw_get_clk(hw, NULL);
1561	unsigned long rate;
1562
1563	KUNIT_ASSERT_EQ(test,
1564	clk_set_rate_range(clk,
1565	DUMMY_CLOCK_RATE_1,
1566	DUMMY_CLOCK_RATE_2),
1567	0);
1568
1569	KUNIT_ASSERT_EQ(test,
1570	clk_set_rate(clk, DUMMY_CLOCK_RATE_1 - 1000),
1571	0);
1572
1573	rate = clk_get_rate(clk);
1574	KUNIT_ASSERT_GT(test, rate, 0);
1575	KUNIT_EXPECT_GE(test, rate, DUMMY_CLOCK_RATE_1);
1576	KUNIT_EXPECT_LE(test, rate, DUMMY_CLOCK_RATE_2);
1577
1578	clk_put(clk);
1579	}
1580
1581	/*
1582	* Test that if our clock has some boundaries and we try to round and
1583	* set a rate lower than the minimum, the rate returned by
1584	* clk_round_rate() will be consistent with the new rate set by
1585	* clk_set_rate().
1586	*/
1587	static void clk_range_test_set_range_set_round_rate_consistent_lower(struct kunit *test)
1588	{
1589	struct clk_dummy_context *ctx = test->priv;
1590	struct clk_hw *hw = &ctx->hw;
1591	struct clk *clk = clk_hw_get_clk(hw, NULL);
1592	long rounded;
1593
1594	KUNIT_ASSERT_EQ(test,
1595	clk_set_rate_range(clk,
1596	DUMMY_CLOCK_RATE_1,
1597	DUMMY_CLOCK_RATE_2),
1598	0);
1599
1600	rounded = clk_round_rate(clk, DUMMY_CLOCK_RATE_1 - 1000);
1601	KUNIT_ASSERT_GT(test, rounded, 0);
1602
1603	KUNIT_ASSERT_EQ(test,
1604	clk_set_rate(clk, DUMMY_CLOCK_RATE_1 - 1000),
1605	0);
1606
1607	KUNIT_EXPECT_EQ(test, rounded, clk_get_rate(clk));
1608
1609	clk_put(clk);
1610	}
1611
1612	/*
1613	* Test that if our clock has some boundaries and we try to round a rate
1614	* higher than the maximum, the returned rate will be within range.
1615	*/
1616	static void clk_range_test_set_range_round_rate_higher(struct kunit *test)
1617	{
1618	struct clk_dummy_context *ctx = test->priv;
1619	struct clk_hw *hw = &ctx->hw;
1620	struct clk *clk = clk_hw_get_clk(hw, NULL);
1621	long rate;
1622
1623	KUNIT_ASSERT_EQ(test,
1624	clk_set_rate_range(clk,
1625	DUMMY_CLOCK_RATE_1,
1626	DUMMY_CLOCK_RATE_2),
1627	0);
1628
1629	rate = clk_round_rate(clk, DUMMY_CLOCK_RATE_2 + 1000);
1630	KUNIT_ASSERT_GT(test, rate, 0);
1631	KUNIT_EXPECT_GE(test, rate, DUMMY_CLOCK_RATE_1);
1632	KUNIT_EXPECT_LE(test, rate, DUMMY_CLOCK_RATE_2);
1633
1634	clk_put(clk);
1635	}
1636
1637	/*
1638	* Test that if our clock has some boundaries and we try to set a rate
1639	* higher than the maximum, the new rate will be within range.
1640	*/
1641	static void clk_range_test_set_range_set_rate_higher(struct kunit *test)
1642	{
1643	struct clk_dummy_context *ctx = test->priv;
1644	struct clk_hw *hw = &ctx->hw;
1645	struct clk *clk = clk_hw_get_clk(hw, NULL);
1646	unsigned long rate;
1647
1648	KUNIT_ASSERT_EQ(test,
1649	clk_set_rate_range(clk,
1650	DUMMY_CLOCK_RATE_1,
1651	DUMMY_CLOCK_RATE_2),
1652	0);
1653
1654	KUNIT_ASSERT_EQ(test,
1655	clk_set_rate(clk, DUMMY_CLOCK_RATE_2 + 1000),
1656	0);
1657
1658	rate = clk_get_rate(clk);
1659	KUNIT_ASSERT_GT(test, rate, 0);
1660	KUNIT_EXPECT_GE(test, rate, DUMMY_CLOCK_RATE_1);
1661	KUNIT_EXPECT_LE(test, rate, DUMMY_CLOCK_RATE_2);
1662
1663	clk_put(clk);
1664	}
1665
1666	/*
1667	* Test that if our clock has some boundaries and we try to round and
1668	* set a rate higher than the maximum, the rate returned by
1669	* clk_round_rate() will be consistent with the new rate set by
1670	* clk_set_rate().
1671	*/
1672	static void clk_range_test_set_range_set_round_rate_consistent_higher(struct kunit *test)
1673	{
1674	struct clk_dummy_context *ctx = test->priv;
1675	struct clk_hw *hw = &ctx->hw;
1676	struct clk *clk = clk_hw_get_clk(hw, NULL);
1677	long rounded;
1678
1679	KUNIT_ASSERT_EQ(test,
1680	clk_set_rate_range(clk,
1681	DUMMY_CLOCK_RATE_1,
1682	DUMMY_CLOCK_RATE_2),
1683	0);
1684
1685	rounded = clk_round_rate(clk, DUMMY_CLOCK_RATE_2 + 1000);
1686	KUNIT_ASSERT_GT(test, rounded, 0);
1687
1688	KUNIT_ASSERT_EQ(test,
1689	clk_set_rate(clk, DUMMY_CLOCK_RATE_2 + 1000),
1690	0);
1691
1692	KUNIT_EXPECT_EQ(test, rounded, clk_get_rate(clk));
1693
1694	clk_put(clk);
1695	}
1696
1697	/*
1698	* Test that if our clock has a rate lower than the minimum set by a
1699	* call to clk_set_rate_range(), the rate will be raised to match the
1700	* new minimum.
1701	*
1702	* This assumes that clk_ops.determine_rate or clk_ops.round_rate won't
1703	* modify the requested rate, which is our case in clk_dummy_rate_ops.
1704	*/
1705	static void clk_range_test_set_range_get_rate_raised(struct kunit *test)
1706	{
1707	struct clk_dummy_context *ctx = test->priv;
1708	struct clk_hw *hw = &ctx->hw;
1709	struct clk *clk = clk_hw_get_clk(hw, NULL);
1710	unsigned long rate;
1711
1712	KUNIT_ASSERT_EQ(test,
1713	clk_set_rate(clk, DUMMY_CLOCK_RATE_1 - 1000),
1714	0);
1715
1716	KUNIT_ASSERT_EQ(test,
1717	clk_set_rate_range(clk,
1718	DUMMY_CLOCK_RATE_1,
1719	DUMMY_CLOCK_RATE_2),
1720	0);
1721
1722	rate = clk_get_rate(clk);
1723	KUNIT_ASSERT_GT(test, rate, 0);
1724	KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_1);
1725
1726	clk_put(clk);
1727	}
1728
1729	/*
1730	* Test that if our clock has a rate higher than the maximum set by a
1731	* call to clk_set_rate_range(), the rate will be lowered to match the
1732	* new maximum.
1733	*
1734	* This assumes that clk_ops.determine_rate or clk_ops.round_rate won't
1735	* modify the requested rate, which is our case in clk_dummy_rate_ops.
1736	*/
1737	static void clk_range_test_set_range_get_rate_lowered(struct kunit *test)
1738	{
1739	struct clk_dummy_context *ctx = test->priv;
1740	struct clk_hw *hw = &ctx->hw;
1741	struct clk *clk = clk_hw_get_clk(hw, NULL);
1742	unsigned long rate;
1743
1744	KUNIT_ASSERT_EQ(test,
1745	clk_set_rate(clk, DUMMY_CLOCK_RATE_2 + 1000),
1746	0);
1747
1748	KUNIT_ASSERT_EQ(test,
1749	clk_set_rate_range(clk,
1750	DUMMY_CLOCK_RATE_1,
1751	DUMMY_CLOCK_RATE_2),
1752	0);
1753
1754	rate = clk_get_rate(clk);
1755	KUNIT_ASSERT_GT(test, rate, 0);
1756	KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_2);
1757
1758	clk_put(clk);
1759	}
1760
1761	static struct kunit_case clk_range_test_cases[] = {
1762	KUNIT_CASE(clk_range_test_set_range),
1763	KUNIT_CASE(clk_range_test_set_range_invalid),
1764	KUNIT_CASE(clk_range_test_multiple_disjoints_range),
1765	KUNIT_CASE(clk_range_test_set_range_round_rate_lower),
1766	KUNIT_CASE(clk_range_test_set_range_set_rate_lower),
1767	KUNIT_CASE(clk_range_test_set_range_set_round_rate_consistent_lower),
1768	KUNIT_CASE(clk_range_test_set_range_round_rate_higher),
1769	KUNIT_CASE(clk_range_test_set_range_set_rate_higher),
1770	KUNIT_CASE(clk_range_test_set_range_set_round_rate_consistent_higher),
1771	KUNIT_CASE(clk_range_test_set_range_get_rate_raised),
1772	KUNIT_CASE(clk_range_test_set_range_get_rate_lowered),
1773	{}
1774	};
1775
1776	/*
1777	* Test suite for a basic rate clock, without any parent.
1778	*
1779	* These tests exercise the rate range API: clk_set_rate_range(),
1780	* clk_set_min_rate(), clk_set_max_rate(), clk_drop_range().
1781	*/
1782	static struct kunit_suite clk_range_test_suite = {
1783	.name = "clk-range-test",
1784	.init = clk_test_init,
1785	.exit = clk_test_exit,
1786	.test_cases = clk_range_test_cases,
1787	};
1788
1789	/*
1790	* Test that if we have several subsequent calls to
1791	* clk_set_rate_range(), the core will reevaluate whether a new rate is
1792	* needed each and every time.
1793	*
1794	* With clk_dummy_maximize_rate_ops, this means that the rate will
1795	* trail along the maximum as it evolves.
1796	*/
1797	static void clk_range_test_set_range_rate_maximized(struct kunit *test)
1798	{
1799	struct clk_dummy_context *ctx = test->priv;
1800	struct clk_hw *hw = &ctx->hw;
1801	struct clk *clk = clk_hw_get_clk(hw, NULL);
1802	unsigned long rate;
1803
1804	KUNIT_ASSERT_EQ(test,
1805	clk_set_rate(clk, DUMMY_CLOCK_RATE_2 + 1000),
1806	0);
1807
1808	KUNIT_ASSERT_EQ(test,
1809	clk_set_rate_range(clk,
1810	DUMMY_CLOCK_RATE_1,
1811	DUMMY_CLOCK_RATE_2),
1812	0);
1813
1814	rate = clk_get_rate(clk);
1815	KUNIT_ASSERT_GT(test, rate, 0);
1816	KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_2);
1817
1818	KUNIT_ASSERT_EQ(test,
1819	clk_set_rate_range(clk,
1820	DUMMY_CLOCK_RATE_1,
1821	DUMMY_CLOCK_RATE_2 - 1000),
1822	0);
1823
1824	rate = clk_get_rate(clk);
1825	KUNIT_ASSERT_GT(test, rate, 0);
1826	KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_2 - 1000);
1827
1828	KUNIT_ASSERT_EQ(test,
1829	clk_set_rate_range(clk,
1830	DUMMY_CLOCK_RATE_1,
1831	DUMMY_CLOCK_RATE_2),
1832	0);
1833
1834	rate = clk_get_rate(clk);
1835	KUNIT_ASSERT_GT(test, rate, 0);
1836	KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_2);
1837
1838	clk_put(clk);
1839	}
1840
1841	/*
1842	* Test that if we have several subsequent calls to
1843	* clk_set_rate_range(), across multiple users, the core will reevaluate
1844	* whether a new rate is needed each and every time.
1845	*
1846	* With clk_dummy_maximize_rate_ops, this means that the rate will
1847	* trail along the maximum as it evolves.
1848	*/
1849	static void clk_range_test_multiple_set_range_rate_maximized(struct kunit *test)
1850	{
1851	struct clk_dummy_context *ctx = test->priv;
1852	struct clk_hw *hw = &ctx->hw;
1853	struct clk *clk = clk_hw_get_clk(hw, NULL);
1854	struct clk *user1, *user2;
1855	unsigned long rate;
1856
1857	user1 = clk_hw_get_clk(hw, NULL);
1858	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, user1);
1859
1860	user2 = clk_hw_get_clk(hw, NULL);
1861	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, user2);
1862
1863	KUNIT_ASSERT_EQ(test,
1864	clk_set_rate(clk, DUMMY_CLOCK_RATE_2 + 1000),
1865	0);
1866
1867	KUNIT_ASSERT_EQ(test,
1868	clk_set_rate_range(user1,
1869	0,
1870	DUMMY_CLOCK_RATE_2),
1871	0);
1872
1873	rate = clk_get_rate(clk);
1874	KUNIT_ASSERT_GT(test, rate, 0);
1875	KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_2);
1876
1877	KUNIT_ASSERT_EQ(test,
1878	clk_set_rate_range(user2,
1879	0,
1880	DUMMY_CLOCK_RATE_1),
1881	0);
1882
1883	rate = clk_get_rate(clk);
1884	KUNIT_ASSERT_GT(test, rate, 0);
1885	KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_1);
1886
1887	KUNIT_ASSERT_EQ(test,
1888	clk_drop_range(user2),
1889	0);
1890
1891	rate = clk_get_rate(clk);
1892	KUNIT_ASSERT_GT(test, rate, 0);
1893	KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_2);
1894
1895	clk_put(clk: user2);
1896	clk_put(clk: user1);
1897	clk_put(clk);
1898	}
1899
1900	/*
1901	* Test that if we have several subsequent calls to
1902	* clk_set_rate_range(), across multiple users, the core will reevaluate
1903	* whether a new rate is needed, including when a user drop its clock.
1904	*
1905	* With clk_dummy_maximize_rate_ops, this means that the rate will
1906	* trail along the maximum as it evolves.
1907	*/
1908	static void clk_range_test_multiple_set_range_rate_put_maximized(struct kunit *test)
1909	{
1910	struct clk_dummy_context *ctx = test->priv;
1911	struct clk_hw *hw = &ctx->hw;
1912	struct clk *clk = clk_hw_get_clk(hw, NULL);
1913	struct clk *user1, *user2;
1914	unsigned long rate;
1915
1916	user1 = clk_hw_get_clk(hw, NULL);
1917	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, user1);
1918
1919	user2 = clk_hw_get_clk(hw, NULL);
1920	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, user2);
1921
1922	KUNIT_ASSERT_EQ(test,
1923	clk_set_rate(clk, DUMMY_CLOCK_RATE_2 + 1000),
1924	0);
1925
1926	KUNIT_ASSERT_EQ(test,
1927	clk_set_rate_range(user1,
1928	0,
1929	DUMMY_CLOCK_RATE_2),
1930	0);
1931
1932	rate = clk_get_rate(clk);
1933	KUNIT_ASSERT_GT(test, rate, 0);
1934	KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_2);
1935
1936	KUNIT_ASSERT_EQ(test,
1937	clk_set_rate_range(user2,
1938	0,
1939	DUMMY_CLOCK_RATE_1),
1940	0);
1941
1942	rate = clk_get_rate(clk);
1943	KUNIT_ASSERT_GT(test, rate, 0);
1944	KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_1);
1945
1946	clk_put(clk: user2);
1947
1948	rate = clk_get_rate(clk);
1949	KUNIT_ASSERT_GT(test, rate, 0);
1950	KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_2);
1951
1952	clk_put(clk: user1);
1953	clk_put(clk);
1954	}
1955
1956	static struct kunit_case clk_range_maximize_test_cases[] = {
1957	KUNIT_CASE(clk_range_test_set_range_rate_maximized),
1958	KUNIT_CASE(clk_range_test_multiple_set_range_rate_maximized),
1959	KUNIT_CASE(clk_range_test_multiple_set_range_rate_put_maximized),
1960	{}
1961	};
1962
1963	/*
1964	* Test suite for a basic rate clock, without any parent.
1965	*
1966	* These tests exercise the rate range API: clk_set_rate_range(),
1967	* clk_set_min_rate(), clk_set_max_rate(), clk_drop_range(), with a
1968	* driver that will always try to run at the highest possible rate.
1969	*/
1970	static struct kunit_suite clk_range_maximize_test_suite = {
1971	.name = "clk-range-maximize-test",
1972	.init = clk_maximize_test_init,
1973	.exit = clk_test_exit,
1974	.test_cases = clk_range_maximize_test_cases,
1975	};
1976
1977	/*
1978	* Test that if we have several subsequent calls to
1979	* clk_set_rate_range(), the core will reevaluate whether a new rate is
1980	* needed each and every time.
1981	*
1982	* With clk_dummy_minimize_rate_ops, this means that the rate will
1983	* trail along the minimum as it evolves.
1984	*/
1985	static void clk_range_test_set_range_rate_minimized(struct kunit *test)
1986	{
1987	struct clk_dummy_context *ctx = test->priv;
1988	struct clk_hw *hw = &ctx->hw;
1989	struct clk *clk = clk_hw_get_clk(hw, NULL);
1990	unsigned long rate;
1991
1992	KUNIT_ASSERT_EQ(test,
1993	clk_set_rate(clk, DUMMY_CLOCK_RATE_1 - 1000),
1994	0);
1995
1996	KUNIT_ASSERT_EQ(test,
1997	clk_set_rate_range(clk,
1998	DUMMY_CLOCK_RATE_1,
1999	DUMMY_CLOCK_RATE_2),
2000	0);
2001
2002	rate = clk_get_rate(clk);
2003	KUNIT_ASSERT_GT(test, rate, 0);
2004	KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_1);
2005
2006	KUNIT_ASSERT_EQ(test,
2007	clk_set_rate_range(clk,
2008	DUMMY_CLOCK_RATE_1 + 1000,
2009	DUMMY_CLOCK_RATE_2),
2010	0);
2011
2012	rate = clk_get_rate(clk);
2013	KUNIT_ASSERT_GT(test, rate, 0);
2014	KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_1 + 1000);
2015
2016	KUNIT_ASSERT_EQ(test,
2017	clk_set_rate_range(clk,
2018	DUMMY_CLOCK_RATE_1,
2019	DUMMY_CLOCK_RATE_2),
2020	0);
2021
2022	rate = clk_get_rate(clk);
2023	KUNIT_ASSERT_GT(test, rate, 0);
2024	KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_1);
2025
2026	clk_put(clk);
2027	}
2028
2029	/*
2030	* Test that if we have several subsequent calls to
2031	* clk_set_rate_range(), across multiple users, the core will reevaluate
2032	* whether a new rate is needed each and every time.
2033	*
2034	* With clk_dummy_minimize_rate_ops, this means that the rate will
2035	* trail along the minimum as it evolves.
2036	*/
2037	static void clk_range_test_multiple_set_range_rate_minimized(struct kunit *test)
2038	{
2039	struct clk_dummy_context *ctx = test->priv;
2040	struct clk_hw *hw = &ctx->hw;
2041	struct clk *clk = clk_hw_get_clk(hw, NULL);
2042	struct clk *user1, *user2;
2043	unsigned long rate;
2044
2045	user1 = clk_hw_get_clk(hw, NULL);
2046	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, user1);
2047
2048	user2 = clk_hw_get_clk(hw, NULL);
2049	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, user2);
2050
2051	KUNIT_ASSERT_EQ(test,
2052	clk_set_rate_range(user1,
2053	DUMMY_CLOCK_RATE_1,
2054	ULONG_MAX),
2055	0);
2056
2057	rate = clk_get_rate(clk);
2058	KUNIT_ASSERT_GT(test, rate, 0);
2059	KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_1);
2060
2061	KUNIT_ASSERT_EQ(test,
2062	clk_set_rate_range(user2,
2063	DUMMY_CLOCK_RATE_2,
2064	ULONG_MAX),
2065	0);
2066
2067	rate = clk_get_rate(clk);
2068	KUNIT_ASSERT_GT(test, rate, 0);
2069	KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_2);
2070
2071	KUNIT_ASSERT_EQ(test,
2072	clk_drop_range(user2),
2073	0);
2074
2075	rate = clk_get_rate(clk);
2076	KUNIT_ASSERT_GT(test, rate, 0);
2077	KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_1);
2078
2079	clk_put(clk: user2);
2080	clk_put(clk: user1);
2081	clk_put(clk);
2082	}
2083
2084	/*
2085	* Test that if we have several subsequent calls to
2086	* clk_set_rate_range(), across multiple users, the core will reevaluate
2087	* whether a new rate is needed, including when a user drop its clock.
2088	*
2089	* With clk_dummy_minimize_rate_ops, this means that the rate will
2090	* trail along the minimum as it evolves.
2091	*/
2092	static void clk_range_test_multiple_set_range_rate_put_minimized(struct kunit *test)
2093	{
2094	struct clk_dummy_context *ctx = test->priv;
2095	struct clk_hw *hw = &ctx->hw;
2096	struct clk *clk = clk_hw_get_clk(hw, NULL);
2097	struct clk *user1, *user2;
2098	unsigned long rate;
2099
2100	user1 = clk_hw_get_clk(hw, NULL);
2101	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, user1);
2102
2103	user2 = clk_hw_get_clk(hw, NULL);
2104	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, user2);
2105
2106	KUNIT_ASSERT_EQ(test,
2107	clk_set_rate_range(user1,
2108	DUMMY_CLOCK_RATE_1,
2109	ULONG_MAX),
2110	0);
2111
2112	rate = clk_get_rate(clk);
2113	KUNIT_ASSERT_GT(test, rate, 0);
2114	KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_1);
2115
2116	KUNIT_ASSERT_EQ(test,
2117	clk_set_rate_range(user2,
2118	DUMMY_CLOCK_RATE_2,
2119	ULONG_MAX),
2120	0);
2121
2122	rate = clk_get_rate(clk);
2123	KUNIT_ASSERT_GT(test, rate, 0);
2124	KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_2);
2125
2126	clk_put(clk: user2);
2127
2128	rate = clk_get_rate(clk);
2129	KUNIT_ASSERT_GT(test, rate, 0);
2130	KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_1);
2131
2132	clk_put(clk: user1);
2133	clk_put(clk);
2134	}
2135
2136	static struct kunit_case clk_range_minimize_test_cases[] = {
2137	KUNIT_CASE(clk_range_test_set_range_rate_minimized),
2138	KUNIT_CASE(clk_range_test_multiple_set_range_rate_minimized),
2139	KUNIT_CASE(clk_range_test_multiple_set_range_rate_put_minimized),
2140	{}
2141	};
2142
2143	/*
2144	* Test suite for a basic rate clock, without any parent.
2145	*
2146	* These tests exercise the rate range API: clk_set_rate_range(),
2147	* clk_set_min_rate(), clk_set_max_rate(), clk_drop_range(), with a
2148	* driver that will always try to run at the lowest possible rate.
2149	*/
2150	static struct kunit_suite clk_range_minimize_test_suite = {
2151	.name = "clk-range-minimize-test",
2152	.init = clk_minimize_test_init,
2153	.exit = clk_test_exit,
2154	.test_cases = clk_range_minimize_test_cases,
2155	};
2156
2157	struct clk_leaf_mux_ctx {
2158	struct clk_multiple_parent_ctx mux_ctx;
2159	struct clk_hw hw;
2160	struct clk_hw parent;
2161	struct clk_rate_request *req;
2162	int (*determine_rate_func)(struct clk_hw *hw, struct clk_rate_request *req);
2163	};
2164
2165	static int clk_leaf_mux_determine_rate(struct clk_hw *hw, struct clk_rate_request *req)
2166	{
2167	struct clk_leaf_mux_ctx *ctx = container_of(hw, struct clk_leaf_mux_ctx, hw);
2168	int ret;
2169	struct clk_rate_request *parent_req = ctx->req;
2170
2171	clk_hw_forward_rate_request(core: hw, old_req: req, parent: req->best_parent_hw, req: parent_req, parent_rate: req->rate);
2172	ret = ctx->determine_rate_func(req->best_parent_hw, parent_req);
2173	if (ret)
2174	return ret;
2175
2176	req->rate = parent_req->rate;
2177
2178	return 0;
2179	}
2180
2181	static const struct clk_ops clk_leaf_mux_set_rate_parent_ops = {
2182	.determine_rate = clk_leaf_mux_determine_rate,
2183	.set_parent = clk_dummy_single_set_parent,
2184	.get_parent = clk_dummy_single_get_parent,
2185	};
2186
2187	static int
2188	clk_leaf_mux_set_rate_parent_test_init(struct kunit *test)
2189	{
2190	struct clk_leaf_mux_ctx *ctx;
2191	const char *top_parents[2] = { "parent-0", "parent-1" };
2192	int ret;
2193
2194	ctx = kunit_kzalloc(test, size: sizeof(*ctx), GFP_KERNEL);
2195	if (!ctx)
2196	return -ENOMEM;
2197	test->priv = ctx;
2198
2199	ctx->mux_ctx.parents_ctx[0].hw.init = CLK_HW_INIT_NO_PARENT("parent-0",
2200	&clk_dummy_rate_ops,
2201	0);
2202	ctx->mux_ctx.parents_ctx[0].rate = DUMMY_CLOCK_RATE_1;
2203	ret = clk_hw_register(NULL, hw: &ctx->mux_ctx.parents_ctx[0].hw);
2204	if (ret)
2205	return ret;
2206
2207	ctx->mux_ctx.parents_ctx[1].hw.init = CLK_HW_INIT_NO_PARENT("parent-1",
2208	&clk_dummy_rate_ops,
2209	0);
2210	ctx->mux_ctx.parents_ctx[1].rate = DUMMY_CLOCK_RATE_2;
2211	ret = clk_hw_register(NULL, hw: &ctx->mux_ctx.parents_ctx[1].hw);
2212	if (ret)
2213	return ret;
2214
2215	ctx->mux_ctx.current_parent = 0;
2216	ctx->mux_ctx.hw.init = CLK_HW_INIT_PARENTS("test-mux", top_parents,
2217	&clk_multiple_parents_mux_ops,
2218	0);
2219	ret = clk_hw_register(NULL, hw: &ctx->mux_ctx.hw);
2220	if (ret)
2221	return ret;
2222
2223	ctx->parent.init = CLK_HW_INIT_HW("test-parent", &ctx->mux_ctx.hw,
2224	&empty_clk_ops, CLK_SET_RATE_PARENT);
2225	ret = clk_hw_register(NULL, hw: &ctx->parent);
2226	if (ret)
2227	return ret;
2228
2229	ctx->hw.init = CLK_HW_INIT_HW("test-clock", &ctx->parent,
2230	&clk_leaf_mux_set_rate_parent_ops,
2231	CLK_SET_RATE_PARENT);
2232	ret = clk_hw_register(NULL, hw: &ctx->hw);
2233	if (ret)
2234	return ret;
2235
2236	return 0;
2237	}
2238
2239	static void clk_leaf_mux_set_rate_parent_test_exit(struct kunit *test)
2240	{
2241	struct clk_leaf_mux_ctx *ctx = test->priv;
2242
2243	clk_hw_unregister(hw: &ctx->hw);
2244	clk_hw_unregister(hw: &ctx->parent);
2245	clk_hw_unregister(hw: &ctx->mux_ctx.hw);
2246	clk_hw_unregister(hw: &ctx->mux_ctx.parents_ctx[0].hw);
2247	clk_hw_unregister(hw: &ctx->mux_ctx.parents_ctx[1].hw);
2248	}
2249
2250	struct clk_leaf_mux_set_rate_parent_determine_rate_test_case {
2251	const char *desc;
2252	int (*determine_rate_func)(struct clk_hw *hw, struct clk_rate_request *req);
2253	};
2254
2255	static void
2256	clk_leaf_mux_set_rate_parent_determine_rate_test_case_to_desc(
2257	const struct clk_leaf_mux_set_rate_parent_determine_rate_test_case *t, char *desc)
2258	{
2259	strcpy(p: desc, q: t->desc);
2260	}
2261
2262	static const struct clk_leaf_mux_set_rate_parent_determine_rate_test_case
2263	clk_leaf_mux_set_rate_parent_determine_rate_test_cases[] = {
2264	{
2265	/*
2266	* Test that __clk_determine_rate() on the parent that can't
2267	* change rate doesn't return a clk_rate_request structure with
2268	* the best_parent_hw pointer pointing to the parent.
2269	*/
2270	.desc = "clk_leaf_mux_set_rate_parent__clk_determine_rate_proper_parent",
2271	.determine_rate_func = __clk_determine_rate,
2272	},
2273	{
2274	/*
2275	* Test that __clk_mux_determine_rate() on the parent that
2276	* can't change rate doesn't return a clk_rate_request
2277	* structure with the best_parent_hw pointer pointing to
2278	* the parent.
2279	*/
2280	.desc = "clk_leaf_mux_set_rate_parent__clk_mux_determine_rate_proper_parent",
2281	.determine_rate_func = __clk_mux_determine_rate,
2282	},
2283	{
2284	/*
2285	* Test that __clk_mux_determine_rate_closest() on the parent
2286	* that can't change rate doesn't return a clk_rate_request
2287	* structure with the best_parent_hw pointer pointing to
2288	* the parent.
2289	*/
2290	.desc = "clk_leaf_mux_set_rate_parent__clk_mux_determine_rate_closest_proper_parent",
2291	.determine_rate_func = __clk_mux_determine_rate_closest,
2292	},
2293	{
2294	/*
2295	* Test that clk_hw_determine_rate_no_reparent() on the parent
2296	* that can't change rate doesn't return a clk_rate_request
2297	* structure with the best_parent_hw pointer pointing to
2298	* the parent.
2299	*/
2300	.desc = "clk_leaf_mux_set_rate_parent_clk_hw_determine_rate_no_reparent_proper_parent",
2301	.determine_rate_func = clk_hw_determine_rate_no_reparent,
2302	},
2303	};
2304
2305	KUNIT_ARRAY_PARAM(clk_leaf_mux_set_rate_parent_determine_rate_test,
2306	clk_leaf_mux_set_rate_parent_determine_rate_test_cases,
2307	clk_leaf_mux_set_rate_parent_determine_rate_test_case_to_desc)
2308
2309	/*
2310	* Test that when a clk that can't change rate itself calls a function like
2311	* __clk_determine_rate() on its parent it doesn't get back a clk_rate_request
2312	* structure that has the best_parent_hw pointer point to the clk_hw passed
2313	* into the determine rate function. See commit 262ca38f4b6e ("clk: Stop
2314	* forwarding clk_rate_requests to the parent") for more background.
2315	*/
2316	static void clk_leaf_mux_set_rate_parent_determine_rate_test(struct kunit *test)
2317	{
2318	struct clk_leaf_mux_ctx *ctx = test->priv;
2319	struct clk_hw *hw = &ctx->hw;
2320	struct clk *clk = clk_hw_get_clk(hw, NULL);
2321	struct clk_rate_request req;
2322	unsigned long rate;
2323	const struct clk_leaf_mux_set_rate_parent_determine_rate_test_case *test_param;
2324
2325	test_param = test->param_value;
2326	ctx->determine_rate_func = test_param->determine_rate_func;
2327
2328	ctx->req = &req;
2329	rate = clk_get_rate(clk);
2330	KUNIT_ASSERT_EQ(test, rate, DUMMY_CLOCK_RATE_1);
2331	KUNIT_ASSERT_EQ(test, DUMMY_CLOCK_RATE_2, clk_round_rate(clk, DUMMY_CLOCK_RATE_2));
2332
2333	KUNIT_EXPECT_EQ(test, req.rate, DUMMY_CLOCK_RATE_2);
2334	KUNIT_EXPECT_EQ(test, req.best_parent_rate, DUMMY_CLOCK_RATE_2);
2335	KUNIT_EXPECT_PTR_EQ(test, req.best_parent_hw, &ctx->mux_ctx.hw);
2336
2337	clk_put(clk);
2338	}
2339
2340	static struct kunit_case clk_leaf_mux_set_rate_parent_test_cases[] = {
2341	KUNIT_CASE_PARAM(clk_leaf_mux_set_rate_parent_determine_rate_test,
2342	clk_leaf_mux_set_rate_parent_determine_rate_test_gen_params),
2343	{}
2344	};
2345
2346	/*
2347	* Test suite for a clock whose parent is a pass-through clk whose parent is a
2348	* mux with multiple parents. The leaf and pass-through clocks have the
2349	* CLK_SET_RATE_PARENT flag, and will forward rate requests to the mux, which
2350	* will then select which parent is the best fit for a given rate.
2351	*
2352	* These tests exercise the behaviour of muxes, and the proper selection
2353	* of parents.
2354	*/
2355	static struct kunit_suite clk_leaf_mux_set_rate_parent_test_suite = {
2356	.name = "clk-leaf-mux-set-rate-parent",
2357	.init = clk_leaf_mux_set_rate_parent_test_init,
2358	.exit = clk_leaf_mux_set_rate_parent_test_exit,
2359	.test_cases = clk_leaf_mux_set_rate_parent_test_cases,
2360	};
2361
2362	struct clk_mux_notifier_rate_change {
2363	bool done;
2364	unsigned long old_rate;
2365	unsigned long new_rate;
2366	wait_queue_head_t wq;
2367	};
2368
2369	struct clk_mux_notifier_ctx {
2370	struct clk_multiple_parent_ctx mux_ctx;
2371	struct clk *clk;
2372	struct notifier_block clk_nb;
2373	struct clk_mux_notifier_rate_change pre_rate_change;
2374	struct clk_mux_notifier_rate_change post_rate_change;
2375	};
2376
2377	#define NOTIFIER_TIMEOUT_MS 100
2378
2379	static int clk_mux_notifier_callback(struct notifier_block *nb,
2380	unsigned long action, void *data)
2381	{
2382	struct clk_notifier_data *clk_data = data;
2383	struct clk_mux_notifier_ctx *ctx = container_of(nb,
2384	struct clk_mux_notifier_ctx,
2385	clk_nb);
2386
2387	if (action & PRE_RATE_CHANGE) {
2388	ctx->pre_rate_change.old_rate = clk_data->old_rate;
2389	ctx->pre_rate_change.new_rate = clk_data->new_rate;
2390	ctx->pre_rate_change.done = true;
2391	wake_up_interruptible(&ctx->pre_rate_change.wq);
2392	}
2393
2394	if (action & POST_RATE_CHANGE) {
2395	ctx->post_rate_change.old_rate = clk_data->old_rate;
2396	ctx->post_rate_change.new_rate = clk_data->new_rate;
2397	ctx->post_rate_change.done = true;
2398	wake_up_interruptible(&ctx->post_rate_change.wq);
2399	}
2400
2401	return 0;
2402	}
2403
2404	static int clk_mux_notifier_test_init(struct kunit *test)
2405	{
2406	struct clk_mux_notifier_ctx *ctx;
2407	const char *top_parents[2] = { "parent-0", "parent-1" };
2408	int ret;
2409
2410	ctx = kunit_kzalloc(test, size: sizeof(*ctx), GFP_KERNEL);
2411	if (!ctx)
2412	return -ENOMEM;
2413	test->priv = ctx;
2414	ctx->clk_nb.notifier_call = clk_mux_notifier_callback;
2415	init_waitqueue_head(&ctx->pre_rate_change.wq);
2416	init_waitqueue_head(&ctx->post_rate_change.wq);
2417
2418	ctx->mux_ctx.parents_ctx[0].hw.init = CLK_HW_INIT_NO_PARENT("parent-0",
2419	&clk_dummy_rate_ops,
2420	0);
2421	ctx->mux_ctx.parents_ctx[0].rate = DUMMY_CLOCK_RATE_1;
2422	ret = clk_hw_register(NULL, hw: &ctx->mux_ctx.parents_ctx[0].hw);
2423	if (ret)
2424	return ret;
2425
2426	ctx->mux_ctx.parents_ctx[1].hw.init = CLK_HW_INIT_NO_PARENT("parent-1",
2427	&clk_dummy_rate_ops,
2428	0);
2429	ctx->mux_ctx.parents_ctx[1].rate = DUMMY_CLOCK_RATE_2;
2430	ret = clk_hw_register(NULL, hw: &ctx->mux_ctx.parents_ctx[1].hw);
2431	if (ret)
2432	return ret;
2433
2434	ctx->mux_ctx.current_parent = 0;
2435	ctx->mux_ctx.hw.init = CLK_HW_INIT_PARENTS("test-mux", top_parents,
2436	&clk_multiple_parents_mux_ops,
2437	0);
2438	ret = clk_hw_register(NULL, hw: &ctx->mux_ctx.hw);
2439	if (ret)
2440	return ret;
2441
2442	ctx->clk = clk_hw_get_clk(hw: &ctx->mux_ctx.hw, NULL);
2443	ret = clk_notifier_register(clk: ctx->clk, nb: &ctx->clk_nb);
2444	if (ret)
2445	return ret;
2446
2447	return 0;
2448	}
2449
2450	static void clk_mux_notifier_test_exit(struct kunit *test)
2451	{
2452	struct clk_mux_notifier_ctx *ctx = test->priv;
2453	struct clk *clk = ctx->clk;
2454
2455	clk_notifier_unregister(clk, nb: &ctx->clk_nb);
2456	clk_put(clk);
2457
2458	clk_hw_unregister(hw: &ctx->mux_ctx.hw);
2459	clk_hw_unregister(hw: &ctx->mux_ctx.parents_ctx[0].hw);
2460	clk_hw_unregister(hw: &ctx->mux_ctx.parents_ctx[1].hw);
2461	}
2462
2463	/*
2464	* Test that if the we have a notifier registered on a mux, the core
2465	* will notify us when we switch to another parent, and with the proper
2466	* old and new rates.
2467	*/
2468	static void clk_mux_notifier_set_parent_test(struct kunit *test)
2469	{
2470	struct clk_mux_notifier_ctx *ctx = test->priv;
2471	struct clk_hw *hw = &ctx->mux_ctx.hw;
2472	struct clk *clk = clk_hw_get_clk(hw, NULL);
2473	struct clk *new_parent = clk_hw_get_clk(hw: &ctx->mux_ctx.parents_ctx[1].hw, NULL);
2474	int ret;
2475
2476	ret = clk_set_parent(clk, parent: new_parent);
2477	KUNIT_ASSERT_EQ(test, ret, 0);
2478
2479	ret = wait_event_interruptible_timeout(ctx->pre_rate_change.wq,
2480	ctx->pre_rate_change.done,
2481	msecs_to_jiffies(NOTIFIER_TIMEOUT_MS));
2482	KUNIT_ASSERT_GT(test, ret, 0);
2483
2484	KUNIT_EXPECT_EQ(test, ctx->pre_rate_change.old_rate, DUMMY_CLOCK_RATE_1);
2485	KUNIT_EXPECT_EQ(test, ctx->pre_rate_change.new_rate, DUMMY_CLOCK_RATE_2);
2486
2487	ret = wait_event_interruptible_timeout(ctx->post_rate_change.wq,
2488	ctx->post_rate_change.done,
2489	msecs_to_jiffies(NOTIFIER_TIMEOUT_MS));
2490	KUNIT_ASSERT_GT(test, ret, 0);
2491
2492	KUNIT_EXPECT_EQ(test, ctx->post_rate_change.old_rate, DUMMY_CLOCK_RATE_1);
2493	KUNIT_EXPECT_EQ(test, ctx->post_rate_change.new_rate, DUMMY_CLOCK_RATE_2);
2494
2495	clk_put(clk: new_parent);
2496	clk_put(clk);
2497	}
2498
2499	static struct kunit_case clk_mux_notifier_test_cases[] = {
2500	KUNIT_CASE(clk_mux_notifier_set_parent_test),
2501	{}
2502	};
2503
2504	/*
2505	* Test suite for a mux with multiple parents, and a notifier registered
2506	* on the mux.
2507	*
2508	* These tests exercise the behaviour of notifiers.
2509	*/
2510	static struct kunit_suite clk_mux_notifier_test_suite = {
2511	.name = "clk-mux-notifier",
2512	.init = clk_mux_notifier_test_init,
2513	.exit = clk_mux_notifier_test_exit,
2514	.test_cases = clk_mux_notifier_test_cases,
2515	};
2516
2517	static int
2518	clk_mux_no_reparent_test_init(struct kunit *test)
2519	{
2520	struct clk_multiple_parent_ctx *ctx;
2521	const char *parents[2] = { "parent-0", "parent-1"};
2522	int ret;
2523
2524	ctx = kunit_kzalloc(test, size: sizeof(*ctx), GFP_KERNEL);
2525	if (!ctx)
2526	return -ENOMEM;
2527	test->priv = ctx;
2528
2529	ctx->parents_ctx[0].hw.init = CLK_HW_INIT_NO_PARENT("parent-0",
2530	&clk_dummy_rate_ops,
2531	0);
2532	ctx->parents_ctx[0].rate = DUMMY_CLOCK_RATE_1;
2533	ret = clk_hw_register(NULL, hw: &ctx->parents_ctx[0].hw);
2534	if (ret)
2535	return ret;
2536
2537	ctx->parents_ctx[1].hw.init = CLK_HW_INIT_NO_PARENT("parent-1",
2538	&clk_dummy_rate_ops,
2539	0);
2540	ctx->parents_ctx[1].rate = DUMMY_CLOCK_RATE_2;
2541	ret = clk_hw_register(NULL, hw: &ctx->parents_ctx[1].hw);
2542	if (ret)
2543	return ret;
2544
2545	ctx->current_parent = 0;
2546	ctx->hw.init = CLK_HW_INIT_PARENTS("test-mux", parents,
2547	&clk_multiple_parents_no_reparent_mux_ops,
2548	0);
2549	ret = clk_hw_register(NULL, hw: &ctx->hw);
2550	if (ret)
2551	return ret;
2552
2553	return 0;
2554	}
2555
2556	static void
2557	clk_mux_no_reparent_test_exit(struct kunit *test)
2558	{
2559	struct clk_multiple_parent_ctx *ctx = test->priv;
2560
2561	clk_hw_unregister(hw: &ctx->hw);
2562	clk_hw_unregister(hw: &ctx->parents_ctx[0].hw);
2563	clk_hw_unregister(hw: &ctx->parents_ctx[1].hw);
2564	}
2565
2566	/*
2567	* Test that if the we have a mux that cannot change parent and we call
2568	* clk_round_rate() on it with a rate that should cause it to change
2569	* parent, it won't.
2570	*/
2571	static void clk_mux_no_reparent_round_rate(struct kunit *test)
2572	{
2573	struct clk_multiple_parent_ctx *ctx = test->priv;
2574	struct clk_hw *hw = &ctx->hw;
2575	struct clk *clk = clk_hw_get_clk(hw, NULL);
2576	struct clk *other_parent, *parent;
2577	unsigned long other_parent_rate;
2578	unsigned long parent_rate;
2579	long rounded_rate;
2580
2581	parent = clk_get_parent(clk);
2582	KUNIT_ASSERT_PTR_NE(test, parent, NULL);
2583
2584	parent_rate = clk_get_rate(clk: parent);
2585	KUNIT_ASSERT_GT(test, parent_rate, 0);
2586
2587	other_parent = clk_hw_get_clk(hw: &ctx->parents_ctx[1].hw, NULL);
2588	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, other_parent);
2589	KUNIT_ASSERT_FALSE(test, clk_is_match(parent, other_parent));
2590
2591	other_parent_rate = clk_get_rate(clk: other_parent);
2592	KUNIT_ASSERT_GT(test, other_parent_rate, 0);
2593	clk_put(clk: other_parent);
2594
2595	rounded_rate = clk_round_rate(clk, rate: other_parent_rate);
2596	KUNIT_ASSERT_GT(test, rounded_rate, 0);
2597	KUNIT_EXPECT_EQ(test, rounded_rate, parent_rate);
2598
2599	clk_put(clk);
2600	}
2601
2602	/*
2603	* Test that if the we have a mux that cannot change parent and we call
2604	* clk_set_rate() on it with a rate that should cause it to change
2605	* parent, it won't.
2606	*/
2607	static void clk_mux_no_reparent_set_rate(struct kunit *test)
2608	{
2609	struct clk_multiple_parent_ctx *ctx = test->priv;
2610	struct clk_hw *hw = &ctx->hw;
2611	struct clk *clk = clk_hw_get_clk(hw, NULL);
2612	struct clk *other_parent, *parent;
2613	unsigned long other_parent_rate;
2614	unsigned long parent_rate;
2615	unsigned long rate;
2616	int ret;
2617
2618	parent = clk_get_parent(clk);
2619	KUNIT_ASSERT_PTR_NE(test, parent, NULL);
2620
2621	parent_rate = clk_get_rate(clk: parent);
2622	KUNIT_ASSERT_GT(test, parent_rate, 0);
2623
2624	other_parent = clk_hw_get_clk(hw: &ctx->parents_ctx[1].hw, NULL);
2625	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, other_parent);
2626	KUNIT_ASSERT_FALSE(test, clk_is_match(parent, other_parent));
2627
2628	other_parent_rate = clk_get_rate(clk: other_parent);
2629	KUNIT_ASSERT_GT(test, other_parent_rate, 0);
2630	clk_put(clk: other_parent);
2631
2632	ret = clk_set_rate(clk, rate: other_parent_rate);
2633	KUNIT_ASSERT_EQ(test, ret, 0);
2634
2635	rate = clk_get_rate(clk);
2636	KUNIT_ASSERT_GT(test, rate, 0);
2637	KUNIT_EXPECT_EQ(test, rate, parent_rate);
2638
2639	clk_put(clk);
2640	}
2641
2642	static struct kunit_case clk_mux_no_reparent_test_cases[] = {
2643	KUNIT_CASE(clk_mux_no_reparent_round_rate),
2644	KUNIT_CASE(clk_mux_no_reparent_set_rate),
2645	{}
2646	};
2647
2648	/*
2649	* Test suite for a clock mux that isn't allowed to change parent, using
2650	* the clk_hw_determine_rate_no_reparent() helper.
2651	*
2652	* These tests exercise that helper, and the proper selection of
2653	* rates and parents.
2654	*/
2655	static struct kunit_suite clk_mux_no_reparent_test_suite = {
2656	.name = "clk-mux-no-reparent",
2657	.init = clk_mux_no_reparent_test_init,
2658	.exit = clk_mux_no_reparent_test_exit,
2659	.test_cases = clk_mux_no_reparent_test_cases,
2660	};
2661
2662	kunit_test_suites(
2663	&clk_leaf_mux_set_rate_parent_test_suite,
2664	&clk_test_suite,
2665	&clk_multiple_parents_mux_test_suite,
2666	&clk_mux_no_reparent_test_suite,
2667	&clk_mux_notifier_test_suite,
2668	&clk_orphan_transparent_multiple_parent_mux_test_suite,
2669	&clk_orphan_transparent_single_parent_test_suite,
2670	&clk_orphan_two_level_root_last_test_suite,
2671	&clk_range_test_suite,
2672	&clk_range_maximize_test_suite,
2673	&clk_range_minimize_test_suite,
2674	&clk_single_parent_mux_test_suite,
2675	&clk_uncached_test_suite
2676	);
2677	MODULE_LICENSE("GPL v2");
2678