stm32l4x2_pac/flash/
optr.rs

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::OPTR {
10    #[doc = r" Modifies the contents of the register"]
11    #[inline]
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        let r = R { bits: bits };
18        let mut w = W { bits: bits };
19        f(&r, &mut w);
20        self.register.set(w.bits);
21    }
22    #[doc = r" Reads the contents of the register"]
23    #[inline]
24    pub fn read(&self) -> R {
25        R {
26            bits: self.register.get(),
27        }
28    }
29    #[doc = r" Writes to the register"]
30    #[inline]
31    pub fn write<F>(&self, f: F)
32    where
33        F: FnOnce(&mut W) -> &mut W,
34    {
35        let mut w = W::reset_value();
36        f(&mut w);
37        self.register.set(w.bits);
38    }
39    #[doc = r" Writes the reset value to the register"]
40    #[inline]
41    pub fn reset(&self) {
42        self.write(|w| w)
43    }
44}
45#[doc = r" Value of the field"]
46pub struct RDPR {
47    bits: u8,
48}
49impl RDPR {
50    #[doc = r" Value of the field as raw bits"]
51    #[inline]
52    pub fn bits(&self) -> u8 {
53        self.bits
54    }
55}
56#[doc = r" Value of the field"]
57pub struct BOR_LEVR {
58    bits: u8,
59}
60impl BOR_LEVR {
61    #[doc = r" Value of the field as raw bits"]
62    #[inline]
63    pub fn bits(&self) -> u8 {
64        self.bits
65    }
66}
67#[doc = r" Value of the field"]
68pub struct NRST_STOPR {
69    bits: bool,
70}
71impl NRST_STOPR {
72    #[doc = r" Value of the field as raw bits"]
73    #[inline]
74    pub fn bit(&self) -> bool {
75        self.bits
76    }
77    #[doc = r" Returns `true` if the bit is clear (0)"]
78    #[inline]
79    pub fn bit_is_clear(&self) -> bool {
80        !self.bit()
81    }
82    #[doc = r" Returns `true` if the bit is set (1)"]
83    #[inline]
84    pub fn bit_is_set(&self) -> bool {
85        self.bit()
86    }
87}
88#[doc = r" Value of the field"]
89pub struct NRST_STDBYR {
90    bits: bool,
91}
92impl NRST_STDBYR {
93    #[doc = r" Value of the field as raw bits"]
94    #[inline]
95    pub fn bit(&self) -> bool {
96        self.bits
97    }
98    #[doc = r" Returns `true` if the bit is clear (0)"]
99    #[inline]
100    pub fn bit_is_clear(&self) -> bool {
101        !self.bit()
102    }
103    #[doc = r" Returns `true` if the bit is set (1)"]
104    #[inline]
105    pub fn bit_is_set(&self) -> bool {
106        self.bit()
107    }
108}
109#[doc = r" Value of the field"]
110pub struct IDWG_SWR {
111    bits: bool,
112}
113impl IDWG_SWR {
114    #[doc = r" Value of the field as raw bits"]
115    #[inline]
116    pub fn bit(&self) -> bool {
117        self.bits
118    }
119    #[doc = r" Returns `true` if the bit is clear (0)"]
120    #[inline]
121    pub fn bit_is_clear(&self) -> bool {
122        !self.bit()
123    }
124    #[doc = r" Returns `true` if the bit is set (1)"]
125    #[inline]
126    pub fn bit_is_set(&self) -> bool {
127        self.bit()
128    }
129}
130#[doc = r" Value of the field"]
131pub struct IWDG_STOPR {
132    bits: bool,
133}
134impl IWDG_STOPR {
135    #[doc = r" Value of the field as raw bits"]
136    #[inline]
137    pub fn bit(&self) -> bool {
138        self.bits
139    }
140    #[doc = r" Returns `true` if the bit is clear (0)"]
141    #[inline]
142    pub fn bit_is_clear(&self) -> bool {
143        !self.bit()
144    }
145    #[doc = r" Returns `true` if the bit is set (1)"]
146    #[inline]
147    pub fn bit_is_set(&self) -> bool {
148        self.bit()
149    }
150}
151#[doc = r" Value of the field"]
152pub struct IWDG_STDBYR {
153    bits: bool,
154}
155impl IWDG_STDBYR {
156    #[doc = r" Value of the field as raw bits"]
157    #[inline]
158    pub fn bit(&self) -> bool {
159        self.bits
160    }
161    #[doc = r" Returns `true` if the bit is clear (0)"]
162    #[inline]
163    pub fn bit_is_clear(&self) -> bool {
164        !self.bit()
165    }
166    #[doc = r" Returns `true` if the bit is set (1)"]
167    #[inline]
168    pub fn bit_is_set(&self) -> bool {
169        self.bit()
170    }
171}
172#[doc = r" Value of the field"]
173pub struct WWDG_SWR {
174    bits: bool,
175}
176impl WWDG_SWR {
177    #[doc = r" Value of the field as raw bits"]
178    #[inline]
179    pub fn bit(&self) -> bool {
180        self.bits
181    }
182    #[doc = r" Returns `true` if the bit is clear (0)"]
183    #[inline]
184    pub fn bit_is_clear(&self) -> bool {
185        !self.bit()
186    }
187    #[doc = r" Returns `true` if the bit is set (1)"]
188    #[inline]
189    pub fn bit_is_set(&self) -> bool {
190        self.bit()
191    }
192}
193#[doc = r" Value of the field"]
194pub struct BFB2R {
195    bits: bool,
196}
197impl BFB2R {
198    #[doc = r" Value of the field as raw bits"]
199    #[inline]
200    pub fn bit(&self) -> bool {
201        self.bits
202    }
203    #[doc = r" Returns `true` if the bit is clear (0)"]
204    #[inline]
205    pub fn bit_is_clear(&self) -> bool {
206        !self.bit()
207    }
208    #[doc = r" Returns `true` if the bit is set (1)"]
209    #[inline]
210    pub fn bit_is_set(&self) -> bool {
211        self.bit()
212    }
213}
214#[doc = r" Value of the field"]
215pub struct DUALBANKR {
216    bits: bool,
217}
218impl DUALBANKR {
219    #[doc = r" Value of the field as raw bits"]
220    #[inline]
221    pub fn bit(&self) -> bool {
222        self.bits
223    }
224    #[doc = r" Returns `true` if the bit is clear (0)"]
225    #[inline]
226    pub fn bit_is_clear(&self) -> bool {
227        !self.bit()
228    }
229    #[doc = r" Returns `true` if the bit is set (1)"]
230    #[inline]
231    pub fn bit_is_set(&self) -> bool {
232        self.bit()
233    }
234}
235#[doc = r" Value of the field"]
236pub struct NBOOT1R {
237    bits: bool,
238}
239impl NBOOT1R {
240    #[doc = r" Value of the field as raw bits"]
241    #[inline]
242    pub fn bit(&self) -> bool {
243        self.bits
244    }
245    #[doc = r" Returns `true` if the bit is clear (0)"]
246    #[inline]
247    pub fn bit_is_clear(&self) -> bool {
248        !self.bit()
249    }
250    #[doc = r" Returns `true` if the bit is set (1)"]
251    #[inline]
252    pub fn bit_is_set(&self) -> bool {
253        self.bit()
254    }
255}
256#[doc = r" Value of the field"]
257pub struct SRAM2_PER {
258    bits: bool,
259}
260impl SRAM2_PER {
261    #[doc = r" Value of the field as raw bits"]
262    #[inline]
263    pub fn bit(&self) -> bool {
264        self.bits
265    }
266    #[doc = r" Returns `true` if the bit is clear (0)"]
267    #[inline]
268    pub fn bit_is_clear(&self) -> bool {
269        !self.bit()
270    }
271    #[doc = r" Returns `true` if the bit is set (1)"]
272    #[inline]
273    pub fn bit_is_set(&self) -> bool {
274        self.bit()
275    }
276}
277#[doc = r" Value of the field"]
278pub struct SRAM2_RSTR {
279    bits: bool,
280}
281impl SRAM2_RSTR {
282    #[doc = r" Value of the field as raw bits"]
283    #[inline]
284    pub fn bit(&self) -> bool {
285        self.bits
286    }
287    #[doc = r" Returns `true` if the bit is clear (0)"]
288    #[inline]
289    pub fn bit_is_clear(&self) -> bool {
290        !self.bit()
291    }
292    #[doc = r" Returns `true` if the bit is set (1)"]
293    #[inline]
294    pub fn bit_is_set(&self) -> bool {
295        self.bit()
296    }
297}
298#[doc = r" Proxy"]
299pub struct _RDPW<'a> {
300    w: &'a mut W,
301}
302impl<'a> _RDPW<'a> {
303    #[doc = r" Writes raw bits to the field"]
304    #[inline]
305    pub unsafe fn bits(self, value: u8) -> &'a mut W {
306        const MASK: u8 = 255;
307        const OFFSET: u8 = 0;
308        self.w.bits &= !((MASK as u32) << OFFSET);
309        self.w.bits |= ((value & MASK) as u32) << OFFSET;
310        self.w
311    }
312}
313#[doc = r" Proxy"]
314pub struct _BOR_LEVW<'a> {
315    w: &'a mut W,
316}
317impl<'a> _BOR_LEVW<'a> {
318    #[doc = r" Writes raw bits to the field"]
319    #[inline]
320    pub unsafe fn bits(self, value: u8) -> &'a mut W {
321        const MASK: u8 = 7;
322        const OFFSET: u8 = 8;
323        self.w.bits &= !((MASK as u32) << OFFSET);
324        self.w.bits |= ((value & MASK) as u32) << OFFSET;
325        self.w
326    }
327}
328#[doc = r" Proxy"]
329pub struct _NRST_STOPW<'a> {
330    w: &'a mut W,
331}
332impl<'a> _NRST_STOPW<'a> {
333    #[doc = r" Sets the field bit"]
334    pub fn set_bit(self) -> &'a mut W {
335        self.bit(true)
336    }
337    #[doc = r" Clears the field bit"]
338    pub fn clear_bit(self) -> &'a mut W {
339        self.bit(false)
340    }
341    #[doc = r" Writes raw bits to the field"]
342    #[inline]
343    pub fn bit(self, value: bool) -> &'a mut W {
344        const MASK: bool = true;
345        const OFFSET: u8 = 12;
346        self.w.bits &= !((MASK as u32) << OFFSET);
347        self.w.bits |= ((value & MASK) as u32) << OFFSET;
348        self.w
349    }
350}
351#[doc = r" Proxy"]
352pub struct _NRST_STDBYW<'a> {
353    w: &'a mut W,
354}
355impl<'a> _NRST_STDBYW<'a> {
356    #[doc = r" Sets the field bit"]
357    pub fn set_bit(self) -> &'a mut W {
358        self.bit(true)
359    }
360    #[doc = r" Clears the field bit"]
361    pub fn clear_bit(self) -> &'a mut W {
362        self.bit(false)
363    }
364    #[doc = r" Writes raw bits to the field"]
365    #[inline]
366    pub fn bit(self, value: bool) -> &'a mut W {
367        const MASK: bool = true;
368        const OFFSET: u8 = 13;
369        self.w.bits &= !((MASK as u32) << OFFSET);
370        self.w.bits |= ((value & MASK) as u32) << OFFSET;
371        self.w
372    }
373}
374#[doc = r" Proxy"]
375pub struct _IDWG_SWW<'a> {
376    w: &'a mut W,
377}
378impl<'a> _IDWG_SWW<'a> {
379    #[doc = r" Sets the field bit"]
380    pub fn set_bit(self) -> &'a mut W {
381        self.bit(true)
382    }
383    #[doc = r" Clears the field bit"]
384    pub fn clear_bit(self) -> &'a mut W {
385        self.bit(false)
386    }
387    #[doc = r" Writes raw bits to the field"]
388    #[inline]
389    pub fn bit(self, value: bool) -> &'a mut W {
390        const MASK: bool = true;
391        const OFFSET: u8 = 16;
392        self.w.bits &= !((MASK as u32) << OFFSET);
393        self.w.bits |= ((value & MASK) as u32) << OFFSET;
394        self.w
395    }
396}
397#[doc = r" Proxy"]
398pub struct _IWDG_STOPW<'a> {
399    w: &'a mut W,
400}
401impl<'a> _IWDG_STOPW<'a> {
402    #[doc = r" Sets the field bit"]
403    pub fn set_bit(self) -> &'a mut W {
404        self.bit(true)
405    }
406    #[doc = r" Clears the field bit"]
407    pub fn clear_bit(self) -> &'a mut W {
408        self.bit(false)
409    }
410    #[doc = r" Writes raw bits to the field"]
411    #[inline]
412    pub fn bit(self, value: bool) -> &'a mut W {
413        const MASK: bool = true;
414        const OFFSET: u8 = 17;
415        self.w.bits &= !((MASK as u32) << OFFSET);
416        self.w.bits |= ((value & MASK) as u32) << OFFSET;
417        self.w
418    }
419}
420#[doc = r" Proxy"]
421pub struct _IWDG_STDBYW<'a> {
422    w: &'a mut W,
423}
424impl<'a> _IWDG_STDBYW<'a> {
425    #[doc = r" Sets the field bit"]
426    pub fn set_bit(self) -> &'a mut W {
427        self.bit(true)
428    }
429    #[doc = r" Clears the field bit"]
430    pub fn clear_bit(self) -> &'a mut W {
431        self.bit(false)
432    }
433    #[doc = r" Writes raw bits to the field"]
434    #[inline]
435    pub fn bit(self, value: bool) -> &'a mut W {
436        const MASK: bool = true;
437        const OFFSET: u8 = 18;
438        self.w.bits &= !((MASK as u32) << OFFSET);
439        self.w.bits |= ((value & MASK) as u32) << OFFSET;
440        self.w
441    }
442}
443#[doc = r" Proxy"]
444pub struct _WWDG_SWW<'a> {
445    w: &'a mut W,
446}
447impl<'a> _WWDG_SWW<'a> {
448    #[doc = r" Sets the field bit"]
449    pub fn set_bit(self) -> &'a mut W {
450        self.bit(true)
451    }
452    #[doc = r" Clears the field bit"]
453    pub fn clear_bit(self) -> &'a mut W {
454        self.bit(false)
455    }
456    #[doc = r" Writes raw bits to the field"]
457    #[inline]
458    pub fn bit(self, value: bool) -> &'a mut W {
459        const MASK: bool = true;
460        const OFFSET: u8 = 19;
461        self.w.bits &= !((MASK as u32) << OFFSET);
462        self.w.bits |= ((value & MASK) as u32) << OFFSET;
463        self.w
464    }
465}
466#[doc = r" Proxy"]
467pub struct _BFB2W<'a> {
468    w: &'a mut W,
469}
470impl<'a> _BFB2W<'a> {
471    #[doc = r" Sets the field bit"]
472    pub fn set_bit(self) -> &'a mut W {
473        self.bit(true)
474    }
475    #[doc = r" Clears the field bit"]
476    pub fn clear_bit(self) -> &'a mut W {
477        self.bit(false)
478    }
479    #[doc = r" Writes raw bits to the field"]
480    #[inline]
481    pub fn bit(self, value: bool) -> &'a mut W {
482        const MASK: bool = true;
483        const OFFSET: u8 = 20;
484        self.w.bits &= !((MASK as u32) << OFFSET);
485        self.w.bits |= ((value & MASK) as u32) << OFFSET;
486        self.w
487    }
488}
489#[doc = r" Proxy"]
490pub struct _DUALBANKW<'a> {
491    w: &'a mut W,
492}
493impl<'a> _DUALBANKW<'a> {
494    #[doc = r" Sets the field bit"]
495    pub fn set_bit(self) -> &'a mut W {
496        self.bit(true)
497    }
498    #[doc = r" Clears the field bit"]
499    pub fn clear_bit(self) -> &'a mut W {
500        self.bit(false)
501    }
502    #[doc = r" Writes raw bits to the field"]
503    #[inline]
504    pub fn bit(self, value: bool) -> &'a mut W {
505        const MASK: bool = true;
506        const OFFSET: u8 = 21;
507        self.w.bits &= !((MASK as u32) << OFFSET);
508        self.w.bits |= ((value & MASK) as u32) << OFFSET;
509        self.w
510    }
511}
512#[doc = r" Proxy"]
513pub struct _NBOOT1W<'a> {
514    w: &'a mut W,
515}
516impl<'a> _NBOOT1W<'a> {
517    #[doc = r" Sets the field bit"]
518    pub fn set_bit(self) -> &'a mut W {
519        self.bit(true)
520    }
521    #[doc = r" Clears the field bit"]
522    pub fn clear_bit(self) -> &'a mut W {
523        self.bit(false)
524    }
525    #[doc = r" Writes raw bits to the field"]
526    #[inline]
527    pub fn bit(self, value: bool) -> &'a mut W {
528        const MASK: bool = true;
529        const OFFSET: u8 = 23;
530        self.w.bits &= !((MASK as u32) << OFFSET);
531        self.w.bits |= ((value & MASK) as u32) << OFFSET;
532        self.w
533    }
534}
535#[doc = r" Proxy"]
536pub struct _SRAM2_PEW<'a> {
537    w: &'a mut W,
538}
539impl<'a> _SRAM2_PEW<'a> {
540    #[doc = r" Sets the field bit"]
541    pub fn set_bit(self) -> &'a mut W {
542        self.bit(true)
543    }
544    #[doc = r" Clears the field bit"]
545    pub fn clear_bit(self) -> &'a mut W {
546        self.bit(false)
547    }
548    #[doc = r" Writes raw bits to the field"]
549    #[inline]
550    pub fn bit(self, value: bool) -> &'a mut W {
551        const MASK: bool = true;
552        const OFFSET: u8 = 24;
553        self.w.bits &= !((MASK as u32) << OFFSET);
554        self.w.bits |= ((value & MASK) as u32) << OFFSET;
555        self.w
556    }
557}
558#[doc = r" Proxy"]
559pub struct _SRAM2_RSTW<'a> {
560    w: &'a mut W,
561}
562impl<'a> _SRAM2_RSTW<'a> {
563    #[doc = r" Sets the field bit"]
564    pub fn set_bit(self) -> &'a mut W {
565        self.bit(true)
566    }
567    #[doc = r" Clears the field bit"]
568    pub fn clear_bit(self) -> &'a mut W {
569        self.bit(false)
570    }
571    #[doc = r" Writes raw bits to the field"]
572    #[inline]
573    pub fn bit(self, value: bool) -> &'a mut W {
574        const MASK: bool = true;
575        const OFFSET: u8 = 25;
576        self.w.bits &= !((MASK as u32) << OFFSET);
577        self.w.bits |= ((value & MASK) as u32) << OFFSET;
578        self.w
579    }
580}
581impl R {
582    #[doc = r" Value of the register as raw bits"]
583    #[inline]
584    pub fn bits(&self) -> u32 {
585        self.bits
586    }
587    #[doc = "Bits 0:7 - Read protection level"]
588    #[inline]
589    pub fn rdp(&self) -> RDPR {
590        let bits = {
591            const MASK: u8 = 255;
592            const OFFSET: u8 = 0;
593            ((self.bits >> OFFSET) & MASK as u32) as u8
594        };
595        RDPR { bits }
596    }
597    #[doc = "Bits 8:10 - BOR reset Level"]
598    #[inline]
599    pub fn bor_lev(&self) -> BOR_LEVR {
600        let bits = {
601            const MASK: u8 = 7;
602            const OFFSET: u8 = 8;
603            ((self.bits >> OFFSET) & MASK as u32) as u8
604        };
605        BOR_LEVR { bits }
606    }
607    #[doc = "Bit 12 - nRST_STOP"]
608    #[inline]
609    pub fn n_rst_stop(&self) -> NRST_STOPR {
610        let bits = {
611            const MASK: bool = true;
612            const OFFSET: u8 = 12;
613            ((self.bits >> OFFSET) & MASK as u32) != 0
614        };
615        NRST_STOPR { bits }
616    }
617    #[doc = "Bit 13 - nRST_STDBY"]
618    #[inline]
619    pub fn n_rst_stdby(&self) -> NRST_STDBYR {
620        let bits = {
621            const MASK: bool = true;
622            const OFFSET: u8 = 13;
623            ((self.bits >> OFFSET) & MASK as u32) != 0
624        };
625        NRST_STDBYR { bits }
626    }
627    #[doc = "Bit 16 - Independent watchdog selection"]
628    #[inline]
629    pub fn idwg_sw(&self) -> IDWG_SWR {
630        let bits = {
631            const MASK: bool = true;
632            const OFFSET: u8 = 16;
633            ((self.bits >> OFFSET) & MASK as u32) != 0
634        };
635        IDWG_SWR { bits }
636    }
637    #[doc = "Bit 17 - Independent watchdog counter freeze in Stop mode"]
638    #[inline]
639    pub fn iwdg_stop(&self) -> IWDG_STOPR {
640        let bits = {
641            const MASK: bool = true;
642            const OFFSET: u8 = 17;
643            ((self.bits >> OFFSET) & MASK as u32) != 0
644        };
645        IWDG_STOPR { bits }
646    }
647    #[doc = "Bit 18 - Independent watchdog counter freeze in Standby mode"]
648    #[inline]
649    pub fn iwdg_stdby(&self) -> IWDG_STDBYR {
650        let bits = {
651            const MASK: bool = true;
652            const OFFSET: u8 = 18;
653            ((self.bits >> OFFSET) & MASK as u32) != 0
654        };
655        IWDG_STDBYR { bits }
656    }
657    #[doc = "Bit 19 - Window watchdog selection"]
658    #[inline]
659    pub fn wwdg_sw(&self) -> WWDG_SWR {
660        let bits = {
661            const MASK: bool = true;
662            const OFFSET: u8 = 19;
663            ((self.bits >> OFFSET) & MASK as u32) != 0
664        };
665        WWDG_SWR { bits }
666    }
667    #[doc = "Bit 20 - Dual-bank boot"]
668    #[inline]
669    pub fn bfb2(&self) -> BFB2R {
670        let bits = {
671            const MASK: bool = true;
672            const OFFSET: u8 = 20;
673            ((self.bits >> OFFSET) & MASK as u32) != 0
674        };
675        BFB2R { bits }
676    }
677    #[doc = "Bit 21 - Dual-Bank on 512 KB or 256 KB Flash memory devices"]
678    #[inline]
679    pub fn dualbank(&self) -> DUALBANKR {
680        let bits = {
681            const MASK: bool = true;
682            const OFFSET: u8 = 21;
683            ((self.bits >> OFFSET) & MASK as u32) != 0
684        };
685        DUALBANKR { bits }
686    }
687    #[doc = "Bit 23 - Boot configuration"]
688    #[inline]
689    pub fn n_boot1(&self) -> NBOOT1R {
690        let bits = {
691            const MASK: bool = true;
692            const OFFSET: u8 = 23;
693            ((self.bits >> OFFSET) & MASK as u32) != 0
694        };
695        NBOOT1R { bits }
696    }
697    #[doc = "Bit 24 - SRAM2 parity check enable"]
698    #[inline]
699    pub fn sram2_pe(&self) -> SRAM2_PER {
700        let bits = {
701            const MASK: bool = true;
702            const OFFSET: u8 = 24;
703            ((self.bits >> OFFSET) & MASK as u32) != 0
704        };
705        SRAM2_PER { bits }
706    }
707    #[doc = "Bit 25 - SRAM2 Erase when system reset"]
708    #[inline]
709    pub fn sram2_rst(&self) -> SRAM2_RSTR {
710        let bits = {
711            const MASK: bool = true;
712            const OFFSET: u8 = 25;
713            ((self.bits >> OFFSET) & MASK as u32) != 0
714        };
715        SRAM2_RSTR { bits }
716    }
717}
718impl W {
719    #[doc = r" Reset value of the register"]
720    #[inline]
721    pub fn reset_value() -> W {
722        W { bits: 4026531840 }
723    }
724    #[doc = r" Writes raw bits to the register"]
725    #[inline]
726    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
727        self.bits = bits;
728        self
729    }
730    #[doc = "Bits 0:7 - Read protection level"]
731    #[inline]
732    pub fn rdp(&mut self) -> _RDPW {
733        _RDPW { w: self }
734    }
735    #[doc = "Bits 8:10 - BOR reset Level"]
736    #[inline]
737    pub fn bor_lev(&mut self) -> _BOR_LEVW {
738        _BOR_LEVW { w: self }
739    }
740    #[doc = "Bit 12 - nRST_STOP"]
741    #[inline]
742    pub fn n_rst_stop(&mut self) -> _NRST_STOPW {
743        _NRST_STOPW { w: self }
744    }
745    #[doc = "Bit 13 - nRST_STDBY"]
746    #[inline]
747    pub fn n_rst_stdby(&mut self) -> _NRST_STDBYW {
748        _NRST_STDBYW { w: self }
749    }
750    #[doc = "Bit 16 - Independent watchdog selection"]
751    #[inline]
752    pub fn idwg_sw(&mut self) -> _IDWG_SWW {
753        _IDWG_SWW { w: self }
754    }
755    #[doc = "Bit 17 - Independent watchdog counter freeze in Stop mode"]
756    #[inline]
757    pub fn iwdg_stop(&mut self) -> _IWDG_STOPW {
758        _IWDG_STOPW { w: self }
759    }
760    #[doc = "Bit 18 - Independent watchdog counter freeze in Standby mode"]
761    #[inline]
762    pub fn iwdg_stdby(&mut self) -> _IWDG_STDBYW {
763        _IWDG_STDBYW { w: self }
764    }
765    #[doc = "Bit 19 - Window watchdog selection"]
766    #[inline]
767    pub fn wwdg_sw(&mut self) -> _WWDG_SWW {
768        _WWDG_SWW { w: self }
769    }
770    #[doc = "Bit 20 - Dual-bank boot"]
771    #[inline]
772    pub fn bfb2(&mut self) -> _BFB2W {
773        _BFB2W { w: self }
774    }
775    #[doc = "Bit 21 - Dual-Bank on 512 KB or 256 KB Flash memory devices"]
776    #[inline]
777    pub fn dualbank(&mut self) -> _DUALBANKW {
778        _DUALBANKW { w: self }
779    }
780    #[doc = "Bit 23 - Boot configuration"]
781    #[inline]
782    pub fn n_boot1(&mut self) -> _NBOOT1W {
783        _NBOOT1W { w: self }
784    }
785    #[doc = "Bit 24 - SRAM2 parity check enable"]
786    #[inline]
787    pub fn sram2_pe(&mut self) -> _SRAM2_PEW {
788        _SRAM2_PEW { w: self }
789    }
790    #[doc = "Bit 25 - SRAM2 Erase when system reset"]
791    #[inline]
792    pub fn sram2_rst(&mut self) -> _SRAM2_RSTW {
793        _SRAM2_RSTW { w: self }
794    }
795}
stm32l4x2_pac/flash/optr.rs

stm32l4x2_pac/flash/
optr.rs
