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
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262

#[doc = "WDOG"]
#[repr(C)]
pub struct RegisterBlock {
    #[doc = "Watchdog Control and Status Register"]
    pub CS: crate::RWRegister<u32>,
    #[doc = "Watchdog Counter Register"]
    pub CNT: crate::RWRegister<u32>,
    #[doc = "Watchdog Timeout Value Register"]
    pub TOVAL: crate::RWRegister<u32>,
    #[doc = "Watchdog Window Register"]
    pub WIN: crate::RWRegister<u32>,
}
#[doc = "Watchdog Control and Status Register"]
pub mod CS {
    #[doc = "Stop Enable"]
    pub mod STOP {
        pub const offset: u32 = 0;
        pub const mask: u32 = 0x01 << offset;
        pub mod R {}
        pub mod W {}
        pub mod RW {
            #[doc = "Watchdog disabled in chip stop mode."]
            pub const STOP_0: u32 = 0;
            #[doc = "Watchdog enabled in chip stop mode."]
            pub const STOP_1: u32 = 0x01;
        }
    }
    #[doc = "Wait Enable"]
    pub mod WAIT {
        pub const offset: u32 = 1;
        pub const mask: u32 = 0x01 << offset;
        pub mod R {}
        pub mod W {}
        pub mod RW {
            #[doc = "Watchdog disabled in chip wait mode."]
            pub const WAIT_0: u32 = 0;
            #[doc = "Watchdog enabled in chip wait mode."]
            pub const WAIT_1: u32 = 0x01;
        }
    }
    #[doc = "Debug Enable"]
    pub mod DBG {
        pub const offset: u32 = 2;
        pub const mask: u32 = 0x01 << offset;
        pub mod R {}
        pub mod W {}
        pub mod RW {
            #[doc = "Watchdog disabled in chip debug mode."]
            pub const DBG_0: u32 = 0;
            #[doc = "Watchdog enabled in chip debug mode."]
            pub const DBG_1: u32 = 0x01;
        }
    }
    #[doc = "Watchdog Test"]
    pub mod TST {
        pub const offset: u32 = 3;
        pub const mask: u32 = 0x03 << offset;
        pub mod R {}
        pub mod W {}
        pub mod RW {
            #[doc = "Watchdog test mode disabled."]
            pub const TST_0: u32 = 0;
            #[doc = "Watchdog user mode enabled. (Watchdog test mode disabled.) After testing the watchdog, software should use this setting to indicate that the watchdog is functioning normally in user mode."]
            pub const TST_1: u32 = 0x01;
            #[doc = "Watchdog test mode enabled, only the low byte is used. CNT\\[CNTLOW\\] is compared with TOVAL\\[TOVALLOW\\]."]
            pub const TST_2: u32 = 0x02;
            #[doc = "Watchdog test mode enabled, only the high byte is used. CNT\\[CNTHIGH\\] is compared with TOVAL\\[TOVALHIGH\\]."]
            pub const TST_3: u32 = 0x03;
        }
    }
    #[doc = "Allow updates"]
    pub mod UPDATE {
        pub const offset: u32 = 5;
        pub const mask: u32 = 0x01 << offset;
        pub mod R {}
        pub mod W {}
        pub mod RW {
            #[doc = "Updates not allowed. After the initial configuration, the watchdog cannot be later modified without forcing a reset."]
            pub const UPDATE_0: u32 = 0;
            #[doc = "Updates allowed. Software can modify the watchdog configuration registers within 128 bus clocks after performing the unlock write sequence."]
            pub const UPDATE_1: u32 = 0x01;
        }
    }
    #[doc = "Watchdog Interrupt"]
    pub mod INT {
        pub const offset: u32 = 6;
        pub const mask: u32 = 0x01 << offset;
        pub mod R {}
        pub mod W {}
        pub mod RW {
            #[doc = "Watchdog interrupts are disabled. Watchdog resets are not delayed."]
            pub const INT_0: u32 = 0;
            #[doc = "Watchdog interrupts are enabled. Watchdog resets are delayed by 128 bus clocks from the interrupt vector fetch."]
            pub const INT_1: u32 = 0x01;
        }
    }
    #[doc = "Watchdog Enable"]
    pub mod EN {
        pub const offset: u32 = 7;
        pub const mask: u32 = 0x01 << offset;
        pub mod R {}
        pub mod W {}
        pub mod RW {
            #[doc = "Watchdog disabled."]
            pub const EN_0: u32 = 0;
            #[doc = "Watchdog enabled."]
            pub const EN_1: u32 = 0x01;
        }
    }
    #[doc = "Watchdog Clock"]
    pub mod CLK {
        pub const offset: u32 = 8;
        pub const mask: u32 = 0x03 << offset;
        pub mod R {}
        pub mod W {}
        pub mod RW {
            #[doc = "Bus clock"]
            pub const CLK_0: u32 = 0;
            #[doc = "LPO clock"]
            pub const CLK_1: u32 = 0x01;
            #[doc = "INTCLK (internal clock)"]
            pub const CLK_2: u32 = 0x02;
            #[doc = "ERCLK (external reference clock)"]
            pub const CLK_3: u32 = 0x03;
        }
    }
    #[doc = "Reconfiguration Success"]
    pub mod RCS {
        pub const offset: u32 = 10;
        pub const mask: u32 = 0x01 << offset;
        pub mod R {}
        pub mod W {}
        pub mod RW {
            #[doc = "Reconfiguring WDOG."]
            pub const RCS_0: u32 = 0;
            #[doc = "Reconfiguration is successful."]
            pub const RCS_1: u32 = 0x01;
        }
    }
    #[doc = "Unlock status"]
    pub mod ULK {
        pub const offset: u32 = 11;
        pub const mask: u32 = 0x01 << offset;
        pub mod R {}
        pub mod W {}
        pub mod RW {
            #[doc = "WDOG is locked."]
            pub const ULK_0: u32 = 0;
            #[doc = "WDOG is unlocked."]
            pub const ULK_1: u32 = 0x01;
        }
    }
    #[doc = "Watchdog prescaler"]
    pub mod PRES {
        pub const offset: u32 = 12;
        pub const mask: u32 = 0x01 << offset;
        pub mod R {}
        pub mod W {}
        pub mod RW {
            #[doc = "256 prescaler disabled."]
            pub const PRES_0: u32 = 0;
            #[doc = "256 prescaler enabled."]
            pub const PRES_1: u32 = 0x01;
        }
    }
    #[doc = "Enables or disables WDOG support for 32-bit (otherwise 16-bit or 8-bit) refresh/unlock command write words"]
    pub mod CMD32EN {
        pub const offset: u32 = 13;
        pub const mask: u32 = 0x01 << offset;
        pub mod R {}
        pub mod W {}
        pub mod RW {
            #[doc = "Disables support for 32-bit refresh/unlock command write words. Only 16-bit or 8-bit is supported."]
            pub const CMD32EN_0: u32 = 0;
            #[doc = "Enables support for 32-bit refresh/unlock command write words. 16-bit or 8-bit is NOT supported."]
            pub const CMD32EN_1: u32 = 0x01;
        }
    }
    #[doc = "Watchdog Interrupt Flag"]
    pub mod FLG {
        pub const offset: u32 = 14;
        pub const mask: u32 = 0x01 << offset;
        pub mod R {}
        pub mod W {}
        pub mod RW {
            #[doc = "No interrupt occurred."]
            pub const FLG_0: u32 = 0;
            #[doc = "An interrupt occurred."]
            pub const FLG_1: u32 = 0x01;
        }
    }
    #[doc = "Watchdog Window"]
    pub mod WIN {
        pub const offset: u32 = 15;
        pub const mask: u32 = 0x01 << offset;
        pub mod R {}
        pub mod W {}
        pub mod RW {
            #[doc = "Window mode disabled."]
            pub const WIN_0: u32 = 0;
            #[doc = "Window mode enabled."]
            pub const WIN_1: u32 = 0x01;
        }
    }
}
#[doc = "Watchdog Counter Register"]
pub mod CNT {
    #[doc = "Low byte of the Watchdog Counter"]
    pub mod CNTLOW {
        pub const offset: u32 = 0;
        pub const mask: u32 = 0xff << offset;
        pub mod R {}
        pub mod W {}
        pub mod RW {}
    }
    #[doc = "High byte of the Watchdog Counter"]
    pub mod CNTHIGH {
        pub const offset: u32 = 8;
        pub const mask: u32 = 0xff << offset;
        pub mod R {}
        pub mod W {}
        pub mod RW {}
    }
}
#[doc = "Watchdog Timeout Value Register"]
pub mod TOVAL {
    #[doc = "Low byte of the timeout value"]
    pub mod TOVALLOW {
        pub const offset: u32 = 0;
        pub const mask: u32 = 0xff << offset;
        pub mod R {}
        pub mod W {}
        pub mod RW {}
    }
    #[doc = "High byte of the timeout value"]
    pub mod TOVALHIGH {
        pub const offset: u32 = 8;
        pub const mask: u32 = 0xff << offset;
        pub mod R {}
        pub mod W {}
        pub mod RW {}
    }
}
#[doc = "Watchdog Window Register"]
pub mod WIN {
    #[doc = "Low byte of Watchdog Window"]
    pub mod WINLOW {
        pub const offset: u32 = 0;
        pub const mask: u32 = 0xff << offset;
        pub mod R {}
        pub mod W {}
        pub mod RW {}
    }
    #[doc = "High byte of Watchdog Window"]
    pub mod WINHIGH {
        pub const offset: u32 = 8;
        pub const mask: u32 = 0xff << offset;
        pub mod R {}
        pub mod W {}
        pub mod RW {}
    }
}