Skip to contentSkip to conversation

clk: nuvoton: ma35d1: fix PLL frequency calculation

PATCH Superseded Joey Lu 2 participants 8 messages Jul 21 – Jul 22

Subsystems (2)

v4 of 5 Superseded Latest is v5 →

lore
Share & tools
lore

Joey Lu

author
#0 lore raw

v4 cover clk: nuvoton: ma35d1: fix PLL frequency calculation

Fix four bugs in the MA35D1 PLL clock driver that cause incorrect frequency values returned from recalc_rate() and determine_rate().

v1 combined all fixes into a single commit. At reviewer request, split into one patch per logical fix:

1/3 - fix div_u64 return value being discarded (affects both
ma35d1_calc_smic_pll_freq and ma35d1_calc_pll_freq INT mode)

2/3 - fix PLL_CTL1_FRAC mask width (8-bit -> 24-bit) and update
the fractional-mode arithmetic accordingly

3/3 - fix ma35d1_clk_pll_determine_rate: move find_closest() into
the configurable-PLL branch; unify read-only PLL handling

Changes in v4 (vs v3):
- 2/3: add Reviewed-by tag

Changes in v3 (vs v2):
- 2/3: replace the manual round-to-nearest expression

    "(u32)(((u64)x * 1000 + 500) >> 24)" with the kernel helper
    DIV_ROUND_CLOSEST_ULL((u64)x * 1000, 1ULL << 24); the result
    is mathematically identical but more readable and idiomatic

Joey Lu (3):
clk: nuvoton: ma35d1: fix ignored div_u64 return values in PLL freq
calculation
clk: nuvoton: ma35d1: fix PLL_CTL1_FRAC bit field width and fractional
calc
clk: nuvoton: ma35d1: fix ma35d1_clk_pll_determine_rate logic

 drivers/clk/nuvoton/clk-ma35d1-pll.c | 38 ++++++++++++++--------------
 1 file changed, 19 insertions(+), 19 deletions(-)
Signature · 1 line
2.43.0
author
#1 lore raw

PATCH v4 1/3 clk: nuvoton: ma35d1: fix ignored div_u64 return values in PLL freq calculation

div_u64() does not modify its argument in place; the return value must be assigned. Both ma35d1_calc_smic_pll_freq() and ma35d1_calc_pll_freq() called div_u64() and discarded the result, leaving pll_freq holding the undivided product and thus returning a frequency orders of magnitude too high.

Fixes 691521a367cf ("clk: nuvoton: Add clock driver for ma35d1 clock controller")
---
 drivers/clk/nuvoton/clk-ma35d1-pll.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)
drivers/clk/nuvoton/clk-ma35d1-pll.c +2 -2
index 4620acfe47e8..bfedd45bd04b 100644
@@ -92,7 +92,7 @@ static unsigned long ma35d1_calc_smic_pll_freq(u32 pll0_ctl0,
 	p = FIELD_GET(SPLL0_CTL0_OUTDIV, pll0_ctl0);
 	outdiv = 1 << p;
 	pll_freq = (u64)parent_rate * n;
-	div_u64(pll_freq, m * outdiv);
+	pll_freq = div_u64(pll_freq, m * outdiv);
 	return pll_freq;
 }
 
@@ -110,7 +110,7 @@ static unsigned long ma35d1_calc_pll_freq(u8 mode, u32 *reg_ctl, unsigned long p
 
 	if (mode == PLL_MODE_INT) {
 		pll_freq = (u64)parent_rate * n;
-		div_u64(pll_freq, m * p);
+		pll_freq = div_u64(pll_freq, m * p);
 	} else {
 		x = FIELD_GET(PLL_CTL1_FRAC, reg_ctl[1]);
 		/* 2 decimal places floating to integer (ex. 1.23 to 123) */
Signature · 1 line
2.43.0
Reviewed-by on v4 1/3
#2 lore raw

Re: [PATCH v4 1/3] clk: nuvoton: ma35d1: fix ignored div_u64 return values in PLL freq calculation

Quoted 8 lines · Joey Lu

div_u64() does not modify its argument in place; the return value must be assigned. Both ma35d1_calc_smic_pll_freq() and ma35d1_calc_pll_freq() called div_u64() and discarded the result, leaving pll_freq holding the undivided product and thus returning a frequency orders of magnitude too high.

[...]

Signature · 1 line
Alexandre Mergnat <[email protected]>
author
#3 lore raw

PATCH v4 2/3 clk: nuvoton: ma35d1: fix PLL_CTL1_FRAC bit field width and fractional calc

In reply to Joey Lu

PLL_CTL1_FRAC was defined as GENMASK(31, 24), covering only 8 bits. The hardware fractional field occupies bits [31:8] (24 bits), so the mask must be GENMASK(31, 8).

The previous fractional-mode calculation used FIELD_MAX(PLL_CTL1_FRAC) as the denominator to obtain 2 decimal places. With the corrected 24-bit mask the old divisor is wrong; replace the arithmetic with a proper 24-bit fixed-point rounding to 3 decimal places using the kernel's DIV_ROUND_CLOSEST_ULL helper:

n_frac = n * 1000 + DIV_ROUND_CLOSEST_ULL(x * 1000, 1 << 24)

Fixes 691521a367cf ("clk: nuvoton: Add clock driver for ma35d1 clock controller")
---
 drivers/clk/nuvoton/clk-ma35d1-pll.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)
drivers/clk/nuvoton/clk-ma35d1-pll.c +4 -4
index bfedd45bd04b..eb9d69d2077b 100644
@@ -48,7 +48,7 @@
 #define PLL_CTL1_PD		BIT(0)
 #define PLL_CTL1_BP		BIT(1)
 #define PLL_CTL1_OUTDIV		GENMASK(6, 4)
-#define PLL_CTL1_FRAC		GENMASK(31, 24)
+#define PLL_CTL1_FRAC		GENMASK(31, 8)
 #define PLL_CTL2_SLOPE		GENMASK(23, 0)
 
 #define INDIV_MIN		1
@@ -113,9 +113,9 @@ static unsigned long ma35d1_calc_pll_freq(u8 mode, u32 *reg_ctl, unsigned long p
 		pll_freq = div_u64(pll_freq, m * p);
 	} else {
 		x = FIELD_GET(PLL_CTL1_FRAC, reg_ctl[1]);
-		/* 2 decimal places floating to integer (ex. 1.23 to 123) */
-		n = n * 100 + ((x * 100) / FIELD_MAX(PLL_CTL1_FRAC));
-		pll_freq = div_u64(parent_rate * n, 100 * m * p);
+		/* convert 24-bit fraction to 3 decimal digits, rounding to closest */
+		n = n * 1000 + DIV_ROUND_CLOSEST_ULL((u64)x * 1000, 1ULL << 24);
+		pll_freq = div_u64((u64)parent_rate * n, 1000 * m * p);
 	}
 	return pll_freq;
 }
Signature · 1 line
2.43.0
Reviewed-by on v4 2/3
#4 lore raw

Re: [PATCH v4 2/3] clk: nuvoton: ma35d1: fix PLL_CTL1_FRAC bit field width and fractional calc

Quoted 11 lines · Joey Lu

PLL_CTL1_FRAC was defined as GENMASK(31, 24), covering only 8 bits. The hardware fractional field occupies bits [31:8] (24 bits), so the mask must be GENMASK(31, 8).

The previous fractional-mode calculation used FIELD_MAX(PLL_CTL1_FRAC) as the denominator to obtain 2 decimal places. With the corrected 24-bit mask the old divisor is wrong; replace the arithmetic with a proper 24-bit fixed-point rounding to 3 decimal places using the kernel's DIV_ROUND_CLOSEST_ULL helper:

[...]

Signature · 1 line
Alexandre Mergnat <[email protected]>
author
#5 lore raw

PATCH v4 3/3 clk: nuvoton: ma35d1: fix ma35d1_clk_pll_determine_rate logic

In reply to Joey Lu

ma35d1_clk_pll_determine_rate() called ma35d1_pll_find_closest() unconditionally before the switch statement, and then every case branch overwrote pll_freq by reading the current hardware registers. For CAPLL and DDRPLL this means find_closest() ran unnecessarily (and incorrectly, since those PLLs are read-only) and its result was silently discarded.

Fix by moving the find_closest() call inside the APLL/EPLL/VPLL branch where it belongs. Group CAPLL and DDRPLL together as read-only PLLs that simply report their current rate; handle them with an explicit if/else to keep the CAPLL (SMIC design) and DDRPLL (standard design) paths distinct.

Fixes 691521a367cf ("clk: nuvoton: Add clock driver for ma35d1 clock controller")
---
 drivers/clk/nuvoton/clk-ma35d1-pll.c | 26 +++++++++++++-------------
 1 file changed, 13 insertions(+), 13 deletions(-)
drivers/clk/nuvoton/clk-ma35d1-pll.c +13 -13
index eb9d69d2077b..c7c0dc91a012 100644
@@ -255,32 +255,32 @@ static int ma35d1_clk_pll_determine_rate(struct clk_hw *hw,
 	if (req->best_parent_rate < PLL_FREF_MIN_FREQ || req->best_parent_rate > PLL_FREF_MAX_FREQ)
 		return -EINVAL;
 
-	ret = ma35d1_pll_find_closest(pll, req->rate, req->best_parent_rate,
-				      reg_ctl, &pll_freq);
-	if (ret < 0)
-		return ret;
-
 	switch (pll->id) {
 	case CAPLL:
+	case DDRPLL:
+		/* Read-only PLLs: return current rate */
 		reg_ctl[0] = readl_relaxed(pll->ctl0_base);
-		pll_freq = ma35d1_calc_smic_pll_freq(reg_ctl[0], req->best_parent_rate);
+		if (pll->id == CAPLL) {
+			pll_freq = ma35d1_calc_smic_pll_freq(reg_ctl[0], req->best_parent_rate);
+		} else {
+			reg_ctl[1] = readl_relaxed(pll->ctl1_base);
+			pll_freq = ma35d1_calc_pll_freq(pll->mode, reg_ctl, req->best_parent_rate);
+		}
 		req->rate = pll_freq;
-
 		return 0;
-	case DDRPLL:
 	case APLL:
 	case EPLL:
 	case VPLL:
-		reg_ctl[0] = readl_relaxed(pll->ctl0_base);
-		reg_ctl[1] = readl_relaxed(pll->ctl1_base);
-		pll_freq = ma35d1_calc_pll_freq(pll->mode, reg_ctl, req->best_parent_rate);
+		/* Configurable PLLs: find closest achievable rate */
+		ret = ma35d1_pll_find_closest(pll, req->rate, req->best_parent_rate,
+					      reg_ctl, &pll_freq);
+		if (ret < 0)
+			return ret;
 		req->rate = pll_freq;
-
 		return 0;
 	}
 
 	req->rate = 0;
-
 	return 0;
 }
 
Signature · 1 line
2.43.0
Reviewed-by on v4 3/3
#6 lore raw

Re: [PATCH v4 3/3] clk: nuvoton: ma35d1: fix ma35d1_clk_pll_determine_rate logic

drivers/clk/nuvoton/clk-ma35d1-pll.c static int ma35d1_clk_pll_determine_rate(struct clk_hw *hw, · line 268

Quoted 12 lines · Joey Lu
drivers/clk/nuvoton/clk-ma35d1-pll.c +0 -0
index eb9d69d2077b..c7c0dc91a012 100644
@@ -255,32 +255,32 @@ static int ma35d1_clk_pll_determine_rate(struct clk_hw *hw,

[ ... skip 14 lines ... ]

drivers/clk/nuvoton/clk-ma35d1-pll.c +6 -0
+		if (pll->id == CAPLL) {
+			pll_freq = ma35d1_calc_smic_pll_freq(reg_ctl[0], req->best_parent_rate);
+		} else {
+			reg_ctl[1] = readl_relaxed(pll->ctl1_base);
+			pll_freq = ma35d1_calc_pll_freq(pll->mode, reg_ctl, req->best_parent_rate);
+		}

Small, non-blocking readability suggestion: since we just switched on pll->id, re-checking if (pll->id == CAPLL) inside the merged case reads a little redundant. Would it be cleaner to keep CAPLL and DDRPLL as separate case labels, mirroring ma35d1_clk_pll_recalc_rate() just above, where CAPLL is the SMIC-design special case and DDRPLL uses the standard calc, and share a single req->rate = pll_freq; return 0; tail? Roughly:

    case CAPLL:
            reg_ctl[0] = readl_relaxed(pll->ctl0_base);
            pll_freq = ma35d1_calc_smic_pll_freq(reg_ctl[0], req->best_parent_rate);
            break;
    case DDRPLL:
            reg_ctl[0] = readl_relaxed(pll->ctl0_base);
            reg_ctl[1] = readl_relaxed(pll->ctl1_base);
            pll_freq = ma35d1_calc_pll_freq(pll->mode, reg_ctl, req->best_parent_rate);
            break;
    case APLL:
    case EPLL:
    case VPLL:
            ret = ma35d1_pll_find_closest(...);
            if (ret < 0)
                    return ret;
            break;
    default:
            req->rate = 0;
            return 0;
    }
    req->rate = pll_freq;
    return 0;

That keeps determine_rate() and recalc_rate() structurally parallel. The logic as written looks correct either way, so please treat this purely as a readability suggestion.

Otherwise,

Signature · 1 line
Alexandre Mergnat <[email protected]>
author
#7 lore raw

Re: [PATCH v4 3/3] clk: nuvoton: ma35d1: fix ma35d1_clk_pll_determine_rate logic

Quoted 43 lines · Alexandre Mergnat

drivers/clk/nuvoton/clk-ma35d1-pll.c static int ma35d1_clk_pll_determine_rate(struct clk_hw *hw, · line 268

Quoted 12 lines · Joey Lu
drivers/clk/nuvoton/clk-ma35d1-pll.c +0 -0
index eb9d69d2077b..c7c0dc91a012 100644
@@ -255,32 +255,32 @@ static int ma35d1_clk_pll_determine_rate(struct clk_hw *hw,

[ ... skip 14 lines ... ]

drivers/clk/nuvoton/clk-ma35d1-pll.c +6 -0
+		if (pll->id == CAPLL) {
+			pll_freq = ma35d1_calc_smic_pll_freq(reg_ctl[0], req->best_parent_rate);
+		} else {
+			reg_ctl[1] = readl_relaxed(pll->ctl1_base);
+			pll_freq = ma35d1_calc_pll_freq(pll->mode, reg_ctl, req->best_parent_rate);
+		}

Small, non-blocking readability suggestion: since we just switched on pll->id, re-checking if (pll->id == CAPLL) inside the merged case reads a little redundant. Would it be cleaner to keep CAPLL and DDRPLL as separate case labels, mirroring ma35d1_clk_pll_recalc_rate() just above, where CAPLL is the SMIC-design special case and DDRPLL uses the standard calc, and share a single req->rate = pll_freq; return 0; tail? Roughly:

     case CAPLL:
             reg_ctl[0] = readl_relaxed(pll->ctl0_base);
             pll_freq = ma35d1_calc_smic_pll_freq(reg_ctl[0], req->best_parent_rate);
             break;
     case DDRPLL:
             reg_ctl[0] = readl_relaxed(pll->ctl0_base);
             reg_ctl[1] = readl_relaxed(pll->ctl1_base);
             pll_freq = ma35d1_calc_pll_freq(pll->mode, reg_ctl, req->best_parent_rate);
             break;
     case APLL:
     case EPLL:
     case VPLL:
             ret = ma35d1_pll_find_closest(...);
             if (ret < 0)
                     return ret;
             break;
     default:
             req->rate = 0;
             return 0;
     }
     req->rate = pll_freq;
     return 0;
Quoted 7 lines

That keeps determine_rate() and recalc_rate() structurally parallel. The logic as written looks correct either way, so please treat this purely as a readability suggestion.

Otherwise,

Thank you for the review and the Reviewed-by tag!

Agreed. CAPLL and DDRPLL will be split back into separate case labels so that determine_rate() stays structurally parallel with recalc_rate(), with the shared req->rate = pll_freq; return 0; tail after the switch and an explicit default: label for unknown PLL IDs. I'll include this cleanup in the next revision.

BR,
Joey