clk: nuvoton: ma35d1: fix PLL frequency calculation
Subsystems (2)
v3 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 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 idiomaticJoey 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
PATCH v3 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.
--- drivers/clk/nuvoton/clk-ma35d1-pll.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-)
drivers/clk/nuvoton/clk-ma35d1-pll.c +2 -2
@@ -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 pif (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
PATCH v3 2/3 clk: nuvoton: ma35d1: fix PLL_CTL1_FRAC bit field width and fractional calc
In reply to Joey LuPLL_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)
--- drivers/clk/nuvoton/clk-ma35d1-pll.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-)
drivers/clk/nuvoton/clk-ma35d1-pll.c +4 -4
@@ -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
Re: [PATCH v3 2/3] clk: nuvoton: ma35d1: fix PLL_CTL1_FRAC bit field width and fractional calc
Quoted 10 lines · Joey Lu
PLL_CTL1_FRACwas defined asGENMASK(31, 24), covering only 8 bits. The hardware fractional field occupies bits [31:8] (24 bits), so the mask must beGENMASK(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'sDIV_ROUND_CLOSEST_ULLhelper:
Quoted 4 lines
n_frac= n * 1000 +DIV_ROUND_CLOSEST_ULL(x * 1000, 1 << 24)Fixes 691521a367cf ("clk: nuvoton: Add clock driver for ma35d1 clock controller")Signed-off-by Joey Lu <[email protected]>
PATCH v3 3/3 clk: nuvoton: ma35d1: fix ma35d1_clk_pll_determine_rate logic
In reply to Joey Luma35d1_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.
--- drivers/clk/nuvoton/clk-ma35d1-pll.c | 26 +++++++++++++------------- 1 file changed, 13 insertions(+), 13 deletions(-)
drivers/clk/nuvoton/clk-ma35d1-pll.c +13 -13
@@ -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