Merge tag 'dma-mapping-5.18-1' of git://git.infradead.org/users/hch/dma-mapping
[linux-block.git] / drivers / clk / clk_test.c
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
17 struct clk_dummy_context {
18         struct clk_hw hw;
19         unsigned long rate;
20 };
21
22 static 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
31 static 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
38 static 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
51 static 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
64 static 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
75 static 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
83 static u8 clk_dummy_single_get_parent(struct clk_hw *hw)
84 {
85         return 0;
86 }
87
88 static 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
94 static 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
100 static 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
106 static 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
111 static int clk_test_init_with_ops(struct kunit *test, const struct clk_ops *ops)
112 {
113         struct clk_dummy_context *ctx;
114         struct clk_init_data init = { };
115         int ret;
116
117         ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
118         if (!ctx)
119                 return -ENOMEM;
120         ctx->rate = DUMMY_CLOCK_INIT_RATE;
121         test->priv = ctx;
122
123         init.name = "test_dummy_rate";
124         init.ops = ops;
125         ctx->hw.init = &init;
126
127         ret = clk_hw_register(NULL, &ctx->hw);
128         if (ret)
129                 return ret;
130
131         return 0;
132 }
133
134 static int clk_test_init(struct kunit *test)
135 {
136         return clk_test_init_with_ops(test, &clk_dummy_rate_ops);
137 }
138
139 static int clk_maximize_test_init(struct kunit *test)
140 {
141         return clk_test_init_with_ops(test, &clk_dummy_maximize_rate_ops);
142 }
143
144 static int clk_minimize_test_init(struct kunit *test)
145 {
146         return clk_test_init_with_ops(test, &clk_dummy_minimize_rate_ops);
147 }
148
149 static void clk_test_exit(struct kunit *test)
150 {
151         struct clk_dummy_context *ctx = test->priv;
152
153         clk_hw_unregister(&ctx->hw);
154 }
155
156 /*
157  * Test that the actual rate matches what is returned by clk_get_rate()
158  */
159 static void clk_test_get_rate(struct kunit *test)
160 {
161         struct clk_dummy_context *ctx = test->priv;
162         struct clk_hw *hw = &ctx->hw;
163         struct clk *clk = hw->clk;
164         unsigned long rate;
165
166         rate = clk_get_rate(clk);
167         KUNIT_ASSERT_GT(test, rate, 0);
168         KUNIT_EXPECT_EQ(test, rate, ctx->rate);
169 }
170
171 /*
172  * Test that, after a call to clk_set_rate(), the rate returned by
173  * clk_get_rate() matches.
174  *
175  * This assumes that clk_ops.determine_rate or clk_ops.round_rate won't
176  * modify the requested rate, which is our case in clk_dummy_rate_ops.
177  */
178 static void clk_test_set_get_rate(struct kunit *test)
179 {
180         struct clk_dummy_context *ctx = test->priv;
181         struct clk_hw *hw = &ctx->hw;
182         struct clk *clk = hw->clk;
183         unsigned long rate;
184
185         KUNIT_ASSERT_EQ(test,
186                         clk_set_rate(clk, DUMMY_CLOCK_RATE_1),
187                         0);
188
189         rate = clk_get_rate(clk);
190         KUNIT_ASSERT_GT(test, rate, 0);
191         KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_1);
192 }
193
194 /*
195  * Test that, after several calls to clk_set_rate(), the rate returned
196  * by clk_get_rate() matches the last one.
197  *
198  * This assumes that clk_ops.determine_rate or clk_ops.round_rate won't
199  * modify the requested rate, which is our case in clk_dummy_rate_ops.
200  */
201 static void clk_test_set_set_get_rate(struct kunit *test)
202 {
203         struct clk_dummy_context *ctx = test->priv;
204         struct clk_hw *hw = &ctx->hw;
205         struct clk *clk = hw->clk;
206         unsigned long rate;
207
208         KUNIT_ASSERT_EQ(test,
209                         clk_set_rate(clk, DUMMY_CLOCK_RATE_1),
210                         0);
211
212         KUNIT_ASSERT_EQ(test,
213                         clk_set_rate(clk, DUMMY_CLOCK_RATE_2),
214                         0);
215
216         rate = clk_get_rate(clk);
217         KUNIT_ASSERT_GT(test, rate, 0);
218         KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_2);
219 }
220
221 /*
222  * Test that clk_round_rate and clk_set_rate are consitent and will
223  * return the same frequency.
224  */
225 static void clk_test_round_set_get_rate(struct kunit *test)
226 {
227         struct clk_dummy_context *ctx = test->priv;
228         struct clk_hw *hw = &ctx->hw;
229         struct clk *clk = hw->clk;
230         unsigned long rounded_rate, set_rate;
231
232         rounded_rate = clk_round_rate(clk, DUMMY_CLOCK_RATE_1);
233         KUNIT_ASSERT_GT(test, rounded_rate, 0);
234         KUNIT_EXPECT_EQ(test, rounded_rate, DUMMY_CLOCK_RATE_1);
235
236         KUNIT_ASSERT_EQ(test,
237                         clk_set_rate(clk, DUMMY_CLOCK_RATE_1),
238                         0);
239
240         set_rate = clk_get_rate(clk);
241         KUNIT_ASSERT_GT(test, set_rate, 0);
242         KUNIT_EXPECT_EQ(test, rounded_rate, set_rate);
243 }
244
245 static struct kunit_case clk_test_cases[] = {
246         KUNIT_CASE(clk_test_get_rate),
247         KUNIT_CASE(clk_test_set_get_rate),
248         KUNIT_CASE(clk_test_set_set_get_rate),
249         KUNIT_CASE(clk_test_round_set_get_rate),
250         {}
251 };
252
253 static struct kunit_suite clk_test_suite = {
254         .name = "clk-test",
255         .init = clk_test_init,
256         .exit = clk_test_exit,
257         .test_cases = clk_test_cases,
258 };
259
260 struct clk_single_parent_ctx {
261         struct clk_dummy_context parent_ctx;
262         struct clk_hw hw;
263 };
264
265 static int clk_orphan_transparent_single_parent_mux_test_init(struct kunit *test)
266 {
267         struct clk_single_parent_ctx *ctx;
268         struct clk_init_data init = { };
269         const char * const parents[] = { "orphan_parent" };
270         int ret;
271
272         ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
273         if (!ctx)
274                 return -ENOMEM;
275         test->priv = ctx;
276
277         init.name = "test_orphan_dummy_parent";
278         init.ops = &clk_dummy_single_parent_ops;
279         init.parent_names = parents;
280         init.num_parents = ARRAY_SIZE(parents);
281         init.flags = CLK_SET_RATE_PARENT;
282         ctx->hw.init = &init;
283
284         ret = clk_hw_register(NULL, &ctx->hw);
285         if (ret)
286                 return ret;
287
288         memset(&init, 0, sizeof(init));
289         init.name = "orphan_parent";
290         init.ops = &clk_dummy_rate_ops;
291         ctx->parent_ctx.hw.init = &init;
292         ctx->parent_ctx.rate = DUMMY_CLOCK_INIT_RATE;
293
294         ret = clk_hw_register(NULL, &ctx->parent_ctx.hw);
295         if (ret)
296                 return ret;
297
298         return 0;
299 }
300
301 static void clk_orphan_transparent_single_parent_mux_test_exit(struct kunit *test)
302 {
303         struct clk_single_parent_ctx *ctx = test->priv;
304
305         clk_hw_unregister(&ctx->hw);
306         clk_hw_unregister(&ctx->parent_ctx.hw);
307 }
308
309 /*
310  * Test that a mux-only clock, with an initial rate within a range,
311  * will still have the same rate after the range has been enforced.
312  */
313 static void clk_test_orphan_transparent_parent_mux_set_range(struct kunit *test)
314 {
315         struct clk_single_parent_ctx *ctx = test->priv;
316         struct clk_hw *hw = &ctx->hw;
317         struct clk *clk = hw->clk;
318         unsigned long rate, new_rate;
319
320         rate = clk_get_rate(clk);
321         KUNIT_ASSERT_GT(test, rate, 0);
322
323         KUNIT_ASSERT_EQ(test,
324                         clk_set_rate_range(clk,
325                                            ctx->parent_ctx.rate - 1000,
326                                            ctx->parent_ctx.rate + 1000),
327                         0);
328
329         new_rate = clk_get_rate(clk);
330         KUNIT_ASSERT_GT(test, new_rate, 0);
331         KUNIT_EXPECT_EQ(test, rate, new_rate);
332 }
333
334 static struct kunit_case clk_orphan_transparent_single_parent_mux_test_cases[] = {
335         KUNIT_CASE(clk_test_orphan_transparent_parent_mux_set_range),
336         {}
337 };
338
339 static struct kunit_suite clk_orphan_transparent_single_parent_test_suite = {
340         .name = "clk-orphan-transparent-single-parent-test",
341         .init = clk_orphan_transparent_single_parent_mux_test_init,
342         .exit = clk_orphan_transparent_single_parent_mux_test_exit,
343         .test_cases = clk_orphan_transparent_single_parent_mux_test_cases,
344 };
345
346 /*
347  * Test that clk_set_rate_range won't return an error for a valid range
348  * and that it will make sure the rate of the clock is within the
349  * boundaries.
350  */
351 static void clk_range_test_set_range(struct kunit *test)
352 {
353         struct clk_dummy_context *ctx = test->priv;
354         struct clk_hw *hw = &ctx->hw;
355         struct clk *clk = hw->clk;
356         unsigned long rate;
357
358         KUNIT_ASSERT_EQ(test,
359                         clk_set_rate_range(clk,
360                                            DUMMY_CLOCK_RATE_1,
361                                            DUMMY_CLOCK_RATE_2),
362                         0);
363
364         rate = clk_get_rate(clk);
365         KUNIT_ASSERT_GT(test, rate, 0);
366         KUNIT_EXPECT_GE(test, rate, DUMMY_CLOCK_RATE_1);
367         KUNIT_EXPECT_LE(test, rate, DUMMY_CLOCK_RATE_2);
368 }
369
370 /*
371  * Test that calling clk_set_rate_range with a minimum rate higher than
372  * the maximum rate returns an error.
373  */
374 static void clk_range_test_set_range_invalid(struct kunit *test)
375 {
376         struct clk_dummy_context *ctx = test->priv;
377         struct clk_hw *hw = &ctx->hw;
378         struct clk *clk = hw->clk;
379
380         KUNIT_EXPECT_LT(test,
381                         clk_set_rate_range(clk,
382                                            DUMMY_CLOCK_RATE_1 + 1000,
383                                            DUMMY_CLOCK_RATE_1),
384                         0);
385 }
386
387 /*
388  * Test that users can't set multiple, disjoints, range that would be
389  * impossible to meet.
390  */
391 static void clk_range_test_multiple_disjoints_range(struct kunit *test)
392 {
393         struct clk_dummy_context *ctx = test->priv;
394         struct clk_hw *hw = &ctx->hw;
395         struct clk *user1, *user2;
396
397         user1 = clk_hw_get_clk(hw, NULL);
398         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, user1);
399
400         user2 = clk_hw_get_clk(hw, NULL);
401         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, user2);
402
403         KUNIT_ASSERT_EQ(test,
404                         clk_set_rate_range(user1, 1000, 2000),
405                         0);
406
407         KUNIT_EXPECT_LT(test,
408                         clk_set_rate_range(user2, 3000, 4000),
409                         0);
410
411         clk_put(user2);
412         clk_put(user1);
413 }
414
415 /*
416  * Test that if our clock has some boundaries and we try to round a rate
417  * lower than the minimum, the returned rate will be within range.
418  */
419 static void clk_range_test_set_range_round_rate_lower(struct kunit *test)
420 {
421         struct clk_dummy_context *ctx = test->priv;
422         struct clk_hw *hw = &ctx->hw;
423         struct clk *clk = hw->clk;
424         long rate;
425
426         KUNIT_ASSERT_EQ(test,
427                         clk_set_rate_range(clk,
428                                            DUMMY_CLOCK_RATE_1,
429                                            DUMMY_CLOCK_RATE_2),
430                         0);
431
432         rate = clk_round_rate(clk, DUMMY_CLOCK_RATE_1 - 1000);
433         KUNIT_ASSERT_GT(test, rate, 0);
434         KUNIT_EXPECT_GE(test, rate, DUMMY_CLOCK_RATE_1);
435         KUNIT_EXPECT_LE(test, rate, DUMMY_CLOCK_RATE_2);
436 }
437
438 /*
439  * Test that if our clock has some boundaries and we try to set a rate
440  * higher than the maximum, the new rate will be within range.
441  */
442 static void clk_range_test_set_range_set_rate_lower(struct kunit *test)
443 {
444         struct clk_dummy_context *ctx = test->priv;
445         struct clk_hw *hw = &ctx->hw;
446         struct clk *clk = hw->clk;
447         unsigned long rate;
448
449         KUNIT_ASSERT_EQ(test,
450                         clk_set_rate_range(clk,
451                                            DUMMY_CLOCK_RATE_1,
452                                            DUMMY_CLOCK_RATE_2),
453                         0);
454
455         KUNIT_ASSERT_EQ(test,
456                         clk_set_rate(clk, DUMMY_CLOCK_RATE_1 - 1000),
457                         0);
458
459         rate = clk_get_rate(clk);
460         KUNIT_ASSERT_GT(test, rate, 0);
461         KUNIT_EXPECT_GE(test, rate, DUMMY_CLOCK_RATE_1);
462         KUNIT_EXPECT_LE(test, rate, DUMMY_CLOCK_RATE_2);
463 }
464
465 /*
466  * Test that if our clock has some boundaries and we try to round and
467  * set a rate lower than the minimum, the rate returned by
468  * clk_round_rate() will be consistent with the new rate set by
469  * clk_set_rate().
470  */
471 static void clk_range_test_set_range_set_round_rate_consistent_lower(struct kunit *test)
472 {
473         struct clk_dummy_context *ctx = test->priv;
474         struct clk_hw *hw = &ctx->hw;
475         struct clk *clk = hw->clk;
476         long rounded;
477
478         KUNIT_ASSERT_EQ(test,
479                         clk_set_rate_range(clk,
480                                            DUMMY_CLOCK_RATE_1,
481                                            DUMMY_CLOCK_RATE_2),
482                         0);
483
484         rounded = clk_round_rate(clk, DUMMY_CLOCK_RATE_1 - 1000);
485         KUNIT_ASSERT_GT(test, rounded, 0);
486
487         KUNIT_ASSERT_EQ(test,
488                         clk_set_rate(clk, DUMMY_CLOCK_RATE_1 - 1000),
489                         0);
490
491         KUNIT_EXPECT_EQ(test, rounded, clk_get_rate(clk));
492 }
493
494 /*
495  * Test that if our clock has some boundaries and we try to round a rate
496  * higher than the maximum, the returned rate will be within range.
497  */
498 static void clk_range_test_set_range_round_rate_higher(struct kunit *test)
499 {
500         struct clk_dummy_context *ctx = test->priv;
501         struct clk_hw *hw = &ctx->hw;
502         struct clk *clk = hw->clk;
503         long rate;
504
505         KUNIT_ASSERT_EQ(test,
506                         clk_set_rate_range(clk,
507                                            DUMMY_CLOCK_RATE_1,
508                                            DUMMY_CLOCK_RATE_2),
509                         0);
510
511         rate = clk_round_rate(clk, DUMMY_CLOCK_RATE_2 + 1000);
512         KUNIT_ASSERT_GT(test, rate, 0);
513         KUNIT_EXPECT_GE(test, rate, DUMMY_CLOCK_RATE_1);
514         KUNIT_EXPECT_LE(test, rate, DUMMY_CLOCK_RATE_2);
515 }
516
517 /*
518  * Test that if our clock has some boundaries and we try to set a rate
519  * higher than the maximum, the new rate will be within range.
520  */
521 static void clk_range_test_set_range_set_rate_higher(struct kunit *test)
522 {
523         struct clk_dummy_context *ctx = test->priv;
524         struct clk_hw *hw = &ctx->hw;
525         struct clk *clk = hw->clk;
526         unsigned long rate;
527
528         KUNIT_ASSERT_EQ(test,
529                         clk_set_rate_range(clk,
530                                            DUMMY_CLOCK_RATE_1,
531                                            DUMMY_CLOCK_RATE_2),
532                         0);
533
534         KUNIT_ASSERT_EQ(test,
535                         clk_set_rate(clk, DUMMY_CLOCK_RATE_2 + 1000),
536                         0);
537
538         rate = clk_get_rate(clk);
539         KUNIT_ASSERT_GT(test, rate, 0);
540         KUNIT_EXPECT_GE(test, rate, DUMMY_CLOCK_RATE_1);
541         KUNIT_EXPECT_LE(test, rate, DUMMY_CLOCK_RATE_2);
542 }
543
544 /*
545  * Test that if our clock has some boundaries and we try to round and
546  * set a rate higher than the maximum, the rate returned by
547  * clk_round_rate() will be consistent with the new rate set by
548  * clk_set_rate().
549  */
550 static void clk_range_test_set_range_set_round_rate_consistent_higher(struct kunit *test)
551 {
552         struct clk_dummy_context *ctx = test->priv;
553         struct clk_hw *hw = &ctx->hw;
554         struct clk *clk = hw->clk;
555         long rounded;
556
557         KUNIT_ASSERT_EQ(test,
558                         clk_set_rate_range(clk,
559                                            DUMMY_CLOCK_RATE_1,
560                                            DUMMY_CLOCK_RATE_2),
561                         0);
562
563         rounded = clk_round_rate(clk, DUMMY_CLOCK_RATE_2 + 1000);
564         KUNIT_ASSERT_GT(test, rounded, 0);
565
566         KUNIT_ASSERT_EQ(test,
567                         clk_set_rate(clk, DUMMY_CLOCK_RATE_2 + 1000),
568                         0);
569
570         KUNIT_EXPECT_EQ(test, rounded, clk_get_rate(clk));
571 }
572
573 /*
574  * Test that if our clock has a rate lower than the minimum set by a
575  * call to clk_set_rate_range(), the rate will be raised to match the
576  * new minimum.
577  *
578  * This assumes that clk_ops.determine_rate or clk_ops.round_rate won't
579  * modify the requested rate, which is our case in clk_dummy_rate_ops.
580  */
581 static void clk_range_test_set_range_get_rate_raised(struct kunit *test)
582 {
583         struct clk_dummy_context *ctx = test->priv;
584         struct clk_hw *hw = &ctx->hw;
585         struct clk *clk = hw->clk;
586         unsigned long rate;
587
588         KUNIT_ASSERT_EQ(test,
589                         clk_set_rate(clk, DUMMY_CLOCK_RATE_1 - 1000),
590                         0);
591
592         KUNIT_ASSERT_EQ(test,
593                         clk_set_rate_range(clk,
594                                            DUMMY_CLOCK_RATE_1,
595                                            DUMMY_CLOCK_RATE_2),
596                         0);
597
598         rate = clk_get_rate(clk);
599         KUNIT_ASSERT_GT(test, rate, 0);
600         KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_1);
601 }
602
603 /*
604  * Test that if our clock has a rate higher than the maximum set by a
605  * call to clk_set_rate_range(), the rate will be lowered to match the
606  * new maximum.
607  *
608  * This assumes that clk_ops.determine_rate or clk_ops.round_rate won't
609  * modify the requested rate, which is our case in clk_dummy_rate_ops.
610  */
611 static void clk_range_test_set_range_get_rate_lowered(struct kunit *test)
612 {
613         struct clk_dummy_context *ctx = test->priv;
614         struct clk_hw *hw = &ctx->hw;
615         struct clk *clk = hw->clk;
616         unsigned long rate;
617
618         KUNIT_ASSERT_EQ(test,
619                         clk_set_rate(clk, DUMMY_CLOCK_RATE_2 + 1000),
620                         0);
621
622         KUNIT_ASSERT_EQ(test,
623                         clk_set_rate_range(clk,
624                                            DUMMY_CLOCK_RATE_1,
625                                            DUMMY_CLOCK_RATE_2),
626                         0);
627
628         rate = clk_get_rate(clk);
629         KUNIT_ASSERT_GT(test, rate, 0);
630         KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_2);
631 }
632
633 static struct kunit_case clk_range_test_cases[] = {
634         KUNIT_CASE(clk_range_test_set_range),
635         KUNIT_CASE(clk_range_test_set_range_invalid),
636         KUNIT_CASE(clk_range_test_multiple_disjoints_range),
637         KUNIT_CASE(clk_range_test_set_range_round_rate_lower),
638         KUNIT_CASE(clk_range_test_set_range_set_rate_lower),
639         KUNIT_CASE(clk_range_test_set_range_set_round_rate_consistent_lower),
640         KUNIT_CASE(clk_range_test_set_range_round_rate_higher),
641         KUNIT_CASE(clk_range_test_set_range_set_rate_higher),
642         KUNIT_CASE(clk_range_test_set_range_set_round_rate_consistent_higher),
643         KUNIT_CASE(clk_range_test_set_range_get_rate_raised),
644         KUNIT_CASE(clk_range_test_set_range_get_rate_lowered),
645         {}
646 };
647
648 static struct kunit_suite clk_range_test_suite = {
649         .name = "clk-range-test",
650         .init = clk_test_init,
651         .exit = clk_test_exit,
652         .test_cases = clk_range_test_cases,
653 };
654
655 /*
656  * Test that if we have several subsequent calls to
657  * clk_set_rate_range(), the core will reevaluate whether a new rate is
658  * needed each and every time.
659  *
660  * With clk_dummy_maximize_rate_ops, this means that the rate will
661  * trail along the maximum as it evolves.
662  */
663 static void clk_range_test_set_range_rate_maximized(struct kunit *test)
664 {
665         struct clk_dummy_context *ctx = test->priv;
666         struct clk_hw *hw = &ctx->hw;
667         struct clk *clk = hw->clk;
668         unsigned long rate;
669
670         KUNIT_ASSERT_EQ(test,
671                         clk_set_rate(clk, DUMMY_CLOCK_RATE_2 + 1000),
672                         0);
673
674         KUNIT_ASSERT_EQ(test,
675                         clk_set_rate_range(clk,
676                                            DUMMY_CLOCK_RATE_1,
677                                            DUMMY_CLOCK_RATE_2),
678                         0);
679
680         rate = clk_get_rate(clk);
681         KUNIT_ASSERT_GT(test, rate, 0);
682         KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_2);
683
684         KUNIT_ASSERT_EQ(test,
685                         clk_set_rate_range(clk,
686                                            DUMMY_CLOCK_RATE_1,
687                                            DUMMY_CLOCK_RATE_2 - 1000),
688                         0);
689
690         rate = clk_get_rate(clk);
691         KUNIT_ASSERT_GT(test, rate, 0);
692         KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_2 - 1000);
693
694         KUNIT_ASSERT_EQ(test,
695                         clk_set_rate_range(clk,
696                                            DUMMY_CLOCK_RATE_1,
697                                            DUMMY_CLOCK_RATE_2),
698                         0);
699
700         rate = clk_get_rate(clk);
701         KUNIT_ASSERT_GT(test, rate, 0);
702         KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_2);
703 }
704
705 /*
706  * Test that if we have several subsequent calls to
707  * clk_set_rate_range(), across multiple users, the core will reevaluate
708  * whether a new rate is needed each and every time.
709  *
710  * With clk_dummy_maximize_rate_ops, this means that the rate will
711  * trail along the maximum as it evolves.
712  */
713 static void clk_range_test_multiple_set_range_rate_maximized(struct kunit *test)
714 {
715         struct clk_dummy_context *ctx = test->priv;
716         struct clk_hw *hw = &ctx->hw;
717         struct clk *clk = hw->clk;
718         struct clk *user1, *user2;
719         unsigned long rate;
720
721         user1 = clk_hw_get_clk(hw, NULL);
722         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, user1);
723
724         user2 = clk_hw_get_clk(hw, NULL);
725         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, user2);
726
727         KUNIT_ASSERT_EQ(test,
728                         clk_set_rate(clk, DUMMY_CLOCK_RATE_2 + 1000),
729                         0);
730
731         KUNIT_ASSERT_EQ(test,
732                         clk_set_rate_range(user1,
733                                            0,
734                                            DUMMY_CLOCK_RATE_2),
735                         0);
736
737         rate = clk_get_rate(clk);
738         KUNIT_ASSERT_GT(test, rate, 0);
739         KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_2);
740
741         KUNIT_ASSERT_EQ(test,
742                         clk_set_rate_range(user2,
743                                            0,
744                                            DUMMY_CLOCK_RATE_1),
745                         0);
746
747         rate = clk_get_rate(clk);
748         KUNIT_ASSERT_GT(test, rate, 0);
749         KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_1);
750
751         KUNIT_ASSERT_EQ(test,
752                         clk_drop_range(user2),
753                         0);
754
755         rate = clk_get_rate(clk);
756         KUNIT_ASSERT_GT(test, rate, 0);
757         KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_2);
758
759         clk_put(user2);
760         clk_put(user1);
761 }
762
763 /*
764  * Test that if we have several subsequent calls to
765  * clk_set_rate_range(), across multiple users, the core will reevaluate
766  * whether a new rate is needed, including when a user drop its clock.
767  *
768  * With clk_dummy_maximize_rate_ops, this means that the rate will
769  * trail along the maximum as it evolves.
770  */
771 static void clk_range_test_multiple_set_range_rate_put_maximized(struct kunit *test)
772 {
773         struct clk_dummy_context *ctx = test->priv;
774         struct clk_hw *hw = &ctx->hw;
775         struct clk *clk = hw->clk;
776         struct clk *user1, *user2;
777         unsigned long rate;
778
779         user1 = clk_hw_get_clk(hw, NULL);
780         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, user1);
781
782         user2 = clk_hw_get_clk(hw, NULL);
783         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, user2);
784
785         KUNIT_ASSERT_EQ(test,
786                         clk_set_rate(clk, DUMMY_CLOCK_RATE_2 + 1000),
787                         0);
788
789         KUNIT_ASSERT_EQ(test,
790                         clk_set_rate_range(user1,
791                                            0,
792                                            DUMMY_CLOCK_RATE_2),
793                         0);
794
795         rate = clk_get_rate(clk);
796         KUNIT_ASSERT_GT(test, rate, 0);
797         KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_2);
798
799         KUNIT_ASSERT_EQ(test,
800                         clk_set_rate_range(user2,
801                                            0,
802                                            DUMMY_CLOCK_RATE_1),
803                         0);
804
805         rate = clk_get_rate(clk);
806         KUNIT_ASSERT_GT(test, rate, 0);
807         KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_1);
808
809         clk_put(user2);
810
811         rate = clk_get_rate(clk);
812         KUNIT_ASSERT_GT(test, rate, 0);
813         KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_2);
814
815         clk_put(user1);
816 }
817
818 static struct kunit_case clk_range_maximize_test_cases[] = {
819         KUNIT_CASE(clk_range_test_set_range_rate_maximized),
820         KUNIT_CASE(clk_range_test_multiple_set_range_rate_maximized),
821         KUNIT_CASE(clk_range_test_multiple_set_range_rate_put_maximized),
822         {}
823 };
824
825 static struct kunit_suite clk_range_maximize_test_suite = {
826         .name = "clk-range-maximize-test",
827         .init = clk_maximize_test_init,
828         .exit = clk_test_exit,
829         .test_cases = clk_range_maximize_test_cases,
830 };
831
832 /*
833  * Test that if we have several subsequent calls to
834  * clk_set_rate_range(), the core will reevaluate whether a new rate is
835  * needed each and every time.
836  *
837  * With clk_dummy_minimize_rate_ops, this means that the rate will
838  * trail along the minimum as it evolves.
839  */
840 static void clk_range_test_set_range_rate_minimized(struct kunit *test)
841 {
842         struct clk_dummy_context *ctx = test->priv;
843         struct clk_hw *hw = &ctx->hw;
844         struct clk *clk = hw->clk;
845         unsigned long rate;
846
847         KUNIT_ASSERT_EQ(test,
848                         clk_set_rate(clk, DUMMY_CLOCK_RATE_1 - 1000),
849                         0);
850
851         KUNIT_ASSERT_EQ(test,
852                         clk_set_rate_range(clk,
853                                            DUMMY_CLOCK_RATE_1,
854                                            DUMMY_CLOCK_RATE_2),
855                         0);
856
857         rate = clk_get_rate(clk);
858         KUNIT_ASSERT_GT(test, rate, 0);
859         KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_1);
860
861         KUNIT_ASSERT_EQ(test,
862                         clk_set_rate_range(clk,
863                                            DUMMY_CLOCK_RATE_1 + 1000,
864                                            DUMMY_CLOCK_RATE_2),
865                         0);
866
867         rate = clk_get_rate(clk);
868         KUNIT_ASSERT_GT(test, rate, 0);
869         KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_1 + 1000);
870
871         KUNIT_ASSERT_EQ(test,
872                         clk_set_rate_range(clk,
873                                            DUMMY_CLOCK_RATE_1,
874                                            DUMMY_CLOCK_RATE_2),
875                         0);
876
877         rate = clk_get_rate(clk);
878         KUNIT_ASSERT_GT(test, rate, 0);
879         KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_1);
880 }
881
882 /*
883  * Test that if we have several subsequent calls to
884  * clk_set_rate_range(), across multiple users, the core will reevaluate
885  * whether a new rate is needed each and every time.
886  *
887  * With clk_dummy_minimize_rate_ops, this means that the rate will
888  * trail along the minimum as it evolves.
889  */
890 static void clk_range_test_multiple_set_range_rate_minimized(struct kunit *test)
891 {
892         struct clk_dummy_context *ctx = test->priv;
893         struct clk_hw *hw = &ctx->hw;
894         struct clk *clk = hw->clk;
895         struct clk *user1, *user2;
896         unsigned long rate;
897
898         user1 = clk_hw_get_clk(hw, NULL);
899         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, user1);
900
901         user2 = clk_hw_get_clk(hw, NULL);
902         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, user2);
903
904         KUNIT_ASSERT_EQ(test,
905                         clk_set_rate_range(user1,
906                                            DUMMY_CLOCK_RATE_1,
907                                            ULONG_MAX),
908                         0);
909
910         rate = clk_get_rate(clk);
911         KUNIT_ASSERT_GT(test, rate, 0);
912         KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_1);
913
914         KUNIT_ASSERT_EQ(test,
915                         clk_set_rate_range(user2,
916                                            DUMMY_CLOCK_RATE_2,
917                                            ULONG_MAX),
918                         0);
919
920         rate = clk_get_rate(clk);
921         KUNIT_ASSERT_GT(test, rate, 0);
922         KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_2);
923
924         KUNIT_ASSERT_EQ(test,
925                         clk_drop_range(user2),
926                         0);
927
928         rate = clk_get_rate(clk);
929         KUNIT_ASSERT_GT(test, rate, 0);
930         KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_1);
931
932         clk_put(user2);
933         clk_put(user1);
934 }
935
936 /*
937  * Test that if we have several subsequent calls to
938  * clk_set_rate_range(), across multiple users, the core will reevaluate
939  * whether a new rate is needed, including when a user drop its clock.
940  *
941  * With clk_dummy_minimize_rate_ops, this means that the rate will
942  * trail along the minimum as it evolves.
943  */
944 static void clk_range_test_multiple_set_range_rate_put_minimized(struct kunit *test)
945 {
946         struct clk_dummy_context *ctx = test->priv;
947         struct clk_hw *hw = &ctx->hw;
948         struct clk *clk = hw->clk;
949         struct clk *user1, *user2;
950         unsigned long rate;
951
952         user1 = clk_hw_get_clk(hw, NULL);
953         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, user1);
954
955         user2 = clk_hw_get_clk(hw, NULL);
956         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, user2);
957
958         KUNIT_ASSERT_EQ(test,
959                         clk_set_rate_range(user1,
960                                            DUMMY_CLOCK_RATE_1,
961                                            ULONG_MAX),
962                         0);
963
964         rate = clk_get_rate(clk);
965         KUNIT_ASSERT_GT(test, rate, 0);
966         KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_1);
967
968         KUNIT_ASSERT_EQ(test,
969                         clk_set_rate_range(user2,
970                                            DUMMY_CLOCK_RATE_2,
971                                            ULONG_MAX),
972                         0);
973
974         rate = clk_get_rate(clk);
975         KUNIT_ASSERT_GT(test, rate, 0);
976         KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_2);
977
978         clk_put(user2);
979
980         rate = clk_get_rate(clk);
981         KUNIT_ASSERT_GT(test, rate, 0);
982         KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_1);
983
984         clk_put(user1);
985 }
986
987 static struct kunit_case clk_range_minimize_test_cases[] = {
988         KUNIT_CASE(clk_range_test_set_range_rate_minimized),
989         KUNIT_CASE(clk_range_test_multiple_set_range_rate_minimized),
990         KUNIT_CASE(clk_range_test_multiple_set_range_rate_put_minimized),
991         {}
992 };
993
994 static struct kunit_suite clk_range_minimize_test_suite = {
995         .name = "clk-range-minimize-test",
996         .init = clk_minimize_test_init,
997         .exit = clk_test_exit,
998         .test_cases = clk_range_minimize_test_cases,
999 };
1000
1001 kunit_test_suites(
1002         &clk_test_suite,
1003         &clk_orphan_transparent_single_parent_test_suite,
1004         &clk_range_test_suite,
1005         &clk_range_maximize_test_suite,
1006         &clk_range_minimize_test_suite
1007 );
1008 MODULE_LICENSE("GPL v2");