virtio-drivers 0.13.0

VirtIO guest drivers.
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

//! Types and macros for VirtIO device configuration space.

use crate::{Error, transport::Transport};
use zerocopy::{FromBytes, Immutable, IntoBytes};

/// A configuration space register from which the driver can only read.
#[derive(Default, FromBytes, Immutable, IntoBytes)]
#[repr(transparent)]
pub struct ReadOnly<T: Copy + FromBytes>(pub T);

impl<T: Copy + FromBytes> ReadOnly<T> {
    /// Constructs a new instance for testing.
    pub const fn new(value: T) -> Self {
        Self(value)
    }
}

/// A configuration space register to which the driver can only write.
#[derive(Default, FromBytes, Immutable, IntoBytes)]
#[repr(transparent)]
pub struct WriteOnly<T: Copy + Immutable + IntoBytes>(pub T);

impl<T: Copy + Immutable + IntoBytes> WriteOnly<T> {
    /// Constructs a new instance for testing.
    pub const fn new(value: T) -> Self {
        Self(value)
    }
}

/// A configuration space register which the driver may both read and write.
#[derive(Default, FromBytes, Immutable, IntoBytes)]
#[repr(transparent)]
pub struct ReadWrite<T: Copy + FromBytes + Immutable + IntoBytes>(pub T);

impl<T: Copy + FromBytes + Immutable + IntoBytes> ReadWrite<T> {
    /// Constructs a new instance for testing.
    pub const fn new(value: T) -> Self {
        Self(value)
    }
}

/// Marker trait for configuration space registers from which the driver may read.
pub trait ConfigReadable<T> {}

/// Marker trait for configuration space registers to which the driver may write.
pub trait ConfigWritable<T> {}

impl<T: Copy + FromBytes> ConfigReadable<T> for ReadOnly<T> {}
impl<T: Copy + FromBytes + Immutable + IntoBytes> ConfigReadable<T> for ReadWrite<T> {}
impl<T: Copy + FromBytes + Immutable + IntoBytes> ConfigWritable<T> for ReadWrite<T> {}
impl<T: Copy + Immutable + IntoBytes> ConfigWritable<T> for WriteOnly<T> {}

/// Wrapper for [`Transport::read_config_space`] with an extra dummy parameter to force the correct
/// type to be inferred.
#[inline(always)]
#[doc(hidden)]
pub fn read_help<T, V, R>(transport: &T, offset: usize, _dummy_r: Option<R>) -> Result<V, Error>
where
    T: Transport,
    V: FromBytes + IntoBytes,
    R: ConfigReadable<V>,
{
    transport.read_config_space(offset)
}

/// Wrapper for [`Transport::write_config_space`] with an extra dummy parameter to force the correct
/// type to be inferred.
#[inline(always)]
#[doc(hidden)]
pub fn write_help<T, V, W>(
    transport: &mut T,
    offset: usize,
    value: V,
    _dummy_w: Option<W>,
) -> Result<(), Error>
where
    T: Transport,
    V: Immutable + IntoBytes,
    W: ConfigWritable<V>,
{
    transport.write_config_space(offset, value)
}

/// Reads the given field of the given struct from the device config space via the given transport.
#[macro_export]
macro_rules! read_config {
    ($transport:expr, $struct:ty, $field:ident) => {{
        let dummy_struct: Option<$struct> = None;
        let dummy_field = dummy_struct.map(|s| s.$field);
        $crate::config::read_help(
            &$transport,
            core::mem::offset_of!($struct, $field),
            dummy_field,
        )
    }};
}

/// Writes the given field of the given struct from the device config space via the given transport.
#[macro_export]
macro_rules! write_config {
    ($transport:expr, $struct:ty, $field:ident, $value:expr) => {{
        let dummy_struct: Option<$struct> = None;
        let dummy_field = dummy_struct.map(|s| s.$field);
        $crate::config::write_help(
            &mut $transport,
            core::mem::offset_of!($struct, $field),
            $value,
            dummy_field,
        )
    }};
}

pub use read_config;
pub use write_config;