* [PATCH v4 0/2] rust: add u64 division helpers and fix the pwm_th1520 32-bit build
@ 2026-11-18 22:48 FUJITA Tomonori
2026-11-18 22:48 ` [PATCH v4 1/2] rust: math: add div64_u64() and div64_u64_round_up() FUJITA Tomonori
2026-11-18 22:48 ` [PATCH v4 2/2] pwm: th1520: Fix 32-bit build with COMPILE_TEST FUJITA Tomonori
0 siblings, 2 replies; 6+ messages in thread
From: FUJITA Tomonori @ 2026-11-18 22:48 UTC (permalink / raw)
To: fustini, guoren, ojeda, ukleinek, wefu
Cc: a.hindborg, acourbot, aliceryhl, bjorn3_gh, boqun,
chenhan0017.work, dakr, daniel.almeida, gary, linux-riscv, lossin,
m.wilczynski, tamird, tmgross, work, linux-pwm, rust-for-linux,
FUJITA Tomonori
From: FUJITA Tomonori <fujita.tomonori@gmail.com>
This series fixes the 32-bit build of the TH1520 PWM driver with
COMPILE_TEST.
Patch 1 adds a math module to the kernel crate with Rust versions of
div64_u64() and DIV64_U64_ROUND_UP(). Patch 2 uses them in the driver.
The driver only needs u64 by u64 division. It does not need a 128-bit
intermediate value like mul_u64_u64_div_u64().
Miguel, Uwe acked patch 2 and is fine with this series going through
the Rust tree.
chenhan's patch [1] also adds rust/kernel/math.rs, with signed
division helpers. Both use the same module header, so whichever
is applied later needs only a small rebase.
Tested with the doctests on x86_64 and 32-bit ARM QEMU.
[1] https://lore.kernel.org/rust-for-linux/20261031103206.24051-4-chenhan0017.work@gmail.com/
v4:
- Add #[track_caller] to both helpers (Alice)
- Check for a zero divisor only on 32-bit, and use the panic of `/` on
64-bit (Alice)
- Add Uwe's Acked-by to patch 2
- Rebase on v7.4-rc3
v3: https://lore.kernel.org/rust-for-linux/20261030020209.3833766-1-tomo@flapping.org/
- Use div helpers instead of limiting COMPILE_TEST to 64BIT (Uwe)
- Add a math module with div64_u64() and div64_u64_round_up()
- Drop Cc: stable and the Reviewed-by tags, since the change is different
v2: https://lore.kernel.org/rust-for-linux/20260930101257.1649945-1-tomo@flapping.org/
- Fix a typo in the commit message
- Add Cc: stable, Reported-by and Closes tags
- Add Reviewed-by tags from Andreas and Gary
- Rebase on v7.3-rc5
v1: https://lore.kernel.org/all/20260929095612.1072417-1-tomo@flapping.org/
FUJITA Tomonori (2):
rust: math: add div64_u64() and div64_u64_round_up()
pwm: th1520: Fix 32-bit build with COMPILE_TEST
drivers/pwm/pwm_th1520.rs | 8 +++--
rust/kernel/lib.rs | 1 +
rust/kernel/math.rs | 73 +++++++++++++++++++++++++++++++++++++++
3 files changed, 80 insertions(+), 2 deletions(-)
create mode 100644 rust/kernel/math.rs
base-commit: aebb7274476403040d582c61478df8f4a7bf9cd3
--
2.43.0
^ permalink raw reply [flat|nested] 6+ messages in thread
* [PATCH v4 1/2] rust: math: add div64_u64() and div64_u64_round_up()
2026-11-18 22:48 [PATCH v4 0/2] rust: add u64 division helpers and fix the pwm_th1520 32-bit build FUJITA Tomonori
@ 2026-11-18 22:48 ` FUJITA Tomonori
2026-11-18 22:53 ` Danilo Krummrich
2026-11-18 23:23 ` Alice Ryhl
2026-11-18 22:48 ` [PATCH v4 2/2] pwm: th1520: Fix 32-bit build with COMPILE_TEST FUJITA Tomonori
1 sibling, 2 replies; 6+ messages in thread
From: FUJITA Tomonori @ 2026-11-18 22:48 UTC (permalink / raw)
To: fustini, guoren, ojeda, ukleinek, wefu
Cc: a.hindborg, acourbot, aliceryhl, bjorn3_gh, boqun,
chenhan0017.work, dakr, daniel.almeida, gary, linux-riscv, lossin,
m.wilczynski, tamird, tmgross, work, linux-pwm, rust-for-linux,
FUJITA Tomonori
From: FUJITA Tomonori <fujita.tomonori@gmail.com>
On 32-bit architectures, dividing a u64 by a u64 with the `/` operator
makes the compiler emit a call to a compiler runtime function, such as
__aeabi_uldivmod() on arm. The kernel does not provide these functions,
so the build fails when Rust code that is also built for 32-bit
architectures uses `/` on u64.
C code uses the helpers in include/linux/math64.h instead. Add a math
module with Rust versions of two of them:
- div64_u64(), the same as div64_u64() in C.
- div64_u64_round_up(), the same as DIV64_U64_ROUND_UP() in C.
On 64-bit architectures, both use `/`. On 32-bit architectures,
div64_u64() calls the C function. Both panic if the divisor is zero,
as `/` does.
Signed-off-by: FUJITA Tomonori <fujita.tomonori@gmail.com>
---
rust/kernel/lib.rs | 1 +
rust/kernel/math.rs | 73 +++++++++++++++++++++++++++++++++++++++++++++
2 files changed, 74 insertions(+)
create mode 100644 rust/kernel/math.rs
diff --git a/rust/kernel/lib.rs b/rust/kernel/lib.rs
index 1ab41129d557..482fef8be2e8 100644
--- a/rust/kernel/lib.rs
+++ b/rust/kernel/lib.rs
@@ -100,6 +100,7 @@
pub mod kunit;
pub mod list;
pub mod maple_tree;
+pub mod math;
pub mod mem;
pub mod miscdevice;
pub mod mm;
diff --git a/rust/kernel/math.rs b/rust/kernel/math.rs
new file mode 100644
index 000000000000..909afcf8dfa2
--- /dev/null
+++ b/rust/kernel/math.rs
@@ -0,0 +1,73 @@
+// SPDX-License-Identifier: GPL-2.0
+
+//! Integer arithmetic helpers.
+//!
+//! C header: [`include/linux/math64.h`](srctree/include/linux/math64.h).
+
+/// Divides a [`u64`] dividend by a [`u64`] divisor, rounding down.
+///
+/// On 32-bit architectures, `/` on [`u64`] needs a function that the kernel does
+/// not provide. Use this function in code that is also built for 32-bit
+/// architectures.
+///
+/// # Panics
+///
+/// Panics if `divisor` is zero.
+///
+/// # Examples
+///
+/// ```
+/// use kernel::math::div64_u64;
+///
+/// assert_eq!(div64_u64(7, 2), 3);
+/// assert_eq!(div64_u64(u64::MAX, 1 << 32), u64::from(u32::MAX));
+/// ```
+#[track_caller]
+#[inline]
+pub fn div64_u64(dividend: u64, divisor: u64) -> u64 {
+ #[cfg(CONFIG_64BIT)]
+ {
+ dividend / divisor
+ }
+
+ #[cfg(not(CONFIG_64BIT))]
+ {
+ if divisor == 0 {
+ panic!("attempt to divide by zero");
+ }
+
+ // SAFETY: `div64_u64()` requires a non-zero `divisor`, which is
+ // checked above.
+ unsafe { bindings::div64_u64(dividend, divisor) }
+ }
+}
+
+/// Divides a [`u64`] dividend by a [`u64`] divisor, rounding up.
+///
+/// # Panics
+///
+/// Panics if `divisor` is zero.
+///
+/// # Examples
+///
+/// ```
+/// use kernel::math::div64_u64_round_up;
+///
+/// assert_eq!(div64_u64_round_up(7, 2), 4);
+/// assert_eq!(div64_u64_round_up(6, 2), 3);
+/// assert_eq!(div64_u64_round_up(u64::MAX, 2), 1 << 63);
+/// ```
+#[track_caller]
+#[inline]
+pub fn div64_u64_round_up(dividend: u64, divisor: u64) -> u64 {
+ let quotient = div64_u64(dividend, divisor);
+
+ // `quotient * divisor` is not greater than `dividend`, so this does not
+ // overflow.
+ if dividend - quotient * divisor == 0 {
+ quotient
+ } else {
+ // A non-zero remainder means `divisor >= 2`, so this does not overflow.
+ quotient + 1
+ }
+}
--
2.43.0
^ permalink raw reply related [flat|nested] 6+ messages in thread
* [PATCH v4 2/2] pwm: th1520: Fix 32-bit build with COMPILE_TEST
2026-11-18 22:48 [PATCH v4 0/2] rust: add u64 division helpers and fix the pwm_th1520 32-bit build FUJITA Tomonori
2026-11-18 22:48 ` [PATCH v4 1/2] rust: math: add div64_u64() and div64_u64_round_up() FUJITA Tomonori
@ 2026-11-18 22:48 ` FUJITA Tomonori
2026-11-18 23:23 ` Alice Ryhl
1 sibling, 1 reply; 6+ messages in thread
From: FUJITA Tomonori @ 2026-11-18 22:48 UTC (permalink / raw)
To: fustini, guoren, ojeda, ukleinek, wefu
Cc: a.hindborg, acourbot, aliceryhl, bjorn3_gh, boqun,
chenhan0017.work, dakr, daniel.almeida, gary, linux-riscv, lossin,
m.wilczynski, tamird, tmgross, work, linux-pwm, rust-for-linux,
FUJITA Tomonori, Uwe Kleine-König
From: FUJITA Tomonori <fujita.tomonori@gmail.com>
Fix the following build error on 32-bit ARM with COMPILE_TEST:
ERROR: modpost: drivers/pwm/pwm_th1520.ko: symbol '__aeabi_uldivmod' undefined!
The driver divides u64 values when it converts between nanoseconds and
clock cycles. On 32-bit ARM, these divisions are compiled to calls to
__aeabi_uldivmod, which the kernel does not provide.
Use div64_u64() and div64_u64_round_up() for these divisions, in the
same way as C drivers use div64_u64() and DIV64_U64_ROUND_UP(). The
results do not change.
Fixes: 3c180003dffb ("pwm: th1520: Fix missing Kconfig dependencies")
Reported-by: Andreas Hindborg <a.hindborg@kernel.org>
Closes: https://rust-for-linux.zulipchat.com/#narrow/channel/291565-Help/topic/64bit.20division.20in.20.60pwm_th1520.2Ers.60/near/626825599
Suggested-by: Uwe Kleine-König <ukleinek@kernel.org>
Acked-by: Uwe Kleine-König <u.kleine-koenig@baylibre.com>
Signed-off-by: FUJITA Tomonori <fujita.tomonori@gmail.com>
---
drivers/pwm/pwm_th1520.rs | 8 ++++++--
1 file changed, 6 insertions(+), 2 deletions(-)
diff --git a/drivers/pwm/pwm_th1520.rs b/drivers/pwm/pwm_th1520.rs
index 728993998446..bd05fe49650e 100644
--- a/drivers/pwm/pwm_th1520.rs
+++ b/drivers/pwm/pwm_th1520.rs
@@ -31,6 +31,10 @@
mem::DevresIoMem,
Io, //
},
+ math::{
+ div64_u64,
+ div64_u64_round_up, //
+ },
of,
platform,
prelude::*,
@@ -68,13 +72,13 @@ const fn th1520_pwm_fp(n: u32) -> usize {
fn ns_to_cycles(ns: u64, rate_hz: u64) -> u64 {
const NSEC_PER_SEC_U64: u64 = time::NSEC_PER_SEC as u64;
- ns.saturating_mul(rate_hz) / NSEC_PER_SEC_U64
+ div64_u64(ns.saturating_mul(rate_hz), NSEC_PER_SEC_U64)
}
fn cycles_to_ns(cycles: u32, rate_hz: u64) -> u64 {
const NSEC_PER_SEC_U64: u64 = time::NSEC_PER_SEC as u64;
- (u64::from(cycles) * NSEC_PER_SEC_U64).div_ceil(rate_hz)
+ div64_u64_round_up(u64::from(cycles) * NSEC_PER_SEC_U64, rate_hz)
}
/// Hardware-specific waveform representation for TH1520.
--
2.43.0
^ permalink raw reply related [flat|nested] 6+ messages in thread
* Re: [PATCH v4 1/2] rust: math: add div64_u64() and div64_u64_round_up()
2026-11-18 22:48 ` [PATCH v4 1/2] rust: math: add div64_u64() and div64_u64_round_up() FUJITA Tomonori
@ 2026-11-18 22:53 ` Danilo Krummrich
2026-11-18 23:23 ` Alice Ryhl
1 sibling, 0 replies; 6+ messages in thread
From: Danilo Krummrich @ 2026-11-18 22:53 UTC (permalink / raw)
To: FUJITA Tomonori
Cc: fustini, guoren, ojeda, ukleinek, wefu, a.hindborg, acourbot,
aliceryhl, bjorn3_gh, boqun, chenhan0017.work, daniel.almeida,
gary, linux-riscv, lossin, m.wilczynski, tamird, tmgross, work,
linux-pwm, rust-for-linux, FUJITA Tomonori
On 11/18/26 11:48 PM, FUJITA Tomonori wrote:
> From: FUJITA Tomonori <fujita.tomonori@gmail.com>
>
> On 32-bit architectures, dividing a u64 by a u64 with the `/` operator
> makes the compiler emit a call to a compiler runtime function, such as
> __aeabi_uldivmod() on arm. The kernel does not provide these functions,
> so the build fails when Rust code that is also built for 32-bit
> architectures uses `/` on u64.
>
> C code uses the helpers in include/linux/math64.h instead. Add a math
> module with Rust versions of two of them:
>
> - div64_u64(), the same as div64_u64() in C.
> - div64_u64_round_up(), the same as DIV64_U64_ROUND_UP() in C.
>
> On 64-bit architectures, both use `/`. On 32-bit architectures,
> div64_u64() calls the C function. Both panic if the divisor is zero,
> as `/` does.
>
> Signed-off-by: FUJITA Tomonori <fujita.tomonori@gmail.com>
Reviewed-by: Danilo Krummrich <dakr@kernel.org>
^ permalink raw reply [flat|nested] 6+ messages in thread
* Re: [PATCH v4 1/2] rust: math: add div64_u64() and div64_u64_round_up()
2026-11-18 22:48 ` [PATCH v4 1/2] rust: math: add div64_u64() and div64_u64_round_up() FUJITA Tomonori
2026-11-18 22:53 ` Danilo Krummrich
@ 2026-11-18 23:23 ` Alice Ryhl
1 sibling, 0 replies; 6+ messages in thread
From: Alice Ryhl @ 2026-11-18 23:23 UTC (permalink / raw)
To: FUJITA Tomonori
Cc: Alice Ryhl, fustini, guoren, ojeda, ukleinek, wefu, a.hindborg,
acourbot, bjorn3_gh, boqun, chenhan0017.work, dakr,
daniel.almeida, gary, linux-riscv, lossin, m.wilczynski, tamird,
tmgross, work, linux-pwm, rust-for-linux, FUJITA Tomonori
On Thu, Nov 19, 2026 at 07:48:25AM +0900, FUJITA Tomonori wrote:
> From: FUJITA Tomonori <fujita.tomonori@gmail.com>
>
> On 32-bit architectures, dividing a u64 by a u64 with the `/` operator
> makes the compiler emit a call to a compiler runtime function, such as
> __aeabi_uldivmod() on arm. The kernel does not provide these functions,
> so the build fails when Rust code that is also built for 32-bit
> architectures uses `/` on u64.
>
> C code uses the helpers in include/linux/math64.h instead. Add a math
> module with Rust versions of two of them:
>
> - div64_u64(), the same as div64_u64() in C.
> - div64_u64_round_up(), the same as DIV64_U64_ROUND_UP() in C.
>
> On 64-bit architectures, both use `/`. On 32-bit architectures,
> div64_u64() calls the C function. Both panic if the divisor is zero,
> as `/` does.
>
> Signed-off-by: FUJITA Tomonori <fujita.tomonori@gmail.com>
Reviewed-by: Alice Ryhl <aliceryhl@google.com>
Alice
^ permalink raw reply [flat|nested] 6+ messages in thread
* Re: [PATCH v4 2/2] pwm: th1520: Fix 32-bit build with COMPILE_TEST
2026-11-18 22:48 ` [PATCH v4 2/2] pwm: th1520: Fix 32-bit build with COMPILE_TEST FUJITA Tomonori
@ 2026-11-18 23:23 ` Alice Ryhl
0 siblings, 0 replies; 6+ messages in thread
From: Alice Ryhl @ 2026-11-18 23:23 UTC (permalink / raw)
To: FUJITA Tomonori
Cc: Alice Ryhl, fustini, guoren, ojeda, ukleinek, wefu, a.hindborg,
acourbot, bjorn3_gh, boqun, chenhan0017.work, dakr,
daniel.almeida, gary, linux-riscv, lossin, m.wilczynski, tamird,
tmgross, work, linux-pwm, rust-for-linux, FUJITA Tomonori,
Uwe Kleine-König
On Thu, Nov 19, 2026 at 07:48:26AM +0900, FUJITA Tomonori wrote:
> From: FUJITA Tomonori <fujita.tomonori@gmail.com>
>
> Fix the following build error on 32-bit ARM with COMPILE_TEST:
>
> ERROR: modpost: drivers/pwm/pwm_th1520.ko: symbol '__aeabi_uldivmod' undefined!
>
> The driver divides u64 values when it converts between nanoseconds and
> clock cycles. On 32-bit ARM, these divisions are compiled to calls to
> __aeabi_uldivmod, which the kernel does not provide.
>
> Use div64_u64() and div64_u64_round_up() for these divisions, in the
> same way as C drivers use div64_u64() and DIV64_U64_ROUND_UP(). The
> results do not change.
>
> Fixes: 3c180003dffb ("pwm: th1520: Fix missing Kconfig dependencies")
> Reported-by: Andreas Hindborg <a.hindborg@kernel.org>
> Closes: https://rust-for-linux.zulipchat.com/#narrow/channel/291565-Help/topic/64bit.20division.20in.20.60pwm_th1520.2Ers.60/near/626825599
> Suggested-by: Uwe Kleine-König <ukleinek@kernel.org>
> Acked-by: Uwe Kleine-König <u.kleine-koenig@baylibre.com>
> Signed-off-by: FUJITA Tomonori <fujita.tomonori@gmail.com>
Reviewed-by: Alice Ryhl <aliceryhl@google.com>
Alice
^ permalink raw reply [flat|nested] 6+ messages in thread
end of thread, other threads:[~2026-11-18 23:23 UTC | newest]
Thread overview: 6+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2026-11-18 22:48 [PATCH v4 0/2] rust: add u64 division helpers and fix the pwm_th1520 32-bit build FUJITA Tomonori
2026-11-18 22:48 ` [PATCH v4 1/2] rust: math: add div64_u64() and div64_u64_round_up() FUJITA Tomonori
2026-11-18 22:53 ` Danilo Krummrich
2026-11-18 23:23 ` Alice Ryhl
2026-11-18 22:48 ` [PATCH v4 2/2] pwm: th1520: Fix 32-bit build with COMPILE_TEST FUJITA Tomonori
2026-11-18 23:23 ` Alice Ryhl
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox