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");