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

use crate::storage::detection::StorageProtocol;
use crate::storage::hw;
use core::sync::atomic::{AtomicU8, Ordering};

static DRIVER_STATE: AtomicU8 = AtomicU8::new(0);

const STATE_PROBED: u8 = 1;
const STATE_ACTIVE: u8 = 2;

pub struct AhciDriver {
    pub base: usize,
    pub port_count: u8,
    pub ports_implemented: u32,
}

pub struct NvmeDriver {
    pub base: usize,
    pub version_major: u16,
    pub version_minor: u16,
}

pub enum StorageDriver {
    Ahci(AhciDriver),
    Nvme(NvmeDriver),
}

pub fn probe(base: usize, protocol: StorageProtocol) -> Option<StorageDriver> {
    match protocol {
        StorageProtocol::Ahci => {
            let ports = hw::ahci_port_count(base);
            let implemented = hw::ahci_ports_implemented(base);
            DRIVER_STATE.store(STATE_PROBED, Ordering::Release);
            Some(StorageDriver::Ahci(AhciDriver {
                base,
                port_count: ports,
                ports_implemented: implemented,
            }))
        }
        StorageProtocol::Nvme => {
            let (major, minor, _) = hw::nvme_version(base);
            DRIVER_STATE.store(STATE_PROBED, Ordering::Release);
            Some(StorageDriver::Nvme(NvmeDriver {
                base,
                version_major: major,
                version_minor: minor as u16,
            }))
        }
        _ => None,
    }
}

pub fn init(driver: &StorageDriver) -> bool {
    match driver {
        StorageDriver::Ahci(ahci) => {
            hw::ahci_enable(ahci.base);
            DRIVER_STATE.store(STATE_ACTIVE, Ordering::Release);
            true
        }
        StorageDriver::Nvme(nvme) => {
            hw::nvme_enable(nvme.base);
            let ready = hw::nvme_ready(nvme.base);
            if ready {
                DRIVER_STATE.store(STATE_ACTIVE, Ordering::Release);
            }
            ready
        }
    }
}

pub fn state() -> u8 {
    DRIVER_STATE.load(Ordering::Acquire)
}