ch32-metapac 0.1.0 

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
127
128
129
130
131
132
133
134
135
136

#![allow(clippy::missing_safety_doc)]
#![allow(clippy::identity_op)]
#![allow(clippy::unnecessary_cast)]
#![allow(clippy::erasing_op)]

#[doc = "ESIG configuration."]
#[derive(Copy, Clone, Eq, PartialEq)]
pub struct Esig {
    ptr: *mut u8,
}
unsafe impl Send for Esig {}
unsafe impl Sync for Esig {}
impl Esig {
    #[inline(always)]
    pub const unsafe fn from_ptr(ptr: *mut ()) -> Self {
        Self { ptr: ptr as _ }
    }
    #[inline(always)]
    pub const fn as_ptr(&self) -> *mut () {
        self.ptr as _
    }
    #[doc = "Flash capacity register."]
    #[inline(always)]
    pub const fn flacap(self) -> crate::common::Reg<regs::Flacap, crate::common::RW> {
        unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0usize) as _) }
    }
    #[doc = "UID register."]
    #[inline(always)]
    pub const fn uniid1(self) -> crate::common::Reg<regs::Uniid1, crate::common::RW> {
        unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x08usize) as _) }
    }
    #[doc = "UID register."]
    #[inline(always)]
    pub const fn uniid2(self) -> crate::common::Reg<regs::Uniid2, crate::common::RW> {
        unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0cusize) as _) }
    }
    #[doc = "Div register."]
    #[inline(always)]
    pub const fn uniid3(self) -> crate::common::Reg<regs::Uniid3, crate::common::RW> {
        unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x10usize) as _) }
    }
}
pub mod regs {
    #[doc = "Flash capacity register."]
    #[repr(transparent)]
    #[derive(Copy, Clone, Eq, PartialEq)]
    pub struct Flacap(pub u16);
    impl Flacap {
        #[doc = "F_SIZE/kByte."]
        #[inline(always)]
        pub const fn f_size(&self) -> u16 {
            let val = (self.0 >> 0usize) & 0xffff;
            val as u16
        }
        #[doc = "F_SIZE/kByte."]
        #[inline(always)]
        pub fn set_f_size(&mut self, val: u16) {
            self.0 = (self.0 & !(0xffff << 0usize)) | (((val as u16) & 0xffff) << 0usize);
        }
    }
    impl Default for Flacap {
        #[inline(always)]
        fn default() -> Flacap {
            Flacap(0)
        }
    }
    #[doc = "UID register."]
    #[repr(transparent)]
    #[derive(Copy, Clone, Eq, PartialEq)]
    pub struct Uniid1(pub u32);
    impl Uniid1 {
        #[doc = "U_ID value."]
        #[inline(always)]
        pub const fn u_id(&self) -> u32 {
            let val = (self.0 >> 0usize) & 0xffff_ffff;
            val as u32
        }
        #[doc = "U_ID value."]
        #[inline(always)]
        pub fn set_u_id(&mut self, val: u32) {
            self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
        }
    }
    impl Default for Uniid1 {
        #[inline(always)]
        fn default() -> Uniid1 {
            Uniid1(0)
        }
    }
    #[doc = "UID register."]
    #[repr(transparent)]
    #[derive(Copy, Clone, Eq, PartialEq)]
    pub struct Uniid2(pub u32);
    impl Uniid2 {
        #[doc = "U_ID value."]
        #[inline(always)]
        pub const fn u_id(&self) -> u32 {
            let val = (self.0 >> 0usize) & 0xffff_ffff;
            val as u32
        }
        #[doc = "U_ID value."]
        #[inline(always)]
        pub fn set_u_id(&mut self, val: u32) {
            self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
        }
    }
    impl Default for Uniid2 {
        #[inline(always)]
        fn default() -> Uniid2 {
            Uniid2(0)
        }
    }
    #[doc = "Div register."]
    #[repr(transparent)]
    #[derive(Copy, Clone, Eq, PartialEq)]
    pub struct Uniid3(pub u32);
    impl Uniid3 {
        #[doc = "U_ID value."]
        #[inline(always)]
        pub const fn u_id(&self) -> u32 {
            let val = (self.0 >> 0usize) & 0xffff_ffff;
            val as u32
        }
        #[doc = "U_ID value."]
        #[inline(always)]
        pub fn set_u_id(&mut self, val: u32) {
            self.0 = (self.0 & !(0xffff_ffff << 0usize)) | (((val as u32) & 0xffff_ffff) << 0usize);
        }
    }
    impl Default for Uniid3 {
        #[inline(always)]
        fn default() -> Uniid3 {
            Uniid3(0)
        }
    }
}