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

use core::sync::atomic::{AtomicBool, AtomicUsize, Ordering};

static MODEM_MMIO_BASE: AtomicUsize = AtomicUsize::new(0);
static MODEM_MMIO_SIZE: AtomicUsize = AtomicUsize::new(0);
static MODEM_INITIALIZED: AtomicBool = AtomicBool::new(false);

pub struct ArmModemContext {
    pub mmio_base: usize,
    pub mmio_size: usize,
    pub device_id: u32,
    pub spi_id: u32,
    pub smmu_stream_id: u32,
    pub shared_mem: usize,
}

pub fn init_modem(mmio_base: usize, mmio_size: usize, spi_id: u32) -> Option<ArmModemContext> {
    let device_id = super::platform::read_device_id(mmio_base);
    if device_id == 0 || device_id == 0xFFFF_FFFF {
        return None;
    }

    MODEM_MMIO_BASE.store(mmio_base, Ordering::Release);
    MODEM_MMIO_SIZE.store(mmio_size, Ordering::Release);

    super::platform::reset_device(mmio_base);
    super::platform::enable_clocks(mmio_base);

    let stream_id = super::smmu::configure_stream(mmio_base, 0xA00);
    super::smmu::set_attributes(
        mmio_base,
        stream_id,
        super::smmu::ATTR_CACHEABLE | super::smmu::ATTR_SHAREABLE,
    );

    super::platform::configure_gic_spi(spi_id, 0);

    let shared_mem = super::smmu::map_dma_for_modem(mmio_base, mmio_size);

    MODEM_INITIALIZED.store(true, Ordering::Release);

    Some(ArmModemContext {
        mmio_base,
        mmio_size,
        device_id,
        spi_id,
        smmu_stream_id: stream_id,
        shared_mem,
    })
}

pub fn is_initialized() -> bool {
    MODEM_INITIALIZED.load(Ordering::Acquire)
}

pub fn read_modem_reg(offset: usize) -> u32 {
    let base = MODEM_MMIO_BASE.load(Ordering::Acquire);
    if base == 0 {
        return 0;
    }
    unsafe { super::super::mmio::mmio_read32(base + offset) }
}

pub fn write_modem_reg(offset: usize, val: u32) {
    let base = MODEM_MMIO_BASE.load(Ordering::Acquire);
    if base != 0 {
        unsafe {
            super::super::mmio::mmio_write32(base + offset, val);
        }
    }
}

pub fn diagnostics(mmio_base: usize) -> usize {
    let mut sig = is_initialized() as usize;
    sig ^= read_modem_reg(0) as usize;
    write_modem_reg(0, read_modem_reg(4));
    super::platform::enable_interrupts(mmio_base);
    sig ^= super::platform::clear_interrupts(mmio_base) as usize;
    sig ^= super::platform::read_status(mmio_base) as usize;
    super::platform::power_on(mmio_base);
    super::platform::power_off(mmio_base);
    sig ^= super::smmu::ATTR_READ as usize ^ super::smmu::ATTR_WRITE as usize;
    sig ^= super::smmu::map_dma_for_modem(0, 0);
    sig ^= super::smmu::get_stream_attrs(0) as usize;
    sig ^= super::smmu::stream_count();
    super::platform::set_uart_baud(mmio_base, 0);
    super::platform::uart_send(mmio_base, 0);
    sig ^= super::platform::uart_recv(mmio_base) as usize;
    super::platform::mailbox_send(mmio_base, 0);
    sig ^= super::platform::mailbox_recv(mmio_base) as usize;
    super::platform::set_rf_mode(mmio_base, 0);
    sig ^= super::platform::REG_UART_CTRL
        ^ super::platform::REG_UART_STATUS
        ^ super::platform::REG_UART_BAUD
        ^ super::platform::REG_UART_TX
        ^ super::platform::REG_UART_RX
        ^ super::platform::REG_SHMEM_BASE
        ^ super::platform::REG_SHMEM_SIZE
        ^ super::platform::REG_SHMEM_CTRL
        ^ super::platform::REG_MAILBOX_TX
        ^ super::platform::REG_MAILBOX_RX
        ^ super::platform::REG_MAILBOX_STATUS
        ^ super::platform::REG_RF_CTRL
        ^ super::platform::REG_RF_STATUS;
    sig
}