1#[doc = r"Value read from the register"]
2pub struct R {
3 bits: u32,
4}
5#[doc = r"Value to write to the register"]
6pub struct W {
7 bits: u32,
8}
9impl super::ENUPD {
10 #[doc = r"Modifies the contents of the register"]
11 #[inline(always)]
12 pub fn modify<F>(&self, f: F)
13 where
14 for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
15 {
16 let bits = self.register.get();
17 self.register.set(f(&R { bits }, &mut W { bits }).bits);
18 }
19 #[doc = r"Reads the contents of the register"]
20 #[inline(always)]
21 pub fn read(&self) -> R {
22 R {
23 bits: self.register.get(),
24 }
25 }
26 #[doc = r"Writes to the register"]
27 #[inline(always)]
28 pub fn write<F>(&self, f: F)
29 where
30 F: FnOnce(&mut W) -> &mut W,
31 {
32 self.register.set(
33 f(&mut W {
34 bits: Self::reset_value(),
35 })
36 .bits,
37 );
38 }
39 #[doc = r"Reset value of the register"]
40 #[inline(always)]
41 pub const fn reset_value() -> u32 {
42 0
43 }
44 #[doc = r"Writes the reset value to the register"]
45 #[inline(always)]
46 pub fn reset(&self) {
47 self.register.set(Self::reset_value())
48 }
49}
50#[doc = "Possible values of the field `PWM_ENUPD_ENUPD0`"]
51#[derive(Clone, Copy, Debug, PartialEq)]
52pub enum PWM_ENUPD_ENUPD0R {
53 #[doc = "Immediate"]
54 PWM_ENUPD_ENUPD0_IMM,
55 #[doc = "Locally Synchronized"]
56 PWM_ENUPD_ENUPD0_LSYNC,
57 #[doc = "Globally Synchronized"]
58 PWM_ENUPD_ENUPD0_GSYNC,
59 #[doc = r"Reserved"]
60 _Reserved(u8),
61}
62impl PWM_ENUPD_ENUPD0R {
63 #[doc = r"Value of the field as raw bits"]
64 #[inline(always)]
65 pub fn bits(&self) -> u8 {
66 match *self {
67 PWM_ENUPD_ENUPD0R::PWM_ENUPD_ENUPD0_IMM => 0,
68 PWM_ENUPD_ENUPD0R::PWM_ENUPD_ENUPD0_LSYNC => 2,
69 PWM_ENUPD_ENUPD0R::PWM_ENUPD_ENUPD0_GSYNC => 3,
70 PWM_ENUPD_ENUPD0R::_Reserved(bits) => bits,
71 }
72 }
73 #[allow(missing_docs)]
74 #[doc(hidden)]
75 #[inline(always)]
76 pub fn _from(value: u8) -> PWM_ENUPD_ENUPD0R {
77 match value {
78 0 => PWM_ENUPD_ENUPD0R::PWM_ENUPD_ENUPD0_IMM,
79 2 => PWM_ENUPD_ENUPD0R::PWM_ENUPD_ENUPD0_LSYNC,
80 3 => PWM_ENUPD_ENUPD0R::PWM_ENUPD_ENUPD0_GSYNC,
81 i => PWM_ENUPD_ENUPD0R::_Reserved(i),
82 }
83 }
84 #[doc = "Checks if the value of the field is `PWM_ENUPD_ENUPD0_IMM`"]
85 #[inline(always)]
86 pub fn is_pwm_enupd_enupd0_imm(&self) -> bool {
87 *self == PWM_ENUPD_ENUPD0R::PWM_ENUPD_ENUPD0_IMM
88 }
89 #[doc = "Checks if the value of the field is `PWM_ENUPD_ENUPD0_LSYNC`"]
90 #[inline(always)]
91 pub fn is_pwm_enupd_enupd0_lsync(&self) -> bool {
92 *self == PWM_ENUPD_ENUPD0R::PWM_ENUPD_ENUPD0_LSYNC
93 }
94 #[doc = "Checks if the value of the field is `PWM_ENUPD_ENUPD0_GSYNC`"]
95 #[inline(always)]
96 pub fn is_pwm_enupd_enupd0_gsync(&self) -> bool {
97 *self == PWM_ENUPD_ENUPD0R::PWM_ENUPD_ENUPD0_GSYNC
98 }
99}
100#[doc = "Values that can be written to the field `PWM_ENUPD_ENUPD0`"]
101#[derive(Clone, Copy, Debug, PartialEq)]
102pub enum PWM_ENUPD_ENUPD0W {
103 #[doc = "Immediate"]
104 PWM_ENUPD_ENUPD0_IMM,
105 #[doc = "Locally Synchronized"]
106 PWM_ENUPD_ENUPD0_LSYNC,
107 #[doc = "Globally Synchronized"]
108 PWM_ENUPD_ENUPD0_GSYNC,
109}
110impl PWM_ENUPD_ENUPD0W {
111 #[allow(missing_docs)]
112 #[doc(hidden)]
113 #[inline(always)]
114 pub fn _bits(&self) -> u8 {
115 match *self {
116 PWM_ENUPD_ENUPD0W::PWM_ENUPD_ENUPD0_IMM => 0,
117 PWM_ENUPD_ENUPD0W::PWM_ENUPD_ENUPD0_LSYNC => 2,
118 PWM_ENUPD_ENUPD0W::PWM_ENUPD_ENUPD0_GSYNC => 3,
119 }
120 }
121}
122#[doc = r"Proxy"]
123pub struct _PWM_ENUPD_ENUPD0W<'a> {
124 w: &'a mut W,
125}
126impl<'a> _PWM_ENUPD_ENUPD0W<'a> {
127 #[doc = r"Writes `variant` to the field"]
128 #[inline(always)]
129 pub fn variant(self, variant: PWM_ENUPD_ENUPD0W) -> &'a mut W {
130 unsafe { self.bits(variant._bits()) }
131 }
132 #[doc = "Immediate"]
133 #[inline(always)]
134 pub fn pwm_enupd_enupd0_imm(self) -> &'a mut W {
135 self.variant(PWM_ENUPD_ENUPD0W::PWM_ENUPD_ENUPD0_IMM)
136 }
137 #[doc = "Locally Synchronized"]
138 #[inline(always)]
139 pub fn pwm_enupd_enupd0_lsync(self) -> &'a mut W {
140 self.variant(PWM_ENUPD_ENUPD0W::PWM_ENUPD_ENUPD0_LSYNC)
141 }
142 #[doc = "Globally Synchronized"]
143 #[inline(always)]
144 pub fn pwm_enupd_enupd0_gsync(self) -> &'a mut W {
145 self.variant(PWM_ENUPD_ENUPD0W::PWM_ENUPD_ENUPD0_GSYNC)
146 }
147 #[doc = r"Writes raw bits to the field"]
148 #[inline(always)]
149 pub unsafe fn bits(self, value: u8) -> &'a mut W {
150 self.w.bits &= !(3 << 0);
151 self.w.bits |= ((value as u32) & 3) << 0;
152 self.w
153 }
154}
155#[doc = "Possible values of the field `PWM_ENUPD_ENUPD1`"]
156#[derive(Clone, Copy, Debug, PartialEq)]
157pub enum PWM_ENUPD_ENUPD1R {
158 #[doc = "Immediate"]
159 PWM_ENUPD_ENUPD1_IMM,
160 #[doc = "Locally Synchronized"]
161 PWM_ENUPD_ENUPD1_LSYNC,
162 #[doc = "Globally Synchronized"]
163 PWM_ENUPD_ENUPD1_GSYNC,
164 #[doc = r"Reserved"]
165 _Reserved(u8),
166}
167impl PWM_ENUPD_ENUPD1R {
168 #[doc = r"Value of the field as raw bits"]
169 #[inline(always)]
170 pub fn bits(&self) -> u8 {
171 match *self {
172 PWM_ENUPD_ENUPD1R::PWM_ENUPD_ENUPD1_IMM => 0,
173 PWM_ENUPD_ENUPD1R::PWM_ENUPD_ENUPD1_LSYNC => 2,
174 PWM_ENUPD_ENUPD1R::PWM_ENUPD_ENUPD1_GSYNC => 3,
175 PWM_ENUPD_ENUPD1R::_Reserved(bits) => bits,
176 }
177 }
178 #[allow(missing_docs)]
179 #[doc(hidden)]
180 #[inline(always)]
181 pub fn _from(value: u8) -> PWM_ENUPD_ENUPD1R {
182 match value {
183 0 => PWM_ENUPD_ENUPD1R::PWM_ENUPD_ENUPD1_IMM,
184 2 => PWM_ENUPD_ENUPD1R::PWM_ENUPD_ENUPD1_LSYNC,
185 3 => PWM_ENUPD_ENUPD1R::PWM_ENUPD_ENUPD1_GSYNC,
186 i => PWM_ENUPD_ENUPD1R::_Reserved(i),
187 }
188 }
189 #[doc = "Checks if the value of the field is `PWM_ENUPD_ENUPD1_IMM`"]
190 #[inline(always)]
191 pub fn is_pwm_enupd_enupd1_imm(&self) -> bool {
192 *self == PWM_ENUPD_ENUPD1R::PWM_ENUPD_ENUPD1_IMM
193 }
194 #[doc = "Checks if the value of the field is `PWM_ENUPD_ENUPD1_LSYNC`"]
195 #[inline(always)]
196 pub fn is_pwm_enupd_enupd1_lsync(&self) -> bool {
197 *self == PWM_ENUPD_ENUPD1R::PWM_ENUPD_ENUPD1_LSYNC
198 }
199 #[doc = "Checks if the value of the field is `PWM_ENUPD_ENUPD1_GSYNC`"]
200 #[inline(always)]
201 pub fn is_pwm_enupd_enupd1_gsync(&self) -> bool {
202 *self == PWM_ENUPD_ENUPD1R::PWM_ENUPD_ENUPD1_GSYNC
203 }
204}
205#[doc = "Values that can be written to the field `PWM_ENUPD_ENUPD1`"]
206#[derive(Clone, Copy, Debug, PartialEq)]
207pub enum PWM_ENUPD_ENUPD1W {
208 #[doc = "Immediate"]
209 PWM_ENUPD_ENUPD1_IMM,
210 #[doc = "Locally Synchronized"]
211 PWM_ENUPD_ENUPD1_LSYNC,
212 #[doc = "Globally Synchronized"]
213 PWM_ENUPD_ENUPD1_GSYNC,
214}
215impl PWM_ENUPD_ENUPD1W {
216 #[allow(missing_docs)]
217 #[doc(hidden)]
218 #[inline(always)]
219 pub fn _bits(&self) -> u8 {
220 match *self {
221 PWM_ENUPD_ENUPD1W::PWM_ENUPD_ENUPD1_IMM => 0,
222 PWM_ENUPD_ENUPD1W::PWM_ENUPD_ENUPD1_LSYNC => 2,
223 PWM_ENUPD_ENUPD1W::PWM_ENUPD_ENUPD1_GSYNC => 3,
224 }
225 }
226}
227#[doc = r"Proxy"]
228pub struct _PWM_ENUPD_ENUPD1W<'a> {
229 w: &'a mut W,
230}
231impl<'a> _PWM_ENUPD_ENUPD1W<'a> {
232 #[doc = r"Writes `variant` to the field"]
233 #[inline(always)]
234 pub fn variant(self, variant: PWM_ENUPD_ENUPD1W) -> &'a mut W {
235 unsafe { self.bits(variant._bits()) }
236 }
237 #[doc = "Immediate"]
238 #[inline(always)]
239 pub fn pwm_enupd_enupd1_imm(self) -> &'a mut W {
240 self.variant(PWM_ENUPD_ENUPD1W::PWM_ENUPD_ENUPD1_IMM)
241 }
242 #[doc = "Locally Synchronized"]
243 #[inline(always)]
244 pub fn pwm_enupd_enupd1_lsync(self) -> &'a mut W {
245 self.variant(PWM_ENUPD_ENUPD1W::PWM_ENUPD_ENUPD1_LSYNC)
246 }
247 #[doc = "Globally Synchronized"]
248 #[inline(always)]
249 pub fn pwm_enupd_enupd1_gsync(self) -> &'a mut W {
250 self.variant(PWM_ENUPD_ENUPD1W::PWM_ENUPD_ENUPD1_GSYNC)
251 }
252 #[doc = r"Writes raw bits to the field"]
253 #[inline(always)]
254 pub unsafe fn bits(self, value: u8) -> &'a mut W {
255 self.w.bits &= !(3 << 2);
256 self.w.bits |= ((value as u32) & 3) << 2;
257 self.w
258 }
259}
260#[doc = "Possible values of the field `PWM_ENUPD_ENUPD2`"]
261#[derive(Clone, Copy, Debug, PartialEq)]
262pub enum PWM_ENUPD_ENUPD2R {
263 #[doc = "Immediate"]
264 PWM_ENUPD_ENUPD2_IMM,
265 #[doc = "Locally Synchronized"]
266 PWM_ENUPD_ENUPD2_LSYNC,
267 #[doc = "Globally Synchronized"]
268 PWM_ENUPD_ENUPD2_GSYNC,
269 #[doc = r"Reserved"]
270 _Reserved(u8),
271}
272impl PWM_ENUPD_ENUPD2R {
273 #[doc = r"Value of the field as raw bits"]
274 #[inline(always)]
275 pub fn bits(&self) -> u8 {
276 match *self {
277 PWM_ENUPD_ENUPD2R::PWM_ENUPD_ENUPD2_IMM => 0,
278 PWM_ENUPD_ENUPD2R::PWM_ENUPD_ENUPD2_LSYNC => 2,
279 PWM_ENUPD_ENUPD2R::PWM_ENUPD_ENUPD2_GSYNC => 3,
280 PWM_ENUPD_ENUPD2R::_Reserved(bits) => bits,
281 }
282 }
283 #[allow(missing_docs)]
284 #[doc(hidden)]
285 #[inline(always)]
286 pub fn _from(value: u8) -> PWM_ENUPD_ENUPD2R {
287 match value {
288 0 => PWM_ENUPD_ENUPD2R::PWM_ENUPD_ENUPD2_IMM,
289 2 => PWM_ENUPD_ENUPD2R::PWM_ENUPD_ENUPD2_LSYNC,
290 3 => PWM_ENUPD_ENUPD2R::PWM_ENUPD_ENUPD2_GSYNC,
291 i => PWM_ENUPD_ENUPD2R::_Reserved(i),
292 }
293 }
294 #[doc = "Checks if the value of the field is `PWM_ENUPD_ENUPD2_IMM`"]
295 #[inline(always)]
296 pub fn is_pwm_enupd_enupd2_imm(&self) -> bool {
297 *self == PWM_ENUPD_ENUPD2R::PWM_ENUPD_ENUPD2_IMM
298 }
299 #[doc = "Checks if the value of the field is `PWM_ENUPD_ENUPD2_LSYNC`"]
300 #[inline(always)]
301 pub fn is_pwm_enupd_enupd2_lsync(&self) -> bool {
302 *self == PWM_ENUPD_ENUPD2R::PWM_ENUPD_ENUPD2_LSYNC
303 }
304 #[doc = "Checks if the value of the field is `PWM_ENUPD_ENUPD2_GSYNC`"]
305 #[inline(always)]
306 pub fn is_pwm_enupd_enupd2_gsync(&self) -> bool {
307 *self == PWM_ENUPD_ENUPD2R::PWM_ENUPD_ENUPD2_GSYNC
308 }
309}
310#[doc = "Values that can be written to the field `PWM_ENUPD_ENUPD2`"]
311#[derive(Clone, Copy, Debug, PartialEq)]
312pub enum PWM_ENUPD_ENUPD2W {
313 #[doc = "Immediate"]
314 PWM_ENUPD_ENUPD2_IMM,
315 #[doc = "Locally Synchronized"]
316 PWM_ENUPD_ENUPD2_LSYNC,
317 #[doc = "Globally Synchronized"]
318 PWM_ENUPD_ENUPD2_GSYNC,
319}
320impl PWM_ENUPD_ENUPD2W {
321 #[allow(missing_docs)]
322 #[doc(hidden)]
323 #[inline(always)]
324 pub fn _bits(&self) -> u8 {
325 match *self {
326 PWM_ENUPD_ENUPD2W::PWM_ENUPD_ENUPD2_IMM => 0,
327 PWM_ENUPD_ENUPD2W::PWM_ENUPD_ENUPD2_LSYNC => 2,
328 PWM_ENUPD_ENUPD2W::PWM_ENUPD_ENUPD2_GSYNC => 3,
329 }
330 }
331}
332#[doc = r"Proxy"]
333pub struct _PWM_ENUPD_ENUPD2W<'a> {
334 w: &'a mut W,
335}
336impl<'a> _PWM_ENUPD_ENUPD2W<'a> {
337 #[doc = r"Writes `variant` to the field"]
338 #[inline(always)]
339 pub fn variant(self, variant: PWM_ENUPD_ENUPD2W) -> &'a mut W {
340 unsafe { self.bits(variant._bits()) }
341 }
342 #[doc = "Immediate"]
343 #[inline(always)]
344 pub fn pwm_enupd_enupd2_imm(self) -> &'a mut W {
345 self.variant(PWM_ENUPD_ENUPD2W::PWM_ENUPD_ENUPD2_IMM)
346 }
347 #[doc = "Locally Synchronized"]
348 #[inline(always)]
349 pub fn pwm_enupd_enupd2_lsync(self) -> &'a mut W {
350 self.variant(PWM_ENUPD_ENUPD2W::PWM_ENUPD_ENUPD2_LSYNC)
351 }
352 #[doc = "Globally Synchronized"]
353 #[inline(always)]
354 pub fn pwm_enupd_enupd2_gsync(self) -> &'a mut W {
355 self.variant(PWM_ENUPD_ENUPD2W::PWM_ENUPD_ENUPD2_GSYNC)
356 }
357 #[doc = r"Writes raw bits to the field"]
358 #[inline(always)]
359 pub unsafe fn bits(self, value: u8) -> &'a mut W {
360 self.w.bits &= !(3 << 4);
361 self.w.bits |= ((value as u32) & 3) << 4;
362 self.w
363 }
364}
365#[doc = "Possible values of the field `PWM_ENUPD_ENUPD3`"]
366#[derive(Clone, Copy, Debug, PartialEq)]
367pub enum PWM_ENUPD_ENUPD3R {
368 #[doc = "Immediate"]
369 PWM_ENUPD_ENUPD3_IMM,
370 #[doc = "Locally Synchronized"]
371 PWM_ENUPD_ENUPD3_LSYNC,
372 #[doc = "Globally Synchronized"]
373 PWM_ENUPD_ENUPD3_GSYNC,
374 #[doc = r"Reserved"]
375 _Reserved(u8),
376}
377impl PWM_ENUPD_ENUPD3R {
378 #[doc = r"Value of the field as raw bits"]
379 #[inline(always)]
380 pub fn bits(&self) -> u8 {
381 match *self {
382 PWM_ENUPD_ENUPD3R::PWM_ENUPD_ENUPD3_IMM => 0,
383 PWM_ENUPD_ENUPD3R::PWM_ENUPD_ENUPD3_LSYNC => 2,
384 PWM_ENUPD_ENUPD3R::PWM_ENUPD_ENUPD3_GSYNC => 3,
385 PWM_ENUPD_ENUPD3R::_Reserved(bits) => bits,
386 }
387 }
388 #[allow(missing_docs)]
389 #[doc(hidden)]
390 #[inline(always)]
391 pub fn _from(value: u8) -> PWM_ENUPD_ENUPD3R {
392 match value {
393 0 => PWM_ENUPD_ENUPD3R::PWM_ENUPD_ENUPD3_IMM,
394 2 => PWM_ENUPD_ENUPD3R::PWM_ENUPD_ENUPD3_LSYNC,
395 3 => PWM_ENUPD_ENUPD3R::PWM_ENUPD_ENUPD3_GSYNC,
396 i => PWM_ENUPD_ENUPD3R::_Reserved(i),
397 }
398 }
399 #[doc = "Checks if the value of the field is `PWM_ENUPD_ENUPD3_IMM`"]
400 #[inline(always)]
401 pub fn is_pwm_enupd_enupd3_imm(&self) -> bool {
402 *self == PWM_ENUPD_ENUPD3R::PWM_ENUPD_ENUPD3_IMM
403 }
404 #[doc = "Checks if the value of the field is `PWM_ENUPD_ENUPD3_LSYNC`"]
405 #[inline(always)]
406 pub fn is_pwm_enupd_enupd3_lsync(&self) -> bool {
407 *self == PWM_ENUPD_ENUPD3R::PWM_ENUPD_ENUPD3_LSYNC
408 }
409 #[doc = "Checks if the value of the field is `PWM_ENUPD_ENUPD3_GSYNC`"]
410 #[inline(always)]
411 pub fn is_pwm_enupd_enupd3_gsync(&self) -> bool {
412 *self == PWM_ENUPD_ENUPD3R::PWM_ENUPD_ENUPD3_GSYNC
413 }
414}
415#[doc = "Values that can be written to the field `PWM_ENUPD_ENUPD3`"]
416#[derive(Clone, Copy, Debug, PartialEq)]
417pub enum PWM_ENUPD_ENUPD3W {
418 #[doc = "Immediate"]
419 PWM_ENUPD_ENUPD3_IMM,
420 #[doc = "Locally Synchronized"]
421 PWM_ENUPD_ENUPD3_LSYNC,
422 #[doc = "Globally Synchronized"]
423 PWM_ENUPD_ENUPD3_GSYNC,
424}
425impl PWM_ENUPD_ENUPD3W {
426 #[allow(missing_docs)]
427 #[doc(hidden)]
428 #[inline(always)]
429 pub fn _bits(&self) -> u8 {
430 match *self {
431 PWM_ENUPD_ENUPD3W::PWM_ENUPD_ENUPD3_IMM => 0,
432 PWM_ENUPD_ENUPD3W::PWM_ENUPD_ENUPD3_LSYNC => 2,
433 PWM_ENUPD_ENUPD3W::PWM_ENUPD_ENUPD3_GSYNC => 3,
434 }
435 }
436}
437#[doc = r"Proxy"]
438pub struct _PWM_ENUPD_ENUPD3W<'a> {
439 w: &'a mut W,
440}
441impl<'a> _PWM_ENUPD_ENUPD3W<'a> {
442 #[doc = r"Writes `variant` to the field"]
443 #[inline(always)]
444 pub fn variant(self, variant: PWM_ENUPD_ENUPD3W) -> &'a mut W {
445 unsafe { self.bits(variant._bits()) }
446 }
447 #[doc = "Immediate"]
448 #[inline(always)]
449 pub fn pwm_enupd_enupd3_imm(self) -> &'a mut W {
450 self.variant(PWM_ENUPD_ENUPD3W::PWM_ENUPD_ENUPD3_IMM)
451 }
452 #[doc = "Locally Synchronized"]
453 #[inline(always)]
454 pub fn pwm_enupd_enupd3_lsync(self) -> &'a mut W {
455 self.variant(PWM_ENUPD_ENUPD3W::PWM_ENUPD_ENUPD3_LSYNC)
456 }
457 #[doc = "Globally Synchronized"]
458 #[inline(always)]
459 pub fn pwm_enupd_enupd3_gsync(self) -> &'a mut W {
460 self.variant(PWM_ENUPD_ENUPD3W::PWM_ENUPD_ENUPD3_GSYNC)
461 }
462 #[doc = r"Writes raw bits to the field"]
463 #[inline(always)]
464 pub unsafe fn bits(self, value: u8) -> &'a mut W {
465 self.w.bits &= !(3 << 6);
466 self.w.bits |= ((value as u32) & 3) << 6;
467 self.w
468 }
469}
470#[doc = "Possible values of the field `PWM_ENUPD_ENUPD4`"]
471#[derive(Clone, Copy, Debug, PartialEq)]
472pub enum PWM_ENUPD_ENUPD4R {
473 #[doc = "Immediate"]
474 PWM_ENUPD_ENUPD4_IMM,
475 #[doc = "Locally Synchronized"]
476 PWM_ENUPD_ENUPD4_LSYNC,
477 #[doc = "Globally Synchronized"]
478 PWM_ENUPD_ENUPD4_GSYNC,
479 #[doc = r"Reserved"]
480 _Reserved(u8),
481}
482impl PWM_ENUPD_ENUPD4R {
483 #[doc = r"Value of the field as raw bits"]
484 #[inline(always)]
485 pub fn bits(&self) -> u8 {
486 match *self {
487 PWM_ENUPD_ENUPD4R::PWM_ENUPD_ENUPD4_IMM => 0,
488 PWM_ENUPD_ENUPD4R::PWM_ENUPD_ENUPD4_LSYNC => 2,
489 PWM_ENUPD_ENUPD4R::PWM_ENUPD_ENUPD4_GSYNC => 3,
490 PWM_ENUPD_ENUPD4R::_Reserved(bits) => bits,
491 }
492 }
493 #[allow(missing_docs)]
494 #[doc(hidden)]
495 #[inline(always)]
496 pub fn _from(value: u8) -> PWM_ENUPD_ENUPD4R {
497 match value {
498 0 => PWM_ENUPD_ENUPD4R::PWM_ENUPD_ENUPD4_IMM,
499 2 => PWM_ENUPD_ENUPD4R::PWM_ENUPD_ENUPD4_LSYNC,
500 3 => PWM_ENUPD_ENUPD4R::PWM_ENUPD_ENUPD4_GSYNC,
501 i => PWM_ENUPD_ENUPD4R::_Reserved(i),
502 }
503 }
504 #[doc = "Checks if the value of the field is `PWM_ENUPD_ENUPD4_IMM`"]
505 #[inline(always)]
506 pub fn is_pwm_enupd_enupd4_imm(&self) -> bool {
507 *self == PWM_ENUPD_ENUPD4R::PWM_ENUPD_ENUPD4_IMM
508 }
509 #[doc = "Checks if the value of the field is `PWM_ENUPD_ENUPD4_LSYNC`"]
510 #[inline(always)]
511 pub fn is_pwm_enupd_enupd4_lsync(&self) -> bool {
512 *self == PWM_ENUPD_ENUPD4R::PWM_ENUPD_ENUPD4_LSYNC
513 }
514 #[doc = "Checks if the value of the field is `PWM_ENUPD_ENUPD4_GSYNC`"]
515 #[inline(always)]
516 pub fn is_pwm_enupd_enupd4_gsync(&self) -> bool {
517 *self == PWM_ENUPD_ENUPD4R::PWM_ENUPD_ENUPD4_GSYNC
518 }
519}
520#[doc = "Values that can be written to the field `PWM_ENUPD_ENUPD4`"]
521#[derive(Clone, Copy, Debug, PartialEq)]
522pub enum PWM_ENUPD_ENUPD4W {
523 #[doc = "Immediate"]
524 PWM_ENUPD_ENUPD4_IMM,
525 #[doc = "Locally Synchronized"]
526 PWM_ENUPD_ENUPD4_LSYNC,
527 #[doc = "Globally Synchronized"]
528 PWM_ENUPD_ENUPD4_GSYNC,
529}
530impl PWM_ENUPD_ENUPD4W {
531 #[allow(missing_docs)]
532 #[doc(hidden)]
533 #[inline(always)]
534 pub fn _bits(&self) -> u8 {
535 match *self {
536 PWM_ENUPD_ENUPD4W::PWM_ENUPD_ENUPD4_IMM => 0,
537 PWM_ENUPD_ENUPD4W::PWM_ENUPD_ENUPD4_LSYNC => 2,
538 PWM_ENUPD_ENUPD4W::PWM_ENUPD_ENUPD4_GSYNC => 3,
539 }
540 }
541}
542#[doc = r"Proxy"]
543pub struct _PWM_ENUPD_ENUPD4W<'a> {
544 w: &'a mut W,
545}
546impl<'a> _PWM_ENUPD_ENUPD4W<'a> {
547 #[doc = r"Writes `variant` to the field"]
548 #[inline(always)]
549 pub fn variant(self, variant: PWM_ENUPD_ENUPD4W) -> &'a mut W {
550 unsafe { self.bits(variant._bits()) }
551 }
552 #[doc = "Immediate"]
553 #[inline(always)]
554 pub fn pwm_enupd_enupd4_imm(self) -> &'a mut W {
555 self.variant(PWM_ENUPD_ENUPD4W::PWM_ENUPD_ENUPD4_IMM)
556 }
557 #[doc = "Locally Synchronized"]
558 #[inline(always)]
559 pub fn pwm_enupd_enupd4_lsync(self) -> &'a mut W {
560 self.variant(PWM_ENUPD_ENUPD4W::PWM_ENUPD_ENUPD4_LSYNC)
561 }
562 #[doc = "Globally Synchronized"]
563 #[inline(always)]
564 pub fn pwm_enupd_enupd4_gsync(self) -> &'a mut W {
565 self.variant(PWM_ENUPD_ENUPD4W::PWM_ENUPD_ENUPD4_GSYNC)
566 }
567 #[doc = r"Writes raw bits to the field"]
568 #[inline(always)]
569 pub unsafe fn bits(self, value: u8) -> &'a mut W {
570 self.w.bits &= !(3 << 8);
571 self.w.bits |= ((value as u32) & 3) << 8;
572 self.w
573 }
574}
575#[doc = "Possible values of the field `PWM_ENUPD_ENUPD5`"]
576#[derive(Clone, Copy, Debug, PartialEq)]
577pub enum PWM_ENUPD_ENUPD5R {
578 #[doc = "Immediate"]
579 PWM_ENUPD_ENUPD5_IMM,
580 #[doc = "Locally Synchronized"]
581 PWM_ENUPD_ENUPD5_LSYNC,
582 #[doc = "Globally Synchronized"]
583 PWM_ENUPD_ENUPD5_GSYNC,
584 #[doc = r"Reserved"]
585 _Reserved(u8),
586}
587impl PWM_ENUPD_ENUPD5R {
588 #[doc = r"Value of the field as raw bits"]
589 #[inline(always)]
590 pub fn bits(&self) -> u8 {
591 match *self {
592 PWM_ENUPD_ENUPD5R::PWM_ENUPD_ENUPD5_IMM => 0,
593 PWM_ENUPD_ENUPD5R::PWM_ENUPD_ENUPD5_LSYNC => 2,
594 PWM_ENUPD_ENUPD5R::PWM_ENUPD_ENUPD5_GSYNC => 3,
595 PWM_ENUPD_ENUPD5R::_Reserved(bits) => bits,
596 }
597 }
598 #[allow(missing_docs)]
599 #[doc(hidden)]
600 #[inline(always)]
601 pub fn _from(value: u8) -> PWM_ENUPD_ENUPD5R {
602 match value {
603 0 => PWM_ENUPD_ENUPD5R::PWM_ENUPD_ENUPD5_IMM,
604 2 => PWM_ENUPD_ENUPD5R::PWM_ENUPD_ENUPD5_LSYNC,
605 3 => PWM_ENUPD_ENUPD5R::PWM_ENUPD_ENUPD5_GSYNC,
606 i => PWM_ENUPD_ENUPD5R::_Reserved(i),
607 }
608 }
609 #[doc = "Checks if the value of the field is `PWM_ENUPD_ENUPD5_IMM`"]
610 #[inline(always)]
611 pub fn is_pwm_enupd_enupd5_imm(&self) -> bool {
612 *self == PWM_ENUPD_ENUPD5R::PWM_ENUPD_ENUPD5_IMM
613 }
614 #[doc = "Checks if the value of the field is `PWM_ENUPD_ENUPD5_LSYNC`"]
615 #[inline(always)]
616 pub fn is_pwm_enupd_enupd5_lsync(&self) -> bool {
617 *self == PWM_ENUPD_ENUPD5R::PWM_ENUPD_ENUPD5_LSYNC
618 }
619 #[doc = "Checks if the value of the field is `PWM_ENUPD_ENUPD5_GSYNC`"]
620 #[inline(always)]
621 pub fn is_pwm_enupd_enupd5_gsync(&self) -> bool {
622 *self == PWM_ENUPD_ENUPD5R::PWM_ENUPD_ENUPD5_GSYNC
623 }
624}
625#[doc = "Values that can be written to the field `PWM_ENUPD_ENUPD5`"]
626#[derive(Clone, Copy, Debug, PartialEq)]
627pub enum PWM_ENUPD_ENUPD5W {
628 #[doc = "Immediate"]
629 PWM_ENUPD_ENUPD5_IMM,
630 #[doc = "Locally Synchronized"]
631 PWM_ENUPD_ENUPD5_LSYNC,
632 #[doc = "Globally Synchronized"]
633 PWM_ENUPD_ENUPD5_GSYNC,
634}
635impl PWM_ENUPD_ENUPD5W {
636 #[allow(missing_docs)]
637 #[doc(hidden)]
638 #[inline(always)]
639 pub fn _bits(&self) -> u8 {
640 match *self {
641 PWM_ENUPD_ENUPD5W::PWM_ENUPD_ENUPD5_IMM => 0,
642 PWM_ENUPD_ENUPD5W::PWM_ENUPD_ENUPD5_LSYNC => 2,
643 PWM_ENUPD_ENUPD5W::PWM_ENUPD_ENUPD5_GSYNC => 3,
644 }
645 }
646}
647#[doc = r"Proxy"]
648pub struct _PWM_ENUPD_ENUPD5W<'a> {
649 w: &'a mut W,
650}
651impl<'a> _PWM_ENUPD_ENUPD5W<'a> {
652 #[doc = r"Writes `variant` to the field"]
653 #[inline(always)]
654 pub fn variant(self, variant: PWM_ENUPD_ENUPD5W) -> &'a mut W {
655 unsafe { self.bits(variant._bits()) }
656 }
657 #[doc = "Immediate"]
658 #[inline(always)]
659 pub fn pwm_enupd_enupd5_imm(self) -> &'a mut W {
660 self.variant(PWM_ENUPD_ENUPD5W::PWM_ENUPD_ENUPD5_IMM)
661 }
662 #[doc = "Locally Synchronized"]
663 #[inline(always)]
664 pub fn pwm_enupd_enupd5_lsync(self) -> &'a mut W {
665 self.variant(PWM_ENUPD_ENUPD5W::PWM_ENUPD_ENUPD5_LSYNC)
666 }
667 #[doc = "Globally Synchronized"]
668 #[inline(always)]
669 pub fn pwm_enupd_enupd5_gsync(self) -> &'a mut W {
670 self.variant(PWM_ENUPD_ENUPD5W::PWM_ENUPD_ENUPD5_GSYNC)
671 }
672 #[doc = r"Writes raw bits to the field"]
673 #[inline(always)]
674 pub unsafe fn bits(self, value: u8) -> &'a mut W {
675 self.w.bits &= !(3 << 10);
676 self.w.bits |= ((value as u32) & 3) << 10;
677 self.w
678 }
679}
680#[doc = "Possible values of the field `PWM_ENUPD_ENUPD6`"]
681#[derive(Clone, Copy, Debug, PartialEq)]
682pub enum PWM_ENUPD_ENUPD6R {
683 #[doc = "Immediate"]
684 PWM_ENUPD_ENUPD6_IMM,
685 #[doc = "Locally Synchronized"]
686 PWM_ENUPD_ENUPD6_LSYNC,
687 #[doc = "Globally Synchronized"]
688 PWM_ENUPD_ENUPD6_GSYNC,
689 #[doc = r"Reserved"]
690 _Reserved(u8),
691}
692impl PWM_ENUPD_ENUPD6R {
693 #[doc = r"Value of the field as raw bits"]
694 #[inline(always)]
695 pub fn bits(&self) -> u8 {
696 match *self {
697 PWM_ENUPD_ENUPD6R::PWM_ENUPD_ENUPD6_IMM => 0,
698 PWM_ENUPD_ENUPD6R::PWM_ENUPD_ENUPD6_LSYNC => 2,
699 PWM_ENUPD_ENUPD6R::PWM_ENUPD_ENUPD6_GSYNC => 3,
700 PWM_ENUPD_ENUPD6R::_Reserved(bits) => bits,
701 }
702 }
703 #[allow(missing_docs)]
704 #[doc(hidden)]
705 #[inline(always)]
706 pub fn _from(value: u8) -> PWM_ENUPD_ENUPD6R {
707 match value {
708 0 => PWM_ENUPD_ENUPD6R::PWM_ENUPD_ENUPD6_IMM,
709 2 => PWM_ENUPD_ENUPD6R::PWM_ENUPD_ENUPD6_LSYNC,
710 3 => PWM_ENUPD_ENUPD6R::PWM_ENUPD_ENUPD6_GSYNC,
711 i => PWM_ENUPD_ENUPD6R::_Reserved(i),
712 }
713 }
714 #[doc = "Checks if the value of the field is `PWM_ENUPD_ENUPD6_IMM`"]
715 #[inline(always)]
716 pub fn is_pwm_enupd_enupd6_imm(&self) -> bool {
717 *self == PWM_ENUPD_ENUPD6R::PWM_ENUPD_ENUPD6_IMM
718 }
719 #[doc = "Checks if the value of the field is `PWM_ENUPD_ENUPD6_LSYNC`"]
720 #[inline(always)]
721 pub fn is_pwm_enupd_enupd6_lsync(&self) -> bool {
722 *self == PWM_ENUPD_ENUPD6R::PWM_ENUPD_ENUPD6_LSYNC
723 }
724 #[doc = "Checks if the value of the field is `PWM_ENUPD_ENUPD6_GSYNC`"]
725 #[inline(always)]
726 pub fn is_pwm_enupd_enupd6_gsync(&self) -> bool {
727 *self == PWM_ENUPD_ENUPD6R::PWM_ENUPD_ENUPD6_GSYNC
728 }
729}
730#[doc = "Values that can be written to the field `PWM_ENUPD_ENUPD6`"]
731#[derive(Clone, Copy, Debug, PartialEq)]
732pub enum PWM_ENUPD_ENUPD6W {
733 #[doc = "Immediate"]
734 PWM_ENUPD_ENUPD6_IMM,
735 #[doc = "Locally Synchronized"]
736 PWM_ENUPD_ENUPD6_LSYNC,
737 #[doc = "Globally Synchronized"]
738 PWM_ENUPD_ENUPD6_GSYNC,
739}
740impl PWM_ENUPD_ENUPD6W {
741 #[allow(missing_docs)]
742 #[doc(hidden)]
743 #[inline(always)]
744 pub fn _bits(&self) -> u8 {
745 match *self {
746 PWM_ENUPD_ENUPD6W::PWM_ENUPD_ENUPD6_IMM => 0,
747 PWM_ENUPD_ENUPD6W::PWM_ENUPD_ENUPD6_LSYNC => 2,
748 PWM_ENUPD_ENUPD6W::PWM_ENUPD_ENUPD6_GSYNC => 3,
749 }
750 }
751}
752#[doc = r"Proxy"]
753pub struct _PWM_ENUPD_ENUPD6W<'a> {
754 w: &'a mut W,
755}
756impl<'a> _PWM_ENUPD_ENUPD6W<'a> {
757 #[doc = r"Writes `variant` to the field"]
758 #[inline(always)]
759 pub fn variant(self, variant: PWM_ENUPD_ENUPD6W) -> &'a mut W {
760 unsafe { self.bits(variant._bits()) }
761 }
762 #[doc = "Immediate"]
763 #[inline(always)]
764 pub fn pwm_enupd_enupd6_imm(self) -> &'a mut W {
765 self.variant(PWM_ENUPD_ENUPD6W::PWM_ENUPD_ENUPD6_IMM)
766 }
767 #[doc = "Locally Synchronized"]
768 #[inline(always)]
769 pub fn pwm_enupd_enupd6_lsync(self) -> &'a mut W {
770 self.variant(PWM_ENUPD_ENUPD6W::PWM_ENUPD_ENUPD6_LSYNC)
771 }
772 #[doc = "Globally Synchronized"]
773 #[inline(always)]
774 pub fn pwm_enupd_enupd6_gsync(self) -> &'a mut W {
775 self.variant(PWM_ENUPD_ENUPD6W::PWM_ENUPD_ENUPD6_GSYNC)
776 }
777 #[doc = r"Writes raw bits to the field"]
778 #[inline(always)]
779 pub unsafe fn bits(self, value: u8) -> &'a mut W {
780 self.w.bits &= !(3 << 12);
781 self.w.bits |= ((value as u32) & 3) << 12;
782 self.w
783 }
784}
785#[doc = "Possible values of the field `PWM_ENUPD_ENUPD7`"]
786#[derive(Clone, Copy, Debug, PartialEq)]
787pub enum PWM_ENUPD_ENUPD7R {
788 #[doc = "Immediate"]
789 PWM_ENUPD_ENUPD7_IMM,
790 #[doc = "Locally Synchronized"]
791 PWM_ENUPD_ENUPD7_LSYNC,
792 #[doc = "Globally Synchronized"]
793 PWM_ENUPD_ENUPD7_GSYNC,
794 #[doc = r"Reserved"]
795 _Reserved(u8),
796}
797impl PWM_ENUPD_ENUPD7R {
798 #[doc = r"Value of the field as raw bits"]
799 #[inline(always)]
800 pub fn bits(&self) -> u8 {
801 match *self {
802 PWM_ENUPD_ENUPD7R::PWM_ENUPD_ENUPD7_IMM => 0,
803 PWM_ENUPD_ENUPD7R::PWM_ENUPD_ENUPD7_LSYNC => 2,
804 PWM_ENUPD_ENUPD7R::PWM_ENUPD_ENUPD7_GSYNC => 3,
805 PWM_ENUPD_ENUPD7R::_Reserved(bits) => bits,
806 }
807 }
808 #[allow(missing_docs)]
809 #[doc(hidden)]
810 #[inline(always)]
811 pub fn _from(value: u8) -> PWM_ENUPD_ENUPD7R {
812 match value {
813 0 => PWM_ENUPD_ENUPD7R::PWM_ENUPD_ENUPD7_IMM,
814 2 => PWM_ENUPD_ENUPD7R::PWM_ENUPD_ENUPD7_LSYNC,
815 3 => PWM_ENUPD_ENUPD7R::PWM_ENUPD_ENUPD7_GSYNC,
816 i => PWM_ENUPD_ENUPD7R::_Reserved(i),
817 }
818 }
819 #[doc = "Checks if the value of the field is `PWM_ENUPD_ENUPD7_IMM`"]
820 #[inline(always)]
821 pub fn is_pwm_enupd_enupd7_imm(&self) -> bool {
822 *self == PWM_ENUPD_ENUPD7R::PWM_ENUPD_ENUPD7_IMM
823 }
824 #[doc = "Checks if the value of the field is `PWM_ENUPD_ENUPD7_LSYNC`"]
825 #[inline(always)]
826 pub fn is_pwm_enupd_enupd7_lsync(&self) -> bool {
827 *self == PWM_ENUPD_ENUPD7R::PWM_ENUPD_ENUPD7_LSYNC
828 }
829 #[doc = "Checks if the value of the field is `PWM_ENUPD_ENUPD7_GSYNC`"]
830 #[inline(always)]
831 pub fn is_pwm_enupd_enupd7_gsync(&self) -> bool {
832 *self == PWM_ENUPD_ENUPD7R::PWM_ENUPD_ENUPD7_GSYNC
833 }
834}
835#[doc = "Values that can be written to the field `PWM_ENUPD_ENUPD7`"]
836#[derive(Clone, Copy, Debug, PartialEq)]
837pub enum PWM_ENUPD_ENUPD7W {
838 #[doc = "Immediate"]
839 PWM_ENUPD_ENUPD7_IMM,
840 #[doc = "Locally Synchronized"]
841 PWM_ENUPD_ENUPD7_LSYNC,
842 #[doc = "Globally Synchronized"]
843 PWM_ENUPD_ENUPD7_GSYNC,
844}
845impl PWM_ENUPD_ENUPD7W {
846 #[allow(missing_docs)]
847 #[doc(hidden)]
848 #[inline(always)]
849 pub fn _bits(&self) -> u8 {
850 match *self {
851 PWM_ENUPD_ENUPD7W::PWM_ENUPD_ENUPD7_IMM => 0,
852 PWM_ENUPD_ENUPD7W::PWM_ENUPD_ENUPD7_LSYNC => 2,
853 PWM_ENUPD_ENUPD7W::PWM_ENUPD_ENUPD7_GSYNC => 3,
854 }
855 }
856}
857#[doc = r"Proxy"]
858pub struct _PWM_ENUPD_ENUPD7W<'a> {
859 w: &'a mut W,
860}
861impl<'a> _PWM_ENUPD_ENUPD7W<'a> {
862 #[doc = r"Writes `variant` to the field"]
863 #[inline(always)]
864 pub fn variant(self, variant: PWM_ENUPD_ENUPD7W) -> &'a mut W {
865 unsafe { self.bits(variant._bits()) }
866 }
867 #[doc = "Immediate"]
868 #[inline(always)]
869 pub fn pwm_enupd_enupd7_imm(self) -> &'a mut W {
870 self.variant(PWM_ENUPD_ENUPD7W::PWM_ENUPD_ENUPD7_IMM)
871 }
872 #[doc = "Locally Synchronized"]
873 #[inline(always)]
874 pub fn pwm_enupd_enupd7_lsync(self) -> &'a mut W {
875 self.variant(PWM_ENUPD_ENUPD7W::PWM_ENUPD_ENUPD7_LSYNC)
876 }
877 #[doc = "Globally Synchronized"]
878 #[inline(always)]
879 pub fn pwm_enupd_enupd7_gsync(self) -> &'a mut W {
880 self.variant(PWM_ENUPD_ENUPD7W::PWM_ENUPD_ENUPD7_GSYNC)
881 }
882 #[doc = r"Writes raw bits to the field"]
883 #[inline(always)]
884 pub unsafe fn bits(self, value: u8) -> &'a mut W {
885 self.w.bits &= !(3 << 14);
886 self.w.bits |= ((value as u32) & 3) << 14;
887 self.w
888 }
889}
890impl R {
891 #[doc = r"Value of the register as raw bits"]
892 #[inline(always)]
893 pub fn bits(&self) -> u32 {
894 self.bits
895 }
896 #[doc = "Bits 0:1 - MnPWM0 Enable Update Mode"]
897 #[inline(always)]
898 pub fn pwm_enupd_enupd0(&self) -> PWM_ENUPD_ENUPD0R {
899 PWM_ENUPD_ENUPD0R::_from(((self.bits >> 0) & 3) as u8)
900 }
901 #[doc = "Bits 2:3 - MnPWM1 Enable Update Mode"]
902 #[inline(always)]
903 pub fn pwm_enupd_enupd1(&self) -> PWM_ENUPD_ENUPD1R {
904 PWM_ENUPD_ENUPD1R::_from(((self.bits >> 2) & 3) as u8)
905 }
906 #[doc = "Bits 4:5 - MnPWM2 Enable Update Mode"]
907 #[inline(always)]
908 pub fn pwm_enupd_enupd2(&self) -> PWM_ENUPD_ENUPD2R {
909 PWM_ENUPD_ENUPD2R::_from(((self.bits >> 4) & 3) as u8)
910 }
911 #[doc = "Bits 6:7 - MnPWM3 Enable Update Mode"]
912 #[inline(always)]
913 pub fn pwm_enupd_enupd3(&self) -> PWM_ENUPD_ENUPD3R {
914 PWM_ENUPD_ENUPD3R::_from(((self.bits >> 6) & 3) as u8)
915 }
916 #[doc = "Bits 8:9 - MnPWM4 Enable Update Mode"]
917 #[inline(always)]
918 pub fn pwm_enupd_enupd4(&self) -> PWM_ENUPD_ENUPD4R {
919 PWM_ENUPD_ENUPD4R::_from(((self.bits >> 8) & 3) as u8)
920 }
921 #[doc = "Bits 10:11 - MnPWM5 Enable Update Mode"]
922 #[inline(always)]
923 pub fn pwm_enupd_enupd5(&self) -> PWM_ENUPD_ENUPD5R {
924 PWM_ENUPD_ENUPD5R::_from(((self.bits >> 10) & 3) as u8)
925 }
926 #[doc = "Bits 12:13 - MnPWM6 Enable Update Mode"]
927 #[inline(always)]
928 pub fn pwm_enupd_enupd6(&self) -> PWM_ENUPD_ENUPD6R {
929 PWM_ENUPD_ENUPD6R::_from(((self.bits >> 12) & 3) as u8)
930 }
931 #[doc = "Bits 14:15 - MnPWM7 Enable Update Mode"]
932 #[inline(always)]
933 pub fn pwm_enupd_enupd7(&self) -> PWM_ENUPD_ENUPD7R {
934 PWM_ENUPD_ENUPD7R::_from(((self.bits >> 14) & 3) as u8)
935 }
936}
937impl W {
938 #[doc = r"Writes raw bits to the register"]
939 #[inline(always)]
940 pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
941 self.bits = bits;
942 self
943 }
944 #[doc = "Bits 0:1 - MnPWM0 Enable Update Mode"]
945 #[inline(always)]
946 pub fn pwm_enupd_enupd0(&mut self) -> _PWM_ENUPD_ENUPD0W {
947 _PWM_ENUPD_ENUPD0W { w: self }
948 }
949 #[doc = "Bits 2:3 - MnPWM1 Enable Update Mode"]
950 #[inline(always)]
951 pub fn pwm_enupd_enupd1(&mut self) -> _PWM_ENUPD_ENUPD1W {
952 _PWM_ENUPD_ENUPD1W { w: self }
953 }
954 #[doc = "Bits 4:5 - MnPWM2 Enable Update Mode"]
955 #[inline(always)]
956 pub fn pwm_enupd_enupd2(&mut self) -> _PWM_ENUPD_ENUPD2W {
957 _PWM_ENUPD_ENUPD2W { w: self }
958 }
959 #[doc = "Bits 6:7 - MnPWM3 Enable Update Mode"]
960 #[inline(always)]
961 pub fn pwm_enupd_enupd3(&mut self) -> _PWM_ENUPD_ENUPD3W {
962 _PWM_ENUPD_ENUPD3W { w: self }
963 }
964 #[doc = "Bits 8:9 - MnPWM4 Enable Update Mode"]
965 #[inline(always)]
966 pub fn pwm_enupd_enupd4(&mut self) -> _PWM_ENUPD_ENUPD4W {
967 _PWM_ENUPD_ENUPD4W { w: self }
968 }
969 #[doc = "Bits 10:11 - MnPWM5 Enable Update Mode"]
970 #[inline(always)]
971 pub fn pwm_enupd_enupd5(&mut self) -> _PWM_ENUPD_ENUPD5W {
972 _PWM_ENUPD_ENUPD5W { w: self }
973 }
974 #[doc = "Bits 12:13 - MnPWM6 Enable Update Mode"]
975 #[inline(always)]
976 pub fn pwm_enupd_enupd6(&mut self) -> _PWM_ENUPD_ENUPD6W {
977 _PWM_ENUPD_ENUPD6W { w: self }
978 }
979 #[doc = "Bits 14:15 - MnPWM7 Enable Update Mode"]
980 #[inline(always)]
981 pub fn pwm_enupd_enupd7(&mut self) -> _PWM_ENUPD_ENUPD7W {
982 _PWM_ENUPD_ENUPD7W { w: self }
983 }
984}