clk: baikal-t1: Using div64_ Ul replaces do_ Div() function
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]
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
@@ -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; }
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 usingdiv64_ulinstead.Signed-off-by Yonggang Wu <[email protected]>---
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.
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 usingdiv64_ulinstead.Signed-off-by Yonggang Wu <[email protected]>
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
index13ef28001439..d41735c6956a100644drivers/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
-0return 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
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 usingdiv64_ulinstead.Signed-off-by Yonggang Wu <[email protected]>Thanks for your patch, which is now commit
b93d1331ea266dea("clk: baikal-t1: Usingdiv64_Ul replacesdo_Div()function") in clk/clk-next.Quoted 9 lines
b/drivers/clk/baikal-t1/ccu-pll.c
index13ef28001439..d41735c6956a100644drivers/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
-0return 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_clkis unsigned long, there is no need to usediv64_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^13ref_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
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 usingdiv64_ulinstead.Signed-off-by Yonggang Wu <[email protected]>Thanks for your patch, which is now commit
b93d1331ea266dea("clk: baikal-t1: Usingdiv64_Ul replacesdo_Div()function") in clk/clk-next.Quoted 17 lines
b/drivers/clk/baikal-t1/ccu-pll.c
index13ef28001439..d41735c6956a100644drivers/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_clkis unsigned long, there is no need to usediv64_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 thediv64_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^13ref_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:
+returndiv64_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
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 usingdiv64_ulinstead.Signed-off-by Yonggang Wu <[email protected]>Thanks for your patch, which is now commit
b93d1331ea266dea("clk: baikal-t1: Usingdiv64_Ul replacesdo_Div()function") in clk/clk-next.Quoted 17 lines
b/drivers/clk/baikal-t1/ccu-pll.c
index13ef28001439..d41735c6956a100644drivers/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_clkis unsigned long, there is no need to usediv64_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 thediv64_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 ofref_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)
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 usingdiv64_ulinstead.Signed-off-by Yonggang Wu <[email protected]>Thanks for your patch, which is now commit
b93d1331ea266dea("clk: baikal-t1: Usingdiv64_Ul replacesdo_Div()function") in clk/clk-next.Quoted 17 lines
b/drivers/clk/baikal-t1/ccu-pll.c
index13ef28001439..d41735c6956a100644drivers/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_clkis unsigned long, there is no need to usediv64_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 thediv64_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 ofref_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^13ref_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:
+returndiv64_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
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 usingdiv64_ulinstead.Signed-off-by Yonggang Wu <[email protected]>Thanks for your patch, which is now commit
b93d1331ea266dea("clk: baikal-t1: Usingdiv64_Ul replacesdo_Div()function") in clk/clk-next.Quoted 17 lines
b/drivers/clk/baikal-t1/ccu-pll.c
index13ef28001439..d41735c6956a100644drivers/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_clkis unsigned long, there is no need to usediv64_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 thediv64_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 ofref_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^13ref_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:
+returndiv64_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 themul_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
Stephen Boyd
maintainerQuoting 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.
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)