clk: fractional-divider: Document the arithmetics used behind the code

It appears that some code lines raise the question why they are needed
and how they are participated in the calculus of the resulting values.

Document this in a form of the top comment in the module file.

Reported-by: Liu Ying <victor.liu@nxp.com>
Signed-off-by: Andy Shevchenko <andriy.shevchenko@linux.intel.com>
Link: https://lore.kernel.org/r/20210812170025.67074-4-andriy.shevchenko@linux.intel.com
[sboyd@kernel.org: Remove "die" as it isn't relevant]
Signed-off-by: Stephen Boyd <sboyd@kernel.org>

diff --git a/drivers/clk/clk-fractional-divider.c b/drivers/clk/clk-fractional-divider.c
index 6a3ed82fdae9b7397600ea8a438e9a9a0fc36f07..4274540327cece5b2428b794a815c55a95ff06cc 100644 (file)
--- a/drivers/clk/clk-fractional-divider.c
+++ b/drivers/clk/clk-fractional-divider.c
@@ -3,8 +3,39 @@
  * Copyright (C) 2014 Intel Corporation
  *
  * Adjustable fractional divider clock implementation.
- * Output rate = (m / n) * parent_rate.
  * Uses rational best approximation algorithm.
+ *
+ * Output is calculated as
+ *
+ *     rate = (m / n) * parent_rate                            (1)
+ *
+ * This is useful when we have a prescaler block which asks for
+ * m (numerator) and n (denominator) values to be provided to satisfy
+ * the (1) as much as possible.
+ *
+ * Since m and n have the limitation by a range, e.g.
+ *
+ *     n >= 1, n < N_width, where N_width = 2^nwidth           (2)
+ *
+ * for some cases the output may be saturated. Hence, from (1) and (2),
+ * assuming the worst case when m = 1, the inequality
+ *
+ *     floor(log2(parent_rate / rate)) <= nwidth               (3)
+ *
+ * may be derived. Thus, in cases when
+ *
+ *     (parent_rate / rate) >> N_width                         (4)
+ *
+ * we might scale up the rate by 2^scale (see the description of
+ * CLK_FRAC_DIVIDER_POWER_OF_TWO_PS for additional information), where
+ *
+ *     scale = floor(log2(parent_rate / rate)) - nwidth        (5)
+ *
+ * and assume that the IP, that needs m and n, has also its own
+ * prescaler, which is capable to divide by 2^scale. In this way
+ * we get the denominator to satisfy the desired range (2) and
+ * at the same time much much better result of m and n than simple
+ * saturated values.
  */
 
 #include <linux/clk-provider.h>
@@ -81,6 +112,8 @@ void clk_fractional_divider_general_approximation(struct clk_hw *hw,
         * Get rate closer to *parent_rate to guarantee there is no overflow
         * for m and n. In the result it will be the nearest rate left shifted
         * by (scale - fd->nwidth) bits.
+        *
+        * For the detailed explanation see the top comment in this file.
         */
        if (fd->flags & CLK_FRAC_DIVIDER_POWER_OF_TWO_PS) {
                unsigned long scale = fls_long(*parent_rate / rate - 1);