1	// SPDX-License-Identifier: GPL-2.0
2	/*
3	* Kunit tests for clk framework
4	*/
5	#include <linux/clk.h>
6	#include <linux/clk-provider.h>
7	#include <linux/clk/clk-conf.h>
8	#include <linux/of.h>
9	#include <linux/platform_device.h>
10
11	/* Needed for clk_hw_get_clk() */
12	#include "clk.h"
13
14	#include <kunit/clk.h>
15	#include <kunit/of.h>
16	#include <kunit/platform_device.h>
17	#include <kunit/test.h>
18
19	#include "kunit_clk_assigned_rates.h"
20	#include "clk_parent_data_test.h"
21
22	static const struct clk_ops empty_clk_ops = { };
23
24	#define DUMMY_CLOCK_INIT_RATE (42 * 1000 * 1000)
25	#define DUMMY_CLOCK_RATE_1 (142 * 1000 * 1000)
26	#define DUMMY_CLOCK_RATE_2 (242 * 1000 * 1000)
27
28	struct clk_dummy_context {
29	struct clk_hw hw;
30	unsigned long rate;
31	};
32
33	static unsigned long clk_dummy_recalc_rate(struct clk_hw *hw,
34	unsigned long parent_rate)
35	{
36	struct clk_dummy_context *ctx =
37	container_of(hw, struct clk_dummy_context, hw);
38
39	return ctx->rate;
40	}
41
42	static int clk_dummy_determine_rate(struct clk_hw *hw,
43	struct clk_rate_request *req)
44	{
45	/* Just return the same rate without modifying it */
46	return 0;
47	}
48
49	static int clk_dummy_maximize_rate(struct clk_hw *hw,
50	struct clk_rate_request *req)
51	{
52	/*
53	* If there's a maximum set, always run the clock at the maximum
54	* allowed.
55	*/
56	if (req->max_rate < ULONG_MAX)
57	req->rate = req->max_rate;
58
59	return 0;
60	}
61
62	static int clk_dummy_minimize_rate(struct clk_hw *hw,
63	struct clk_rate_request *req)
64	{
65	/*
66	* If there's a minimum set, always run the clock at the minimum
67	* allowed.
68	*/
69	if (req->min_rate > 0)
70	req->rate = req->min_rate;
71
72	return 0;
73	}
74
75	static int clk_dummy_set_rate(struct clk_hw *hw,
76	unsigned long rate,
77	unsigned long parent_rate)
78	{
79	struct clk_dummy_context *ctx =
80	container_of(hw, struct clk_dummy_context, hw);
81
82	ctx->rate = rate;
83	return 0;
84	}
85
86	static int clk_dummy_single_set_parent(struct clk_hw *hw, u8 index)
87	{
88	if (index >= clk_hw_get_num_parents(hw))
89	return -EINVAL;
90
91	return 0;
92	}
93
94	static u8 clk_dummy_single_get_parent(struct clk_hw *hw)
95	{
96	return 0;
97	}
98
99	static const struct clk_ops clk_dummy_rate_ops = {
100	.recalc_rate = clk_dummy_recalc_rate,
101	.determine_rate = clk_dummy_determine_rate,
102	.set_rate = clk_dummy_set_rate,
103	};
104
105	static const struct clk_ops clk_dummy_maximize_rate_ops = {
106	.recalc_rate = clk_dummy_recalc_rate,
107	.determine_rate = clk_dummy_maximize_rate,
108	.set_rate = clk_dummy_set_rate,
109	};
110
111	static const struct clk_ops clk_dummy_minimize_rate_ops = {
112	.recalc_rate = clk_dummy_recalc_rate,
113	.determine_rate = clk_dummy_minimize_rate,
114	.set_rate = clk_dummy_set_rate,
115	};
116
117	static const struct clk_ops clk_dummy_single_parent_ops = {
118	/*
119	* FIXME: Even though we should probably be able to use
120	* __clk_mux_determine_rate() here, if we use it and call
121	* clk_round_rate() or clk_set_rate() with a rate lower than
122	* what all the parents can provide, it will return -EINVAL.
123	*
124	* This is due to the fact that it has the undocumented
125	* behaviour to always pick up the closest rate higher than the
126	* requested rate. If we get something lower, it thus considers
127	* that it's not acceptable and will return an error.
128	*
129	* It's somewhat inconsistent and creates a weird threshold
130	* between rates above the parent rate which would be rounded to
131	* what the parent can provide, but rates below will simply
132	* return an error.
133	*/
134	.determine_rate = __clk_mux_determine_rate_closest,
135	.set_parent = clk_dummy_single_set_parent,
136	.get_parent = clk_dummy_single_get_parent,
137	};
138
139	struct clk_multiple_parent_ctx {
140	struct clk_dummy_context parents_ctx[2];
141	struct clk_hw hw;
142	u8 current_parent;
143	};
144
145	static int clk_multiple_parents_mux_set_parent(struct clk_hw *hw, u8 index)
146	{
147	struct clk_multiple_parent_ctx *ctx =
148	container_of(hw, struct clk_multiple_parent_ctx, hw);
149
150	if (index >= clk_hw_get_num_parents(hw))
151	return -EINVAL;
152
153	ctx->current_parent = index;
154
155	return 0;
156	}
157
158	static u8 clk_multiple_parents_mux_get_parent(struct clk_hw *hw)
159	{
160	struct clk_multiple_parent_ctx *ctx =
161	container_of(hw, struct clk_multiple_parent_ctx, hw);
162
163	return ctx->current_parent;
164	}
165
166	static const struct clk_ops clk_multiple_parents_mux_ops = {
167	.get_parent = clk_multiple_parents_mux_get_parent,
168	.set_parent = clk_multiple_parents_mux_set_parent,
169	.determine_rate = __clk_mux_determine_rate_closest,
170	};
171
172	static const struct clk_ops clk_multiple_parents_no_reparent_mux_ops = {
173	.determine_rate = clk_hw_determine_rate_no_reparent,
174	.get_parent = clk_multiple_parents_mux_get_parent,
175	.set_parent = clk_multiple_parents_mux_set_parent,
176	};
177
178	static int clk_test_init_with_ops(struct kunit *test, const struct clk_ops *ops)
179	{
180	struct clk_dummy_context *ctx;
181	struct clk_init_data init = { };
182	int ret;
183
184	ctx = kunit_kzalloc(test, size: sizeof(*ctx), GFP_KERNEL);
185	if (!ctx)
186	return -ENOMEM;
187	ctx->rate = DUMMY_CLOCK_INIT_RATE;
188	test->priv = ctx;
189
190	init.name = "test_dummy_rate";
191	init.ops = ops;
192	ctx->hw.init = &init;
193
194	ret = clk_hw_register(NULL, hw: &ctx->hw);
195	if (ret)
196	return ret;
197
198	return 0;
199	}
200
201	static int clk_test_init(struct kunit *test)
202	{
203	return clk_test_init_with_ops(test, ops: &clk_dummy_rate_ops);
204	}
205
206	static int clk_maximize_test_init(struct kunit *test)
207	{
208	return clk_test_init_with_ops(test, ops: &clk_dummy_maximize_rate_ops);
209	}
210
211	static int clk_minimize_test_init(struct kunit *test)
212	{
213	return clk_test_init_with_ops(test, ops: &clk_dummy_minimize_rate_ops);
214	}
215
216	static void clk_test_exit(struct kunit *test)
217	{
218	struct clk_dummy_context *ctx = test->priv;
219
220	clk_hw_unregister(hw: &ctx->hw);
221	}
222
223	/*
224	* Test that the actual rate matches what is returned by clk_get_rate()
225	*/
226	static void clk_test_get_rate(struct kunit *test)
227	{
228	struct clk_dummy_context *ctx = test->priv;
229	struct clk_hw *hw = &ctx->hw;
230	struct clk *clk = clk_hw_get_clk(hw, NULL);
231	unsigned long rate;
232
233	rate = clk_get_rate(clk);
234	KUNIT_ASSERT_GT(test, rate, 0);
235	KUNIT_EXPECT_EQ(test, rate, ctx->rate);
236
237	clk_put(clk);
238	}
239
240	/*
241	* Test that, after a call to clk_set_rate(), the rate returned by
242	* clk_get_rate() matches.
243	*
244	* This assumes that clk_ops.determine_rate or clk_ops.round_rate won't
245	* modify the requested rate, which is our case in clk_dummy_rate_ops.
246	*/
247	static void clk_test_set_get_rate(struct kunit *test)
248	{
249	struct clk_dummy_context *ctx = test->priv;
250	struct clk_hw *hw = &ctx->hw;
251	struct clk *clk = clk_hw_get_clk(hw, NULL);
252	unsigned long rate;
253
254	KUNIT_ASSERT_EQ(test,
255	clk_set_rate(clk, DUMMY_CLOCK_RATE_1),
256	0);
257
258	rate = clk_get_rate(clk);
259	KUNIT_ASSERT_GT(test, rate, 0);
260	KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_1);
261
262	clk_put(clk);
263	}
264
265	/*
266	* Test that, after several calls to clk_set_rate(), the rate returned
267	* by clk_get_rate() matches the last one.
268	*
269	* This assumes that clk_ops.determine_rate or clk_ops.round_rate won't
270	* modify the requested rate, which is our case in clk_dummy_rate_ops.
271	*/
272	static void clk_test_set_set_get_rate(struct kunit *test)
273	{
274	struct clk_dummy_context *ctx = test->priv;
275	struct clk_hw *hw = &ctx->hw;
276	struct clk *clk = clk_hw_get_clk(hw, NULL);
277	unsigned long rate;
278
279	KUNIT_ASSERT_EQ(test,
280	clk_set_rate(clk, DUMMY_CLOCK_RATE_1),
281	0);
282
283	KUNIT_ASSERT_EQ(test,
284	clk_set_rate(clk, DUMMY_CLOCK_RATE_2),
285	0);
286
287	rate = clk_get_rate(clk);
288	KUNIT_ASSERT_GT(test, rate, 0);
289	KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_2);
290
291	clk_put(clk);
292	}
293
294	/*
295	* Test that clk_round_rate and clk_set_rate are consistent and will
296	* return the same frequency.
297	*/
298	static void clk_test_round_set_get_rate(struct kunit *test)
299	{
300	struct clk_dummy_context *ctx = test->priv;
301	struct clk_hw *hw = &ctx->hw;
302	struct clk *clk = clk_hw_get_clk(hw, NULL);
303	unsigned long set_rate;
304	long rounded_rate;
305
306	rounded_rate = clk_round_rate(clk, DUMMY_CLOCK_RATE_1);
307	KUNIT_ASSERT_GT(test, rounded_rate, 0);
308	KUNIT_EXPECT_EQ(test, rounded_rate, DUMMY_CLOCK_RATE_1);
309
310	KUNIT_ASSERT_EQ(test,
311	clk_set_rate(clk, DUMMY_CLOCK_RATE_1),
312	0);
313
314	set_rate = clk_get_rate(clk);
315	KUNIT_ASSERT_GT(test, set_rate, 0);
316	KUNIT_EXPECT_EQ(test, rounded_rate, set_rate);
317
318	clk_put(clk);
319	}
320
321	static struct kunit_case clk_test_cases[] = {
322	KUNIT_CASE(clk_test_get_rate),
323	KUNIT_CASE(clk_test_set_get_rate),
324	KUNIT_CASE(clk_test_set_set_get_rate),
325	KUNIT_CASE(clk_test_round_set_get_rate),
326	{}
327	};
328
329	/*
330	* Test suite for a basic rate clock, without any parent.
331	*
332	* These tests exercise the rate API with simple scenarios
333	*/
334	static struct kunit_suite clk_test_suite = {
335	.name = "clk-test",
336	.init = clk_test_init,
337	.exit = clk_test_exit,
338	.test_cases = clk_test_cases,
339	};
340
341	static int clk_uncached_test_init(struct kunit *test)
342	{
343	struct clk_dummy_context *ctx;
344	int ret;
345
346	ctx = kunit_kzalloc(test, size: sizeof(*ctx), GFP_KERNEL);
347	if (!ctx)
348	return -ENOMEM;
349	test->priv = ctx;
350
351	ctx->rate = DUMMY_CLOCK_INIT_RATE;
352	ctx->hw.init = CLK_HW_INIT_NO_PARENT("test-clk",
353	&clk_dummy_rate_ops,
354	CLK_GET_RATE_NOCACHE);
355
356	ret = clk_hw_register(NULL, hw: &ctx->hw);
357	if (ret)
358	return ret;
359
360	return 0;
361	}
362
363	/*
364	* Test that for an uncached clock, the clock framework doesn't cache
365	* the rate and clk_get_rate() will return the underlying clock rate
366	* even if it changed.
367	*/
368	static void clk_test_uncached_get_rate(struct kunit *test)
369	{
370	struct clk_dummy_context *ctx = test->priv;
371	struct clk_hw *hw = &ctx->hw;
372	struct clk *clk = clk_hw_get_clk(hw, NULL);
373	unsigned long rate;
374
375	rate = clk_get_rate(clk);
376	KUNIT_ASSERT_GT(test, rate, 0);
377	KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_INIT_RATE);
378
379	/* We change the rate behind the clock framework's back */
380	ctx->rate = DUMMY_CLOCK_RATE_1;
381	rate = clk_get_rate(clk);
382	KUNIT_ASSERT_GT(test, rate, 0);
383	KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_1);
384
385	clk_put(clk);
386	}
387
388	/*
389	* Test that for an uncached clock, clk_set_rate_range() will work
390	* properly if the rate hasn't changed.
391	*/
392	static void clk_test_uncached_set_range(struct kunit *test)
393	{
394	struct clk_dummy_context *ctx = test->priv;
395	struct clk_hw *hw = &ctx->hw;
396	struct clk *clk = clk_hw_get_clk(hw, NULL);
397	unsigned long rate;
398
399	KUNIT_ASSERT_EQ(test,
400	clk_set_rate_range(clk,
401	DUMMY_CLOCK_RATE_1,
402	DUMMY_CLOCK_RATE_2),
403	0);
404
405	rate = clk_get_rate(clk);
406	KUNIT_ASSERT_GT(test, rate, 0);
407	KUNIT_EXPECT_GE(test, rate, DUMMY_CLOCK_RATE_1);
408	KUNIT_EXPECT_LE(test, rate, DUMMY_CLOCK_RATE_2);
409
410	clk_put(clk);
411	}
412
413	/*
414	* Test that for an uncached clock, clk_set_rate_range() will work
415	* properly if the rate has changed in hardware.
416	*
417	* In this case, it means that if the rate wasn't initially in the range
418	* we're trying to set, but got changed at some point into the range
419	* without the kernel knowing about it, its rate shouldn't be affected.
420	*/
421	static void clk_test_uncached_updated_rate_set_range(struct kunit *test)
422	{
423	struct clk_dummy_context *ctx = test->priv;
424	struct clk_hw *hw = &ctx->hw;
425	struct clk *clk = clk_hw_get_clk(hw, NULL);
426	unsigned long rate;
427
428	/* We change the rate behind the clock framework's back */
429	ctx->rate = DUMMY_CLOCK_RATE_1 + 1000;
430	KUNIT_ASSERT_EQ(test,
431	clk_set_rate_range(clk,
432	DUMMY_CLOCK_RATE_1,
433	DUMMY_CLOCK_RATE_2),
434	0);
435
436	rate = clk_get_rate(clk);
437	KUNIT_ASSERT_GT(test, rate, 0);
438	KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_1 + 1000);
439
440	clk_put(clk);
441	}
442
443	static struct kunit_case clk_uncached_test_cases[] = {
444	KUNIT_CASE(clk_test_uncached_get_rate),
445	KUNIT_CASE(clk_test_uncached_set_range),
446	KUNIT_CASE(clk_test_uncached_updated_rate_set_range),
447	{}
448	};
449
450	/*
451	* Test suite for a basic, uncached, rate clock, without any parent.
452	*
453	* These tests exercise the rate API with simple scenarios
454	*/
455	static struct kunit_suite clk_uncached_test_suite = {
456	.name = "clk-uncached-test",
457	.init = clk_uncached_test_init,
458	.exit = clk_test_exit,
459	.test_cases = clk_uncached_test_cases,
460	};
461
462	static int
463	clk_multiple_parents_mux_test_init(struct kunit *test)
464	{
465	struct clk_multiple_parent_ctx *ctx;
466	const char *parents[2] = { "parent-0", "parent-1"};
467	int ret;
468
469	ctx = kunit_kzalloc(test, size: sizeof(*ctx), GFP_KERNEL);
470	if (!ctx)
471	return -ENOMEM;
472	test->priv = ctx;
473
474	ctx->parents_ctx[0].hw.init = CLK_HW_INIT_NO_PARENT("parent-0",
475	&clk_dummy_rate_ops,
476	0);
477	ctx->parents_ctx[0].rate = DUMMY_CLOCK_RATE_1;
478	ret = clk_hw_register_kunit(test, NULL, hw: &ctx->parents_ctx[0].hw);
479	if (ret)
480	return ret;
481
482	ctx->parents_ctx[1].hw.init = CLK_HW_INIT_NO_PARENT("parent-1",
483	&clk_dummy_rate_ops,
484	0);
485	ctx->parents_ctx[1].rate = DUMMY_CLOCK_RATE_2;
486	ret = clk_hw_register_kunit(test, NULL, hw: &ctx->parents_ctx[1].hw);
487	if (ret)
488	return ret;
489
490	ctx->current_parent = 0;
491	ctx->hw.init = CLK_HW_INIT_PARENTS("test-mux", parents,
492	&clk_multiple_parents_mux_ops,
493	CLK_SET_RATE_PARENT);
494	ret = clk_hw_register_kunit(test, NULL, hw: &ctx->hw);
495	if (ret)
496	return ret;
497
498	return 0;
499	}
500
501	/*
502	* Test that for a clock with multiple parents, clk_get_parent()
503	* actually returns the current one.
504	*/
505	static void
506	clk_test_multiple_parents_mux_get_parent(struct kunit *test)
507	{
508	struct clk_multiple_parent_ctx *ctx = test->priv;
509	struct clk_hw *hw = &ctx->hw;
510	struct clk *clk = clk_hw_get_clk(hw, NULL);
511	struct clk *parent = clk_hw_get_clk(hw: &ctx->parents_ctx[0].hw, NULL);
512
513	KUNIT_EXPECT_TRUE(test, clk_is_match(clk_get_parent(clk), parent));
514
515	clk_put(clk: parent);
516	clk_put(clk);
517	}
518
519	/*
520	* Test that for a clock with a multiple parents, clk_has_parent()
521	* actually reports all of them as parents.
522	*/
523	static void
524	clk_test_multiple_parents_mux_has_parent(struct kunit *test)
525	{
526	struct clk_multiple_parent_ctx *ctx = test->priv;
527	struct clk_hw *hw = &ctx->hw;
528	struct clk *clk = clk_hw_get_clk(hw, NULL);
529	struct clk *parent;
530
531	parent = clk_hw_get_clk(hw: &ctx->parents_ctx[0].hw, NULL);
532	KUNIT_EXPECT_TRUE(test, clk_has_parent(clk, parent));
533	clk_put(clk: parent);
534
535	parent = clk_hw_get_clk(hw: &ctx->parents_ctx[1].hw, NULL);
536	KUNIT_EXPECT_TRUE(test, clk_has_parent(clk, parent));
537	clk_put(clk: parent);
538
539	clk_put(clk);
540	}
541
542	/*
543	* Test that for a clock with a multiple parents, if we set a range on
544	* that clock and the parent is changed, its rate after the reparenting
545	* is still within the range we asked for.
546	*
547	* FIXME: clk_set_parent() only does the reparenting but doesn't
548	* reevaluate whether the new clock rate is within its boundaries or
549	* not.
550	*/
551	static void
552	clk_test_multiple_parents_mux_set_range_set_parent_get_rate(struct kunit *test)
553	{
554	struct clk_multiple_parent_ctx *ctx = test->priv;
555	struct clk_hw *hw = &ctx->hw;
556	struct clk *clk = clk_hw_get_clk_kunit(test, hw, NULL);
557	struct clk *parent1, *parent2;
558	unsigned long rate;
559	int ret;
560
561	kunit_skip(test, "This needs to be fixed in the core.");
562
563	parent1 = clk_hw_get_clk_kunit(test, hw: &ctx->parents_ctx[0].hw, NULL);
564	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent1);
565	KUNIT_ASSERT_TRUE(test, clk_is_match(clk_get_parent(clk), parent1));
566
567	parent2 = clk_hw_get_clk_kunit(test, hw: &ctx->parents_ctx[1].hw, NULL);
568	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent2);
569
570	ret = clk_set_rate(clk: parent1, DUMMY_CLOCK_RATE_1);
571	KUNIT_ASSERT_EQ(test, ret, 0);
572
573	ret = clk_set_rate(clk: parent2, DUMMY_CLOCK_RATE_2);
574	KUNIT_ASSERT_EQ(test, ret, 0);
575
576	ret = clk_set_rate_range(clk,
577	DUMMY_CLOCK_RATE_1 - 1000,
578	DUMMY_CLOCK_RATE_1 + 1000);
579	KUNIT_ASSERT_EQ(test, ret, 0);
580
581	ret = clk_set_parent(clk, parent: parent2);
582	KUNIT_ASSERT_EQ(test, ret, 0);
583
584	rate = clk_get_rate(clk);
585	KUNIT_ASSERT_GT(test, rate, 0);
586	KUNIT_EXPECT_GE(test, rate, DUMMY_CLOCK_RATE_1 - 1000);
587	KUNIT_EXPECT_LE(test, rate, DUMMY_CLOCK_RATE_1 + 1000);
588	}
589
590	static struct kunit_case clk_multiple_parents_mux_test_cases[] = {
591	KUNIT_CASE(clk_test_multiple_parents_mux_get_parent),
592	KUNIT_CASE(clk_test_multiple_parents_mux_has_parent),
593	KUNIT_CASE(clk_test_multiple_parents_mux_set_range_set_parent_get_rate),
594	{}
595	};
596
597	/*
598	* Test suite for a basic mux clock with two parents, with
599	* CLK_SET_RATE_PARENT on the child.
600	*
601	* These tests exercise the consumer API and check that the state of the
602	* child and parents are sane and consistent.
603	*/
604	static struct kunit_suite
605	clk_multiple_parents_mux_test_suite = {
606	.name = "clk-multiple-parents-mux-test",
607	.init = clk_multiple_parents_mux_test_init,
608	.test_cases = clk_multiple_parents_mux_test_cases,
609	};
610
611	static int
612	clk_orphan_transparent_multiple_parent_mux_test_init(struct kunit *test)
613	{
614	struct clk_multiple_parent_ctx *ctx;
615	const char *parents[2] = { "missing-parent", "proper-parent"};
616	int ret;
617
618	ctx = kunit_kzalloc(test, size: sizeof(*ctx), GFP_KERNEL);
619	if (!ctx)
620	return -ENOMEM;
621	test->priv = ctx;
622
623	ctx->parents_ctx[1].hw.init = CLK_HW_INIT_NO_PARENT("proper-parent",
624	&clk_dummy_rate_ops,
625	0);
626	ctx->parents_ctx[1].rate = DUMMY_CLOCK_INIT_RATE;
627	ret = clk_hw_register_kunit(test, NULL, hw: &ctx->parents_ctx[1].hw);
628	if (ret)
629	return ret;
630
631	ctx->hw.init = CLK_HW_INIT_PARENTS("test-orphan-mux", parents,
632	&clk_multiple_parents_mux_ops,
633	CLK_SET_RATE_PARENT);
634	ret = clk_hw_register_kunit(test, NULL, hw: &ctx->hw);
635	if (ret)
636	return ret;
637
638	return 0;
639	}
640
641	/*
642	* Test that, for a mux whose current parent hasn't been registered yet and is
643	* thus orphan, clk_get_parent() will return NULL.
644	*/
645	static void
646	clk_test_orphan_transparent_multiple_parent_mux_get_parent(struct kunit *test)
647	{
648	struct clk_multiple_parent_ctx *ctx = test->priv;
649	struct clk_hw *hw = &ctx->hw;
650	struct clk *clk = clk_hw_get_clk(hw, NULL);
651
652	KUNIT_EXPECT_PTR_EQ(test, clk_get_parent(clk), NULL);
653
654	clk_put(clk);
655	}
656
657	/*
658	* Test that, for a mux whose current parent hasn't been registered yet,
659	* calling clk_set_parent() to a valid parent will properly update the
660	* mux parent and its orphan status.
661	*/
662	static void
663	clk_test_orphan_transparent_multiple_parent_mux_set_parent(struct kunit *test)
664	{
665	struct clk_multiple_parent_ctx *ctx = test->priv;
666	struct clk_hw *hw = &ctx->hw;
667	struct clk *clk = clk_hw_get_clk(hw, NULL);
668	struct clk *parent, *new_parent;
669	int ret;
670
671	parent = clk_hw_get_clk(hw: &ctx->parents_ctx[1].hw, NULL);
672	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent);
673
674	ret = clk_set_parent(clk, parent);
675	KUNIT_ASSERT_EQ(test, ret, 0);
676
677	new_parent = clk_get_parent(clk);
678	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent);
679	KUNIT_EXPECT_TRUE(test, clk_is_match(parent, new_parent));
680
681	clk_put(clk: parent);
682	clk_put(clk);
683	}
684
685	/*
686	* Test that, for a mux that started orphan but got switched to a valid
687	* parent, calling clk_drop_range() on the mux won't affect the parent
688	* rate.
689	*/
690	static void
691	clk_test_orphan_transparent_multiple_parent_mux_set_parent_drop_range(struct kunit *test)
692	{
693	struct clk_multiple_parent_ctx *ctx = test->priv;
694	struct clk_hw *hw = &ctx->hw;
695	struct clk *clk = clk_hw_get_clk(hw, NULL);
696	struct clk *parent;
697	unsigned long parent_rate, new_parent_rate;
698	int ret;
699
700	parent = clk_hw_get_clk(hw: &ctx->parents_ctx[1].hw, NULL);
701	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent);
702
703	parent_rate = clk_get_rate(clk: parent);
704	KUNIT_ASSERT_GT(test, parent_rate, 0);
705
706	ret = clk_set_parent(clk, parent);
707	KUNIT_ASSERT_EQ(test, ret, 0);
708
709	ret = clk_drop_range(clk);
710	KUNIT_ASSERT_EQ(test, ret, 0);
711
712	new_parent_rate = clk_get_rate(clk);
713	KUNIT_ASSERT_GT(test, new_parent_rate, 0);
714	KUNIT_EXPECT_EQ(test, parent_rate, new_parent_rate);
715
716	clk_put(clk: parent);
717	clk_put(clk);
718	}
719
720	/*
721	* Test that, for a mux that started orphan but got switched to a valid
722	* parent, the rate of the mux and its new parent are consistent.
723	*/
724	static void
725	clk_test_orphan_transparent_multiple_parent_mux_set_parent_get_rate(struct kunit *test)
726	{
727	struct clk_multiple_parent_ctx *ctx = test->priv;
728	struct clk_hw *hw = &ctx->hw;
729	struct clk *clk = clk_hw_get_clk(hw, NULL);
730	struct clk *parent;
731	unsigned long parent_rate, rate;
732	int ret;
733
734	parent = clk_hw_get_clk(hw: &ctx->parents_ctx[1].hw, NULL);
735	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent);
736
737	parent_rate = clk_get_rate(clk: parent);
738	KUNIT_ASSERT_GT(test, parent_rate, 0);
739
740	ret = clk_set_parent(clk, parent);
741	KUNIT_ASSERT_EQ(test, ret, 0);
742
743	rate = clk_get_rate(clk);
744	KUNIT_ASSERT_GT(test, rate, 0);
745	KUNIT_EXPECT_EQ(test, parent_rate, rate);
746
747	clk_put(clk: parent);
748	clk_put(clk);
749	}
750
751	/*
752	* Test that, for a mux that started orphan but got switched to a valid
753	* parent, calling clk_put() on the mux won't affect the parent rate.
754	*/
755	static void
756	clk_test_orphan_transparent_multiple_parent_mux_set_parent_put(struct kunit *test)
757	{
758	struct clk_multiple_parent_ctx *ctx = test->priv;
759	struct clk *clk, *parent;
760	unsigned long parent_rate, new_parent_rate;
761	int ret;
762
763	parent = clk_hw_get_clk(hw: &ctx->parents_ctx[1].hw, NULL);
764	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent);
765
766	clk = clk_hw_get_clk(hw: &ctx->hw, NULL);
767	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, clk);
768
769	parent_rate = clk_get_rate(clk: parent);
770	KUNIT_ASSERT_GT(test, parent_rate, 0);
771
772	ret = clk_set_parent(clk, parent);
773	KUNIT_ASSERT_EQ(test, ret, 0);
774
775	clk_put(clk);
776
777	new_parent_rate = clk_get_rate(clk: parent);
778	KUNIT_ASSERT_GT(test, new_parent_rate, 0);
779	KUNIT_EXPECT_EQ(test, parent_rate, new_parent_rate);
780
781	clk_put(clk: parent);
782	}
783
784	/*
785	* Test that, for a mux that started orphan but got switched to a valid
786	* parent, calling clk_set_rate_range() will affect the parent state if
787	* its rate is out of range.
788	*/
789	static void
790	clk_test_orphan_transparent_multiple_parent_mux_set_parent_set_range_modified(struct kunit *test)
791	{
792	struct clk_multiple_parent_ctx *ctx = test->priv;
793	struct clk_hw *hw = &ctx->hw;
794	struct clk *clk = clk_hw_get_clk(hw, NULL);
795	struct clk *parent;
796	unsigned long rate;
797	int ret;
798
799	parent = clk_hw_get_clk(hw: &ctx->parents_ctx[1].hw, NULL);
800	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent);
801
802	ret = clk_set_parent(clk, parent);
803	KUNIT_ASSERT_EQ(test, ret, 0);
804
805	ret = clk_set_rate_range(clk, DUMMY_CLOCK_RATE_1, DUMMY_CLOCK_RATE_2);
806	KUNIT_ASSERT_EQ(test, ret, 0);
807
808	rate = clk_get_rate(clk);
809	KUNIT_ASSERT_GT(test, rate, 0);
810	KUNIT_EXPECT_GE(test, rate, DUMMY_CLOCK_RATE_1);
811	KUNIT_EXPECT_LE(test, rate, DUMMY_CLOCK_RATE_2);
812
813	clk_put(clk: parent);
814	clk_put(clk);
815	}
816
817	/*
818	* Test that, for a mux that started orphan but got switched to a valid
819	* parent, calling clk_set_rate_range() won't affect the parent state if
820	* its rate is within range.
821	*/
822	static void
823	clk_test_orphan_transparent_multiple_parent_mux_set_parent_set_range_untouched(struct kunit *test)
824	{
825	struct clk_multiple_parent_ctx *ctx = test->priv;
826	struct clk_hw *hw = &ctx->hw;
827	struct clk *clk = clk_hw_get_clk(hw, NULL);
828	struct clk *parent;
829	unsigned long parent_rate, new_parent_rate;
830	int ret;
831
832	parent = clk_hw_get_clk(hw: &ctx->parents_ctx[1].hw, NULL);
833	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent);
834
835	parent_rate = clk_get_rate(clk: parent);
836	KUNIT_ASSERT_GT(test, parent_rate, 0);
837
838	ret = clk_set_parent(clk, parent);
839	KUNIT_ASSERT_EQ(test, ret, 0);
840
841	ret = clk_set_rate_range(clk,
842	DUMMY_CLOCK_INIT_RATE - 1000,
843	DUMMY_CLOCK_INIT_RATE + 1000);
844	KUNIT_ASSERT_EQ(test, ret, 0);
845
846	new_parent_rate = clk_get_rate(clk: parent);
847	KUNIT_ASSERT_GT(test, new_parent_rate, 0);
848	KUNIT_EXPECT_EQ(test, parent_rate, new_parent_rate);
849
850	clk_put(clk: parent);
851	clk_put(clk);
852	}
853
854	/*
855	* Test that, for a mux whose current parent hasn't been registered yet,
856	* calling clk_set_rate_range() will succeed, and will be taken into
857	* account when rounding a rate.
858	*/
859	static void
860	clk_test_orphan_transparent_multiple_parent_mux_set_range_round_rate(struct kunit *test)
861	{
862	struct clk_multiple_parent_ctx *ctx = test->priv;
863	struct clk_hw *hw = &ctx->hw;
864	struct clk *clk = clk_hw_get_clk(hw, NULL);
865	long rate;
866	int ret;
867
868	ret = clk_set_rate_range(clk, DUMMY_CLOCK_RATE_1, DUMMY_CLOCK_RATE_2);
869	KUNIT_ASSERT_EQ(test, ret, 0);
870
871	rate = clk_round_rate(clk, DUMMY_CLOCK_RATE_1 - 1000);
872	KUNIT_ASSERT_GT(test, rate, 0);
873	KUNIT_EXPECT_GE(test, rate, DUMMY_CLOCK_RATE_1);
874	KUNIT_EXPECT_LE(test, rate, DUMMY_CLOCK_RATE_2);
875
876	clk_put(clk);
877	}
878
879	/*
880	* Test that, for a mux that started orphan, was assigned and rate and
881	* then got switched to a valid parent, its rate is eventually within
882	* range.
883	*
884	* FIXME: Even though we update the rate as part of clk_set_parent(), we
885	* don't evaluate whether that new rate is within range and needs to be
886	* adjusted.
887	*/
888	static void
889	clk_test_orphan_transparent_multiple_parent_mux_set_range_set_parent_get_rate(struct kunit *test)
890	{
891	struct clk_multiple_parent_ctx *ctx = test->priv;
892	struct clk_hw *hw = &ctx->hw;
893	struct clk *clk = clk_hw_get_clk_kunit(test, hw, NULL);
894	struct clk *parent;
895	unsigned long rate;
896	int ret;
897
898	kunit_skip(test, "This needs to be fixed in the core.");
899
900	clk_hw_set_rate_range(hw, DUMMY_CLOCK_RATE_1, DUMMY_CLOCK_RATE_2);
901
902	parent = clk_hw_get_clk_kunit(test, hw: &ctx->parents_ctx[1].hw, NULL);
903	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent);
904
905	ret = clk_set_parent(clk, parent);
906	KUNIT_ASSERT_EQ(test, ret, 0);
907
908	rate = clk_get_rate(clk);
909	KUNIT_ASSERT_GT(test, rate, 0);
910	KUNIT_EXPECT_GE(test, rate, DUMMY_CLOCK_RATE_1);
911	KUNIT_EXPECT_LE(test, rate, DUMMY_CLOCK_RATE_2);
912	}
913
914	static struct kunit_case clk_orphan_transparent_multiple_parent_mux_test_cases[] = {
915	KUNIT_CASE(clk_test_orphan_transparent_multiple_parent_mux_get_parent),
916	KUNIT_CASE(clk_test_orphan_transparent_multiple_parent_mux_set_parent),
917	KUNIT_CASE(clk_test_orphan_transparent_multiple_parent_mux_set_parent_drop_range),
918	KUNIT_CASE(clk_test_orphan_transparent_multiple_parent_mux_set_parent_get_rate),
919	KUNIT_CASE(clk_test_orphan_transparent_multiple_parent_mux_set_parent_put),
920	KUNIT_CASE(clk_test_orphan_transparent_multiple_parent_mux_set_parent_set_range_modified),
921	KUNIT_CASE(clk_test_orphan_transparent_multiple_parent_mux_set_parent_set_range_untouched),
922	KUNIT_CASE(clk_test_orphan_transparent_multiple_parent_mux_set_range_round_rate),
923	KUNIT_CASE(clk_test_orphan_transparent_multiple_parent_mux_set_range_set_parent_get_rate),
924	{}
925	};
926
927	/*
928	* Test suite for a basic mux clock with two parents. The default parent
929	* isn't registered, only the second parent is. By default, the clock
930	* will thus be orphan.
931	*
932	* These tests exercise the behaviour of the consumer API when dealing
933	* with an orphan clock, and how we deal with the transition to a valid
934	* parent.
935	*/
936	static struct kunit_suite clk_orphan_transparent_multiple_parent_mux_test_suite = {
937	.name = "clk-orphan-transparent-multiple-parent-mux-test",
938	.init = clk_orphan_transparent_multiple_parent_mux_test_init,
939	.test_cases = clk_orphan_transparent_multiple_parent_mux_test_cases,
940	};
941
942	struct clk_single_parent_ctx {
943	struct clk_dummy_context parent_ctx;
944	struct clk_hw hw;
945	};
946
947	static int clk_single_parent_mux_test_init(struct kunit *test)
948	{
949	struct clk_single_parent_ctx *ctx;
950	int ret;
951
952	ctx = kunit_kzalloc(test, size: sizeof(*ctx), GFP_KERNEL);
953	if (!ctx)
954	return -ENOMEM;
955	test->priv = ctx;
956
957	ctx->parent_ctx.rate = DUMMY_CLOCK_INIT_RATE;
958	ctx->parent_ctx.hw.init =
959	CLK_HW_INIT_NO_PARENT("parent-clk",
960	&clk_dummy_rate_ops,
961	0);
962
963	ret = clk_hw_register_kunit(test, NULL, hw: &ctx->parent_ctx.hw);
964	if (ret)
965	return ret;
966
967	ctx->hw.init = CLK_HW_INIT("test-clk", "parent-clk",
968	&clk_dummy_single_parent_ops,
969	CLK_SET_RATE_PARENT);
970
971	ret = clk_hw_register_kunit(test, NULL, hw: &ctx->hw);
972	if (ret)
973	return ret;
974
975	return 0;
976	}
977
978	static void
979	clk_single_parent_mux_test_exit(struct kunit *test)
980	{
981	struct clk_single_parent_ctx *ctx = test->priv;
982
983	clk_hw_unregister(hw: &ctx->hw);
984	clk_hw_unregister(hw: &ctx->parent_ctx.hw);
985	}
986
987	/*
988	* Test that for a clock with a single parent, clk_get_parent() actually
989	* returns the parent.
990	*/
991	static void
992	clk_test_single_parent_mux_get_parent(struct kunit *test)
993	{
994	struct clk_single_parent_ctx *ctx = test->priv;
995	struct clk_hw *hw = &ctx->hw;
996	struct clk *clk = clk_hw_get_clk(hw, NULL);
997	struct clk *parent = clk_hw_get_clk(hw: &ctx->parent_ctx.hw, NULL);
998
999	KUNIT_EXPECT_TRUE(test, clk_is_match(clk_get_parent(clk), parent));
1000
1001	clk_put(clk: parent);
1002	clk_put(clk);
1003	}
1004
1005	/*
1006	* Test that for a clock with a single parent, clk_has_parent() actually
1007	* reports it as a parent.
1008	*/
1009	static void
1010	clk_test_single_parent_mux_has_parent(struct kunit *test)
1011	{
1012	struct clk_single_parent_ctx *ctx = test->priv;
1013	struct clk_hw *hw = &ctx->hw;
1014	struct clk *clk = clk_hw_get_clk(hw, NULL);
1015	struct clk *parent = clk_hw_get_clk(hw: &ctx->parent_ctx.hw, NULL);
1016
1017	KUNIT_EXPECT_TRUE(test, clk_has_parent(clk, parent));
1018
1019	clk_put(clk: parent);
1020	clk_put(clk);
1021	}
1022
1023	/*
1024	* Test that for a clock that can't modify its rate and with a single
1025	* parent, if we set disjoints range on the parent and then the child,
1026	* the second will return an error.
1027	*
1028	* FIXME: clk_set_rate_range() only considers the current clock when
1029	* evaluating whether ranges are disjoints and not the upstream clocks
1030	* ranges.
1031	*/
1032	static void
1033	clk_test_single_parent_mux_set_range_disjoint_child_last(struct kunit *test)
1034	{
1035	struct clk_single_parent_ctx *ctx = test->priv;
1036	struct clk_hw *hw = &ctx->hw;
1037	struct clk *clk = clk_hw_get_clk_kunit(test, hw, NULL);
1038	struct clk *parent;
1039	int ret;
1040
1041	kunit_skip(test, "This needs to be fixed in the core.");
1042
1043	parent = clk_get_parent(clk);
1044	KUNIT_ASSERT_PTR_NE(test, parent, NULL);
1045
1046	ret = clk_set_rate_range(clk: parent, min: 1000, max: 2000);
1047	KUNIT_ASSERT_EQ(test, ret, 0);
1048
1049	ret = clk_set_rate_range(clk, min: 3000, max: 4000);
1050	KUNIT_EXPECT_LT(test, ret, 0);
1051	}
1052
1053	/*
1054	* Test that for a clock that can't modify its rate and with a single
1055	* parent, if we set disjoints range on the child and then the parent,
1056	* the second will return an error.
1057	*
1058	* FIXME: clk_set_rate_range() only considers the current clock when
1059	* evaluating whether ranges are disjoints and not the downstream clocks
1060	* ranges.
1061	*/
1062	static void
1063	clk_test_single_parent_mux_set_range_disjoint_parent_last(struct kunit *test)
1064	{
1065	struct clk_single_parent_ctx *ctx = test->priv;
1066	struct clk_hw *hw = &ctx->hw;
1067	struct clk *clk = clk_hw_get_clk_kunit(test, hw, NULL);
1068	struct clk *parent;
1069	int ret;
1070
1071	kunit_skip(test, "This needs to be fixed in the core.");
1072
1073	parent = clk_get_parent(clk);
1074	KUNIT_ASSERT_PTR_NE(test, parent, NULL);
1075
1076	ret = clk_set_rate_range(clk, min: 1000, max: 2000);
1077	KUNIT_ASSERT_EQ(test, ret, 0);
1078
1079	ret = clk_set_rate_range(clk: parent, min: 3000, max: 4000);
1080	KUNIT_EXPECT_LT(test, ret, 0);
1081	}
1082
1083	/*
1084	* Test that for a clock that can't modify its rate and with a single
1085	* parent, if we set a range on the parent and then call
1086	* clk_round_rate(), the boundaries of the parent are taken into
1087	* account.
1088	*/
1089	static void
1090	clk_test_single_parent_mux_set_range_round_rate_parent_only(struct kunit *test)
1091	{
1092	struct clk_single_parent_ctx *ctx = test->priv;
1093	struct clk_hw *hw = &ctx->hw;
1094	struct clk *clk = clk_hw_get_clk(hw, NULL);
1095	struct clk *parent;
1096	long rate;
1097	int ret;
1098
1099	parent = clk_get_parent(clk);
1100	KUNIT_ASSERT_PTR_NE(test, parent, NULL);
1101
1102	ret = clk_set_rate_range(clk: parent, DUMMY_CLOCK_RATE_1, DUMMY_CLOCK_RATE_2);
1103	KUNIT_ASSERT_EQ(test, ret, 0);
1104
1105	rate = clk_round_rate(clk, DUMMY_CLOCK_RATE_1 - 1000);
1106	KUNIT_ASSERT_GT(test, rate, 0);
1107	KUNIT_EXPECT_GE(test, rate, DUMMY_CLOCK_RATE_1);
1108	KUNIT_EXPECT_LE(test, rate, DUMMY_CLOCK_RATE_2);
1109
1110	clk_put(clk);
1111	}
1112
1113	/*
1114	* Test that for a clock that can't modify its rate and with a single
1115	* parent, if we set a range on the parent and a more restrictive one on
1116	* the child, and then call clk_round_rate(), the boundaries of the
1117	* two clocks are taken into account.
1118	*/
1119	static void
1120	clk_test_single_parent_mux_set_range_round_rate_child_smaller(struct kunit *test)
1121	{
1122	struct clk_single_parent_ctx *ctx = test->priv;
1123	struct clk_hw *hw = &ctx->hw;
1124	struct clk *clk = clk_hw_get_clk(hw, NULL);
1125	struct clk *parent;
1126	long rate;
1127	int ret;
1128
1129	parent = clk_get_parent(clk);
1130	KUNIT_ASSERT_PTR_NE(test, parent, NULL);
1131
1132	ret = clk_set_rate_range(clk: parent, DUMMY_CLOCK_RATE_1, DUMMY_CLOCK_RATE_2);
1133	KUNIT_ASSERT_EQ(test, ret, 0);
1134
1135	ret = clk_set_rate_range(clk, DUMMY_CLOCK_RATE_1 + 1000, DUMMY_CLOCK_RATE_2 - 1000);
1136	KUNIT_ASSERT_EQ(test, ret, 0);
1137
1138	rate = clk_round_rate(clk, DUMMY_CLOCK_RATE_1 - 1000);
1139	KUNIT_ASSERT_GT(test, rate, 0);
1140	KUNIT_EXPECT_GE(test, rate, DUMMY_CLOCK_RATE_1 + 1000);
1141	KUNIT_EXPECT_LE(test, rate, DUMMY_CLOCK_RATE_2 - 1000);
1142
1143	rate = clk_round_rate(clk, DUMMY_CLOCK_RATE_2 + 1000);
1144	KUNIT_ASSERT_GT(test, rate, 0);
1145	KUNIT_EXPECT_GE(test, rate, DUMMY_CLOCK_RATE_1 + 1000);
1146	KUNIT_EXPECT_LE(test, rate, DUMMY_CLOCK_RATE_2 - 1000);
1147
1148	clk_put(clk);
1149	}
1150
1151	/*
1152	* Test that for a clock that can't modify its rate and with a single
1153	* parent, if we set a range on the child and a more restrictive one on
1154	* the parent, and then call clk_round_rate(), the boundaries of the
1155	* two clocks are taken into account.
1156	*/
1157	static void
1158	clk_test_single_parent_mux_set_range_round_rate_parent_smaller(struct kunit *test)
1159	{
1160	struct clk_single_parent_ctx *ctx = test->priv;
1161	struct clk_hw *hw = &ctx->hw;
1162	struct clk *clk = clk_hw_get_clk(hw, NULL);
1163	struct clk *parent;
1164	long rate;
1165	int ret;
1166
1167	parent = clk_get_parent(clk);
1168	KUNIT_ASSERT_PTR_NE(test, parent, NULL);
1169
1170	ret = clk_set_rate_range(clk: parent, DUMMY_CLOCK_RATE_1 + 1000, DUMMY_CLOCK_RATE_2 - 1000);
1171	KUNIT_ASSERT_EQ(test, ret, 0);
1172
1173	ret = clk_set_rate_range(clk, DUMMY_CLOCK_RATE_1, DUMMY_CLOCK_RATE_2);
1174	KUNIT_ASSERT_EQ(test, ret, 0);
1175
1176	rate = clk_round_rate(clk, DUMMY_CLOCK_RATE_1 - 1000);
1177	KUNIT_ASSERT_GT(test, rate, 0);
1178	KUNIT_EXPECT_GE(test, rate, DUMMY_CLOCK_RATE_1 + 1000);
1179	KUNIT_EXPECT_LE(test, rate, DUMMY_CLOCK_RATE_2 - 1000);
1180
1181	rate = clk_round_rate(clk, DUMMY_CLOCK_RATE_2 + 1000);
1182	KUNIT_ASSERT_GT(test, rate, 0);
1183	KUNIT_EXPECT_GE(test, rate, DUMMY_CLOCK_RATE_1 + 1000);
1184	KUNIT_EXPECT_LE(test, rate, DUMMY_CLOCK_RATE_2 - 1000);
1185
1186	clk_put(clk);
1187	}
1188
1189	static struct kunit_case clk_single_parent_mux_test_cases[] = {
1190	KUNIT_CASE(clk_test_single_parent_mux_get_parent),
1191	KUNIT_CASE(clk_test_single_parent_mux_has_parent),
1192	KUNIT_CASE(clk_test_single_parent_mux_set_range_disjoint_child_last),
1193	KUNIT_CASE(clk_test_single_parent_mux_set_range_disjoint_parent_last),
1194	KUNIT_CASE(clk_test_single_parent_mux_set_range_round_rate_child_smaller),
1195	KUNIT_CASE(clk_test_single_parent_mux_set_range_round_rate_parent_only),
1196	KUNIT_CASE(clk_test_single_parent_mux_set_range_round_rate_parent_smaller),
1197	{}
1198	};
1199
1200	/*
1201	* Test suite for a basic mux clock with one parent, with
1202	* CLK_SET_RATE_PARENT on the child.
1203	*
1204	* These tests exercise the consumer API and check that the state of the
1205	* child and parent are sane and consistent.
1206	*/
1207	static struct kunit_suite
1208	clk_single_parent_mux_test_suite = {
1209	.name = "clk-single-parent-mux-test",
1210	.init = clk_single_parent_mux_test_init,
1211	.test_cases = clk_single_parent_mux_test_cases,
1212	};
1213
1214	static int clk_orphan_transparent_single_parent_mux_test_init(struct kunit *test)
1215	{
1216	struct clk_single_parent_ctx *ctx;
1217	struct clk_init_data init = { };
1218	const char * const parents[] = { "orphan_parent" };
1219	int ret;
1220
1221	ctx = kunit_kzalloc(test, size: sizeof(*ctx), GFP_KERNEL);
1222	if (!ctx)
1223	return -ENOMEM;
1224	test->priv = ctx;
1225
1226	init.name = "test_orphan_dummy_parent";
1227	init.ops = &clk_dummy_single_parent_ops;
1228	init.parent_names = parents;
1229	init.num_parents = ARRAY_SIZE(parents);
1230	init.flags = CLK_SET_RATE_PARENT;
1231	ctx->hw.init = &init;
1232
1233	ret = clk_hw_register(NULL, hw: &ctx->hw);
1234	if (ret)
1235	return ret;
1236
1237	memset(&init, 0, sizeof(init));
1238	init.name = "orphan_parent";
1239	init.ops = &clk_dummy_rate_ops;
1240	ctx->parent_ctx.hw.init = &init;
1241	ctx->parent_ctx.rate = DUMMY_CLOCK_INIT_RATE;
1242
1243	ret = clk_hw_register(NULL, hw: &ctx->parent_ctx.hw);
1244	if (ret)
1245	return ret;
1246
1247	return 0;
1248	}
1249
1250	/*
1251	* Test that a mux-only clock, with an initial rate within a range,
1252	* will still have the same rate after the range has been enforced.
1253	*
1254	* See:
1255	* https://lore.kernel.org/linux-clk/7720158d-10a7-a17b-73a4-a8615c9c6d5c@collabora.com/
1256	*/
1257	static void clk_test_orphan_transparent_parent_mux_set_range(struct kunit *test)
1258	{
1259	struct clk_single_parent_ctx *ctx = test->priv;
1260	struct clk_hw *hw = &ctx->hw;
1261	struct clk *clk = clk_hw_get_clk(hw, NULL);
1262	unsigned long rate, new_rate;
1263
1264	rate = clk_get_rate(clk);
1265	KUNIT_ASSERT_GT(test, rate, 0);
1266
1267	KUNIT_ASSERT_EQ(test,
1268	clk_set_rate_range(clk,
1269	ctx->parent_ctx.rate - 1000,
1270	ctx->parent_ctx.rate + 1000),
1271	0);
1272
1273	new_rate = clk_get_rate(clk);
1274	KUNIT_ASSERT_GT(test, new_rate, 0);
1275	KUNIT_EXPECT_EQ(test, rate, new_rate);
1276
1277	clk_put(clk);
1278	}
1279
1280	static struct kunit_case clk_orphan_transparent_single_parent_mux_test_cases[] = {
1281	KUNIT_CASE(clk_test_orphan_transparent_parent_mux_set_range),
1282	{}
1283	};
1284
1285	/*
1286	* Test suite for a basic mux clock with one parent. The parent is
1287	* registered after its child. The clock will thus be an orphan when
1288	* registered, but will no longer be when the tests run.
1289	*
1290	* These tests make sure a clock that used to be orphan has a sane,
1291	* consistent, behaviour.
1292	*/
1293	static struct kunit_suite clk_orphan_transparent_single_parent_test_suite = {
1294	.name = "clk-orphan-transparent-single-parent-test",
1295	.init = clk_orphan_transparent_single_parent_mux_test_init,
1296	.exit = clk_single_parent_mux_test_exit,
1297	.test_cases = clk_orphan_transparent_single_parent_mux_test_cases,
1298	};
1299
1300	struct clk_single_parent_two_lvl_ctx {
1301	struct clk_dummy_context parent_parent_ctx;
1302	struct clk_dummy_context parent_ctx;
1303	struct clk_hw hw;
1304	};
1305
1306	static int
1307	clk_orphan_two_level_root_last_test_init(struct kunit *test)
1308	{
1309	struct clk_single_parent_two_lvl_ctx *ctx;
1310	int ret;
1311
1312	ctx = kunit_kzalloc(test, size: sizeof(*ctx), GFP_KERNEL);
1313	if (!ctx)
1314	return -ENOMEM;
1315	test->priv = ctx;
1316
1317	ctx->parent_ctx.hw.init =
1318	CLK_HW_INIT("intermediate-parent",
1319	"root-parent",
1320	&clk_dummy_single_parent_ops,
1321	CLK_SET_RATE_PARENT);
1322	ret = clk_hw_register(NULL, hw: &ctx->parent_ctx.hw);
1323	if (ret)
1324	return ret;
1325
1326	ctx->hw.init =
1327	CLK_HW_INIT("test-clk", "intermediate-parent",
1328	&clk_dummy_single_parent_ops,
1329	CLK_SET_RATE_PARENT);
1330	ret = clk_hw_register(NULL, hw: &ctx->hw);
1331	if (ret)
1332	return ret;
1333
1334	ctx->parent_parent_ctx.rate = DUMMY_CLOCK_INIT_RATE;
1335	ctx->parent_parent_ctx.hw.init =
1336	CLK_HW_INIT_NO_PARENT("root-parent",
1337	&clk_dummy_rate_ops,
1338	0);
1339	ret = clk_hw_register(NULL, hw: &ctx->parent_parent_ctx.hw);
1340	if (ret)
1341	return ret;
1342
1343	return 0;
1344	}
1345
1346	static void
1347	clk_orphan_two_level_root_last_test_exit(struct kunit *test)
1348	{
1349	struct clk_single_parent_two_lvl_ctx *ctx = test->priv;
1350
1351	clk_hw_unregister(hw: &ctx->hw);
1352	clk_hw_unregister(hw: &ctx->parent_ctx.hw);
1353	clk_hw_unregister(hw: &ctx->parent_parent_ctx.hw);
1354	}
1355
1356	/*
1357	* Test that, for a clock whose parent used to be orphan, clk_get_rate()
1358	* will return the proper rate.
1359	*/
1360	static void
1361	clk_orphan_two_level_root_last_test_get_rate(struct kunit *test)
1362	{
1363	struct clk_single_parent_two_lvl_ctx *ctx = test->priv;
1364	struct clk_hw *hw = &ctx->hw;
1365	struct clk *clk = clk_hw_get_clk(hw, NULL);
1366	unsigned long rate;
1367
1368	rate = clk_get_rate(clk);
1369	KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_INIT_RATE);
1370
1371	clk_put(clk);
1372	}
1373
1374	/*
1375	* Test that, for a clock whose parent used to be orphan,
1376	* clk_set_rate_range() won't affect its rate if it is already within
1377	* range.
1378	*
1379	* See (for Exynos 4210):
1380	* https://lore.kernel.org/linux-clk/366a0232-bb4a-c357-6aa8-636e398e05eb@samsung.com/
1381	*/
1382	static void
1383	clk_orphan_two_level_root_last_test_set_range(struct kunit *test)
1384	{
1385	struct clk_single_parent_two_lvl_ctx *ctx = test->priv;
1386	struct clk_hw *hw = &ctx->hw;
1387	struct clk *clk = clk_hw_get_clk(hw, NULL);
1388	unsigned long rate;
1389	int ret;
1390
1391	ret = clk_set_rate_range(clk,
1392	DUMMY_CLOCK_INIT_RATE - 1000,
1393	DUMMY_CLOCK_INIT_RATE + 1000);
1394	KUNIT_ASSERT_EQ(test, ret, 0);
1395
1396	rate = clk_get_rate(clk);
1397	KUNIT_ASSERT_GT(test, rate, 0);
1398	KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_INIT_RATE);
1399
1400	clk_put(clk);
1401	}
1402
1403	static struct kunit_case
1404	clk_orphan_two_level_root_last_test_cases[] = {
1405	KUNIT_CASE(clk_orphan_two_level_root_last_test_get_rate),
1406	KUNIT_CASE(clk_orphan_two_level_root_last_test_set_range),
1407	{}
1408	};
1409
1410	/*
1411	* Test suite for a basic, transparent, clock with a parent that is also
1412	* such a clock. The parent's parent is registered last, while the
1413	* parent and its child are registered in that order. The intermediate
1414	* and leaf clocks will thus be orphan when registered, but the leaf
1415	* clock itself will always have its parent and will never be
1416	* reparented. Indeed, it's only orphan because its parent is.
1417	*
1418	* These tests exercise the behaviour of the consumer API when dealing
1419	* with an orphan clock, and how we deal with the transition to a valid
1420	* parent.
1421	*/
1422	static struct kunit_suite
1423	clk_orphan_two_level_root_last_test_suite = {
1424	.name = "clk-orphan-two-level-root-last-test",
1425	.init = clk_orphan_two_level_root_last_test_init,
1426	.exit = clk_orphan_two_level_root_last_test_exit,
1427	.test_cases = clk_orphan_two_level_root_last_test_cases,
1428	};
1429
1430	/*
1431	* Test that clk_set_rate_range won't return an error for a valid range
1432	* and that it will make sure the rate of the clock is within the
1433	* boundaries.
1434	*/
1435	static void clk_range_test_set_range(struct kunit *test)
1436	{
1437	struct clk_dummy_context *ctx = test->priv;
1438	struct clk_hw *hw = &ctx->hw;
1439	struct clk *clk = clk_hw_get_clk(hw, NULL);
1440	unsigned long rate;
1441
1442	KUNIT_ASSERT_EQ(test,
1443	clk_set_rate_range(clk,
1444	DUMMY_CLOCK_RATE_1,
1445	DUMMY_CLOCK_RATE_2),
1446	0);
1447
1448	rate = clk_get_rate(clk);
1449	KUNIT_ASSERT_GT(test, rate, 0);
1450	KUNIT_EXPECT_GE(test, rate, DUMMY_CLOCK_RATE_1);
1451	KUNIT_EXPECT_LE(test, rate, DUMMY_CLOCK_RATE_2);
1452
1453	clk_put(clk);
1454	}
1455
1456	/*
1457	* Test that calling clk_set_rate_range with a minimum rate higher than
1458	* the maximum rate returns an error.
1459	*/
1460	static void clk_range_test_set_range_invalid(struct kunit *test)
1461	{
1462	struct clk_dummy_context *ctx = test->priv;
1463	struct clk_hw *hw = &ctx->hw;
1464	struct clk *clk = clk_hw_get_clk(hw, NULL);
1465
1466	KUNIT_EXPECT_LT(test,
1467	clk_set_rate_range(clk,
1468	DUMMY_CLOCK_RATE_1 + 1000,
1469	DUMMY_CLOCK_RATE_1),
1470	0);
1471
1472	clk_put(clk);
1473	}
1474
1475	/*
1476	* Test that users can't set multiple, disjoints, range that would be
1477	* impossible to meet.
1478	*/
1479	static void clk_range_test_multiple_disjoints_range(struct kunit *test)
1480	{
1481	struct clk_dummy_context *ctx = test->priv;
1482	struct clk_hw *hw = &ctx->hw;
1483	struct clk *user1, *user2;
1484
1485	user1 = clk_hw_get_clk(hw, NULL);
1486	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, user1);
1487
1488	user2 = clk_hw_get_clk(hw, NULL);
1489	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, user2);
1490
1491	KUNIT_ASSERT_EQ(test,
1492	clk_set_rate_range(user1, 1000, 2000),
1493	0);
1494
1495	KUNIT_EXPECT_LT(test,
1496	clk_set_rate_range(user2, 3000, 4000),
1497	0);
1498
1499	clk_put(clk: user2);
1500	clk_put(clk: user1);
1501	}
1502
1503	/*
1504	* Test that if our clock has some boundaries and we try to round a rate
1505	* lower than the minimum, the returned rate will be within range.
1506	*/
1507	static void clk_range_test_set_range_round_rate_lower(struct kunit *test)
1508	{
1509	struct clk_dummy_context *ctx = test->priv;
1510	struct clk_hw *hw = &ctx->hw;
1511	struct clk *clk = clk_hw_get_clk(hw, NULL);
1512	long rate;
1513
1514	KUNIT_ASSERT_EQ(test,
1515	clk_set_rate_range(clk,
1516	DUMMY_CLOCK_RATE_1,
1517	DUMMY_CLOCK_RATE_2),
1518	0);
1519
1520	rate = clk_round_rate(clk, DUMMY_CLOCK_RATE_1 - 1000);
1521	KUNIT_ASSERT_GT(test, rate, 0);
1522	KUNIT_EXPECT_GE(test, rate, DUMMY_CLOCK_RATE_1);
1523	KUNIT_EXPECT_LE(test, rate, DUMMY_CLOCK_RATE_2);
1524
1525	clk_put(clk);
1526	}
1527
1528	/*
1529	* Test that if our clock has some boundaries and we try to set a rate
1530	* higher than the maximum, the new rate will be within range.
1531	*/
1532	static void clk_range_test_set_range_set_rate_lower(struct kunit *test)
1533	{
1534	struct clk_dummy_context *ctx = test->priv;
1535	struct clk_hw *hw = &ctx->hw;
1536	struct clk *clk = clk_hw_get_clk(hw, NULL);
1537	unsigned long rate;
1538
1539	KUNIT_ASSERT_EQ(test,
1540	clk_set_rate_range(clk,
1541	DUMMY_CLOCK_RATE_1,
1542	DUMMY_CLOCK_RATE_2),
1543	0);
1544
1545	KUNIT_ASSERT_EQ(test,
1546	clk_set_rate(clk, DUMMY_CLOCK_RATE_1 - 1000),
1547	0);
1548
1549	rate = clk_get_rate(clk);
1550	KUNIT_ASSERT_GT(test, rate, 0);
1551	KUNIT_EXPECT_GE(test, rate, DUMMY_CLOCK_RATE_1);
1552	KUNIT_EXPECT_LE(test, rate, DUMMY_CLOCK_RATE_2);
1553
1554	clk_put(clk);
1555	}
1556
1557	/*
1558	* Test that if our clock has some boundaries and we try to round and
1559	* set a rate lower than the minimum, the rate returned by
1560	* clk_round_rate() will be consistent with the new rate set by
1561	* clk_set_rate().
1562	*/
1563	static void clk_range_test_set_range_set_round_rate_consistent_lower(struct kunit *test)
1564	{
1565	struct clk_dummy_context *ctx = test->priv;
1566	struct clk_hw *hw = &ctx->hw;
1567	struct clk *clk = clk_hw_get_clk(hw, NULL);
1568	long rounded;
1569
1570	KUNIT_ASSERT_EQ(test,
1571	clk_set_rate_range(clk,
1572	DUMMY_CLOCK_RATE_1,
1573	DUMMY_CLOCK_RATE_2),
1574	0);
1575
1576	rounded = clk_round_rate(clk, DUMMY_CLOCK_RATE_1 - 1000);
1577	KUNIT_ASSERT_GT(test, rounded, 0);
1578
1579	KUNIT_ASSERT_EQ(test,
1580	clk_set_rate(clk, DUMMY_CLOCK_RATE_1 - 1000),
1581	0);
1582
1583	KUNIT_EXPECT_EQ(test, rounded, clk_get_rate(clk));
1584
1585	clk_put(clk);
1586	}
1587
1588	/*
1589	* Test that if our clock has some boundaries and we try to round a rate
1590	* higher than the maximum, the returned rate will be within range.
1591	*/
1592	static void clk_range_test_set_range_round_rate_higher(struct kunit *test)
1593	{
1594	struct clk_dummy_context *ctx = test->priv;
1595	struct clk_hw *hw = &ctx->hw;
1596	struct clk *clk = clk_hw_get_clk(hw, NULL);
1597	long rate;
1598
1599	KUNIT_ASSERT_EQ(test,
1600	clk_set_rate_range(clk,
1601	DUMMY_CLOCK_RATE_1,
1602	DUMMY_CLOCK_RATE_2),
1603	0);
1604
1605	rate = clk_round_rate(clk, DUMMY_CLOCK_RATE_2 + 1000);
1606	KUNIT_ASSERT_GT(test, rate, 0);
1607	KUNIT_EXPECT_GE(test, rate, DUMMY_CLOCK_RATE_1);
1608	KUNIT_EXPECT_LE(test, rate, DUMMY_CLOCK_RATE_2);
1609
1610	clk_put(clk);
1611	}
1612
1613	/*
1614	* Test that if our clock has some boundaries and we try to set a rate
1615	* higher than the maximum, the new rate will be within range.
1616	*/
1617	static void clk_range_test_set_range_set_rate_higher(struct kunit *test)
1618	{
1619	struct clk_dummy_context *ctx = test->priv;
1620	struct clk_hw *hw = &ctx->hw;
1621	struct clk *clk = clk_hw_get_clk(hw, NULL);
1622	unsigned long rate;
1623
1624	KUNIT_ASSERT_EQ(test,
1625	clk_set_rate_range(clk,
1626	DUMMY_CLOCK_RATE_1,
1627	DUMMY_CLOCK_RATE_2),
1628	0);
1629
1630	KUNIT_ASSERT_EQ(test,
1631	clk_set_rate(clk, DUMMY_CLOCK_RATE_2 + 1000),
1632	0);
1633
1634	rate = clk_get_rate(clk);
1635	KUNIT_ASSERT_GT(test, rate, 0);
1636	KUNIT_EXPECT_GE(test, rate, DUMMY_CLOCK_RATE_1);
1637	KUNIT_EXPECT_LE(test, rate, DUMMY_CLOCK_RATE_2);
1638
1639	clk_put(clk);
1640	}
1641
1642	/*
1643	* Test that if our clock has some boundaries and we try to round and
1644	* set a rate higher than the maximum, the rate returned by
1645	* clk_round_rate() will be consistent with the new rate set by
1646	* clk_set_rate().
1647	*/
1648	static void clk_range_test_set_range_set_round_rate_consistent_higher(struct kunit *test)
1649	{
1650	struct clk_dummy_context *ctx = test->priv;
1651	struct clk_hw *hw = &ctx->hw;
1652	struct clk *clk = clk_hw_get_clk(hw, NULL);
1653	long rounded;
1654
1655	KUNIT_ASSERT_EQ(test,
1656	clk_set_rate_range(clk,
1657	DUMMY_CLOCK_RATE_1,
1658	DUMMY_CLOCK_RATE_2),
1659	0);
1660
1661	rounded = clk_round_rate(clk, DUMMY_CLOCK_RATE_2 + 1000);
1662	KUNIT_ASSERT_GT(test, rounded, 0);
1663
1664	KUNIT_ASSERT_EQ(test,
1665	clk_set_rate(clk, DUMMY_CLOCK_RATE_2 + 1000),
1666	0);
1667
1668	KUNIT_EXPECT_EQ(test, rounded, clk_get_rate(clk));
1669
1670	clk_put(clk);
1671	}
1672
1673	/*
1674	* Test that if our clock has a rate lower than the minimum set by a
1675	* call to clk_set_rate_range(), the rate will be raised to match the
1676	* new minimum.
1677	*
1678	* This assumes that clk_ops.determine_rate or clk_ops.round_rate won't
1679	* modify the requested rate, which is our case in clk_dummy_rate_ops.
1680	*/
1681	static void clk_range_test_set_range_get_rate_raised(struct kunit *test)
1682	{
1683	struct clk_dummy_context *ctx = test->priv;
1684	struct clk_hw *hw = &ctx->hw;
1685	struct clk *clk = clk_hw_get_clk(hw, NULL);
1686	unsigned long rate;
1687
1688	KUNIT_ASSERT_EQ(test,
1689	clk_set_rate(clk, DUMMY_CLOCK_RATE_1 - 1000),
1690	0);
1691
1692	KUNIT_ASSERT_EQ(test,
1693	clk_set_rate_range(clk,
1694	DUMMY_CLOCK_RATE_1,
1695	DUMMY_CLOCK_RATE_2),
1696	0);
1697
1698	rate = clk_get_rate(clk);
1699	KUNIT_ASSERT_GT(test, rate, 0);
1700	KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_1);
1701
1702	clk_put(clk);
1703	}
1704
1705	/*
1706	* Test that if our clock has a rate higher than the maximum set by a
1707	* call to clk_set_rate_range(), the rate will be lowered to match the
1708	* new maximum.
1709	*
1710	* This assumes that clk_ops.determine_rate or clk_ops.round_rate won't
1711	* modify the requested rate, which is our case in clk_dummy_rate_ops.
1712	*/
1713	static void clk_range_test_set_range_get_rate_lowered(struct kunit *test)
1714	{
1715	struct clk_dummy_context *ctx = test->priv;
1716	struct clk_hw *hw = &ctx->hw;
1717	struct clk *clk = clk_hw_get_clk(hw, NULL);
1718	unsigned long rate;
1719
1720	KUNIT_ASSERT_EQ(test,
1721	clk_set_rate(clk, DUMMY_CLOCK_RATE_2 + 1000),
1722	0);
1723
1724	KUNIT_ASSERT_EQ(test,
1725	clk_set_rate_range(clk,
1726	DUMMY_CLOCK_RATE_1,
1727	DUMMY_CLOCK_RATE_2),
1728	0);
1729
1730	rate = clk_get_rate(clk);
1731	KUNIT_ASSERT_GT(test, rate, 0);
1732	KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_2);
1733
1734	clk_put(clk);
1735	}
1736
1737	static struct kunit_case clk_range_test_cases[] = {
1738	KUNIT_CASE(clk_range_test_set_range),
1739	KUNIT_CASE(clk_range_test_set_range_invalid),
1740	KUNIT_CASE(clk_range_test_multiple_disjoints_range),
1741	KUNIT_CASE(clk_range_test_set_range_round_rate_lower),
1742	KUNIT_CASE(clk_range_test_set_range_set_rate_lower),
1743	KUNIT_CASE(clk_range_test_set_range_set_round_rate_consistent_lower),
1744	KUNIT_CASE(clk_range_test_set_range_round_rate_higher),
1745	KUNIT_CASE(clk_range_test_set_range_set_rate_higher),
1746	KUNIT_CASE(clk_range_test_set_range_set_round_rate_consistent_higher),
1747	KUNIT_CASE(clk_range_test_set_range_get_rate_raised),
1748	KUNIT_CASE(clk_range_test_set_range_get_rate_lowered),
1749	{}
1750	};
1751
1752	/*
1753	* Test suite for a basic rate clock, without any parent.
1754	*
1755	* These tests exercise the rate range API: clk_set_rate_range(),
1756	* clk_set_min_rate(), clk_set_max_rate(), clk_drop_range().
1757	*/
1758	static struct kunit_suite clk_range_test_suite = {
1759	.name = "clk-range-test",
1760	.init = clk_test_init,
1761	.exit = clk_test_exit,
1762	.test_cases = clk_range_test_cases,
1763	};
1764
1765	/*
1766	* Test that if we have several subsequent calls to
1767	* clk_set_rate_range(), the core will reevaluate whether a new rate is
1768	* needed each and every time.
1769	*
1770	* With clk_dummy_maximize_rate_ops, this means that the rate will
1771	* trail along the maximum as it evolves.
1772	*/
1773	static void clk_range_test_set_range_rate_maximized(struct kunit *test)
1774	{
1775	struct clk_dummy_context *ctx = test->priv;
1776	struct clk_hw *hw = &ctx->hw;
1777	struct clk *clk = clk_hw_get_clk(hw, NULL);
1778	unsigned long rate;
1779
1780	KUNIT_ASSERT_EQ(test,
1781	clk_set_rate(clk, DUMMY_CLOCK_RATE_2 + 1000),
1782	0);
1783
1784	KUNIT_ASSERT_EQ(test,
1785	clk_set_rate_range(clk,
1786	DUMMY_CLOCK_RATE_1,
1787	DUMMY_CLOCK_RATE_2),
1788	0);
1789
1790	rate = clk_get_rate(clk);
1791	KUNIT_ASSERT_GT(test, rate, 0);
1792	KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_2);
1793
1794	KUNIT_ASSERT_EQ(test,
1795	clk_set_rate_range(clk,
1796	DUMMY_CLOCK_RATE_1,
1797	DUMMY_CLOCK_RATE_2 - 1000),
1798	0);
1799
1800	rate = clk_get_rate(clk);
1801	KUNIT_ASSERT_GT(test, rate, 0);
1802	KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_2 - 1000);
1803
1804	KUNIT_ASSERT_EQ(test,
1805	clk_set_rate_range(clk,
1806	DUMMY_CLOCK_RATE_1,
1807	DUMMY_CLOCK_RATE_2),
1808	0);
1809
1810	rate = clk_get_rate(clk);
1811	KUNIT_ASSERT_GT(test, rate, 0);
1812	KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_2);
1813
1814	clk_put(clk);
1815	}
1816
1817	/*
1818	* Test that if we have several subsequent calls to
1819	* clk_set_rate_range(), across multiple users, the core will reevaluate
1820	* whether a new rate is needed each and every time.
1821	*
1822	* With clk_dummy_maximize_rate_ops, this means that the rate will
1823	* trail along the maximum as it evolves.
1824	*/
1825	static void clk_range_test_multiple_set_range_rate_maximized(struct kunit *test)
1826	{
1827	struct clk_dummy_context *ctx = test->priv;
1828	struct clk_hw *hw = &ctx->hw;
1829	struct clk *clk = clk_hw_get_clk(hw, NULL);
1830	struct clk *user1, *user2;
1831	unsigned long rate;
1832
1833	user1 = clk_hw_get_clk(hw, NULL);
1834	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, user1);
1835
1836	user2 = clk_hw_get_clk(hw, NULL);
1837	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, user2);
1838
1839	KUNIT_ASSERT_EQ(test,
1840	clk_set_rate(clk, DUMMY_CLOCK_RATE_2 + 1000),
1841	0);
1842
1843	KUNIT_ASSERT_EQ(test,
1844	clk_set_rate_range(user1,
1845	0,
1846	DUMMY_CLOCK_RATE_2),
1847	0);
1848
1849	rate = clk_get_rate(clk);
1850	KUNIT_ASSERT_GT(test, rate, 0);
1851	KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_2);
1852
1853	KUNIT_ASSERT_EQ(test,
1854	clk_set_rate_range(user2,
1855	0,
1856	DUMMY_CLOCK_RATE_1),
1857	0);
1858
1859	rate = clk_get_rate(clk);
1860	KUNIT_ASSERT_GT(test, rate, 0);
1861	KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_1);
1862
1863	KUNIT_ASSERT_EQ(test,
1864	clk_drop_range(user2),
1865	0);
1866
1867	rate = clk_get_rate(clk);
1868	KUNIT_ASSERT_GT(test, rate, 0);
1869	KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_2);
1870
1871	clk_put(clk: user2);
1872	clk_put(clk: user1);
1873	clk_put(clk);
1874	}
1875
1876	/*
1877	* Test that if we have several subsequent calls to
1878	* clk_set_rate_range(), across multiple users, the core will reevaluate
1879	* whether a new rate is needed, including when a user drop its clock.
1880	*
1881	* With clk_dummy_maximize_rate_ops, this means that the rate will
1882	* trail along the maximum as it evolves.
1883	*/
1884	static void clk_range_test_multiple_set_range_rate_put_maximized(struct kunit *test)
1885	{
1886	struct clk_dummy_context *ctx = test->priv;
1887	struct clk_hw *hw = &ctx->hw;
1888	struct clk *clk = clk_hw_get_clk(hw, NULL);
1889	struct clk *user1, *user2;
1890	unsigned long rate;
1891
1892	user1 = clk_hw_get_clk(hw, NULL);
1893	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, user1);
1894
1895	user2 = clk_hw_get_clk(hw, NULL);
1896	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, user2);
1897
1898	KUNIT_ASSERT_EQ(test,
1899	clk_set_rate(clk, DUMMY_CLOCK_RATE_2 + 1000),
1900	0);
1901
1902	KUNIT_ASSERT_EQ(test,
1903	clk_set_rate_range(user1,
1904	0,
1905	DUMMY_CLOCK_RATE_2),
1906	0);
1907
1908	rate = clk_get_rate(clk);
1909	KUNIT_ASSERT_GT(test, rate, 0);
1910	KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_2);
1911
1912	KUNIT_ASSERT_EQ(test,
1913	clk_set_rate_range(user2,
1914	0,
1915	DUMMY_CLOCK_RATE_1),
1916	0);
1917
1918	rate = clk_get_rate(clk);
1919	KUNIT_ASSERT_GT(test, rate, 0);
1920	KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_1);
1921
1922	clk_put(clk: user2);
1923
1924	rate = clk_get_rate(clk);
1925	KUNIT_ASSERT_GT(test, rate, 0);
1926	KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_2);
1927
1928	clk_put(clk: user1);
1929	clk_put(clk);
1930	}
1931
1932	static struct kunit_case clk_range_maximize_test_cases[] = {
1933	KUNIT_CASE(clk_range_test_set_range_rate_maximized),
1934	KUNIT_CASE(clk_range_test_multiple_set_range_rate_maximized),
1935	KUNIT_CASE(clk_range_test_multiple_set_range_rate_put_maximized),
1936	{}
1937	};
1938
1939	/*
1940	* Test suite for a basic rate clock, without any parent.
1941	*
1942	* These tests exercise the rate range API: clk_set_rate_range(),
1943	* clk_set_min_rate(), clk_set_max_rate(), clk_drop_range(), with a
1944	* driver that will always try to run at the highest possible rate.
1945	*/
1946	static struct kunit_suite clk_range_maximize_test_suite = {
1947	.name = "clk-range-maximize-test",
1948	.init = clk_maximize_test_init,
1949	.exit = clk_test_exit,
1950	.test_cases = clk_range_maximize_test_cases,
1951	};
1952
1953	/*
1954	* Test that if we have several subsequent calls to
1955	* clk_set_rate_range(), the core will reevaluate whether a new rate is
1956	* needed each and every time.
1957	*
1958	* With clk_dummy_minimize_rate_ops, this means that the rate will
1959	* trail along the minimum as it evolves.
1960	*/
1961	static void clk_range_test_set_range_rate_minimized(struct kunit *test)
1962	{
1963	struct clk_dummy_context *ctx = test->priv;
1964	struct clk_hw *hw = &ctx->hw;
1965	struct clk *clk = clk_hw_get_clk(hw, NULL);
1966	unsigned long rate;
1967
1968	KUNIT_ASSERT_EQ(test,
1969	clk_set_rate(clk, DUMMY_CLOCK_RATE_1 - 1000),
1970	0);
1971
1972	KUNIT_ASSERT_EQ(test,
1973	clk_set_rate_range(clk,
1974	DUMMY_CLOCK_RATE_1,
1975	DUMMY_CLOCK_RATE_2),
1976	0);
1977
1978	rate = clk_get_rate(clk);
1979	KUNIT_ASSERT_GT(test, rate, 0);
1980	KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_1);
1981
1982	KUNIT_ASSERT_EQ(test,
1983	clk_set_rate_range(clk,
1984	DUMMY_CLOCK_RATE_1 + 1000,
1985	DUMMY_CLOCK_RATE_2),
1986	0);
1987
1988	rate = clk_get_rate(clk);
1989	KUNIT_ASSERT_GT(test, rate, 0);
1990	KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_1 + 1000);
1991
1992	KUNIT_ASSERT_EQ(test,
1993	clk_set_rate_range(clk,
1994	DUMMY_CLOCK_RATE_1,
1995	DUMMY_CLOCK_RATE_2),
1996	0);
1997
1998	rate = clk_get_rate(clk);
1999	KUNIT_ASSERT_GT(test, rate, 0);
2000	KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_1);
2001
2002	clk_put(clk);
2003	}
2004
2005	/*
2006	* Test that if we have several subsequent calls to
2007	* clk_set_rate_range(), across multiple users, the core will reevaluate
2008	* whether a new rate is needed each and every time.
2009	*
2010	* With clk_dummy_minimize_rate_ops, this means that the rate will
2011	* trail along the minimum as it evolves.
2012	*/
2013	static void clk_range_test_multiple_set_range_rate_minimized(struct kunit *test)
2014	{
2015	struct clk_dummy_context *ctx = test->priv;
2016	struct clk_hw *hw = &ctx->hw;
2017	struct clk *clk = clk_hw_get_clk(hw, NULL);
2018	struct clk *user1, *user2;
2019	unsigned long rate;
2020
2021	user1 = clk_hw_get_clk(hw, NULL);
2022	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, user1);
2023
2024	user2 = clk_hw_get_clk(hw, NULL);
2025	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, user2);
2026
2027	KUNIT_ASSERT_EQ(test,
2028	clk_set_rate_range(user1,
2029	DUMMY_CLOCK_RATE_1,
2030	ULONG_MAX),
2031	0);
2032
2033	rate = clk_get_rate(clk);
2034	KUNIT_ASSERT_GT(test, rate, 0);
2035	KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_1);
2036
2037	KUNIT_ASSERT_EQ(test,
2038	clk_set_rate_range(user2,
2039	DUMMY_CLOCK_RATE_2,
2040	ULONG_MAX),
2041	0);
2042
2043	rate = clk_get_rate(clk);
2044	KUNIT_ASSERT_GT(test, rate, 0);
2045	KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_2);
2046
2047	KUNIT_ASSERT_EQ(test,
2048	clk_drop_range(user2),
2049	0);
2050
2051	rate = clk_get_rate(clk);
2052	KUNIT_ASSERT_GT(test, rate, 0);
2053	KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_1);
2054
2055	clk_put(clk: user2);
2056	clk_put(clk: user1);
2057	clk_put(clk);
2058	}
2059
2060	/*
2061	* Test that if we have several subsequent calls to
2062	* clk_set_rate_range(), across multiple users, the core will reevaluate
2063	* whether a new rate is needed, including when a user drop its clock.
2064	*
2065	* With clk_dummy_minimize_rate_ops, this means that the rate will
2066	* trail along the minimum as it evolves.
2067	*/
2068	static void clk_range_test_multiple_set_range_rate_put_minimized(struct kunit *test)
2069	{
2070	struct clk_dummy_context *ctx = test->priv;
2071	struct clk_hw *hw = &ctx->hw;
2072	struct clk *clk = clk_hw_get_clk(hw, NULL);
2073	struct clk *user1, *user2;
2074	unsigned long rate;
2075
2076	user1 = clk_hw_get_clk(hw, NULL);
2077	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, user1);
2078
2079	user2 = clk_hw_get_clk(hw, NULL);
2080	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, user2);
2081
2082	KUNIT_ASSERT_EQ(test,
2083	clk_set_rate_range(user1,
2084	DUMMY_CLOCK_RATE_1,
2085	ULONG_MAX),
2086	0);
2087
2088	rate = clk_get_rate(clk);
2089	KUNIT_ASSERT_GT(test, rate, 0);
2090	KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_1);
2091
2092	KUNIT_ASSERT_EQ(test,
2093	clk_set_rate_range(user2,
2094	DUMMY_CLOCK_RATE_2,
2095	ULONG_MAX),
2096	0);
2097
2098	rate = clk_get_rate(clk);
2099	KUNIT_ASSERT_GT(test, rate, 0);
2100	KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_2);
2101
2102	clk_put(clk: user2);
2103
2104	rate = clk_get_rate(clk);
2105	KUNIT_ASSERT_GT(test, rate, 0);
2106	KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_1);
2107
2108	clk_put(clk: user1);
2109	clk_put(clk);
2110	}
2111
2112	static struct kunit_case clk_range_minimize_test_cases[] = {
2113	KUNIT_CASE(clk_range_test_set_range_rate_minimized),
2114	KUNIT_CASE(clk_range_test_multiple_set_range_rate_minimized),
2115	KUNIT_CASE(clk_range_test_multiple_set_range_rate_put_minimized),
2116	{}
2117	};
2118
2119	/*
2120	* Test suite for a basic rate clock, without any parent.
2121	*
2122	* These tests exercise the rate range API: clk_set_rate_range(),
2123	* clk_set_min_rate(), clk_set_max_rate(), clk_drop_range(), with a
2124	* driver that will always try to run at the lowest possible rate.
2125	*/
2126	static struct kunit_suite clk_range_minimize_test_suite = {
2127	.name = "clk-range-minimize-test",
2128	.init = clk_minimize_test_init,
2129	.exit = clk_test_exit,
2130	.test_cases = clk_range_minimize_test_cases,
2131	};
2132
2133	struct clk_leaf_mux_ctx {
2134	struct clk_multiple_parent_ctx mux_ctx;
2135	struct clk_hw hw;
2136	struct clk_hw parent;
2137	struct clk_rate_request *req;
2138	int (*determine_rate_func)(struct clk_hw *hw, struct clk_rate_request *req);
2139	};
2140
2141	static int clk_leaf_mux_determine_rate(struct clk_hw *hw, struct clk_rate_request *req)
2142	{
2143	struct clk_leaf_mux_ctx *ctx = container_of(hw, struct clk_leaf_mux_ctx, hw);
2144	int ret;
2145	struct clk_rate_request *parent_req = ctx->req;
2146
2147	clk_hw_forward_rate_request(core: hw, old_req: req, parent: req->best_parent_hw, req: parent_req, parent_rate: req->rate);
2148	ret = ctx->determine_rate_func(req->best_parent_hw, parent_req);
2149	if (ret)
2150	return ret;
2151
2152	req->rate = parent_req->rate;
2153
2154	return 0;
2155	}
2156
2157	static const struct clk_ops clk_leaf_mux_set_rate_parent_ops = {
2158	.determine_rate = clk_leaf_mux_determine_rate,
2159	.set_parent = clk_dummy_single_set_parent,
2160	.get_parent = clk_dummy_single_get_parent,
2161	};
2162
2163	static int
2164	clk_leaf_mux_set_rate_parent_test_init(struct kunit *test)
2165	{
2166	struct clk_leaf_mux_ctx *ctx;
2167	const char *top_parents[2] = { "parent-0", "parent-1" };
2168	int ret;
2169
2170	ctx = kunit_kzalloc(test, size: sizeof(*ctx), GFP_KERNEL);
2171	if (!ctx)
2172	return -ENOMEM;
2173	test->priv = ctx;
2174
2175	ctx->mux_ctx.parents_ctx[0].hw.init = CLK_HW_INIT_NO_PARENT("parent-0",
2176	&clk_dummy_rate_ops,
2177	0);
2178	ctx->mux_ctx.parents_ctx[0].rate = DUMMY_CLOCK_RATE_1;
2179	ret = clk_hw_register(NULL, hw: &ctx->mux_ctx.parents_ctx[0].hw);
2180	if (ret)
2181	return ret;
2182
2183	ctx->mux_ctx.parents_ctx[1].hw.init = CLK_HW_INIT_NO_PARENT("parent-1",
2184	&clk_dummy_rate_ops,
2185	0);
2186	ctx->mux_ctx.parents_ctx[1].rate = DUMMY_CLOCK_RATE_2;
2187	ret = clk_hw_register(NULL, hw: &ctx->mux_ctx.parents_ctx[1].hw);
2188	if (ret)
2189	return ret;
2190
2191	ctx->mux_ctx.current_parent = 0;
2192	ctx->mux_ctx.hw.init = CLK_HW_INIT_PARENTS("test-mux", top_parents,
2193	&clk_multiple_parents_mux_ops,
2194	0);
2195	ret = clk_hw_register(NULL, hw: &ctx->mux_ctx.hw);
2196	if (ret)
2197	return ret;
2198
2199	ctx->parent.init = CLK_HW_INIT_HW("test-parent", &ctx->mux_ctx.hw,
2200	&empty_clk_ops, CLK_SET_RATE_PARENT);
2201	ret = clk_hw_register(NULL, hw: &ctx->parent);
2202	if (ret)
2203	return ret;
2204
2205	ctx->hw.init = CLK_HW_INIT_HW("test-clock", &ctx->parent,
2206	&clk_leaf_mux_set_rate_parent_ops,
2207	CLK_SET_RATE_PARENT);
2208	ret = clk_hw_register(NULL, hw: &ctx->hw);
2209	if (ret)
2210	return ret;
2211
2212	return 0;
2213	}
2214
2215	static void clk_leaf_mux_set_rate_parent_test_exit(struct kunit *test)
2216	{
2217	struct clk_leaf_mux_ctx *ctx = test->priv;
2218
2219	clk_hw_unregister(hw: &ctx->hw);
2220	clk_hw_unregister(hw: &ctx->parent);
2221	clk_hw_unregister(hw: &ctx->mux_ctx.hw);
2222	clk_hw_unregister(hw: &ctx->mux_ctx.parents_ctx[0].hw);
2223	clk_hw_unregister(hw: &ctx->mux_ctx.parents_ctx[1].hw);
2224	}
2225
2226	struct clk_leaf_mux_set_rate_parent_determine_rate_test_case {
2227	const char *desc;
2228	int (*determine_rate_func)(struct clk_hw *hw, struct clk_rate_request *req);
2229	};
2230
2231	static void
2232	clk_leaf_mux_set_rate_parent_determine_rate_test_case_to_desc(
2233	const struct clk_leaf_mux_set_rate_parent_determine_rate_test_case *t, char *desc)
2234	{
2235	strcpy(p: desc, q: t->desc);
2236	}
2237
2238	static const struct clk_leaf_mux_set_rate_parent_determine_rate_test_case
2239	clk_leaf_mux_set_rate_parent_determine_rate_test_cases[] = {
2240	{
2241	/*
2242	* Test that __clk_determine_rate() on the parent that can't
2243	* change rate doesn't return a clk_rate_request structure with
2244	* the best_parent_hw pointer pointing to the parent.
2245	*/
2246	.desc = "clk_leaf_mux_set_rate_parent__clk_determine_rate_proper_parent",
2247	.determine_rate_func = __clk_determine_rate,
2248	},
2249	{
2250	/*
2251	* Test that __clk_mux_determine_rate() on the parent that
2252	* can't change rate doesn't return a clk_rate_request
2253	* structure with the best_parent_hw pointer pointing to
2254	* the parent.
2255	*/
2256	.desc = "clk_leaf_mux_set_rate_parent__clk_mux_determine_rate_proper_parent",
2257	.determine_rate_func = __clk_mux_determine_rate,
2258	},
2259	{
2260	/*
2261	* Test that __clk_mux_determine_rate_closest() on the parent
2262	* that can't change rate doesn't return a clk_rate_request
2263	* structure with the best_parent_hw pointer pointing to
2264	* the parent.
2265	*/
2266	.desc = "clk_leaf_mux_set_rate_parent__clk_mux_determine_rate_closest_proper_parent",
2267	.determine_rate_func = __clk_mux_determine_rate_closest,
2268	},
2269	{
2270	/*
2271	* Test that clk_hw_determine_rate_no_reparent() on the parent
2272	* that can't change rate doesn't return a clk_rate_request
2273	* structure with the best_parent_hw pointer pointing to
2274	* the parent.
2275	*/
2276	.desc = "clk_leaf_mux_set_rate_parent_clk_hw_determine_rate_no_reparent_proper_parent",
2277	.determine_rate_func = clk_hw_determine_rate_no_reparent,
2278	},
2279	};
2280
2281	KUNIT_ARRAY_PARAM(clk_leaf_mux_set_rate_parent_determine_rate_test,
2282	clk_leaf_mux_set_rate_parent_determine_rate_test_cases,
2283	clk_leaf_mux_set_rate_parent_determine_rate_test_case_to_desc)
2284
2285	/*
2286	* Test that when a clk that can't change rate itself calls a function like
2287	* __clk_determine_rate() on its parent it doesn't get back a clk_rate_request
2288	* structure that has the best_parent_hw pointer point to the clk_hw passed
2289	* into the determine rate function. See commit 262ca38f4b6e ("clk: Stop
2290	* forwarding clk_rate_requests to the parent") for more background.
2291	*/
2292	static void clk_leaf_mux_set_rate_parent_determine_rate_test(struct kunit *test)
2293	{
2294	struct clk_leaf_mux_ctx *ctx = test->priv;
2295	struct clk_hw *hw = &ctx->hw;
2296	struct clk *clk = clk_hw_get_clk(hw, NULL);
2297	struct clk_rate_request req;
2298	unsigned long rate;
2299	const struct clk_leaf_mux_set_rate_parent_determine_rate_test_case *test_param;
2300
2301	test_param = test->param_value;
2302	ctx->determine_rate_func = test_param->determine_rate_func;
2303
2304	ctx->req = &req;
2305	rate = clk_get_rate(clk);
2306	KUNIT_ASSERT_EQ(test, rate, DUMMY_CLOCK_RATE_1);
2307	KUNIT_ASSERT_EQ(test, DUMMY_CLOCK_RATE_2, clk_round_rate(clk, DUMMY_CLOCK_RATE_2));
2308
2309	KUNIT_EXPECT_EQ(test, req.rate, DUMMY_CLOCK_RATE_2);
2310	KUNIT_EXPECT_EQ(test, req.best_parent_rate, DUMMY_CLOCK_RATE_2);
2311	KUNIT_EXPECT_PTR_EQ(test, req.best_parent_hw, &ctx->mux_ctx.hw);
2312
2313	clk_put(clk);
2314	}
2315
2316	static struct kunit_case clk_leaf_mux_set_rate_parent_test_cases[] = {
2317	KUNIT_CASE_PARAM(clk_leaf_mux_set_rate_parent_determine_rate_test,
2318	clk_leaf_mux_set_rate_parent_determine_rate_test_gen_params),
2319	{}
2320	};
2321
2322	/*
2323	* Test suite for a clock whose parent is a pass-through clk whose parent is a
2324	* mux with multiple parents. The leaf and pass-through clocks have the
2325	* CLK_SET_RATE_PARENT flag, and will forward rate requests to the mux, which
2326	* will then select which parent is the best fit for a given rate.
2327	*
2328	* These tests exercise the behaviour of muxes, and the proper selection
2329	* of parents.
2330	*/
2331	static struct kunit_suite clk_leaf_mux_set_rate_parent_test_suite = {
2332	.name = "clk-leaf-mux-set-rate-parent",
2333	.init = clk_leaf_mux_set_rate_parent_test_init,
2334	.exit = clk_leaf_mux_set_rate_parent_test_exit,
2335	.test_cases = clk_leaf_mux_set_rate_parent_test_cases,
2336	};
2337
2338	struct clk_mux_notifier_rate_change {
2339	bool done;
2340	unsigned long old_rate;
2341	unsigned long new_rate;
2342	wait_queue_head_t wq;
2343	};
2344
2345	struct clk_mux_notifier_ctx {
2346	struct clk_multiple_parent_ctx mux_ctx;
2347	struct clk *clk;
2348	struct notifier_block clk_nb;
2349	struct clk_mux_notifier_rate_change pre_rate_change;
2350	struct clk_mux_notifier_rate_change post_rate_change;
2351	};
2352
2353	#define NOTIFIER_TIMEOUT_MS 100
2354
2355	static int clk_mux_notifier_callback(struct notifier_block *nb,
2356	unsigned long action, void *data)
2357	{
2358	struct clk_notifier_data *clk_data = data;
2359	struct clk_mux_notifier_ctx *ctx = container_of(nb,
2360	struct clk_mux_notifier_ctx,
2361	clk_nb);
2362
2363	if (action & PRE_RATE_CHANGE) {
2364	ctx->pre_rate_change.old_rate = clk_data->old_rate;
2365	ctx->pre_rate_change.new_rate = clk_data->new_rate;
2366	ctx->pre_rate_change.done = true;
2367	wake_up_interruptible(&ctx->pre_rate_change.wq);
2368	}
2369
2370	if (action & POST_RATE_CHANGE) {
2371	ctx->post_rate_change.old_rate = clk_data->old_rate;
2372	ctx->post_rate_change.new_rate = clk_data->new_rate;
2373	ctx->post_rate_change.done = true;
2374	wake_up_interruptible(&ctx->post_rate_change.wq);
2375	}
2376
2377	return 0;
2378	}
2379
2380	static int clk_mux_notifier_test_init(struct kunit *test)
2381	{
2382	struct clk_mux_notifier_ctx *ctx;
2383	const char *top_parents[2] = { "parent-0", "parent-1" };
2384	int ret;
2385
2386	ctx = kunit_kzalloc(test, size: sizeof(*ctx), GFP_KERNEL);
2387	if (!ctx)
2388	return -ENOMEM;
2389	test->priv = ctx;
2390	ctx->clk_nb.notifier_call = clk_mux_notifier_callback;
2391	init_waitqueue_head(&ctx->pre_rate_change.wq);
2392	init_waitqueue_head(&ctx->post_rate_change.wq);
2393
2394	ctx->mux_ctx.parents_ctx[0].hw.init = CLK_HW_INIT_NO_PARENT("parent-0",
2395	&clk_dummy_rate_ops,
2396	0);
2397	ctx->mux_ctx.parents_ctx[0].rate = DUMMY_CLOCK_RATE_1;
2398	ret = clk_hw_register(NULL, hw: &ctx->mux_ctx.parents_ctx[0].hw);
2399	if (ret)
2400	return ret;
2401
2402	ctx->mux_ctx.parents_ctx[1].hw.init = CLK_HW_INIT_NO_PARENT("parent-1",
2403	&clk_dummy_rate_ops,
2404	0);
2405	ctx->mux_ctx.parents_ctx[1].rate = DUMMY_CLOCK_RATE_2;
2406	ret = clk_hw_register(NULL, hw: &ctx->mux_ctx.parents_ctx[1].hw);
2407	if (ret)
2408	return ret;
2409
2410	ctx->mux_ctx.current_parent = 0;
2411	ctx->mux_ctx.hw.init = CLK_HW_INIT_PARENTS("test-mux", top_parents,
2412	&clk_multiple_parents_mux_ops,
2413	0);
2414	ret = clk_hw_register(NULL, hw: &ctx->mux_ctx.hw);
2415	if (ret)
2416	return ret;
2417
2418	ctx->clk = clk_hw_get_clk(hw: &ctx->mux_ctx.hw, NULL);
2419	ret = clk_notifier_register(clk: ctx->clk, nb: &ctx->clk_nb);
2420	if (ret)
2421	return ret;
2422
2423	return 0;
2424	}
2425
2426	static void clk_mux_notifier_test_exit(struct kunit *test)
2427	{
2428	struct clk_mux_notifier_ctx *ctx = test->priv;
2429	struct clk *clk = ctx->clk;
2430
2431	clk_notifier_unregister(clk, nb: &ctx->clk_nb);
2432	clk_put(clk);
2433
2434	clk_hw_unregister(hw: &ctx->mux_ctx.hw);
2435	clk_hw_unregister(hw: &ctx->mux_ctx.parents_ctx[0].hw);
2436	clk_hw_unregister(hw: &ctx->mux_ctx.parents_ctx[1].hw);
2437	}
2438
2439	/*
2440	* Test that if the we have a notifier registered on a mux, the core
2441	* will notify us when we switch to another parent, and with the proper
2442	* old and new rates.
2443	*/
2444	static void clk_mux_notifier_set_parent_test(struct kunit *test)
2445	{
2446	struct clk_mux_notifier_ctx *ctx = test->priv;
2447	struct clk_hw *hw = &ctx->mux_ctx.hw;
2448	struct clk *clk = clk_hw_get_clk(hw, NULL);
2449	struct clk *new_parent = clk_hw_get_clk(hw: &ctx->mux_ctx.parents_ctx[1].hw, NULL);
2450	int ret;
2451
2452	ret = clk_set_parent(clk, parent: new_parent);
2453	KUNIT_ASSERT_EQ(test, ret, 0);
2454
2455	ret = wait_event_interruptible_timeout(ctx->pre_rate_change.wq,
2456	ctx->pre_rate_change.done,
2457	msecs_to_jiffies(NOTIFIER_TIMEOUT_MS));
2458	KUNIT_ASSERT_GT(test, ret, 0);
2459
2460	KUNIT_EXPECT_EQ(test, ctx->pre_rate_change.old_rate, DUMMY_CLOCK_RATE_1);
2461	KUNIT_EXPECT_EQ(test, ctx->pre_rate_change.new_rate, DUMMY_CLOCK_RATE_2);
2462
2463	ret = wait_event_interruptible_timeout(ctx->post_rate_change.wq,
2464	ctx->post_rate_change.done,
2465	msecs_to_jiffies(NOTIFIER_TIMEOUT_MS));
2466	KUNIT_ASSERT_GT(test, ret, 0);
2467
2468	KUNIT_EXPECT_EQ(test, ctx->post_rate_change.old_rate, DUMMY_CLOCK_RATE_1);
2469	KUNIT_EXPECT_EQ(test, ctx->post_rate_change.new_rate, DUMMY_CLOCK_RATE_2);
2470
2471	clk_put(clk: new_parent);
2472	clk_put(clk);
2473	}
2474
2475	static struct kunit_case clk_mux_notifier_test_cases[] = {
2476	KUNIT_CASE(clk_mux_notifier_set_parent_test),
2477	{}
2478	};
2479
2480	/*
2481	* Test suite for a mux with multiple parents, and a notifier registered
2482	* on the mux.
2483	*
2484	* These tests exercise the behaviour of notifiers.
2485	*/
2486	static struct kunit_suite clk_mux_notifier_test_suite = {
2487	.name = "clk-mux-notifier",
2488	.init = clk_mux_notifier_test_init,
2489	.exit = clk_mux_notifier_test_exit,
2490	.test_cases = clk_mux_notifier_test_cases,
2491	};
2492
2493	static int
2494	clk_mux_no_reparent_test_init(struct kunit *test)
2495	{
2496	struct clk_multiple_parent_ctx *ctx;
2497	const char *parents[2] = { "parent-0", "parent-1"};
2498	int ret;
2499
2500	ctx = kunit_kzalloc(test, size: sizeof(*ctx), GFP_KERNEL);
2501	if (!ctx)
2502	return -ENOMEM;
2503	test->priv = ctx;
2504
2505	ctx->parents_ctx[0].hw.init = CLK_HW_INIT_NO_PARENT("parent-0",
2506	&clk_dummy_rate_ops,
2507	0);
2508	ctx->parents_ctx[0].rate = DUMMY_CLOCK_RATE_1;
2509	ret = clk_hw_register(NULL, hw: &ctx->parents_ctx[0].hw);
2510	if (ret)
2511	return ret;
2512
2513	ctx->parents_ctx[1].hw.init = CLK_HW_INIT_NO_PARENT("parent-1",
2514	&clk_dummy_rate_ops,
2515	0);
2516	ctx->parents_ctx[1].rate = DUMMY_CLOCK_RATE_2;
2517	ret = clk_hw_register(NULL, hw: &ctx->parents_ctx[1].hw);
2518	if (ret)
2519	return ret;
2520
2521	ctx->current_parent = 0;
2522	ctx->hw.init = CLK_HW_INIT_PARENTS("test-mux", parents,
2523	&clk_multiple_parents_no_reparent_mux_ops,
2524	0);
2525	ret = clk_hw_register(NULL, hw: &ctx->hw);
2526	if (ret)
2527	return ret;
2528
2529	return 0;
2530	}
2531
2532	static void
2533	clk_mux_no_reparent_test_exit(struct kunit *test)
2534	{
2535	struct clk_multiple_parent_ctx *ctx = test->priv;
2536
2537	clk_hw_unregister(hw: &ctx->hw);
2538	clk_hw_unregister(hw: &ctx->parents_ctx[0].hw);
2539	clk_hw_unregister(hw: &ctx->parents_ctx[1].hw);
2540	}
2541
2542	/*
2543	* Test that if the we have a mux that cannot change parent and we call
2544	* clk_round_rate() on it with a rate that should cause it to change
2545	* parent, it won't.
2546	*/
2547	static void clk_mux_no_reparent_round_rate(struct kunit *test)
2548	{
2549	struct clk_multiple_parent_ctx *ctx = test->priv;
2550	struct clk_hw *hw = &ctx->hw;
2551	struct clk *clk = clk_hw_get_clk(hw, NULL);
2552	struct clk *other_parent, *parent;
2553	unsigned long other_parent_rate;
2554	unsigned long parent_rate;
2555	long rounded_rate;
2556
2557	parent = clk_get_parent(clk);
2558	KUNIT_ASSERT_PTR_NE(test, parent, NULL);
2559
2560	parent_rate = clk_get_rate(clk: parent);
2561	KUNIT_ASSERT_GT(test, parent_rate, 0);
2562
2563	other_parent = clk_hw_get_clk(hw: &ctx->parents_ctx[1].hw, NULL);
2564	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, other_parent);
2565	KUNIT_ASSERT_FALSE(test, clk_is_match(parent, other_parent));
2566
2567	other_parent_rate = clk_get_rate(clk: other_parent);
2568	KUNIT_ASSERT_GT(test, other_parent_rate, 0);
2569	clk_put(clk: other_parent);
2570
2571	rounded_rate = clk_round_rate(clk, rate: other_parent_rate);
2572	KUNIT_ASSERT_GT(test, rounded_rate, 0);
2573	KUNIT_EXPECT_EQ(test, rounded_rate, parent_rate);
2574
2575	clk_put(clk);
2576	}
2577
2578	/*
2579	* Test that if the we have a mux that cannot change parent and we call
2580	* clk_set_rate() on it with a rate that should cause it to change
2581	* parent, it won't.
2582	*/
2583	static void clk_mux_no_reparent_set_rate(struct kunit *test)
2584	{
2585	struct clk_multiple_parent_ctx *ctx = test->priv;
2586	struct clk_hw *hw = &ctx->hw;
2587	struct clk *clk = clk_hw_get_clk(hw, NULL);
2588	struct clk *other_parent, *parent;
2589	unsigned long other_parent_rate;
2590	unsigned long parent_rate;
2591	unsigned long rate;
2592	int ret;
2593
2594	parent = clk_get_parent(clk);
2595	KUNIT_ASSERT_PTR_NE(test, parent, NULL);
2596
2597	parent_rate = clk_get_rate(clk: parent);
2598	KUNIT_ASSERT_GT(test, parent_rate, 0);
2599
2600	other_parent = clk_hw_get_clk(hw: &ctx->parents_ctx[1].hw, NULL);
2601	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, other_parent);
2602	KUNIT_ASSERT_FALSE(test, clk_is_match(parent, other_parent));
2603
2604	other_parent_rate = clk_get_rate(clk: other_parent);
2605	KUNIT_ASSERT_GT(test, other_parent_rate, 0);
2606	clk_put(clk: other_parent);
2607
2608	ret = clk_set_rate(clk, rate: other_parent_rate);
2609	KUNIT_ASSERT_EQ(test, ret, 0);
2610
2611	rate = clk_get_rate(clk);
2612	KUNIT_ASSERT_GT(test, rate, 0);
2613	KUNIT_EXPECT_EQ(test, rate, parent_rate);
2614
2615	clk_put(clk);
2616	}
2617
2618	static struct kunit_case clk_mux_no_reparent_test_cases[] = {
2619	KUNIT_CASE(clk_mux_no_reparent_round_rate),
2620	KUNIT_CASE(clk_mux_no_reparent_set_rate),
2621	{}
2622	};
2623
2624	/*
2625	* Test suite for a clock mux that isn't allowed to change parent, using
2626	* the clk_hw_determine_rate_no_reparent() helper.
2627	*
2628	* These tests exercise that helper, and the proper selection of
2629	* rates and parents.
2630	*/
2631	static struct kunit_suite clk_mux_no_reparent_test_suite = {
2632	.name = "clk-mux-no-reparent",
2633	.init = clk_mux_no_reparent_test_init,
2634	.exit = clk_mux_no_reparent_test_exit,
2635	.test_cases = clk_mux_no_reparent_test_cases,
2636	};
2637
2638	struct clk_register_clk_parent_data_test_case {
2639	const char *desc;
2640	struct clk_parent_data pdata;
2641	};
2642
2643	static void
2644	clk_register_clk_parent_data_test_case_to_desc(
2645	const struct clk_register_clk_parent_data_test_case *t, char *desc)
2646	{
2647	strcpy(p: desc, q: t->desc);
2648	}
2649
2650	static const struct clk_register_clk_parent_data_test_case
2651	clk_register_clk_parent_data_of_cases[] = {
2652	{
2653	/*
2654	* Test that a clk registered with a struct device_node can
2655	* find a parent based on struct clk_parent_data::index.
2656	*/
2657	.desc = "clk_parent_data_of_index_test",
2658	.pdata.index = 0,
2659	},
2660	{
2661	/*
2662	* Test that a clk registered with a struct device_node can
2663	* find a parent based on struct clk_parent_data::fwname.
2664	*/
2665	.desc = "clk_parent_data_of_fwname_test",
2666	.pdata.fw_name = CLK_PARENT_DATA_PARENT1,
2667	},
2668	{
2669	/*
2670	* Test that a clk registered with a struct device_node can
2671	* find a parent based on struct clk_parent_data::name.
2672	*/
2673	.desc = "clk_parent_data_of_name_test",
2674	/* The index must be negative to indicate firmware not used */
2675	.pdata.index = -1,
2676	.pdata.name = CLK_PARENT_DATA_1MHZ_NAME,
2677	},
2678	{
2679	/*
2680	* Test that a clk registered with a struct device_node can
2681	* find a parent based on struct
2682	* clk_parent_data::{fw_name,name}.
2683	*/
2684	.desc = "clk_parent_data_of_fwname_name_test",
2685	.pdata.fw_name = CLK_PARENT_DATA_PARENT1,
2686	.pdata.name = "not_matching",
2687	},
2688	{
2689	/*
2690	* Test that a clk registered with a struct device_node can
2691	* find a parent based on struct clk_parent_data::{index,name}.
2692	* Index takes priority.
2693	*/
2694	.desc = "clk_parent_data_of_index_name_priority_test",
2695	.pdata.index = 0,
2696	.pdata.name = "not_matching",
2697	},
2698	{
2699	/*
2700	* Test that a clk registered with a struct device_node can
2701	* find a parent based on struct
2702	* clk_parent_data::{index,fwname,name}. The fw_name takes
2703	* priority over index and name.
2704	*/
2705	.desc = "clk_parent_data_of_index_fwname_name_priority_test",
2706	.pdata.index = 1,
2707	.pdata.fw_name = CLK_PARENT_DATA_PARENT1,
2708	.pdata.name = "not_matching",
2709	},
2710	};
2711
2712	KUNIT_ARRAY_PARAM(clk_register_clk_parent_data_of_test, clk_register_clk_parent_data_of_cases,
2713	clk_register_clk_parent_data_test_case_to_desc)
2714
2715	/**
2716	* struct clk_register_clk_parent_data_of_ctx - Context for clk_parent_data OF tests
2717	* @np: device node of clk under test
2718	* @hw: clk_hw for clk under test
2719	*/
2720	struct clk_register_clk_parent_data_of_ctx {
2721	struct device_node *np;
2722	struct clk_hw hw;
2723	};
2724
2725	static int clk_register_clk_parent_data_of_test_init(struct kunit *test)
2726	{
2727	struct clk_register_clk_parent_data_of_ctx *ctx;
2728
2729	KUNIT_ASSERT_EQ(test, 0,
2730	of_overlay_apply_kunit(test, kunit_clk_parent_data_test));
2731
2732	ctx = kunit_kzalloc(test, size: sizeof(*ctx), GFP_KERNEL);
2733	if (!ctx)
2734	return -ENOMEM;
2735	test->priv = ctx;
2736
2737	ctx->np = of_find_compatible_node(NULL, NULL, compat: "test,clk-parent-data");
2738	if (!ctx->np)
2739	return -ENODEV;
2740
2741	of_node_put_kunit(test, node: ctx->np);
2742
2743	return 0;
2744	}
2745
2746	/*
2747	* Test that a clk registered with a struct device_node can find a parent based on
2748	* struct clk_parent_data when the hw member isn't set.
2749	*/
2750	static void clk_register_clk_parent_data_of_test(struct kunit *test)
2751	{
2752	struct clk_register_clk_parent_data_of_ctx *ctx = test->priv;
2753	struct clk_hw *parent_hw;
2754	const struct clk_register_clk_parent_data_test_case *test_param;
2755	struct clk_init_data init = { };
2756	struct clk *expected_parent, *actual_parent;
2757
2758	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx->np);
2759
2760	expected_parent = of_clk_get_kunit(test, np: ctx->np, index: 0);
2761	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, expected_parent);
2762
2763	test_param = test->param_value;
2764	init.parent_data = &test_param->pdata;
2765	init.num_parents = 1;
2766	init.name = "parent_data_of_test_clk";
2767	init.ops = &clk_dummy_single_parent_ops;
2768	ctx->hw.init = &init;
2769	KUNIT_ASSERT_EQ(test, 0, of_clk_hw_register_kunit(test, ctx->np, &ctx->hw));
2770
2771	parent_hw = clk_hw_get_parent(hw: &ctx->hw);
2772	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent_hw);
2773
2774	actual_parent = clk_hw_get_clk_kunit(test, hw: parent_hw, con_id: __func__);
2775	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, actual_parent);
2776
2777	KUNIT_EXPECT_TRUE(test, clk_is_match(expected_parent, actual_parent));
2778	}
2779
2780	static struct kunit_case clk_register_clk_parent_data_of_test_cases[] = {
2781	KUNIT_CASE_PARAM(clk_register_clk_parent_data_of_test,
2782	clk_register_clk_parent_data_of_test_gen_params),
2783	{}
2784	};
2785
2786	/*
2787	* Test suite for registering clks with struct clk_parent_data and a struct
2788	* device_node.
2789	*/
2790	static struct kunit_suite clk_register_clk_parent_data_of_suite = {
2791	.name = "clk_register_clk_parent_data_of",
2792	.init = clk_register_clk_parent_data_of_test_init,
2793	.test_cases = clk_register_clk_parent_data_of_test_cases,
2794	};
2795
2796	/**
2797	* struct platform_driver_dev_ctx - Context to stash platform device
2798	* @dev: device under test
2799	* @pdrv: driver to attach to find @dev
2800	*/
2801	struct platform_driver_dev_ctx {
2802	struct device *dev;
2803	struct platform_driver pdrv;
2804	};
2805
2806	static inline struct platform_driver_dev_ctx *
2807	pdev_to_platform_driver_dev_ctx(struct platform_device *pdev)
2808	{
2809	return container_of(to_platform_driver(pdev->dev.driver),
2810	struct platform_driver_dev_ctx, pdrv);
2811	}
2812
2813	static int kunit_platform_driver_dev_probe(struct platform_device *pdev)
2814	{
2815	struct platform_driver_dev_ctx *ctx;
2816
2817	ctx = pdev_to_platform_driver_dev_ctx(pdev);
2818	ctx->dev = &pdev->dev;
2819
2820	return 0;
2821	}
2822
2823	static struct device *
2824	kunit_of_platform_driver_dev(struct kunit *test, const struct of_device_id *match_table)
2825	{
2826	struct platform_driver_dev_ctx *ctx;
2827
2828	ctx = kunit_kzalloc(test, size: sizeof(*ctx), GFP_KERNEL);
2829	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx);
2830
2831	ctx->pdrv.probe = kunit_platform_driver_dev_probe;
2832	ctx->pdrv.driver.of_match_table = match_table;
2833	ctx->pdrv.driver.name = __func__;
2834	ctx->pdrv.driver.owner = THIS_MODULE;
2835
2836	KUNIT_ASSERT_EQ(test, 0, kunit_platform_driver_register(test, &ctx->pdrv));
2837	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, ctx->dev);
2838
2839	return ctx->dev;
2840	}
2841
2842	static const struct clk_register_clk_parent_data_test_case
2843	clk_register_clk_parent_data_device_cases[] = {
2844	{
2845	/*
2846	* Test that a clk registered with a struct device can find a
2847	* parent based on struct clk_parent_data::index.
2848	*/
2849	.desc = "clk_parent_data_device_index_test",
2850	.pdata.index = 1,
2851	},
2852	{
2853	/*
2854	* Test that a clk registered with a struct device can find a
2855	* parent based on struct clk_parent_data::fwname.
2856	*/
2857	.desc = "clk_parent_data_device_fwname_test",
2858	.pdata.fw_name = CLK_PARENT_DATA_PARENT2,
2859	},
2860	{
2861	/*
2862	* Test that a clk registered with a struct device can find a
2863	* parent based on struct clk_parent_data::name.
2864	*/
2865	.desc = "clk_parent_data_device_name_test",
2866	/* The index must be negative to indicate firmware not used */
2867	.pdata.index = -1,
2868	.pdata.name = CLK_PARENT_DATA_50MHZ_NAME,
2869	},
2870	{
2871	/*
2872	* Test that a clk registered with a struct device can find a
2873	* parent based on struct clk_parent_data::{fw_name,name}.
2874	*/
2875	.desc = "clk_parent_data_device_fwname_name_test",
2876	.pdata.fw_name = CLK_PARENT_DATA_PARENT2,
2877	.pdata.name = "not_matching",
2878	},
2879	{
2880	/*
2881	* Test that a clk registered with a struct device can find a
2882	* parent based on struct clk_parent_data::{index,name}. Index
2883	* takes priority.
2884	*/
2885	.desc = "clk_parent_data_device_index_name_priority_test",
2886	.pdata.index = 1,
2887	.pdata.name = "not_matching",
2888	},
2889	{
2890	/*
2891	* Test that a clk registered with a struct device can find a
2892	* parent based on struct clk_parent_data::{index,fwname,name}.
2893	* The fw_name takes priority over index and name.
2894	*/
2895	.desc = "clk_parent_data_device_index_fwname_name_priority_test",
2896	.pdata.index = 0,
2897	.pdata.fw_name = CLK_PARENT_DATA_PARENT2,
2898	.pdata.name = "not_matching",
2899	},
2900	};
2901
2902	KUNIT_ARRAY_PARAM(clk_register_clk_parent_data_device_test,
2903	clk_register_clk_parent_data_device_cases,
2904	clk_register_clk_parent_data_test_case_to_desc)
2905
2906	/*
2907	* Test that a clk registered with a struct device can find a parent based on
2908	* struct clk_parent_data when the hw member isn't set.
2909	*/
2910	static void clk_register_clk_parent_data_device_test(struct kunit *test)
2911	{
2912	struct device *dev;
2913	struct clk_hw *hw;
2914	const struct clk_register_clk_parent_data_test_case *test_param;
2915	struct clk_hw *parent_hw;
2916	struct clk_init_data init = { };
2917	struct clk *expected_parent, *actual_parent;
2918	static const struct of_device_id match_table[] = {
2919	{ .compatible = "test,clk-parent-data" },
2920	{ }
2921	};
2922
2923	dev = kunit_of_platform_driver_dev(test, match_table);
2924
2925	expected_parent = clk_get_kunit(test, dev, con_id: "50");
2926	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, expected_parent);
2927
2928	hw = kunit_kzalloc(test, size: sizeof(*hw), GFP_KERNEL);
2929	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, hw);
2930
2931	test_param = test->param_value;
2932	init.parent_data = &test_param->pdata;
2933	init.num_parents = 1;
2934	init.name = "parent_data_device_test_clk";
2935	init.ops = &clk_dummy_single_parent_ops;
2936	hw->init = &init;
2937	KUNIT_ASSERT_EQ(test, 0, clk_hw_register_kunit(test, dev, hw));
2938
2939	parent_hw = clk_hw_get_parent(hw);
2940	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent_hw);
2941
2942	actual_parent = clk_hw_get_clk_kunit(test, hw: parent_hw, con_id: __func__);
2943	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, actual_parent);
2944
2945	KUNIT_EXPECT_TRUE(test, clk_is_match(expected_parent, actual_parent));
2946	}
2947
2948	static const struct clk_register_clk_parent_data_test_case
2949	clk_register_clk_parent_data_device_hw_cases[] = {
2950	{
2951	/*
2952	* Test that a clk registered with a struct device can find a
2953	* parent based on struct clk_parent_data::hw.
2954	*/
2955	.desc = "clk_parent_data_device_hw_index_test",
2956	/* The index must be negative to indicate firmware not used */
2957	.pdata.index = -1,
2958	},
2959	{
2960	/*
2961	* Test that a clk registered with a struct device can find a
2962	* parent based on struct clk_parent_data::hw when
2963	* struct clk_parent_data::fw_name is set.
2964	*/
2965	.desc = "clk_parent_data_device_hw_fwname_test",
2966	.pdata.fw_name = CLK_PARENT_DATA_PARENT2,
2967	},
2968	{
2969	/*
2970	* Test that a clk registered with a struct device can find a
2971	* parent based on struct clk_parent_data::hw when struct
2972	* clk_parent_data::name is set.
2973	*/
2974	.desc = "clk_parent_data_device_hw_name_test",
2975	/* The index must be negative to indicate firmware not used */
2976	.pdata.index = -1,
2977	.pdata.name = CLK_PARENT_DATA_50MHZ_NAME,
2978	},
2979	{
2980	/*
2981	* Test that a clk registered with a struct device can find a
2982	* parent based on struct clk_parent_data::hw when struct
2983	* clk_parent_data::{fw_name,name} are set.
2984	*/
2985	.desc = "clk_parent_data_device_hw_fwname_name_test",
2986	.pdata.fw_name = CLK_PARENT_DATA_PARENT2,
2987	.pdata.name = "not_matching",
2988	},
2989	{
2990	/*
2991	* Test that a clk registered with a struct device can find a
2992	* parent based on struct clk_parent_data::hw when struct
2993	* clk_parent_data::index is set. The hw pointer takes
2994	* priority.
2995	*/
2996	.desc = "clk_parent_data_device_hw_index_priority_test",
2997	.pdata.index = 0,
2998	},
2999	{
3000	/*
3001	* Test that a clk registered with a struct device can find a
3002	* parent based on struct clk_parent_data::hw when
3003	* struct clk_parent_data::{index,fwname,name} are set.
3004	* The hw pointer takes priority over everything else.
3005	*/
3006	.desc = "clk_parent_data_device_hw_index_fwname_name_priority_test",
3007	.pdata.index = 0,
3008	.pdata.fw_name = CLK_PARENT_DATA_PARENT2,
3009	.pdata.name = "not_matching",
3010	},
3011	};
3012
3013	KUNIT_ARRAY_PARAM(clk_register_clk_parent_data_device_hw_test,
3014	clk_register_clk_parent_data_device_hw_cases,
3015	clk_register_clk_parent_data_test_case_to_desc)
3016
3017	/*
3018	* Test that a clk registered with a struct device can find a
3019	* parent based on struct clk_parent_data::hw.
3020	*/
3021	static void clk_register_clk_parent_data_device_hw_test(struct kunit *test)
3022	{
3023	struct device *dev;
3024	struct clk_hw *hw;
3025	const struct clk_register_clk_parent_data_test_case *test_param;
3026	struct clk_dummy_context *parent;
3027	struct clk_hw *parent_hw;
3028	struct clk_parent_data pdata = { };
3029	struct clk_init_data init = { };
3030	static const struct of_device_id match_table[] = {
3031	{ .compatible = "test,clk-parent-data" },
3032	{ }
3033	};
3034
3035	dev = kunit_of_platform_driver_dev(test, match_table);
3036
3037	parent = kunit_kzalloc(test, size: sizeof(*parent), GFP_KERNEL);
3038	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent);
3039
3040	parent_hw = &parent->hw;
3041	parent_hw->init = CLK_HW_INIT_NO_PARENT("parent-clk",
3042	&clk_dummy_rate_ops, 0);
3043
3044	KUNIT_ASSERT_EQ(test, 0, clk_hw_register_kunit(test, dev, parent_hw));
3045
3046	hw = kunit_kzalloc(test, size: sizeof(*hw), GFP_KERNEL);
3047	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, hw);
3048
3049	test_param = test->param_value;
3050	memcpy(&pdata, &test_param->pdata, sizeof(pdata));
3051	pdata.hw = parent_hw;
3052	init.parent_data = &pdata;
3053	init.num_parents = 1;
3054	init.ops = &clk_dummy_single_parent_ops;
3055	init.name = "parent_data_device_hw_test_clk";
3056	hw->init = &init;
3057	KUNIT_ASSERT_EQ(test, 0, clk_hw_register_kunit(test, dev, hw));
3058
3059	KUNIT_EXPECT_PTR_EQ(test, parent_hw, clk_hw_get_parent(hw));
3060	}
3061
3062	static struct kunit_case clk_register_clk_parent_data_device_test_cases[] = {
3063	KUNIT_CASE_PARAM(clk_register_clk_parent_data_device_test,
3064	clk_register_clk_parent_data_device_test_gen_params),
3065	KUNIT_CASE_PARAM(clk_register_clk_parent_data_device_hw_test,
3066	clk_register_clk_parent_data_device_hw_test_gen_params),
3067	{}
3068	};
3069
3070	static int clk_register_clk_parent_data_device_init(struct kunit *test)
3071	{
3072	KUNIT_ASSERT_EQ(test, 0,
3073	of_overlay_apply_kunit(test, kunit_clk_parent_data_test));
3074
3075	return 0;
3076	}
3077
3078	/*
3079	* Test suite for registering clks with struct clk_parent_data and a struct
3080	* device.
3081	*/
3082	static struct kunit_suite clk_register_clk_parent_data_device_suite = {
3083	.name = "clk_register_clk_parent_data_device",
3084	.init = clk_register_clk_parent_data_device_init,
3085	.test_cases = clk_register_clk_parent_data_device_test_cases,
3086	};
3087
3088	struct clk_assigned_rates_context {
3089	struct clk_dummy_context clk0;
3090	struct clk_dummy_context clk1;
3091	};
3092
3093	/*
3094	* struct clk_assigned_rates_test_param - Test parameters for clk_assigned_rates test
3095	* @desc: Test description
3096	* @overlay_begin: Pointer to start of DT overlay to apply for test
3097	* @overlay_end: Pointer to end of DT overlay to apply for test
3098	* @rate0: Initial rate of first clk
3099	* @rate1: Initial rate of second clk
3100	* @consumer_test: true if a consumer is being tested
3101	*/
3102	struct clk_assigned_rates_test_param {
3103	const char *desc;
3104	u8 *overlay_begin;
3105	u8 *overlay_end;
3106	unsigned long rate0;
3107	unsigned long rate1;
3108	bool consumer_test;
3109	};
3110
3111	#define TEST_PARAM_OVERLAY(overlay_name) \
3112	.overlay_begin = of_overlay_begin(overlay_name), \
3113	.overlay_end = of_overlay_end(overlay_name)
3114
3115	static void
3116	clk_assigned_rates_register_clk(struct kunit *test,
3117	struct clk_dummy_context *ctx,
3118	struct device_node *np, const char *name,
3119	unsigned long rate)
3120	{
3121	struct clk_init_data init = { };
3122
3123	init.name = name;
3124	init.ops = &clk_dummy_rate_ops;
3125	ctx->hw.init = &init;
3126	ctx->rate = rate;
3127
3128	KUNIT_ASSERT_EQ(test, 0, of_clk_hw_register_kunit(test, np, &ctx->hw));
3129	KUNIT_ASSERT_EQ(test, ctx->rate, rate);
3130	}
3131
3132	/*
3133	* Does most of the work of the test:
3134	*
3135	* 1. Apply the overlay to test
3136	* 2. Register the clk or clks to test
3137	* 3. Register the clk provider
3138	* 4. Apply clk defaults to the consumer device if this is a consumer test
3139	*
3140	* The tests will set different test_param values to test different scenarios
3141	* and validate that in their test functions.
3142	*/
3143	static int clk_assigned_rates_test_init(struct kunit *test)
3144	{
3145	struct device_node *np, *consumer;
3146	struct clk_hw_onecell_data *data;
3147	struct clk_assigned_rates_context *ctx;
3148	u32 clk_cells;
3149	const struct clk_assigned_rates_test_param *test_param;
3150
3151	test_param = test->param_value;
3152
3153	KUNIT_ASSERT_EQ(test, 0, __of_overlay_apply_kunit(test,
3154	test_param->overlay_begin,
3155	test_param->overlay_end));
3156
3157	KUNIT_ASSERT_NOT_ERR_OR_NULL(test,
3158	ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL));
3159	test->priv = ctx;
3160
3161	KUNIT_ASSERT_NOT_ERR_OR_NULL(test,
3162	np = of_find_compatible_node(NULL, NULL, "test,clk-assigned-rates"));
3163	of_node_put_kunit(test, node: np);
3164
3165	KUNIT_ASSERT_EQ(test, 0, of_property_read_u32(np, "#clock-cells", &clk_cells));
3166	/* Only support #clock-cells = <0> or <1> */
3167	KUNIT_ASSERT_LT(test, clk_cells, 2);
3168
3169	clk_assigned_rates_register_clk(test, ctx: &ctx->clk0, np,
3170	name: "test_assigned_rate0", rate: test_param->rate0);
3171	if (clk_cells == 0) {
3172	KUNIT_ASSERT_EQ(test, 0,
3173	of_clk_add_hw_provider_kunit(test, np, of_clk_hw_simple_get,
3174	&ctx->clk0.hw));
3175	} else if (clk_cells == 1) {
3176	clk_assigned_rates_register_clk(test, ctx: &ctx->clk1, np,
3177	name: "test_assigned_rate1", rate: test_param->rate1);
3178
3179	KUNIT_ASSERT_NOT_ERR_OR_NULL(test,
3180	data = kunit_kzalloc(test, struct_size(data, hws, 2), GFP_KERNEL));
3181	data->num = 2;
3182	data->hws[0] = &ctx->clk0.hw;
3183	data->hws[1] = &ctx->clk1.hw;
3184
3185	KUNIT_ASSERT_EQ(test, 0,
3186	of_clk_add_hw_provider_kunit(test, np, of_clk_hw_onecell_get, data));
3187	}
3188
3189	/* Consumers are optional */
3190	if (test_param->consumer_test) {
3191	KUNIT_ASSERT_NOT_ERR_OR_NULL(test,
3192	consumer = of_find_compatible_node(NULL, NULL, "test,clk-consumer"));
3193	of_node_put_kunit(test, node: consumer);
3194
3195	KUNIT_ASSERT_EQ(test, 0, of_clk_set_defaults(consumer, false));
3196	}
3197
3198	return 0;
3199	}
3200
3201	static void clk_assigned_rates_assigns_one(struct kunit *test)
3202	{
3203	struct clk_assigned_rates_context *ctx = test->priv;
3204
3205	KUNIT_EXPECT_EQ(test, ctx->clk0.rate, ASSIGNED_RATES_0_RATE);
3206	}
3207
3208	static void clk_assigned_rates_assigns_multiple(struct kunit *test)
3209	{
3210	struct clk_assigned_rates_context *ctx = test->priv;
3211
3212	KUNIT_EXPECT_EQ(test, ctx->clk0.rate, ASSIGNED_RATES_0_RATE);
3213	KUNIT_EXPECT_EQ(test, ctx->clk1.rate, ASSIGNED_RATES_1_RATE);
3214	}
3215
3216	static void clk_assigned_rates_skips(struct kunit *test)
3217	{
3218	struct clk_assigned_rates_context *ctx = test->priv;
3219	const struct clk_assigned_rates_test_param *test_param = test->param_value;
3220
3221	KUNIT_EXPECT_NE(test, ctx->clk0.rate, ASSIGNED_RATES_0_RATE);
3222	KUNIT_EXPECT_EQ(test, ctx->clk0.rate, test_param->rate0);
3223	}
3224
3225	OF_OVERLAY_DECLARE(kunit_clk_assigned_rates_one);
3226	OF_OVERLAY_DECLARE(kunit_clk_assigned_rates_one_consumer);
3227	OF_OVERLAY_DECLARE(kunit_clk_assigned_rates_u64_one);
3228	OF_OVERLAY_DECLARE(kunit_clk_assigned_rates_u64_one_consumer);
3229
3230	/* Test cases that assign one rate */
3231	static const struct clk_assigned_rates_test_param clk_assigned_rates_assigns_one_test_params[] = {
3232	{
3233	/*
3234	* Test that a single cell assigned-clock-rates property
3235	* assigns the rate when the property is in the provider.
3236	*/
3237	.desc = "provider assigns",
3238	TEST_PARAM_OVERLAY(kunit_clk_assigned_rates_one),
3239	},
3240	{
3241	/*
3242	* Test that a single cell assigned-clock-rates property
3243	* assigns the rate when the property is in the consumer.
3244	*/
3245	.desc = "consumer assigns",
3246	TEST_PARAM_OVERLAY(kunit_clk_assigned_rates_one_consumer),
3247	.consumer_test = true,
3248	},
3249	{
3250	/*
3251	* Test that a single cell assigned-clock-rates-u64 property
3252	* assigns the rate when the property is in the provider.
3253	*/
3254	.desc = "provider assigns u64",
3255	TEST_PARAM_OVERLAY(kunit_clk_assigned_rates_u64_one),
3256	},
3257	{
3258	/*
3259	* Test that a single cell assigned-clock-rates-u64 property
3260	* assigns the rate when the property is in the consumer.
3261	*/
3262	.desc = "consumer assigns u64",
3263	TEST_PARAM_OVERLAY(kunit_clk_assigned_rates_u64_one_consumer),
3264	.consumer_test = true,
3265	},
3266	};
3267	KUNIT_ARRAY_PARAM_DESC(clk_assigned_rates_assigns_one,
3268	clk_assigned_rates_assigns_one_test_params, desc)
3269
3270	OF_OVERLAY_DECLARE(kunit_clk_assigned_rates_multiple);
3271	OF_OVERLAY_DECLARE(kunit_clk_assigned_rates_multiple_consumer);
3272	OF_OVERLAY_DECLARE(kunit_clk_assigned_rates_u64_multiple);
3273	OF_OVERLAY_DECLARE(kunit_clk_assigned_rates_u64_multiple_consumer);
3274
3275	/* Test cases that assign multiple rates */
3276	static const struct clk_assigned_rates_test_param clk_assigned_rates_assigns_multiple_test_params[] = {
3277	{
3278	/*
3279	* Test that a multiple cell assigned-clock-rates property
3280	* assigns the rates when the property is in the provider.
3281	*/
3282	.desc = "provider assigns",
3283	TEST_PARAM_OVERLAY(kunit_clk_assigned_rates_multiple),
3284	},
3285	{
3286	/*
3287	* Test that a multiple cell assigned-clock-rates property
3288	* assigns the rates when the property is in the consumer.
3289	*/
3290	.desc = "consumer assigns",
3291	TEST_PARAM_OVERLAY(kunit_clk_assigned_rates_multiple_consumer),
3292	.consumer_test = true,
3293	},
3294	{
3295	/*
3296	* Test that a single cell assigned-clock-rates-u64 property
3297	* assigns the rate when the property is in the provider.
3298	*/
3299	.desc = "provider assigns u64",
3300	TEST_PARAM_OVERLAY(kunit_clk_assigned_rates_u64_multiple),
3301	},
3302	{
3303	/*
3304	* Test that a multiple cell assigned-clock-rates-u64 property
3305	* assigns the rates when the property is in the consumer.
3306	*/
3307	.desc = "consumer assigns u64",
3308	TEST_PARAM_OVERLAY(kunit_clk_assigned_rates_u64_multiple_consumer),
3309	.consumer_test = true,
3310	},
3311	};
3312	KUNIT_ARRAY_PARAM_DESC(clk_assigned_rates_assigns_multiple,
3313	clk_assigned_rates_assigns_multiple_test_params,
3314	desc)
3315
3316	OF_OVERLAY_DECLARE(kunit_clk_assigned_rates_without);
3317	OF_OVERLAY_DECLARE(kunit_clk_assigned_rates_without_consumer);
3318	OF_OVERLAY_DECLARE(kunit_clk_assigned_rates_zero);
3319	OF_OVERLAY_DECLARE(kunit_clk_assigned_rates_zero_consumer);
3320	OF_OVERLAY_DECLARE(kunit_clk_assigned_rates_null);
3321	OF_OVERLAY_DECLARE(kunit_clk_assigned_rates_null_consumer);
3322
3323	/* Test cases that skip changing the rate due to malformed DT */
3324	static const struct clk_assigned_rates_test_param clk_assigned_rates_skips_test_params[] = {
3325	{
3326	/*
3327	* Test that an assigned-clock-rates property without an assigned-clocks
3328	* property fails when the property is in the provider.
3329	*/
3330	.desc = "provider missing assigned-clocks",
3331	TEST_PARAM_OVERLAY(kunit_clk_assigned_rates_without),
3332	.rate0 = 3000,
3333	},
3334	{
3335	/*
3336	* Test that an assigned-clock-rates property without an assigned-clocks
3337	* property fails when the property is in the consumer.
3338	*/
3339	.desc = "consumer missing assigned-clocks",
3340	TEST_PARAM_OVERLAY(kunit_clk_assigned_rates_without_consumer),
3341	.rate0 = 3000,
3342	.consumer_test = true,
3343	},
3344	{
3345	/*
3346	* Test that an assigned-clock-rates property of zero doesn't
3347	* set a rate when the property is in the provider.
3348	*/
3349	.desc = "provider assigned-clock-rates of zero",
3350	TEST_PARAM_OVERLAY(kunit_clk_assigned_rates_zero),
3351	.rate0 = 3000,
3352	},
3353	{
3354	/*
3355	* Test that an assigned-clock-rates property of zero doesn't
3356	* set a rate when the property is in the consumer.
3357	*/
3358	.desc = "consumer assigned-clock-rates of zero",
3359	TEST_PARAM_OVERLAY(kunit_clk_assigned_rates_zero_consumer),
3360	.rate0 = 3000,
3361	.consumer_test = true,
3362	},
3363	{
3364	/*
3365	* Test that an assigned-clocks property with a null phandle
3366	* doesn't set a rate when the property is in the provider.
3367	*/
3368	.desc = "provider assigned-clocks null phandle",
3369	TEST_PARAM_OVERLAY(kunit_clk_assigned_rates_null),
3370	.rate0 = 3000,
3371	},
3372	{
3373	/*
3374	* Test that an assigned-clocks property with a null phandle
3375	* doesn't set a rate when the property is in the consumer.
3376	*/
3377	.desc = "provider assigned-clocks null phandle",
3378	TEST_PARAM_OVERLAY(kunit_clk_assigned_rates_null_consumer),
3379	.rate0 = 3000,
3380	.consumer_test = true,
3381	},
3382	};
3383	KUNIT_ARRAY_PARAM_DESC(clk_assigned_rates_skips,
3384	clk_assigned_rates_skips_test_params,
3385	desc)
3386
3387	static struct kunit_case clk_assigned_rates_test_cases[] = {
3388	KUNIT_CASE_PARAM(clk_assigned_rates_assigns_one,
3389	clk_assigned_rates_assigns_one_gen_params),
3390	KUNIT_CASE_PARAM(clk_assigned_rates_assigns_multiple,
3391	clk_assigned_rates_assigns_multiple_gen_params),
3392	KUNIT_CASE_PARAM(clk_assigned_rates_skips,
3393	clk_assigned_rates_skips_gen_params),
3394	{}
3395	};
3396
3397	/*
3398	* Test suite for assigned-clock-rates{-u64} DT property.
3399	*/
3400	static struct kunit_suite clk_assigned_rates_suite = {
3401	.name = "clk_assigned_rates",
3402	.test_cases = clk_assigned_rates_test_cases,
3403	.init = clk_assigned_rates_test_init,
3404	};
3405
3406	static const struct clk_init_data clk_hw_get_dev_of_node_init_data = {
3407	.name = "clk_hw_get_dev_of_node",
3408	.ops = &empty_clk_ops,
3409	};
3410
3411	/*
3412	* Test that a clk registered with a struct device returns the device from
3413	* clk_hw_get_dev() and the node from clk_hw_get_of_node()
3414	*/
3415	static void clk_hw_register_dev_get_dev_returns_dev(struct kunit *test)
3416	{
3417	struct device *dev;
3418	struct clk_hw *hw;
3419	static const struct of_device_id match_table[] = {
3420	{ .compatible = "test,clk-hw-get-dev-of-node" },
3421	{ }
3422	};
3423
3424	KUNIT_ASSERT_EQ(test, 0, of_overlay_apply_kunit(test, kunit_clk_hw_get_dev_of_node));
3425
3426	dev = kunit_of_platform_driver_dev(test, match_table);
3427
3428	hw = kunit_kzalloc(test, size: sizeof(*hw), GFP_KERNEL);
3429	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, hw);
3430
3431	hw->init = &clk_hw_get_dev_of_node_init_data;
3432	KUNIT_ASSERT_EQ(test, 0, clk_hw_register_kunit(test, dev, hw));
3433
3434	KUNIT_EXPECT_PTR_EQ(test, dev, clk_hw_get_dev(hw));
3435	KUNIT_EXPECT_PTR_EQ(test, dev_of_node(dev), clk_hw_get_of_node(hw));
3436	}
3437
3438	/*
3439	* Test that a clk registered with a struct device that's not associated with
3440	* an OF node returns the device from clk_hw_get_dev() and NULL from
3441	* clk_hw_get_of_node()
3442	*/
3443	static void clk_hw_register_dev_no_node_get_dev_returns_dev(struct kunit *test)
3444	{
3445	struct platform_device *pdev;
3446	struct device *dev;
3447	struct clk_hw *hw;
3448
3449	pdev = kunit_platform_device_alloc(test, name: "clk_hw_register_dev_no_node", id: -1);
3450	KUNIT_ASSERT_NOT_NULL(test, pdev);
3451	KUNIT_ASSERT_EQ(test, 0, kunit_platform_device_add(test, pdev));
3452	dev = &pdev->dev;
3453
3454	hw = kunit_kzalloc(test, size: sizeof(*hw), GFP_KERNEL);
3455	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, hw);
3456
3457	hw->init = &clk_hw_get_dev_of_node_init_data;
3458	KUNIT_ASSERT_EQ(test, 0, clk_hw_register_kunit(test, dev, hw));
3459
3460	KUNIT_EXPECT_PTR_EQ(test, dev, clk_hw_get_dev(hw));
3461	KUNIT_EXPECT_PTR_EQ(test, NULL, clk_hw_get_of_node(hw));
3462	}
3463
3464	/*
3465	* Test that a clk registered without a struct device returns NULL from
3466	* clk_hw_get_dev()
3467	*/
3468	static void clk_hw_register_NULL_get_dev_of_node_returns_NULL(struct kunit *test)
3469	{
3470	struct clk_hw *hw;
3471
3472	hw = kunit_kzalloc(test, size: sizeof(*hw), GFP_KERNEL);
3473	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, hw);
3474
3475	hw->init = &clk_hw_get_dev_of_node_init_data;
3476
3477	KUNIT_ASSERT_EQ(test, 0, clk_hw_register_kunit(test, NULL, hw));
3478
3479	KUNIT_EXPECT_PTR_EQ(test, NULL, clk_hw_get_dev(hw));
3480	KUNIT_EXPECT_PTR_EQ(test, NULL, clk_hw_get_of_node(hw));
3481	}
3482
3483	/*
3484	* Test that a clk registered with an of_node returns the node from
3485	* clk_hw_get_of_node() and NULL from clk_hw_get_dev()
3486	*/
3487	static void of_clk_hw_register_node_get_of_node_returns_node(struct kunit *test)
3488	{
3489	struct device_node *np;
3490	struct clk_hw *hw;
3491
3492	hw = kunit_kzalloc(test, size: sizeof(*hw), GFP_KERNEL);
3493	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, hw);
3494
3495	KUNIT_ASSERT_EQ(test, 0, of_overlay_apply_kunit(test, kunit_clk_hw_get_dev_of_node));
3496
3497	np = of_find_compatible_node(NULL, NULL, compat: "test,clk-hw-get-dev-of-node");
3498	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, np);
3499	of_node_put_kunit(test, node: np);
3500
3501	hw->init = &clk_hw_get_dev_of_node_init_data;
3502	KUNIT_ASSERT_EQ(test, 0, of_clk_hw_register_kunit(test, np, hw));
3503
3504	KUNIT_EXPECT_PTR_EQ(test, NULL, clk_hw_get_dev(hw));
3505	KUNIT_EXPECT_PTR_EQ(test, np, clk_hw_get_of_node(hw));
3506	}
3507
3508	/*
3509	* Test that a clk registered without an of_node returns the node from
3510	* clk_hw_get_of_node() and clk_hw_get_dev()
3511	*/
3512	static void of_clk_hw_register_NULL_get_of_node_returns_NULL(struct kunit *test)
3513	{
3514	struct clk_hw *hw;
3515
3516	hw = kunit_kzalloc(test, size: sizeof(*hw), GFP_KERNEL);
3517	KUNIT_ASSERT_NOT_ERR_OR_NULL(test, hw);
3518
3519	hw->init = &clk_hw_get_dev_of_node_init_data;
3520	KUNIT_ASSERT_EQ(test, 0, of_clk_hw_register_kunit(test, NULL, hw));
3521
3522	KUNIT_EXPECT_PTR_EQ(test, NULL, clk_hw_get_dev(hw));
3523	KUNIT_EXPECT_PTR_EQ(test, NULL, clk_hw_get_of_node(hw));
3524	}
3525
3526	static struct kunit_case clk_hw_get_dev_of_node_test_cases[] = {
3527	KUNIT_CASE(clk_hw_register_dev_get_dev_returns_dev),
3528	KUNIT_CASE(clk_hw_register_dev_no_node_get_dev_returns_dev),
3529	KUNIT_CASE(clk_hw_register_NULL_get_dev_of_node_returns_NULL),
3530	KUNIT_CASE(of_clk_hw_register_node_get_of_node_returns_node),
3531	KUNIT_CASE(of_clk_hw_register_NULL_get_of_node_returns_NULL),
3532	{}
3533	};
3534
3535	/*
3536	* Test suite to verify clk_hw_get_dev() and clk_hw_get_of_node() when clk
3537	* registered with clk_hw_register() and of_clk_hw_register()
3538	*/
3539	static struct kunit_suite clk_hw_get_dev_of_node_test_suite = {
3540	.name = "clk_hw_get_dev_of_node_test_suite",
3541	.test_cases = clk_hw_get_dev_of_node_test_cases,
3542	};
3543
3544
3545	kunit_test_suites(
3546	&clk_assigned_rates_suite,
3547	&clk_hw_get_dev_of_node_test_suite,
3548	&clk_leaf_mux_set_rate_parent_test_suite,
3549	&clk_test_suite,
3550	&clk_multiple_parents_mux_test_suite,
3551	&clk_mux_no_reparent_test_suite,
3552	&clk_mux_notifier_test_suite,
3553	&clk_orphan_transparent_multiple_parent_mux_test_suite,
3554	&clk_orphan_transparent_single_parent_test_suite,
3555	&clk_orphan_two_level_root_last_test_suite,
3556	&clk_range_test_suite,
3557	&clk_range_maximize_test_suite,
3558	&clk_range_minimize_test_suite,
3559	&clk_register_clk_parent_data_of_suite,
3560	&clk_register_clk_parent_data_device_suite,
3561	&clk_single_parent_mux_test_suite,
3562	&clk_uncached_test_suite,
3563	);
3564	MODULE_DESCRIPTION("Kunit tests for clk framework");
3565	MODULE_LICENSE("GPL v2");
3566