Skip to contentSkip to conversation

clk: baikal-t1: Using div64_ Ul replaces do_ Div() function

PATCH Applied [email protected] 5 participants 10 messages Jun 14, 2023 – Jul 31, 2023 2 messages not in the archive Common clk

lore
Share & tools
lore

A message that is not in the archive (sent off-list or not yet received): [email protected]

A message that is not in the archive (sent off-list or not yet received): [email protected]

#2 lore raw

PATCH 1/1 clk: baikal-t1: Using div64_ Ul replaces do_ Div() function

Fix the following coccicheck warning:

drivers/clk/baikal-t1/ccu-pll.c:81:1-7: WARNING: do_div() does a 64-by-32 division, please consider using div64_ul instead.

---
 drivers/clk/baikal-t1/ccu-pll.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)
drivers/clk/baikal-t1/ccu-pll.c +3 -3
index 13ef28001439..d41735c6956a 100644
@@ -66,7 +66,7 @@ static inline unsigned long ccu_pll_lock_delay_us(unsigned long ref_clk,
 {
     u64 us = 500ULL * nr * USEC_PER_SEC;
 
-    do_div(us, ref_clk);
+    div64_ul(us, ref_clk);
 
     return us;
 }
@@ -78,9 +78,9 @@ static inline unsigned long ccu_pll_calc_freq(unsigned long ref_clk,
 {
     u64 tmp = ref_clk;
 
-    do_div(tmp, nr);
+    div64_ul(tmp, nr);
     tmp *= nf;
-    do_div(tmp, od);
+    div64_ul(tmp, od);
 
     return tmp;
 }
maintainer Applied
#3 lore raw

Quoting [email protected] (2023-06-13 22:45:48)

Quoted 7 lines

Fix the following coccicheck warning:

drivers/clk/baikal-t1/ccu-pll.c:81:1-7: WARNING: do_div() does a 64-by-32 division, please consider using div64_ul instead.

---

Applied to clk-next

I had to manually apply it though and I had to fix the author to match the SoB. Please take more care next time.

#4 lore raw
In reply to [email protected]

Hi Yonggang,

CC Serge

Quoted 6 lines · On Wed, Jun 14, 2023 at 8:07 AM <[email protected]> wrote:

Fix the following coccicheck warning:

drivers/clk/baikal-t1/ccu-pll.c:81:1-7: WARNING: do_div() does a 64-by-32 division, please consider using div64_ul instead.

Thanks for your patch, which is now commit b93d1331ea266dea ("clk: baikal-t1: Using div64_ Ul replaces do_ Div() function") in clk/clk-next.

drivers/clk/baikal-t1/ccu-pll.c static inline unsigned long · line 70

Quoted 11 lines

b/drivers/clk/baikal-t1/ccu-pll.c
index 13ef28001439..d41735c6956a 100644

drivers/clk/baikal-t1/ccu-pll.c +1 -1
@@ -66,7 +66,7 @@ static inline unsigned long
 ccu_pll_lock_delay_us(unsigned long ref_clk,
  {
      u64 us = 500ULL * nr * USEC_PER_SEC;
 
-    do_div(us, ref_clk);
+    div64_ul(us, ref_clk);

The above is not equivalent:
- do_div() returned the quotient as an output parameter in us,
- div64_ul() returns the quotient using the return value.

Have you tested your patch?

drivers/clk/baikal-t1/ccu-pll.c static inline unsigned long ccu_pll_lock_delay_us(unsigned long ref_clk, · line 71

Quoted 2 lines
drivers/clk/baikal-t1/ccu-pll.c +0 -0
      return us;

So this should become:

    return div64_ul(500ULL * nr * USEC_PER_SEC, ref_clk);

drivers/clk/baikal-t1/ccu-pll.c static inline unsigned long ccu_pll_calc_freq(unsigned · line 86

Quoted 13 lines
drivers/clk/baikal-t1/ccu-pll.c +2 -2
  }
@@ -78,9 +78,9 @@ static inline unsigned long ccu_pll_calc_freq(unsigned
 long ref_clk,
  {
      u64 tmp = ref_clk;
 
-    do_div(tmp, nr);
+    div64_ul(tmp, nr);
      tmp *= nf;
-    do_div(tmp, od);
+    div64_ul(tmp, od);
 
      return tmp;

Likewise.
But as ref_clk is unsigned long, there is no need to use div64_ul() for the first division, and this can be simplified to:

    u64 tmp = (u64)(ref_clk / nr) * nf;
    return div64_ul(tmp, od);

To avoid loss of precision, it might be better to reverse the order of the division and multiplication:

    u64 tmp = (u64)ref_clk * nf / nr;

But doing that requires intimate knowledge about the range of nf to avoid overflow, so I leave that to Serge.

Quoted 1 line
  }

Gr{oetje,eeting}s,

Geert

Signature · 5 lines
Geert Uytterhoeven -- There's lots of Linux beyond ia32 -- [email protected]

In personal conversations with technical people, I call myself a hacker. But
when I'm talking to journalists I just say "programmer" or something like that.
                                -- Linus Torvalds
#5 lore raw

Hi Geert

Quoted 3 lines · Geert Uytterhoeven

Hi Yonggang,

CC Serge

Thanks for Cc-ing me.

Quoted 23 lines · On Wed, Jun 14, 2023 at 8:07 AM <[email protected]> wrote:
Quoted 6 lines

Fix the following coccicheck warning:

drivers/clk/baikal-t1/ccu-pll.c:81:1-7: WARNING: do_div() does a 64-by-32 division, please consider using div64_ul instead.

Thanks for your patch, which is now commit b93d1331ea266dea ("clk: baikal-t1: Using div64_ Ul replaces do_ Div() function") in clk/clk-next.

Quoted 9 lines

b/drivers/clk/baikal-t1/ccu-pll.c
index 13ef28001439..d41735c6956a 100644

drivers/clk/baikal-t1/ccu-pll.c +0 -0
@@ -66,7 +66,7 @@ static inline unsigned long
 ccu_pll_lock_delay_us(unsigned long ref_clk,
  {
      u64 us = 500ULL * nr * USEC_PER_SEC;
 
Quoted 6 lines

drivers/clk/baikal-t1/ccu-pll.c static inline unsigned long ccu_pll_lock_delay_us(unsigned long ref_clk, · line 69

Quoted 2 lines
drivers/clk/baikal-t1/ccu-pll.c +1 -1
-    do_div(us, ref_clk);
+    div64_ul(us, ref_clk);

The above is not equivalent:
- do_div() returned the quotient as an output parameter in us,
- div64_ul() returns the quotient using the return value.

Indeed, leaving the patch as is will break the driver for sure. do_div() and div64_ul() aren't equivalent in regard of the return values. So this update will cause the ccu_pll_lock_delay_us() returning "500ULL * nr * USEC_PER_SEC" instead of "(500ULL * nr * USEC_PER_SEC) / ref_clk".

Quoted 9 lines

Have you tested your patch?

drivers/clk/baikal-t1/ccu-pll.c static inline unsigned long ccu_pll_lock_delay_us(unsigned long ref_clk, · line 71

Quoted 2 lines
drivers/clk/baikal-t1/ccu-pll.c +0 -0
      return us;

So this should become:

    return div64_ul(500ULL * nr * USEC_PER_SEC, ref_clk);

This would be the correct fix. But I would either retain the local "us" variable here or fixed the drivers/clk/baikal-t1/ccu-div.c:ccu_div_lock_delay_ns() function too for the sake of the driver unification. The later is preferable though.

Quoted 14 lines
Quoted 14 lines
drivers/clk/baikal-t1/ccu-pll.c +2 -2
  }
@@ -78,9 +78,9 @@ static inline unsigned long ccu_pll_calc_freq(unsigned
 long ref_clk,
  {
      u64 tmp = ref_clk;
 
 
-    do_div(tmp, nr);
+    div64_ul(tmp, nr);
      tmp *= nf;
-    do_div(tmp, od);
+    div64_ul(tmp, od);
 
Quoted 3 lines
Quoted 1 line
      return tmp;

Likewise.

Right. This will also break the driver.

Quoted 5 lines

But as ref_clk is unsigned long, there is no need to use div64_ul() for the first division, and this can be simplified to:

    u64 tmp = (u64)(ref_clk / nr) * nf;
    return div64_ul(tmp, od);

Absolutely right. My intention of using the do_div() anyway was for the sake of the code unification.

Quoted 6 lines

To avoid loss of precision, it might be better to reverse the order of the division and multiplication:

    u64 tmp = (u64)ref_clk * nf / nr;

Alas exactly this code will cause the compilation error on the 32-bit platform:
ccu-pll.c:(.text+0x458): undefined reference to `__udivdi3'

That's why I am using the do_div() here. I would have rather used the div64_ul() instead as this patch suggests, but I haven't known about its existence up to this moment.

Anyway my intention of dividing before multiplying had twofold justification. Firstly I didn't want to use the "/" operator and do_div() macro in the statements used to implement the same formulae. Since I couldn't use the operator I decided to use the macro only for the code unification. Secondly the PLL is designed in a way so the signal is first divided by NR, then multiplied by NF and then divided by OD. That's why I decided to preserve the same order in the calculations here. I assumed back then that the NR-divider performs the integer division in the analog circuitry. I have doubts now that my assumption was correct since it's analog device and most likely divides the source signal with no integer rounding-up. So using the order suggested by you would have likely given a more exact result.

Quoted 3 lines

But doing that requires intimate knowledge about the range of nf to avoid overflow, so I leave that to Serge.

nr: 1 - 2^6
nf: 1 - 2^13
ref_clk: normally 25'000'000 Hz.
Using "unsigned long"/u32 multiplication will give the integer overflow. Meanwhile the u64 arithmetics will be more than enough here.

So to speak the next alteration seems more correct here:
+return div64_ul(div64_ul((u64)ref_clk * nf, nr), od);

What do you think?

Yonggang, several comments:
1. Could you please include the "linux/math64.h" header file to the driver?
2. Could you please fix the same thing in the ccu-div.c file too?

-Serge(y)

Quoted 13 lines
Quoted 2 lines
  }

Gr{oetje,eeting}s,

Geert

Signature · 5 lines
Geert Uytterhoeven -- There's lots of Linux beyond ia32 -- [email protected]

In personal conversations with technical people, I call myself a hacker. But
when I'm talking to journalists I just say "programmer" or something like that.
                                -- Linus Torvalds
#6 lore raw

Hi Serge,

Quoted 52 lines · Serge Semin
Quoted 29 lines · Geert Uytterhoeven
Quoted 6 lines · On Wed, Jun 14, 2023 at 8:07 AM <[email protected]> wrote:

Fix the following coccicheck warning:

drivers/clk/baikal-t1/ccu-pll.c:81:1-7: WARNING: do_div() does a 64-by-32 division, please consider using div64_ul instead.

Thanks for your patch, which is now commit b93d1331ea266dea ("clk: baikal-t1: Using div64_ Ul replaces do_ Div() function") in clk/clk-next.

Quoted 17 lines

b/drivers/clk/baikal-t1/ccu-pll.c
index 13ef28001439..d41735c6956a 100644

drivers/clk/baikal-t1/ccu-pll.c +2 -2
@@ -78,9 +78,9 @@ static inline unsigned long ccu_pll_calc_freq(unsigned
 long ref_clk,
  {
      u64 tmp = ref_clk;
 
 
-    do_div(tmp, nr);
+    div64_ul(tmp, nr);
      tmp *= nf;
-    do_div(tmp, od);
+    div64_ul(tmp, od);
 
Quoted 3 lines
Quoted 1 line
      return tmp;

Likewise.

Right. This will also break the driver.

Quoted 5 lines

But as ref_clk is unsigned long, there is no need to use div64_ul() for the first division, and this can be simplified to:

    u64 tmp = (u64)(ref_clk / nr) * nf;
    return div64_ul(tmp, od);

Absolutely right. My intention of using the do_div() anyway was for the sake of the code unification.

Quoted 6 lines

To avoid loss of precision, it might be better to reverse the order of the division and multiplication:

    u64 tmp = (u64)ref_clk * nf / nr;
Quoted 7 lines

Alas exactly this code will cause the compilation error on the 32-bit platform:
ccu-pll.c:(.text+0x458): undefined reference to `__udivdi3'

That's why I am using the do_div() here. I would have rather used the div64_ul() instead as this patch suggests, but I haven't known about its existence up to this moment.

Bummer, that was a silly mistake on my side...
(Initially, I didn't write the cast to u64 there, as all of ref_clk, nf, and nr
are unsigned long. Then I realized "ref_clk * nf" might overflow on 32-bit, thus requiring a 64-bit result. And I added the cast...)

Quoted 23 lines

Anyway my intention of dividing before multiplying had twofold justification. Firstly I didn't want to use the "/" operator and do_div() macro in the statements used to implement the same formulae. Since I couldn't use the operator I decided to use the macro only for the code unification. Secondly the PLL is designed in a way so the signal is first divided by NR, then multiplied by NF and then divided by OD. That's why I decided to preserve the same order in the calculations here. I assumed back then that the NR-divider performs the integer division in the analog circuitry. I have doubts now that my assumption was correct since it's analog device and most likely divides the source signal with no integer rounding-up. So using the order suggested by you would have likely given a more exact result.

Quoted 3 lines

But doing that requires intimate knowledge about the range of nf to avoid overflow, so I leave that to Serge.

nr: 1 - 2^6
nf: 1 - 2^13
ref_clk: normally 25'000'000 Hz.
Using "unsigned long"/u32 multiplication will give the integer overflow. Meanwhile the u64 arithmetics will be more than enough here.

Quoted 4 lines

So to speak the next alteration seems more correct here:
+return div64_ul(div64_ul((u64)ref_clk * nf, nr), od);

What do you think?

Given the ranges above, nr and nf can be u32 instead of unsigned long. So perhaps it makes sense to use the mul_u64_u32_div() helper?

    return div64_ul(mul_u64_u32_div(ref_clk, nf, nr), of);

Gr{oetje,eeting}s,

Geert

Signature · 5 lines
Geert Uytterhoeven -- There's lots of Linux beyond ia32 -- [email protected]

In personal conversations with technical people, I call myself a hacker. But
when I'm talking to journalists I just say "programmer" or something like that.
                                -- Linus Torvalds
#7 lore raw

From: Geert Uytterhoeven

Quoted 61 lines

Sent: 24 July 2023 14:39

Hi Serge,

Quoted 56 lines · Serge Semin
Quoted 29 lines · Geert Uytterhoeven
Quoted 6 lines · On Wed, Jun 14, 2023 at 8:07 AM <[email protected]> wrote:

Fix the following coccicheck warning:

drivers/clk/baikal-t1/ccu-pll.c:81:1-7: WARNING: do_div() does a 64-by-32 division, please consider using div64_ul instead.

Thanks for your patch, which is now commit b93d1331ea266dea ("clk: baikal-t1: Using div64_ Ul replaces do_ Div() function") in clk/clk-next.

Quoted 17 lines

b/drivers/clk/baikal-t1/ccu-pll.c
index 13ef28001439..d41735c6956a 100644

drivers/clk/baikal-t1/ccu-pll.c +2 -2
@@ -78,9 +78,9 @@ static inline unsigned long ccu_pll_calc_freq(unsigned
 long ref_clk,
  {
      u64 tmp = ref_clk;
 
 
-    do_div(tmp, nr);
+    div64_ul(tmp, nr);
      tmp *= nf;
-    do_div(tmp, od);
+    div64_ul(tmp, od);
 
Quoted 3 lines
Quoted 1 line
      return tmp;

Likewise.

Right. This will also break the driver.

Quoted 5 lines

But as ref_clk is unsigned long, there is no need to use div64_ul() for the first division, and this can be simplified to:

    u64 tmp = (u64)(ref_clk / nr) * nf;
    return div64_ul(tmp, od);

Absolutely right. My intention of using the do_div() anyway was for the sake of the code unification.

Quoted 6 lines

To avoid loss of precision, it might be better to reverse the order of the division and multiplication:

    u64 tmp = (u64)ref_clk * nf / nr;

Alas exactly this code will cause the compilation error on the 32-bit platform:
ccu-pll.c:(.text+0x458): undefined reference to `__udivdi3'

Quoted 8 lines
Quoted 3 lines

That's why I am using the do_div() here. I would have rather used the div64_ul() instead as this patch suggests, but I haven't known about its existence up to this moment.

Bummer, that was a silly mistake on my side...
(Initially, I didn't write the cast to u64 there, as all of ref_clk, nf, and nr
are unsigned long. Then I realized "ref_clk * nf" might overflow on 32-bit, thus requiring a 64-bit result. And I added the cast...)

But on 32bit the result is 'long'.
So it will overflow unless do_div() is also valid.

The analysis need to look at the domain of the values. The warning and suggestion to use div64_ul() is pretty much always wrong.

div64_ul() is going to be horribly slow on 32bit.
Also on 64bit Intel cpu the 128/64 divide takes twice as long as 64/32 even when the values are small.

David

-
Registered Address Lakeside, Bramley Road, Mount Farm, Milton Keynes, MK1 1PT, UK Registration No: 1397386 (Wales)

#8 lore raw
In reply to Geert Uytterhoeven
Quoted 94 lines · Geert Uytterhoeven

Hi Serge,

Quoted 52 lines · Serge Semin
Quoted 29 lines · Geert Uytterhoeven
Quoted 6 lines · On Wed, Jun 14, 2023 at 8:07 AM <[email protected]> wrote:

Fix the following coccicheck warning:

drivers/clk/baikal-t1/ccu-pll.c:81:1-7: WARNING: do_div() does a 64-by-32 division, please consider using div64_ul instead.

Thanks for your patch, which is now commit b93d1331ea266dea ("clk: baikal-t1: Using div64_ Ul replaces do_ Div() function") in clk/clk-next.

Quoted 17 lines

b/drivers/clk/baikal-t1/ccu-pll.c
index 13ef28001439..d41735c6956a 100644

drivers/clk/baikal-t1/ccu-pll.c +2 -2
@@ -78,9 +78,9 @@ static inline unsigned long ccu_pll_calc_freq(unsigned
 long ref_clk,
  {
      u64 tmp = ref_clk;
 
 
-    do_div(tmp, nr);
+    div64_ul(tmp, nr);
      tmp *= nf;
-    do_div(tmp, od);
+    div64_ul(tmp, od);
 
Quoted 3 lines
Quoted 1 line
      return tmp;

Likewise.

Right. This will also break the driver.

Quoted 5 lines

But as ref_clk is unsigned long, there is no need to use div64_ul() for the first division, and this can be simplified to:

    u64 tmp = (u64)(ref_clk / nr) * nf;
    return div64_ul(tmp, od);

Absolutely right. My intention of using the do_div() anyway was for the sake of the code unification.

Quoted 6 lines

To avoid loss of precision, it might be better to reverse the order of the division and multiplication:

    u64 tmp = (u64)ref_clk * nf / nr;
Quoted 7 lines

Alas exactly this code will cause the compilation error on the 32-bit platform:
ccu-pll.c:(.text+0x458): undefined reference to `__udivdi3'

That's why I am using the do_div() here. I would have rather used the div64_ul() instead as this patch suggests, but I haven't known about its existence up to this moment.

Bummer, that was a silly mistake on my side...
(Initially, I didn't write the cast to u64 there, as all of ref_clk, nf, and nr
are unsigned long. Then I realized "ref_clk * nf" might overflow on 32-bit, thus requiring a 64-bit result. And I added the cast...)

Quoted 26 lines

Anyway my intention of dividing before multiplying had twofold justification. Firstly I didn't want to use the "/" operator and do_div() macro in the statements used to implement the same formulae. Since I couldn't use the operator I decided to use the macro only for the code unification. Secondly the PLL is designed in a way so the signal is first divided by NR, then multiplied by NF and then divided by OD. That's why I decided to preserve the same order in the calculations here. I assumed back then that the NR-divider performs the integer division in the analog circuitry. I have doubts now that my assumption was correct since it's analog device and most likely divides the source signal with no integer rounding-up. So using the order suggested by you would have likely given a more exact result.

Quoted 3 lines

But doing that requires intimate knowledge about the range of nf to avoid overflow, so I leave that to Serge.

nr: 1 - 2^6
nf: 1 - 2^13
ref_clk: normally 25'000'000 Hz.
Using "unsigned long"/u32 multiplication will give the integer overflow. Meanwhile the u64 arithmetics will be more than enough here.

So to speak the next alteration seems more correct here:
+return div64_ul(div64_ul((u64)ref_clk * nf, nr), od);

Quoted 7 lines
Quoted 1 line

What do you think?

Given the ranges above, nr and nf can be u32 instead of unsigned long. So perhaps it makes sense to use the mul_u64_u32_div() helper?

    return div64_ul(mul_u64_u32_div(ref_clk, nf, nr), of);

Just a day of discoveries today.) Didn't know about the mul_u64_u32_div() existence either. Thanks for suggestion. Anyway seeing "unsigned long" is 32-bits wide on my platform, nr/nf/od will always be within the specified ranges, why not. Although using two div64_ul()'s seems a bit more readable. But it might be just because of me not being used to the mul_u64_u32_div() prototype notation.

-Serge(y)

Quoted 11 lines

Gr{oetje,eeting}s,

Geert

Signature · 5 lines
Geert Uytterhoeven -- There's lots of Linux beyond ia32 -- [email protected]

In personal conversations with technical people, I call myself a hacker. But
when I'm talking to journalists I just say "programmer" or something like that.
                                -- Linus Torvalds
#9 lore raw

Hi Geert, Stephen

Quoted 34 lines · Serge Semin
Quoted 33 lines · Geert Uytterhoeven

Hi Serge,

Quoted 30 lines · Serge Semin
Quoted 29 lines · Geert Uytterhoeven
Quoted 6 lines · On Wed, Jun 14, 2023 at 8:07 AM <[email protected]> wrote:

Fix the following coccicheck warning:

drivers/clk/baikal-t1/ccu-pll.c:81:1-7: WARNING: do_div() does a 64-by-32 division, please consider using div64_ul instead.

Thanks for your patch, which is now commit b93d1331ea266dea ("clk: baikal-t1: Using div64_ Ul replaces do_ Div() function") in clk/clk-next.

Quoted 17 lines

b/drivers/clk/baikal-t1/ccu-pll.c
index 13ef28001439..d41735c6956a 100644

drivers/clk/baikal-t1/ccu-pll.c +2 -2
@@ -78,9 +78,9 @@ static inline unsigned long ccu_pll_calc_freq(unsigned
 long ref_clk,
  {
      u64 tmp = ref_clk;
 
 
-    do_div(tmp, nr);
+    div64_ul(tmp, nr);
      tmp *= nf;
-    do_div(tmp, od);
+    div64_ul(tmp, od);
 
Quoted 5 lines
Quoted 5 lines
Quoted 5 lines
Quoted 3 lines
Quoted 1 line
      return tmp;

Likewise.

Right. This will also break the driver.

No news from Yonggang meanwhile the patch will certainly break the driver. Is it still possible to drop it from the clk-cleanup and clk-next branches then before it gets to the mainline kernel?

-Serge(y)

Quoted 84 lines
Quoted 56 lines
Quoted 17 lines
Quoted 6 lines

But as ref_clk is unsigned long, there is no need to use div64_ul() for the first division, and this can be simplified to:

    u64 tmp = (u64)(ref_clk / nr) * nf;
    return div64_ul(tmp, od);

Absolutely right. My intention of using the do_div() anyway was for the sake of the code unification.

Quoted 6 lines

To avoid loss of precision, it might be better to reverse the order of the division and multiplication:

    u64 tmp = (u64)ref_clk * nf / nr;
Quoted 7 lines

Alas exactly this code will cause the compilation error on the 32-bit platform:
ccu-pll.c:(.text+0x458): undefined reference to `__udivdi3'

That's why I am using the do_div() here. I would have rather used the div64_ul() instead as this patch suggests, but I haven't known about its existence up to this moment.

Bummer, that was a silly mistake on my side...
(Initially, I didn't write the cast to u64 there, as all of ref_clk, nf, and nr
are unsigned long. Then I realized "ref_clk * nf" might overflow on 32-bit, thus requiring a 64-bit result. And I added the cast...)

Quoted 26 lines

Anyway my intention of dividing before multiplying had twofold justification. Firstly I didn't want to use the "/" operator and do_div() macro in the statements used to implement the same formulae. Since I couldn't use the operator I decided to use the macro only for the code unification. Secondly the PLL is designed in a way so the signal is first divided by NR, then multiplied by NF and then divided by OD. That's why I decided to preserve the same order in the calculations here. I assumed back then that the NR-divider performs the integer division in the analog circuitry. I have doubts now that my assumption was correct since it's analog device and most likely divides the source signal with no integer rounding-up. So using the order suggested by you would have likely given a more exact result.

Quoted 3 lines

But doing that requires intimate knowledge about the range of nf to avoid overflow, so I leave that to Serge.

nr: 1 - 2^6
nf: 1 - 2^13
ref_clk: normally 25'000'000 Hz.
Using "unsigned long"/u32 multiplication will give the integer overflow. Meanwhile the u64 arithmetics will be more than enough here.

So to speak the next alteration seems more correct here:
+return div64_ul(div64_ul((u64)ref_clk * nf, nr), od);

Quoted 7 lines
Quoted 1 line

What do you think?

Given the ranges above, nr and nf can be u32 instead of unsigned long. So perhaps it makes sense to use the mul_u64_u32_div() helper?

    return div64_ul(mul_u64_u32_div(ref_clk, nf, nr), of);

Just a day of discoveries today.) Didn't know about the mul_u64_u32_div() existence either. Thanks for suggestion. Anyway seeing "unsigned long" is 32-bits wide on my platform, nr/nf/od will always be within the specified ranges, why not. Although using two div64_ul()'s seems a bit more readable. But it might be just because of me not being used to the mul_u64_u32_div() prototype notation.

-Serge(y)

Quoted 11 lines

Gr{oetje,eeting}s,

Geert

Signature · 5 lines
Geert Uytterhoeven -- There's lots of Linux beyond ia32 -- [email protected]

In personal conversations with technical people, I call myself a hacker. But
when I'm talking to journalists I just say "programmer" or something like that.
                                -- Linus Torvalds
maintainer
#10 lore raw

Quoting Serge Semin (2023-07-27 05:28:47)

Quoted 11 lines · Serge Semin
Quoted 5 lines · Geert Uytterhoeven
Quoted 4 lines
Quoted 4 lines
Quoted 2 lines

Likewise.

Right. This will also break the driver.

No news from Yonggang meanwhile the patch will certainly break the driver. Is it still possible to drop it from the clk-cleanup and clk-next branches then before it gets to the mainline kernel?

I've dropped it.

#11 lore raw
Quoted 6 lines · Stephen Boyd

Quoting Serge Semin (2023-07-27 05:28:47)

Quoted 5 lines · Serge Semin
Quoted 4 lines · Geert Uytterhoeven
Quoted 3 lines
Quoted 3 lines
Quoted 2 lines

Likewise.

Quoted 8 lines
Quoted 6 lines
Quoted 1 line
Quoted 1 line
Quoted 1 line

Right. This will also break the driver.

No news from Yonggang meanwhile the patch will certainly break the driver. Is it still possible to drop it from the clk-cleanup and clk-next branches then before it gets to the mainline kernel?

I've dropped it.

Great! Thanks.

-Serge(y)