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