pcie 0.6.6

A simple PCIE driver for enumerating devices.
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

use core::fmt::Debug;

mod card_bridge;
mod endpoint;
mod pci_bridge;
mod unknown;

pub use card_bridge::*;
pub use endpoint::Endpoint;
pub use pci_bridge::*;
use pci_types::{
    CommandRegister, ConfigRegionAccess, HeaderType, PciAddress, PciHeader, StatusRegister,
};
use rdif_pcie::ConfigAccess;
pub use unknown::*;

use crate::chip::PcieController;

#[derive(Debug)]
pub enum PciConfigSpace {
    PciPciBridge(PciPciBridge),
    Endpoint(Endpoint),
    CardBusBridge(CardBusBridge),
    Unknown(Unknown),
}

pub struct PciHeaderBase {
    vid: u16,
    did: u16,
    root: ConfigAccess,
    header: PciHeader,
}

impl PciHeaderBase {
    pub(crate) fn new(root: &mut PcieController, address: PciAddress) -> Option<Self> {
        let root = root.config_access(address);
        let header = PciHeader::new(address);
        let (vid, did) = header.id(&root);
        if vid == 0xffff {
            return None;
        }

        Some(Self {
            vid,
            did,
            root,
            header,
        })
    }

    pub fn header(&self) -> PciHeader {
        PciHeader::new(self.address())
    }

    pub fn address(&self) -> PciAddress {
        self.header.address()
    }

    pub fn header_type(&self) -> HeaderType {
        self.header.header_type(&self.root)
    }

    pub fn has_multiple_functions(&self) -> bool {
        self.header.has_multiple_functions(&self.root)
    }

    pub fn update_command<F>(&mut self, f: F)
    where
        F: FnOnce(CommandRegister) -> CommandRegister,
    {
        self.header.update_command(&self.root, f);
    }

    pub fn status(&self) -> StatusRegister {
        self.header.status(&self.root)
    }

    pub fn command(&self) -> CommandRegister {
        self.header.command(&self.root)
    }

    pub fn revision_and_class(&self) -> RevisionAndClass {
        let (revision_id, base_class, sub_class, interface) =
            self.header.revision_and_class(&self.root);
        RevisionAndClass {
            revision_id,
            base_class,
            sub_class,
            interface,
        }
    }

    pub fn vendor_id(&self) -> u16 {
        self.vid
    }

    pub fn device_id(&self) -> u16 {
        self.did
    }

    pub fn read(&self, offset: u16) -> u32 {
        unsafe { self.root.read(self.address(), offset) }
    }

    pub fn write(&self, offset: u16, value: u32) {
        unsafe { self.root.write(self.address(), offset, value) }
    }
}

#[derive(Debug, Clone)]
pub struct RevisionAndClass {
    pub revision_id: u8,
    pub base_class: u8,
    pub sub_class: u8,
    pub interface: u8,
}

impl Debug for PciHeaderBase {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        f.debug_struct("PciHeaderBase")
            .field("address", &self.address())
            .field("vid", &format_args!("{:#06x}", self.vid))
            .field("did", &format_args!("{:#06x}", self.did))
            .field("command", &self.command())
            .field("status", &self.status())
            .field("has_multiple_functions", &self.has_multiple_functions())
            .field("revision_and_class", &self.revision_and_class())
            .finish()
    }
}