libdrm_amdgpu_sys 0.8.16

libdrm_amdgpu bindings for Rust, and some methods ported from Mesa3D.
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

use core::mem::{size_of, MaybeUninit};
use core::ptr;
use crate::bindings::atom_common_table_header;
pub use crate::bindings::ppt::{
    smu_v11_0_0_ppt::{smu_11_0_powerplay_table, PPTable_t as PPTable_smu_11_0_t},
    smu_v11_0_7_ppt::{smu_11_0_7_powerplay_table, PPTable_t as PPTable_smu_11_0_7_t, PPTable_beige_goby_t},
    smu_v13_0_0_ppt::{smu_13_0_0_powerplay_table, PPTable_t as PPTable_smu_13_0_0_t},
    smu_v13_0_7_ppt::{smu_13_0_7_powerplay_table, PPTable_t as PPTable_smu_13_0_7_t},
};

#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
pub enum PPTableDecodeError {
    SmallerThanHeader,
    SmallerThanStructureSizeInHeader,
}

#[derive(Debug, Clone)]
pub enum PPTable {
    V11_0_0(smu_11_0_powerplay_table),
    V11_0_7(smu_11_0_7_powerplay_table),
    V13_0_0(smu_13_0_0_powerplay_table),
    V13_0_7(smu_13_0_7_powerplay_table),
    Unknown(atom_common_table_header),
    Invalid,
}

impl PPTable {
    fn get_header(bytes: &[u8]) -> Option<atom_common_table_header> {
        const HEADER_SIZE: usize = size_of::<atom_common_table_header>();

        let bin = bytes.get(0..HEADER_SIZE)?;

        unsafe {
            let mut h = MaybeUninit::<atom_common_table_header>::zeroed();

            ptr::copy_nonoverlapping(
                bin.as_ptr(),
                h.as_mut_ptr() as *mut u8,
                HEADER_SIZE,
            );

            Some(h.assume_init())
        }
    }

    fn check_length(header: &atom_common_table_header, len: usize) -> bool {
        header.structuresize as usize <= len
    }

    pub fn decode(bytes: &[u8]) -> Result<Self, PPTableDecodeError> {
        let Some(header) = Self::get_header(bytes) else { return Err(PPTableDecodeError::SmallerThanHeader) };

        if !Self::check_length(&header, bytes.len()) {
            return Err(PPTableDecodeError::SmallerThanStructureSizeInHeader);
        }

        // ref: https://github.com/sibradzic/upp/blob/master/src/upp/decode.py
        let ppt = match header.format_revision {
            // Navi10: 12
            // Navi12: 14
            // Navi14: 12?
            12 | 14 => Self::V11_0_0(Self::to_pptable(bytes)),
            // Navi21: 15
            // Navi22: 16?
            // Navi23: 18
            // Navi24: 19?
            15 | 16 | 18 | 19 => Self::V11_0_7(Self::to_pptable(bytes)),
            // Navi31: 20
            // Navi32: ?
            // Navi33: ?
            20 => Self::V13_0_0(Self::to_pptable(bytes)),
            _ => Self::Unknown(header),
        };

        Ok(ppt)
    }

    pub fn decode_with_smu_version(bytes: &[u8], smu_ver: (u8, u8, u8)) -> Result<Self, PPTableDecodeError> {
        let Some(header) = Self::get_header(bytes) else { return Err(PPTableDecodeError::SmallerThanHeader) };

        if !Self::check_length(&header, bytes.len()) {
            return Err(PPTableDecodeError::SmallerThanStructureSizeInHeader);
        }

        // ref: https://github.com/sibradzic/upp/blob/master/src/upp/decode.py
        let ppt = match smu_ver {
            (11, 0, 0) | /* Navi10 */
            (11, 0, 5) | /* Navi14 */
            (11, 0, 9) /* Navi12 */
                => Self::V11_0_0(Self::to_pptable(bytes)),
            (11, 0, 7) | /* Navi21 */
            (11, 0, 11) | /* Navi22 */
            (11, 0, 12) | /* Navi23 */
            (11, 0, 13) /* Navi24 */
                => Self::V11_0_7(Self::to_pptable(bytes)),
            (13, 0, 0) |
            (13, 0, 10) => Self::V13_0_0(Self::to_pptable(bytes)),
            (13, 0, 7) => Self::V13_0_7(Self::to_pptable(bytes)),
            _ => Self::Unknown(header),
        };

        Ok(ppt)
    }

    fn to_pptable<T>(bytes: &[u8]) -> T {
        unsafe {
            let mut t = MaybeUninit::<T>::zeroed();

            ptr::copy_nonoverlapping(
                bytes.as_ptr(),
                t.as_mut_ptr() as *mut u8,
                size_of::<T>(),
            );

            t.assume_init()
        }
    }

    pub fn is_valid(&self) -> bool {
        match self {
            Self::Unknown(_) |
            Self::Invalid => false,
            _ => true,
        }
    }
}