rdif-pcie 0.2.2

Driver Interface of interrupt controller.
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

use crate::{
    PciMem32, PciMem64,
    addr_alloc::{self, AddressAllocator, AllocPolicy},
};

#[derive(Default)]
pub struct SimpleBarAllocator {
    // Non-prefetchable windows
    mem32: Option<AddressAllocator>,
    mem64: Option<AddressAllocator>,
    // Prefetchable windows
    mem32_pref: Option<AddressAllocator>,
    mem64_pref: Option<AddressAllocator>,
}

impl SimpleBarAllocator {
    /// Convenience: add a 32-bit window with prefetchable attribute.
    pub fn set_mem32(
        &mut self,
        space: PciMem32,
        prefetchable: bool,
    ) -> Result<(), addr_alloc::Error> {
        let a = AddressAllocator::new(space.address as _, space.size as _)?;
        if prefetchable {
            self.mem32_pref = Some(a);
        } else {
            self.mem32 = Some(a);
        }
        Ok(())
    }

    /// Convenience: add a 64-bit window with prefetchable attribute.
    pub fn set_mem64(
        &mut self,
        space: PciMem64,
        prefetchable: bool,
    ) -> Result<(), addr_alloc::Error> {
        let a = AddressAllocator::new(space.address as _, space.size as _)?;
        if prefetchable {
            self.mem64_pref = Some(a);
        } else {
            self.mem64 = Some(a);
        }
        Ok(())
    }

    pub fn alloc_memory32(&mut self, size: u32, prefetchable: bool) -> Option<u32> {
        self.alloc_from_32(size, prefetchable)
    }

    pub fn alloc_memory64(&mut self, size: u64, prefetchable: bool) -> Option<u64> {
        if let Some(addr) = self.alloc_from_64(size, prefetchable) {
            return Some(addr);
        }

        // A 64-bit BAR can legally be programmed with an address below 4 GiB.
        // Keep the fallback on the same 32-bit allocator so 32-bit and 64-bit
        // BARs do not receive overlapping low MMIO ranges.
        if let Ok(size) = u32::try_from(size) {
            return self.alloc_from_32(size, prefetchable).map(u64::from);
        }

        None
    }

    fn alloc_from_32(&mut self, size: u32, prefetchable: bool) -> Option<u32> {
        if prefetchable && let Some(addr) = alloc_from(&mut self.mem32_pref, size as u64) {
            return Some(addr as u32);
        }

        alloc_from(&mut self.mem32, size as u64).map(|addr| addr as u32)
    }

    fn alloc_from_64(&mut self, size: u64, prefetchable: bool) -> Option<u64> {
        if prefetchable && let Some(addr) = alloc_from(&mut self.mem64_pref, size) {
            return Some(addr);
        }

        alloc_from(&mut self.mem64, size)
    }
}

fn alloc_from(allocator: &mut Option<AddressAllocator>, size: u64) -> Option<u64> {
    allocator
        .as_mut()?
        .allocate(size, size, AllocPolicy::FirstMatch)
        .ok()
        .map(|range| range.start())
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn memory64_falls_back_to_shared_memory32_window() {
        let mut allocator = SimpleBarAllocator::default();
        allocator
            .set_mem32(
                PciMem32 {
                    address: 0x1000_0000,
                    size: 0x2000,
                },
                false,
            )
            .unwrap();

        assert_eq!(allocator.alloc_memory64(0x1000, false), Some(0x1000_0000));
        assert_eq!(allocator.alloc_memory32(0x1000, false), Some(0x1000_1000));
    }

    #[test]
    fn memory64_prefers_native_memory64_window() {
        let mut allocator = SimpleBarAllocator::default();
        allocator
            .set_mem32(
                PciMem32 {
                    address: 0x1000_0000,
                    size: 0x2000,
                },
                false,
            )
            .unwrap();
        allocator
            .set_mem64(
                PciMem64 {
                    address: 0x8_0000_0000,
                    size: 0x2000,
                },
                false,
            )
            .unwrap();

        assert_eq!(allocator.alloc_memory64(0x1000, false), Some(0x8_0000_0000));
        assert_eq!(allocator.alloc_memory32(0x1000, false), Some(0x1000_0000));
    }
}