Loading...
Note: File does not exist in v3.1.
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Kunit test for clk rate management
4 */
5#include <linux/clk.h>
6#include <linux/clk-provider.h>
7
8/* Needed for clk_hw_get_clk() */
9#include "clk.h"
10
11#include <kunit/test.h>
12
13#define DUMMY_CLOCK_INIT_RATE (42 * 1000 * 1000)
14#define DUMMY_CLOCK_RATE_1 (142 * 1000 * 1000)
15#define DUMMY_CLOCK_RATE_2 (242 * 1000 * 1000)
16
17struct clk_dummy_context {
18 struct clk_hw hw;
19 unsigned long rate;
20};
21
22static unsigned long clk_dummy_recalc_rate(struct clk_hw *hw,
23 unsigned long parent_rate)
24{
25 struct clk_dummy_context *ctx =
26 container_of(hw, struct clk_dummy_context, hw);
27
28 return ctx->rate;
29}
30
31static int clk_dummy_determine_rate(struct clk_hw *hw,
32 struct clk_rate_request *req)
33{
34 /* Just return the same rate without modifying it */
35 return 0;
36}
37
38static int clk_dummy_maximize_rate(struct clk_hw *hw,
39 struct clk_rate_request *req)
40{
41 /*
42 * If there's a maximum set, always run the clock at the maximum
43 * allowed.
44 */
45 if (req->max_rate < ULONG_MAX)
46 req->rate = req->max_rate;
47
48 return 0;
49}
50
51static int clk_dummy_minimize_rate(struct clk_hw *hw,
52 struct clk_rate_request *req)
53{
54 /*
55 * If there's a minimum set, always run the clock at the minimum
56 * allowed.
57 */
58 if (req->min_rate > 0)
59 req->rate = req->min_rate;
60
61 return 0;
62}
63
64static int clk_dummy_set_rate(struct clk_hw *hw,
65 unsigned long rate,
66 unsigned long parent_rate)
67{
68 struct clk_dummy_context *ctx =
69 container_of(hw, struct clk_dummy_context, hw);
70
71 ctx->rate = rate;
72 return 0;
73}
74
75static int clk_dummy_single_set_parent(struct clk_hw *hw, u8 index)
76{
77 if (index >= clk_hw_get_num_parents(hw))
78 return -EINVAL;
79
80 return 0;
81}
82
83static u8 clk_dummy_single_get_parent(struct clk_hw *hw)
84{
85 return 0;
86}
87
88static const struct clk_ops clk_dummy_rate_ops = {
89 .recalc_rate = clk_dummy_recalc_rate,
90 .determine_rate = clk_dummy_determine_rate,
91 .set_rate = clk_dummy_set_rate,
92};
93
94static const struct clk_ops clk_dummy_maximize_rate_ops = {
95 .recalc_rate = clk_dummy_recalc_rate,
96 .determine_rate = clk_dummy_maximize_rate,
97 .set_rate = clk_dummy_set_rate,
98};
99
100static const struct clk_ops clk_dummy_minimize_rate_ops = {
101 .recalc_rate = clk_dummy_recalc_rate,
102 .determine_rate = clk_dummy_minimize_rate,
103 .set_rate = clk_dummy_set_rate,
104};
105
106static const struct clk_ops clk_dummy_single_parent_ops = {
107 .set_parent = clk_dummy_single_set_parent,
108 .get_parent = clk_dummy_single_get_parent,
109};
110
111struct clk_multiple_parent_ctx {
112 struct clk_dummy_context parents_ctx[2];
113 struct clk_hw hw;
114 u8 current_parent;
115};
116
117static int clk_multiple_parents_mux_set_parent(struct clk_hw *hw, u8 index)
118{
119 struct clk_multiple_parent_ctx *ctx =
120 container_of(hw, struct clk_multiple_parent_ctx, hw);
121
122 if (index >= clk_hw_get_num_parents(hw))
123 return -EINVAL;
124
125 ctx->current_parent = index;
126
127 return 0;
128}
129
130static u8 clk_multiple_parents_mux_get_parent(struct clk_hw *hw)
131{
132 struct clk_multiple_parent_ctx *ctx =
133 container_of(hw, struct clk_multiple_parent_ctx, hw);
134
135 return ctx->current_parent;
136}
137
138static const struct clk_ops clk_multiple_parents_mux_ops = {
139 .get_parent = clk_multiple_parents_mux_get_parent,
140 .set_parent = clk_multiple_parents_mux_set_parent,
141 .determine_rate = __clk_mux_determine_rate_closest,
142};
143
144static int clk_test_init_with_ops(struct kunit *test, const struct clk_ops *ops)
145{
146 struct clk_dummy_context *ctx;
147 struct clk_init_data init = { };
148 int ret;
149
150 ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
151 if (!ctx)
152 return -ENOMEM;
153 ctx->rate = DUMMY_CLOCK_INIT_RATE;
154 test->priv = ctx;
155
156 init.name = "test_dummy_rate";
157 init.ops = ops;
158 ctx->hw.init = &init;
159
160 ret = clk_hw_register(NULL, &ctx->hw);
161 if (ret)
162 return ret;
163
164 return 0;
165}
166
167static int clk_test_init(struct kunit *test)
168{
169 return clk_test_init_with_ops(test, &clk_dummy_rate_ops);
170}
171
172static int clk_maximize_test_init(struct kunit *test)
173{
174 return clk_test_init_with_ops(test, &clk_dummy_maximize_rate_ops);
175}
176
177static int clk_minimize_test_init(struct kunit *test)
178{
179 return clk_test_init_with_ops(test, &clk_dummy_minimize_rate_ops);
180}
181
182static void clk_test_exit(struct kunit *test)
183{
184 struct clk_dummy_context *ctx = test->priv;
185
186 clk_hw_unregister(&ctx->hw);
187}
188
189/*
190 * Test that the actual rate matches what is returned by clk_get_rate()
191 */
192static void clk_test_get_rate(struct kunit *test)
193{
194 struct clk_dummy_context *ctx = test->priv;
195 struct clk_hw *hw = &ctx->hw;
196 struct clk *clk = clk_hw_get_clk(hw, NULL);
197 unsigned long rate;
198
199 rate = clk_get_rate(clk);
200 KUNIT_ASSERT_GT(test, rate, 0);
201 KUNIT_EXPECT_EQ(test, rate, ctx->rate);
202
203 clk_put(clk);
204}
205
206/*
207 * Test that, after a call to clk_set_rate(), the rate returned by
208 * clk_get_rate() matches.
209 *
210 * This assumes that clk_ops.determine_rate or clk_ops.round_rate won't
211 * modify the requested rate, which is our case in clk_dummy_rate_ops.
212 */
213static void clk_test_set_get_rate(struct kunit *test)
214{
215 struct clk_dummy_context *ctx = test->priv;
216 struct clk_hw *hw = &ctx->hw;
217 struct clk *clk = clk_hw_get_clk(hw, NULL);
218 unsigned long rate;
219
220 KUNIT_ASSERT_EQ(test,
221 clk_set_rate(clk, DUMMY_CLOCK_RATE_1),
222 0);
223
224 rate = clk_get_rate(clk);
225 KUNIT_ASSERT_GT(test, rate, 0);
226 KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_1);
227
228 clk_put(clk);
229}
230
231/*
232 * Test that, after several calls to clk_set_rate(), the rate returned
233 * by clk_get_rate() matches the last one.
234 *
235 * This assumes that clk_ops.determine_rate or clk_ops.round_rate won't
236 * modify the requested rate, which is our case in clk_dummy_rate_ops.
237 */
238static void clk_test_set_set_get_rate(struct kunit *test)
239{
240 struct clk_dummy_context *ctx = test->priv;
241 struct clk_hw *hw = &ctx->hw;
242 struct clk *clk = clk_hw_get_clk(hw, NULL);
243 unsigned long rate;
244
245 KUNIT_ASSERT_EQ(test,
246 clk_set_rate(clk, DUMMY_CLOCK_RATE_1),
247 0);
248
249 KUNIT_ASSERT_EQ(test,
250 clk_set_rate(clk, DUMMY_CLOCK_RATE_2),
251 0);
252
253 rate = clk_get_rate(clk);
254 KUNIT_ASSERT_GT(test, rate, 0);
255 KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_2);
256
257 clk_put(clk);
258}
259
260/*
261 * Test that clk_round_rate and clk_set_rate are consitent and will
262 * return the same frequency.
263 */
264static void clk_test_round_set_get_rate(struct kunit *test)
265{
266 struct clk_dummy_context *ctx = test->priv;
267 struct clk_hw *hw = &ctx->hw;
268 struct clk *clk = clk_hw_get_clk(hw, NULL);
269 unsigned long rounded_rate, set_rate;
270
271 rounded_rate = clk_round_rate(clk, DUMMY_CLOCK_RATE_1);
272 KUNIT_ASSERT_GT(test, rounded_rate, 0);
273 KUNIT_EXPECT_EQ(test, rounded_rate, DUMMY_CLOCK_RATE_1);
274
275 KUNIT_ASSERT_EQ(test,
276 clk_set_rate(clk, DUMMY_CLOCK_RATE_1),
277 0);
278
279 set_rate = clk_get_rate(clk);
280 KUNIT_ASSERT_GT(test, set_rate, 0);
281 KUNIT_EXPECT_EQ(test, rounded_rate, set_rate);
282
283 clk_put(clk);
284}
285
286static struct kunit_case clk_test_cases[] = {
287 KUNIT_CASE(clk_test_get_rate),
288 KUNIT_CASE(clk_test_set_get_rate),
289 KUNIT_CASE(clk_test_set_set_get_rate),
290 KUNIT_CASE(clk_test_round_set_get_rate),
291 {}
292};
293
294/*
295 * Test suite for a basic rate clock, without any parent.
296 *
297 * These tests exercise the rate API with simple scenarios
298 */
299static struct kunit_suite clk_test_suite = {
300 .name = "clk-test",
301 .init = clk_test_init,
302 .exit = clk_test_exit,
303 .test_cases = clk_test_cases,
304};
305
306static int clk_uncached_test_init(struct kunit *test)
307{
308 struct clk_dummy_context *ctx;
309 int ret;
310
311 ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
312 if (!ctx)
313 return -ENOMEM;
314 test->priv = ctx;
315
316 ctx->rate = DUMMY_CLOCK_INIT_RATE;
317 ctx->hw.init = CLK_HW_INIT_NO_PARENT("test-clk",
318 &clk_dummy_rate_ops,
319 CLK_GET_RATE_NOCACHE);
320
321 ret = clk_hw_register(NULL, &ctx->hw);
322 if (ret)
323 return ret;
324
325 return 0;
326}
327
328/*
329 * Test that for an uncached clock, the clock framework doesn't cache
330 * the rate and clk_get_rate() will return the underlying clock rate
331 * even if it changed.
332 */
333static void clk_test_uncached_get_rate(struct kunit *test)
334{
335 struct clk_dummy_context *ctx = test->priv;
336 struct clk_hw *hw = &ctx->hw;
337 struct clk *clk = clk_hw_get_clk(hw, NULL);
338 unsigned long rate;
339
340 rate = clk_get_rate(clk);
341 KUNIT_ASSERT_GT(test, rate, 0);
342 KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_INIT_RATE);
343
344 /* We change the rate behind the clock framework's back */
345 ctx->rate = DUMMY_CLOCK_RATE_1;
346 rate = clk_get_rate(clk);
347 KUNIT_ASSERT_GT(test, rate, 0);
348 KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_1);
349
350 clk_put(clk);
351}
352
353/*
354 * Test that for an uncached clock, clk_set_rate_range() will work
355 * properly if the rate hasn't changed.
356 */
357static void clk_test_uncached_set_range(struct kunit *test)
358{
359 struct clk_dummy_context *ctx = test->priv;
360 struct clk_hw *hw = &ctx->hw;
361 struct clk *clk = clk_hw_get_clk(hw, NULL);
362 unsigned long rate;
363
364 KUNIT_ASSERT_EQ(test,
365 clk_set_rate_range(clk,
366 DUMMY_CLOCK_RATE_1,
367 DUMMY_CLOCK_RATE_2),
368 0);
369
370 rate = clk_get_rate(clk);
371 KUNIT_ASSERT_GT(test, rate, 0);
372 KUNIT_EXPECT_GE(test, rate, DUMMY_CLOCK_RATE_1);
373 KUNIT_EXPECT_LE(test, rate, DUMMY_CLOCK_RATE_2);
374
375 clk_put(clk);
376}
377
378/*
379 * Test that for an uncached clock, clk_set_rate_range() will work
380 * properly if the rate has changed in hardware.
381 *
382 * In this case, it means that if the rate wasn't initially in the range
383 * we're trying to set, but got changed at some point into the range
384 * without the kernel knowing about it, its rate shouldn't be affected.
385 */
386static void clk_test_uncached_updated_rate_set_range(struct kunit *test)
387{
388 struct clk_dummy_context *ctx = test->priv;
389 struct clk_hw *hw = &ctx->hw;
390 struct clk *clk = clk_hw_get_clk(hw, NULL);
391 unsigned long rate;
392
393 /* We change the rate behind the clock framework's back */
394 ctx->rate = DUMMY_CLOCK_RATE_1 + 1000;
395 KUNIT_ASSERT_EQ(test,
396 clk_set_rate_range(clk,
397 DUMMY_CLOCK_RATE_1,
398 DUMMY_CLOCK_RATE_2),
399 0);
400
401 rate = clk_get_rate(clk);
402 KUNIT_ASSERT_GT(test, rate, 0);
403 KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_1 + 1000);
404
405 clk_put(clk);
406}
407
408static struct kunit_case clk_uncached_test_cases[] = {
409 KUNIT_CASE(clk_test_uncached_get_rate),
410 KUNIT_CASE(clk_test_uncached_set_range),
411 KUNIT_CASE(clk_test_uncached_updated_rate_set_range),
412 {}
413};
414
415/*
416 * Test suite for a basic, uncached, rate clock, without any parent.
417 *
418 * These tests exercise the rate API with simple scenarios
419 */
420static struct kunit_suite clk_uncached_test_suite = {
421 .name = "clk-uncached-test",
422 .init = clk_uncached_test_init,
423 .exit = clk_test_exit,
424 .test_cases = clk_uncached_test_cases,
425};
426
427static int
428clk_multiple_parents_mux_test_init(struct kunit *test)
429{
430 struct clk_multiple_parent_ctx *ctx;
431 const char *parents[2] = { "parent-0", "parent-1"};
432 int ret;
433
434 ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
435 if (!ctx)
436 return -ENOMEM;
437 test->priv = ctx;
438
439 ctx->parents_ctx[0].hw.init = CLK_HW_INIT_NO_PARENT("parent-0",
440 &clk_dummy_rate_ops,
441 0);
442 ctx->parents_ctx[0].rate = DUMMY_CLOCK_RATE_1;
443 ret = clk_hw_register(NULL, &ctx->parents_ctx[0].hw);
444 if (ret)
445 return ret;
446
447 ctx->parents_ctx[1].hw.init = CLK_HW_INIT_NO_PARENT("parent-1",
448 &clk_dummy_rate_ops,
449 0);
450 ctx->parents_ctx[1].rate = DUMMY_CLOCK_RATE_2;
451 ret = clk_hw_register(NULL, &ctx->parents_ctx[1].hw);
452 if (ret)
453 return ret;
454
455 ctx->current_parent = 0;
456 ctx->hw.init = CLK_HW_INIT_PARENTS("test-mux", parents,
457 &clk_multiple_parents_mux_ops,
458 CLK_SET_RATE_PARENT);
459 ret = clk_hw_register(NULL, &ctx->hw);
460 if (ret)
461 return ret;
462
463 return 0;
464}
465
466static void
467clk_multiple_parents_mux_test_exit(struct kunit *test)
468{
469 struct clk_multiple_parent_ctx *ctx = test->priv;
470
471 clk_hw_unregister(&ctx->hw);
472 clk_hw_unregister(&ctx->parents_ctx[0].hw);
473 clk_hw_unregister(&ctx->parents_ctx[1].hw);
474}
475
476/*
477 * Test that for a clock with multiple parents, clk_get_parent()
478 * actually returns the current one.
479 */
480static void
481clk_test_multiple_parents_mux_get_parent(struct kunit *test)
482{
483 struct clk_multiple_parent_ctx *ctx = test->priv;
484 struct clk_hw *hw = &ctx->hw;
485 struct clk *clk = clk_hw_get_clk(hw, NULL);
486 struct clk *parent = clk_hw_get_clk(&ctx->parents_ctx[0].hw, NULL);
487
488 KUNIT_EXPECT_TRUE(test, clk_is_match(clk_get_parent(clk), parent));
489
490 clk_put(parent);
491 clk_put(clk);
492}
493
494/*
495 * Test that for a clock with a multiple parents, clk_has_parent()
496 * actually reports all of them as parents.
497 */
498static void
499clk_test_multiple_parents_mux_has_parent(struct kunit *test)
500{
501 struct clk_multiple_parent_ctx *ctx = test->priv;
502 struct clk_hw *hw = &ctx->hw;
503 struct clk *clk = clk_hw_get_clk(hw, NULL);
504 struct clk *parent;
505
506 parent = clk_hw_get_clk(&ctx->parents_ctx[0].hw, NULL);
507 KUNIT_EXPECT_TRUE(test, clk_has_parent(clk, parent));
508 clk_put(parent);
509
510 parent = clk_hw_get_clk(&ctx->parents_ctx[1].hw, NULL);
511 KUNIT_EXPECT_TRUE(test, clk_has_parent(clk, parent));
512 clk_put(parent);
513
514 clk_put(clk);
515}
516
517/*
518 * Test that for a clock with a multiple parents, if we set a range on
519 * that clock and the parent is changed, its rate after the reparenting
520 * is still within the range we asked for.
521 *
522 * FIXME: clk_set_parent() only does the reparenting but doesn't
523 * reevaluate whether the new clock rate is within its boundaries or
524 * not.
525 */
526static void
527clk_test_multiple_parents_mux_set_range_set_parent_get_rate(struct kunit *test)
528{
529 struct clk_multiple_parent_ctx *ctx = test->priv;
530 struct clk_hw *hw = &ctx->hw;
531 struct clk *clk = clk_hw_get_clk(hw, NULL);
532 struct clk *parent1, *parent2;
533 unsigned long rate;
534 int ret;
535
536 kunit_skip(test, "This needs to be fixed in the core.");
537
538 parent1 = clk_hw_get_clk(&ctx->parents_ctx[0].hw, NULL);
539 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent1);
540 KUNIT_ASSERT_TRUE(test, clk_is_match(clk_get_parent(clk), parent1));
541
542 parent2 = clk_hw_get_clk(&ctx->parents_ctx[1].hw, NULL);
543 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent2);
544
545 ret = clk_set_rate(parent1, DUMMY_CLOCK_RATE_1);
546 KUNIT_ASSERT_EQ(test, ret, 0);
547
548 ret = clk_set_rate(parent2, DUMMY_CLOCK_RATE_2);
549 KUNIT_ASSERT_EQ(test, ret, 0);
550
551 ret = clk_set_rate_range(clk,
552 DUMMY_CLOCK_RATE_1 - 1000,
553 DUMMY_CLOCK_RATE_1 + 1000);
554 KUNIT_ASSERT_EQ(test, ret, 0);
555
556 ret = clk_set_parent(clk, parent2);
557 KUNIT_ASSERT_EQ(test, ret, 0);
558
559 rate = clk_get_rate(clk);
560 KUNIT_ASSERT_GT(test, rate, 0);
561 KUNIT_EXPECT_GE(test, rate, DUMMY_CLOCK_RATE_1 - 1000);
562 KUNIT_EXPECT_LE(test, rate, DUMMY_CLOCK_RATE_1 + 1000);
563
564 clk_put(parent2);
565 clk_put(parent1);
566 clk_put(clk);
567}
568
569static struct kunit_case clk_multiple_parents_mux_test_cases[] = {
570 KUNIT_CASE(clk_test_multiple_parents_mux_get_parent),
571 KUNIT_CASE(clk_test_multiple_parents_mux_has_parent),
572 KUNIT_CASE(clk_test_multiple_parents_mux_set_range_set_parent_get_rate),
573 {}
574};
575
576/*
577 * Test suite for a basic mux clock with two parents, with
578 * CLK_SET_RATE_PARENT on the child.
579 *
580 * These tests exercise the consumer API and check that the state of the
581 * child and parents are sane and consistent.
582 */
583static struct kunit_suite
584clk_multiple_parents_mux_test_suite = {
585 .name = "clk-multiple-parents-mux-test",
586 .init = clk_multiple_parents_mux_test_init,
587 .exit = clk_multiple_parents_mux_test_exit,
588 .test_cases = clk_multiple_parents_mux_test_cases,
589};
590
591static int
592clk_orphan_transparent_multiple_parent_mux_test_init(struct kunit *test)
593{
594 struct clk_multiple_parent_ctx *ctx;
595 const char *parents[2] = { "missing-parent", "proper-parent"};
596 int ret;
597
598 ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
599 if (!ctx)
600 return -ENOMEM;
601 test->priv = ctx;
602
603 ctx->parents_ctx[1].hw.init = CLK_HW_INIT_NO_PARENT("proper-parent",
604 &clk_dummy_rate_ops,
605 0);
606 ctx->parents_ctx[1].rate = DUMMY_CLOCK_INIT_RATE;
607 ret = clk_hw_register(NULL, &ctx->parents_ctx[1].hw);
608 if (ret)
609 return ret;
610
611 ctx->hw.init = CLK_HW_INIT_PARENTS("test-orphan-mux", parents,
612 &clk_multiple_parents_mux_ops,
613 CLK_SET_RATE_PARENT);
614 ret = clk_hw_register(NULL, &ctx->hw);
615 if (ret)
616 return ret;
617
618 return 0;
619}
620
621static void
622clk_orphan_transparent_multiple_parent_mux_test_exit(struct kunit *test)
623{
624 struct clk_multiple_parent_ctx *ctx = test->priv;
625
626 clk_hw_unregister(&ctx->hw);
627 clk_hw_unregister(&ctx->parents_ctx[1].hw);
628}
629
630/*
631 * Test that, for a mux whose current parent hasn't been registered yet and is
632 * thus orphan, clk_get_parent() will return NULL.
633 */
634static void
635clk_test_orphan_transparent_multiple_parent_mux_get_parent(struct kunit *test)
636{
637 struct clk_multiple_parent_ctx *ctx = test->priv;
638 struct clk_hw *hw = &ctx->hw;
639 struct clk *clk = clk_hw_get_clk(hw, NULL);
640
641 KUNIT_EXPECT_PTR_EQ(test, clk_get_parent(clk), NULL);
642
643 clk_put(clk);
644}
645
646/*
647 * Test that, for a mux whose current parent hasn't been registered yet,
648 * calling clk_set_parent() to a valid parent will properly update the
649 * mux parent and its orphan status.
650 */
651static void
652clk_test_orphan_transparent_multiple_parent_mux_set_parent(struct kunit *test)
653{
654 struct clk_multiple_parent_ctx *ctx = test->priv;
655 struct clk_hw *hw = &ctx->hw;
656 struct clk *clk = clk_hw_get_clk(hw, NULL);
657 struct clk *parent, *new_parent;
658 int ret;
659
660 parent = clk_hw_get_clk(&ctx->parents_ctx[1].hw, NULL);
661 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent);
662
663 ret = clk_set_parent(clk, parent);
664 KUNIT_ASSERT_EQ(test, ret, 0);
665
666 new_parent = clk_get_parent(clk);
667 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent);
668 KUNIT_EXPECT_TRUE(test, clk_is_match(parent, new_parent));
669
670 clk_put(parent);
671 clk_put(clk);
672}
673
674/*
675 * Test that, for a mux that started orphan but got switched to a valid
676 * parent, calling clk_drop_range() on the mux won't affect the parent
677 * rate.
678 */
679static void
680clk_test_orphan_transparent_multiple_parent_mux_set_parent_drop_range(struct kunit *test)
681{
682 struct clk_multiple_parent_ctx *ctx = test->priv;
683 struct clk_hw *hw = &ctx->hw;
684 struct clk *clk = clk_hw_get_clk(hw, NULL);
685 struct clk *parent;
686 unsigned long parent_rate, new_parent_rate;
687 int ret;
688
689 parent = clk_hw_get_clk(&ctx->parents_ctx[1].hw, NULL);
690 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent);
691
692 parent_rate = clk_get_rate(parent);
693 KUNIT_ASSERT_GT(test, parent_rate, 0);
694
695 ret = clk_set_parent(clk, parent);
696 KUNIT_ASSERT_EQ(test, ret, 0);
697
698 ret = clk_drop_range(clk);
699 KUNIT_ASSERT_EQ(test, ret, 0);
700
701 new_parent_rate = clk_get_rate(clk);
702 KUNIT_ASSERT_GT(test, new_parent_rate, 0);
703 KUNIT_EXPECT_EQ(test, parent_rate, new_parent_rate);
704
705 clk_put(parent);
706 clk_put(clk);
707}
708
709/*
710 * Test that, for a mux that started orphan but got switched to a valid
711 * parent, the rate of the mux and its new parent are consistent.
712 */
713static void
714clk_test_orphan_transparent_multiple_parent_mux_set_parent_get_rate(struct kunit *test)
715{
716 struct clk_multiple_parent_ctx *ctx = test->priv;
717 struct clk_hw *hw = &ctx->hw;
718 struct clk *clk = clk_hw_get_clk(hw, NULL);
719 struct clk *parent;
720 unsigned long parent_rate, rate;
721 int ret;
722
723 parent = clk_hw_get_clk(&ctx->parents_ctx[1].hw, NULL);
724 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent);
725
726 parent_rate = clk_get_rate(parent);
727 KUNIT_ASSERT_GT(test, parent_rate, 0);
728
729 ret = clk_set_parent(clk, parent);
730 KUNIT_ASSERT_EQ(test, ret, 0);
731
732 rate = clk_get_rate(clk);
733 KUNIT_ASSERT_GT(test, rate, 0);
734 KUNIT_EXPECT_EQ(test, parent_rate, rate);
735
736 clk_put(parent);
737 clk_put(clk);
738}
739
740/*
741 * Test that, for a mux that started orphan but got switched to a valid
742 * parent, calling clk_put() on the mux won't affect the parent rate.
743 */
744static void
745clk_test_orphan_transparent_multiple_parent_mux_set_parent_put(struct kunit *test)
746{
747 struct clk_multiple_parent_ctx *ctx = test->priv;
748 struct clk *clk, *parent;
749 unsigned long parent_rate, new_parent_rate;
750 int ret;
751
752 parent = clk_hw_get_clk(&ctx->parents_ctx[1].hw, NULL);
753 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent);
754
755 clk = clk_hw_get_clk(&ctx->hw, NULL);
756 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, clk);
757
758 parent_rate = clk_get_rate(parent);
759 KUNIT_ASSERT_GT(test, parent_rate, 0);
760
761 ret = clk_set_parent(clk, parent);
762 KUNIT_ASSERT_EQ(test, ret, 0);
763
764 clk_put(clk);
765
766 new_parent_rate = clk_get_rate(parent);
767 KUNIT_ASSERT_GT(test, new_parent_rate, 0);
768 KUNIT_EXPECT_EQ(test, parent_rate, new_parent_rate);
769
770 clk_put(parent);
771}
772
773/*
774 * Test that, for a mux that started orphan but got switched to a valid
775 * parent, calling clk_set_rate_range() will affect the parent state if
776 * its rate is out of range.
777 */
778static void
779clk_test_orphan_transparent_multiple_parent_mux_set_parent_set_range_modified(struct kunit *test)
780{
781 struct clk_multiple_parent_ctx *ctx = test->priv;
782 struct clk_hw *hw = &ctx->hw;
783 struct clk *clk = clk_hw_get_clk(hw, NULL);
784 struct clk *parent;
785 unsigned long rate;
786 int ret;
787
788 parent = clk_hw_get_clk(&ctx->parents_ctx[1].hw, NULL);
789 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent);
790
791 ret = clk_set_parent(clk, parent);
792 KUNIT_ASSERT_EQ(test, ret, 0);
793
794 ret = clk_set_rate_range(clk, DUMMY_CLOCK_RATE_1, DUMMY_CLOCK_RATE_2);
795 KUNIT_ASSERT_EQ(test, ret, 0);
796
797 rate = clk_get_rate(clk);
798 KUNIT_ASSERT_GT(test, rate, 0);
799 KUNIT_EXPECT_GE(test, rate, DUMMY_CLOCK_RATE_1);
800 KUNIT_EXPECT_LE(test, rate, DUMMY_CLOCK_RATE_2);
801
802 clk_put(parent);
803 clk_put(clk);
804}
805
806/*
807 * Test that, for a mux that started orphan but got switched to a valid
808 * parent, calling clk_set_rate_range() won't affect the parent state if
809 * its rate is within range.
810 */
811static void
812clk_test_orphan_transparent_multiple_parent_mux_set_parent_set_range_untouched(struct kunit *test)
813{
814 struct clk_multiple_parent_ctx *ctx = test->priv;
815 struct clk_hw *hw = &ctx->hw;
816 struct clk *clk = clk_hw_get_clk(hw, NULL);
817 struct clk *parent;
818 unsigned long parent_rate, new_parent_rate;
819 int ret;
820
821 parent = clk_hw_get_clk(&ctx->parents_ctx[1].hw, NULL);
822 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent);
823
824 parent_rate = clk_get_rate(parent);
825 KUNIT_ASSERT_GT(test, parent_rate, 0);
826
827 ret = clk_set_parent(clk, parent);
828 KUNIT_ASSERT_EQ(test, ret, 0);
829
830 ret = clk_set_rate_range(clk,
831 DUMMY_CLOCK_INIT_RATE - 1000,
832 DUMMY_CLOCK_INIT_RATE + 1000);
833 KUNIT_ASSERT_EQ(test, ret, 0);
834
835 new_parent_rate = clk_get_rate(parent);
836 KUNIT_ASSERT_GT(test, new_parent_rate, 0);
837 KUNIT_EXPECT_EQ(test, parent_rate, new_parent_rate);
838
839 clk_put(parent);
840 clk_put(clk);
841}
842
843/*
844 * Test that, for a mux whose current parent hasn't been registered yet,
845 * calling clk_set_rate_range() will succeed, and will be taken into
846 * account when rounding a rate.
847 */
848static void
849clk_test_orphan_transparent_multiple_parent_mux_set_range_round_rate(struct kunit *test)
850{
851 struct clk_multiple_parent_ctx *ctx = test->priv;
852 struct clk_hw *hw = &ctx->hw;
853 struct clk *clk = clk_hw_get_clk(hw, NULL);
854 unsigned long rate;
855 int ret;
856
857 ret = clk_set_rate_range(clk, DUMMY_CLOCK_RATE_1, DUMMY_CLOCK_RATE_2);
858 KUNIT_ASSERT_EQ(test, ret, 0);
859
860 rate = clk_round_rate(clk, DUMMY_CLOCK_RATE_1 - 1000);
861 KUNIT_ASSERT_GT(test, rate, 0);
862 KUNIT_EXPECT_GE(test, rate, DUMMY_CLOCK_RATE_1);
863 KUNIT_EXPECT_LE(test, rate, DUMMY_CLOCK_RATE_2);
864
865 clk_put(clk);
866}
867
868/*
869 * Test that, for a mux that started orphan, was assigned and rate and
870 * then got switched to a valid parent, its rate is eventually within
871 * range.
872 *
873 * FIXME: Even though we update the rate as part of clk_set_parent(), we
874 * don't evaluate whether that new rate is within range and needs to be
875 * adjusted.
876 */
877static void
878clk_test_orphan_transparent_multiple_parent_mux_set_range_set_parent_get_rate(struct kunit *test)
879{
880 struct clk_multiple_parent_ctx *ctx = test->priv;
881 struct clk_hw *hw = &ctx->hw;
882 struct clk *clk = clk_hw_get_clk(hw, NULL);
883 struct clk *parent;
884 unsigned long rate;
885 int ret;
886
887 kunit_skip(test, "This needs to be fixed in the core.");
888
889 clk_hw_set_rate_range(hw, DUMMY_CLOCK_RATE_1, DUMMY_CLOCK_RATE_2);
890
891 parent = clk_hw_get_clk(&ctx->parents_ctx[1].hw, NULL);
892 KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent);
893
894 ret = clk_set_parent(clk, parent);
895 KUNIT_ASSERT_EQ(test, ret, 0);
896
897 rate = clk_get_rate(clk);
898 KUNIT_ASSERT_GT(test, rate, 0);
899 KUNIT_EXPECT_GE(test, rate, DUMMY_CLOCK_RATE_1);
900 KUNIT_EXPECT_LE(test, rate, DUMMY_CLOCK_RATE_2);
901
902 clk_put(parent);
903 clk_put(clk);
904}
905
906static struct kunit_case clk_orphan_transparent_multiple_parent_mux_test_cases[] = {
907 KUNIT_CASE(clk_test_orphan_transparent_multiple_parent_mux_get_parent),
908 KUNIT_CASE(clk_test_orphan_transparent_multiple_parent_mux_set_parent),
909 KUNIT_CASE(clk_test_orphan_transparent_multiple_parent_mux_set_parent_drop_range),
910 KUNIT_CASE(clk_test_orphan_transparent_multiple_parent_mux_set_parent_get_rate),
911 KUNIT_CASE(clk_test_orphan_transparent_multiple_parent_mux_set_parent_put),
912 KUNIT_CASE(clk_test_orphan_transparent_multiple_parent_mux_set_parent_set_range_modified),
913 KUNIT_CASE(clk_test_orphan_transparent_multiple_parent_mux_set_parent_set_range_untouched),
914 KUNIT_CASE(clk_test_orphan_transparent_multiple_parent_mux_set_range_round_rate),
915 KUNIT_CASE(clk_test_orphan_transparent_multiple_parent_mux_set_range_set_parent_get_rate),
916 {}
917};
918
919/*
920 * Test suite for a basic mux clock with two parents. The default parent
921 * isn't registered, only the second parent is. By default, the clock
922 * will thus be orphan.
923 *
924 * These tests exercise the behaviour of the consumer API when dealing
925 * with an orphan clock, and how we deal with the transition to a valid
926 * parent.
927 */
928static struct kunit_suite clk_orphan_transparent_multiple_parent_mux_test_suite = {
929 .name = "clk-orphan-transparent-multiple-parent-mux-test",
930 .init = clk_orphan_transparent_multiple_parent_mux_test_init,
931 .exit = clk_orphan_transparent_multiple_parent_mux_test_exit,
932 .test_cases = clk_orphan_transparent_multiple_parent_mux_test_cases,
933};
934
935struct clk_single_parent_ctx {
936 struct clk_dummy_context parent_ctx;
937 struct clk_hw hw;
938};
939
940static int clk_single_parent_mux_test_init(struct kunit *test)
941{
942 struct clk_single_parent_ctx *ctx;
943 int ret;
944
945 ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
946 if (!ctx)
947 return -ENOMEM;
948 test->priv = ctx;
949
950 ctx->parent_ctx.rate = DUMMY_CLOCK_INIT_RATE;
951 ctx->parent_ctx.hw.init =
952 CLK_HW_INIT_NO_PARENT("parent-clk",
953 &clk_dummy_rate_ops,
954 0);
955
956 ret = clk_hw_register(NULL, &ctx->parent_ctx.hw);
957 if (ret)
958 return ret;
959
960 ctx->hw.init = CLK_HW_INIT("test-clk", "parent-clk",
961 &clk_dummy_single_parent_ops,
962 CLK_SET_RATE_PARENT);
963
964 ret = clk_hw_register(NULL, &ctx->hw);
965 if (ret)
966 return ret;
967
968 return 0;
969}
970
971static void
972clk_single_parent_mux_test_exit(struct kunit *test)
973{
974 struct clk_single_parent_ctx *ctx = test->priv;
975
976 clk_hw_unregister(&ctx->hw);
977 clk_hw_unregister(&ctx->parent_ctx.hw);
978}
979
980/*
981 * Test that for a clock with a single parent, clk_get_parent() actually
982 * returns the parent.
983 */
984static void
985clk_test_single_parent_mux_get_parent(struct kunit *test)
986{
987 struct clk_single_parent_ctx *ctx = test->priv;
988 struct clk_hw *hw = &ctx->hw;
989 struct clk *clk = clk_hw_get_clk(hw, NULL);
990 struct clk *parent = clk_hw_get_clk(&ctx->parent_ctx.hw, NULL);
991
992 KUNIT_EXPECT_TRUE(test, clk_is_match(clk_get_parent(clk), parent));
993
994 clk_put(parent);
995 clk_put(clk);
996}
997
998/*
999 * Test that for a clock with a single parent, clk_has_parent() actually
1000 * reports it as a parent.
1001 */
1002static void
1003clk_test_single_parent_mux_has_parent(struct kunit *test)
1004{
1005 struct clk_single_parent_ctx *ctx = test->priv;
1006 struct clk_hw *hw = &ctx->hw;
1007 struct clk *clk = clk_hw_get_clk(hw, NULL);
1008 struct clk *parent = clk_hw_get_clk(&ctx->parent_ctx.hw, NULL);
1009
1010 KUNIT_EXPECT_TRUE(test, clk_has_parent(clk, parent));
1011
1012 clk_put(parent);
1013 clk_put(clk);
1014}
1015
1016/*
1017 * Test that for a clock that can't modify its rate and with a single
1018 * parent, if we set disjoints range on the parent and then the child,
1019 * the second will return an error.
1020 *
1021 * FIXME: clk_set_rate_range() only considers the current clock when
1022 * evaluating whether ranges are disjoints and not the upstream clocks
1023 * ranges.
1024 */
1025static void
1026clk_test_single_parent_mux_set_range_disjoint_child_last(struct kunit *test)
1027{
1028 struct clk_single_parent_ctx *ctx = test->priv;
1029 struct clk_hw *hw = &ctx->hw;
1030 struct clk *clk = clk_hw_get_clk(hw, NULL);
1031 struct clk *parent;
1032 int ret;
1033
1034 kunit_skip(test, "This needs to be fixed in the core.");
1035
1036 parent = clk_get_parent(clk);
1037 KUNIT_ASSERT_PTR_NE(test, parent, NULL);
1038
1039 ret = clk_set_rate_range(parent, 1000, 2000);
1040 KUNIT_ASSERT_EQ(test, ret, 0);
1041
1042 ret = clk_set_rate_range(clk, 3000, 4000);
1043 KUNIT_EXPECT_LT(test, ret, 0);
1044
1045 clk_put(clk);
1046}
1047
1048/*
1049 * Test that for a clock that can't modify its rate and with a single
1050 * parent, if we set disjoints range on the child and then the parent,
1051 * the second will return an error.
1052 *
1053 * FIXME: clk_set_rate_range() only considers the current clock when
1054 * evaluating whether ranges are disjoints and not the downstream clocks
1055 * ranges.
1056 */
1057static void
1058clk_test_single_parent_mux_set_range_disjoint_parent_last(struct kunit *test)
1059{
1060 struct clk_single_parent_ctx *ctx = test->priv;
1061 struct clk_hw *hw = &ctx->hw;
1062 struct clk *clk = clk_hw_get_clk(hw, NULL);
1063 struct clk *parent;
1064 int ret;
1065
1066 kunit_skip(test, "This needs to be fixed in the core.");
1067
1068 parent = clk_get_parent(clk);
1069 KUNIT_ASSERT_PTR_NE(test, parent, NULL);
1070
1071 ret = clk_set_rate_range(clk, 1000, 2000);
1072 KUNIT_ASSERT_EQ(test, ret, 0);
1073
1074 ret = clk_set_rate_range(parent, 3000, 4000);
1075 KUNIT_EXPECT_LT(test, ret, 0);
1076
1077 clk_put(clk);
1078}
1079
1080/*
1081 * Test that for a clock that can't modify its rate and with a single
1082 * parent, if we set a range on the parent and then call
1083 * clk_round_rate(), the boundaries of the parent are taken into
1084 * account.
1085 */
1086static void
1087clk_test_single_parent_mux_set_range_round_rate_parent_only(struct kunit *test)
1088{
1089 struct clk_single_parent_ctx *ctx = test->priv;
1090 struct clk_hw *hw = &ctx->hw;
1091 struct clk *clk = clk_hw_get_clk(hw, NULL);
1092 struct clk *parent;
1093 unsigned long rate;
1094 int ret;
1095
1096 parent = clk_get_parent(clk);
1097 KUNIT_ASSERT_PTR_NE(test, parent, NULL);
1098
1099 ret = clk_set_rate_range(parent, DUMMY_CLOCK_RATE_1, DUMMY_CLOCK_RATE_2);
1100 KUNIT_ASSERT_EQ(test, ret, 0);
1101
1102 rate = clk_round_rate(clk, DUMMY_CLOCK_RATE_1 - 1000);
1103 KUNIT_ASSERT_GT(test, rate, 0);
1104 KUNIT_EXPECT_GE(test, rate, DUMMY_CLOCK_RATE_1);
1105 KUNIT_EXPECT_LE(test, rate, DUMMY_CLOCK_RATE_2);
1106
1107 clk_put(clk);
1108}
1109
1110/*
1111 * Test that for a clock that can't modify its rate and with a single
1112 * parent, if we set a range on the parent and a more restrictive one on
1113 * the child, and then call clk_round_rate(), the boundaries of the
1114 * two clocks are taken into account.
1115 */
1116static void
1117clk_test_single_parent_mux_set_range_round_rate_child_smaller(struct kunit *test)
1118{
1119 struct clk_single_parent_ctx *ctx = test->priv;
1120 struct clk_hw *hw = &ctx->hw;
1121 struct clk *clk = clk_hw_get_clk(hw, NULL);
1122 struct clk *parent;
1123 unsigned long rate;
1124 int ret;
1125
1126 parent = clk_get_parent(clk);
1127 KUNIT_ASSERT_PTR_NE(test, parent, NULL);
1128
1129 ret = clk_set_rate_range(parent, DUMMY_CLOCK_RATE_1, DUMMY_CLOCK_RATE_2);
1130 KUNIT_ASSERT_EQ(test, ret, 0);
1131
1132 ret = clk_set_rate_range(clk, DUMMY_CLOCK_RATE_1 + 1000, DUMMY_CLOCK_RATE_2 - 1000);
1133 KUNIT_ASSERT_EQ(test, ret, 0);
1134
1135 rate = clk_round_rate(clk, DUMMY_CLOCK_RATE_1 - 1000);
1136 KUNIT_ASSERT_GT(test, rate, 0);
1137 KUNIT_EXPECT_GE(test, rate, DUMMY_CLOCK_RATE_1 + 1000);
1138 KUNIT_EXPECT_LE(test, rate, DUMMY_CLOCK_RATE_2 - 1000);
1139
1140 rate = clk_round_rate(clk, DUMMY_CLOCK_RATE_2 + 1000);
1141 KUNIT_ASSERT_GT(test, rate, 0);
1142 KUNIT_EXPECT_GE(test, rate, DUMMY_CLOCK_RATE_1 + 1000);
1143 KUNIT_EXPECT_LE(test, rate, DUMMY_CLOCK_RATE_2 - 1000);
1144
1145 clk_put(clk);
1146}
1147
1148/*
1149 * Test that for a clock that can't modify its rate and with a single
1150 * parent, if we set a range on the child and a more restrictive one on
1151 * the parent, and then call clk_round_rate(), the boundaries of the
1152 * two clocks are taken into account.
1153 */
1154static void
1155clk_test_single_parent_mux_set_range_round_rate_parent_smaller(struct kunit *test)
1156{
1157 struct clk_single_parent_ctx *ctx = test->priv;
1158 struct clk_hw *hw = &ctx->hw;
1159 struct clk *clk = clk_hw_get_clk(hw, NULL);
1160 struct clk *parent;
1161 unsigned long rate;
1162 int ret;
1163
1164 parent = clk_get_parent(clk);
1165 KUNIT_ASSERT_PTR_NE(test, parent, NULL);
1166
1167 ret = clk_set_rate_range(parent, DUMMY_CLOCK_RATE_1 + 1000, DUMMY_CLOCK_RATE_2 - 1000);
1168 KUNIT_ASSERT_EQ(test, ret, 0);
1169
1170 ret = clk_set_rate_range(clk, DUMMY_CLOCK_RATE_1, DUMMY_CLOCK_RATE_2);
1171 KUNIT_ASSERT_EQ(test, ret, 0);
1172
1173 rate = clk_round_rate(clk, DUMMY_CLOCK_RATE_1 - 1000);
1174 KUNIT_ASSERT_GT(test, rate, 0);
1175 KUNIT_EXPECT_GE(test, rate, DUMMY_CLOCK_RATE_1 + 1000);
1176 KUNIT_EXPECT_LE(test, rate, DUMMY_CLOCK_RATE_2 - 1000);
1177
1178 rate = clk_round_rate(clk, DUMMY_CLOCK_RATE_2 + 1000);
1179 KUNIT_ASSERT_GT(test, rate, 0);
1180 KUNIT_EXPECT_GE(test, rate, DUMMY_CLOCK_RATE_1 + 1000);
1181 KUNIT_EXPECT_LE(test, rate, DUMMY_CLOCK_RATE_2 - 1000);
1182
1183 clk_put(clk);
1184}
1185
1186static struct kunit_case clk_single_parent_mux_test_cases[] = {
1187 KUNIT_CASE(clk_test_single_parent_mux_get_parent),
1188 KUNIT_CASE(clk_test_single_parent_mux_has_parent),
1189 KUNIT_CASE(clk_test_single_parent_mux_set_range_disjoint_child_last),
1190 KUNIT_CASE(clk_test_single_parent_mux_set_range_disjoint_parent_last),
1191 KUNIT_CASE(clk_test_single_parent_mux_set_range_round_rate_child_smaller),
1192 KUNIT_CASE(clk_test_single_parent_mux_set_range_round_rate_parent_only),
1193 KUNIT_CASE(clk_test_single_parent_mux_set_range_round_rate_parent_smaller),
1194 {}
1195};
1196
1197/*
1198 * Test suite for a basic mux clock with one parent, with
1199 * CLK_SET_RATE_PARENT on the child.
1200 *
1201 * These tests exercise the consumer API and check that the state of the
1202 * child and parent are sane and consistent.
1203 */
1204static struct kunit_suite
1205clk_single_parent_mux_test_suite = {
1206 .name = "clk-single-parent-mux-test",
1207 .init = clk_single_parent_mux_test_init,
1208 .exit = clk_single_parent_mux_test_exit,
1209 .test_cases = clk_single_parent_mux_test_cases,
1210};
1211
1212static 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 */
1255static 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
1278static 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 */
1291static 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
1298struct 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
1304static int
1305clk_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
1344static void
1345clk_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 */
1358static void
1359clk_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 */
1380static void
1381clk_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
1401static struct kunit_case
1402clk_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 */
1420static struct kunit_suite
1421clk_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 */
1433static 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 */
1458static 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 */
1477static 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 */
1505static 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 */
1530static 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 */
1561static 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 */
1590static 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 */
1615static 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 */
1646static 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 */
1679static 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 */
1711static 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
1735static 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 */
1756static 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 */
1771static 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 */
1823static 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 */
1882static 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
1930static 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 */
1944static 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 */
1959static 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 */
2011static 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 */
2066static 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
2110static 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 */
2124static 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
2131struct clk_leaf_mux_ctx {
2132 struct clk_multiple_parent_ctx mux_ctx;
2133 struct clk_hw hw;
2134};
2135
2136static int
2137clk_leaf_mux_set_rate_parent_test_init(struct kunit *test)
2138{
2139 struct clk_leaf_mux_ctx *ctx;
2140 const char *top_parents[2] = { "parent-0", "parent-1" };
2141 int ret;
2142
2143 ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
2144 if (!ctx)
2145 return -ENOMEM;
2146 test->priv = ctx;
2147
2148 ctx->mux_ctx.parents_ctx[0].hw.init = CLK_HW_INIT_NO_PARENT("parent-0",
2149 &clk_dummy_rate_ops,
2150 0);
2151 ctx->mux_ctx.parents_ctx[0].rate = DUMMY_CLOCK_RATE_1;
2152 ret = clk_hw_register(NULL, &ctx->mux_ctx.parents_ctx[0].hw);
2153 if (ret)
2154 return ret;
2155
2156 ctx->mux_ctx.parents_ctx[1].hw.init = CLK_HW_INIT_NO_PARENT("parent-1",
2157 &clk_dummy_rate_ops,
2158 0);
2159 ctx->mux_ctx.parents_ctx[1].rate = DUMMY_CLOCK_RATE_2;
2160 ret = clk_hw_register(NULL, &ctx->mux_ctx.parents_ctx[1].hw);
2161 if (ret)
2162 return ret;
2163
2164 ctx->mux_ctx.current_parent = 0;
2165 ctx->mux_ctx.hw.init = CLK_HW_INIT_PARENTS("test-mux", top_parents,
2166 &clk_multiple_parents_mux_ops,
2167 0);
2168 ret = clk_hw_register(NULL, &ctx->mux_ctx.hw);
2169 if (ret)
2170 return ret;
2171
2172 ctx->hw.init = CLK_HW_INIT_HW("test-clock", &ctx->mux_ctx.hw,
2173 &clk_dummy_single_parent_ops,
2174 CLK_SET_RATE_PARENT);
2175 ret = clk_hw_register(NULL, &ctx->hw);
2176 if (ret)
2177 return ret;
2178
2179 return 0;
2180}
2181
2182static void clk_leaf_mux_set_rate_parent_test_exit(struct kunit *test)
2183{
2184 struct clk_leaf_mux_ctx *ctx = test->priv;
2185
2186 clk_hw_unregister(&ctx->hw);
2187 clk_hw_unregister(&ctx->mux_ctx.hw);
2188 clk_hw_unregister(&ctx->mux_ctx.parents_ctx[0].hw);
2189 clk_hw_unregister(&ctx->mux_ctx.parents_ctx[1].hw);
2190}
2191
2192/*
2193 * Test that, for a clock that will forward any rate request to its
2194 * parent, the rate request structure returned by __clk_determine_rate
2195 * is sane and will be what we expect.
2196 */
2197static void clk_leaf_mux_set_rate_parent_determine_rate(struct kunit *test)
2198{
2199 struct clk_leaf_mux_ctx *ctx = test->priv;
2200 struct clk_hw *hw = &ctx->hw;
2201 struct clk *clk = clk_hw_get_clk(hw, NULL);
2202 struct clk_rate_request req;
2203 unsigned long rate;
2204 int ret;
2205
2206 rate = clk_get_rate(clk);
2207 KUNIT_ASSERT_EQ(test, rate, DUMMY_CLOCK_RATE_1);
2208
2209 clk_hw_init_rate_request(hw, &req, DUMMY_CLOCK_RATE_2);
2210
2211 ret = __clk_determine_rate(hw, &req);
2212 KUNIT_ASSERT_EQ(test, ret, 0);
2213
2214 KUNIT_EXPECT_EQ(test, req.rate, DUMMY_CLOCK_RATE_2);
2215 KUNIT_EXPECT_EQ(test, req.best_parent_rate, DUMMY_CLOCK_RATE_2);
2216 KUNIT_EXPECT_PTR_EQ(test, req.best_parent_hw, &ctx->mux_ctx.hw);
2217
2218 clk_put(clk);
2219}
2220
2221static struct kunit_case clk_leaf_mux_set_rate_parent_test_cases[] = {
2222 KUNIT_CASE(clk_leaf_mux_set_rate_parent_determine_rate),
2223 {}
2224};
2225
2226/*
2227 * Test suite for a clock whose parent is a mux with multiple parents.
2228 * The leaf clock has CLK_SET_RATE_PARENT, and will forward rate
2229 * requests to the mux, which will then select which parent is the best
2230 * fit for a given rate.
2231 *
2232 * These tests exercise the behaviour of muxes, and the proper selection
2233 * of parents.
2234 */
2235static struct kunit_suite clk_leaf_mux_set_rate_parent_test_suite = {
2236 .name = "clk-leaf-mux-set-rate-parent",
2237 .init = clk_leaf_mux_set_rate_parent_test_init,
2238 .exit = clk_leaf_mux_set_rate_parent_test_exit,
2239 .test_cases = clk_leaf_mux_set_rate_parent_test_cases,
2240};
2241
2242struct clk_mux_notifier_rate_change {
2243 bool done;
2244 unsigned long old_rate;
2245 unsigned long new_rate;
2246 wait_queue_head_t wq;
2247};
2248
2249struct clk_mux_notifier_ctx {
2250 struct clk_multiple_parent_ctx mux_ctx;
2251 struct clk *clk;
2252 struct notifier_block clk_nb;
2253 struct clk_mux_notifier_rate_change pre_rate_change;
2254 struct clk_mux_notifier_rate_change post_rate_change;
2255};
2256
2257#define NOTIFIER_TIMEOUT_MS 100
2258
2259static int clk_mux_notifier_callback(struct notifier_block *nb,
2260 unsigned long action, void *data)
2261{
2262 struct clk_notifier_data *clk_data = data;
2263 struct clk_mux_notifier_ctx *ctx = container_of(nb,
2264 struct clk_mux_notifier_ctx,
2265 clk_nb);
2266
2267 if (action & PRE_RATE_CHANGE) {
2268 ctx->pre_rate_change.old_rate = clk_data->old_rate;
2269 ctx->pre_rate_change.new_rate = clk_data->new_rate;
2270 ctx->pre_rate_change.done = true;
2271 wake_up_interruptible(&ctx->pre_rate_change.wq);
2272 }
2273
2274 if (action & POST_RATE_CHANGE) {
2275 ctx->post_rate_change.old_rate = clk_data->old_rate;
2276 ctx->post_rate_change.new_rate = clk_data->new_rate;
2277 ctx->post_rate_change.done = true;
2278 wake_up_interruptible(&ctx->post_rate_change.wq);
2279 }
2280
2281 return 0;
2282}
2283
2284static int clk_mux_notifier_test_init(struct kunit *test)
2285{
2286 struct clk_mux_notifier_ctx *ctx;
2287 const char *top_parents[2] = { "parent-0", "parent-1" };
2288 int ret;
2289
2290 ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
2291 if (!ctx)
2292 return -ENOMEM;
2293 test->priv = ctx;
2294 ctx->clk_nb.notifier_call = clk_mux_notifier_callback;
2295 init_waitqueue_head(&ctx->pre_rate_change.wq);
2296 init_waitqueue_head(&ctx->post_rate_change.wq);
2297
2298 ctx->mux_ctx.parents_ctx[0].hw.init = CLK_HW_INIT_NO_PARENT("parent-0",
2299 &clk_dummy_rate_ops,
2300 0);
2301 ctx->mux_ctx.parents_ctx[0].rate = DUMMY_CLOCK_RATE_1;
2302 ret = clk_hw_register(NULL, &ctx->mux_ctx.parents_ctx[0].hw);
2303 if (ret)
2304 return ret;
2305
2306 ctx->mux_ctx.parents_ctx[1].hw.init = CLK_HW_INIT_NO_PARENT("parent-1",
2307 &clk_dummy_rate_ops,
2308 0);
2309 ctx->mux_ctx.parents_ctx[1].rate = DUMMY_CLOCK_RATE_2;
2310 ret = clk_hw_register(NULL, &ctx->mux_ctx.parents_ctx[1].hw);
2311 if (ret)
2312 return ret;
2313
2314 ctx->mux_ctx.current_parent = 0;
2315 ctx->mux_ctx.hw.init = CLK_HW_INIT_PARENTS("test-mux", top_parents,
2316 &clk_multiple_parents_mux_ops,
2317 0);
2318 ret = clk_hw_register(NULL, &ctx->mux_ctx.hw);
2319 if (ret)
2320 return ret;
2321
2322 ctx->clk = clk_hw_get_clk(&ctx->mux_ctx.hw, NULL);
2323 ret = clk_notifier_register(ctx->clk, &ctx->clk_nb);
2324 if (ret)
2325 return ret;
2326
2327 return 0;
2328}
2329
2330static void clk_mux_notifier_test_exit(struct kunit *test)
2331{
2332 struct clk_mux_notifier_ctx *ctx = test->priv;
2333 struct clk *clk = ctx->clk;
2334
2335 clk_notifier_unregister(clk, &ctx->clk_nb);
2336 clk_put(clk);
2337
2338 clk_hw_unregister(&ctx->mux_ctx.hw);
2339 clk_hw_unregister(&ctx->mux_ctx.parents_ctx[0].hw);
2340 clk_hw_unregister(&ctx->mux_ctx.parents_ctx[1].hw);
2341}
2342
2343/*
2344 * Test that if the we have a notifier registered on a mux, the core
2345 * will notify us when we switch to another parent, and with the proper
2346 * old and new rates.
2347 */
2348static void clk_mux_notifier_set_parent_test(struct kunit *test)
2349{
2350 struct clk_mux_notifier_ctx *ctx = test->priv;
2351 struct clk_hw *hw = &ctx->mux_ctx.hw;
2352 struct clk *clk = clk_hw_get_clk(hw, NULL);
2353 struct clk *new_parent = clk_hw_get_clk(&ctx->mux_ctx.parents_ctx[1].hw, NULL);
2354 int ret;
2355
2356 ret = clk_set_parent(clk, new_parent);
2357 KUNIT_ASSERT_EQ(test, ret, 0);
2358
2359 ret = wait_event_interruptible_timeout(ctx->pre_rate_change.wq,
2360 ctx->pre_rate_change.done,
2361 msecs_to_jiffies(NOTIFIER_TIMEOUT_MS));
2362 KUNIT_ASSERT_GT(test, ret, 0);
2363
2364 KUNIT_EXPECT_EQ(test, ctx->pre_rate_change.old_rate, DUMMY_CLOCK_RATE_1);
2365 KUNIT_EXPECT_EQ(test, ctx->pre_rate_change.new_rate, DUMMY_CLOCK_RATE_2);
2366
2367 ret = wait_event_interruptible_timeout(ctx->post_rate_change.wq,
2368 ctx->post_rate_change.done,
2369 msecs_to_jiffies(NOTIFIER_TIMEOUT_MS));
2370 KUNIT_ASSERT_GT(test, ret, 0);
2371
2372 KUNIT_EXPECT_EQ(test, ctx->post_rate_change.old_rate, DUMMY_CLOCK_RATE_1);
2373 KUNIT_EXPECT_EQ(test, ctx->post_rate_change.new_rate, DUMMY_CLOCK_RATE_2);
2374
2375 clk_put(new_parent);
2376 clk_put(clk);
2377}
2378
2379static struct kunit_case clk_mux_notifier_test_cases[] = {
2380 KUNIT_CASE(clk_mux_notifier_set_parent_test),
2381 {}
2382};
2383
2384/*
2385 * Test suite for a mux with multiple parents, and a notifier registered
2386 * on the mux.
2387 *
2388 * These tests exercise the behaviour of notifiers.
2389 */
2390static struct kunit_suite clk_mux_notifier_test_suite = {
2391 .name = "clk-mux-notifier",
2392 .init = clk_mux_notifier_test_init,
2393 .exit = clk_mux_notifier_test_exit,
2394 .test_cases = clk_mux_notifier_test_cases,
2395};
2396
2397kunit_test_suites(
2398 &clk_leaf_mux_set_rate_parent_test_suite,
2399 &clk_test_suite,
2400 &clk_multiple_parents_mux_test_suite,
2401 &clk_mux_notifier_test_suite,
2402 &clk_orphan_transparent_multiple_parent_mux_test_suite,
2403 &clk_orphan_transparent_single_parent_test_suite,
2404 &clk_orphan_two_level_root_last_test_suite,
2405 &clk_range_test_suite,
2406 &clk_range_maximize_test_suite,
2407 &clk_range_minimize_test_suite,
2408 &clk_single_parent_mux_test_suite,
2409 &clk_uncached_test_suite
2410);
2411MODULE_LICENSE("GPL v2");