xhci 0.9.2

A library to handle xHCI
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

macro_rules! impl_debug_from_methods_cx {
    ($name:ident {
        $($method:ident),*$(,)?
    }) => {
        impl<const N:usize> core::fmt::Debug for $name<N> {
            fn fmt(&self, f:&mut core::fmt::Formatter<'_>) -> core::fmt::Result{
                f.debug_struct(core::stringify!($name))
                    $(.field(core::stringify!($method), &self.$method()))*
                    .finish()
            }
        }
    };
}

macro_rules! bit_getter_cx {
    ([$offset:literal]($bit:literal),$method:ident,$name:literal) => {
        #[doc = "Returns the"]
        #[doc = $name]
        #[doc = "bit."]
        #[must_use]
        fn $method(&self) -> bool {
            use bit_field::BitField;
            self.as_ref()[$offset].get_bit($bit)
        }
    };
}

macro_rules! bit_modifier_cx {
    ([$offset:literal]($bit:literal),$method:ident,$name:literal) => {
        paste::paste! {
            #[doc = "Sets the"]
            #[doc = $name]
            #[doc = "bit."]
             fn [<set_ $method>](&mut self){
                use bit_field::BitField;
                self.as_mut()[$offset].set_bit($bit,true);
            }

            #[doc = "Clears the"]
            #[doc = $name]
            #[doc = "bit."]
             fn [<clear_ $method>](&mut self){
                use bit_field::BitField;
                self.as_mut()[$offset].set_bit($bit,false);
            }
        }
    };
}

macro_rules! rw_bit_cx {
    ([$offset:literal]($bit:literal),$method:ident,$name:literal) => {
        bit_getter_cx!([$offset]($bit), $method, $name);
        bit_modifier_cx!([$offset]($bit), $method, $name);
    };
}

macro_rules! field_getter_cx {
    ([$offset:literal]($range:expr),$method:ident,$name:literal,$ty:ty) => {
        #[doc = "Returns the value of the"]
        #[doc = $name]
        #[doc = "field."]
        #[must_use]
        fn $method(&self) -> $ty {
            use bit_field::BitField;
            use core::convert::TryInto;
            self.as_ref()[$offset].get_bits($range).try_into().unwrap()
        }
    };
}

macro_rules! field_setter_cx {
    ([$offset:literal]($range:expr),$method:ident,$name:literal,$ty:ty) => {
        paste::paste! {
            #[doc = "Sets the value of the"]
            #[doc = $name]
            #[doc = "field."]
             fn [<set_ $method>](&mut self,value:$ty){
                use bit_field::BitField;
                use core::convert::TryInto;
                self.as_mut()[$offset].set_bits($range,value.try_into().unwrap());
            }
        }
    };
}

macro_rules! rw_field_cx {
    ([$offset:literal]($range:expr),$method:ident,$name:literal,$ty:ty) => {
        field_getter_cx!([$offset]($range), $method, $name, $ty);
        field_setter_cx!([$offset]($range), $method, $name, $ty);
    };
}

macro_rules! impl_constructor_for_bytes {
    ($name:ident,$full:literal,$bytes:literal) => {
        paste::paste! {
            impl [<$name $bytes Byte>]{
                #[doc = "Creates an empty"]
                #[doc = $bytes]
                #[doc = "byte"]
                #[doc = $full]
                #[doc = "Context."]
                #[must_use]
                pub const fn [<new_ $bytes byte>]()->Self{
                    Self::new()
                }
            }
            impl Default for [<$name $bytes Byte>]{
                fn default()->Self{
                    Self::new()
                }
            }
        }
    };
}
macro_rules! impl_constructor {
    ($name:ident,$full:literal) => {
        paste::paste! {
            impl_constructor_for_bytes!($name,$full,"32");
            impl_constructor_for_bytes!($name,$full,"64");
        }
    };
}