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