use core :: ops :: Deref ; use core :: marker :: PhantomData ; # [doc = r"Number available in the NVIC for configuring priority"] pub const NVIC_PRIO_BITS : u8 = 3 ; pub use cortex_m :: peripheral :: Peripherals as CorePeripherals ; # [cfg (feature = "rt")] pub use cortex_m_rt :: interrupt ; # [cfg (feature = "rt")] pub use self :: Interrupt as interrupt ; pub use cortex_m :: peripheral :: { CBP , CPUID , DCB , DWT , FPB , FPU , ITM , MPU , NVIC , SCB , SYST , TPIU , } ; # [allow (unused_imports)] use generic :: * ; # [doc = r"Common register and bit access and modify traits"] pub mod generic ; # [cfg (feature = "rt")] extern "C" { fn SUPC () ; fn RSTC () ; fn RTC () ; fn RTT () ; fn WDT () ; fn PMC () ; fn EFC () ; fn UART0 () ; fn UART1 () ; fn PIOA () ; fn PIOB () ; fn USART0 () ; fn USART1 () ; fn USART2 () ; fn PIOD () ; fn HSMCI () ; fn TWIHS0 () ; fn TWIHS1 () ; fn SPI0 () ; fn SSC () ; fn TC0 () ; fn TC1 () ; fn TC2 () ; fn TC3 () ; fn TC4 () ; fn TC5 () ; fn AFEC0 () ; fn DACC () ; fn PWM0 () ; fn ICM () ; fn ACC () ; fn USBHS () ; fn MCAN0_INT0 () ; fn MCAN0_INT1 () ; fn MCAN1_INT0 () ; fn MCAN1_INT1 () ; fn GMAC () ; fn AFEC1 () ; fn TWIHS2 () ; fn QSPI () ; fn UART2 () ; fn UART3 () ; fn UART4 () ; fn TC6 () ; fn TC7 () ; fn TC8 () ; fn TC9 () ; fn TC10 () ; fn TC11 () ; fn AES () ; fn TRNG () ; fn XDMAC () ; fn ISI () ; fn PWM1 () ; fn FPU () ; fn RSWDT () ; fn CCW () ; fn CCF () ; fn GMAC_Q1 () ; fn GMAC_Q2 () ; fn IXC () ; fn I2SC0 () ; fn GMAC_Q3 () ; fn GMAC_Q4 () ; fn GMAC_Q5 () ; } # [doc (hidden)] pub union Vector { _handler : unsafe extern "C" fn () , _reserved : u32 , } # [cfg (feature = "rt")] # [doc (hidden)] # [link_section = ".vector_table.interrupts"] # [no_mangle] pub static __INTERRUPTS : [Vector ; 74] = [Vector { _handler : SUPC } , Vector { _handler : RSTC } , Vector { _handler : RTC } , Vector { _handler : RTT } , Vector { _handler : WDT } , Vector { _handler : PMC } , Vector { _handler : EFC } , Vector { _handler : UART0 } , Vector { _handler : UART1 } , Vector { _reserved : 0 } , Vector { _handler : PIOA } , Vector { _handler : PIOB } , Vector { _reserved : 0 } , Vector { _handler : USART0 } , Vector { _handler : USART1 } , Vector { _handler : USART2 } , Vector { _handler : PIOD } , Vector { _reserved : 0 } , Vector { _handler : HSMCI } , Vector { _handler : TWIHS0 } , Vector { _handler : TWIHS1 } , Vector { _handler : SPI0 } , Vector { _handler : SSC } , Vector { _handler : TC0 } , Vector { _handler : TC1 } , Vector { _handler : TC2 } , Vector { _handler : TC3 } , Vector { _handler : TC4 } , Vector { _handler : TC5 } , Vector { _handler : AFEC0 } , Vector { _handler : DACC } , Vector { _handler : PWM0 } , Vector { _handler : ICM } , Vector { _handler : ACC } , Vector { _handler : USBHS } , Vector { _handler : MCAN0_INT0 } , Vector { _handler : MCAN0_INT1 } , Vector { _handler : MCAN1_INT0 } , Vector { _handler : MCAN1_INT1 } , Vector { _handler : GMAC } , Vector { _handler : AFEC1 } , Vector { _handler : TWIHS2 } , Vector { _reserved : 0 } , Vector { _handler : QSPI } , Vector { _handler : UART2 } , Vector { _handler : UART3 } , Vector { _handler : UART4 } , Vector { _handler : TC6 } , Vector { _handler : TC7 } , Vector { _handler : TC8 } , Vector { _handler : TC9 } , Vector { _handler : TC10 } , Vector { _handler : TC11 } , Vector { _reserved : 0 } , Vector { _reserved : 0 } , Vector { _reserved : 0 } , Vector { _handler : AES } , Vector { _handler : TRNG } , Vector { _handler : XDMAC } , Vector { _handler : ISI } , Vector { _handler : PWM1 } , Vector { _handler : FPU } , Vector { _reserved : 0 } , Vector { _handler : RSWDT } , Vector { _handler : CCW } , Vector { _handler : CCF } , Vector { _handler : GMAC_Q1 } , Vector { _handler : GMAC_Q2 } , Vector { _handler : IXC } , Vector { _handler : I2SC0 } , Vector { _reserved : 0 } , Vector { _handler : GMAC_Q3 } , Vector { _handler : GMAC_Q4 } , Vector { _handler : GMAC_Q5 } ,] ; # [doc = r"Enumeration of all the interrupts."] # [derive (Copy , Clone , Debug , PartialEq , Eq)] # [repr (u16)] pub enum Interrupt { # [doc = "0 - SUPC"] SUPC = 0 , # [doc = "1 - RSTC"] RSTC = 1 , # [doc = "2 - RTC"] RTC = 2 , # [doc = "3 - RTT"] RTT = 3 , # [doc = "4 - WDT"] WDT = 4 , # [doc = "5 - PMC"] PMC = 5 , # [doc = "6 - EFC"] EFC = 6 , # [doc = "7 - UART0"] UART0 = 7 , # [doc = "8 - UART1"] UART1 = 8 , # [doc = "10 - PIOA"] PIOA = 10 , # [doc = "11 - PIOB"] PIOB = 11 , # [doc = "13 - USART0"] USART0 = 13 , # [doc = "14 - USART1"] USART1 = 14 , # [doc = "15 - USART2"] USART2 = 15 , # [doc = "16 - PIOD"] PIOD = 16 , # [doc = "18 - HSMCI"] HSMCI = 18 , # [doc = "19 - TWIHS0"] TWIHS0 = 19 , # [doc = "20 - TWIHS1"] TWIHS1 = 20 , # [doc = "21 - SPI0"] SPI0 = 21 , # [doc = "22 - SSC"] SSC = 22 , # [doc = "23 - TC0"] TC0 = 23 , # [doc = "24 - TC1"] TC1 = 24 , # [doc = "25 - TC2"] TC2 = 25 , # [doc = "26 - TC3"] TC3 = 26 , # [doc = "27 - TC4"] TC4 = 27 , # [doc = "28 - TC5"] TC5 = 28 , # [doc = "29 - AFEC0"] AFEC0 = 29 , # [doc = "30 - DACC"] DACC = 30 , # [doc = "31 - PWM0"] PWM0 = 31 , # [doc = "32 - ICM"] ICM = 32 , # [doc = "33 - ACC"] ACC = 33 , # [doc = "34 - USBHS"] USBHS = 34 , # [doc = "35 - MCAN0_INT0"] MCAN0_INT0 = 35 , # [doc = "36 - MCAN0_INT1"] MCAN0_INT1 = 36 , # [doc = "37 - MCAN1_INT0"] MCAN1_INT0 = 37 , # [doc = "38 - MCAN1_INT1"] MCAN1_INT1 = 38 , # [doc = "39 - GMAC"] GMAC = 39 , # [doc = "40 - AFEC1"] AFEC1 = 40 , # [doc = "41 - TWIHS2"] TWIHS2 = 41 , # [doc = "43 - QSPI"] QSPI = 43 , # [doc = "44 - UART2"] UART2 = 44 , # [doc = "45 - UART3"] UART3 = 45 , # [doc = "46 - UART4"] UART4 = 46 , # [doc = "47 - TC6"] TC6 = 47 , # [doc = "48 - TC7"] TC7 = 48 , # [doc = "49 - TC8"] TC8 = 49 , # [doc = "50 - TC9"] TC9 = 50 , # [doc = "51 - TC10"] TC10 = 51 , # [doc = "52 - TC11"] TC11 = 52 , # [doc = "56 - AES"] AES = 56 , # [doc = "57 - TRNG"] TRNG = 57 , # [doc = "58 - XDMAC"] XDMAC = 58 , # [doc = "59 - ISI"] ISI = 59 , # [doc = "60 - PWM1"] PWM1 = 60 , # [doc = "61 - FPU"] FPU = 61 , # [doc = "63 - RSWDT"] RSWDT = 63 , # [doc = "64 - CCW"] CCW = 64 , # [doc = "65 - CCF"] CCF = 65 , # [doc = "66 - GMAC_Q1"] GMAC_Q1 = 66 , # [doc = "67 - GMAC_Q2"] GMAC_Q2 = 67 , # [doc = "68 - IXC"] IXC = 68 , # [doc = "69 - I2SC0"] I2SC0 = 69 , # [doc = "71 - GMAC_Q3"] GMAC_Q3 = 71 , # [doc = "72 - GMAC_Q4"] GMAC_Q4 = 72 , # [doc = "73 - GMAC_Q5"] GMAC_Q5 = 73 , } unsafe impl cortex_m :: interrupt :: InterruptNumber for Interrupt { # [inline (always)] fn number (self) -> u16 { self as u16 } } # [doc = "Analog Comparator Controller"] pub struct ACC { _marker : PhantomData < * const () > } unsafe impl Send for ACC { } impl ACC { # [doc = r"Pointer to the register block"] pub const PTR : * const acc :: RegisterBlock = 0x4004_4000 as * const _ ; # [doc = r"Return the pointer to the register block"] # [inline (always)] pub const fn ptr () -> * const acc :: RegisterBlock { Self :: PTR } } impl Deref for ACC { type Target = acc :: RegisterBlock ; # [inline (always)] fn deref (& self) -> & Self :: Target { unsafe { & * Self :: PTR } } } impl core :: fmt :: Debug for ACC { fn fmt (& self , f : & mut core :: fmt :: Formatter) -> core :: fmt :: Result { f . debug_struct ("ACC") . finish () } } # [doc = "Analog Comparator Controller"] pub mod acc ; # [doc = "Advanced Encryption Standard"] pub struct AES { _marker : PhantomData < * const () > } unsafe impl Send for AES { } impl AES { # [doc = r"Pointer to the register block"] pub const PTR : * const aes :: RegisterBlock = 0x4006_c000 as * const _ ; # [doc = r"Return the pointer to the register block"] # [inline (always)] pub const fn ptr () -> * const aes :: RegisterBlock { Self :: PTR } } impl Deref for AES { type Target = aes :: RegisterBlock ; # [inline (always)] fn deref (& self) -> & Self :: Target { unsafe { & * Self :: PTR } } } impl core :: fmt :: Debug for AES { fn fmt (& self , f : & mut core :: fmt :: Formatter) -> core :: fmt :: Result { f . debug_struct ("AES") . finish () } } # [doc = "Advanced Encryption Standard"] pub mod aes ; # [doc = "Analog Front-End Controller"] pub struct AFEC0 { _marker : PhantomData < * const () > } unsafe impl Send for AFEC0 { } impl AFEC0 { # [doc = r"Pointer to the register block"] pub const PTR : * const afec0 :: RegisterBlock = 0x4003_c000 as * const _ ; # [doc = r"Return the pointer to the register block"] # [inline (always)] pub const fn ptr () -> * const afec0 :: RegisterBlock { Self :: PTR } } impl Deref for AFEC0 { type Target = afec0 :: RegisterBlock ; # [inline (always)] fn deref (& self) -> & Self :: Target { unsafe { & * Self :: PTR } } } impl core :: fmt :: Debug for AFEC0 { fn fmt (& self , f : & mut core :: fmt :: Formatter) -> core :: fmt :: Result { f . debug_struct ("AFEC0") . finish () } } # [doc = "Analog Front-End Controller"] pub mod afec0 ; # [doc = "Analog Front-End Controller"] pub struct AFEC1 { _marker : PhantomData < * const () > } unsafe impl Send for AFEC1 { } impl AFEC1 { # [doc = r"Pointer to the register block"] pub const PTR : * const afec0 :: RegisterBlock = 0x4006_4000 as * const _ ; # [doc = r"Return the pointer to the register block"] # [inline (always)] pub const fn ptr () -> * const afec0 :: RegisterBlock { Self :: PTR } } impl Deref for AFEC1 { type Target = afec0 :: RegisterBlock ; # [inline (always)] fn deref (& self) -> & Self :: Target { unsafe { & * Self :: PTR } } } impl core :: fmt :: Debug for AFEC1 { fn fmt (& self , f : & mut core :: fmt :: Formatter) -> core :: fmt :: Result { f . debug_struct ("AFEC1") . finish () } } # [doc = "Analog Front-End Controller"] pub use self :: afec0 as afec1 ; # [doc = "Chip Identifier"] pub struct CHIPID { _marker : PhantomData < * const () > } unsafe impl Send for CHIPID { } impl CHIPID { # [doc = r"Pointer to the register block"] pub const PTR : * const chipid :: RegisterBlock = 0x400e_0940 as * const _ ; # [doc = r"Return the pointer to the register block"] # [inline (always)] pub const fn ptr () -> * const chipid :: RegisterBlock { Self :: PTR } } impl Deref for CHIPID { type Target = chipid :: RegisterBlock ; # [inline (always)] fn deref (& self) -> & Self :: Target { unsafe { & * Self :: PTR } } } impl core :: fmt :: Debug for CHIPID { fn fmt (& self , f : & mut core :: fmt :: Formatter) -> core :: fmt :: Result { f . debug_struct ("CHIPID") . finish () } } # [doc = "Chip Identifier"] pub mod chipid ; # [doc = "Digital-to-Analog Converter Controller"] pub struct DACC { _marker : PhantomData < * const () > } unsafe impl Send for DACC { } impl DACC { # [doc = r"Pointer to the register block"] pub const PTR : * const dacc :: RegisterBlock = 0x4004_0000 as * const _ ; # [doc = r"Return the pointer to the register block"] # [inline (always)] pub const fn ptr () -> * const dacc :: RegisterBlock { Self :: PTR } } impl Deref for DACC { type Target = dacc :: RegisterBlock ; # [inline (always)] fn deref (& self) -> & Self :: Target { unsafe { & * Self :: PTR } } } impl core :: fmt :: Debug for DACC { fn fmt (& self , f : & mut core :: fmt :: Formatter) -> core :: fmt :: Result { f . debug_struct ("DACC") . finish () } } # [doc = "Digital-to-Analog Converter Controller"] pub mod dacc ; # [doc = "Embedded Flash Controller"] pub struct EFC { _marker : PhantomData < * const () > } unsafe impl Send for EFC { } impl EFC { # [doc = r"Pointer to the register block"] pub const PTR : * const efc :: RegisterBlock = 0x400e_0c00 as * const _ ; # [doc = r"Return the pointer to the register block"] # [inline (always)] pub const fn ptr () -> * const efc :: RegisterBlock { Self :: PTR } } impl Deref for EFC { type Target = efc :: RegisterBlock ; # [inline (always)] fn deref (& self) -> & Self :: Target { unsafe { & * Self :: PTR } } } impl core :: fmt :: Debug for EFC { fn fmt (& self , f : & mut core :: fmt :: Formatter) -> core :: fmt :: Result { f . debug_struct ("EFC") . finish () } } # [doc = "Embedded Flash Controller"] pub mod efc ; # [doc = "Gigabit Ethernet MAC"] pub struct GMAC { _marker : PhantomData < * const () > } unsafe impl Send for GMAC { } impl GMAC { # [doc = r"Pointer to the register block"] pub const PTR : * const gmac :: RegisterBlock = 0x4005_0000 as * const _ ; # [doc = r"Return the pointer to the register block"] # [inline (always)] pub const fn ptr () -> * const gmac :: RegisterBlock { Self :: PTR } } impl Deref for GMAC { type Target = gmac :: RegisterBlock ; # [inline (always)] fn deref (& self) -> & Self :: Target { unsafe { & * Self :: PTR } } } impl core :: fmt :: Debug for GMAC { fn fmt (& self , f : & mut core :: fmt :: Formatter) -> core :: fmt :: Result { f . debug_struct ("GMAC") . finish () } } # [doc = "Gigabit Ethernet MAC"] pub mod gmac ; # [doc = "General Purpose Backup Registers"] pub struct GPBR { _marker : PhantomData < * const () > } unsafe impl Send for GPBR { } impl GPBR { # [doc = r"Pointer to the register block"] pub const PTR : * const gpbr :: RegisterBlock = 0x400e_1890 as * const _ ; # [doc = r"Return the pointer to the register block"] # [inline (always)] pub const fn ptr () -> * const gpbr :: RegisterBlock { Self :: PTR } } impl Deref for GPBR { type Target = gpbr :: RegisterBlock ; # [inline (always)] fn deref (& self) -> & Self :: Target { unsafe { & * Self :: PTR } } } impl core :: fmt :: Debug for GPBR { fn fmt (& self , f : & mut core :: fmt :: Formatter) -> core :: fmt :: Result { f . debug_struct ("GPBR") . finish () } } # [doc = "General Purpose Backup Registers"] pub mod gpbr ; # [doc = "High Speed MultiMedia Card Interface"] pub struct HSMCI { _marker : PhantomData < * const () > } unsafe impl Send for HSMCI { } impl HSMCI { # [doc = r"Pointer to the register block"] pub const PTR : * const hsmci :: RegisterBlock = 0x4000_0000 as * const _ ; # [doc = r"Return the pointer to the register block"] # [inline (always)] pub const fn ptr () -> * const hsmci :: RegisterBlock { Self :: PTR } } impl Deref for HSMCI { type Target = hsmci :: RegisterBlock ; # [inline (always)] fn deref (& self) -> & Self :: Target { unsafe { & * Self :: PTR } } } impl core :: fmt :: Debug for HSMCI { fn fmt (& self , f : & mut core :: fmt :: Formatter) -> core :: fmt :: Result { f . debug_struct ("HSMCI") . finish () } } # [doc = "High Speed MultiMedia Card Interface"] pub mod hsmci ; # [doc = "Inter-IC Sound Controller"] pub struct I2SC0 { _marker : PhantomData < * const () > } unsafe impl Send for I2SC0 { } impl I2SC0 { # [doc = r"Pointer to the register block"] pub const PTR : * const i2sc0 :: RegisterBlock = 0x4008_c000 as * const _ ; # [doc = r"Return the pointer to the register block"] # [inline (always)] pub const fn ptr () -> * const i2sc0 :: RegisterBlock { Self :: PTR } } impl Deref for I2SC0 { type Target = i2sc0 :: RegisterBlock ; # [inline (always)] fn deref (& self) -> & Self :: Target { unsafe { & * Self :: PTR } } } impl core :: fmt :: Debug for I2SC0 { fn fmt (& self , f : & mut core :: fmt :: Formatter) -> core :: fmt :: Result { f . debug_struct ("I2SC0") . finish () } } # [doc = "Inter-IC Sound Controller"] pub mod i2sc0 ; # [doc = "Integrity Check Monitor"] pub struct ICM { _marker : PhantomData < * const () > } unsafe impl Send for ICM { } impl ICM { # [doc = r"Pointer to the register block"] pub const PTR : * const icm :: RegisterBlock = 0x4004_8000 as * const _ ; # [doc = r"Return the pointer to the register block"] # [inline (always)] pub const fn ptr () -> * const icm :: RegisterBlock { Self :: PTR } } impl Deref for ICM { type Target = icm :: RegisterBlock ; # [inline (always)] fn deref (& self) -> & Self :: Target { unsafe { & * Self :: PTR } } } impl core :: fmt :: Debug for ICM { fn fmt (& self , f : & mut core :: fmt :: Formatter) -> core :: fmt :: Result { f . debug_struct ("ICM") . finish () } } # [doc = "Integrity Check Monitor"] pub mod icm ; # [doc = "Image Sensor Interface"] pub struct ISI { _marker : PhantomData < * const () > } unsafe impl Send for ISI { } impl ISI { # [doc = r"Pointer to the register block"] pub const PTR : * const isi :: RegisterBlock = 0x4004_c000 as * const _ ; # [doc = r"Return the pointer to the register block"] # [inline (always)] pub const fn ptr () -> * const isi :: RegisterBlock { Self :: PTR } } impl Deref for ISI { type Target = isi :: RegisterBlock ; # [inline (always)] fn deref (& self) -> & Self :: Target { unsafe { & * Self :: PTR } } } impl core :: fmt :: Debug for ISI { fn fmt (& self , f : & mut core :: fmt :: Formatter) -> core :: fmt :: Result { f . debug_struct ("ISI") . finish () } } # [doc = "Image Sensor Interface"] pub mod isi ; # [doc = "AHB Bus Matrix"] pub struct MATRIX { _marker : PhantomData < * const () > } unsafe impl Send for MATRIX { } impl MATRIX { # [doc = r"Pointer to the register block"] pub const PTR : * const matrix :: RegisterBlock = 0x4008_8000 as * const _ ; # [doc = r"Return the pointer to the register block"] # [inline (always)] pub const fn ptr () -> * const matrix :: RegisterBlock { Self :: PTR } } impl Deref for MATRIX { type Target = matrix :: RegisterBlock ; # [inline (always)] fn deref (& self) -> & Self :: Target { unsafe { & * Self :: PTR } } } impl core :: fmt :: Debug for MATRIX { fn fmt (& self , f : & mut core :: fmt :: Formatter) -> core :: fmt :: Result { f . debug_struct ("MATRIX") . finish () } } # [doc = "AHB Bus Matrix"] pub mod matrix ; # [doc = "Controller Area Network"] pub struct MCAN0 { _marker : PhantomData < * const () > } unsafe impl Send for MCAN0 { } impl MCAN0 { # [doc = r"Pointer to the register block"] pub const PTR : * const mcan0 :: RegisterBlock = 0x4003_0000 as * const _ ; # [doc = r"Return the pointer to the register block"] # [inline (always)] pub const fn ptr () -> * const mcan0 :: RegisterBlock { Self :: PTR } } impl Deref for MCAN0 { type Target = mcan0 :: RegisterBlock ; # [inline (always)] fn deref (& self) -> & Self :: Target { unsafe { & * Self :: PTR } } } impl core :: fmt :: Debug for MCAN0 { fn fmt (& self , f : & mut core :: fmt :: Formatter) -> core :: fmt :: Result { f . debug_struct ("MCAN0") . finish () } } # [doc = "Controller Area Network"] pub mod mcan0 ; # [doc = "Controller Area Network"] pub struct MCAN1 { _marker : PhantomData < * const () > } unsafe impl Send for MCAN1 { } impl MCAN1 { # [doc = r"Pointer to the register block"] pub const PTR : * const mcan0 :: RegisterBlock = 0x4003_4000 as * const _ ; # [doc = r"Return the pointer to the register block"] # [inline (always)] pub const fn ptr () -> * const mcan0 :: RegisterBlock { Self :: PTR } } impl Deref for MCAN1 { type Target = mcan0 :: RegisterBlock ; # [inline (always)] fn deref (& self) -> & Self :: Target { unsafe { & * Self :: PTR } } } impl core :: fmt :: Debug for MCAN1 { fn fmt (& self , f : & mut core :: fmt :: Formatter) -> core :: fmt :: Result { f . debug_struct ("MCAN1") . finish () } } # [doc = "Controller Area Network"] pub use self :: mcan0 as mcan1 ; # [doc = "Parallel Input/Output Controller"] pub struct PIOA { _marker : PhantomData < * const () > } unsafe impl Send for PIOA { } impl PIOA { # [doc = r"Pointer to the register block"] pub const PTR : * const pioa :: RegisterBlock = 0x400e_0e00 as * const _ ; # [doc = r"Return the pointer to the register block"] # [inline (always)] pub const fn ptr () -> * const pioa :: RegisterBlock { Self :: PTR } } impl Deref for PIOA { type Target = pioa :: RegisterBlock ; # [inline (always)] fn deref (& self) -> & Self :: Target { unsafe { & * Self :: PTR } } } impl core :: fmt :: Debug for PIOA { fn fmt (& self , f : & mut core :: fmt :: Formatter) -> core :: fmt :: Result { f . debug_struct ("PIOA") . finish () } } # [doc = "Parallel Input/Output Controller"] pub mod pioa ; # [doc = "Parallel Input/Output Controller"] pub struct PIOB { _marker : PhantomData < * const () > } unsafe impl Send for PIOB { } impl PIOB { # [doc = r"Pointer to the register block"] pub const PTR : * const pioa :: RegisterBlock = 0x400e_1000 as * const _ ; # [doc = r"Return the pointer to the register block"] # [inline (always)] pub const fn ptr () -> * const pioa :: RegisterBlock { Self :: PTR } } impl Deref for PIOB { type Target = pioa :: RegisterBlock ; # [inline (always)] fn deref (& self) -> & Self :: Target { unsafe { & * Self :: PTR } } } impl core :: fmt :: Debug for PIOB { fn fmt (& self , f : & mut core :: fmt :: Formatter) -> core :: fmt :: Result { f . debug_struct ("PIOB") . finish () } } # [doc = "Parallel Input/Output Controller"] pub use self :: pioa as piob ; # [doc = "Parallel Input/Output Controller"] pub struct PIOD { _marker : PhantomData < * const () > } unsafe impl Send for PIOD { } impl PIOD { # [doc = r"Pointer to the register block"] pub const PTR : * const pioa :: RegisterBlock = 0x400e_1400 as * const _ ; # [doc = r"Return the pointer to the register block"] # [inline (always)] pub const fn ptr () -> * const pioa :: RegisterBlock { Self :: PTR } } impl Deref for PIOD { type Target = pioa :: RegisterBlock ; # [inline (always)] fn deref (& self) -> & Self :: Target { unsafe { & * Self :: PTR } } } impl core :: fmt :: Debug for PIOD { fn fmt (& self , f : & mut core :: fmt :: Formatter) -> core :: fmt :: Result { f . debug_struct ("PIOD") . finish () } } # [doc = "Parallel Input/Output Controller"] pub use self :: pioa as piod ; # [doc = "Power Management Controller"] pub struct PMC { _marker : PhantomData < * const () > } unsafe impl Send for PMC { } impl PMC { # [doc = r"Pointer to the register block"] pub const PTR : * const pmc :: RegisterBlock = 0x400e_0600 as * const _ ; # [doc = r"Return the pointer to the register block"] # [inline (always)] pub const fn ptr () -> * const pmc :: RegisterBlock { Self :: PTR } } impl Deref for PMC { type Target = pmc :: RegisterBlock ; # [inline (always)] fn deref (& self) -> & Self :: Target { unsafe { & * Self :: PTR } } } impl core :: fmt :: Debug for PMC { fn fmt (& self , f : & mut core :: fmt :: Formatter) -> core :: fmt :: Result { f . debug_struct ("PMC") . finish () } } # [doc = "Power Management Controller"] pub mod pmc ; # [doc = "Pulse Width Modulation Controller"] pub struct PWM0 { _marker : PhantomData < * const () > } unsafe impl Send for PWM0 { } impl PWM0 { # [doc = r"Pointer to the register block"] pub const PTR : * const pwm0 :: RegisterBlock = 0x4002_0000 as * const _ ; # [doc = r"Return the pointer to the register block"] # [inline (always)] pub const fn ptr () -> * const pwm0 :: RegisterBlock { Self :: PTR } } impl Deref for PWM0 { type Target = pwm0 :: RegisterBlock ; # [inline (always)] fn deref (& self) -> & Self :: Target { unsafe { & * Self :: PTR } } } impl core :: fmt :: Debug for PWM0 { fn fmt (& self , f : & mut core :: fmt :: Formatter) -> core :: fmt :: Result { f . debug_struct ("PWM0") . finish () } } # [doc = "Pulse Width Modulation Controller"] pub mod pwm0 ; # [doc = "Pulse Width Modulation Controller"] pub struct PWM1 { _marker : PhantomData < * const () > } unsafe impl Send for PWM1 { } impl PWM1 { # [doc = r"Pointer to the register block"] pub const PTR : * const pwm0 :: RegisterBlock = 0x4005_c000 as * const _ ; # [doc = r"Return the pointer to the register block"] # [inline (always)] pub const fn ptr () -> * const pwm0 :: RegisterBlock { Self :: PTR } } impl Deref for PWM1 { type Target = pwm0 :: RegisterBlock ; # [inline (always)] fn deref (& self) -> & Self :: Target { unsafe { & * Self :: PTR } } } impl core :: fmt :: Debug for PWM1 { fn fmt (& self , f : & mut core :: fmt :: Formatter) -> core :: fmt :: Result { f . debug_struct ("PWM1") . finish () } } # [doc = "Pulse Width Modulation Controller"] pub use self :: pwm0 as pwm1 ; # [doc = "Quad Serial Peripheral Interface"] pub struct QSPI { _marker : PhantomData < * const () > } unsafe impl Send for QSPI { } impl QSPI { # [doc = r"Pointer to the register block"] pub const PTR : * const qspi :: RegisterBlock = 0x4007_c000 as * const _ ; # [doc = r"Return the pointer to the register block"] # [inline (always)] pub const fn ptr () -> * const qspi :: RegisterBlock { Self :: PTR } } impl Deref for QSPI { type Target = qspi :: RegisterBlock ; # [inline (always)] fn deref (& self) -> & Self :: Target { unsafe { & * Self :: PTR } } } impl core :: fmt :: Debug for QSPI { fn fmt (& self , f : & mut core :: fmt :: Formatter) -> core :: fmt :: Result { f . debug_struct ("QSPI") . finish () } } # [doc = "Quad Serial Peripheral Interface"] pub mod qspi ; # [doc = "Reset Controller"] pub struct RSTC { _marker : PhantomData < * const () > } unsafe impl Send for RSTC { } impl RSTC { # [doc = r"Pointer to the register block"] pub const PTR : * const rstc :: RegisterBlock = 0x400e_1800 as * const _ ; # [doc = r"Return the pointer to the register block"] # [inline (always)] pub const fn ptr () -> * const rstc :: RegisterBlock { Self :: PTR } } impl Deref for RSTC { type Target = rstc :: RegisterBlock ; # [inline (always)] fn deref (& self) -> & Self :: Target { unsafe { & * Self :: PTR } } } impl core :: fmt :: Debug for RSTC { fn fmt (& self , f : & mut core :: fmt :: Formatter) -> core :: fmt :: Result { f . debug_struct ("RSTC") . finish () } } # [doc = "Reset Controller"] pub mod rstc ; # [doc = "Reinforced Safety Watchdog Timer"] pub struct RSWDT { _marker : PhantomData < * const () > } unsafe impl Send for RSWDT { } impl RSWDT { # [doc = r"Pointer to the register block"] pub const PTR : * const rswdt :: RegisterBlock = 0x400e_1900 as * const _ ; # [doc = r"Return the pointer to the register block"] # [inline (always)] pub const fn ptr () -> * const rswdt :: RegisterBlock { Self :: PTR } } impl Deref for RSWDT { type Target = rswdt :: RegisterBlock ; # [inline (always)] fn deref (& self) -> & Self :: Target { unsafe { & * Self :: PTR } } } impl core :: fmt :: Debug for RSWDT { fn fmt (& self , f : & mut core :: fmt :: Formatter) -> core :: fmt :: Result { f . debug_struct ("RSWDT") . finish () } } # [doc = "Reinforced Safety Watchdog Timer"] pub mod rswdt ; # [doc = "Real-time Clock"] pub struct RTC { _marker : PhantomData < * const () > } unsafe impl Send for RTC { } impl RTC { # [doc = r"Pointer to the register block"] pub const PTR : * const rtc :: RegisterBlock = 0x400e_1860 as * const _ ; # [doc = r"Return the pointer to the register block"] # [inline (always)] pub const fn ptr () -> * const rtc :: RegisterBlock { Self :: PTR } } impl Deref for RTC { type Target = rtc :: RegisterBlock ; # [inline (always)] fn deref (& self) -> & Self :: Target { unsafe { & * Self :: PTR } } } impl core :: fmt :: Debug for RTC { fn fmt (& self , f : & mut core :: fmt :: Formatter) -> core :: fmt :: Result { f . debug_struct ("RTC") . finish () } } # [doc = "Real-time Clock"] pub mod rtc ; # [doc = "Real-time Timer"] pub struct RTT { _marker : PhantomData < * const () > } unsafe impl Send for RTT { } impl RTT { # [doc = r"Pointer to the register block"] pub const PTR : * const rtt :: RegisterBlock = 0x400e_1830 as * const _ ; # [doc = r"Return the pointer to the register block"] # [inline (always)] pub const fn ptr () -> * const rtt :: RegisterBlock { Self :: PTR } } impl Deref for RTT { type Target = rtt :: RegisterBlock ; # [inline (always)] fn deref (& self) -> & Self :: Target { unsafe { & * Self :: PTR } } } impl core :: fmt :: Debug for RTT { fn fmt (& self , f : & mut core :: fmt :: Formatter) -> core :: fmt :: Result { f . debug_struct ("RTT") . finish () } } # [doc = "Real-time Timer"] pub mod rtt ; # [doc = "Serial Peripheral Interface"] pub struct SPI0 { _marker : PhantomData < * const () > } unsafe impl Send for SPI0 { } impl SPI0 { # [doc = r"Pointer to the register block"] pub const PTR : * const spi0 :: RegisterBlock = 0x4000_8000 as * const _ ; # [doc = r"Return the pointer to the register block"] # [inline (always)] pub const fn ptr () -> * const spi0 :: RegisterBlock { Self :: PTR } } impl Deref for SPI0 { type Target = spi0 :: RegisterBlock ; # [inline (always)] fn deref (& self) -> & Self :: Target { unsafe { & * Self :: PTR } } } impl core :: fmt :: Debug for SPI0 { fn fmt (& self , f : & mut core :: fmt :: Formatter) -> core :: fmt :: Result { f . debug_struct ("SPI0") . finish () } } # [doc = "Serial Peripheral Interface"] pub mod spi0 ; # [doc = "Synchronous Serial Controller"] pub struct SSC { _marker : PhantomData < * const () > } unsafe impl Send for SSC { } impl SSC { # [doc = r"Pointer to the register block"] pub const PTR : * const ssc :: RegisterBlock = 0x4000_4000 as * const _ ; # [doc = r"Return the pointer to the register block"] # [inline (always)] pub const fn ptr () -> * const ssc :: RegisterBlock { Self :: PTR } } impl Deref for SSC { type Target = ssc :: RegisterBlock ; # [inline (always)] fn deref (& self) -> & Self :: Target { unsafe { & * Self :: PTR } } } impl core :: fmt :: Debug for SSC { fn fmt (& self , f : & mut core :: fmt :: Formatter) -> core :: fmt :: Result { f . debug_struct ("SSC") . finish () } } # [doc = "Synchronous Serial Controller"] pub mod ssc ; # [doc = "Supply Controller"] pub struct SUPC { _marker : PhantomData < * const () > } unsafe impl Send for SUPC { } impl SUPC { # [doc = r"Pointer to the register block"] pub const PTR : * const supc :: RegisterBlock = 0x400e_1810 as * const _ ; # [doc = r"Return the pointer to the register block"] # [inline (always)] pub const fn ptr () -> * const supc :: RegisterBlock { Self :: PTR } } impl Deref for SUPC { type Target = supc :: RegisterBlock ; # [inline (always)] fn deref (& self) -> & Self :: Target { unsafe { & * Self :: PTR } } } impl core :: fmt :: Debug for SUPC { fn fmt (& self , f : & mut core :: fmt :: Formatter) -> core :: fmt :: Result { f . debug_struct ("SUPC") . finish () } } # [doc = "Supply Controller"] pub mod supc ; # [doc = "Timer Counter"] pub struct TC0 { _marker : PhantomData < * const () > } unsafe impl Send for TC0 { } impl TC0 { # [doc = r"Pointer to the register block"] pub const PTR : * const tc0 :: RegisterBlock = 0x4000_c000 as * const _ ; # [doc = r"Return the pointer to the register block"] # [inline (always)] pub const fn ptr () -> * const tc0 :: RegisterBlock { Self :: PTR } } impl Deref for TC0 { type Target = tc0 :: RegisterBlock ; # [inline (always)] fn deref (& self) -> & Self :: Target { unsafe { & * Self :: PTR } } } impl core :: fmt :: Debug for TC0 { fn fmt (& self , f : & mut core :: fmt :: Formatter) -> core :: fmt :: Result { f . debug_struct ("TC0") . finish () } } # [doc = "Timer Counter"] pub mod tc0 ; # [doc = "Timer Counter"] pub struct TC1 { _marker : PhantomData < * const () > } unsafe impl Send for TC1 { } impl TC1 { # [doc = r"Pointer to the register block"] pub const PTR : * const tc0 :: RegisterBlock = 0x4001_0000 as * const _ ; # [doc = r"Return the pointer to the register block"] # [inline (always)] pub const fn ptr () -> * const tc0 :: RegisterBlock { Self :: PTR } } impl Deref for TC1 { type Target = tc0 :: RegisterBlock ; # [inline (always)] fn deref (& self) -> & Self :: Target { unsafe { & * Self :: PTR } } } impl core :: fmt :: Debug for TC1 { fn fmt (& self , f : & mut core :: fmt :: Formatter) -> core :: fmt :: Result { f . debug_struct ("TC1") . finish () } } # [doc = "Timer Counter"] pub use self :: tc0 as tc1 ; # [doc = "Timer Counter"] pub struct TC2 { _marker : PhantomData < * const () > } unsafe impl Send for TC2 { } impl TC2 { # [doc = r"Pointer to the register block"] pub const PTR : * const tc0 :: RegisterBlock = 0x4001_4000 as * const _ ; # [doc = r"Return the pointer to the register block"] # [inline (always)] pub const fn ptr () -> * const tc0 :: RegisterBlock { Self :: PTR } } impl Deref for TC2 { type Target = tc0 :: RegisterBlock ; # [inline (always)] fn deref (& self) -> & Self :: Target { unsafe { & * Self :: PTR } } } impl core :: fmt :: Debug for TC2 { fn fmt (& self , f : & mut core :: fmt :: Formatter) -> core :: fmt :: Result { f . debug_struct ("TC2") . finish () } } # [doc = "Timer Counter"] pub use self :: tc0 as tc2 ; # [doc = "Timer Counter"] pub struct TC3 { _marker : PhantomData < * const () > } unsafe impl Send for TC3 { } impl TC3 { # [doc = r"Pointer to the register block"] pub const PTR : * const tc0 :: RegisterBlock = 0x4005_4000 as * const _ ; # [doc = r"Return the pointer to the register block"] # [inline (always)] pub const fn ptr () -> * const tc0 :: RegisterBlock { Self :: PTR } } impl Deref for TC3 { type Target = tc0 :: RegisterBlock ; # [inline (always)] fn deref (& self) -> & Self :: Target { unsafe { & * Self :: PTR } } } impl core :: fmt :: Debug for TC3 { fn fmt (& self , f : & mut core :: fmt :: Formatter) -> core :: fmt :: Result { f . debug_struct ("TC3") . finish () } } # [doc = "Timer Counter"] pub use self :: tc0 as tc3 ; # [doc = "True Random Number Generator"] pub struct TRNG { _marker : PhantomData < * const () > } unsafe impl Send for TRNG { } impl TRNG { # [doc = r"Pointer to the register block"] pub const PTR : * const trng :: RegisterBlock = 0x4007_0000 as * const _ ; # [doc = r"Return the pointer to the register block"] # [inline (always)] pub const fn ptr () -> * const trng :: RegisterBlock { Self :: PTR } } impl Deref for TRNG { type Target = trng :: RegisterBlock ; # [inline (always)] fn deref (& self) -> & Self :: Target { unsafe { & * Self :: PTR } } } impl core :: fmt :: Debug for TRNG { fn fmt (& self , f : & mut core :: fmt :: Formatter) -> core :: fmt :: Result { f . debug_struct ("TRNG") . finish () } } # [doc = "True Random Number Generator"] pub mod trng ; # [doc = "Two-wire Interface High Speed"] pub struct TWIHS0 { _marker : PhantomData < * const () > } unsafe impl Send for TWIHS0 { } impl TWIHS0 { # [doc = r"Pointer to the register block"] pub const PTR : * const twihs0 :: RegisterBlock = 0x4001_8000 as * const _ ; # [doc = r"Return the pointer to the register block"] # [inline (always)] pub const fn ptr () -> * const twihs0 :: RegisterBlock { Self :: PTR } } impl Deref for TWIHS0 { type Target = twihs0 :: RegisterBlock ; # [inline (always)] fn deref (& self) -> & Self :: Target { unsafe { & * Self :: PTR } } } impl core :: fmt :: Debug for TWIHS0 { fn fmt (& self , f : & mut core :: fmt :: Formatter) -> core :: fmt :: Result { f . debug_struct ("TWIHS0") . finish () } } # [doc = "Two-wire Interface High Speed"] pub mod twihs0 ; # [doc = "Two-wire Interface High Speed"] pub struct TWIHS1 { _marker : PhantomData < * const () > } unsafe impl Send for TWIHS1 { } impl TWIHS1 { # [doc = r"Pointer to the register block"] pub const PTR : * const twihs0 :: RegisterBlock = 0x4001_c000 as * const _ ; # [doc = r"Return the pointer to the register block"] # [inline (always)] pub const fn ptr () -> * const twihs0 :: RegisterBlock { Self :: PTR } } impl Deref for TWIHS1 { type Target = twihs0 :: RegisterBlock ; # [inline (always)] fn deref (& self) -> & Self :: Target { unsafe { & * Self :: PTR } } } impl core :: fmt :: Debug for TWIHS1 { fn fmt (& self , f : & mut core :: fmt :: Formatter) -> core :: fmt :: Result { f . debug_struct ("TWIHS1") . finish () } } # [doc = "Two-wire Interface High Speed"] pub use self :: twihs0 as twihs1 ; # [doc = "Two-wire Interface High Speed"] pub struct TWIHS2 { _marker : PhantomData < * const () > } unsafe impl Send for TWIHS2 { } impl TWIHS2 { # [doc = r"Pointer to the register block"] pub const PTR : * const twihs0 :: RegisterBlock = 0x4006_0000 as * const _ ; # [doc = r"Return the pointer to the register block"] # [inline (always)] pub const fn ptr () -> * const twihs0 :: RegisterBlock { Self :: PTR } } impl Deref for TWIHS2 { type Target = twihs0 :: RegisterBlock ; # [inline (always)] fn deref (& self) -> & Self :: Target { unsafe { & * Self :: PTR } } } impl core :: fmt :: Debug for TWIHS2 { fn fmt (& self , f : & mut core :: fmt :: Formatter) -> core :: fmt :: Result { f . debug_struct ("TWIHS2") . finish () } } # [doc = "Two-wire Interface High Speed"] pub use self :: twihs0 as twihs2 ; # [doc = "Universal Asynchronous Receiver Transmitter"] pub struct UART0 { _marker : PhantomData < * const () > } unsafe impl Send for UART0 { } impl UART0 { # [doc = r"Pointer to the register block"] pub const PTR : * const uart0 :: RegisterBlock = 0x400e_0800 as * const _ ; # [doc = r"Return the pointer to the register block"] # [inline (always)] pub const fn ptr () -> * const uart0 :: RegisterBlock { Self :: PTR } } impl Deref for UART0 { type Target = uart0 :: RegisterBlock ; # [inline (always)] fn deref (& self) -> & Self :: Target { unsafe { & * Self :: PTR } } } impl core :: fmt :: Debug for UART0 { fn fmt (& self , f : & mut core :: fmt :: Formatter) -> core :: fmt :: Result { f . debug_struct ("UART0") . finish () } } # [doc = "Universal Asynchronous Receiver Transmitter"] pub mod uart0 ; # [doc = "Universal Asynchronous Receiver Transmitter"] pub struct UART1 { _marker : PhantomData < * const () > } unsafe impl Send for UART1 { } impl UART1 { # [doc = r"Pointer to the register block"] pub const PTR : * const uart0 :: RegisterBlock = 0x400e_0a00 as * const _ ; # [doc = r"Return the pointer to the register block"] # [inline (always)] pub const fn ptr () -> * const uart0 :: RegisterBlock { Self :: PTR } } impl Deref for UART1 { type Target = uart0 :: RegisterBlock ; # [inline (always)] fn deref (& self) -> & Self :: Target { unsafe { & * Self :: PTR } } } impl core :: fmt :: Debug for UART1 { fn fmt (& self , f : & mut core :: fmt :: Formatter) -> core :: fmt :: Result { f . debug_struct ("UART1") . finish () } } # [doc = "Universal Asynchronous Receiver Transmitter"] pub use self :: uart0 as uart1 ; # [doc = "Universal Asynchronous Receiver Transmitter"] pub struct UART2 { _marker : PhantomData < * const () > } unsafe impl Send for UART2 { } impl UART2 { # [doc = r"Pointer to the register block"] pub const PTR : * const uart0 :: RegisterBlock = 0x400e_1a00 as * const _ ; # [doc = r"Return the pointer to the register block"] # [inline (always)] pub const fn ptr () -> * const uart0 :: RegisterBlock { Self :: PTR } } impl Deref for UART2 { type Target = uart0 :: RegisterBlock ; # [inline (always)] fn deref (& self) -> & Self :: Target { unsafe { & * Self :: PTR } } } impl core :: fmt :: Debug for UART2 { fn fmt (& self , f : & mut core :: fmt :: Formatter) -> core :: fmt :: Result { f . debug_struct ("UART2") . finish () } } # [doc = "Universal Asynchronous Receiver Transmitter"] pub use self :: uart0 as uart2 ; # [doc = "Universal Asynchronous Receiver Transmitter"] pub struct UART3 { _marker : PhantomData < * const () > } unsafe impl Send for UART3 { } impl UART3 { # [doc = r"Pointer to the register block"] pub const PTR : * const uart0 :: RegisterBlock = 0x400e_1c00 as * const _ ; # [doc = r"Return the pointer to the register block"] # [inline (always)] pub const fn ptr () -> * const uart0 :: RegisterBlock { Self :: PTR } } impl Deref for UART3 { type Target = uart0 :: RegisterBlock ; # [inline (always)] fn deref (& self) -> & Self :: Target { unsafe { & * Self :: PTR } } } impl core :: fmt :: Debug for UART3 { fn fmt (& self , f : & mut core :: fmt :: Formatter) -> core :: fmt :: Result { f . debug_struct ("UART3") . finish () } } # [doc = "Universal Asynchronous Receiver Transmitter"] pub use self :: uart0 as uart3 ; # [doc = "Universal Asynchronous Receiver Transmitter"] pub struct UART4 { _marker : PhantomData < * const () > } unsafe impl Send for UART4 { } impl UART4 { # [doc = r"Pointer to the register block"] pub const PTR : * const uart0 :: RegisterBlock = 0x400e_1e00 as * const _ ; # [doc = r"Return the pointer to the register block"] # [inline (always)] pub const fn ptr () -> * const uart0 :: RegisterBlock { Self :: PTR } } impl Deref for UART4 { type Target = uart0 :: RegisterBlock ; # [inline (always)] fn deref (& self) -> & Self :: Target { unsafe { & * Self :: PTR } } } impl core :: fmt :: Debug for UART4 { fn fmt (& self , f : & mut core :: fmt :: Formatter) -> core :: fmt :: Result { f . debug_struct ("UART4") . finish () } } # [doc = "Universal Asynchronous Receiver Transmitter"] pub use self :: uart0 as uart4 ; # [doc = "Universal Synchronous Asynchronous Receiver Transmitter"] pub struct USART0 { _marker : PhantomData < * const () > } unsafe impl Send for USART0 { } impl USART0 { # [doc = r"Pointer to the register block"] pub const PTR : * const usart0 :: RegisterBlock = 0x4002_4000 as * const _ ; # [doc = r"Return the pointer to the register block"] # [inline (always)] pub const fn ptr () -> * const usart0 :: RegisterBlock { Self :: PTR } } impl Deref for USART0 { type Target = usart0 :: RegisterBlock ; # [inline (always)] fn deref (& self) -> & Self :: Target { unsafe { & * Self :: PTR } } } impl core :: fmt :: Debug for USART0 { fn fmt (& self , f : & mut core :: fmt :: Formatter) -> core :: fmt :: Result { f . debug_struct ("USART0") . finish () } } # [doc = "Universal Synchronous Asynchronous Receiver Transmitter"] pub mod usart0 ; # [doc = "Universal Synchronous Asynchronous Receiver Transmitter"] pub struct USART1 { _marker : PhantomData < * const () > } unsafe impl Send for USART1 { } impl USART1 { # [doc = r"Pointer to the register block"] pub const PTR : * const usart0 :: RegisterBlock = 0x4002_8000 as * const _ ; # [doc = r"Return the pointer to the register block"] # [inline (always)] pub const fn ptr () -> * const usart0 :: RegisterBlock { Self :: PTR } } impl Deref for USART1 { type Target = usart0 :: RegisterBlock ; # [inline (always)] fn deref (& self) -> & Self :: Target { unsafe { & * Self :: PTR } } } impl core :: fmt :: Debug for USART1 { fn fmt (& self , f : & mut core :: fmt :: Formatter) -> core :: fmt :: Result { f . debug_struct ("USART1") . finish () } } # [doc = "Universal Synchronous Asynchronous Receiver Transmitter"] pub use self :: usart0 as usart1 ; # [doc = "Universal Synchronous Asynchronous Receiver Transmitter"] pub struct USART2 { _marker : PhantomData < * const () > } unsafe impl Send for USART2 { } impl USART2 { # [doc = r"Pointer to the register block"] pub const PTR : * const usart0 :: RegisterBlock = 0x4002_c000 as * const _ ; # [doc = r"Return the pointer to the register block"] # [inline (always)] pub const fn ptr () -> * const usart0 :: RegisterBlock { Self :: PTR } } impl Deref for USART2 { type Target = usart0 :: RegisterBlock ; # [inline (always)] fn deref (& self) -> & Self :: Target { unsafe { & * Self :: PTR } } } impl core :: fmt :: Debug for USART2 { fn fmt (& self , f : & mut core :: fmt :: Formatter) -> core :: fmt :: Result { f . debug_struct ("USART2") . finish () } } # [doc = "Universal Synchronous Asynchronous Receiver Transmitter"] pub use self :: usart0 as usart2 ; # [doc = "USB High-Speed Interface"] pub struct USBHS { _marker : PhantomData < * const () > } unsafe impl Send for USBHS { } impl USBHS { # [doc = r"Pointer to the register block"] pub const PTR : * const usbhs :: RegisterBlock = 0x4003_8000 as * const _ ; # [doc = r"Return the pointer to the register block"] # [inline (always)] pub const fn ptr () -> * const usbhs :: RegisterBlock { Self :: PTR } } impl Deref for USBHS { type Target = usbhs :: RegisterBlock ; # [inline (always)] fn deref (& self) -> & Self :: Target { unsafe { & * Self :: PTR } } } impl core :: fmt :: Debug for USBHS { fn fmt (& self , f : & mut core :: fmt :: Formatter) -> core :: fmt :: Result { f . debug_struct ("USBHS") . finish () } } # [doc = "USB High-Speed Interface"] pub mod usbhs ; # [doc = "USB Transmitter Interface Macrocell"] pub struct UTMI { _marker : PhantomData < * const () > } unsafe impl Send for UTMI { } impl UTMI { # [doc = r"Pointer to the register block"] pub const PTR : * const utmi :: RegisterBlock = 0x400e_0400 as * const _ ; # [doc = r"Return the pointer to the register block"] # [inline (always)] pub const fn ptr () -> * const utmi :: RegisterBlock { Self :: PTR } } impl Deref for UTMI { type Target = utmi :: RegisterBlock ; # [inline (always)] fn deref (& self) -> & Self :: Target { unsafe { & * Self :: PTR } } } impl core :: fmt :: Debug for UTMI { fn fmt (& self , f : & mut core :: fmt :: Formatter) -> core :: fmt :: Result { f . debug_struct ("UTMI") . finish () } } # [doc = "USB Transmitter Interface Macrocell"] pub mod utmi ; # [doc = "Watchdog Timer"] pub struct WDT { _marker : PhantomData < * const () > } unsafe impl Send for WDT { } impl WDT { # [doc = r"Pointer to the register block"] pub const PTR : * const wdt :: RegisterBlock = 0x400e_1850 as * const _ ; # [doc = r"Return the pointer to the register block"] # [inline (always)] pub const fn ptr () -> * const wdt :: RegisterBlock { Self :: PTR } } impl Deref for WDT { type Target = wdt :: RegisterBlock ; # [inline (always)] fn deref (& self) -> & Self :: Target { unsafe { & * Self :: PTR } } } impl core :: fmt :: Debug for WDT { fn fmt (& self , f : & mut core :: fmt :: Formatter) -> core :: fmt :: Result { f . debug_struct ("WDT") . finish () } } # [doc = "Watchdog Timer"] pub mod wdt ; # [doc = "Extensible DMA Controller"] pub struct XDMAC { _marker : PhantomData < * const () > } unsafe impl Send for XDMAC { } impl XDMAC { # [doc = r"Pointer to the register block"] pub const PTR : * const xdmac :: RegisterBlock = 0x4007_8000 as * const _ ; # [doc = r"Return the pointer to the register block"] # [inline (always)] pub const fn ptr () -> * const xdmac :: RegisterBlock { Self :: PTR } } impl Deref for XDMAC { type Target = xdmac :: RegisterBlock ; # [inline (always)] fn deref (& self) -> & Self :: Target { unsafe { & * Self :: PTR } } } impl core :: fmt :: Debug for XDMAC { fn fmt (& self , f : & mut core :: fmt :: Formatter) -> core :: fmt :: Result { f . debug_struct ("XDMAC") . finish () } } # [doc = "Extensible DMA Controller"] pub mod xdmac ; # [doc = "LOCKBIT"] pub struct LOCKBIT { _marker : PhantomData < * const () > } unsafe impl Send for LOCKBIT { } impl LOCKBIT { # [doc = r"Pointer to the register block"] pub const PTR : * const lockbit :: RegisterBlock = 0 as * const _ ; # [doc = r"Return the pointer to the register block"] # [inline (always)] pub const fn ptr () -> * const lockbit :: RegisterBlock { Self :: PTR } } impl Deref for LOCKBIT { type Target = lockbit :: RegisterBlock ; # [inline (always)] fn deref (& self) -> & Self :: Target { unsafe { & * Self :: PTR } } } impl core :: fmt :: Debug for LOCKBIT { fn fmt (& self , f : & mut core :: fmt :: Formatter) -> core :: fmt :: Result { f . debug_struct ("LOCKBIT") . finish () } } # [doc = "LOCKBIT"] pub mod lockbit ; # [doc = "System control not in SCB"] pub struct SCN_SCB { _marker : PhantomData < * const () > } unsafe impl Send for SCN_SCB { } impl SCN_SCB { # [doc = r"Pointer to the register block"] pub const PTR : * const scn_scb :: RegisterBlock = 0xe000_e000 as * const _ ; # [doc = r"Return the pointer to the register block"] # [inline (always)] pub const fn ptr () -> * const scn_scb :: RegisterBlock { Self :: PTR } } impl Deref for SCN_SCB { type Target = scn_scb :: RegisterBlock ; # [inline (always)] fn deref (& self) -> & Self :: Target { unsafe { & * Self :: PTR } } } impl core :: fmt :: Debug for SCN_SCB { fn fmt (& self , f : & mut core :: fmt :: Formatter) -> core :: fmt :: Result { f . debug_struct ("SCN_SCB") . finish () } } # [doc = "System control not in SCB"] pub mod scn_scb ; # [doc = "System timer"] pub struct SYS_TICK { _marker : PhantomData < * const () > } unsafe impl Send for SYS_TICK { } impl SYS_TICK { # [doc = r"Pointer to the register block"] pub const PTR : * const sys_tick :: RegisterBlock = 0xe000_e010 as * const _ ; # [doc = r"Return the pointer to the register block"] # [inline (always)] pub const fn ptr () -> * const sys_tick :: RegisterBlock { Self :: PTR } } impl Deref for SYS_TICK { type Target = sys_tick :: RegisterBlock ; # [inline (always)] fn deref (& self) -> & Self :: Target { unsafe { & * Self :: PTR } } } impl core :: fmt :: Debug for SYS_TICK { fn fmt (& self , f : & mut core :: fmt :: Formatter) -> core :: fmt :: Result { f . debug_struct ("SYS_TICK") . finish () } } # [doc = "System timer"] pub mod sys_tick ; # [doc = "Core Debug Register"] pub struct CORE_DEBUG { _marker : PhantomData < * const () > } unsafe impl Send for CORE_DEBUG { } impl CORE_DEBUG { # [doc = r"Pointer to the register block"] pub const PTR : * const core_debug :: RegisterBlock = 0xe000_edf0 as * const _ ; # [doc = r"Return the pointer to the register block"] # [inline (always)] pub const fn ptr () -> * const core_debug :: RegisterBlock { Self :: PTR } } impl Deref for CORE_DEBUG { type Target = core_debug :: RegisterBlock ; # [inline (always)] fn deref (& self) -> & Self :: Target { unsafe { & * Self :: PTR } } } impl core :: fmt :: Debug for CORE_DEBUG { fn fmt (& self , f : & mut core :: fmt :: Formatter) -> core :: fmt :: Result { f . debug_struct ("CORE_DEBUG") . finish () } } # [doc = "Core Debug Register"] pub mod core_debug ; # [doc = "Embedded Trace Macrocell"] pub struct ETM { _marker : PhantomData < * const () > } unsafe impl Send for ETM { } impl ETM { # [doc = r"Pointer to the register block"] pub const PTR : * const etm :: RegisterBlock = 0xe004_1000 as * const _ ; # [doc = r"Return the pointer to the register block"] # [inline (always)] pub const fn ptr () -> * const etm :: RegisterBlock { Self :: PTR } } impl Deref for ETM { type Target = etm :: RegisterBlock ; # [inline (always)] fn deref (& self) -> & Self :: Target { unsafe { & * Self :: PTR } } } impl core :: fmt :: Debug for ETM { fn fmt (& self , f : & mut core :: fmt :: Formatter) -> core :: fmt :: Result { f . debug_struct ("ETM") . finish () } } # [doc = "Embedded Trace Macrocell"] pub mod etm ; # [no_mangle] static mut DEVICE_PERIPHERALS : bool = false ; # [doc = r" All the peripherals."] # [allow (non_snake_case)] pub struct Peripherals { # [doc = "ACC"] pub ACC : ACC , # [doc = "AES"] pub AES : AES , # [doc = "AFEC0"] pub AFEC0 : AFEC0 , # [doc = "AFEC1"] pub AFEC1 : AFEC1 , # [doc = "CHIPID"] pub CHIPID : CHIPID , # [doc = "DACC"] pub DACC : DACC , # [doc = "EFC"] pub EFC : EFC , # [doc = "GMAC"] pub GMAC : GMAC , # [doc = "GPBR"] pub GPBR : GPBR , # [doc = "HSMCI"] pub HSMCI : HSMCI , # [doc = "I2SC0"] pub I2SC0 : I2SC0 , # [doc = "ICM"] pub ICM : ICM , # [doc = "ISI"] pub ISI : ISI , # [doc = "MATRIX"] pub MATRIX : MATRIX , # [doc = "MCAN0"] pub MCAN0 : MCAN0 , # [doc = "MCAN1"] pub MCAN1 : MCAN1 , # [doc = "PIOA"] pub PIOA : PIOA , # [doc = "PIOB"] pub PIOB : PIOB , # [doc = "PIOD"] pub PIOD : PIOD , # [doc = "PMC"] pub PMC : PMC , # [doc = "PWM0"] pub PWM0 : PWM0 , # [doc = "PWM1"] pub PWM1 : PWM1 , # [doc = "QSPI"] pub QSPI : QSPI , # [doc = "RSTC"] pub RSTC : RSTC , # [doc = "RSWDT"] pub RSWDT : RSWDT , # [doc = "RTC"] pub RTC : RTC , # [doc = "RTT"] pub RTT : RTT , # [doc = "SPI0"] pub SPI0 : SPI0 , # [doc = "SSC"] pub SSC : SSC , # [doc = "SUPC"] pub SUPC : SUPC , # [doc = "TC0"] pub TC0 : TC0 , # [doc = "TC1"] pub TC1 : TC1 , # [doc = "TC2"] pub TC2 : TC2 , # [doc = "TC3"] pub TC3 : TC3 , # [doc = "TRNG"] pub TRNG : TRNG , # [doc = "TWIHS0"] pub TWIHS0 : TWIHS0 , # [doc = "TWIHS1"] pub TWIHS1 : TWIHS1 , # [doc = "TWIHS2"] pub TWIHS2 : TWIHS2 , # [doc = "UART0"] pub UART0 : UART0 , # [doc = "UART1"] pub UART1 : UART1 , # [doc = "UART2"] pub UART2 : UART2 , # [doc = "UART3"] pub UART3 : UART3 , # [doc = "UART4"] pub UART4 : UART4 , # [doc = "USART0"] pub USART0 : USART0 , # [doc = "USART1"] pub USART1 : USART1 , # [doc = "USART2"] pub USART2 : USART2 , # [doc = "USBHS"] pub USBHS : USBHS , # [doc = "UTMI"] pub UTMI : UTMI , # [doc = "WDT"] pub WDT : WDT , # [doc = "XDMAC"] pub XDMAC : XDMAC , # [doc = "LOCKBIT"] pub LOCKBIT : LOCKBIT , # [doc = "SCN_SCB"] pub SCN_SCB : SCN_SCB , # [doc = "SYS_TICK"] pub SYS_TICK : SYS_TICK , # [doc = "CORE_DEBUG"] pub CORE_DEBUG : CORE_DEBUG , # [doc = "ETM"] pub ETM : ETM , } impl Peripherals { # [doc = r" Returns all the peripherals *once*."] # [cfg (feature = "critical-section")] # [inline] pub fn take () -> Option < Self > { critical_section :: with (| _ | { if unsafe { DEVICE_PERIPHERALS } { return None } Some (unsafe { Peripherals :: steal () }) }) } # [doc = r" Unchecked version of `Peripherals::take`."] # [doc = r""] # [doc = r" # Safety"] # [doc = r""] # [doc = r" Each of the returned peripherals must be used at most once."] # [inline] pub unsafe fn steal () -> Self { DEVICE_PERIPHERALS = true ; Peripherals { ACC : ACC { _marker : PhantomData } , AES : AES { _marker : PhantomData } , AFEC0 : AFEC0 { _marker : PhantomData } , AFEC1 : AFEC1 { _marker : PhantomData } , CHIPID : CHIPID { _marker : PhantomData } , DACC : DACC { _marker : PhantomData } , EFC : EFC { _marker : PhantomData } , GMAC : GMAC { _marker : PhantomData } , GPBR : GPBR { _marker : PhantomData } , HSMCI : HSMCI { _marker : PhantomData } , I2SC0 : I2SC0 { _marker : PhantomData } , ICM : ICM { _marker : PhantomData } , ISI : ISI { _marker : PhantomData } , MATRIX : MATRIX { _marker : PhantomData } , MCAN0 : MCAN0 { _marker : PhantomData } , MCAN1 : MCAN1 { _marker : PhantomData } , PIOA : PIOA { _marker : PhantomData } , PIOB : PIOB { _marker : PhantomData } , PIOD : PIOD { _marker : PhantomData } , PMC : PMC { _marker : PhantomData } , PWM0 : PWM0 { _marker : PhantomData } , PWM1 : PWM1 { _marker : PhantomData } , QSPI : QSPI { _marker : PhantomData } , RSTC : RSTC { _marker : PhantomData } , RSWDT : RSWDT { _marker : PhantomData } , RTC : RTC { _marker : PhantomData } , RTT : RTT { _marker : PhantomData } , SPI0 : SPI0 { _marker : PhantomData } , SSC : SSC { _marker : PhantomData } , SUPC : SUPC { _marker : PhantomData } , TC0 : TC0 { _marker : PhantomData } , TC1 : TC1 { _marker : PhantomData } , TC2 : TC2 { _marker : PhantomData } , TC3 : TC3 { _marker : PhantomData } , TRNG : TRNG { _marker : PhantomData } , TWIHS0 : TWIHS0 { _marker : PhantomData } , TWIHS1 : TWIHS1 { _marker : PhantomData } , TWIHS2 : TWIHS2 { _marker : PhantomData } , UART0 : UART0 { _marker : PhantomData } , UART1 : UART1 { _marker : PhantomData } , UART2 : UART2 { _marker : PhantomData } , UART3 : UART3 { _marker : PhantomData } , UART4 : UART4 { _marker : PhantomData } , USART0 : USART0 { _marker : PhantomData } , USART1 : USART1 { _marker : PhantomData } , USART2 : USART2 { _marker : PhantomData } , USBHS : USBHS { _marker : PhantomData } , UTMI : UTMI { _marker : PhantomData } , WDT : WDT { _marker : PhantomData } , XDMAC : XDMAC { _marker : PhantomData } , LOCKBIT : LOCKBIT { _marker : PhantomData } , SCN_SCB : SCN_SCB { _marker : PhantomData } , SYS_TICK : SYS_TICK { _marker : PhantomData } , CORE_DEBUG : CORE_DEBUG { _marker : PhantomData } , ETM : ETM { _marker : PhantomData } , } } }