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
#[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CFG { #[doc = r" Writes to the register"] #[inline] pub fn write<F>(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } } #[doc = r" Proxy"] pub struct _RESERVED8W<'a> { w: &'a mut W, } impl<'a> _RESERVED8W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u32) -> &'a mut W { const MASK: u32 = 16777215; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PRTOCTRLW<'a> { w: &'a mut W, } impl<'a> _PRTOCTRLW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 7; const OFFSET: u8 = 5; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _RESERVED1W<'a> { w: &'a mut W, } impl<'a> _RESERVED1W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 15; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MASTERENABLEW<'a> { w: &'a mut W, } impl<'a> _MASTERENABLEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 8:31 - Software should not rely on the value of a reserved. Writing any other value than the reset value may result in undefined behavior."] #[inline] pub fn reserved8(&mut self) -> _RESERVED8W { _RESERVED8W { w: self } } #[doc = "Bits 5:7 - Sets the AHB-Lite bus protocol protection state by controlling the AHB signal HProt\\[3:1\\] as follows: Bit \\[7\\] Controls HProt\\[3\\] to indicate if a cacheable access is occurring. Bit \\[6\\] Controls HProt\\[2\\] to indicate if a bufferable access is occurring. Bit \\[5\\] Controls HProt\\[1\\] to indicate if a privileged access is occurring. When bit \\[n\\] = 1 then the corresponding HProt bit is high. When bit \\[n\\] = 0 then the corresponding HProt bit is low. This field controls HProt\\[3:1\\] signal for all transactions initiated by uDMA except two transactions below: - the read from the address indicated by source address pointer - the write to the address indicated by destination address pointer HProt\\[3:1\\] for these two exceptions can be controlled by dedicated fields in the channel configutation descriptor."] #[inline] pub fn prtoctrl(&mut self) -> _PRTOCTRLW { _PRTOCTRLW { w: self } } #[doc = "Bits 1:4 - Software should not rely on the value of a reserved. Writing any other value than the reset value may result in undefined behavior."] #[inline] pub fn reserved1(&mut self) -> _RESERVED1W { _RESERVED1W { w: self } } #[doc = "Bit 0 - Enables the controller: 0: Disables the controller 1: Enables the controller"] #[inline] pub fn masterenable(&mut self) -> _MASTERENABLEW { _MASTERENABLEW { w: self } } }