hardware 0.0.9

A no_std bare-metal hardware abstraction layer — all port I/O, memory and swap allocations are guarded at runtime. Do not consider this dependency stable before x.1.x
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
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

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

use crate::arch::x86_64::interrupt::apic::Apic;
use crate::arch::x86_64::interrupt::ioapic::IoApic;
use crate::arch::x86_64::interrupt::pic::Pic8259;
use crate::interrupt::IrqController;

pub struct X86Controller;

static SELECTED_KIND: AtomicU8 = AtomicU8::new(0);
static PIC_IMPL: Pic8259 = Pic8259::new();
static APIC_ONCE: crate::common::once::Once<Apic> = crate::common::once::Once::new();
static IOAPIC_ONCE: crate::common::once::Once<IoApic> = crate::common::once::Once::new();
static APIC_ADAPTER: ApicAdapter = ApicAdapter;

struct ApicAdapter;

impl ApicAdapter {
    unsafe fn apic() -> Option<&'static Apic> {
        APIC_ONCE.get()
    }
}

impl IrqController for ApicAdapter {
    fn init(&self) -> bool {
        match unsafe { Self::apic() } {
            Some(a) => a.init(),
            None => false,
        }
    }
    fn enable_irq(&self, irq: u8) {
        static IRQ_X86_LAST: core::sync::atomic::AtomicUsize =
            core::sync::atomic::AtomicUsize::new(0);
        IRQ_X86_LAST.store(irq as usize, core::sync::atomic::Ordering::Release);
    }
    fn disable_irq(&self, irq: u8) {
        static IRQ_X86_LAST2: core::sync::atomic::AtomicUsize =
            core::sync::atomic::AtomicUsize::new(0);
        IRQ_X86_LAST2.store(irq as usize, core::sync::atomic::Ordering::Release);
    }
    fn eoi(&self, irq: u8) {
        static IRQ_X86_LAST3: core::sync::atomic::AtomicUsize =
            core::sync::atomic::AtomicUsize::new(0);
        IRQ_X86_LAST3.store(irq as usize, core::sync::atomic::Ordering::Release);
        unsafe {
            if let Some(a) = Self::apic() {
                a.eoi();
            }
        }
    }
}

struct IoapicAdapter;
static IOAPIC_ADAPTER: IoapicAdapter = IoapicAdapter;

impl IoapicAdapter {
    unsafe fn ioapic() -> Option<&'static IoApic> {
        IOAPIC_ONCE.get()
    }
    unsafe fn apic() -> Option<&'static Apic> {
        APIC_ONCE.get()
    }
}

impl IrqController for IoapicAdapter {
    fn init(&self) -> bool {
        unsafe {
            match Self::ioapic() {
                Some(io) => io.version() != 0,
                None => false,
            }
        }
    }

    fn enable_irq(&self, irq: u8) {
        unsafe {
            if let (Some(apic), Some(ioapic)) = (Self::apic(), Self::ioapic()) {
                let apic_id = apic.id() as u8;
                let vec = 0x20u8.wrapping_add(irq);
                ioapic.route_irq(irq, apic_id, vec);
            }
        }
    }

    fn disable_irq(&self, irq: u8) {
        unsafe {
            if let Some(ioapic) = Self::ioapic() {
                let vec = 0u8;
                let apic_id = 0u8;
                let low = (vec as u32) | (1u32 << 16);
                let high = (apic_id as u32) << 24;
                ioapic.write_redtbl(irq, low, high);
            }
        }
    }

    fn eoi(&self, irq: u8) {
        static IRQ_IOAPIC_LAST: core::sync::atomic::AtomicUsize =
            core::sync::atomic::AtomicUsize::new(0);
        IRQ_IOAPIC_LAST.store(irq as usize, core::sync::atomic::Ordering::Release);
        unsafe {
            if let Some(apic) = Self::apic() {
                apic.eoi();
            }
        }
    }
}

pub fn init() {
    let apic = Apic::probe();
    debug_assert!(APIC_ONCE.get().is_none());
    APIC_ONCE.set(apic);

    if let Some(base) = crate::firmware::acpi::find_ioapic_base() {
        let ioapic = IoApic::new(base);
        debug_assert!(IOAPIC_ONCE.get().is_none());
        IOAPIC_ONCE.set(ioapic);
        if IOAPIC_ADAPTER.init() {
            SELECTED_KIND.store(2, Ordering::Release);
            return;
        }
    }

    if APIC_ADAPTER.init() {
        SELECTED_KIND.store(1, Ordering::Release);
        return;
    }

    PIC_IMPL.init();
    SELECTED_KIND.store(0, Ordering::Release);
}

fn get_selected() -> &'static dyn IrqController {
    match SELECTED_KIND.load(Ordering::Acquire) {
        1 => &APIC_ADAPTER as &dyn IrqController,
        2 => &IOAPIC_ADAPTER as &dyn IrqController,
        other => {
            static SEL_X86_SIG: core::sync::atomic::AtomicUsize =
                core::sync::atomic::AtomicUsize::new(0);
            SEL_X86_SIG.store(other as usize, core::sync::atomic::Ordering::Release);
            &PIC_IMPL as &dyn IrqController
        }
    }
}

pub fn enable_irq(irq: u8) {
    get_selected().enable_irq(irq);
}
pub fn disable_irq(irq: u8) {
    get_selected().disable_irq(irq);
}
pub fn eoi(irq: u8) {
    get_selected().eoi(irq);
}