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         /*
 108          * FIXME: Even though we should probably be able to use
 109          * __clk_mux_determine_rate() here, if we use it and call
 110          * clk_round_rate() or clk_set_rate() with a rate lower than
 111          * what all the parents can provide, it will return -EINVAL.
 112          *
 113          * This is due to the fact that it has the undocumented
 114          * behaviour to always pick up the closest rate higher than the
 115          * requested rate. If we get something lower, it thus considers
 116          * that it's not acceptable and will return an error.
 117          *
 118          * It's somewhat inconsistent and creates a weird threshold
 119          * between rates above the parent rate which would be rounded to
 120          * what the parent can provide, but rates below will simply
 121          * return an error.
 122          */
 123         .determine_rate = __clk_mux_determine_rate_closest,
 124         .set_parent = clk_dummy_single_set_parent,
 125         .get_parent = clk_dummy_single_get_parent,
 126 };
 127
 128 struct clk_multiple_parent_ctx {
 129         struct clk_dummy_context parents_ctx[2];
 130         struct clk_hw hw;
 131         u8 current_parent;
 132 };
 133
 134 static int clk_multiple_parents_mux_set_parent(struct clk_hw *hw, u8 index)
 135 {
 136         struct clk_multiple_parent_ctx *ctx =
 137                 container_of(hw, struct clk_multiple_parent_ctx, hw);
 138
 139         if (index >= clk_hw_get_num_parents(hw))
 140                 return -EINVAL;
 141
 142         ctx->current_parent = index;
 143
 144         return 0;
 145 }
 146
 147 static u8 clk_multiple_parents_mux_get_parent(struct clk_hw *hw)
 148 {
 149         struct clk_multiple_parent_ctx *ctx =
 150                 container_of(hw, struct clk_multiple_parent_ctx, hw);
 151
 152         return ctx->current_parent;
 153 }
 154
 155 static const struct clk_ops clk_multiple_parents_mux_ops = {
 156         .get_parent = clk_multiple_parents_mux_get_parent,
 157         .set_parent = clk_multiple_parents_mux_set_parent,
 158         .determine_rate = __clk_mux_determine_rate_closest,
 159 };
 160
 161 static const struct clk_ops clk_multiple_parents_no_reparent_mux_ops = {
 162         .determine_rate = clk_hw_determine_rate_no_reparent,
 163         .get_parent = clk_multiple_parents_mux_get_parent,
 164         .set_parent = clk_multiple_parents_mux_set_parent,
 165 };
 166
 167 static int clk_test_init_with_ops(struct kunit *test, const struct clk_ops *ops)
 168 {
 169         struct clk_dummy_context *ctx;
 170         struct clk_init_data init = { };
 171         int ret;
 172
 173         ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
 174         if (!ctx)
 175                 return -ENOMEM;
 176         ctx->rate = DUMMY_CLOCK_INIT_RATE;
 177         test->priv = ctx;
 178
 179         init.name = "test_dummy_rate";
 180         init.ops = ops;
 181         ctx->hw.init = &init;
 182
 183         ret = clk_hw_register(NULL, &ctx->hw);
 184         if (ret)
 185                 return ret;
 186
 187         return 0;
 188 }
 189
 190 static int clk_test_init(struct kunit *test)
 191 {
 192         return clk_test_init_with_ops(test, &clk_dummy_rate_ops);
 193 }
 194
 195 static int clk_maximize_test_init(struct kunit *test)
 196 {
 197         return clk_test_init_with_ops(test, &clk_dummy_maximize_rate_ops);
 198 }
 199
 200 static int clk_minimize_test_init(struct kunit *test)
 201 {
 202         return clk_test_init_with_ops(test, &clk_dummy_minimize_rate_ops);
 203 }
 204
 205 static void clk_test_exit(struct kunit *test)
 206 {
 207         struct clk_dummy_context *ctx = test->priv;
 208
 209         clk_hw_unregister(&ctx->hw);
 210 }
 211
 212 /*
 213  * Test that the actual rate matches what is returned by clk_get_rate()
 214  */
 215 static void clk_test_get_rate(struct kunit *test)
 216 {
 217         struct clk_dummy_context *ctx = test->priv;
 218         struct clk_hw *hw = &ctx->hw;
 219         struct clk *clk = clk_hw_get_clk(hw, NULL);
 220         unsigned long rate;
 221
 222         rate = clk_get_rate(clk);
 223         KUNIT_ASSERT_GT(test, rate, 0);
 224         KUNIT_EXPECT_EQ(test, rate, ctx->rate);
 225
 226         clk_put(clk);
 227 }
 228
 229 /*
 230  * Test that, after a call to clk_set_rate(), the rate returned by
 231  * clk_get_rate() matches.
 232  *
 233  * This assumes that clk_ops.determine_rate or clk_ops.round_rate won't
 234  * modify the requested rate, which is our case in clk_dummy_rate_ops.
 235  */
 236 static void clk_test_set_get_rate(struct kunit *test)
 237 {
 238         struct clk_dummy_context *ctx = test->priv;
 239         struct clk_hw *hw = &ctx->hw;
 240         struct clk *clk = clk_hw_get_clk(hw, NULL);
 241         unsigned long rate;
 242
 243         KUNIT_ASSERT_EQ(test,
 244                         clk_set_rate(clk, DUMMY_CLOCK_RATE_1),
 245                         0);
 246
 247         rate = clk_get_rate(clk);
 248         KUNIT_ASSERT_GT(test, rate, 0);
 249         KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_1);
 250
 251         clk_put(clk);
 252 }
 253
 254 /*
 255  * Test that, after several calls to clk_set_rate(), the rate returned
 256  * by clk_get_rate() matches the last one.
 257  *
 258  * This assumes that clk_ops.determine_rate or clk_ops.round_rate won't
 259  * modify the requested rate, which is our case in clk_dummy_rate_ops.
 260  */
 261 static void clk_test_set_set_get_rate(struct kunit *test)
 262 {
 263         struct clk_dummy_context *ctx = test->priv;
 264         struct clk_hw *hw = &ctx->hw;
 265         struct clk *clk = clk_hw_get_clk(hw, NULL);
 266         unsigned long rate;
 267
 268         KUNIT_ASSERT_EQ(test,
 269                         clk_set_rate(clk, DUMMY_CLOCK_RATE_1),
 270                         0);
 271
 272         KUNIT_ASSERT_EQ(test,
 273                         clk_set_rate(clk, DUMMY_CLOCK_RATE_2),
 274                         0);
 275
 276         rate = clk_get_rate(clk);
 277         KUNIT_ASSERT_GT(test, rate, 0);
 278         KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_2);
 279
 280         clk_put(clk);
 281 }
 282
 283 /*
 284  * Test that clk_round_rate and clk_set_rate are consitent and will
 285  * return the same frequency.
 286  */
 287 static void clk_test_round_set_get_rate(struct kunit *test)
 288 {
 289         struct clk_dummy_context *ctx = test->priv;
 290         struct clk_hw *hw = &ctx->hw;
 291         struct clk *clk = clk_hw_get_clk(hw, NULL);
 292         unsigned long set_rate;
 293         long rounded_rate;
 294
 295         rounded_rate = clk_round_rate(clk, DUMMY_CLOCK_RATE_1);
 296         KUNIT_ASSERT_GT(test, rounded_rate, 0);
 297         KUNIT_EXPECT_EQ(test, rounded_rate, DUMMY_CLOCK_RATE_1);
 298
 299         KUNIT_ASSERT_EQ(test,
 300                         clk_set_rate(clk, DUMMY_CLOCK_RATE_1),
 301                         0);
 302
 303         set_rate = clk_get_rate(clk);
 304         KUNIT_ASSERT_GT(test, set_rate, 0);
 305         KUNIT_EXPECT_EQ(test, rounded_rate, set_rate);
 306
 307         clk_put(clk);
 308 }
 309
 310 static struct kunit_case clk_test_cases[] = {
 311         KUNIT_CASE(clk_test_get_rate),
 312         KUNIT_CASE(clk_test_set_get_rate),
 313         KUNIT_CASE(clk_test_set_set_get_rate),
 314         KUNIT_CASE(clk_test_round_set_get_rate),
 315         {}
 316 };
 317
 318 /*
 319  * Test suite for a basic rate clock, without any parent.
 320  *
 321  * These tests exercise the rate API with simple scenarios
 322  */
 323 static struct kunit_suite clk_test_suite = {
 324         .name = "clk-test",
 325         .init = clk_test_init,
 326         .exit = clk_test_exit,
 327         .test_cases = clk_test_cases,
 328 };
 329
 330 static int clk_uncached_test_init(struct kunit *test)
 331 {
 332         struct clk_dummy_context *ctx;
 333         int ret;
 334
 335         ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
 336         if (!ctx)
 337                 return -ENOMEM;
 338         test->priv = ctx;
 339
 340         ctx->rate = DUMMY_CLOCK_INIT_RATE;
 341         ctx->hw.init = CLK_HW_INIT_NO_PARENT("test-clk",
 342                                              &clk_dummy_rate_ops,
 343                                              CLK_GET_RATE_NOCACHE);
 344
 345         ret = clk_hw_register(NULL, &ctx->hw);
 346         if (ret)
 347                 return ret;
 348
 349         return 0;
 350 }
 351
 352 /*
 353  * Test that for an uncached clock, the clock framework doesn't cache
 354  * the rate and clk_get_rate() will return the underlying clock rate
 355  * even if it changed.
 356  */
 357 static void clk_test_uncached_get_rate(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         rate = clk_get_rate(clk);
 365         KUNIT_ASSERT_GT(test, rate, 0);
 366         KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_INIT_RATE);
 367
 368         /* We change the rate behind the clock framework's back */
 369         ctx->rate = DUMMY_CLOCK_RATE_1;
 370         rate = clk_get_rate(clk);
 371         KUNIT_ASSERT_GT(test, rate, 0);
 372         KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_1);
 373
 374         clk_put(clk);
 375 }
 376
 377 /*
 378  * Test that for an uncached clock, clk_set_rate_range() will work
 379  * properly if the rate hasn't changed.
 380  */
 381 static void clk_test_uncached_set_range(struct kunit *test)
 382 {
 383         struct clk_dummy_context *ctx = test->priv;
 384         struct clk_hw *hw = &ctx->hw;
 385         struct clk *clk = clk_hw_get_clk(hw, NULL);
 386         unsigned long rate;
 387
 388         KUNIT_ASSERT_EQ(test,
 389                         clk_set_rate_range(clk,
 390                                            DUMMY_CLOCK_RATE_1,
 391                                            DUMMY_CLOCK_RATE_2),
 392                         0);
 393
 394         rate = clk_get_rate(clk);
 395         KUNIT_ASSERT_GT(test, rate, 0);
 396         KUNIT_EXPECT_GE(test, rate, DUMMY_CLOCK_RATE_1);
 397         KUNIT_EXPECT_LE(test, rate, DUMMY_CLOCK_RATE_2);
 398
 399         clk_put(clk);
 400 }
 401
 402 /*
 403  * Test that for an uncached clock, clk_set_rate_range() will work
 404  * properly if the rate has changed in hardware.
 405  *
 406  * In this case, it means that if the rate wasn't initially in the range
 407  * we're trying to set, but got changed at some point into the range
 408  * without the kernel knowing about it, its rate shouldn't be affected.
 409  */
 410 static void clk_test_uncached_updated_rate_set_range(struct kunit *test)
 411 {
 412         struct clk_dummy_context *ctx = test->priv;
 413         struct clk_hw *hw = &ctx->hw;
 414         struct clk *clk = clk_hw_get_clk(hw, NULL);
 415         unsigned long rate;
 416
 417         /* We change the rate behind the clock framework's back */
 418         ctx->rate = DUMMY_CLOCK_RATE_1 + 1000;
 419         KUNIT_ASSERT_EQ(test,
 420                         clk_set_rate_range(clk,
 421                                            DUMMY_CLOCK_RATE_1,
 422                                            DUMMY_CLOCK_RATE_2),
 423                         0);
 424
 425         rate = clk_get_rate(clk);
 426         KUNIT_ASSERT_GT(test, rate, 0);
 427         KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_1 + 1000);
 428
 429         clk_put(clk);
 430 }
 431
 432 static struct kunit_case clk_uncached_test_cases[] = {
 433         KUNIT_CASE(clk_test_uncached_get_rate),
 434         KUNIT_CASE(clk_test_uncached_set_range),
 435         KUNIT_CASE(clk_test_uncached_updated_rate_set_range),
 436         {}
 437 };
 438
 439 /*
 440  * Test suite for a basic, uncached, rate clock, without any parent.
 441  *
 442  * These tests exercise the rate API with simple scenarios
 443  */
 444 static struct kunit_suite clk_uncached_test_suite = {
 445         .name = "clk-uncached-test",
 446         .init = clk_uncached_test_init,
 447         .exit = clk_test_exit,
 448         .test_cases = clk_uncached_test_cases,
 449 };
 450
 451 static int
 452 clk_multiple_parents_mux_test_init(struct kunit *test)
 453 {
 454         struct clk_multiple_parent_ctx *ctx;
 455         const char *parents[2] = { "parent-0", "parent-1"};
 456         int ret;
 457
 458         ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
 459         if (!ctx)
 460                 return -ENOMEM;
 461         test->priv = ctx;
 462
 463         ctx->parents_ctx[0].hw.init = CLK_HW_INIT_NO_PARENT("parent-0",
 464                                                             &clk_dummy_rate_ops,
 465                                                             0);
 466         ctx->parents_ctx[0].rate = DUMMY_CLOCK_RATE_1;
 467         ret = clk_hw_register(NULL, &ctx->parents_ctx[0].hw);
 468         if (ret)
 469                 return ret;
 470
 471         ctx->parents_ctx[1].hw.init = CLK_HW_INIT_NO_PARENT("parent-1",
 472                                                             &clk_dummy_rate_ops,
 473                                                             0);
 474         ctx->parents_ctx[1].rate = DUMMY_CLOCK_RATE_2;
 475         ret = clk_hw_register(NULL, &ctx->parents_ctx[1].hw);
 476         if (ret)
 477                 return ret;
 478
 479         ctx->current_parent = 0;
 480         ctx->hw.init = CLK_HW_INIT_PARENTS("test-mux", parents,
 481                                            &clk_multiple_parents_mux_ops,
 482                                            CLK_SET_RATE_PARENT);
 483         ret = clk_hw_register(NULL, &ctx->hw);
 484         if (ret)
 485                 return ret;
 486
 487         return 0;
 488 }
 489
 490 static void
 491 clk_multiple_parents_mux_test_exit(struct kunit *test)
 492 {
 493         struct clk_multiple_parent_ctx *ctx = test->priv;
 494
 495         clk_hw_unregister(&ctx->hw);
 496         clk_hw_unregister(&ctx->parents_ctx[0].hw);
 497         clk_hw_unregister(&ctx->parents_ctx[1].hw);
 498 }
 499
 500 /*
 501  * Test that for a clock with multiple parents, clk_get_parent()
 502  * actually returns the current one.
 503  */
 504 static void
 505 clk_test_multiple_parents_mux_get_parent(struct kunit *test)
 506 {
 507         struct clk_multiple_parent_ctx *ctx = test->priv;
 508         struct clk_hw *hw = &ctx->hw;
 509         struct clk *clk = clk_hw_get_clk(hw, NULL);
 510         struct clk *parent = clk_hw_get_clk(&ctx->parents_ctx[0].hw, NULL);
 511
 512         KUNIT_EXPECT_TRUE(test, clk_is_match(clk_get_parent(clk), parent));
 513
 514         clk_put(parent);
 515         clk_put(clk);
 516 }
 517
 518 /*
 519  * Test that for a clock with a multiple parents, clk_has_parent()
 520  * actually reports all of them as parents.
 521  */
 522 static void
 523 clk_test_multiple_parents_mux_has_parent(struct kunit *test)
 524 {
 525         struct clk_multiple_parent_ctx *ctx = test->priv;
 526         struct clk_hw *hw = &ctx->hw;
 527         struct clk *clk = clk_hw_get_clk(hw, NULL);
 528         struct clk *parent;
 529
 530         parent = clk_hw_get_clk(&ctx->parents_ctx[0].hw, NULL);
 531         KUNIT_EXPECT_TRUE(test, clk_has_parent(clk, parent));
 532         clk_put(parent);
 533
 534         parent = clk_hw_get_clk(&ctx->parents_ctx[1].hw, NULL);
 535         KUNIT_EXPECT_TRUE(test, clk_has_parent(clk, parent));
 536         clk_put(parent);
 537
 538         clk_put(clk);
 539 }
 540
 541 /*
 542  * Test that for a clock with a multiple parents, if we set a range on
 543  * that clock and the parent is changed, its rate after the reparenting
 544  * is still within the range we asked for.
 545  *
 546  * FIXME: clk_set_parent() only does the reparenting but doesn't
 547  * reevaluate whether the new clock rate is within its boundaries or
 548  * not.
 549  */
 550 static void
 551 clk_test_multiple_parents_mux_set_range_set_parent_get_rate(struct kunit *test)
 552 {
 553         struct clk_multiple_parent_ctx *ctx = test->priv;
 554         struct clk_hw *hw = &ctx->hw;
 555         struct clk *clk = clk_hw_get_clk(hw, NULL);
 556         struct clk *parent1, *parent2;
 557         unsigned long rate;
 558         int ret;
 559
 560         kunit_skip(test, "This needs to be fixed in the core.");
 561
 562         parent1 = clk_hw_get_clk(&ctx->parents_ctx[0].hw, NULL);
 563         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent1);
 564         KUNIT_ASSERT_TRUE(test, clk_is_match(clk_get_parent(clk), parent1));
 565
 566         parent2 = clk_hw_get_clk(&ctx->parents_ctx[1].hw, NULL);
 567         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent2);
 568
 569         ret = clk_set_rate(parent1, DUMMY_CLOCK_RATE_1);
 570         KUNIT_ASSERT_EQ(test, ret, 0);
 571
 572         ret = clk_set_rate(parent2, DUMMY_CLOCK_RATE_2);
 573         KUNIT_ASSERT_EQ(test, ret, 0);
 574
 575         ret = clk_set_rate_range(clk,
 576                                  DUMMY_CLOCK_RATE_1 - 1000,
 577                                  DUMMY_CLOCK_RATE_1 + 1000);
 578         KUNIT_ASSERT_EQ(test, ret, 0);
 579
 580         ret = clk_set_parent(clk, parent2);
 581         KUNIT_ASSERT_EQ(test, ret, 0);
 582
 583         rate = clk_get_rate(clk);
 584         KUNIT_ASSERT_GT(test, rate, 0);
 585         KUNIT_EXPECT_GE(test, rate, DUMMY_CLOCK_RATE_1 - 1000);
 586         KUNIT_EXPECT_LE(test, rate, DUMMY_CLOCK_RATE_1 + 1000);
 587
 588         clk_put(parent2);
 589         clk_put(parent1);
 590         clk_put(clk);
 591 }
 592
 593 static struct kunit_case clk_multiple_parents_mux_test_cases[] = {
 594         KUNIT_CASE(clk_test_multiple_parents_mux_get_parent),
 595         KUNIT_CASE(clk_test_multiple_parents_mux_has_parent),
 596         KUNIT_CASE(clk_test_multiple_parents_mux_set_range_set_parent_get_rate),
 597         {}
 598 };
 599
 600 /*
 601  * Test suite for a basic mux clock with two parents, with
 602  * CLK_SET_RATE_PARENT on the child.
 603  *
 604  * These tests exercise the consumer API and check that the state of the
 605  * child and parents are sane and consistent.
 606  */
 607 static struct kunit_suite
 608 clk_multiple_parents_mux_test_suite = {
 609         .name = "clk-multiple-parents-mux-test",
 610         .init = clk_multiple_parents_mux_test_init,
 611         .exit = clk_multiple_parents_mux_test_exit,
 612         .test_cases = clk_multiple_parents_mux_test_cases,
 613 };
 614
 615 static int
 616 clk_orphan_transparent_multiple_parent_mux_test_init(struct kunit *test)
 617 {
 618         struct clk_multiple_parent_ctx *ctx;
 619         const char *parents[2] = { "missing-parent", "proper-parent"};
 620         int ret;
 621
 622         ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
 623         if (!ctx)
 624                 return -ENOMEM;
 625         test->priv = ctx;
 626
 627         ctx->parents_ctx[1].hw.init = CLK_HW_INIT_NO_PARENT("proper-parent",
 628                                                             &clk_dummy_rate_ops,
 629                                                             0);
 630         ctx->parents_ctx[1].rate = DUMMY_CLOCK_INIT_RATE;
 631         ret = clk_hw_register(NULL, &ctx->parents_ctx[1].hw);
 632         if (ret)
 633                 return ret;
 634
 635         ctx->hw.init = CLK_HW_INIT_PARENTS("test-orphan-mux", parents,
 636                                            &clk_multiple_parents_mux_ops,
 637                                            CLK_SET_RATE_PARENT);
 638         ret = clk_hw_register(NULL, &ctx->hw);
 639         if (ret)
 640                 return ret;
 641
 642         return 0;
 643 }
 644
 645 static void
 646 clk_orphan_transparent_multiple_parent_mux_test_exit(struct kunit *test)
 647 {
 648         struct clk_multiple_parent_ctx *ctx = test->priv;
 649
 650         clk_hw_unregister(&ctx->hw);
 651         clk_hw_unregister(&ctx->parents_ctx[1].hw);
 652 }
 653
 654 /*
 655  * Test that, for a mux whose current parent hasn't been registered yet and is
 656  * thus orphan, clk_get_parent() will return NULL.
 657  */
 658 static void
 659 clk_test_orphan_transparent_multiple_parent_mux_get_parent(struct kunit *test)
 660 {
 661         struct clk_multiple_parent_ctx *ctx = test->priv;
 662         struct clk_hw *hw = &ctx->hw;
 663         struct clk *clk = clk_hw_get_clk(hw, NULL);
 664
 665         KUNIT_EXPECT_PTR_EQ(test, clk_get_parent(clk), NULL);
 666
 667         clk_put(clk);
 668 }
 669
 670 /*
 671  * Test that, for a mux whose current parent hasn't been registered yet,
 672  * calling clk_set_parent() to a valid parent will properly update the
 673  * mux parent and its orphan status.
 674  */
 675 static void
 676 clk_test_orphan_transparent_multiple_parent_mux_set_parent(struct kunit *test)
 677 {
 678         struct clk_multiple_parent_ctx *ctx = test->priv;
 679         struct clk_hw *hw = &ctx->hw;
 680         struct clk *clk = clk_hw_get_clk(hw, NULL);
 681         struct clk *parent, *new_parent;
 682         int ret;
 683
 684         parent = clk_hw_get_clk(&ctx->parents_ctx[1].hw, NULL);
 685         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent);
 686
 687         ret = clk_set_parent(clk, parent);
 688         KUNIT_ASSERT_EQ(test, ret, 0);
 689
 690         new_parent = clk_get_parent(clk);
 691         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent);
 692         KUNIT_EXPECT_TRUE(test, clk_is_match(parent, new_parent));
 693
 694         clk_put(parent);
 695         clk_put(clk);
 696 }
 697
 698 /*
 699  * Test that, for a mux that started orphan but got switched to a valid
 700  * parent, calling clk_drop_range() on the mux won't affect the parent
 701  * rate.
 702  */
 703 static void
 704 clk_test_orphan_transparent_multiple_parent_mux_set_parent_drop_range(struct kunit *test)
 705 {
 706         struct clk_multiple_parent_ctx *ctx = test->priv;
 707         struct clk_hw *hw = &ctx->hw;
 708         struct clk *clk = clk_hw_get_clk(hw, NULL);
 709         struct clk *parent;
 710         unsigned long parent_rate, new_parent_rate;
 711         int ret;
 712
 713         parent = clk_hw_get_clk(&ctx->parents_ctx[1].hw, NULL);
 714         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent);
 715
 716         parent_rate = clk_get_rate(parent);
 717         KUNIT_ASSERT_GT(test, parent_rate, 0);
 718
 719         ret = clk_set_parent(clk, parent);
 720         KUNIT_ASSERT_EQ(test, ret, 0);
 721
 722         ret = clk_drop_range(clk);
 723         KUNIT_ASSERT_EQ(test, ret, 0);
 724
 725         new_parent_rate = clk_get_rate(clk);
 726         KUNIT_ASSERT_GT(test, new_parent_rate, 0);
 727         KUNIT_EXPECT_EQ(test, parent_rate, new_parent_rate);
 728
 729         clk_put(parent);
 730         clk_put(clk);
 731 }
 732
 733 /*
 734  * Test that, for a mux that started orphan but got switched to a valid
 735  * parent, the rate of the mux and its new parent are consistent.
 736  */
 737 static void
 738 clk_test_orphan_transparent_multiple_parent_mux_set_parent_get_rate(struct kunit *test)
 739 {
 740         struct clk_multiple_parent_ctx *ctx = test->priv;
 741         struct clk_hw *hw = &ctx->hw;
 742         struct clk *clk = clk_hw_get_clk(hw, NULL);
 743         struct clk *parent;
 744         unsigned long parent_rate, rate;
 745         int ret;
 746
 747         parent = clk_hw_get_clk(&ctx->parents_ctx[1].hw, NULL);
 748         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent);
 749
 750         parent_rate = clk_get_rate(parent);
 751         KUNIT_ASSERT_GT(test, parent_rate, 0);
 752
 753         ret = clk_set_parent(clk, parent);
 754         KUNIT_ASSERT_EQ(test, ret, 0);
 755
 756         rate = clk_get_rate(clk);
 757         KUNIT_ASSERT_GT(test, rate, 0);
 758         KUNIT_EXPECT_EQ(test, parent_rate, rate);
 759
 760         clk_put(parent);
 761         clk_put(clk);
 762 }
 763
 764 /*
 765  * Test that, for a mux that started orphan but got switched to a valid
 766  * parent, calling clk_put() on the mux won't affect the parent rate.
 767  */
 768 static void
 769 clk_test_orphan_transparent_multiple_parent_mux_set_parent_put(struct kunit *test)
 770 {
 771         struct clk_multiple_parent_ctx *ctx = test->priv;
 772         struct clk *clk, *parent;
 773         unsigned long parent_rate, new_parent_rate;
 774         int ret;
 775
 776         parent = clk_hw_get_clk(&ctx->parents_ctx[1].hw, NULL);
 777         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent);
 778
 779         clk = clk_hw_get_clk(&ctx->hw, NULL);
 780         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, clk);
 781
 782         parent_rate = clk_get_rate(parent);
 783         KUNIT_ASSERT_GT(test, parent_rate, 0);
 784
 785         ret = clk_set_parent(clk, parent);
 786         KUNIT_ASSERT_EQ(test, ret, 0);
 787
 788         clk_put(clk);
 789
 790         new_parent_rate = clk_get_rate(parent);
 791         KUNIT_ASSERT_GT(test, new_parent_rate, 0);
 792         KUNIT_EXPECT_EQ(test, parent_rate, new_parent_rate);
 793
 794         clk_put(parent);
 795 }
 796
 797 /*
 798  * Test that, for a mux that started orphan but got switched to a valid
 799  * parent, calling clk_set_rate_range() will affect the parent state if
 800  * its rate is out of range.
 801  */
 802 static void
 803 clk_test_orphan_transparent_multiple_parent_mux_set_parent_set_range_modified(struct kunit *test)
 804 {
 805         struct clk_multiple_parent_ctx *ctx = test->priv;
 806         struct clk_hw *hw = &ctx->hw;
 807         struct clk *clk = clk_hw_get_clk(hw, NULL);
 808         struct clk *parent;
 809         unsigned long rate;
 810         int ret;
 811
 812         parent = clk_hw_get_clk(&ctx->parents_ctx[1].hw, NULL);
 813         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent);
 814
 815         ret = clk_set_parent(clk, parent);
 816         KUNIT_ASSERT_EQ(test, ret, 0);
 817
 818         ret = clk_set_rate_range(clk, DUMMY_CLOCK_RATE_1, DUMMY_CLOCK_RATE_2);
 819         KUNIT_ASSERT_EQ(test, ret, 0);
 820
 821         rate = clk_get_rate(clk);
 822         KUNIT_ASSERT_GT(test, rate, 0);
 823         KUNIT_EXPECT_GE(test, rate, DUMMY_CLOCK_RATE_1);
 824         KUNIT_EXPECT_LE(test, rate, DUMMY_CLOCK_RATE_2);
 825
 826         clk_put(parent);
 827         clk_put(clk);
 828 }
 829
 830 /*
 831  * Test that, for a mux that started orphan but got switched to a valid
 832  * parent, calling clk_set_rate_range() won't affect the parent state if
 833  * its rate is within range.
 834  */
 835 static void
 836 clk_test_orphan_transparent_multiple_parent_mux_set_parent_set_range_untouched(struct kunit *test)
 837 {
 838         struct clk_multiple_parent_ctx *ctx = test->priv;
 839         struct clk_hw *hw = &ctx->hw;
 840         struct clk *clk = clk_hw_get_clk(hw, NULL);
 841         struct clk *parent;
 842         unsigned long parent_rate, new_parent_rate;
 843         int ret;
 844
 845         parent = clk_hw_get_clk(&ctx->parents_ctx[1].hw, NULL);
 846         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent);
 847
 848         parent_rate = clk_get_rate(parent);
 849         KUNIT_ASSERT_GT(test, parent_rate, 0);
 850
 851         ret = clk_set_parent(clk, parent);
 852         KUNIT_ASSERT_EQ(test, ret, 0);
 853
 854         ret = clk_set_rate_range(clk,
 855                                  DUMMY_CLOCK_INIT_RATE - 1000,
 856                                  DUMMY_CLOCK_INIT_RATE + 1000);
 857         KUNIT_ASSERT_EQ(test, ret, 0);
 858
 859         new_parent_rate = clk_get_rate(parent);
 860         KUNIT_ASSERT_GT(test, new_parent_rate, 0);
 861         KUNIT_EXPECT_EQ(test, parent_rate, new_parent_rate);
 862
 863         clk_put(parent);
 864         clk_put(clk);
 865 }
 866
 867 /*
 868  * Test that, for a mux whose current parent hasn't been registered yet,
 869  * calling clk_set_rate_range() will succeed, and will be taken into
 870  * account when rounding a rate.
 871  */
 872 static void
 873 clk_test_orphan_transparent_multiple_parent_mux_set_range_round_rate(struct kunit *test)
 874 {
 875         struct clk_multiple_parent_ctx *ctx = test->priv;
 876         struct clk_hw *hw = &ctx->hw;
 877         struct clk *clk = clk_hw_get_clk(hw, NULL);
 878         long rate;
 879         int ret;
 880
 881         ret = clk_set_rate_range(clk, DUMMY_CLOCK_RATE_1, DUMMY_CLOCK_RATE_2);
 882         KUNIT_ASSERT_EQ(test, ret, 0);
 883
 884         rate = clk_round_rate(clk, DUMMY_CLOCK_RATE_1 - 1000);
 885         KUNIT_ASSERT_GT(test, rate, 0);
 886         KUNIT_EXPECT_GE(test, rate, DUMMY_CLOCK_RATE_1);
 887         KUNIT_EXPECT_LE(test, rate, DUMMY_CLOCK_RATE_2);
 888
 889         clk_put(clk);
 890 }
 891
 892 /*
 893  * Test that, for a mux that started orphan, was assigned and rate and
 894  * then got switched to a valid parent, its rate is eventually within
 895  * range.
 896  *
 897  * FIXME: Even though we update the rate as part of clk_set_parent(), we
 898  * don't evaluate whether that new rate is within range and needs to be
 899  * adjusted.
 900  */
 901 static void
 902 clk_test_orphan_transparent_multiple_parent_mux_set_range_set_parent_get_rate(struct kunit *test)
 903 {
 904         struct clk_multiple_parent_ctx *ctx = test->priv;
 905         struct clk_hw *hw = &ctx->hw;
 906         struct clk *clk = clk_hw_get_clk(hw, NULL);
 907         struct clk *parent;
 908         unsigned long rate;
 909         int ret;
 910
 911         kunit_skip(test, "This needs to be fixed in the core.");
 912
 913         clk_hw_set_rate_range(hw, DUMMY_CLOCK_RATE_1, DUMMY_CLOCK_RATE_2);
 914
 915         parent = clk_hw_get_clk(&ctx->parents_ctx[1].hw, NULL);
 916         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, parent);
 917
 918         ret = clk_set_parent(clk, parent);
 919         KUNIT_ASSERT_EQ(test, ret, 0);
 920
 921         rate = clk_get_rate(clk);
 922         KUNIT_ASSERT_GT(test, rate, 0);
 923         KUNIT_EXPECT_GE(test, rate, DUMMY_CLOCK_RATE_1);
 924         KUNIT_EXPECT_LE(test, rate, DUMMY_CLOCK_RATE_2);
 925
 926         clk_put(parent);
 927         clk_put(clk);
 928 }
 929
 930 static struct kunit_case clk_orphan_transparent_multiple_parent_mux_test_cases[] = {
 931         KUNIT_CASE(clk_test_orphan_transparent_multiple_parent_mux_get_parent),
 932         KUNIT_CASE(clk_test_orphan_transparent_multiple_parent_mux_set_parent),
 933         KUNIT_CASE(clk_test_orphan_transparent_multiple_parent_mux_set_parent_drop_range),
 934         KUNIT_CASE(clk_test_orphan_transparent_multiple_parent_mux_set_parent_get_rate),
 935         KUNIT_CASE(clk_test_orphan_transparent_multiple_parent_mux_set_parent_put),
 936         KUNIT_CASE(clk_test_orphan_transparent_multiple_parent_mux_set_parent_set_range_modified),
 937         KUNIT_CASE(clk_test_orphan_transparent_multiple_parent_mux_set_parent_set_range_untouched),
 938         KUNIT_CASE(clk_test_orphan_transparent_multiple_parent_mux_set_range_round_rate),
 939         KUNIT_CASE(clk_test_orphan_transparent_multiple_parent_mux_set_range_set_parent_get_rate),
 940         {}
 941 };
 942
 943 /*
 944  * Test suite for a basic mux clock with two parents. The default parent
 945  * isn't registered, only the second parent is. By default, the clock
 946  * will thus be orphan.
 947  *
 948  * These tests exercise the behaviour of the consumer API when dealing
 949  * with an orphan clock, and how we deal with the transition to a valid
 950  * parent.
 951  */
 952 static struct kunit_suite clk_orphan_transparent_multiple_parent_mux_test_suite = {
 953         .name = "clk-orphan-transparent-multiple-parent-mux-test",
 954         .init = clk_orphan_transparent_multiple_parent_mux_test_init,
 955         .exit = clk_orphan_transparent_multiple_parent_mux_test_exit,
 956         .test_cases = clk_orphan_transparent_multiple_parent_mux_test_cases,
 957 };
 958
 959 struct clk_single_parent_ctx {
 960         struct clk_dummy_context parent_ctx;
 961         struct clk_hw hw;
 962 };
 963
 964 static int clk_single_parent_mux_test_init(struct kunit *test)
 965 {
 966         struct clk_single_parent_ctx *ctx;
 967         int ret;
 968
 969         ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
 970         if (!ctx)
 971                 return -ENOMEM;
 972         test->priv = ctx;
 973
 974         ctx->parent_ctx.rate = DUMMY_CLOCK_INIT_RATE;
 975         ctx->parent_ctx.hw.init =
 976                 CLK_HW_INIT_NO_PARENT("parent-clk",
 977                                       &clk_dummy_rate_ops,
 978                                       0);
 979
 980         ret = clk_hw_register(NULL, &ctx->parent_ctx.hw);
 981         if (ret)
 982                 return ret;
 983
 984         ctx->hw.init = CLK_HW_INIT("test-clk", "parent-clk",
 985                                    &clk_dummy_single_parent_ops,
 986                                    CLK_SET_RATE_PARENT);
 987
 988         ret = clk_hw_register(NULL, &ctx->hw);
 989         if (ret)
 990                 return ret;
 991
 992         return 0;
 993 }
 994
 995 static void
 996 clk_single_parent_mux_test_exit(struct kunit *test)
 997 {
 998         struct clk_single_parent_ctx *ctx = test->priv;
 999
1000         clk_hw_unregister(&ctx->hw);
1001         clk_hw_unregister(&ctx->parent_ctx.hw);
1002 }
1003
1004 /*
1005  * Test that for a clock with a single parent, clk_get_parent() actually
1006  * returns the parent.
1007  */
1008 static void
1009 clk_test_single_parent_mux_get_parent(struct kunit *test)
1010 {
1011         struct clk_single_parent_ctx *ctx = test->priv;
1012         struct clk_hw *hw = &ctx->hw;
1013         struct clk *clk = clk_hw_get_clk(hw, NULL);
1014         struct clk *parent = clk_hw_get_clk(&ctx->parent_ctx.hw, NULL);
1015
1016         KUNIT_EXPECT_TRUE(test, clk_is_match(clk_get_parent(clk), parent));
1017
1018         clk_put(parent);
1019         clk_put(clk);
1020 }
1021
1022 /*
1023  * Test that for a clock with a single parent, clk_has_parent() actually
1024  * reports it as a parent.
1025  */
1026 static void
1027 clk_test_single_parent_mux_has_parent(struct kunit *test)
1028 {
1029         struct clk_single_parent_ctx *ctx = test->priv;
1030         struct clk_hw *hw = &ctx->hw;
1031         struct clk *clk = clk_hw_get_clk(hw, NULL);
1032         struct clk *parent = clk_hw_get_clk(&ctx->parent_ctx.hw, NULL);
1033
1034         KUNIT_EXPECT_TRUE(test, clk_has_parent(clk, parent));
1035
1036         clk_put(parent);
1037         clk_put(clk);
1038 }
1039
1040 /*
1041  * Test that for a clock that can't modify its rate and with a single
1042  * parent, if we set disjoints range on the parent and then the child,
1043  * the second will return an error.
1044  *
1045  * FIXME: clk_set_rate_range() only considers the current clock when
1046  * evaluating whether ranges are disjoints and not the upstream clocks
1047  * ranges.
1048  */
1049 static void
1050 clk_test_single_parent_mux_set_range_disjoint_child_last(struct kunit *test)
1051 {
1052         struct clk_single_parent_ctx *ctx = test->priv;
1053         struct clk_hw *hw = &ctx->hw;
1054         struct clk *clk = clk_hw_get_clk(hw, NULL);
1055         struct clk *parent;
1056         int ret;
1057
1058         kunit_skip(test, "This needs to be fixed in the core.");
1059
1060         parent = clk_get_parent(clk);
1061         KUNIT_ASSERT_PTR_NE(test, parent, NULL);
1062
1063         ret = clk_set_rate_range(parent, 1000, 2000);
1064         KUNIT_ASSERT_EQ(test, ret, 0);
1065
1066         ret = clk_set_rate_range(clk, 3000, 4000);
1067         KUNIT_EXPECT_LT(test, ret, 0);
1068
1069         clk_put(clk);
1070 }
1071
1072 /*
1073  * Test that for a clock that can't modify its rate and with a single
1074  * parent, if we set disjoints range on the child and then the parent,
1075  * the second will return an error.
1076  *
1077  * FIXME: clk_set_rate_range() only considers the current clock when
1078  * evaluating whether ranges are disjoints and not the downstream clocks
1079  * ranges.
1080  */
1081 static void
1082 clk_test_single_parent_mux_set_range_disjoint_parent_last(struct kunit *test)
1083 {
1084         struct clk_single_parent_ctx *ctx = test->priv;
1085         struct clk_hw *hw = &ctx->hw;
1086         struct clk *clk = clk_hw_get_clk(hw, NULL);
1087         struct clk *parent;
1088         int ret;
1089
1090         kunit_skip(test, "This needs to be fixed in the core.");
1091
1092         parent = clk_get_parent(clk);
1093         KUNIT_ASSERT_PTR_NE(test, parent, NULL);
1094
1095         ret = clk_set_rate_range(clk, 1000, 2000);
1096         KUNIT_ASSERT_EQ(test, ret, 0);
1097
1098         ret = clk_set_rate_range(parent, 3000, 4000);
1099         KUNIT_EXPECT_LT(test, ret, 0);
1100
1101         clk_put(clk);
1102 }
1103
1104 /*
1105  * Test that for a clock that can't modify its rate and with a single
1106  * parent, if we set a range on the parent and then call
1107  * clk_round_rate(), the boundaries of the parent are taken into
1108  * account.
1109  */
1110 static void
1111 clk_test_single_parent_mux_set_range_round_rate_parent_only(struct kunit *test)
1112 {
1113         struct clk_single_parent_ctx *ctx = test->priv;
1114         struct clk_hw *hw = &ctx->hw;
1115         struct clk *clk = clk_hw_get_clk(hw, NULL);
1116         struct clk *parent;
1117         long rate;
1118         int ret;
1119
1120         parent = clk_get_parent(clk);
1121         KUNIT_ASSERT_PTR_NE(test, parent, NULL);
1122
1123         ret = clk_set_rate_range(parent, DUMMY_CLOCK_RATE_1, DUMMY_CLOCK_RATE_2);
1124         KUNIT_ASSERT_EQ(test, ret, 0);
1125
1126         rate = clk_round_rate(clk, DUMMY_CLOCK_RATE_1 - 1000);
1127         KUNIT_ASSERT_GT(test, rate, 0);
1128         KUNIT_EXPECT_GE(test, rate, DUMMY_CLOCK_RATE_1);
1129         KUNIT_EXPECT_LE(test, rate, DUMMY_CLOCK_RATE_2);
1130
1131         clk_put(clk);
1132 }
1133
1134 /*
1135  * Test that for a clock that can't modify its rate and with a single
1136  * parent, if we set a range on the parent and a more restrictive one on
1137  * the child, and then call clk_round_rate(), the boundaries of the
1138  * two clocks are taken into account.
1139  */
1140 static void
1141 clk_test_single_parent_mux_set_range_round_rate_child_smaller(struct kunit *test)
1142 {
1143         struct clk_single_parent_ctx *ctx = test->priv;
1144         struct clk_hw *hw = &ctx->hw;
1145         struct clk *clk = clk_hw_get_clk(hw, NULL);
1146         struct clk *parent;
1147         long rate;
1148         int ret;
1149
1150         parent = clk_get_parent(clk);
1151         KUNIT_ASSERT_PTR_NE(test, parent, NULL);
1152
1153         ret = clk_set_rate_range(parent, DUMMY_CLOCK_RATE_1, DUMMY_CLOCK_RATE_2);
1154         KUNIT_ASSERT_EQ(test, ret, 0);
1155
1156         ret = clk_set_rate_range(clk, DUMMY_CLOCK_RATE_1 + 1000, DUMMY_CLOCK_RATE_2 - 1000);
1157         KUNIT_ASSERT_EQ(test, ret, 0);
1158
1159         rate = clk_round_rate(clk, DUMMY_CLOCK_RATE_1 - 1000);
1160         KUNIT_ASSERT_GT(test, rate, 0);
1161         KUNIT_EXPECT_GE(test, rate, DUMMY_CLOCK_RATE_1 + 1000);
1162         KUNIT_EXPECT_LE(test, rate, DUMMY_CLOCK_RATE_2 - 1000);
1163
1164         rate = clk_round_rate(clk, DUMMY_CLOCK_RATE_2 + 1000);
1165         KUNIT_ASSERT_GT(test, rate, 0);
1166         KUNIT_EXPECT_GE(test, rate, DUMMY_CLOCK_RATE_1 + 1000);
1167         KUNIT_EXPECT_LE(test, rate, DUMMY_CLOCK_RATE_2 - 1000);
1168
1169         clk_put(clk);
1170 }
1171
1172 /*
1173  * Test that for a clock that can't modify its rate and with a single
1174  * parent, if we set a range on the child and a more restrictive one on
1175  * the parent, and then call clk_round_rate(), the boundaries of the
1176  * two clocks are taken into account.
1177  */
1178 static void
1179 clk_test_single_parent_mux_set_range_round_rate_parent_smaller(struct kunit *test)
1180 {
1181         struct clk_single_parent_ctx *ctx = test->priv;
1182         struct clk_hw *hw = &ctx->hw;
1183         struct clk *clk = clk_hw_get_clk(hw, NULL);
1184         struct clk *parent;
1185         long rate;
1186         int ret;
1187
1188         parent = clk_get_parent(clk);
1189         KUNIT_ASSERT_PTR_NE(test, parent, NULL);
1190
1191         ret = clk_set_rate_range(parent, DUMMY_CLOCK_RATE_1 + 1000, DUMMY_CLOCK_RATE_2 - 1000);
1192         KUNIT_ASSERT_EQ(test, ret, 0);
1193
1194         ret = clk_set_rate_range(clk, DUMMY_CLOCK_RATE_1, DUMMY_CLOCK_RATE_2);
1195         KUNIT_ASSERT_EQ(test, ret, 0);
1196
1197         rate = clk_round_rate(clk, DUMMY_CLOCK_RATE_1 - 1000);
1198         KUNIT_ASSERT_GT(test, rate, 0);
1199         KUNIT_EXPECT_GE(test, rate, DUMMY_CLOCK_RATE_1 + 1000);
1200         KUNIT_EXPECT_LE(test, rate, DUMMY_CLOCK_RATE_2 - 1000);
1201
1202         rate = clk_round_rate(clk, DUMMY_CLOCK_RATE_2 + 1000);
1203         KUNIT_ASSERT_GT(test, rate, 0);
1204         KUNIT_EXPECT_GE(test, rate, DUMMY_CLOCK_RATE_1 + 1000);
1205         KUNIT_EXPECT_LE(test, rate, DUMMY_CLOCK_RATE_2 - 1000);
1206
1207         clk_put(clk);
1208 }
1209
1210 static struct kunit_case clk_single_parent_mux_test_cases[] = {
1211         KUNIT_CASE(clk_test_single_parent_mux_get_parent),
1212         KUNIT_CASE(clk_test_single_parent_mux_has_parent),
1213         KUNIT_CASE(clk_test_single_parent_mux_set_range_disjoint_child_last),
1214         KUNIT_CASE(clk_test_single_parent_mux_set_range_disjoint_parent_last),
1215         KUNIT_CASE(clk_test_single_parent_mux_set_range_round_rate_child_smaller),
1216         KUNIT_CASE(clk_test_single_parent_mux_set_range_round_rate_parent_only),
1217         KUNIT_CASE(clk_test_single_parent_mux_set_range_round_rate_parent_smaller),
1218         {}
1219 };
1220
1221 /*
1222  * Test suite for a basic mux clock with one parent, with
1223  * CLK_SET_RATE_PARENT on the child.
1224  *
1225  * These tests exercise the consumer API and check that the state of the
1226  * child and parent are sane and consistent.
1227  */
1228 static struct kunit_suite
1229 clk_single_parent_mux_test_suite = {
1230         .name = "clk-single-parent-mux-test",
1231         .init = clk_single_parent_mux_test_init,
1232         .exit = clk_single_parent_mux_test_exit,
1233         .test_cases = clk_single_parent_mux_test_cases,
1234 };
1235
1236 static int clk_orphan_transparent_single_parent_mux_test_init(struct kunit *test)
1237 {
1238         struct clk_single_parent_ctx *ctx;
1239         struct clk_init_data init = { };
1240         const char * const parents[] = { "orphan_parent" };
1241         int ret;
1242
1243         ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
1244         if (!ctx)
1245                 return -ENOMEM;
1246         test->priv = ctx;
1247
1248         init.name = "test_orphan_dummy_parent";
1249         init.ops = &clk_dummy_single_parent_ops;
1250         init.parent_names = parents;
1251         init.num_parents = ARRAY_SIZE(parents);
1252         init.flags = CLK_SET_RATE_PARENT;
1253         ctx->hw.init = &init;
1254
1255         ret = clk_hw_register(NULL, &ctx->hw);
1256         if (ret)
1257                 return ret;
1258
1259         memset(&init, 0, sizeof(init));
1260         init.name = "orphan_parent";
1261         init.ops = &clk_dummy_rate_ops;
1262         ctx->parent_ctx.hw.init = &init;
1263         ctx->parent_ctx.rate = DUMMY_CLOCK_INIT_RATE;
1264
1265         ret = clk_hw_register(NULL, &ctx->parent_ctx.hw);
1266         if (ret)
1267                 return ret;
1268
1269         return 0;
1270 }
1271
1272 /*
1273  * Test that a mux-only clock, with an initial rate within a range,
1274  * will still have the same rate after the range has been enforced.
1275  *
1276  * See:
1277  * https://lore.kernel.org/linux-clk/7720158d-10a7-a17b-73a4-a8615c9c6d5c@collabora.com/
1278  */
1279 static void clk_test_orphan_transparent_parent_mux_set_range(struct kunit *test)
1280 {
1281         struct clk_single_parent_ctx *ctx = test->priv;
1282         struct clk_hw *hw = &ctx->hw;
1283         struct clk *clk = clk_hw_get_clk(hw, NULL);
1284         unsigned long rate, new_rate;
1285
1286         rate = clk_get_rate(clk);
1287         KUNIT_ASSERT_GT(test, rate, 0);
1288
1289         KUNIT_ASSERT_EQ(test,
1290                         clk_set_rate_range(clk,
1291                                            ctx->parent_ctx.rate - 1000,
1292                                            ctx->parent_ctx.rate + 1000),
1293                         0);
1294
1295         new_rate = clk_get_rate(clk);
1296         KUNIT_ASSERT_GT(test, new_rate, 0);
1297         KUNIT_EXPECT_EQ(test, rate, new_rate);
1298
1299         clk_put(clk);
1300 }
1301
1302 static struct kunit_case clk_orphan_transparent_single_parent_mux_test_cases[] = {
1303         KUNIT_CASE(clk_test_orphan_transparent_parent_mux_set_range),
1304         {}
1305 };
1306
1307 /*
1308  * Test suite for a basic mux clock with one parent. The parent is
1309  * registered after its child. The clock will thus be an orphan when
1310  * registered, but will no longer be when the tests run.
1311  *
1312  * These tests make sure a clock that used to be orphan has a sane,
1313  * consistent, behaviour.
1314  */
1315 static struct kunit_suite clk_orphan_transparent_single_parent_test_suite = {
1316         .name = "clk-orphan-transparent-single-parent-test",
1317         .init = clk_orphan_transparent_single_parent_mux_test_init,
1318         .exit = clk_single_parent_mux_test_exit,
1319         .test_cases = clk_orphan_transparent_single_parent_mux_test_cases,
1320 };
1321
1322 struct clk_single_parent_two_lvl_ctx {
1323         struct clk_dummy_context parent_parent_ctx;
1324         struct clk_dummy_context parent_ctx;
1325         struct clk_hw hw;
1326 };
1327
1328 static int
1329 clk_orphan_two_level_root_last_test_init(struct kunit *test)
1330 {
1331         struct clk_single_parent_two_lvl_ctx *ctx;
1332         int ret;
1333
1334         ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
1335         if (!ctx)
1336                 return -ENOMEM;
1337         test->priv = ctx;
1338
1339         ctx->parent_ctx.hw.init =
1340                 CLK_HW_INIT("intermediate-parent",
1341                             "root-parent",
1342                             &clk_dummy_single_parent_ops,
1343                             CLK_SET_RATE_PARENT);
1344         ret = clk_hw_register(NULL, &ctx->parent_ctx.hw);
1345         if (ret)
1346                 return ret;
1347
1348         ctx->hw.init =
1349                 CLK_HW_INIT("test-clk", "intermediate-parent",
1350                             &clk_dummy_single_parent_ops,
1351                             CLK_SET_RATE_PARENT);
1352         ret = clk_hw_register(NULL, &ctx->hw);
1353         if (ret)
1354                 return ret;
1355
1356         ctx->parent_parent_ctx.rate = DUMMY_CLOCK_INIT_RATE;
1357         ctx->parent_parent_ctx.hw.init =
1358                 CLK_HW_INIT_NO_PARENT("root-parent",
1359                                       &clk_dummy_rate_ops,
1360                                       0);
1361         ret = clk_hw_register(NULL, &ctx->parent_parent_ctx.hw);
1362         if (ret)
1363                 return ret;
1364
1365         return 0;
1366 }
1367
1368 static void
1369 clk_orphan_two_level_root_last_test_exit(struct kunit *test)
1370 {
1371         struct clk_single_parent_two_lvl_ctx *ctx = test->priv;
1372
1373         clk_hw_unregister(&ctx->hw);
1374         clk_hw_unregister(&ctx->parent_ctx.hw);
1375         clk_hw_unregister(&ctx->parent_parent_ctx.hw);
1376 }
1377
1378 /*
1379  * Test that, for a clock whose parent used to be orphan, clk_get_rate()
1380  * will return the proper rate.
1381  */
1382 static void
1383 clk_orphan_two_level_root_last_test_get_rate(struct kunit *test)
1384 {
1385         struct clk_single_parent_two_lvl_ctx *ctx = test->priv;
1386         struct clk_hw *hw = &ctx->hw;
1387         struct clk *clk = clk_hw_get_clk(hw, NULL);
1388         unsigned long rate;
1389
1390         rate = clk_get_rate(clk);
1391         KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_INIT_RATE);
1392
1393         clk_put(clk);
1394 }
1395
1396 /*
1397  * Test that, for a clock whose parent used to be orphan,
1398  * clk_set_rate_range() won't affect its rate if it is already within
1399  * range.
1400  *
1401  * See (for Exynos 4210):
1402  * https://lore.kernel.org/linux-clk/366a0232-bb4a-c357-6aa8-636e398e05eb@samsung.com/
1403  */
1404 static void
1405 clk_orphan_two_level_root_last_test_set_range(struct kunit *test)
1406 {
1407         struct clk_single_parent_two_lvl_ctx *ctx = test->priv;
1408         struct clk_hw *hw = &ctx->hw;
1409         struct clk *clk = clk_hw_get_clk(hw, NULL);
1410         unsigned long rate;
1411         int ret;
1412
1413         ret = clk_set_rate_range(clk,
1414                                  DUMMY_CLOCK_INIT_RATE - 1000,
1415                                  DUMMY_CLOCK_INIT_RATE + 1000);
1416         KUNIT_ASSERT_EQ(test, ret, 0);
1417
1418         rate = clk_get_rate(clk);
1419         KUNIT_ASSERT_GT(test, rate, 0);
1420         KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_INIT_RATE);
1421
1422         clk_put(clk);
1423 }
1424
1425 static struct kunit_case
1426 clk_orphan_two_level_root_last_test_cases[] = {
1427         KUNIT_CASE(clk_orphan_two_level_root_last_test_get_rate),
1428         KUNIT_CASE(clk_orphan_two_level_root_last_test_set_range),
1429         {}
1430 };
1431
1432 /*
1433  * Test suite for a basic, transparent, clock with a parent that is also
1434  * such a clock. The parent's parent is registered last, while the
1435  * parent and its child are registered in that order. The intermediate
1436  * and leaf clocks will thus be orphan when registered, but the leaf
1437  * clock itself will always have its parent and will never be
1438  * reparented. Indeed, it's only orphan because its parent is.
1439  *
1440  * These tests exercise the behaviour of the consumer API when dealing
1441  * with an orphan clock, and how we deal with the transition to a valid
1442  * parent.
1443  */
1444 static struct kunit_suite
1445 clk_orphan_two_level_root_last_test_suite = {
1446         .name = "clk-orphan-two-level-root-last-test",
1447         .init = clk_orphan_two_level_root_last_test_init,
1448         .exit = clk_orphan_two_level_root_last_test_exit,
1449         .test_cases = clk_orphan_two_level_root_last_test_cases,
1450 };
1451
1452 /*
1453  * Test that clk_set_rate_range won't return an error for a valid range
1454  * and that it will make sure the rate of the clock is within the
1455  * boundaries.
1456  */
1457 static void clk_range_test_set_range(struct kunit *test)
1458 {
1459         struct clk_dummy_context *ctx = test->priv;
1460         struct clk_hw *hw = &ctx->hw;
1461         struct clk *clk = clk_hw_get_clk(hw, NULL);
1462         unsigned long rate;
1463
1464         KUNIT_ASSERT_EQ(test,
1465                         clk_set_rate_range(clk,
1466                                            DUMMY_CLOCK_RATE_1,
1467                                            DUMMY_CLOCK_RATE_2),
1468                         0);
1469
1470         rate = clk_get_rate(clk);
1471         KUNIT_ASSERT_GT(test, rate, 0);
1472         KUNIT_EXPECT_GE(test, rate, DUMMY_CLOCK_RATE_1);
1473         KUNIT_EXPECT_LE(test, rate, DUMMY_CLOCK_RATE_2);
1474
1475         clk_put(clk);
1476 }
1477
1478 /*
1479  * Test that calling clk_set_rate_range with a minimum rate higher than
1480  * the maximum rate returns an error.
1481  */
1482 static void clk_range_test_set_range_invalid(struct kunit *test)
1483 {
1484         struct clk_dummy_context *ctx = test->priv;
1485         struct clk_hw *hw = &ctx->hw;
1486         struct clk *clk = clk_hw_get_clk(hw, NULL);
1487
1488         KUNIT_EXPECT_LT(test,
1489                         clk_set_rate_range(clk,
1490                                            DUMMY_CLOCK_RATE_1 + 1000,
1491                                            DUMMY_CLOCK_RATE_1),
1492                         0);
1493
1494         clk_put(clk);
1495 }
1496
1497 /*
1498  * Test that users can't set multiple, disjoints, range that would be
1499  * impossible to meet.
1500  */
1501 static void clk_range_test_multiple_disjoints_range(struct kunit *test)
1502 {
1503         struct clk_dummy_context *ctx = test->priv;
1504         struct clk_hw *hw = &ctx->hw;
1505         struct clk *user1, *user2;
1506
1507         user1 = clk_hw_get_clk(hw, NULL);
1508         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, user1);
1509
1510         user2 = clk_hw_get_clk(hw, NULL);
1511         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, user2);
1512
1513         KUNIT_ASSERT_EQ(test,
1514                         clk_set_rate_range(user1, 1000, 2000),
1515                         0);
1516
1517         KUNIT_EXPECT_LT(test,
1518                         clk_set_rate_range(user2, 3000, 4000),
1519                         0);
1520
1521         clk_put(user2);
1522         clk_put(user1);
1523 }
1524
1525 /*
1526  * Test that if our clock has some boundaries and we try to round a rate
1527  * lower than the minimum, the returned rate will be within range.
1528  */
1529 static void clk_range_test_set_range_round_rate_lower(struct kunit *test)
1530 {
1531         struct clk_dummy_context *ctx = test->priv;
1532         struct clk_hw *hw = &ctx->hw;
1533         struct clk *clk = clk_hw_get_clk(hw, NULL);
1534         long rate;
1535
1536         KUNIT_ASSERT_EQ(test,
1537                         clk_set_rate_range(clk,
1538                                            DUMMY_CLOCK_RATE_1,
1539                                            DUMMY_CLOCK_RATE_2),
1540                         0);
1541
1542         rate = clk_round_rate(clk, DUMMY_CLOCK_RATE_1 - 1000);
1543         KUNIT_ASSERT_GT(test, rate, 0);
1544         KUNIT_EXPECT_GE(test, rate, DUMMY_CLOCK_RATE_1);
1545         KUNIT_EXPECT_LE(test, rate, DUMMY_CLOCK_RATE_2);
1546
1547         clk_put(clk);
1548 }
1549
1550 /*
1551  * Test that if our clock has some boundaries and we try to set a rate
1552  * higher than the maximum, the new rate will be within range.
1553  */
1554 static void clk_range_test_set_range_set_rate_lower(struct kunit *test)
1555 {
1556         struct clk_dummy_context *ctx = test->priv;
1557         struct clk_hw *hw = &ctx->hw;
1558         struct clk *clk = clk_hw_get_clk(hw, NULL);
1559         unsigned long rate;
1560
1561         KUNIT_ASSERT_EQ(test,
1562                         clk_set_rate_range(clk,
1563                                            DUMMY_CLOCK_RATE_1,
1564                                            DUMMY_CLOCK_RATE_2),
1565                         0);
1566
1567         KUNIT_ASSERT_EQ(test,
1568                         clk_set_rate(clk, DUMMY_CLOCK_RATE_1 - 1000),
1569                         0);
1570
1571         rate = clk_get_rate(clk);
1572         KUNIT_ASSERT_GT(test, rate, 0);
1573         KUNIT_EXPECT_GE(test, rate, DUMMY_CLOCK_RATE_1);
1574         KUNIT_EXPECT_LE(test, rate, DUMMY_CLOCK_RATE_2);
1575
1576         clk_put(clk);
1577 }
1578
1579 /*
1580  * Test that if our clock has some boundaries and we try to round and
1581  * set a rate lower than the minimum, the rate returned by
1582  * clk_round_rate() will be consistent with the new rate set by
1583  * clk_set_rate().
1584  */
1585 static void clk_range_test_set_range_set_round_rate_consistent_lower(struct kunit *test)
1586 {
1587         struct clk_dummy_context *ctx = test->priv;
1588         struct clk_hw *hw = &ctx->hw;
1589         struct clk *clk = clk_hw_get_clk(hw, NULL);
1590         long rounded;
1591
1592         KUNIT_ASSERT_EQ(test,
1593                         clk_set_rate_range(clk,
1594                                            DUMMY_CLOCK_RATE_1,
1595                                            DUMMY_CLOCK_RATE_2),
1596                         0);
1597
1598         rounded = clk_round_rate(clk, DUMMY_CLOCK_RATE_1 - 1000);
1599         KUNIT_ASSERT_GT(test, rounded, 0);
1600
1601         KUNIT_ASSERT_EQ(test,
1602                         clk_set_rate(clk, DUMMY_CLOCK_RATE_1 - 1000),
1603                         0);
1604
1605         KUNIT_EXPECT_EQ(test, rounded, clk_get_rate(clk));
1606
1607         clk_put(clk);
1608 }
1609
1610 /*
1611  * Test that if our clock has some boundaries and we try to round a rate
1612  * higher than the maximum, the returned rate will be within range.
1613  */
1614 static void clk_range_test_set_range_round_rate_higher(struct kunit *test)
1615 {
1616         struct clk_dummy_context *ctx = test->priv;
1617         struct clk_hw *hw = &ctx->hw;
1618         struct clk *clk = clk_hw_get_clk(hw, NULL);
1619         long rate;
1620
1621         KUNIT_ASSERT_EQ(test,
1622                         clk_set_rate_range(clk,
1623                                            DUMMY_CLOCK_RATE_1,
1624                                            DUMMY_CLOCK_RATE_2),
1625                         0);
1626
1627         rate = clk_round_rate(clk, DUMMY_CLOCK_RATE_2 + 1000);
1628         KUNIT_ASSERT_GT(test, rate, 0);
1629         KUNIT_EXPECT_GE(test, rate, DUMMY_CLOCK_RATE_1);
1630         KUNIT_EXPECT_LE(test, rate, DUMMY_CLOCK_RATE_2);
1631
1632         clk_put(clk);
1633 }
1634
1635 /*
1636  * Test that if our clock has some boundaries and we try to set a rate
1637  * higher than the maximum, the new rate will be within range.
1638  */
1639 static void clk_range_test_set_range_set_rate_higher(struct kunit *test)
1640 {
1641         struct clk_dummy_context *ctx = test->priv;
1642         struct clk_hw *hw = &ctx->hw;
1643         struct clk *clk = clk_hw_get_clk(hw, NULL);
1644         unsigned long rate;
1645
1646         KUNIT_ASSERT_EQ(test,
1647                         clk_set_rate_range(clk,
1648                                            DUMMY_CLOCK_RATE_1,
1649                                            DUMMY_CLOCK_RATE_2),
1650                         0);
1651
1652         KUNIT_ASSERT_EQ(test,
1653                         clk_set_rate(clk, DUMMY_CLOCK_RATE_2 + 1000),
1654                         0);
1655
1656         rate = clk_get_rate(clk);
1657         KUNIT_ASSERT_GT(test, rate, 0);
1658         KUNIT_EXPECT_GE(test, rate, DUMMY_CLOCK_RATE_1);
1659         KUNIT_EXPECT_LE(test, rate, DUMMY_CLOCK_RATE_2);
1660
1661         clk_put(clk);
1662 }
1663
1664 /*
1665  * Test that if our clock has some boundaries and we try to round and
1666  * set a rate higher than the maximum, the rate returned by
1667  * clk_round_rate() will be consistent with the new rate set by
1668  * clk_set_rate().
1669  */
1670 static void clk_range_test_set_range_set_round_rate_consistent_higher(struct kunit *test)
1671 {
1672         struct clk_dummy_context *ctx = test->priv;
1673         struct clk_hw *hw = &ctx->hw;
1674         struct clk *clk = clk_hw_get_clk(hw, NULL);
1675         long rounded;
1676
1677         KUNIT_ASSERT_EQ(test,
1678                         clk_set_rate_range(clk,
1679                                            DUMMY_CLOCK_RATE_1,
1680                                            DUMMY_CLOCK_RATE_2),
1681                         0);
1682
1683         rounded = clk_round_rate(clk, DUMMY_CLOCK_RATE_2 + 1000);
1684         KUNIT_ASSERT_GT(test, rounded, 0);
1685
1686         KUNIT_ASSERT_EQ(test,
1687                         clk_set_rate(clk, DUMMY_CLOCK_RATE_2 + 1000),
1688                         0);
1689
1690         KUNIT_EXPECT_EQ(test, rounded, clk_get_rate(clk));
1691
1692         clk_put(clk);
1693 }
1694
1695 /*
1696  * Test that if our clock has a rate lower than the minimum set by a
1697  * call to clk_set_rate_range(), the rate will be raised to match the
1698  * new minimum.
1699  *
1700  * This assumes that clk_ops.determine_rate or clk_ops.round_rate won't
1701  * modify the requested rate, which is our case in clk_dummy_rate_ops.
1702  */
1703 static void clk_range_test_set_range_get_rate_raised(struct kunit *test)
1704 {
1705         struct clk_dummy_context *ctx = test->priv;
1706         struct clk_hw *hw = &ctx->hw;
1707         struct clk *clk = clk_hw_get_clk(hw, NULL);
1708         unsigned long rate;
1709
1710         KUNIT_ASSERT_EQ(test,
1711                         clk_set_rate(clk, DUMMY_CLOCK_RATE_1 - 1000),
1712                         0);
1713
1714         KUNIT_ASSERT_EQ(test,
1715                         clk_set_rate_range(clk,
1716                                            DUMMY_CLOCK_RATE_1,
1717                                            DUMMY_CLOCK_RATE_2),
1718                         0);
1719
1720         rate = clk_get_rate(clk);
1721         KUNIT_ASSERT_GT(test, rate, 0);
1722         KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_1);
1723
1724         clk_put(clk);
1725 }
1726
1727 /*
1728  * Test that if our clock has a rate higher than the maximum set by a
1729  * call to clk_set_rate_range(), the rate will be lowered to match the
1730  * new maximum.
1731  *
1732  * This assumes that clk_ops.determine_rate or clk_ops.round_rate won't
1733  * modify the requested rate, which is our case in clk_dummy_rate_ops.
1734  */
1735 static void clk_range_test_set_range_get_rate_lowered(struct kunit *test)
1736 {
1737         struct clk_dummy_context *ctx = test->priv;
1738         struct clk_hw *hw = &ctx->hw;
1739         struct clk *clk = clk_hw_get_clk(hw, NULL);
1740         unsigned long rate;
1741
1742         KUNIT_ASSERT_EQ(test,
1743                         clk_set_rate(clk, DUMMY_CLOCK_RATE_2 + 1000),
1744                         0);
1745
1746         KUNIT_ASSERT_EQ(test,
1747                         clk_set_rate_range(clk,
1748                                            DUMMY_CLOCK_RATE_1,
1749                                            DUMMY_CLOCK_RATE_2),
1750                         0);
1751
1752         rate = clk_get_rate(clk);
1753         KUNIT_ASSERT_GT(test, rate, 0);
1754         KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_2);
1755
1756         clk_put(clk);
1757 }
1758
1759 static struct kunit_case clk_range_test_cases[] = {
1760         KUNIT_CASE(clk_range_test_set_range),
1761         KUNIT_CASE(clk_range_test_set_range_invalid),
1762         KUNIT_CASE(clk_range_test_multiple_disjoints_range),
1763         KUNIT_CASE(clk_range_test_set_range_round_rate_lower),
1764         KUNIT_CASE(clk_range_test_set_range_set_rate_lower),
1765         KUNIT_CASE(clk_range_test_set_range_set_round_rate_consistent_lower),
1766         KUNIT_CASE(clk_range_test_set_range_round_rate_higher),
1767         KUNIT_CASE(clk_range_test_set_range_set_rate_higher),
1768         KUNIT_CASE(clk_range_test_set_range_set_round_rate_consistent_higher),
1769         KUNIT_CASE(clk_range_test_set_range_get_rate_raised),
1770         KUNIT_CASE(clk_range_test_set_range_get_rate_lowered),
1771         {}
1772 };
1773
1774 /*
1775  * Test suite for a basic rate clock, without any parent.
1776  *
1777  * These tests exercise the rate range API: clk_set_rate_range(),
1778  * clk_set_min_rate(), clk_set_max_rate(), clk_drop_range().
1779  */
1780 static struct kunit_suite clk_range_test_suite = {
1781         .name = "clk-range-test",
1782         .init = clk_test_init,
1783         .exit = clk_test_exit,
1784         .test_cases = clk_range_test_cases,
1785 };
1786
1787 /*
1788  * Test that if we have several subsequent calls to
1789  * clk_set_rate_range(), the core will reevaluate whether a new rate is
1790  * needed each and every time.
1791  *
1792  * With clk_dummy_maximize_rate_ops, this means that the rate will
1793  * trail along the maximum as it evolves.
1794  */
1795 static void clk_range_test_set_range_rate_maximized(struct kunit *test)
1796 {
1797         struct clk_dummy_context *ctx = test->priv;
1798         struct clk_hw *hw = &ctx->hw;
1799         struct clk *clk = clk_hw_get_clk(hw, NULL);
1800         unsigned long rate;
1801
1802         KUNIT_ASSERT_EQ(test,
1803                         clk_set_rate(clk, DUMMY_CLOCK_RATE_2 + 1000),
1804                         0);
1805
1806         KUNIT_ASSERT_EQ(test,
1807                         clk_set_rate_range(clk,
1808                                            DUMMY_CLOCK_RATE_1,
1809                                            DUMMY_CLOCK_RATE_2),
1810                         0);
1811
1812         rate = clk_get_rate(clk);
1813         KUNIT_ASSERT_GT(test, rate, 0);
1814         KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_2);
1815
1816         KUNIT_ASSERT_EQ(test,
1817                         clk_set_rate_range(clk,
1818                                            DUMMY_CLOCK_RATE_1,
1819                                            DUMMY_CLOCK_RATE_2 - 1000),
1820                         0);
1821
1822         rate = clk_get_rate(clk);
1823         KUNIT_ASSERT_GT(test, rate, 0);
1824         KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_2 - 1000);
1825
1826         KUNIT_ASSERT_EQ(test,
1827                         clk_set_rate_range(clk,
1828                                            DUMMY_CLOCK_RATE_1,
1829                                            DUMMY_CLOCK_RATE_2),
1830                         0);
1831
1832         rate = clk_get_rate(clk);
1833         KUNIT_ASSERT_GT(test, rate, 0);
1834         KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_2);
1835
1836         clk_put(clk);
1837 }
1838
1839 /*
1840  * Test that if we have several subsequent calls to
1841  * clk_set_rate_range(), across multiple users, the core will reevaluate
1842  * whether a new rate is needed each and every time.
1843  *
1844  * With clk_dummy_maximize_rate_ops, this means that the rate will
1845  * trail along the maximum as it evolves.
1846  */
1847 static void clk_range_test_multiple_set_range_rate_maximized(struct kunit *test)
1848 {
1849         struct clk_dummy_context *ctx = test->priv;
1850         struct clk_hw *hw = &ctx->hw;
1851         struct clk *clk = clk_hw_get_clk(hw, NULL);
1852         struct clk *user1, *user2;
1853         unsigned long rate;
1854
1855         user1 = clk_hw_get_clk(hw, NULL);
1856         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, user1);
1857
1858         user2 = clk_hw_get_clk(hw, NULL);
1859         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, user2);
1860
1861         KUNIT_ASSERT_EQ(test,
1862                         clk_set_rate(clk, DUMMY_CLOCK_RATE_2 + 1000),
1863                         0);
1864
1865         KUNIT_ASSERT_EQ(test,
1866                         clk_set_rate_range(user1,
1867                                            0,
1868                                            DUMMY_CLOCK_RATE_2),
1869                         0);
1870
1871         rate = clk_get_rate(clk);
1872         KUNIT_ASSERT_GT(test, rate, 0);
1873         KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_2);
1874
1875         KUNIT_ASSERT_EQ(test,
1876                         clk_set_rate_range(user2,
1877                                            0,
1878                                            DUMMY_CLOCK_RATE_1),
1879                         0);
1880
1881         rate = clk_get_rate(clk);
1882         KUNIT_ASSERT_GT(test, rate, 0);
1883         KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_1);
1884
1885         KUNIT_ASSERT_EQ(test,
1886                         clk_drop_range(user2),
1887                         0);
1888
1889         rate = clk_get_rate(clk);
1890         KUNIT_ASSERT_GT(test, rate, 0);
1891         KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_2);
1892
1893         clk_put(user2);
1894         clk_put(user1);
1895         clk_put(clk);
1896 }
1897
1898 /*
1899  * Test that if we have several subsequent calls to
1900  * clk_set_rate_range(), across multiple users, the core will reevaluate
1901  * whether a new rate is needed, including when a user drop its clock.
1902  *
1903  * With clk_dummy_maximize_rate_ops, this means that the rate will
1904  * trail along the maximum as it evolves.
1905  */
1906 static void clk_range_test_multiple_set_range_rate_put_maximized(struct kunit *test)
1907 {
1908         struct clk_dummy_context *ctx = test->priv;
1909         struct clk_hw *hw = &ctx->hw;
1910         struct clk *clk = clk_hw_get_clk(hw, NULL);
1911         struct clk *user1, *user2;
1912         unsigned long rate;
1913
1914         user1 = clk_hw_get_clk(hw, NULL);
1915         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, user1);
1916
1917         user2 = clk_hw_get_clk(hw, NULL);
1918         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, user2);
1919
1920         KUNIT_ASSERT_EQ(test,
1921                         clk_set_rate(clk, DUMMY_CLOCK_RATE_2 + 1000),
1922                         0);
1923
1924         KUNIT_ASSERT_EQ(test,
1925                         clk_set_rate_range(user1,
1926                                            0,
1927                                            DUMMY_CLOCK_RATE_2),
1928                         0);
1929
1930         rate = clk_get_rate(clk);
1931         KUNIT_ASSERT_GT(test, rate, 0);
1932         KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_2);
1933
1934         KUNIT_ASSERT_EQ(test,
1935                         clk_set_rate_range(user2,
1936                                            0,
1937                                            DUMMY_CLOCK_RATE_1),
1938                         0);
1939
1940         rate = clk_get_rate(clk);
1941         KUNIT_ASSERT_GT(test, rate, 0);
1942         KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_1);
1943
1944         clk_put(user2);
1945
1946         rate = clk_get_rate(clk);
1947         KUNIT_ASSERT_GT(test, rate, 0);
1948         KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_2);
1949
1950         clk_put(user1);
1951         clk_put(clk);
1952 }
1953
1954 static struct kunit_case clk_range_maximize_test_cases[] = {
1955         KUNIT_CASE(clk_range_test_set_range_rate_maximized),
1956         KUNIT_CASE(clk_range_test_multiple_set_range_rate_maximized),
1957         KUNIT_CASE(clk_range_test_multiple_set_range_rate_put_maximized),
1958         {}
1959 };
1960
1961 /*
1962  * Test suite for a basic rate clock, without any parent.
1963  *
1964  * These tests exercise the rate range API: clk_set_rate_range(),
1965  * clk_set_min_rate(), clk_set_max_rate(), clk_drop_range(), with a
1966  * driver that will always try to run at the highest possible rate.
1967  */
1968 static struct kunit_suite clk_range_maximize_test_suite = {
1969         .name = "clk-range-maximize-test",
1970         .init = clk_maximize_test_init,
1971         .exit = clk_test_exit,
1972         .test_cases = clk_range_maximize_test_cases,
1973 };
1974
1975 /*
1976  * Test that if we have several subsequent calls to
1977  * clk_set_rate_range(), the core will reevaluate whether a new rate is
1978  * needed each and every time.
1979  *
1980  * With clk_dummy_minimize_rate_ops, this means that the rate will
1981  * trail along the minimum as it evolves.
1982  */
1983 static void clk_range_test_set_range_rate_minimized(struct kunit *test)
1984 {
1985         struct clk_dummy_context *ctx = test->priv;
1986         struct clk_hw *hw = &ctx->hw;
1987         struct clk *clk = clk_hw_get_clk(hw, NULL);
1988         unsigned long rate;
1989
1990         KUNIT_ASSERT_EQ(test,
1991                         clk_set_rate(clk, DUMMY_CLOCK_RATE_1 - 1000),
1992                         0);
1993
1994         KUNIT_ASSERT_EQ(test,
1995                         clk_set_rate_range(clk,
1996                                            DUMMY_CLOCK_RATE_1,
1997                                            DUMMY_CLOCK_RATE_2),
1998                         0);
1999
2000         rate = clk_get_rate(clk);
2001         KUNIT_ASSERT_GT(test, rate, 0);
2002         KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_1);
2003
2004         KUNIT_ASSERT_EQ(test,
2005                         clk_set_rate_range(clk,
2006                                            DUMMY_CLOCK_RATE_1 + 1000,
2007                                            DUMMY_CLOCK_RATE_2),
2008                         0);
2009
2010         rate = clk_get_rate(clk);
2011         KUNIT_ASSERT_GT(test, rate, 0);
2012         KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_1 + 1000);
2013
2014         KUNIT_ASSERT_EQ(test,
2015                         clk_set_rate_range(clk,
2016                                            DUMMY_CLOCK_RATE_1,
2017                                            DUMMY_CLOCK_RATE_2),
2018                         0);
2019
2020         rate = clk_get_rate(clk);
2021         KUNIT_ASSERT_GT(test, rate, 0);
2022         KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_1);
2023
2024         clk_put(clk);
2025 }
2026
2027 /*
2028  * Test that if we have several subsequent calls to
2029  * clk_set_rate_range(), across multiple users, the core will reevaluate
2030  * whether a new rate is needed each and every time.
2031  *
2032  * With clk_dummy_minimize_rate_ops, this means that the rate will
2033  * trail along the minimum as it evolves.
2034  */
2035 static void clk_range_test_multiple_set_range_rate_minimized(struct kunit *test)
2036 {
2037         struct clk_dummy_context *ctx = test->priv;
2038         struct clk_hw *hw = &ctx->hw;
2039         struct clk *clk = clk_hw_get_clk(hw, NULL);
2040         struct clk *user1, *user2;
2041         unsigned long rate;
2042
2043         user1 = clk_hw_get_clk(hw, NULL);
2044         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, user1);
2045
2046         user2 = clk_hw_get_clk(hw, NULL);
2047         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, user2);
2048
2049         KUNIT_ASSERT_EQ(test,
2050                         clk_set_rate_range(user1,
2051                                            DUMMY_CLOCK_RATE_1,
2052                                            ULONG_MAX),
2053                         0);
2054
2055         rate = clk_get_rate(clk);
2056         KUNIT_ASSERT_GT(test, rate, 0);
2057         KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_1);
2058
2059         KUNIT_ASSERT_EQ(test,
2060                         clk_set_rate_range(user2,
2061                                            DUMMY_CLOCK_RATE_2,
2062                                            ULONG_MAX),
2063                         0);
2064
2065         rate = clk_get_rate(clk);
2066         KUNIT_ASSERT_GT(test, rate, 0);
2067         KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_2);
2068
2069         KUNIT_ASSERT_EQ(test,
2070                         clk_drop_range(user2),
2071                         0);
2072
2073         rate = clk_get_rate(clk);
2074         KUNIT_ASSERT_GT(test, rate, 0);
2075         KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_1);
2076
2077         clk_put(user2);
2078         clk_put(user1);
2079         clk_put(clk);
2080 }
2081
2082 /*
2083  * Test that if we have several subsequent calls to
2084  * clk_set_rate_range(), across multiple users, the core will reevaluate
2085  * whether a new rate is needed, including when a user drop its clock.
2086  *
2087  * With clk_dummy_minimize_rate_ops, this means that the rate will
2088  * trail along the minimum as it evolves.
2089  */
2090 static void clk_range_test_multiple_set_range_rate_put_minimized(struct kunit *test)
2091 {
2092         struct clk_dummy_context *ctx = test->priv;
2093         struct clk_hw *hw = &ctx->hw;
2094         struct clk *clk = clk_hw_get_clk(hw, NULL);
2095         struct clk *user1, *user2;
2096         unsigned long rate;
2097
2098         user1 = clk_hw_get_clk(hw, NULL);
2099         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, user1);
2100
2101         user2 = clk_hw_get_clk(hw, NULL);
2102         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, user2);
2103
2104         KUNIT_ASSERT_EQ(test,
2105                         clk_set_rate_range(user1,
2106                                            DUMMY_CLOCK_RATE_1,
2107                                            ULONG_MAX),
2108                         0);
2109
2110         rate = clk_get_rate(clk);
2111         KUNIT_ASSERT_GT(test, rate, 0);
2112         KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_1);
2113
2114         KUNIT_ASSERT_EQ(test,
2115                         clk_set_rate_range(user2,
2116                                            DUMMY_CLOCK_RATE_2,
2117                                            ULONG_MAX),
2118                         0);
2119
2120         rate = clk_get_rate(clk);
2121         KUNIT_ASSERT_GT(test, rate, 0);
2122         KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_2);
2123
2124         clk_put(user2);
2125
2126         rate = clk_get_rate(clk);
2127         KUNIT_ASSERT_GT(test, rate, 0);
2128         KUNIT_EXPECT_EQ(test, rate, DUMMY_CLOCK_RATE_1);
2129
2130         clk_put(user1);
2131         clk_put(clk);
2132 }
2133
2134 static struct kunit_case clk_range_minimize_test_cases[] = {
2135         KUNIT_CASE(clk_range_test_set_range_rate_minimized),
2136         KUNIT_CASE(clk_range_test_multiple_set_range_rate_minimized),
2137         KUNIT_CASE(clk_range_test_multiple_set_range_rate_put_minimized),
2138         {}
2139 };
2140
2141 /*
2142  * Test suite for a basic rate clock, without any parent.
2143  *
2144  * These tests exercise the rate range API: clk_set_rate_range(),
2145  * clk_set_min_rate(), clk_set_max_rate(), clk_drop_range(), with a
2146  * driver that will always try to run at the lowest possible rate.
2147  */
2148 static struct kunit_suite clk_range_minimize_test_suite = {
2149         .name = "clk-range-minimize-test",
2150         .init = clk_minimize_test_init,
2151         .exit = clk_test_exit,
2152         .test_cases = clk_range_minimize_test_cases,
2153 };
2154
2155 struct clk_leaf_mux_ctx {
2156         struct clk_multiple_parent_ctx mux_ctx;
2157         struct clk_hw hw;
2158 };
2159
2160 static int
2161 clk_leaf_mux_set_rate_parent_test_init(struct kunit *test)
2162 {
2163         struct clk_leaf_mux_ctx *ctx;
2164         const char *top_parents[2] = { "parent-0", "parent-1" };
2165         int ret;
2166
2167         ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
2168         if (!ctx)
2169                 return -ENOMEM;
2170         test->priv = ctx;
2171
2172         ctx->mux_ctx.parents_ctx[0].hw.init = CLK_HW_INIT_NO_PARENT("parent-0",
2173                                                                     &clk_dummy_rate_ops,
2174                                                                     0);
2175         ctx->mux_ctx.parents_ctx[0].rate = DUMMY_CLOCK_RATE_1;
2176         ret = clk_hw_register(NULL, &ctx->mux_ctx.parents_ctx[0].hw);
2177         if (ret)
2178                 return ret;
2179
2180         ctx->mux_ctx.parents_ctx[1].hw.init = CLK_HW_INIT_NO_PARENT("parent-1",
2181                                                                     &clk_dummy_rate_ops,
2182                                                                     0);
2183         ctx->mux_ctx.parents_ctx[1].rate = DUMMY_CLOCK_RATE_2;
2184         ret = clk_hw_register(NULL, &ctx->mux_ctx.parents_ctx[1].hw);
2185         if (ret)
2186                 return ret;
2187
2188         ctx->mux_ctx.current_parent = 0;
2189         ctx->mux_ctx.hw.init = CLK_HW_INIT_PARENTS("test-mux", top_parents,
2190                                                    &clk_multiple_parents_mux_ops,
2191                                                    0);
2192         ret = clk_hw_register(NULL, &ctx->mux_ctx.hw);
2193         if (ret)
2194                 return ret;
2195
2196         ctx->hw.init = CLK_HW_INIT_HW("test-clock", &ctx->mux_ctx.hw,
2197                                       &clk_dummy_single_parent_ops,
2198                                       CLK_SET_RATE_PARENT);
2199         ret = clk_hw_register(NULL, &ctx->hw);
2200         if (ret)
2201                 return ret;
2202
2203         return 0;
2204 }
2205
2206 static void clk_leaf_mux_set_rate_parent_test_exit(struct kunit *test)
2207 {
2208         struct clk_leaf_mux_ctx *ctx = test->priv;
2209
2210         clk_hw_unregister(&ctx->hw);
2211         clk_hw_unregister(&ctx->mux_ctx.hw);
2212         clk_hw_unregister(&ctx->mux_ctx.parents_ctx[0].hw);
2213         clk_hw_unregister(&ctx->mux_ctx.parents_ctx[1].hw);
2214 }
2215
2216 /*
2217  * Test that, for a clock that will forward any rate request to its
2218  * parent, the rate request structure returned by __clk_determine_rate
2219  * is sane and will be what we expect.
2220  */
2221 static void clk_leaf_mux_set_rate_parent_determine_rate(struct kunit *test)
2222 {
2223         struct clk_leaf_mux_ctx *ctx = test->priv;
2224         struct clk_hw *hw = &ctx->hw;
2225         struct clk *clk = clk_hw_get_clk(hw, NULL);
2226         struct clk_rate_request req;
2227         unsigned long rate;
2228         int ret;
2229
2230         rate = clk_get_rate(clk);
2231         KUNIT_ASSERT_EQ(test, rate, DUMMY_CLOCK_RATE_1);
2232
2233         clk_hw_init_rate_request(hw, &req, DUMMY_CLOCK_RATE_2);
2234
2235         ret = __clk_determine_rate(hw, &req);
2236         KUNIT_ASSERT_EQ(test, ret, 0);
2237
2238         KUNIT_EXPECT_EQ(test, req.rate, DUMMY_CLOCK_RATE_2);
2239         KUNIT_EXPECT_EQ(test, req.best_parent_rate, DUMMY_CLOCK_RATE_2);
2240         KUNIT_EXPECT_PTR_EQ(test, req.best_parent_hw, &ctx->mux_ctx.hw);
2241
2242         clk_put(clk);
2243 }
2244
2245 static struct kunit_case clk_leaf_mux_set_rate_parent_test_cases[] = {
2246         KUNIT_CASE(clk_leaf_mux_set_rate_parent_determine_rate),
2247         {}
2248 };
2249
2250 /*
2251  * Test suite for a clock whose parent is a mux with multiple parents.
2252  * The leaf clock has CLK_SET_RATE_PARENT, and will forward rate
2253  * requests to the mux, which will then select which parent is the best
2254  * fit for a given rate.
2255  *
2256  * These tests exercise the behaviour of muxes, and the proper selection
2257  * of parents.
2258  */
2259 static struct kunit_suite clk_leaf_mux_set_rate_parent_test_suite = {
2260         .name = "clk-leaf-mux-set-rate-parent",
2261         .init = clk_leaf_mux_set_rate_parent_test_init,
2262         .exit = clk_leaf_mux_set_rate_parent_test_exit,
2263         .test_cases = clk_leaf_mux_set_rate_parent_test_cases,
2264 };
2265
2266 struct clk_mux_notifier_rate_change {
2267         bool done;
2268         unsigned long old_rate;
2269         unsigned long new_rate;
2270         wait_queue_head_t wq;
2271 };
2272
2273 struct clk_mux_notifier_ctx {
2274         struct clk_multiple_parent_ctx mux_ctx;
2275         struct clk *clk;
2276         struct notifier_block clk_nb;
2277         struct clk_mux_notifier_rate_change pre_rate_change;
2278         struct clk_mux_notifier_rate_change post_rate_change;
2279 };
2280
2281 #define NOTIFIER_TIMEOUT_MS 100
2282
2283 static int clk_mux_notifier_callback(struct notifier_block *nb,
2284                                      unsigned long action, void *data)
2285 {
2286         struct clk_notifier_data *clk_data = data;
2287         struct clk_mux_notifier_ctx *ctx = container_of(nb,
2288                                                         struct clk_mux_notifier_ctx,
2289                                                         clk_nb);
2290
2291         if (action & PRE_RATE_CHANGE) {
2292                 ctx->pre_rate_change.old_rate = clk_data->old_rate;
2293                 ctx->pre_rate_change.new_rate = clk_data->new_rate;
2294                 ctx->pre_rate_change.done = true;
2295                 wake_up_interruptible(&ctx->pre_rate_change.wq);
2296         }
2297
2298         if (action & POST_RATE_CHANGE) {
2299                 ctx->post_rate_change.old_rate = clk_data->old_rate;
2300                 ctx->post_rate_change.new_rate = clk_data->new_rate;
2301                 ctx->post_rate_change.done = true;
2302                 wake_up_interruptible(&ctx->post_rate_change.wq);
2303         }
2304
2305         return 0;
2306 }
2307
2308 static int clk_mux_notifier_test_init(struct kunit *test)
2309 {
2310         struct clk_mux_notifier_ctx *ctx;
2311         const char *top_parents[2] = { "parent-0", "parent-1" };
2312         int ret;
2313
2314         ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
2315         if (!ctx)
2316                 return -ENOMEM;
2317         test->priv = ctx;
2318         ctx->clk_nb.notifier_call = clk_mux_notifier_callback;
2319         init_waitqueue_head(&ctx->pre_rate_change.wq);
2320         init_waitqueue_head(&ctx->post_rate_change.wq);
2321
2322         ctx->mux_ctx.parents_ctx[0].hw.init = CLK_HW_INIT_NO_PARENT("parent-0",
2323                                                                     &clk_dummy_rate_ops,
2324                                                                     0);
2325         ctx->mux_ctx.parents_ctx[0].rate = DUMMY_CLOCK_RATE_1;
2326         ret = clk_hw_register(NULL, &ctx->mux_ctx.parents_ctx[0].hw);
2327         if (ret)
2328                 return ret;
2329
2330         ctx->mux_ctx.parents_ctx[1].hw.init = CLK_HW_INIT_NO_PARENT("parent-1",
2331                                                                     &clk_dummy_rate_ops,
2332                                                                     0);
2333         ctx->mux_ctx.parents_ctx[1].rate = DUMMY_CLOCK_RATE_2;
2334         ret = clk_hw_register(NULL, &ctx->mux_ctx.parents_ctx[1].hw);
2335         if (ret)
2336                 return ret;
2337
2338         ctx->mux_ctx.current_parent = 0;
2339         ctx->mux_ctx.hw.init = CLK_HW_INIT_PARENTS("test-mux", top_parents,
2340                                                    &clk_multiple_parents_mux_ops,
2341                                                    0);
2342         ret = clk_hw_register(NULL, &ctx->mux_ctx.hw);
2343         if (ret)
2344                 return ret;
2345
2346         ctx->clk = clk_hw_get_clk(&ctx->mux_ctx.hw, NULL);
2347         ret = clk_notifier_register(ctx->clk, &ctx->clk_nb);
2348         if (ret)
2349                 return ret;
2350
2351         return 0;
2352 }
2353
2354 static void clk_mux_notifier_test_exit(struct kunit *test)
2355 {
2356         struct clk_mux_notifier_ctx *ctx = test->priv;
2357         struct clk *clk = ctx->clk;
2358
2359         clk_notifier_unregister(clk, &ctx->clk_nb);
2360         clk_put(clk);
2361
2362         clk_hw_unregister(&ctx->mux_ctx.hw);
2363         clk_hw_unregister(&ctx->mux_ctx.parents_ctx[0].hw);
2364         clk_hw_unregister(&ctx->mux_ctx.parents_ctx[1].hw);
2365 }
2366
2367 /*
2368  * Test that if the we have a notifier registered on a mux, the core
2369  * will notify us when we switch to another parent, and with the proper
2370  * old and new rates.
2371  */
2372 static void clk_mux_notifier_set_parent_test(struct kunit *test)
2373 {
2374         struct clk_mux_notifier_ctx *ctx = test->priv;
2375         struct clk_hw *hw = &ctx->mux_ctx.hw;
2376         struct clk *clk = clk_hw_get_clk(hw, NULL);
2377         struct clk *new_parent = clk_hw_get_clk(&ctx->mux_ctx.parents_ctx[1].hw, NULL);
2378         int ret;
2379
2380         ret = clk_set_parent(clk, new_parent);
2381         KUNIT_ASSERT_EQ(test, ret, 0);
2382
2383         ret = wait_event_interruptible_timeout(ctx->pre_rate_change.wq,
2384                                                ctx->pre_rate_change.done,
2385                                                msecs_to_jiffies(NOTIFIER_TIMEOUT_MS));
2386         KUNIT_ASSERT_GT(test, ret, 0);
2387
2388         KUNIT_EXPECT_EQ(test, ctx->pre_rate_change.old_rate, DUMMY_CLOCK_RATE_1);
2389         KUNIT_EXPECT_EQ(test, ctx->pre_rate_change.new_rate, DUMMY_CLOCK_RATE_2);
2390
2391         ret = wait_event_interruptible_timeout(ctx->post_rate_change.wq,
2392                                                ctx->post_rate_change.done,
2393                                                msecs_to_jiffies(NOTIFIER_TIMEOUT_MS));
2394         KUNIT_ASSERT_GT(test, ret, 0);
2395
2396         KUNIT_EXPECT_EQ(test, ctx->post_rate_change.old_rate, DUMMY_CLOCK_RATE_1);
2397         KUNIT_EXPECT_EQ(test, ctx->post_rate_change.new_rate, DUMMY_CLOCK_RATE_2);
2398
2399         clk_put(new_parent);
2400         clk_put(clk);
2401 }
2402
2403 static struct kunit_case clk_mux_notifier_test_cases[] = {
2404         KUNIT_CASE(clk_mux_notifier_set_parent_test),
2405         {}
2406 };
2407
2408 /*
2409  * Test suite for a mux with multiple parents, and a notifier registered
2410  * on the mux.
2411  *
2412  * These tests exercise the behaviour of notifiers.
2413  */
2414 static struct kunit_suite clk_mux_notifier_test_suite = {
2415         .name = "clk-mux-notifier",
2416         .init = clk_mux_notifier_test_init,
2417         .exit = clk_mux_notifier_test_exit,
2418         .test_cases = clk_mux_notifier_test_cases,
2419 };
2420
2421 static int
2422 clk_mux_no_reparent_test_init(struct kunit *test)
2423 {
2424         struct clk_multiple_parent_ctx *ctx;
2425         const char *parents[2] = { "parent-0", "parent-1"};
2426         int ret;
2427
2428         ctx = kunit_kzalloc(test, sizeof(*ctx), GFP_KERNEL);
2429         if (!ctx)
2430                 return -ENOMEM;
2431         test->priv = ctx;
2432
2433         ctx->parents_ctx[0].hw.init = CLK_HW_INIT_NO_PARENT("parent-0",
2434                                                             &clk_dummy_rate_ops,
2435                                                             0);
2436         ctx->parents_ctx[0].rate = DUMMY_CLOCK_RATE_1;
2437         ret = clk_hw_register(NULL, &ctx->parents_ctx[0].hw);
2438         if (ret)
2439                 return ret;
2440
2441         ctx->parents_ctx[1].hw.init = CLK_HW_INIT_NO_PARENT("parent-1",
2442                                                             &clk_dummy_rate_ops,
2443                                                             0);
2444         ctx->parents_ctx[1].rate = DUMMY_CLOCK_RATE_2;
2445         ret = clk_hw_register(NULL, &ctx->parents_ctx[1].hw);
2446         if (ret)
2447                 return ret;
2448
2449         ctx->current_parent = 0;
2450         ctx->hw.init = CLK_HW_INIT_PARENTS("test-mux", parents,
2451                                            &clk_multiple_parents_no_reparent_mux_ops,
2452                                            0);
2453         ret = clk_hw_register(NULL, &ctx->hw);
2454         if (ret)
2455                 return ret;
2456
2457         return 0;
2458 }
2459
2460 static void
2461 clk_mux_no_reparent_test_exit(struct kunit *test)
2462 {
2463         struct clk_multiple_parent_ctx *ctx = test->priv;
2464
2465         clk_hw_unregister(&ctx->hw);
2466         clk_hw_unregister(&ctx->parents_ctx[0].hw);
2467         clk_hw_unregister(&ctx->parents_ctx[1].hw);
2468 }
2469
2470 /*
2471  * Test that if the we have a mux that cannot change parent and we call
2472  * clk_round_rate() on it with a rate that should cause it to change
2473  * parent, it won't.
2474  */
2475 static void clk_mux_no_reparent_round_rate(struct kunit *test)
2476 {
2477         struct clk_multiple_parent_ctx *ctx = test->priv;
2478         struct clk_hw *hw = &ctx->hw;
2479         struct clk *clk = clk_hw_get_clk(hw, NULL);
2480         struct clk *other_parent, *parent;
2481         unsigned long other_parent_rate;
2482         unsigned long parent_rate;
2483         long rounded_rate;
2484
2485         parent = clk_get_parent(clk);
2486         KUNIT_ASSERT_PTR_NE(test, parent, NULL);
2487
2488         parent_rate = clk_get_rate(parent);
2489         KUNIT_ASSERT_GT(test, parent_rate, 0);
2490
2491         other_parent = clk_hw_get_clk(&ctx->parents_ctx[1].hw, NULL);
2492         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, other_parent);
2493         KUNIT_ASSERT_FALSE(test, clk_is_match(parent, other_parent));
2494
2495         other_parent_rate = clk_get_rate(other_parent);
2496         KUNIT_ASSERT_GT(test, other_parent_rate, 0);
2497         clk_put(other_parent);
2498
2499         rounded_rate = clk_round_rate(clk, other_parent_rate);
2500         KUNIT_ASSERT_GT(test, rounded_rate, 0);
2501         KUNIT_EXPECT_EQ(test, rounded_rate, parent_rate);
2502
2503         clk_put(clk);
2504 }
2505
2506 /*
2507  * Test that if the we have a mux that cannot change parent and we call
2508  * clk_set_rate() on it with a rate that should cause it to change
2509  * parent, it won't.
2510  */
2511 static void clk_mux_no_reparent_set_rate(struct kunit *test)
2512 {
2513         struct clk_multiple_parent_ctx *ctx = test->priv;
2514         struct clk_hw *hw = &ctx->hw;
2515         struct clk *clk = clk_hw_get_clk(hw, NULL);
2516         struct clk *other_parent, *parent;
2517         unsigned long other_parent_rate;
2518         unsigned long parent_rate;
2519         unsigned long rate;
2520         int ret;
2521
2522         parent = clk_get_parent(clk);
2523         KUNIT_ASSERT_PTR_NE(test, parent, NULL);
2524
2525         parent_rate = clk_get_rate(parent);
2526         KUNIT_ASSERT_GT(test, parent_rate, 0);
2527
2528         other_parent = clk_hw_get_clk(&ctx->parents_ctx[1].hw, NULL);
2529         KUNIT_ASSERT_NOT_ERR_OR_NULL(test, other_parent);
2530         KUNIT_ASSERT_FALSE(test, clk_is_match(parent, other_parent));
2531
2532         other_parent_rate = clk_get_rate(other_parent);
2533         KUNIT_ASSERT_GT(test, other_parent_rate, 0);
2534         clk_put(other_parent);
2535
2536         ret = clk_set_rate(clk, other_parent_rate);
2537         KUNIT_ASSERT_EQ(test, ret, 0);
2538
2539         rate = clk_get_rate(clk);
2540         KUNIT_ASSERT_GT(test, rate, 0);
2541         KUNIT_EXPECT_EQ(test, rate, parent_rate);
2542
2543         clk_put(clk);
2544 }
2545
2546 static struct kunit_case clk_mux_no_reparent_test_cases[] = {
2547         KUNIT_CASE(clk_mux_no_reparent_round_rate),
2548         KUNIT_CASE(clk_mux_no_reparent_set_rate),
2549         {}
2550 };
2551
2552 /*
2553  * Test suite for a clock mux that isn't allowed to change parent, using
2554  * the clk_hw_determine_rate_no_reparent() helper.
2555  *
2556  * These tests exercise that helper, and the proper selection of
2557  * rates and parents.
2558  */
2559 static struct kunit_suite clk_mux_no_reparent_test_suite = {
2560         .name = "clk-mux-no-reparent",
2561         .init = clk_mux_no_reparent_test_init,
2562         .exit = clk_mux_no_reparent_test_exit,
2563         .test_cases = clk_mux_no_reparent_test_cases,
2564 };
2565
2566 kunit_test_suites(
2567         &clk_leaf_mux_set_rate_parent_test_suite,
2568         &clk_test_suite,
2569         &clk_multiple_parents_mux_test_suite,
2570         &clk_mux_no_reparent_test_suite,
2571         &clk_mux_notifier_test_suite,
2572         &clk_orphan_transparent_multiple_parent_mux_test_suite,
2573         &clk_orphan_transparent_single_parent_test_suite,
2574         &clk_orphan_two_level_root_last_test_suite,
2575         &clk_range_test_suite,
2576         &clk_range_maximize_test_suite,
2577         &clk_range_minimize_test_suite,
2578         &clk_single_parent_mux_test_suite,
2579         &clk_uncached_test_suite
2580 );
2581 MODULE_LICENSE("GPL v2");