1// SPDX-License-Identifier: GPL-2.0 2/* 3 * Kunit test for clock fractional divider 4 */ 5#include <linux/clk-provider.h> 6#include <kunit/test.h> 7 8#include "clk-fractional-divider.h" 9 10/* 11 * Test the maximum denominator case for fd clock without flags. 12 * 13 * Expect the highest possible denominator to be used in order to get as close as possible to the 14 * requested rate. 15 */ 16static void clk_fd_test_approximation_max_denominator(struct kunit *test) 17{ 18 struct clk_fractional_divider *fd; 19 unsigned long rate, parent_rate, parent_rate_before, m, n, max_n; 20 21 fd = kunit_kzalloc(test, sizeof(*fd), GFP_KERNEL); 22 KUNIT_ASSERT_NOT_NULL(test, fd); 23 24 fd->mwidth = 3; 25 fd->nwidth = 3; 26 max_n = 7; 27 28 rate = 240000000; 29 parent_rate = (max_n + 1) * rate; /* so that it exceeds the maximum divisor */ 30 parent_rate_before = parent_rate; 31 32 clk_fractional_divider_general_approximation(&fd->hw, rate, &parent_rate, &m, &n); 33 KUNIT_ASSERT_EQ(test, parent_rate, parent_rate_before); 34 35 KUNIT_EXPECT_EQ(test, m, 1); 36 KUNIT_EXPECT_EQ(test, n, max_n); 37} 38 39/* 40 * Test the maximum numerator case for fd clock without flags. 41 * 42 * Expect the highest possible numerator to be used in order to get as close as possible to the 43 * requested rate. 44 */ 45static void clk_fd_test_approximation_max_numerator(struct kunit *test) 46{ 47 struct clk_fractional_divider *fd; 48 unsigned long rate, parent_rate, parent_rate_before, m, n, max_m; 49 50 fd = kunit_kzalloc(test, sizeof(*fd), GFP_KERNEL); 51 KUNIT_ASSERT_NOT_NULL(test, fd); 52 53 fd->mwidth = 3; 54 max_m = 7; 55 fd->nwidth = 3; 56 57 rate = 240000000; 58 parent_rate = rate / (max_m + 1); /* so that it exceeds the maximum numerator */ 59 parent_rate_before = parent_rate; 60 61 clk_fractional_divider_general_approximation(&fd->hw, rate, &parent_rate, &m, &n); 62 KUNIT_ASSERT_EQ(test, parent_rate, parent_rate_before); 63 64 KUNIT_EXPECT_EQ(test, m, max_m); 65 KUNIT_EXPECT_EQ(test, n, 1); 66} 67 68/* 69 * Test the maximum denominator case for zero based fd clock. 70 * 71 * Expect the highest possible denominator to be used in order to get as close as possible to the 72 * requested rate. 73 */ 74static void clk_fd_test_approximation_max_denominator_zero_based(struct kunit *test) 75{ 76 struct clk_fractional_divider *fd; 77 unsigned long rate, parent_rate, parent_rate_before, m, n, max_n; 78 79 fd = kunit_kzalloc(test, sizeof(*fd), GFP_KERNEL); 80 KUNIT_ASSERT_NOT_NULL(test, fd); 81 82 fd->flags = CLK_FRAC_DIVIDER_ZERO_BASED; 83 fd->mwidth = 3; 84 fd->nwidth = 3; 85 max_n = 8; 86 87 rate = 240000000; 88 parent_rate = (max_n + 1) * rate; /* so that it exceeds the maximum divisor */ 89 parent_rate_before = parent_rate; 90 91 clk_fractional_divider_general_approximation(&fd->hw, rate, &parent_rate, &m, &n); 92 KUNIT_ASSERT_EQ(test, parent_rate, parent_rate_before); 93 94 KUNIT_EXPECT_EQ(test, m, 1); 95 KUNIT_EXPECT_EQ(test, n, max_n); 96} 97 98/* 99 * Test the maximum numerator case for zero based fd clock. 100 * 101 * Expect the highest possible numerator to be used in order to get as close as possible to the 102 * requested rate. 103 */ 104static void clk_fd_test_approximation_max_numerator_zero_based(struct kunit *test) 105{ 106 struct clk_fractional_divider *fd; 107 unsigned long rate, parent_rate, parent_rate_before, m, n, max_m; 108 109 fd = kunit_kzalloc(test, sizeof(*fd), GFP_KERNEL); 110 KUNIT_ASSERT_NOT_NULL(test, fd); 111 112 fd->flags = CLK_FRAC_DIVIDER_ZERO_BASED; 113 fd->mwidth = 3; 114 max_m = 8; 115 fd->nwidth = 3; 116 117 rate = 240000000; 118 parent_rate = rate / (max_m + 1); /* so that it exceeds the maximum numerator */ 119 parent_rate_before = parent_rate; 120 121 clk_fractional_divider_general_approximation(&fd->hw, rate, &parent_rate, &m, &n); 122 KUNIT_ASSERT_EQ(test, parent_rate, parent_rate_before); 123 124 KUNIT_EXPECT_EQ(test, m, max_m); 125 KUNIT_EXPECT_EQ(test, n, 1); 126} 127 128static struct kunit_case clk_fd_approximation_test_cases[] = { 129 KUNIT_CASE(clk_fd_test_approximation_max_denominator), 130 KUNIT_CASE(clk_fd_test_approximation_max_numerator), 131 KUNIT_CASE(clk_fd_test_approximation_max_denominator_zero_based), 132 KUNIT_CASE(clk_fd_test_approximation_max_numerator_zero_based), 133 {} 134}; 135 136/* 137 * Test suite for clk_fractional_divider_general_approximation(). 138 */ 139static struct kunit_suite clk_fd_approximation_suite = { 140 .name = "clk-fd-approximation", 141 .test_cases = clk_fd_approximation_test_cases, 142}; 143 144kunit_test_suites( 145 &clk_fd_approximation_suite 146); 147MODULE_LICENSE("GPL"); 148