arm_vgic 0.5.5

ARM Virtual Generic Interrupt Controller (VGIC) implementation.
Documentation 
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
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138

//! Host callbacks required by ARM virtual interrupt-controller devices.

use alloc::boxed::Box;
use core::time::Duration;

use ax_memory_addr::{PhysAddr, VirtAddr};

/// Host operations required by ARM VGIC and virtual timer components.
#[ax_crate_interface::def_interface]
pub trait ArmVgicHostIf {
    /// Allocate contiguous host frames.
    fn alloc_contiguous_frames(frame_count: usize, frame_align: usize) -> Option<PhysAddr>;

    /// Deallocate contiguous host frames.
    fn dealloc_contiguous_frames(start_paddr: PhysAddr, frame_count: usize);

    /// Convert host physical address to host virtual address.
    fn phys_to_virt(paddr: PhysAddr) -> VirtAddr;

    /// Return host CPU count.
    fn host_cpu_num() -> usize;

    /// Return current VM ID.
    fn current_vm_id() -> usize;

    /// Return current vCPU ID.
    fn current_vcpu_id() -> usize;

    /// Queue a virtual interrupt for delivery to a VM vCPU.
    fn queue_virtual_interrupt(vm_id: usize, vcpu_id: usize, vector: u8);

    /// Current monotonic host time in nanoseconds.
    fn current_time_nanos() -> u64;

    /// Register a timer callback at an absolute host deadline.
    fn register_timer(
        deadline: Duration,
        callback: Box<dyn FnOnce(Duration) + Send + 'static>,
    ) -> usize;

    /// Cancel a previously registered timer callback.
    fn cancel_timer(token: usize);

    /// Read VGICD IIDR from host GIC.
    fn read_vgicd_iidr() -> u32;

    /// Read VGICD TYPER from host GIC.
    fn read_vgicd_typer() -> u32;

    /// Return host GICD base.
    fn get_host_gicd_base() -> PhysAddr;

    /// Return host GICR base.
    fn get_host_gicr_base() -> PhysAddr;

    /// Inject a virtual interrupt.
    fn hardware_inject_virtual_interrupt(vector: u8);
}

#[cfg(feature = "vgicv3")]
pub(crate) fn alloc_contiguous_frames(frame_count: usize, frame_align: usize) -> Option<PhysAddr> {
    ax_crate_interface::call_interface!(ArmVgicHostIf::alloc_contiguous_frames(
        frame_count,
        frame_align
    ))
}

#[cfg(feature = "vgicv3")]
pub(crate) fn dealloc_contiguous_frames(start_paddr: PhysAddr, frame_count: usize) {
    ax_crate_interface::call_interface!(ArmVgicHostIf::dealloc_contiguous_frames(
        start_paddr,
        frame_count
    ));
}

#[cfg(feature = "vgicv3")]
pub(crate) fn phys_to_virt(paddr: PhysAddr) -> VirtAddr {
    ax_crate_interface::call_interface!(ArmVgicHostIf::phys_to_virt(paddr))
}

#[cfg(feature = "vgicv3")]
pub(crate) fn host_cpu_num() -> usize {
    ax_crate_interface::call_interface!(ArmVgicHostIf::host_cpu_num())
}

#[cfg(target_arch = "aarch64")]
pub(crate) fn current_vm_id() -> usize {
    ax_crate_interface::call_interface!(ArmVgicHostIf::current_vm_id())
}

pub(crate) fn current_vcpu_id() -> usize {
    ax_crate_interface::call_interface!(ArmVgicHostIf::current_vcpu_id())
}

#[cfg(target_arch = "aarch64")]
pub(crate) fn queue_virtual_interrupt(vm_id: usize, vcpu_id: usize, vector: u8) {
    ax_crate_interface::call_interface!(ArmVgicHostIf::queue_virtual_interrupt(
        vm_id, vcpu_id, vector
    ));
}

#[cfg(target_arch = "aarch64")]
pub(crate) fn current_time_nanos() -> u64 {
    ax_crate_interface::call_interface!(ArmVgicHostIf::current_time_nanos())
}

#[cfg(target_arch = "aarch64")]
pub(crate) fn register_timer(
    deadline: Duration,
    callback: Box<dyn FnOnce(Duration) + Send + 'static>,
) -> usize {
    ax_crate_interface::call_interface!(ArmVgicHostIf::register_timer(deadline, callback))
}

#[cfg(target_arch = "aarch64")]
pub(crate) fn cancel_timer(token: usize) {
    ax_crate_interface::call_interface!(ArmVgicHostIf::cancel_timer(token));
}

pub fn read_vgicd_iidr() -> u32 {
    ax_crate_interface::call_interface!(ArmVgicHostIf::read_vgicd_iidr())
}

pub fn read_vgicd_typer() -> u32 {
    ax_crate_interface::call_interface!(ArmVgicHostIf::read_vgicd_typer())
}

pub fn get_host_gicd_base() -> PhysAddr {
    ax_crate_interface::call_interface!(ArmVgicHostIf::get_host_gicd_base())
}

pub fn get_host_gicr_base() -> PhysAddr {
    ax_crate_interface::call_interface!(ArmVgicHostIf::get_host_gicr_base())
}

pub fn hardware_inject_virtual_interrupt(vector: u8) {
    ax_crate_interface::call_interface!(ArmVgicHostIf::hardware_inject_virtual_interrupt(vector));
}