VbiosParser

libdrm_amdgpu_sys::AMDGPU::VBIOS

Struct VbiosParser 

Source 
pub struct VbiosParser(/* private fields */);

Implementations§

Source§

impl VbiosParser

Source

pub fn new(v: Vec<u8>) -> Self

Examples found in repository?
examples/vbios_parser.rs (line 19)
6fn main() {
7    let libdrm_amdgpu = LibDrmAmdgpu::new().unwrap();
8    let device_path = std::env::var("AMDGPU_PATH").unwrap_or("/dev/dri/renderD128".to_string());
9    let (amdgpu_dev, _, _) = {
10        use std::os::fd::IntoRawFd;
11
12        let f = File::open(device_path).unwrap();
13
14        libdrm_amdgpu.init_device_handle(f.into_raw_fd()).unwrap()
15    };
16
17    let Ok(vbios_image) = amdgpu_dev.get_vbios_image() else { return };
18
19    let vbios_parser = VbiosParser::new(vbios_image);
20
21    if !vbios_parser.valid_vbios() || !vbios_parser.check_length() {
22        panic!();
23    }
24
25    if let Some(name) = vbios_parser.get_vbios_name() {
26        println!("name: {name:?}");
27    }
28
29    let rom_header = vbios_parser.get_atom_rom_header().unwrap();
30    println!("{rom_header:#X?}");
31
32    let data_table = vbios_parser.get_atom_data_table(&rom_header).unwrap();
33    println!("{data_table:#X?}");
34
35    if let Some(h) = vbios_parser.get_atom_firmware_info_header(&data_table) {
36        println!("{h:#?}");
37        match (h.format_revision, h.content_revision) {
38            (3, 5) => {
39                let firmware_info = vbios_parser.get_atom_firmware_info_v3_5(&data_table).unwrap();
40                println!("firmwareinfo: {firmware_info:#?}");
41            },
42            _ => {
43                let firmware_info = vbios_parser.get_atom_firmware_info(&data_table).unwrap();
44                println!("firmwareinfo: {firmware_info:#?}");
45            },
46        }
47    }
48}
More examples
Hide additional examples
examples/pp_table.rs (line 27)
5fn main() {
6    let libdrm_amdgpu = LibDrmAmdgpu::new().unwrap();
7    let device_path = std::env::var("AMDGPU_PATH").unwrap_or("/dev/dri/renderD128".to_string());
8    let (amdgpu_dev, _, _) = {
9        use std::os::fd::IntoRawFd;
10
11        let f = File::open(device_path).unwrap();
12
13        libdrm_amdgpu.init_device_handle(f.into_raw_fd()).unwrap()
14    };
15
16    let sysfs = amdgpu_dev.get_sysfs_path().unwrap();
17    let smu = IpHwId::get_from_die_id_sysfs(HwId::MP1, &sysfs.join("ip_discovery/die/0/")).ok().and_then(|smu| smu.instances.get(0).map(|v| v.clone()));
18
19    if let Some(smu) = &smu {
20        println!("SMU (MP1) version: {}.{}.{}", smu.major, smu.minor, smu.revision);
21    }
22
23    let pp_table_bytes_sysfs = std::fs::read(&sysfs.join("pp_table")).ok();
24    let pp_table_bytes_vbios = amdgpu_dev.get_vbios_image().ok().and_then(|vbios_image| {
25        use AMDGPU::VBIOS::VbiosParser;
26
27        let vbios_parser = VbiosParser::new(vbios_image);
28        let rom_header = vbios_parser.get_atom_rom_header()?;
29        let data_table = vbios_parser.get_atom_data_table(&rom_header)?;
30
31        Some(vbios_parser.get_powerplay_table_bytes(&data_table)?.to_vec())
32    });
33
34    for (bytes, src) in [
35        (pp_table_bytes_sysfs, "sysfs"),
36        (pp_table_bytes_vbios, "VBIOS"),
37    ] {
38        let Some(bytes) = bytes else { continue };
39        let pp_table = if let Some(smu) = &smu {
40            AMDGPU::PPTable::decode_with_smu_version(&bytes, smu.version())
41        } else {
42            AMDGPU::PPTable::decode(&bytes)
43        };
44
45        println!("from {src}: {pp_table:#?}");
46    }
47}
Source

pub fn vbios(&self) -> Vec<u8> ⓘ

Source

pub fn length(&self) -> usize

Source

pub fn valid_vbios(&self) -> bool

Examples found in repository?
examples/vbios_parser.rs (line 21)
6fn main() {
7    let libdrm_amdgpu = LibDrmAmdgpu::new().unwrap();
8    let device_path = std::env::var("AMDGPU_PATH").unwrap_or("/dev/dri/renderD128".to_string());
9    let (amdgpu_dev, _, _) = {
10        use std::os::fd::IntoRawFd;
11
12        let f = File::open(device_path).unwrap();
13
14        libdrm_amdgpu.init_device_handle(f.into_raw_fd()).unwrap()
15    };
16
17    let Ok(vbios_image) = amdgpu_dev.get_vbios_image() else { return };
18
19    let vbios_parser = VbiosParser::new(vbios_image);
20
21    if !vbios_parser.valid_vbios() || !vbios_parser.check_length() {
22        panic!();
23    }
24
25    if let Some(name) = vbios_parser.get_vbios_name() {
26        println!("name: {name:?}");
27    }
28
29    let rom_header = vbios_parser.get_atom_rom_header().unwrap();
30    println!("{rom_header:#X?}");
31
32    let data_table = vbios_parser.get_atom_data_table(&rom_header).unwrap();
33    println!("{data_table:#X?}");
34
35    if let Some(h) = vbios_parser.get_atom_firmware_info_header(&data_table) {
36        println!("{h:#?}");
37        match (h.format_revision, h.content_revision) {
38            (3, 5) => {
39                let firmware_info = vbios_parser.get_atom_firmware_info_v3_5(&data_table).unwrap();
40                println!("firmwareinfo: {firmware_info:#?}");
41            },
42            _ => {
43                let firmware_info = vbios_parser.get_atom_firmware_info(&data_table).unwrap();
44                println!("firmwareinfo: {firmware_info:#?}");
45            },
46        }
47    }
48}
Source

pub fn check_length(&self) -> bool

Examples found in repository?
examples/vbios_parser.rs (line 21)
6fn main() {
7    let libdrm_amdgpu = LibDrmAmdgpu::new().unwrap();
8    let device_path = std::env::var("AMDGPU_PATH").unwrap_or("/dev/dri/renderD128".to_string());
9    let (amdgpu_dev, _, _) = {
10        use std::os::fd::IntoRawFd;
11
12        let f = File::open(device_path).unwrap();
13
14        libdrm_amdgpu.init_device_handle(f.into_raw_fd()).unwrap()
15    };
16
17    let Ok(vbios_image) = amdgpu_dev.get_vbios_image() else { return };
18
19    let vbios_parser = VbiosParser::new(vbios_image);
20
21    if !vbios_parser.valid_vbios() || !vbios_parser.check_length() {
22        panic!();
23    }
24
25    if let Some(name) = vbios_parser.get_vbios_name() {
26        println!("name: {name:?}");
27    }
28
29    let rom_header = vbios_parser.get_atom_rom_header().unwrap();
30    println!("{rom_header:#X?}");
31
32    let data_table = vbios_parser.get_atom_data_table(&rom_header).unwrap();
33    println!("{data_table:#X?}");
34
35    if let Some(h) = vbios_parser.get_atom_firmware_info_header(&data_table) {
36        println!("{h:#?}");
37        match (h.format_revision, h.content_revision) {
38            (3, 5) => {
39                let firmware_info = vbios_parser.get_atom_firmware_info_v3_5(&data_table).unwrap();
40                println!("firmwareinfo: {firmware_info:#?}");
41            },
42            _ => {
43                let firmware_info = vbios_parser.get_atom_firmware_info(&data_table).unwrap();
44                println!("firmwareinfo: {firmware_info:#?}");
45            },
46        }
47    }
48}
Source

pub fn get_vbios_name(&self) -> Option<String>

Examples found in repository?
examples/vbios_parser.rs (line 25)
6fn main() {
7    let libdrm_amdgpu = LibDrmAmdgpu::new().unwrap();
8    let device_path = std::env::var("AMDGPU_PATH").unwrap_or("/dev/dri/renderD128".to_string());
9    let (amdgpu_dev, _, _) = {
10        use std::os::fd::IntoRawFd;
11
12        let f = File::open(device_path).unwrap();
13
14        libdrm_amdgpu.init_device_handle(f.into_raw_fd()).unwrap()
15    };
16
17    let Ok(vbios_image) = amdgpu_dev.get_vbios_image() else { return };
18
19    let vbios_parser = VbiosParser::new(vbios_image);
20
21    if !vbios_parser.valid_vbios() || !vbios_parser.check_length() {
22        panic!();
23    }
24
25    if let Some(name) = vbios_parser.get_vbios_name() {
26        println!("name: {name:?}");
27    }
28
29    let rom_header = vbios_parser.get_atom_rom_header().unwrap();
30    println!("{rom_header:#X?}");
31
32    let data_table = vbios_parser.get_atom_data_table(&rom_header).unwrap();
33    println!("{data_table:#X?}");
34
35    if let Some(h) = vbios_parser.get_atom_firmware_info_header(&data_table) {
36        println!("{h:#?}");
37        match (h.format_revision, h.content_revision) {
38            (3, 5) => {
39                let firmware_info = vbios_parser.get_atom_firmware_info_v3_5(&data_table).unwrap();
40                println!("firmwareinfo: {firmware_info:#?}");
41            },
42            _ => {
43                let firmware_info = vbios_parser.get_atom_firmware_info(&data_table).unwrap();
44                println!("firmwareinfo: {firmware_info:#?}");
45            },
46        }
47    }
48}
Source

pub fn get_date(&self) -> Option<Vec<u8>>

Source

pub fn read_header(&self, offset: usize) -> Option<atom_common_table_header>

Source

pub fn read_table<T>(&self, offset: usize) -> Option<T>

Source

pub fn get_atom_rom_header(&self) -> Option<atom_rom_header_v2_2>

Examples found in repository?
examples/vbios_parser.rs (line 29)
6fn main() {
7    let libdrm_amdgpu = LibDrmAmdgpu::new().unwrap();
8    let device_path = std::env::var("AMDGPU_PATH").unwrap_or("/dev/dri/renderD128".to_string());
9    let (amdgpu_dev, _, _) = {
10        use std::os::fd::IntoRawFd;
11
12        let f = File::open(device_path).unwrap();
13
14        libdrm_amdgpu.init_device_handle(f.into_raw_fd()).unwrap()
15    };
16
17    let Ok(vbios_image) = amdgpu_dev.get_vbios_image() else { return };
18
19    let vbios_parser = VbiosParser::new(vbios_image);
20
21    if !vbios_parser.valid_vbios() || !vbios_parser.check_length() {
22        panic!();
23    }
24
25    if let Some(name) = vbios_parser.get_vbios_name() {
26        println!("name: {name:?}");
27    }
28
29    let rom_header = vbios_parser.get_atom_rom_header().unwrap();
30    println!("{rom_header:#X?}");
31
32    let data_table = vbios_parser.get_atom_data_table(&rom_header).unwrap();
33    println!("{data_table:#X?}");
34
35    if let Some(h) = vbios_parser.get_atom_firmware_info_header(&data_table) {
36        println!("{h:#?}");
37        match (h.format_revision, h.content_revision) {
38            (3, 5) => {
39                let firmware_info = vbios_parser.get_atom_firmware_info_v3_5(&data_table).unwrap();
40                println!("firmwareinfo: {firmware_info:#?}");
41            },
42            _ => {
43                let firmware_info = vbios_parser.get_atom_firmware_info(&data_table).unwrap();
44                println!("firmwareinfo: {firmware_info:#?}");
45            },
46        }
47    }
48}
More examples
Hide additional examples
examples/pp_table.rs (line 28)
5fn main() {
6    let libdrm_amdgpu = LibDrmAmdgpu::new().unwrap();
7    let device_path = std::env::var("AMDGPU_PATH").unwrap_or("/dev/dri/renderD128".to_string());
8    let (amdgpu_dev, _, _) = {
9        use std::os::fd::IntoRawFd;
10
11        let f = File::open(device_path).unwrap();
12
13        libdrm_amdgpu.init_device_handle(f.into_raw_fd()).unwrap()
14    };
15
16    let sysfs = amdgpu_dev.get_sysfs_path().unwrap();
17    let smu = IpHwId::get_from_die_id_sysfs(HwId::MP1, &sysfs.join("ip_discovery/die/0/")).ok().and_then(|smu| smu.instances.get(0).map(|v| v.clone()));
18
19    if let Some(smu) = &smu {
20        println!("SMU (MP1) version: {}.{}.{}", smu.major, smu.minor, smu.revision);
21    }
22
23    let pp_table_bytes_sysfs = std::fs::read(&sysfs.join("pp_table")).ok();
24    let pp_table_bytes_vbios = amdgpu_dev.get_vbios_image().ok().and_then(|vbios_image| {
25        use AMDGPU::VBIOS::VbiosParser;
26
27        let vbios_parser = VbiosParser::new(vbios_image);
28        let rom_header = vbios_parser.get_atom_rom_header()?;
29        let data_table = vbios_parser.get_atom_data_table(&rom_header)?;
30
31        Some(vbios_parser.get_powerplay_table_bytes(&data_table)?.to_vec())
32    });
33
34    for (bytes, src) in [
35        (pp_table_bytes_sysfs, "sysfs"),
36        (pp_table_bytes_vbios, "VBIOS"),
37    ] {
38        let Some(bytes) = bytes else { continue };
39        let pp_table = if let Some(smu) = &smu {
40            AMDGPU::PPTable::decode_with_smu_version(&bytes, smu.version())
41        } else {
42            AMDGPU::PPTable::decode(&bytes)
43        };
44
45        println!("from {src}: {pp_table:#?}");
46    }
47}
Source

pub fn get_atom_data_table( &self, rom_header: &atom_rom_header_v2_2, ) -> Option<atom_master_data_table_v2_1>

Examples found in repository?
examples/vbios_parser.rs (line 32)
6fn main() {
7    let libdrm_amdgpu = LibDrmAmdgpu::new().unwrap();
8    let device_path = std::env::var("AMDGPU_PATH").unwrap_or("/dev/dri/renderD128".to_string());
9    let (amdgpu_dev, _, _) = {
10        use std::os::fd::IntoRawFd;
11
12        let f = File::open(device_path).unwrap();
13
14        libdrm_amdgpu.init_device_handle(f.into_raw_fd()).unwrap()
15    };
16
17    let Ok(vbios_image) = amdgpu_dev.get_vbios_image() else { return };
18
19    let vbios_parser = VbiosParser::new(vbios_image);
20
21    if !vbios_parser.valid_vbios() || !vbios_parser.check_length() {
22        panic!();
23    }
24
25    if let Some(name) = vbios_parser.get_vbios_name() {
26        println!("name: {name:?}");
27    }
28
29    let rom_header = vbios_parser.get_atom_rom_header().unwrap();
30    println!("{rom_header:#X?}");
31
32    let data_table = vbios_parser.get_atom_data_table(&rom_header).unwrap();
33    println!("{data_table:#X?}");
34
35    if let Some(h) = vbios_parser.get_atom_firmware_info_header(&data_table) {
36        println!("{h:#?}");
37        match (h.format_revision, h.content_revision) {
38            (3, 5) => {
39                let firmware_info = vbios_parser.get_atom_firmware_info_v3_5(&data_table).unwrap();
40                println!("firmwareinfo: {firmware_info:#?}");
41            },
42            _ => {
43                let firmware_info = vbios_parser.get_atom_firmware_info(&data_table).unwrap();
44                println!("firmwareinfo: {firmware_info:#?}");
45            },
46        }
47    }
48}
More examples
Hide additional examples
examples/pp_table.rs (line 29)
5fn main() {
6    let libdrm_amdgpu = LibDrmAmdgpu::new().unwrap();
7    let device_path = std::env::var("AMDGPU_PATH").unwrap_or("/dev/dri/renderD128".to_string());
8    let (amdgpu_dev, _, _) = {
9        use std::os::fd::IntoRawFd;
10
11        let f = File::open(device_path).unwrap();
12
13        libdrm_amdgpu.init_device_handle(f.into_raw_fd()).unwrap()
14    };
15
16    let sysfs = amdgpu_dev.get_sysfs_path().unwrap();
17    let smu = IpHwId::get_from_die_id_sysfs(HwId::MP1, &sysfs.join("ip_discovery/die/0/")).ok().and_then(|smu| smu.instances.get(0).map(|v| v.clone()));
18
19    if let Some(smu) = &smu {
20        println!("SMU (MP1) version: {}.{}.{}", smu.major, smu.minor, smu.revision);
21    }
22
23    let pp_table_bytes_sysfs = std::fs::read(&sysfs.join("pp_table")).ok();
24    let pp_table_bytes_vbios = amdgpu_dev.get_vbios_image().ok().and_then(|vbios_image| {
25        use AMDGPU::VBIOS::VbiosParser;
26
27        let vbios_parser = VbiosParser::new(vbios_image);
28        let rom_header = vbios_parser.get_atom_rom_header()?;
29        let data_table = vbios_parser.get_atom_data_table(&rom_header)?;
30
31        Some(vbios_parser.get_powerplay_table_bytes(&data_table)?.to_vec())
32    });
33
34    for (bytes, src) in [
35        (pp_table_bytes_sysfs, "sysfs"),
36        (pp_table_bytes_vbios, "VBIOS"),
37    ] {
38        let Some(bytes) = bytes else { continue };
39        let pp_table = if let Some(smu) = &smu {
40            AMDGPU::PPTable::decode_with_smu_version(&bytes, smu.version())
41        } else {
42            AMDGPU::PPTable::decode(&bytes)
43        };
44
45        println!("from {src}: {pp_table:#?}");
46    }
47}
Source

pub fn get_atom_firmware_info_header( &self, data_table: &atom_master_data_table_v2_1, ) -> Option<atom_common_table_header>

Examples found in repository?
examples/vbios_parser.rs (line 35)
6fn main() {
7    let libdrm_amdgpu = LibDrmAmdgpu::new().unwrap();
8    let device_path = std::env::var("AMDGPU_PATH").unwrap_or("/dev/dri/renderD128".to_string());
9    let (amdgpu_dev, _, _) = {
10        use std::os::fd::IntoRawFd;
11
12        let f = File::open(device_path).unwrap();
13
14        libdrm_amdgpu.init_device_handle(f.into_raw_fd()).unwrap()
15    };
16
17    let Ok(vbios_image) = amdgpu_dev.get_vbios_image() else { return };
18
19    let vbios_parser = VbiosParser::new(vbios_image);
20
21    if !vbios_parser.valid_vbios() || !vbios_parser.check_length() {
22        panic!();
23    }
24
25    if let Some(name) = vbios_parser.get_vbios_name() {
26        println!("name: {name:?}");
27    }
28
29    let rom_header = vbios_parser.get_atom_rom_header().unwrap();
30    println!("{rom_header:#X?}");
31
32    let data_table = vbios_parser.get_atom_data_table(&rom_header).unwrap();
33    println!("{data_table:#X?}");
34
35    if let Some(h) = vbios_parser.get_atom_firmware_info_header(&data_table) {
36        println!("{h:#?}");
37        match (h.format_revision, h.content_revision) {
38            (3, 5) => {
39                let firmware_info = vbios_parser.get_atom_firmware_info_v3_5(&data_table).unwrap();
40                println!("firmwareinfo: {firmware_info:#?}");
41            },
42            _ => {
43                let firmware_info = vbios_parser.get_atom_firmware_info(&data_table).unwrap();
44                println!("firmwareinfo: {firmware_info:#?}");
45            },
46        }
47    }
48}
Source

pub fn get_atom_firmware_info( &self, data_table: &atom_master_data_table_v2_1, ) -> Option<atom_firmware_info_v3_4>

Examples found in repository?
examples/vbios_parser.rs (line 43)
6fn main() {
7    let libdrm_amdgpu = LibDrmAmdgpu::new().unwrap();
8    let device_path = std::env::var("AMDGPU_PATH").unwrap_or("/dev/dri/renderD128".to_string());
9    let (amdgpu_dev, _, _) = {
10        use std::os::fd::IntoRawFd;
11
12        let f = File::open(device_path).unwrap();
13
14        libdrm_amdgpu.init_device_handle(f.into_raw_fd()).unwrap()
15    };
16
17    let Ok(vbios_image) = amdgpu_dev.get_vbios_image() else { return };
18
19    let vbios_parser = VbiosParser::new(vbios_image);
20
21    if !vbios_parser.valid_vbios() || !vbios_parser.check_length() {
22        panic!();
23    }
24
25    if let Some(name) = vbios_parser.get_vbios_name() {
26        println!("name: {name:?}");
27    }
28
29    let rom_header = vbios_parser.get_atom_rom_header().unwrap();
30    println!("{rom_header:#X?}");
31
32    let data_table = vbios_parser.get_atom_data_table(&rom_header).unwrap();
33    println!("{data_table:#X?}");
34
35    if let Some(h) = vbios_parser.get_atom_firmware_info_header(&data_table) {
36        println!("{h:#?}");
37        match (h.format_revision, h.content_revision) {
38            (3, 5) => {
39                let firmware_info = vbios_parser.get_atom_firmware_info_v3_5(&data_table).unwrap();
40                println!("firmwareinfo: {firmware_info:#?}");
41            },
42            _ => {
43                let firmware_info = vbios_parser.get_atom_firmware_info(&data_table).unwrap();
44                println!("firmwareinfo: {firmware_info:#?}");
45            },
46        }
47    }
48}
Source

pub fn get_atom_firmware_info_v3_5( &self, data_table: &atom_master_data_table_v2_1, ) -> Option<atom_firmware_info_v3_5>

Examples found in repository?
examples/vbios_parser.rs (line 39)
6fn main() {
7    let libdrm_amdgpu = LibDrmAmdgpu::new().unwrap();
8    let device_path = std::env::var("AMDGPU_PATH").unwrap_or("/dev/dri/renderD128".to_string());
9    let (amdgpu_dev, _, _) = {
10        use std::os::fd::IntoRawFd;
11
12        let f = File::open(device_path).unwrap();
13
14        libdrm_amdgpu.init_device_handle(f.into_raw_fd()).unwrap()
15    };
16
17    let Ok(vbios_image) = amdgpu_dev.get_vbios_image() else { return };
18
19    let vbios_parser = VbiosParser::new(vbios_image);
20
21    if !vbios_parser.valid_vbios() || !vbios_parser.check_length() {
22        panic!();
23    }
24
25    if let Some(name) = vbios_parser.get_vbios_name() {
26        println!("name: {name:?}");
27    }
28
29    let rom_header = vbios_parser.get_atom_rom_header().unwrap();
30    println!("{rom_header:#X?}");
31
32    let data_table = vbios_parser.get_atom_data_table(&rom_header).unwrap();
33    println!("{data_table:#X?}");
34
35    if let Some(h) = vbios_parser.get_atom_firmware_info_header(&data_table) {
36        println!("{h:#?}");
37        match (h.format_revision, h.content_revision) {
38            (3, 5) => {
39                let firmware_info = vbios_parser.get_atom_firmware_info_v3_5(&data_table).unwrap();
40                println!("firmwareinfo: {firmware_info:#?}");
41            },
42            _ => {
43                let firmware_info = vbios_parser.get_atom_firmware_info(&data_table).unwrap();
44                println!("firmwareinfo: {firmware_info:#?}");
45            },
46        }
47    }
48}
Source

pub fn get_powerplay_table_bytes( &self, data_table: &atom_master_data_table_v2_1, ) -> Option<&[u8]>

Examples found in repository?
examples/pp_table.rs (line 31)
5fn main() {
6    let libdrm_amdgpu = LibDrmAmdgpu::new().unwrap();
7    let device_path = std::env::var("AMDGPU_PATH").unwrap_or("/dev/dri/renderD128".to_string());
8    let (amdgpu_dev, _, _) = {
9        use std::os::fd::IntoRawFd;
10
11        let f = File::open(device_path).unwrap();
12
13        libdrm_amdgpu.init_device_handle(f.into_raw_fd()).unwrap()
14    };
15
16    let sysfs = amdgpu_dev.get_sysfs_path().unwrap();
17    let smu = IpHwId::get_from_die_id_sysfs(HwId::MP1, &sysfs.join("ip_discovery/die/0/")).ok().and_then(|smu| smu.instances.get(0).map(|v| v.clone()));
18
19    if let Some(smu) = &smu {
20        println!("SMU (MP1) version: {}.{}.{}", smu.major, smu.minor, smu.revision);
21    }
22
23    let pp_table_bytes_sysfs = std::fs::read(&sysfs.join("pp_table")).ok();
24    let pp_table_bytes_vbios = amdgpu_dev.get_vbios_image().ok().and_then(|vbios_image| {
25        use AMDGPU::VBIOS::VbiosParser;
26
27        let vbios_parser = VbiosParser::new(vbios_image);
28        let rom_header = vbios_parser.get_atom_rom_header()?;
29        let data_table = vbios_parser.get_atom_data_table(&rom_header)?;
30
31        Some(vbios_parser.get_powerplay_table_bytes(&data_table)?.to_vec())
32    });
33
34    for (bytes, src) in [
35        (pp_table_bytes_sysfs, "sysfs"),
36        (pp_table_bytes_vbios, "VBIOS"),
37    ] {
38        let Some(bytes) = bytes else { continue };
39        let pp_table = if let Some(smu) = &smu {
40            AMDGPU::PPTable::decode_with_smu_version(&bytes, smu.version())
41        } else {
42            AMDGPU::PPTable::decode(&bytes)
43        };
44
45        println!("from {src}: {pp_table:#?}");
46    }
47}
Source

pub fn get_powerplay_table( &self, data_table: &atom_master_data_table_v2_1, ) -> Option<PPTable>

Trait Implementations§

Source§

impl Clone for VbiosParser

Source§

fn clone(&self) -> VbiosParser

Returns a duplicate of the value. Read more
1.0.0 · Source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more
Source§

impl Debug for VbiosParser

Source§

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter. Read more

Auto Trait Implementations§

Blanket Implementations§

Source§

impl<T> Any for T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

impl<T> Borrow<T> for T
where T: ?Sized,

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

impl<T> BorrowMut<T> for T
where T: ?Sized,

Source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
Source§

impl<T> CloneToUninit for T
where T: Clone,

Source§

unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dest. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where U: From<T>,

Source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

Source§

impl<T> ToOwned for T
where T: Clone,

Source§

type Owned = T

The resulting type after obtaining ownership.
Source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
Source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
Source§

impl<T, U> TryFrom<U> for T
where U: Into<T>,

Source§

type Error = Infallible

The type returned in the event of a conversion error.
Source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
Source§

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

Source§

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.
Source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.