drivers/clk/clk_test.c

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