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

#[derive(Copy, Clone, PartialEq)]
pub enum NfcChip {
    Nxp,
    St,
    Broadcom,
    Ti,
    Unknown,
}

#[derive(Copy, Clone)]
pub struct NfcController {
    pub chip: NfcChip,
    pub reg_base: u64,
    pub irq: u32,
    pub compat: [u8; 64],
    pub compat_len: usize,
}

pub fn detect(out: &mut [NfcController]) -> usize {
    if out.is_empty() {
        return 0;
    }
    scan_dt(out)
}

fn scan_dt(out: &mut [NfcController]) -> usize {
    let mut blob = [0u8; 4096];
    let blen = crate::firmware::devicetree::load_fdt_blob(&mut blob);
    if blen < 40 {
        return 0;
    }
    let mut entries = [crate::firmware::devicetree::DtDeviceEntry {
        name: [0u8; 64],
        name_len: 0,
        reg_base: 0,
        reg_size: 0,
        irq: 0,
        compatible: [0u8; 128],
        compatible_len: 0,
    }; 64];
    let count = crate::firmware::devicetree::enumerate_devices(&blob[..blen], &mut entries);
    let mut found = 0usize;
    let mut i = 0usize;
    while i < count && found < out.len() {
        let compat = &entries[i].compatible[..entries[i].compatible_len];
        let name = &entries[i].name[..entries[i].name_len];
        let chip = classify_nfc(compat, name);
        if !matches!(chip, NfcChip::Unknown) {
            let mut compat_buf = [0u8; 64];
            let clen = copy_min(compat, &mut compat_buf);
            out[found] = NfcController {
                chip,
                reg_base: entries[i].reg_base,
                irq: entries[i].irq,
                compat: compat_buf,
                compat_len: clen,
            };
            found += 1;
        }
        i += 1;
    }
    found
}

fn classify_nfc(compat: &[u8], name: &[u8]) -> NfcChip {
    if contains(compat, b"nxp,pn5")
        || contains(compat, b"nxp,pn7")
        || contains(compat, b"nxp,nq")
        || contains(compat, b"nxp,sn")
    {
        return NfcChip::Nxp;
    }
    if contains(compat, b"st,st21") || contains(compat, b"st,st54") || contains(compat, b"st,st25")
    {
        return NfcChip::St;
    }
    if contains(compat, b"brcm,bcm2079") || contains(compat, b"brcm,nfc") {
        return NfcChip::Broadcom;
    }
    if contains(compat, b"ti,trf7") {
        return NfcChip::Ti;
    }
    if contains(compat, b"nfc") || contains(name, b"nfc") {
        return NfcChip::Nxp;
    }
    NfcChip::Unknown
}

fn copy_min(src: &[u8], dst: &mut [u8; 64]) -> usize {
    let n = if src.len() < 64 { src.len() } else { 64 };
    let mut i = 0usize;
    while i < n {
        dst[i] = src[i];
        i += 1;
    }
    n
}

fn contains(haystack: &[u8], needle: &[u8]) -> bool {
    if needle.len() > haystack.len() {
        return false;
    }
    let mut i = 0usize;
    while i + needle.len() <= haystack.len() {
        let mut ok = true;
        let mut j = 0usize;
        while j < needle.len() {
            if haystack[i + j] != needle[j] {
                ok = false;
                break;
            }
            j += 1;
        }
        if ok {
            return true;
        }
        i += 1;
    }
    false
}