axplat-dyn 0.7.0

A dynamic platform module for ArceOS, providing runtime platform detection and configuration
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

//! ARM Generic Timer.

use core::sync::atomic::{AtomicU64, Ordering};

const UNINIT_EPOCH_OFFSET_NANOS: u64 = u64::MAX;
static EPOCH_OFFSET_NANOS: AtomicU64 = AtomicU64::new(UNINIT_EPOCH_OFFSET_NANOS);

pub(crate) fn current_ticks() -> u64 {
    somehal::timer::ticks() as _
}

pub(crate) fn ticks_to_nanos(ticks: u64) -> u64 {
    let freq = somehal::timer::freq() as u64;
    if freq == 0 {
        return 0;
    }
    (ticks * ax_plat::time::NANOS_PER_SEC) / freq
}

pub(crate) fn nanos_to_ticks(nanos: u64) -> u64 {
    let freq = somehal::timer::freq() as u64;
    if freq == 0 {
        return 0;
    }
    (nanos * freq) / ax_plat::time::NANOS_PER_SEC
}

pub fn try_init_epoch_offset(epoch_time_nanos: u64) -> bool {
    let boot_offset = epoch_time_nanos.saturating_sub(ticks_to_nanos(current_ticks()));
    EPOCH_OFFSET_NANOS
        .compare_exchange(
            UNINIT_EPOCH_OFFSET_NANOS,
            boot_offset,
            Ordering::AcqRel,
            Ordering::Acquire,
        )
        .is_ok()
}

struct GenericTimer;

#[impl_plat_interface]
impl ax_plat::time::TimeIf for GenericTimer {
    /// Returns the current clock time in hardware ticks.
    fn current_ticks() -> u64 {
        current_ticks()
    }

    /// Converts hardware ticks to nanoseconds.
    fn ticks_to_nanos(ticks: u64) -> u64 {
        ticks_to_nanos(ticks)
    }

    /// Converts nanoseconds to hardware ticks.
    fn nanos_to_ticks(nanos: u64) -> u64 {
        nanos_to_ticks(nanos)
    }

    /// Return epoch offset in nanoseconds (wall time offset to monotonic
    /// clock start).
    fn epochoffset_nanos() -> u64 {
        match EPOCH_OFFSET_NANOS.load(Ordering::Acquire) {
            UNINIT_EPOCH_OFFSET_NANOS => 0,
            offset => offset,
        }
    }
    /// Returns the IRQ number for the timer interrupt.
    #[cfg(feature = "irq")]
    fn irq_num() -> usize {
        somehal::irq::systick_irq().into()
    }
    /// Set a one-shot timer.
    ///
    /// A timer interrupt will be triggered at the specified monotonic time
    /// deadline (in nanoseconds).
    #[cfg(feature = "irq")]
    fn set_oneshot_timer(deadline_ns: u64) {
        let cnptct = somehal::timer::ticks() as u64;
        let deadline = GenericTimer::nanos_to_ticks(deadline_ns);
        let interval = if cnptct < deadline {
            let interval = deadline - cnptct;
            debug_assert!(interval <= u32::MAX as u64);
            interval
        } else {
            0
        };

        somehal::timer::set_next_event_in_ticks(interval as _);
    }
}