Struct devices::pci::PciAddress

pub struct PciAddress {
    pub bus: u8,
    pub dev: u8,
    pub func: u8,
}

PCI Device Address, AKA Bus:Device.Function

Fields

bus: u8

Bus number, in the range 0..=255.

dev: u8

Device number, in the range 0..=31.

func: u8

Function number, in the range 0..=7.

Implementations

impl PciAddress

pub fn new( domain: u32, bus: u32, dev: u32, func: u32 ) -> Result<PciAddress, Error>

Construct PciAddress from separate domain, bus, device, and function numbers.

Arguments

• domain - The PCI domain number. Must be 0 in the current implementation.
• bus - The PCI bus number. Must be in the range 0..=255.
• dev - The PCI device number. Must be in the range 0..=31.
• func - The PCI function number. Must be in the range 0..=7.

Errors

If any component is out of the valid range, this function will return Error::ComponentOutOfRange.

pub fn from_config_address( config_address: u32, register_bits_num: usize ) -> (PciAddress, usize)

Decode a PciAddress and register index from a CONFIG_ADDRESS value.

The configuration address should be in the format used with the PCI CAM or ECAM configuration space access mechanisms, with the lowest bits encoding a register index and the bits above that encoding the PCI function (3 bits), device (5 bits), and bus (8 bits). The low two bits of the configuration address, which are technically part of the register number, are ignored, since PCI configuration space accesses must be DWORD (4-byte) aligned.

On success, returns a PciAddress and the extracted register index in DWORDs.

Arguments

• config_address - The PCI configuration address.
• register_bits_num - The size of the register value in bits.

Example

use resources::PciAddress;

let (pci_address, register_index) = PciAddress::from_config_address(0x32a354, 8);
assert_eq!(pci_address.bus, 0x32);
assert_eq!(pci_address.dev, 0x14);
assert_eq!(pci_address.func, 0x3);
assert_eq!(register_index, 0x15);

pub fn from_path(path: &Path) -> Result<PciAddress, Error>

Construct PciAddress from a system PCI path

Arguments

• path - The system PCI path. The file name of this path must be a valid PCI address.

Errors

If the path given is invalid or filename is an invalid PCI address, this function will return error.

pub fn to_config_address( &self, register: usize, register_bits_num: usize ) -> u32

Encode PciAddress into CONFIG_ADDRESS value.

See PciAddress::from_config_address() for details of the encoding.

Arguments

• register - The register index in DWORDs.
• register_bits_num - The width of the register field, not including the two lowest bits.

Example

use resources::PciAddress;

let pci_address = PciAddress::new(0x0000, 0x32, 0x14, 0x3)?;
let config_address = pci_address.to_config_address(0x15, 8);
assert_eq!(config_address, 0x32a354);

pub fn to_u32(&self) -> u32

Convert B:D:F PCI address to unsigned 32 bit integer.

The bus, device, and function numbers are packed into an integer as follows:

Bits 15-8	Bits 7-3	Bits 2-0
Bus	Device	Function

pub fn devfn(&self) -> u8

Convert D:F PCI address to a linux style devfn.

The device and function numbers are packed into an u8 as follows:

Bits 7-3	Bits 2-0
Device	Function

pub fn acpi_adr(&self) -> u32

Convert D:F PCI address to an ACPI _ADR.

The device and function numbers are packed into an u32 as follows:

Bits 31-16	Bits 15-0
Device	Function

pub fn pme_requester_id(&self) -> u16

Convert B:D:F PCI address to a PCI PME Requester ID.

The output is identical to to_u32() except that only the lower 16 bits are needed

pub fn is_root(&self) -> bool

Returns true if the address points to PCI root host-bridge.

This is true if and only if this is the all-zero address (00:0.0).

Trait Implementations

impl Clone for PciAddress

fn clone(&self) -> PciAddress

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for PciAddress

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

Formats the value using the given formatter.

impl Default for PciAddress

fn default() -> PciAddress

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for PciAddress

fn deserialize<D>( deserializer: D ) -> Result<PciAddress, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for PciAddress

Convert PciAddress to a human-readable string format.

The display format will always include the domain component, even if it is zero.

Example

use resources::PciAddress;

let pci_address = PciAddress::new(0x0000, 0x03, 0x14, 0x1)?;
assert_eq!(pci_address.to_string(), "0000:03:14.1");

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

Formats the value using the given formatter.

impl FromStr for PciAddress

Construct PciAddress from string “[domain:]bus:device.function”. Each component of the address is unprefixed hexadecimal.

Example

use std::str::FromStr;
use resources::PciAddress;

let pci_address = PciAddress::from_str("d7:15.4")?;
assert_eq!(pci_address.bus, 0xd7);
assert_eq!(pci_address.dev, 0x15);
assert_eq!(pci_address.func, 0x4);

type Err = Error

The associated error which can be returned from parsing.

fn from_str(address: &str) -> Result<PciAddress, <PciAddress as FromStr>::Err>

Parses a string s to return a value of this type.

impl Hash for PciAddress

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for PciAddress

fn cmp(&self, other: &PciAddress) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl PartialEq for PciAddress

fn eq(&self, other: &PciAddress) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for PciAddress

fn partial_cmp(&self, other: &PciAddress) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for PciAddress

fn serialize<S>( &self, serializer: S ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl Copy for PciAddress

impl Eq for PciAddress

impl StructuralPartialEq for PciAddress