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